{"version":3,"file":"bundles/3c33f185e5c2d3d2132d/9372.js","mappings":"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GA,uBACA,kBAKA,OAJA,iFACA,gCAKA,CAEA,KACA,aACA,eAEA,CACA,CA/I1CC,CAA6BxI,IAE5DmI,EAASt0C,MRxCoCulB,EQwF4B,SACA,EACA,GAEA,mBACA,kBACA,OAGA,MACA,EACA,iDAEA,EACA,gFACA,SACA,KACA,UACA,iHAEA,KAGA,qBACA,OAIA,IACA,gBACA,EAmOA,YACA,qBACA,CArOA,eAEA,6CACA,aACA,UACA,aACA,CAEA,gBACA,OAGA,SACA,wBACA,WAGA,IACA,gCAGA,KACA,cACA,YACA,iBAEA,CACA,CAxGpCqvB,CAAyBzI,EAAQmI,EAASt0C,MRvCvF,QADa,MACIulB,IACjB,QAFa,MAESspB,IQwCdyF,EAAShD,KPlEZ,SAAsC/rB,IAE3C,QADa,MACIA,IACjB,QAFa,MAES0qB,EACxB,CO+DQ4E,CA8I2E,YACA,mBACA,kBACA,OAGA,yCAEA,WAGA,cACA,OAGA,6CAEA,GACA,SACA,MACA,eAGA,GACA,UACA,QACA,iBACA,gBAGA,GACA,eACA,OACA,YACA,YAGA,8CAEA,MACA,CACA,CAvL9CC,CAAyB3I,IAEpDmI,EAASC,OLjEZ,SACLhvB,EACAktB,GAEA,MAAM5wC,EAAO,SACb,QAAWA,EAAM0jB,IACjB,QAAgB1jB,GAAM,IAAM0wC,OAAgB12B,EAAW42B,IACzD,CK2DQsC,CAyL2E,YACA,mBACA,kBACA,OAGA,yCAGA,QAIA,kEAUA,GAJA,mBACA,gBAGA,SACA,oBACA,GACA,aACA,aACA,iBACA,gBAGA,GACA,iBACA,OACA,cACA,aAGA,8CAEA,MACA,MACA,mBACA,MACA,YACA,uBAGA,8BACA,+BAGA,SACA,aACA,WACA,iBACA,gBAGA,GACA,iBACA,OACA,YACA,wBAGA,8CAEA,MACA,CACA,CACA,CAjQ5CC,CAA2B7I,IAExDmI,EAASlJ,UACX,OAmQ2E,YACA,mBACA,kBACA,OAGA,aACA,OACA,8BACA,oBACA,aAGA,UACA,KAKA,2CACA,cAEA,2CACA,cAGA,GACA,sBACA,MACA,OACA,OAGA,CACA,CArS1C6J,CAA6B9I,I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AAK,IAAK,IAAK,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,GAAI,MAAO,GAAI,GAAI,MAAO,GAAI,GAAI,IAAK,IAAK,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,GAAI,MAAO,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,GAAI,IAAK,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,GAAI,GAAI,MAAO,IAAK,GAAI,GAAI,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,KAAM,GAAI,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,GAAI,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,KAAM,GAAI,GAAI,GAAI,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,GAAI,MAAO,KAAM,GAAI,GAAI,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,MAAO,KAAM,IAAK,GAAI,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,GAAI,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,KAAM,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,IAAK,IAAK,KAAM,GAAI,GAAI,GAAI,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,MAAO,KAAM,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,GAAI,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,IAAK,GAAI,GAAI,IAAK,IAAK,MAAO,KAAM,GAAI,IAAK,GAAI,MAAO,KAAM,KAAM,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,KAAM,IAAK,GAAI,IAAK,IAAK,IAAK,MAAO,KAAM,IAAK,IAAK,GAAI,IAAK,IAAK,GAAI,MAAO,MAAO,GAAI,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,MAAO,KAAM,GAAI,GAAI,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,GAAI,IAAK,KAAM,GAAI,GAAI,GAAI,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,GAAI,IAAK,IAAK,GAAI,GAAI,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,IAAK,IAAK,GAAI,MAAO,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,GAAI,GAAI,MAAO,KAAM,KAAM,IAAK,EAAG,EAAG,EAAG,IAAK,IAAK,EAAG,KAAM,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,GAAI,GAAI,GAAI,IAAK,IAAK,IAAK,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,IAAK,KAAM,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,KAAM,IAAK,EAAG,EAAG,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,KAAM,KAAM,IAAK,IAAK,IAAK,GAAI,GAAI,GAAI,KAAM,KAAM,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,GAAI,KAAM,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,GAAI,KAAM,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,GAAI,KAAM,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,KAAM,KAAM,EAAG,EAAG,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,GAAI,IAAK,GAAI,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,KAAM,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,GAAI,GAAI,KAAM,KAAM,KAAM,MAAO,KAAM,GAAI,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,EAAG,KAAM,EAAG,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,GAAI,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,IAAK,GAAI,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,GAAI,KAAM,KAAM,MAAO,KAAM,GAAI,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,IAAK,KAAM,EAAG,KAAM,IAAK,IAAK,GAAI,IAAK,GAAI,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,GAAI,KAAM,KAAM,MAAO,KAAM,GAAI,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,GAAI,KAAM,KAAM,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,KAAM,KAAM,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,KAAM,GAAI,GAAI,GAAI,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,GAAI,GAAI,MAAO,IAAK,GAAI,MAAO,IAAK,GAAI,MAAO,IAAK,GAAI,IAAK,IAAK,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,IAAK,IAAK,KAAM,KAAM,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,MAAO,IAAK,GAAI,MAAO,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,GAAI,IAAK,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,KAAM,KAAM,GAAI,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,KAAM,KAAM,EAAG,EAAG,KAAM,IAAK,GAAI,IAAK,IAAK,GAAI,IAAK,IAAK,GAAI,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,IAAK,GAAI,IAAK,IAAK,GAAI,IAAK,IAAK,GAAI,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,KAAM,KAAM,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,GAAI,IAAK,KAAM,KAAM,IAAK,IAAK,GAAI,GAAI,KAAM,KAAM,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,KAAM,KAAM,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,MAAO,GAAI,GAAI,MAAO,IAAK,IAAK,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,GAAI,GAAI,MAAO,KAAM,KAAM,GAAI,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,KAAM,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,EAAG,EAAG,KAAM,IAAK,GAAI,IAAK,IAAK,GAAI,IAAK,IAAK,GAAI,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,IAAK,GAAI,IAAK,IAAK,GAAI,IAAK,IAAK,GAAI,IAAK,IAAK,GAAI,MAAO,KAAM,KAAM,KAAM,EAAG,KAAM,EAAG,EAAG,KAAM,IAAK,GAAI,MAAO,MAAO,MAAO,GAAI,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,GAAI,MAAO,KAAM,KAAM,GAAI,GAAI,GAAI,GAAI,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,GAAI,IAAK,GAAI,MAAO,KAAM,MAAO,GAAI,GAAI,MAAO,GAAI,IAAK,IAAK,GAAI,IAAK,GAAI,IAAK,KAAM,KAAM,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,GAAI,MAAO,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,MAAO,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,GAAI,IAAK,IAAK,IAAK,KAAM,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,IAAK,IAAK,GAAI,IAAK,IAAK,GAAI,GAAI,KAAM,KAAM,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,IAAK,GAAI,IAAK,IAAK,GAAI,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,GAAI,MAAO,MAAO,MAAO,GAAI,MAAO,KAAM,KAAM,GAAI,GAAI,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,GAAI,GAAI,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,KAAM,KAAM,IAAK,IAAK,GAAI,MAAO,IAAK,GAAI,MAAO,GAAI,IAAK,IAAK,GAAI,GAAI,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,IAAK,IAAK,GAAI,IAAK,GAAI,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,KAAM,EAAG,KAAM,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,GAAI,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,KAAM,KAAM,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,IAAK,GAAI,MAAO,KAAM,KAAM,GAAI,GAAI,GAAI,GAAI,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,GAAI,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,IAAK,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,IAAK,GAAI,MAAO,IAAK,GAAI,MAAO,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,GAAI,IAAK,KAAM,KAAM,KAAM,MAAO,KAAM,IAAK,GAAI,IAAK,KAAM,KAAM,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,GAAI,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,KAAM,EAAG,KAAM,IAAK,GAAI,IAAK,KAAM,KAAM,MAAO,KAAM,IAAK,IAAK,IAAK,KAAM,KAAM,IAAK,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,GAAI,GAAI,KAAM,KAAM,IAAK,IAAK,IAAK,GAAI,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,MAAO,GAAI,GAAI,MAAO,IAAK,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,KAAM,EAAG,KAAM,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,KAAM,GAAI,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,KAAM,IAAK,IAAK,IAAK,KAAM,KAAM,IAAK,GAAI,GAAI,MAAO,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,KAAM,EAAG,KAAM,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,GAAI,MAAO,KAAM,KAAM,GAAI,GAAI,GAAI,GAAI,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,GAAI,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,MAAO,GAAI,IAAK,GAAI,MAAO,MAAO,MAAO,KAAM,GAAI,GAAI,GAAI,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,GAAI,IAAK,GAAI,MAAO,KAAM,MAAO,GAAI,GAAI,MAAO,GAAI,KAAM,GAAI,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,GAAI,IAAK,GAAI,GAAI,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,IAAK,KAAM,KAAM,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,KAAM,KAAM,IAAK,KAAM,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,IAAK,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,IAAK,IAAK,IAAK,KAAM,KAAM,IAAK,IAAK,IAAK,GAAI,IAAK,GAAI,GAAI,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,GAAI,GAAI,KAAM,KAAM,KAAM,MAAO,KAAM,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,KAAM,EAAG,KAAM,GAAI,IAAK,IAAK,GAAI,IAAK,GAAI,GAAI,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,KAAM,EAAG,KAAM,IAAK,IAAK,GAAI,IAAK,GAAI,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,GAAI,KAAM,KAAM,MAAO,KAAM,GAAI,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,GAAI,KAAM,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,KAAM,KAAM,IAAK,IAAK,GAAI,GAAI,GAAI,KAAM,KAAM,KAAM,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,GAAI,GAAI,KAAM,KAAM,KAAM,MAAO,KAAM,GAAI,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,GAAI,GAAI,KAAM,KAAM,KAAM,IAAK,IAAK,IAAK,GAAI,IAAK,GAAI,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,IAAK,GAAI,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,GAAI,KAAM,KAAM,MAAO,KAAM,GAAI,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,GAAI,KAAM,KAAM,MAAO,KAAM,GAAI,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,KAAM,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,IAAK,IAAK,GAAI,IAAK,GAAI,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,IAAK,GAAI,IAAK,IAAK,GAAI,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,GAAI,IAAK,KAAM,KAAM,MAAO,KAAM,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,IAAK,KAAM,GAAI,GAAI,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,GAAI,KAAM,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,KAAM,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,GAAI,KAAM,KAAM,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,IAAK,KAAM,KAAM,KAAM,IAAK,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,GAAI,MAAO,KAAM,KAAM,GAAI,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,KAAM,KAAM,IAAK,IAAK,IAAK,GAAI,IAAK,GAAI,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,MAAO,MAAO,GAAI,IAAK,GAAI,MAAO,KAAM,GAAI,MAAO,IAAK,KAAM,GAAI,GAAI,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,GAAI,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,IAAK,IAAK,KAAM,KAAM,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,GAAI,GAAI,KAAM,KAAM,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,GAAI,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,IAAK,KAAM,KAAM,IAAK,GAAI,IAAK,GAAI,GAAI,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,GAAI,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,GAAI,IAAK,GAAI,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,GAAI,KAAM,KAAM,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,IAAK,IAAK,GAAI,MAAO,GAAI,IAAK,GAAI,MAAO,MAAO,MAAO,KAAM,GAAI,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,IAAK,IAAK,GAAI,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,GAAI,GAAI,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,KAAM,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,MAAO,MAAO,IAAK,IAAK,IAAK,KAAM,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,GAAI,IAAK,GAAI,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,IAAK,GAAI,GAAI,KAAM,KAAM,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,KAAM,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,MAAO,KAAM,IAAK,IAAK,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,IAAK,GAAI,IAAK,IAAK,GAAI,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,IAAK,GAAI,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,GAAI,GAAI,KAAM,KAAM,KAAM,MAAO,KAAM,GAAI,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,KAAM,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,MAAO,KAAM,IAAK,IAAK,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,IAAK,IAAK,GAAI,IAAK,IAAK,GAAI,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,GAAI,KAAM,KAAM,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,GAAI,GAAI,KAAM,KAAM,KAAM,MAAO,KAAM,IAAK,IAAK,GAAI,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,IAAK,IAAK,GAAI,IAAK,IAAK,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,KAAM,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,GAAI,GAAI,KAAM,KAAM,KAAM,MAAO,KAAM,GAAI,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,KAAM,KAAM,IAAK,GAAI,IAAK,IAAK,GAAI,IAAK,IAAK,GAAI,IAAK,KAAM,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,GAAI,KAAM,KAAM,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,GAAI,KAAM,KAAM,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,GAAI,IAAK,KAAM,KAAM,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,GAAI,KAAM,KAAM,MAAO,KAAM,KAAM,IAAK,IAAK,GAAI,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,IAAK,IAAK,IAAK,KAAM,GAAI,GAAI,GAAI,GAAI,KAAM,KAAM,KAAM,KAAM,MAAO,KAAM,IAAK,IAAK,GAAI,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,IAAK,IAAK,GAAI,IAAK,IAAK,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,GAAI,KAAM,KAAM,MAAO,KAAM,KAAM,IAAK,IAAK,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,KAAM,GAAI,GAAI,GAAI,GAAI,KAAM,KAAM,KAAM,KAAM,MAAO,KAAM,IAAK,IAAK,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,GAAI,IAAK,GAAI,GAAI,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,GAAI,MAAO,IAAK,KAAM,GAAI,GAAI,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,GAAI,IAAK,IAAK,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,IAAK,GAAI,MAAO,IAAK,GAAI,MAAO,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,GAAI,GAAI,GAAI,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,GAAI,IAAK,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,IAAK,IAAK,KAAM,KAAM,KAAM,GAAI,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,GAAI,MAAO,IAAK,GAAI,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,GAAI,KAAM,KAAM,IAAK,IAAK,GAAI,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,KAAM,KAAM,IAAK,GAAI,MAAO,MAAO,MAAO,GAAI,IAAK,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,KAAM,KAAM,IAAK,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,GAAI,KAAM,KAAM,IAAK,GAAI,IAAK,KAAM,KAAM,IAAK,GAAI,MAAO,KAAM,GAAI,GAAI,IAAK,IAAK,IAAK,KAAM,KAAM,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,KAAM,GAAI,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,IAAK,IAAK,IAAK,GAAI,IAAK,GAAI,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,GAAI,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,IAAK,GAAI,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,KAAM,KAAM,GAAI,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,MAAO,MAAO,GAAI,IAAK,IAAK,IAAK,IAAK,KAAM,GAAI,GAAI,GAAI,GAAI,KAAM,KAAM,KAAM,KAAM,MAAO,KAAM,IAAK,IAAK,GAAI,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,IAAK,GAAI,IAAK,IAAK,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,KAAM,KAAM,IAAK,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,GAAI,KAAM,KAAM,MAAO,KAAM,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,KAAM,KAAM,IAAK,GAAI,MAAO,MAAO,MAAO,GAAI,MAAO,IAAK,KAAM,GAAI,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,GAAI,GAAI,MAAO,GAAI,GAAI,MAAO,GAAI,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,GAAI,MAAO,MAAO,MAAO,KAAM,GAAI,GAAI,GAAI,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,GAAI,IAAK,IAAK,GAAI,MAAO,MAAO,GAAI,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,IAAK,IAAK,KAAM,KAAM,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,IAAK,KAAM,KAAM,MAAO,KAAM,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,IAAK,KAAM,KAAM,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,KAAM,KAAM,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,GAAI,KAAM,KAAM,IAAK,IAAK,IAAK,KAAM,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,KAAM,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,IAAK,IAAK,IAAK,KAAM,KAAM,IAAK,IAAK,IAAK,GAAI,IAAK,GAAI,GAAI,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,GAAI,GAAI,KAAM,KAAM,KAAM,MAAO,KAAM,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,KAAM,EAAG,KAAM,GAAI,IAAK,IAAK,GAAI,IAAK,GAAI,GAAI,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,KAAM,EAAG,KAAM,IAAK,IAAK,GAAI,IAAK,GAAI,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,GAAI,KAAM,KAAM,MAAO,KAAM,GAAI,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,KAAM,KAAM,IAAK,IAAK,GAAI,GAAI,GAAI,KAAM,KAAM,KAAM,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,GAAI,GAAI,KAAM,KAAM,KAAM,MAAO,KAAM,GAAI,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,GAAI,GAAI,KAAM,KAAM,KAAM,IAAK,IAAK,IAAK,GAAI,IAAK,GAAI,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,IAAK,GAAI,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,GAAI,KAAM,KAAM,MAAO,KAAM,GAAI,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,GAAI,KAAM,KAAM,MAAO,KAAM,GAAI,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,KAAM,KAAM,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,KAAM,KAAM,IAAK,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,KAAM,GAAI,GAAI,GAAI,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,IAAK,GAAI,GAAI,KAAM,KAAM,GAAI,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,KAAM,GAAI,GAAI,GAAI,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,KAAM,GAAI,GAAI,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,KAAM,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,GAAI,MAAO,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,KAAM,GAAI,GAAI,GAAI,GAAI,KAAM,KAAM,KAAM,KAAM,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,GAAI,MAAO,IAAK,GAAI,IAAK,IAAK,GAAI,IAAK,IAAK,GAAI,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,MAAO,MAAO,KAAM,KAAM,EAAG,EAAG,KAAM,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,IAAK,KAAM,GAAI,GAAI,GAAI,GAAI,KAAM,KAAM,KAAM,KAAM,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,IAAK,KAAM,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,GAAI,KAAM,KAAM,MAAO,KAAM,IAAK,IAAK,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,GAAI,KAAM,KAAM,MAAO,KAAM,IAAK,IAAK,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,GAAI,MAAO,MAAO,MAAO,GAAI,IAAK,GAAI,MAAO,KAAM,KAAM,GAAI,GAAI,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,IAAK,GAAI,IAAK,KAAM,KAAM,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,GAAI,KAAM,KAAM,MAAO,KAAM,IAAK,IAAK,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,KAAM,KAAM,IAAK,IAAK,IAAK,IAAK,KAAM,GAAI,GAAI,GAAI,GAAI,KAAM,KAAM,KAAM,KAAM,MAAO,KAAM,IAAK,IAAK,GAAI,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,IAAK,GAAI,IAAK,IAAK,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,GAAI,IAAK,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,IAAK,KAAM,KAAM,KAAM,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,GAAI,KAAM,KAAM,MAAO,KAAM,IAAK,IAAK,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,KAAM,GAAI,GAAI,GAAI,GAAI,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,GAAI,GAAI,GAAI,MAAO,IAAK,GAAI,MAAO,IAAK,GAAI,GAAI,GAAI,GAAI,MAAO,KAAM,IAAK,GAAI,GAAI,KAAM,KAAM,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,KAAM,KAAM,GAAI,MAAO,EAAG,GAAI,MAAO,IAAK,IAAK,GAAI,IAAK,IAAK,KAAM,KAAM,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,KAAM,KAAM,IAAK,KAAM,EAAG,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,GAAI,MAAO,IAAK,IAAK,GAAI,IAAK,KAAM,KAAM,IAAK,GAAI,IAAK,GAAI,GAAI,IAAK,GAAI,MAAO,KAAM,KAAM,GAAI,IAAK,GAAI,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,KAAM,GAAI,GAAI,GAAI,GAAI,KAAM,KAAM,KAAM,KAAM,MAAO,KAAM,IAAK,IAAK,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,KAAM,KAAM,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,KAAM,KAAM,KAAM,KAAM,KAAM,EAAG,KAAM,KAAM,EAAG,EAAG,EAAG,EAAG,EAAG,KAAM,KAAM,KAAM,KAAM,EAAG,KAAM,KAAM,KAAM,KAAM,IAAK,GAAI,IAAK,KAAM,KAAM,IAAK,IAAK,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,GAAI,IAAK,KAAM,KAAM,MAAO,KAAM,GAAI,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,KAAM,EAAG,KAAM,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,IAAK,GAAI,MAAO,IAAK,GAAI,MAAO,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,GAAI,GAAI,GAAI,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,GAAI,IAAK,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,GAAI,GAAI,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,IAAK,IAAK,IAAK,GAAI,GAAI,KAAM,KAAM,IAAK,GAAI,IAAK,KAAM,KAAM,IAAK,GAAI,MAAO,GAAI,GAAI,GAAI,IAAK,IAAK,IAAK,KAAM,KAAM,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,GAAI,KAAM,KAAM,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,KAAM,KAAM,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,MAAO,KAAM,GAAI,GAAI,GAAI,GAAI,GAAI,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,GAAI,GAAI,KAAM,KAAM,KAAM,MAAO,KAAM,GAAI,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,GAAI,KAAM,KAAM,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,GAAI,KAAM,KAAM,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,IAAK,KAAM,KAAM,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,GAAI,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,KAAM,GAAI,GAAI,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,GAAI,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,IAAK,IAAK,GAAI,IAAK,KAAM,KAAM,MAAO,KAAM,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,KAAM,KAAM,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,IAAK,KAAM,KAAM,KAAM,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,KAAM,KAAM,MAAO,KAAM,GAAI,GAAI,IAAK,KAAM,GAAI,GAAI,GAAI,GAAI,KAAM,KAAM,KAAM,KAAM,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,GAAI,IAAK,GAAI,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,IAAK,IAAK,GAAI,IAAK,GAAI,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,MAAO,GAAI,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,GAAI,IAAK,IAAK,GAAI,MAAO,KAAM,KAAM,GAAI,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,KAAM,IAAK,IAAK,GAAI,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,MAAO,GAAI,IAAK,GAAI,MAAO,MAAO,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,IAAK,GAAI,MAAO,MAAO,MAAO,GAAI,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,MAAO,GAAI,IAAK,GAAI,MAAO,MAAO,MAAO,KAAM,GAAI,GAAI,GAAI,GAAI,GAAI,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,IAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,GAAI,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,IAAK,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,IAAK,GAAI,GAAI,MAAO,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,MAAO,GAAI,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,IAAK,KAAM,GAAI,GAAI,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,GAAI,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,IAAK,KAAM,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,KAAM,EAAG,KAAM,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,GAAI,GAAI,IAAK,GAAI,MAAO,KAAM,GAAI,GAAI,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,GAAI,MAAO,MAAO,MAAO,KAAM,KAAM,KAAM,KAAM,EAAG,KAAM,KAAM,KAAM,EAAG,EAAG,EAAG,EAAG,KAAM,KAAM,KAAM,KAAM,KAAM,EAAG,KAAM,KAAM,KAAM,KAAM,EAAG,KAAM,GAAI,IAAK,IAAK,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,KAAM,GAAI,GAAI,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,IAAK,KAAM,KAAM,MAAO,KAAM,GAAI,MAAO,MAAO,MAAO,IAAK,GAAI,IAAK,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,IAAK,IAAK,IAAK,KAAM,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,GAAI,MAAO,IAAK,IAAK,GAAI,IAAK,KAAM,KAAM,IAAK,GAAI,IAAK,KAAM,KAAM,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,MAAO,GAAI,GAAI,MAAO,GAAI,KAAM,KAAM,EAAG,EAAG,KAAM,KAAM,GAAI,GAAI,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,KAAM,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,MAAO,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,GAAI,MAAO,MAAO,KAAM,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,MAAO,KAAM,GAAI,MAAO,MAAO,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,GAAI,KAAM,KAAM,MAAO,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,GAAI,MAAO,MAAO,GAAI,MAAO,MAAO,GAAI,MAAO,MAAO,GAAI,MAAO,MAAO,GAAI,MAAO,MAAO,GAAI,MAAO,MAAO,GAAI,MAAO,MAAO,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,IAAK,KAAM,KAAM,MAAO,KAAM,GAAI,IAAK,GAAI,IAAK,KAAM,KAAM,MAAO,KAAM,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,KAAM,KAAM,IAAK,GAAI,MAAO,KAAM,GAAI,MAAO,IAAK,GAAI,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,KAAM,KAAM,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,MAAO,KAAM,GAAI,GAAI,GAAI,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,MAAO,KAAM,GAAI,MAAO,MAAO,GAAI,IAAK,IAAK,GAAI,MAAO,MAAO,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,KAAM,KAAM,MAAO,KAAM,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,IAAK,IAAK,KAAM,KAAM,KAAM,IAAK,GAAI,MAAO,MAAO,MAAO,GAAI,MAAO,GAAI,IAAK,IAAK,IAAK,GAAI,IAAK,KAAM,KAAM,MAAO,KAAM,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,IAAK,KAAM,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,MAAO,KAAM,GAAI,GAAI,GAAI,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,KAAM,KAAM,IAAK,KAAM,GAAI,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,IAAK,KAAM,KAAM,MAAO,KAAM,IAAK,GAAI,MAAO,KAAM,IAAK,KAAM,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,IAAK,KAAM,KAAM,MAAO,KAAM,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,IAAK,KAAM,KAAM,MAAO,KAAM,GAAI,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,KAAM,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,KAAM,GAAI,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,KAAM,GAAI,IAAK,IAAK,IAAK,GAAI,IAAK,KAAM,KAAM,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,IAAK,KAAM,KAAM,KAAM,GAAI,MAAO,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,KAAM,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,IAAK,GAAI,IAAK,IAAK,KAAM,KAAM,KAAM,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,KAAM,KAAM,EAAG,EAAG,KAAM,GAAI,IAAK,IAAK,GAAI,MAAO,MAAO,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,IAAK,KAAM,KAAM,KAAM,IAAK,GAAI,IAAK,KAAM,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,KAAM,GAAI,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,KAAM,IAAK,KAAM,EAAG,KAAM,IAAK,KAAM,EAAG,KAAM,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,GAAI,GAAI,MAAO,KAAM,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,KAAM,KAAM,IAAK,GAAI,IAAK,KAAM,KAAM,MAAO,GAAI,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,KAAM,IAAK,GAAI,MAAO,KAAM,KAAM,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,GAAI,IAAK,KAAM,KAAM,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,KAAM,GAAI,GAAI,GAAI,GAAI,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,GAAI,GAAI,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,KAAM,GAAI,GAAI,GAAI,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,KAAM,MAAO,KAAM,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,KAAM,GAAI,GAAI,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,KAAM,GAAI,GAAI,GAAI,GAAI,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,MAAO,KAAM,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,MAAO,KAAM,GAAI,GAAI,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,KAAM,GAAI,GAAI,GAAI,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,KAAM,MAAO,KAAM,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,KAAM,GAAI,GAAI,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,KAAM,GAAI,GAAI,GAAI,GAAI,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,MAAO,KAAM,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,KAAM,KAAM,IAAK,IAAK,GAAI,MAAO,IAAK,GAAI,GAAI,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,KAAM,GAAI,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,IAAK,KAAM,KAAM,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,GAAI,IAAK,KAAM,KAAM,KAAM,MAAO,GAAI,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,GAAI,MAAO,MAAO,IAAK,KAAM,KAAM,IAAK,IAAK,GAAI,IAAK,KAAM,KAAM,MAAO,KAAM,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,GAAI,IAAK,KAAM,KAAM,KAAM,MAAO,KAAM,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,KAAM,KAAM,MAAO,KAAM,GAAI,MAAO,KAAM,KAAM,KAAM,EAAG,KAAM,KAAM,KAAM,KAAM,EAAG,KAAM,KAAM,EAAG,EAAG,KAAM,EAAG,EAAG,KAAM,EAAG,EAAG,KAAM,KAAM,KAAM,KAAM,EAAG,KAAM,EAAG,KAAM,IAAK,GAAI,IAAK,IAAK,KAAM,KAAM,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,KAAM,GAAI,GAAI,GAAI,GAAI,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,KAAM,KAAM,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,GAAI,MAAO,KAAM,MAAO,IAAK,IAAK,IAAK,KAAM,KAAM,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,IAAK,KAAM,GAAI,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,IAAK,KAAM,EAAG,KAAM,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,KAAM,KAAM,MAAO,MAAO,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,IAAK,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,MAAO,IAAK,GAAI,IAAK,KAAM,KAAM,MAAO,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,GAAI,IAAK,IAAK,KAAM,KAAM,KAAM,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,IAAK,GAAI,IAAK,KAAM,KAAM,MAAO,MAAO,GAAI,IAAK,IAAK,GAAI,MAAO,MAAO,GAAI,MAAO,IAAK,IAAK,KAAM,GAAI,GAAI,GAAI,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,MAAO,KAAM,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,IAAK,KAAM,KAAM,KAAM,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,KAAM,KAAM,EAAG,EAAG,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,KAAM,GAAI,GAAI,GAAI,GAAI,IAAK,KAAM,KAAM,KAAM,KAAM,KAAM,GAAI,MAAO,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,GAAI,MAAO,KAAM,GAAI,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,GAAI,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,IAAK,GAAI,IAAK,KAAM,KAAM,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,KAAM,KAAM,KAAM,KAAM,EAAG,KAAM,IAAK,IAAK,IAAK,GAAI,IAAK,KAAM,KAAM,MAAO,GAAI,IAAK,GAAI,IAAK,KAAM,KAAM,MAAO,KAAM,GAAI,MAAO,KAAM,KAAM,KAAM,EAAG,EAAG,KAAM,GAAI,IAAK,GAAI,IAAK,KAAM,KAAM,MAAO,GAAI,GAAI,MAAO,GAAI,IAAK,GAAI,IAAK,IAAK,KAAM,KAAM,KAAM,MAAO,KAAM,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,KAAM,EAAG,KAAM,IAAK,GAAI,IAAK,KAAM,KAAM,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,GAAI,MAAO,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,MAAO,IAAK,GAAI,IAAK,KAAM,KAAM,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,KAAM,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,KAAM,KAAM,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,GAAI,IAAK,KAAM,KAAM,IAAK,GAAI,IAAK,KAAM,KAAM,MAAO,MAAO,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,KAAM,KAAM,MAAO,MAAO,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,GAAI,MAAO,MAAO,GAAI,MAAO,MAAO,KAAM,KAAM,EAAG,EAAG,KAAM,IAAK,GAAI,MAAO,KAAM,GAAI,GAAI,MAAO,KAAM,GAAI,IAAK,IAAK,IAAK,GAAI,IAAK,KAAM,KAAM,MAAO,KAAM,GAAI,MAAO,MAAO,KAAM,GAAI,GAAI,GAAI,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,MAAO,KAAM,IAAK,GAAI,GAAI,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,KAAM,KAAM,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,MAAO,GAAI,MAAO,KAAM,MAAO,KAAM,GAAI,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,IAAK,IAAK,IAAK,GAAI,IAAK,KAAM,KAAM,MAAO,KAAM,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,IAAK,KAAM,KAAM,EAAG,EAAG,KAAM,IAAK,IAAK,GAAI,GAAI,MAAO,KAAM,IAAK,GAAI,GAAI,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,KAAM,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,IAAK,GAAI,MAAO,KAAM,KAAM,GAAI,GAAI,GAAI,GAAI,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,GAAI,MAAO,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,IAAK,KAAM,KAAM,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,KAAM,KAAM,GAAI,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,GAAI,GAAI,GAAI,MAAO,IAAK,IAAK,GAAI,IAAK,KAAM,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,GAAI,IAAK,KAAM,KAAM,KAAM,MAAO,KAAM,IAAK,IAAK,IAAK,KAAM,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,KAAM,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,GAAI,MAAO,MAAO,MAAO,GAAI,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,KAAM,GAAI,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,KAAM,IAAK,IAAK,GAAI,IAAK,IAAK,KAAM,KAAM,KAAM,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,IAAK,KAAM,KAAM,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,GAAI,MAAO,IAAK,GAAI,IAAK,IAAK,GAAI,GAAI,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,IAAK,KAAM,KAAM,KAAM,MAAO,IAAK,IAAK,IAAK,MAAO,IAAK,GAAI,IAAK,KAAM,KAAM,MAAO,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,GAAI,MAAO,KAAM,GAAI,KAAM,KAAM,EAAG,EAAG,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,KAAM,IAAK,GAAI,IAAK,GAAI,MAAO,GAAI,IAAK,GAAI,MAAO,MAAO,MAAO,KAAM,GAAI,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,KAAM,MAAO,IAAK,IAAK,IAAK,GAAI,IAAK,KAAM,KAAM,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,IAAK,GAAI,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,IAAK,IAAK,KAAM,KAAM,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,KAAM,KAAM,IAAK,GAAI,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,KAAM,KAAM,EAAG,EAAG,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,IAAK,KAAM,KAAM,KAAM,IAAK,IAAK,IAAK,KAAM,KAAM,GAAI,MAAO,MAAO,MAAO,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,IAAK,KAAM,KAAM,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,KAAM,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,GAAI,MAAO,MAAO,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,KAAM,KAAM,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,IAAK,IAAK,GAAI,MAAO,MAAO,KAAM,GAAI,GAAI,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,IAAK,GAAI,IAAK,KAAM,KAAM,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,KAAM,KAAM,IAAK,IAAK,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,KAAM,GAAI,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,GAAI,GAAI,KAAM,KAAM,MAAO,KAAM,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,KAAM,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,MAAO,MAAO,MAAO,IAAK,GAAI,IAAK,IAAK,KAAM,KAAM,KAAM,MAAO,MAAO,GAAI,IAAK,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,IAAK,KAAM,KAAM,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,KAAM,GAAI,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,KAAM,KAAM,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,IAAK,KAAM,KAAM,KAAM,GAAI,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,KAAM,KAAM,KAAM,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,GAAI,KAAM,KAAM,IAAK,KAAM,KAAM,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,MAAO,KAAM,IAAK,IAAK,IAAK,KAAM,KAAM,GAAI,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,KAAM,KAAM,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,GAAI,IAAK,IAAK,KAAM,KAAM,KAAM,IAAK,IAAK,GAAI,IAAK,KAAM,KAAM,MAAO,KAAM,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,IAAK,IAAK,KAAM,KAAM,KAAM,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,GAAI,MAAO,KAAM,KAAM,GAAI,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,IAAK,IAAK,IAAK,KAAM,KAAM,IAAK,GAAI,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,KAAM,KAAM,EAAG,EAAG,KAAM,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,IAAK,KAAM,KAAM,KAAM,IAAK,IAAK,GAAI,MAAO,GAAI,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,GAAI,KAAM,KAAM,MAAO,KAAM,GAAI,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,GAAI,KAAM,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,IAAK,KAAM,KAAM,KAAM,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,KAAM,KAAM,GAAI,MAAO,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,IAAK,KAAM,KAAM,KAAM,IAAK,GAAI,MAAO,GAAI,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,KAAM,KAAM,GAAI,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,GAAI,MAAO,KAAM,KAAM,KAAM,EAAG,KAAM,EAAG,KAAM,KAAM,EAAG,EAAG,KAAM,KAAM,EAAG,KAAM,EAAG,KAAM,KAAM,KAAM,EAAG,KAAM,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,KAAM,KAAM,EAAG,EAAG,KAAM,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,GAAI,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,KAAM,KAAM,KAAM,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,KAAM,EAAG,KAAM,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,GAAI,IAAK,KAAM,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,KAAM,KAAM,MAAO,KAAM,GAAI,MAAO,MAAO,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,KAAM,KAAM,IAAK,GAAI,IAAK,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,EAAG,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,EAAG,KAAM,MAAO,IAAK,GAAI,MAAO,IAAK,GAAI,MAAO,KAAM,MAAO,IAAK,GAAI,MAAO,IAAK,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,KAAM,EAAG,KAAM,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,KAAM,KAAM,KAAM,EAAG,EAAG,KAAM,MAAO,IAAK,GAAI,MAAO,IAAK,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,GAAI,GAAI,MAAO,KAAM,IAAK,KAAM,EAAG,KAAM,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,GAAI,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,GAAI,MAAO,MAAO,MAAO,KAAM,GAAI,GAAI,GAAI,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,IAAK,GAAI,IAAK,KAAM,KAAM,MAAO,KAAM,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,IAAK,KAAM,KAAM,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,IAAK,GAAI,IAAK,KAAM,KAAM,MAAO,IAAK,GAAI,MAAO,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,IAAK,GAAI,GAAI,MAAO,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,IAAK,KAAM,GAAI,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,IAAK,KAAM,KAAM,KAAM,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,IAAK,GAAI,MAAO,MAAO,KAAM,GAAI,GAAI,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,MAAO,MAAO,GAAI,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,IAAK,KAAM,KAAM,MAAO,MAAO,IAAK,GAAI,IAAK,KAAM,KAAM,MAAO,MAAO,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,KAAM,KAAM,MAAO,KAAM,MAAO,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,GAAI,IAAK,KAAM,KAAM,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,GAAI,MAAO,KAAM,KAAM,GAAI,GAAI,GAAI,IAAK,KAAM,KAAM,KAAM,KAAM,MAAO,KAAM,GAAI,MAAO,MAAO,GAAI,MAAO,MAAO,GAAI,MAAO,MAAO,KAAM,GAAI,GAAI,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,IAAK,KAAM,KAAM,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,KAAM,KAAM,MAAO,MAAO,IAAK,GAAI,IAAK,KAAM,KAAM,MAAO,MAAO,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,MAAO,MAAO,GAAI,IAAK,IAAK,GAAI,MAAO,GAAI,IAAK,GAAI,IAAK,KAAM,KAAM,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,IAAK,IAAK,KAAM,KAAM,KAAM,MAAO,KAAM,GAAI,MAAO,MAAO,GAAI,MAAO,MAAO,MAAO,GAAI,GAAI,GAAI,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,MAAO,GAAI,IAAK,GAAI,IAAK,KAAM,KAAM,GAAI,MAAO,MAAO,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,GAAI,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,KAAM,GAAI,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,KAAM,IAAK,KAAM,EAAG,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,KAAM,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,MAAO,GAAI,GAAI,MAAO,KAAM,MAAO,KAAM,GAAI,GAAI,GAAI,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,KAAM,IAAK,IAAK,IAAK,IAAK,KAAM,KAAM,KAAM,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,KAAM,KAAM,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,GAAI,IAAK,MAAO,MAAO,MAAO,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,MAAO,GAAI,MAAO,KAAM,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,GAAI,MAAO,IAAK,IAAK,GAAI,IAAK,IAAK,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,GAAI,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,GAAI,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,KAAM,GAAI,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,MAAO,MAAO,GAAI,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,IAAK,MAAO,MAAO,MAAO,IAAK,GAAI,MAAO,MAAO,MAAO,GAAI,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,KAAM,MAAO,EAAG,MAAO,EAAG,MAAO,MAAO,MAAO,EAAG,MAAO,MAAO,EAAG,EAAG,MAAO,MAAO,MAAO,MAAO,MAAO,EAAG,MAAO,MAAO,MAAO,GAAI,IAAK,IAAK,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,KAAM,IAAK,GAAI,MAAO,IAAK,GAAI,MAAO,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,MAAO,MAAO,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,GAAI,MAAO,KAAM,GAAI,MAAO,MAAO,MAAO,IAAK,GAAI,IAAK,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,KAAM,GAAI,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,KAAM,IAAK,IAAK,IAAK,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,IAAK,IAAK,MAAO,MAAO,MAAO,IAAK,GAAI,IAAK,IAAK,MAAO,MAAO,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,IAAK,KAAM,GAAI,GAAI,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,KAAM,GAAI,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,KAAM,GAAI,GAAI,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,KAAM,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,GAAI,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,KAAM,GAAI,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,MAAO,GAAI,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,KAAM,GAAI,GAAI,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,MAAO,EAAG,MAAO,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,KAAM,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,MAAO,MAAO,IAAK,GAAI,GAAI,MAAO,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,MAAO,MAAO,GAAI,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,MAAO,EAAG,MAAO,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,GAAI,MAAO,KAAM,KAAM,GAAI,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,IAAK,IAAK,GAAI,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,GAAI,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,MAAO,MAAO,GAAI,IAAK,GAAI,MAAO,MAAO,MAAO,KAAM,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,IAAK,GAAI,IAAK,IAAK,MAAO,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,IAAK,GAAI,MAAO,MAAO,GAAI,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,GAAI,MAAO,MAAO,GAAI,IAAK,GAAI,MAAO,MAAO,KAAM,MAAO,EAAG,MAAO,EAAG,MAAO,EAAG,EAAG,EAAG,EAAG,EAAG,MAAO,MAAO,EAAG,MAAO,MAAO,MAAO,EAAG,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,GAAI,GAAI,MAAO,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,GAAI,MAAO,MAAO,IAAK,GAAI,MAAO,MAAO,GAAI,MAAO,MAAO,IAAK,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,KAAM,GAAI,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,KAAM,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,GAAI,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,MAAO,GAAI,MAAO,MAAO,MAAO,IAAK,GAAI,GAAI,IAAK,MAAO,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,MAAO,MAAO,GAAI,IAAK,IAAK,IAAK,MAAO,MAAO,GAAI,MAAO,IAAK,GAAI,MAAO,GAAI,IAAK,IAAK,IAAK,MAAO,MAAO,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,GAAI,MAAO,MAAO,GAAI,MAAO,MAAO,KAAM,GAAI,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,GAAI,MAAO,IAAK,GAAI,MAAO,KAAM,KAAM,GAAI,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,GAAI,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,MAAO,MAAO,IAAK,GAAI,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,MAAO,KAAM,KAAM,GAAI,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,KAAM,IAAK,KAAM,GAAI,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,GAAI,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,GAAI,MAAO,KAAM,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,IAAK,GAAI,MAAO,MAAO,KAAM,GAAI,GAAI,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,GAAI,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,MAAO,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,MAAO,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,MAAO,IAAK,GAAI,MAAO,MAAO,KAAM,GAAI,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,MAAO,MAAO,MAAO,IAAK,GAAI,GAAI,MAAO,MAAO,MAAO,KAAM,GAAI,MAAO,MAAO,IAAK,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,GAAI,MAAO,KAAM,KAAM,GAAI,GAAI,GAAI,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,GAAI,MAAO,MAAO,MAAO,KAAM,GAAI,IAAK,IAAK,GAAI,MAAO,KAAM,KAAM,GAAI,GAAI,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,MAAO,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,MAAO,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,KAAM,GAAI,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,MAAO,MAAO,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,IAAK,MAAO,MAAO,MAAO,IAAK,GAAI,MAAO,MAAO,GAAI,MAAO,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,GAAI,MAAO,GAAI,IAAK,GAAI,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,MAAO,MAAO,GAAI,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,GAAI,IAAK,GAAI,MAAO,MAAO,KAAM,GAAI,GAAI,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,GAAI,MAAO,MAAO,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,KAAM,GAAI,GAAI,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,MAAO,MAAO,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,KAAM,GAAI,MAAO,MAAO,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,MAAO,MAAO,GAAI,MAAO,GAAI,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,MAAO,GAAI,GAAI,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,GAAI,IAAK,GAAI,IAAK,MAAO,MAAO,GAAI,MAAO,MAAO,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,MAAO,MAAO,GAAI,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,KAAM,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,IAAK,IAAK,GAAI,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,MAAO,GAAI,GAAI,MAAO,KAAM,MAAO,KAAM,GAAI,GAAI,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,GAAI,IAAK,IAAK,GAAI,MAAO,KAAM,KAAM,GAAI,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,IAAK,IAAK,KAAM,GAAI,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,MAAO,MAAO,IAAK,IAAK,GAAI,GAAI,MAAO,MAAO,GAAI,MAAO,KAAM,GAAI,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,IAAK,MAAO,MAAO,MAAO,IAAK,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,KAAM,GAAI,GAAI,GAAI,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,GAAI,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,GAAI,IAAK,MAAO,MAAO,MAAO,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,GAAI,MAAO,MAAO,IAAK,MAAO,MAAO,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,MAAO,MAAO,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,MAAO,MAAO,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,GAAI,MAAO,KAAM,KAAM,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,MAAO,MAAO,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,KAAM,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,KAAM,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,MAAO,MAAO,GAAI,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,IAAK,GAAI,MAAO,KAAM,KAAM,GAAI,GAAI,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,IAAK,GAAI,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,KAAM,KAAM,GAAI,GAAI,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,KAAM,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,GAAI,MAAO,MAAO,MAAO,KAAM,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,MAAO,EAAG,MAAO,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,IAAK,GAAI,MAAO,KAAM,IAAK,KAAM,GAAI,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,IAAK,MAAO,EAAG,MAAO,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,GAAI,MAAO,KAAM,GAAI,IAAK,IAAK,GAAI,MAAO,KAAM,KAAM,GAAI,GAAI,GAAI,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,MAAO,MAAO,GAAI,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,MAAO,MAAO,KAAM,GAAI,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,KAAM,IAAK,GAAI,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,GAAI,GAAI,IAAK,MAAO,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,KAAM,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,GAAI,IAAK,GAAI,MAAO,KAAM,KAAM,GAAI,GAAI,GAAI,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,KAAM,KAAM,GAAI,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,KAAM,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,MAAO,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,MAAO,MAAO,IAAK,GAAI,MAAO,MAAO,MAAO,MAAO,IAAK,GAAI,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,IAAK,IAAK,KAAM,GAAI,GAAI,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,MAAO,MAAO,MAAO,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,IAAK,MAAO,MAAO,MAAO,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,IAAK,MAAO,MAAO,MAAO,IAAK,KAAM,GAAI,GAAI,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,GAAI,IAAK,MAAO,MAAO,MAAO,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,GAAI,MAAO,MAAO,MAAO,MAAO,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,IAAK,GAAI,MAAO,MAAO,IAAK,KAAM,GAAI,GAAI,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,GAAI,IAAK,MAAO,MAAO,MAAO,MAAO,KAAM,GAAI,MAAO,MAAO,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,GAAI,MAAO,KAAM,KAAM,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,KAAM,GAAI,GAAI,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,MAAO,MAAO,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,KAAM,MAAO,EAAG,EAAG,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,GAAI,GAAI,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,KAAM,GAAI,MAAO,MAAO,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,KAAM,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,IAAK,GAAI,MAAO,MAAO,IAAK,KAAM,GAAI,GAAI,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,KAAM,GAAI,MAAO,MAAO,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,KAAM,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,GAAI,MAAO,MAAO,IAAK,KAAM,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,IAAK,IAAK,GAAI,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,GAAI,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,KAAM,KAAM,GAAI,GAAI,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,GAAI,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,MAAO,KAAM,KAAM,GAAI,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,MAAO,MAAO,GAAI,MAAO,KAAM,KAAM,GAAI,MAAO,GAAI,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,IAAK,MAAO,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,GAAI,MAAO,KAAM,KAAM,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,GAAI,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,KAAM,IAAK,GAAI,IAAK,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,KAAM,IAAK,GAAI,GAAI,IAAK,MAAO,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,GAAI,MAAO,MAAO,KAAM,MAAO,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,MAAO,EAAG,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,EAAG,EAAG,MAAO,MAAO,EAAG,MAAO,MAAO,EAAG,MAAO,MAAO,MAAO,MAAO,MAAO,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,MAAO,MAAO,IAAK,IAAK,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,MAAO,MAAO,IAAK,IAAK,GAAI,GAAI,MAAO,MAAO,MAAO,KAAM,MAAO,IAAK,GAAI,MAAO,IAAK,GAAI,MAAO,KAAM,KAAM,GAAI,GAAI,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,GAAI,GAAI,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,GAAI,MAAO,MAAO,MAAO,KAAM,MAAO,EAAG,EAAG,MAAO,EAAG,MAAO,IAAK,GAAI,MAAO,IAAK,GAAI,IAAK,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,MAAO,MAAO,GAAI,IAAK,GAAI,MAAO,MAAO,GAAI,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,KAAM,GAAI,GAAI,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,MAAO,MAAO,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,IAAK,MAAO,MAAO,MAAO,GAAI,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,GAAI,MAAO,IAAK,IAAK,GAAI,IAAK,IAAK,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,GAAI,IAAK,IAAK,MAAO,MAAO,MAAO,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,KAAM,GAAI,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,KAAM,GAAI,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,IAAK,GAAI,MAAO,KAAM,MAAO,IAAK,GAAI,MAAO,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,IAAK,MAAO,MAAO,MAAO,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,MAAO,MAAO,IAAK,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,GAAI,MAAO,MAAO,MAAO,KAAM,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,GAAI,GAAI,IAAK,GAAI,MAAO,KAAM,KAAM,MAAO,EAAG,MAAO,EAAG,MAAO,MAAO,EAAG,MAAO,MAAO,EAAG,EAAG,MAAO,MAAO,EAAG,MAAO,EAAG,EAAG,MAAO,MAAO,EAAG,MAAO,IAAK,KAAM,GAAI,GAAI,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,KAAM,MAAO,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,KAAM,MAAO,EAAG,EAAG,MAAO,IAAK,GAAI,MAAO,MAAO,GAAI,MAAO,MAAO,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,KAAM,IAAK,KAAM,GAAI,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,GAAI,IAAK,IAAK,GAAI,MAAO,GAAI,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,MAAO,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,KAAM,IAAK,KAAM,GAAI,GAAI,GAAI,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,GAAI,GAAI,IAAK,IAAK,GAAI,MAAO,MAAO,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,MAAO,MAAO,GAAI,MAAO,KAAM,GAAI,MAAO,MAAO,GAAI,MAAO,MAAO,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,KAAM,GAAI,GAAI,GAAI,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,KAAM,GAAI,MAAO,MAAO,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,GAAI,MAAO,MAAO,MAAO,MAAO,KAAM,GAAI,GAAI,GAAI,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,IAAK,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,GAAI,GAAI,IAAK,MAAO,MAAO,MAAO,GAAI,MAAO,MAAO,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,IAAK,MAAO,MAAO,MAAO,IAAK,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,MAAO,MAAO,IAAK,GAAI,MAAO,MAAO,MAAO,GAAI,MAAO,IAAK,IAAK,GAAI,IAAK,IAAK,GAAI,MAAO,KAAM,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,GAAI,IAAK,IAAK,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,MAAO,GAAI,GAAI,MAAO,GAAI,KAAM,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,KAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,IAAK,GAAI,IAAK,IAAK,MAAO,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,IAAK,GAAI,MAAO,MAAO,GAAI,IAAK,IAAK,GAAI,MAAO,MAAO,GAAI,IAAK,GAAI,MAAO,MAAO,KAAM,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,MAAO,MAAO,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,KAAM,GAAI,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,GAAI,MAAO,MAAO,GAAI,MAAO,MAAO,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,KAAM,GAAI,GAAI,GAAI,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,KAAM,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,IAAK,GAAI,MAAO,MAAO,GAAI,MAAO,MAAO,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,GAAI,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,GAAI,IAAK,MAAO,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,MAAO,MAAO,GAAI,IAAK,IAAK,IAAK,MAAO,MAAO,GAAI,MAAO,IAAK,GAAI,MAAO,GAAI,IAAK,IAAK,IAAK,MAAO,MAAO,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,GAAI,MAAO,MAAO,GAAI,MAAO,MAAO,KAAM,GAAI,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,GAAI,MAAO,IAAK,GAAI,MAAO,KAAM,KAAM,GAAI,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,GAAI,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,GAAI,IAAK,MAAO,MAAO,MAAO,IAAK,KAAM,GAAI,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,KAAM,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,MAAO,MAAO,MAAO,IAAK,GAAI,IAAK,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,IAAK,IAAK,KAAM,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,GAAI,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,IAAK,MAAO,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,GAAI,MAAO,MAAO,MAAO,KAAM,GAAI,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,KAAM,GAAI,GAAI,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,MAAO,MAAO,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,IAAK,MAAO,MAAO,MAAO,IAAK,GAAI,MAAO,MAAO,GAAI,MAAO,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,MAAO,MAAO,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,GAAI,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,GAAI,IAAK,IAAK,GAAI,MAAO,KAAM,KAAM,GAAI,GAAI,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,MAAO,MAAO,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,MAAO,MAAO,GAAI,MAAO,GAAI,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,KAAM,GAAI,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,KAAM,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,IAAK,GAAI,MAAO,MAAO,GAAI,MAAO,KAAM,KAAM,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,EAAG,MAAO,MAAO,EAAG,EAAG,MAAO,MAAO,EAAG,MAAO,MAAO,MAAO,KAAO,MAAO,MAAO,MAAO,EAAG,MAAO,EAAG,EAAG,MAAO,GAAI,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,KAAM,GAAI,GAAI,GAAI,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,KAAM,GAAI,MAAO,MAAO,IAAK,MAAO,EAAG,MAAO,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,GAAI,MAAO,IAAK,IAAK,GAAI,GAAI,IAAK,MAAO,MAAO,MAAO,GAAI,MAAO,MAAO,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,GAAI,IAAK,MAAO,MAAO,MAAO,MAAO,KAAM,GAAI,MAAO,KAAM,GAAI,MAAO,MAAO,KAAM,GAAI,GAAI,GAAI,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,IAAK,GAAI,MAAO,KAAM,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,MAAO,GAAI,IAAK,GAAI,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,KAAM,GAAI,GAAI,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,MAAO,MAAO,GAAI,IAAK,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,IAAK,KAAM,MAAO,EAAG,EAAG,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,IAAK,GAAI,IAAK,GAAI,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,IAAK,GAAI,MAAO,IAAK,GAAI,MAAO,IAAK,KAAM,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,GAAI,GAAI,MAAO,MAAO,MAAO,MAAO,GAAI,MAAO,MAAO,IAAK,GAAI,GAAI,MAAO,MAAO,MAAO,MAAO,GAAI,MAAO,MAAO,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,GAAI,IAAK,IAAK,GAAI,MAAO,MAAO,GAAI,IAAK,IAAK,GAAI,MAAO,KAAM,KAAM,GAAI,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,MAAO,MAAO,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,MAAO,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,MAAO,GAAI,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,IAAK,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,GAAI,MAAO,MAAO,MAAO,GAAI,IAAK,GAAI,GAAI,MAAO,MAAO,MAAO,MAAO,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,MAAO,MAAO,GAAI,IAAK,IAAK,IAAK,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,IAAK,MAAO,MAAO,MAAO,IAAK,GAAI,IAAK,MAAO,MAAO,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,GAAI,MAAO,KAAM,MAAO,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,GAAI,MAAO,KAAM,MAAO,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,IAAK,GAAI,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,GAAI,IAAK,MAAO,MAAO,MAAO,MAAO,KAAM,IAAK,IAAK,MAAO,MAAO,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,GAAI,IAAK,IAAK,GAAI,MAAO,KAAM,KAAM,GAAI,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,MAAO,MAAO,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,MAAO,IAAK,KAAM,GAAI,GAAI,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,KAAM,GAAI,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,KAAM,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,MAAO,MAAO,GAAI,MAAO,MAAO,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,GAAI,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,IAAK,IAAK,GAAI,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,KAAM,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,GAAI,MAAO,MAAO,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,MAAO,MAAO,GAAI,MAAO,MAAO,GAAI,MAAO,MAAO,GAAI,KAAM,GAAI,GAAI,GAAI,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,IAAK,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,KAAM,KAAM,GAAI,GAAI,GAAI,GAAI,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,IAAK,GAAI,MAAO,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,MAAO,KAAM,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,MAAO,MAAO,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,IAAK,GAAI,MAAO,MAAO,GAAI,GAAI,MAAO,MAAO,GAAI,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,MAAO,MAAO,GAAI,MAAO,MAAO,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,IAAK,IAAK,GAAI,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,KAAM,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,GAAI,MAAO,MAAO,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,MAAO,MAAO,GAAI,MAAO,MAAO,GAAI,MAAO,MAAO,IAAK,GAAI,GAAI,IAAK,MAAO,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,KAAM,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,EAAG,MAAO,MAAO,EAAG,EAAG,EAAG,EAAG,EAAG,MAAO,MAAO,EAAG,MAAO,MAAO,EAAG,EAAG,EAAG,MAAO,KAAM,MAAO,EAAG,EAAG,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,IAAK,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,MAAO,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,IAAK,MAAO,EAAG,MAAO,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,GAAI,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,MAAO,MAAO,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,MAAO,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,MAAO,IAAK,GAAI,GAAI,IAAK,MAAO,MAAO,MAAO,MAAO,IAAK,IAAK,GAAI,GAAI,MAAO,MAAO,MAAO,KAAM,IAAK,GAAI,MAAO,MAAO,GAAI,MAAO,MAAO,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,GAAI,GAAI,MAAO,MAAO,KAAM,GAAI,GAAI,GAAI,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,GAAI,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,IAAK,MAAO,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,KAAM,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,KAAM,GAAI,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,IAAK,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,GAAI,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,IAAK,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,MAAO,MAAO,GAAI,MAAO,MAAO,MAAO,GAAI,MAAO,KAAM,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,KAAM,GAAI,GAAI,GAAI,GAAI,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,MAAO,MAAO,IAAK,IAAK,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,MAAO,EAAG,MAAO,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,IAAK,GAAI,MAAO,IAAK,GAAI,MAAO,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,GAAI,IAAK,MAAO,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,GAAI,GAAI,MAAO,IAAK,GAAI,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,GAAI,MAAO,MAAO,MAAO,IAAK,GAAI,IAAK,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,GAAI,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,MAAO,MAAO,KAAM,MAAO,EAAG,EAAG,MAAO,IAAK,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,MAAO,MAAO,GAAI,IAAK,GAAI,MAAO,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,MAAO,KAAM,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,IAAK,MAAO,MAAO,MAAO,KAAM,MAAO,EAAG,EAAG,MAAO,IAAK,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,KAAM,GAAI,GAAI,GAAI,GAAI,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,MAAO,GAAI,MAAO,MAAO,GAAI,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,IAAK,GAAI,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,IAAK,GAAI,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,MAAO,MAAO,IAAK,IAAK,GAAI,GAAI,MAAO,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,MAAO,GAAI,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,MAAO,GAAI,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,MAAO,MAAO,IAAK,IAAK,GAAI,GAAI,MAAO,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,IAAK,GAAI,GAAI,IAAK,MAAO,MAAO,MAAO,MAAO,KAAM,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,MAAO,MAAO,GAAI,IAAK,GAAI,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,GAAI,MAAO,KAAM,KAAM,GAAI,MAAO,KAAM,KAAM,IAAK,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,MAAO,MAAO,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,GAAI,IAAK,MAAO,MAAO,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,GAAI,MAAO,MAAO,MAAO,GAAI,MAAO,KAAM,MAAO,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,GAAI,MAAO,MAAO,MAAO,GAAI,MAAO,KAAM,MAAO,IAAK,IAAK,IAAK,GAAI,IAAK,GAAI,MAAO,MAAO,KAAM,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,IAAK,IAAK,GAAI,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,IAAK,GAAI,IAAK,MAAO,MAAO,GAAI,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,MAAO,GAAI,MAAO,KAAM,IAAK,GAAI,IAAK,MAAO,MAAO,MAAO,KAAM,GAAI,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,IAAK,GAAI,MAAO,MAAO,MAAO,KAAM,MAAO,MAAO,EAAG,MAAO,EAAG,MAAO,MAAO,EAAG,EAAG,MAAO,MAAO,MAAO,MAAO,EAAG,EAAG,MAAO,MAAO,EAAG,MAAO,MAAO,MAAO,IAAK,GAAI,IAAK,IAAK,MAAO,MAAO,MAAO,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,GAAI,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,GAAI,MAAO,IAAK,IAAK,GAAI,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,GAAI,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,MAAO,MAAO,GAAI,MAAO,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,GAAI,IAAK,MAAO,MAAO,IAAK,GAAI,MAAO,MAAO,MAAO,GAAI,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,IAAK,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,MAAO,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,KAAM,GAAI,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,GAAI,IAAK,IAAK,IAAK,MAAO,MAAO,IAAK,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,IAAK,MAAO,MAAO,IAAK,GAAI,GAAI,MAAO,IAAK,GAAI,MAAO,KAAM,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,MAAO,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,MAAO,MAAO,GAAI,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,GAAI,IAAK,MAAO,MAAO,IAAK,GAAI,MAAO,KAAM,IAAK,MAAO,IAAK,GAAI,MAAO,IAAK,KAAM,GAAI,GAAI,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,GAAI,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,GAAI,IAAK,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,IAAK,IAAK,IAAK,IAAK,MAAO,MAAO,IAAK,IAAK,IAAK,GAAI,MAAO,KAAM,GAAI,GAAI,MAAO,IAAK,IAAK,GAAI,MAAO,MAAO,MAAO,GAAI,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,IAAK,IAAK,GAAI,MAAO,KAAM,IAAK,IAAK,GAAI,MAAO,MAAO,MAAO,GAAI,IAAK,GAAI,MAAO,MAAO,MAAO,IAAK,IAAK,IAAK,MAAO,MAAO,GAAI,MAAO,KAAM,IAAK,GAAI,MAAO,gHCHnkhG9zI,OAAOC,eAAejB,EAAS,aAAc,CAAEoB,OAAO,IAGtDpB,EAAA,QAAkB,IAAI80I,YAAY,CAAC,KAAM,GAAI,IAAK,IAAK,IAAK,EAAG,GAAI,GAAI,GAAI,KAAM,GAAI,EAAG,EAAG,GAAI,IAAK,GAAI,MAAO,GAAI,IAAK,IAAK,GAAI,MAAO,GAAI,IAAK,GAAI,MAAO,GAAI,IAAK,GAAI,MAAO,GAAI,IAAK,IAAK,IAAK,GAAI,MAAO,4FCFhF90I,EAAQ,GAA6QA,EAAQ,GAAeA,EAAQ,GAAeA,EAAQ,QAAc,EACvd,IAGI+0I,EAQAC,EAOAC,EAlBAC,EAAW,EAAQ,iEACnBC,EAAW,EAAQ,kEAGvB,SAAWJ,GAEPA,EAAYA,EAAiB,IAAI,GAAK,MAEtCA,EAAYA,EAAkB,KAAI,GAAK,MAC1C,CALD,CAKGA,EAAc/0I,EAAQ,KAAgBA,EAAQ,GAAc,CAAC,IAGhE,SAAWg1I,GAEPA,EAAaA,EAAqB,OAAI,GAAK,SAE3CA,EAAaA,EAAqB,OAAI,GAAK,QAC9C,CALD,CAKGA,EAAeh1I,EAAQ,KAAiBA,EAAQ,GAAe,CAAC,IAEnE,SAAWi1I,GAKPA,EAAaA,EAAmB,KAAI,GAAK,OAMzCA,EAAaA,EAAoB,MAAI,GAAK,QAK1CA,EAAaA,EAAwB,UAAI,GAAK,WACjD,CAjBD,CAiBGA,EAAej1I,EAAQ,KAAiBA,EAAQ,GAAe,CAAC,IA4DnE,IAAIo1I,EAAW,EAAQ,iEASvB,IAAIC,EAAW,EAAQ,iEAGvBr0I,OAAOC,eAAejB,EAAS,KAA/B,CAAqDa,YAAY,EAAM2L,IAAK,WAAc,OAAO6oI,EAAS/D,gBAAkB,4x5BCzFxHgE,EAAe,mKACfC,EAAc,wCACdC,EAAe,gCAQfC,EAAc,6BAKdC,EAAe,WASfC,EAAc,6DA4JlB,SAASC,EAASj+F,GAChB,IAAIkF,EAAM/5C,OAAO60C,GAGjB,GAAI69F,EAAa1xI,KAAK+4C,GACpB,OAAOA,EAGT,GAAIA,EAAIl8C,OAAS,IAAM40I,EAAYzxI,KAAK+4C,GACtC,MAAM,IAAIv8C,UAAU,2BAGtB,MAAO,IAAMu8C,EAAIjxC,QAAQ8pI,EAAc,QAAU,GACnD,CAMA,SAASG,EAAa/5H,GACpB7T,KAAK6tI,WAAa90I,OAAOa,OAAO,MAChCoG,KAAK6T,KAAOA,CACd,CA1KA9b,EAAQ,EAmDR,SAAgBmyH,GACd,IAAKA,EACH,MAAM,IAAI7xH,UAAU,+BAItB,IAAI0rD,EAA2B,iBAAXmmE,EAiEtB,SAAyBt2G,GACvB,IAAImwC,EAEyB,mBAAlBnwC,EAAIk6H,UAEb/pF,EAASnwC,EAAIk6H,UAAU,gBACS,iBAAhBl6H,EAAIi2C,UAEpB9F,EAASnwC,EAAIi2C,SAAWj2C,EAAIi2C,QAAQ,iBAGtC,GAAsB,iBAAX9F,EACT,MAAM,IAAI1rD,UAAU,8CAGtB,OAAO0rD,CACT,CAhFMgqF,CAAe7jB,GACfA,EAEJ,GAAsB,iBAAXnmE,EACT,MAAM,IAAI1rD,UAAU,8CAGtB,IAAI8E,EAAQ4mD,EAAO9pD,QAAQ,KACvB4Z,GAAkB,IAAX1W,EACP4mD,EAAOh9C,MAAM,EAAG5J,GAAO+C,OACvB6jD,EAAO7jD,OAEX,IAAKwtI,EAAY7xI,KAAKgY,GACpB,MAAM,IAAIxb,UAAU,sBAGtB,IAAIub,EAAM,IAAIg6H,EAAY/5H,EAAKrM,eAG/B,IAAe,IAAXrK,EAAc,CAChB,IAAIlE,EACAkH,EACAhH,EAIJ,IAFAk0I,EAAax+H,UAAY1R,EAEjBgD,EAAQktI,EAAaz+H,KAAKm1C,IAAU,CAC1C,GAAI5jD,EAAMhD,QAAUA,EAClB,MAAM,IAAI9E,UAAU,4BAGtB8E,GAASgD,EAAM,GAAGzH,OAClBO,EAAMkH,EAAM,GAAGqH,cAGa,MAF5BrO,EAAQgH,EAAM,IAEJ86E,WAAW,KAKU,KAH7B9hF,EAAQA,EAAM4N,MAAM,GAAI,IAGd9M,QAAQ,QAChBd,EAAQA,EAAMwK,QAAQ6pI,EAAa,OAIvC55H,EAAIi6H,WAAW50I,GAAOE,CACxB,CAEA,GAAIgE,IAAU4mD,EAAOrrD,OACnB,MAAM,IAAIL,UAAU,2BAExB,CAEA,OAAOub,CACT,gECpKA,IAAIo6H,EAAU,EAAQ,kCAClB1kH,EAAU,yCACV2kH,EAAU,wCACVC,EAAU,sDACVz1G,EAAU,EAAQ,mCAClB01G,EAAU,EAAQ,kCAElBC,EAAW,EAAQ,0CAEnBC,EAAmB,cAEvB,SAASvlE,EAASp5B,GAChB,MAAsB,iBAARA,GAA4D,oBAAxC32C,OAAOG,UAAU8H,SAASvH,KAAKi2C,EACnE,CAcA,SAAS4+F,EAASr1I,GAChB,OAAO6vE,EAAS7vE,IAAmB,MAAXA,EAAI,EAC9B,CAMA,SAASs1I,EAASC,EAAc7nI,GAC9B,OAAOA,EAAK2X,QAAO,SAASzY,EAAQ5M,GAClC,OAhBU,QAFSy2C,EAkBD7pC,IAb2B,oBAAxC9M,OAAOG,UAAU8H,SAASvH,KAAKi2C,IAOxC,SAAoB97B,EAAK3a,GACvB,OAAOF,OAAOG,UAAUM,eAAeC,KAAKma,EAAK3a,EACnD,CAIiCw1I,CAAW5oI,EAAQ5M,GACvC4M,EAAO5M,GAEP,KArBb,IAAuBy2C,CAuBrB,GAAG8+F,EACL,CAEA,SAASE,IACPj2G,EAAOk2G,aAAaj1I,MAAMsG,MAE1BA,KAAK4uI,UAAY,CACfC,OAAQ,KACRC,aAAa,EACbC,gBAAiB,GACjBx1F,MAAO,KACPi1F,aAAc,CAAC,EACfQ,eAAgB,CAAC,EACjBC,eAAgB,CAAC,EACjBznE,UAAW,IACX0nE,iBAAiB,EACjBC,eAAgB,SAASl2I,GAAO,OAAOA,CAAK,EAC5Cm2I,qBAAsB,SAASn2I,GAAO,MAAO,wBAA0BA,CAAK,GAG9E+G,KAAKqvI,qBAAqB,KAAM,EAAQ,6CACxCrvI,KAAKsvI,gBAAgB,EACvB,CAEAZ,EAAYx1I,UAAYu/B,EAAOk2G,aAAaz1I,UAC5Cw1I,EAAYx1I,UAAUW,YAAc4+B,EAAOk2G,aAE3CD,EAAYx1I,UAAUq2I,UAAY,WAChC,OAAOvvI,KAAK4uI,UAAUC,MACxB,EAEAH,EAAYx1I,UAAUs2I,UAAY,SAASr2I,GACzC,IAAI+kI,EAAWl+H,KAAK4uI,UAAUC,OAO9B,OALI3Q,GAAY/kI,IACd6G,KAAK4uI,UAAUC,OAAS11I,EACxB6G,KAAKq3B,KAAK,eAAgBl+B,EAAO+kI,IAG5BA,CACT,EAEAwQ,EAAYx1I,UAAUu2I,kBAAoB,WACxC,OAAOzvI,KAAK4uI,UAAUG,eACxB,EAEAL,EAAYx1I,UAAUw2I,kBAAoB,SAASv2I,GACjD,IAAI+kI,EAAWl+H,KAAK4uI,UAAUG,gBAE9B,OADA/uI,KAAK4uI,UAAUG,gBAAkB,GAAG5wH,OAAOhlB,GAAS,IAC7C+kI,CACT,EAEAwQ,EAAYx1I,UAAUy2I,oBAAsB,WAC1C,OAAO3vI,KAAK4uI,UAAUgB,kBAAoB72I,OAAO4N,KAAK3G,KAAK4uI,UAAUJ,aACvE,EAEAE,EAAYx1I,UAAU22I,oBAAsB,SAAS12I,GACnD,IAAI+kI,EAAWl+H,KAAK2vI,sBAEpB,OADA3vI,KAAK4uI,UAAUgB,iBAAmBz2I,EAC3B+kI,CACT,EAEAwQ,EAAYx1I,UAAU42I,aAAe,WACnC,OAAO9vI,KAAK4uI,UAAUpnE,SACxB,EAEAknE,EAAYx1I,UAAU62I,aAAe,SAAS52I,GAC5C,IAAI+kI,EAAWl+H,KAAK4uI,UAAUpnE,UAE9B,OADAxnE,KAAK4uI,UAAUpnE,UAAYruE,EACpB+kI,CACT,EAEAwQ,EAAYx1I,UAAU82I,eAAiB,SAAS72I,GAC9C,IAAI+kI,EAAWl+H,KAAK4uI,UAAUE,YAE9B,OADA9uI,KAAK4uI,UAAUE,YAAc31I,EACtB+kI,CACT,EAEAwQ,EAAYx1I,UAAU+2I,eAAiB,WACrC,OAAOjwI,KAAK4uI,UAAUE,WACxB,EAEAJ,EAAYx1I,UAAUg3I,kBAAoB,SAAS/2I,GACjD,IAAI+kI,EAAWl+H,KAAK4uI,UAAUO,eAE9B,OADAnvI,KAAK4uI,UAAUO,eAAiBh2I,EACzB+kI,CACT,EAEAwQ,EAAYx1I,UAAUi3I,kBAAoB,WACxC,OAAOnwI,KAAK4uI,UAAUO,cACxB,EAEAT,EAAYx1I,UAAUk3I,yBAA2B,SAASj3I,GACxD,IAAI+kI,EAAWl+H,KAAK4uI,UAAUQ,qBAE9B,OADApvI,KAAK4uI,UAAUQ,qBAAuBj2I,EAC/B+kI,CACT,EAEAwQ,EAAYx1I,UAAUm3I,yBAA2B,WAC/C,OAAOrwI,KAAK4uI,UAAUQ,oBACxB,EAEAV,EAAYx1I,UAAUm2I,qBAAuB,SAASR,EAAQpwH,GAC5D,IAAI+vH,EAAe,CAAC,EAGpB,OAFAA,EAAaK,GAAUpwH,EACvBuvH,GAAO,EAAMhuI,KAAK4uI,UAAUJ,aAAcA,GACnCA,CACT,EAEAE,EAAYx1I,UAAUo3I,uBAAyB,SAAS7xH,GACtD,OAAOuvH,GAAO,EAAMhuI,KAAK4uI,UAAUI,eAAgBvwH,EACrD,EAEAiwH,EAAYx1I,UAAUq3I,eACtB7B,EAAYx1I,UAAUs3I,wBAA0B,SAASj8G,GACvDv0B,KAAKywI,YAAY,eAAgBl8G,EACnC,EAEAm6G,EAAYx1I,UAAUw3I,gBACtBhC,EAAYx1I,UAAUy3I,2BAA6B,SAASp8G,GAC1Dv0B,KAAK4wI,eAAe,eAAgBr8G,EACtC,EAEAm6G,EAAYx1I,UAAU23I,sBACtBnC,EAAYx1I,UAAU43I,+BAAiC,SAASv8G,GAC9Dv0B,KAAKywI,YAAY,sBAAuBl8G,EAC1C,EAEAm6G,EAAYx1I,UAAU63I,uBACtBrC,EAAYx1I,UAAU83I,kCAAoC,SAASz8G,GACjEv0B,KAAK4wI,eAAe,sBAAuBr8G,EAC7C,EAEAm6G,EAAYx1I,UAAU6gF,QACtB20D,EAAYx1I,UAAU+3I,iBAAmB,SAAS18G,GAChDv0B,KAAKywI,YAAY,QAASl8G,EAC5B,EAEAm6G,EAAYx1I,UAAUg4I,SACtBxC,EAAYx1I,UAAUi4I,oBAAsB,SAAS58G,GACnDv0B,KAAK4wI,eAAe,QAASr8G,EAC/B,EAEAm6G,EAAYx1I,UAAUk+G,UAAY,SAASn+G,EAAKgG,GAC9C,IAAKqqB,EAAQrwB,KAAS6vE,EAAS7vE,KAASA,EAAIP,OAC1C,MAAM,IAAIiJ,MAAM,yBAGd2sI,EAASr1I,KACXA,EAAMA,EAAIoxH,OAAO,IAGnBpxH,EAAM+G,KAAK4uI,UAAUO,eAAel2I,EAAKgG,GAIzC,IAAI4vI,GAFJ5vI,EAAU+uI,GAAO,EAAM,CAAC,EAAG/uI,IAEN4vI,QAAU7uI,KAAK4uI,UAAUC,cACvC5vI,EAAQ4vI,OAEf,IAAIt1F,EAAQt6C,EAAQs6C,OAASv5C,KAAK4uI,UAAUr1F,aACrCt6C,EAAQs6C,MAEf,IAAIiuB,EAAYvoE,EAAQuoE,WAAaxnE,KAAK4uI,UAAUpnE,iBAC7CvoE,EAAQuoE,UAEf,IAAIunE,EAAkB,GAAG5wH,OAAOlf,EAAQmyI,gBAAkBpxI,KAAK4uI,UAAUG,wBAClE9vI,EAAQmyI,eAEf,IAAIzqI,EAAO3G,KAAKqxI,eAAexC,EAAQt1F,EAAOtgD,EAAKuuE,GAE/C0hB,EAAQqlD,EAASvuI,KAAK4uI,UAAUJ,aAAc7nI,GAUlD,GARc,OAAVuiF,IACFlpF,KAAKq3B,KAAK,sBAAuBw3G,EAAQ51I,EAAKgG,EAAQqyI,SAAU/3F,GAE5Dt6C,EAAQqyI,WACVpoD,EAAQlpF,KAAKuxI,UAAU1C,EAAQt1F,EAAOtgD,EAAKgG,EAAQqyI,SAAUryI,KAInD,OAAViqF,GAAkB6lD,EAAgBr2I,OAAS,IAA0C,IAArCq2I,EAAgB90I,QAAQ40I,GAC1E,IAAK,IAAI90I,EAAI,EAAGy3I,EAAKzC,EAAgBr2I,OAAQqB,EAAIy3I,EAAIz3I,IAAK,CACxD,IAAIq3I,EAAiBrC,EAAgBh1I,GACjC03I,EAAezxI,KAAKqxI,eAAeD,EAAgB73F,EAAOtgD,EAAKuuE,GAGnE,GAFA0hB,EAAQqlD,EAASvuI,KAAK4uI,UAAUJ,aAAciD,GAEnC,CACT5C,EAASuC,EACT,KACF,CACF,CAaF,OAVc,OAAVloD,IACFA,EAAQlpF,KAAK4uI,UAAUQ,qBAAqBzoI,EAAK1J,KAAKuqE,KAGxD0hB,EAAQlpF,KAAK0xI,WAAW7C,EAAQ3lD,EAAOjqF,EAAQi2B,QAEZ,IAA/Bl1B,KAAK4uI,UAAUE,cAAiD,IAAxB7vI,EAAQ6vI,cAClD5lD,EAAQlpF,KAAK2xI,aAAazoD,EAAOjqF,IAG5BiqF,CACT,EAEAwlD,EAAYx1I,UAAU04I,SAAW,SAASxmE,EAAQnsE,GAChD,IAAKgvI,EAAO7iE,GACV,MAAM,IAAIzpE,MAAM,2CAKlB,IAAIktI,GAFJ5vI,EAAU+uI,GAAO,EAAM,CAAC,EAAG/uI,IAEL4vI,QAAW7uI,KAAK4uI,UAAUC,OAC5Ct1F,EAAUt6C,EAAQs6C,OAAW80F,EAC7Bx6H,EAAU5U,EAAQ4U,MAAW,WAC7B9S,EAAU9B,EAAQ8B,QAAW,UAKjC,OAHA9B,EAAU,CAAE4vI,OAAQA,EAAQt1F,MAAOA,EAAOu1F,aAAa,GACvD/tI,EAAUf,KAAKo3G,UAAU,CAAC,UAAWvjG,EAAM9S,GAASitI,GAAO,EAAM,CAAC,EAAG/uI,IAE9DmvI,EAAShjE,EAAQrqE,EAAQf,KAAKo3G,UAAU,QAASn4G,GAC1D,EAEAyvI,EAAYx1I,UAAUw4I,WAAa,SAAS7C,EAAQ3lD,EAAOh0D,GACzD,GAAqB,iBAAVg0D,GAAgC,OAAVA,GAAmC,iBAAVh0D,EACxD,OAAOg0D,EAGT,IAAI2oD,EAAgB7xI,KAAKo3G,UAAU,YAAa,CAAEy3B,OAAQA,EAAQt1F,MAAO80F,IAEzE,MAAsD,sBAAlDt1I,OAAOG,UAAU8H,SAASvH,KAAKo4I,GAC1BA,EAGFA,EAAc3oD,EAAOh0D,EAC9B,EAEAw5G,EAAYx1I,UAAU44I,WAAa,SAASjD,EAAQt6G,EAAUkB,GAC5D,IAAIyoG,EAAWl+H,KAAK4uI,UAAUC,OAC9B7uI,KAAK4uI,UAAUC,OAASA,EACxB,IAAIhpI,EAAS0uB,EAAS96B,KAAKg8B,GAE3B,OADAz1B,KAAK4uI,UAAUC,OAAS3Q,EACjBr4H,CACT,EAEA6oI,EAAYx1I,UAAU0iE,UAAY,SAASriB,EAAOhlB,EAAUkB,GAC1D,IAAIyoG,EAAWl+H,KAAK4uI,UAAUr1F,MAC9Bv5C,KAAK4uI,UAAUr1F,MAAQA,EACvB,IAAI1zC,EAAS0uB,EAAS96B,KAAKg8B,GAE3B,OADAz1B,KAAK4uI,UAAUr1F,MAAQ2kF,EAChBr4H,CACT,EAEA6oI,EAAYx1I,UAAU64I,cAAgB,SAASvqE,EAAWjzC,EAAUkB,GAClE,IAAIyoG,EAAWl+H,KAAK+vI,aAAavoE,GAC7B3hE,EAAS0uB,EAAS96B,KAAKg8B,GAE3B,OADAz1B,KAAK+vI,aAAa7R,GACXr4H,CACT,EAEA6oI,EAAYx1I,UAAUm4I,eAAiB,SAASxC,EAAQt1F,EAAOtgD,EAAKuuE,GAClE,IAAI7gE,EAAO,GAMX,OAFAA,GADAA,GADAA,EAAOA,EAAKwX,OAAOne,KAAKgyI,cAAcnD,EAAQrnE,KAClCrpD,OAAOne,KAAKgyI,cAAcz4F,EAAOiuB,KACjCrpD,OAAOne,KAAKgyI,cAAc/4I,EAAKuuE,GAG7C,EAEAknE,EAAYx1I,UAAU84I,cAAgB,SAAS/4I,EAAKuuE,GA6BlD,OA5BAxnE,KAAK4uI,UAAUK,eAAeznE,GAAaxnE,KAAK4uI,UAAUK,eAAeznE,IAAc,CAAC,EAExFxnE,KAAK4uI,UAAUK,eAAeznE,GAAWvuE,GAAO+G,KAAK4uI,UAAUK,eAAeznE,GAAWvuE,IAAS,SAASA,GACzG,GAAIqwB,EAAQrwB,GAAM,CAChB,IAAIg5I,EAAqBh5I,EAAI0H,IAAI,SAASwD,GAAK,OAAOnE,KAAKgyI,cAAc7tI,EAAGqjE,EAAY,EAAEluE,KAAK0G,OAE/F,MAAO,GAAGme,OAAOzkB,MAAM,GAAIu4I,EAC7B,CACE,GAAI,MAAOh5I,EACT,MAAO,GAKT,IAFA,IAAI0N,EAAO1N,EAAI+D,MAAMwqE,GAEZztE,EAAI4M,EAAKjO,OAAS,EAAGqB,GAAK,EAAGA,IACpB,KAAZ4M,EAAK5M,KACP4M,EAAKyxD,OAAOr+D,EAAG,IAEwB,IAAnCiG,KAAK4uI,UAAUM,iBAA4Bn1I,GAAK4M,EAAKjO,SACvDiO,EAAKA,EAAKjO,OAAS,IAAM,GAAK8uE,IAKpC,OAAO7gE,CAEX,EAAErN,KAAK0G,KAxB0F,CAwBnF/G,GAEP+G,KAAK4uI,UAAUK,eAAeznE,GAAWvuE,EAClD,EAEAy1I,EAAYx1I,UAAUy4I,aAAe,SAASzoD,EAAOpjF,GACnD,GAAqB,iBAAVojF,EACT,OAAOA,EAGT,IACE,OAAOglD,EAAQhlD,EAAO8kD,EAAO,CAAC,EAAGhuI,KAAK4uI,UAAUI,eAAgBlpI,GAClE,CAAE,MAAOqrB,GACP,KAAInxB,KAAKkyI,cAAc,SAAW,GAGhC,MAAM/gH,EAER,OAJEnxB,KAAKq3B,KAAK,QAASlG,EAAK+3D,EAAOpjF,GAI1B,IACT,CACF,EAEA4oI,EAAYx1I,UAAUi5I,SAAW,SAAStD,EAAQt1F,EAAO6xB,EAAQ8wD,EAASj9H,GAGxE,IAAwB,KAFxBA,EAAUA,GAAW,CAAC,GAEVo5D,QACV,OAAO6jE,EAGT,IAAIr2H,EAlWc6pC,EAoWlB,GAAI4+F,EAASpS,GACXr2H,EAAS7F,KAAKo3G,UAAU8kB,EAAS8R,EAAO,CAAC,EAAG/uI,EAAS,CAAE4vI,OAAQA,EAAQt1F,MAAOA,UACzE,GArWe,mBADJ7J,EAsWIwsF,IArWsD,sBAAxCnjI,OAAOG,UAAU8H,SAASvH,KAAKi2C,GAqWnC,CAC9B,IAAI0iG,EAEAnzI,EAAQmsE,QACVgnE,EAAanzI,EAAQmsE,cACdnsE,EAAQmsE,QAEfgnE,EAAahnE,EAGfvlE,EAAS7F,KAAKmyI,SAAStD,EAAQt1F,EAAO6xB,EAAQ8wD,EAAQkW,EAAYnzI,GACpE,MACE4G,EAASq2H,EAGX,MAAO,wBAAwBrgI,KAAKgK,GAAU,KAAOA,CACvD,EAEA6oI,EAAYx1I,UAAUq4I,UAAY,SAAS1C,EAAQt1F,EAAO6xB,EAAQ8wD,EAASj9H,GAGzE,GAFAA,EAAUkvI,EAAOlvI,EAAS,YAEtBqqB,EAAQ4yG,GAAU,CACpB,IAAK,IAAIniI,EAAI,EAAGy3I,EAAKtV,EAAQxjI,OAAQqB,EAAIy3I,EAAIz3I,IAAK,CAChD,IAAI8L,EAAS7F,KAAKmyI,SAAStD,EAAQt1F,EAAO6xB,EAAQ8wD,EAAQniI,GAAIkF,GAE9D,GAAI4G,EACF,OAAOA,CAEX,CAEA,OAAO,IACT,CACE,OAAO7F,KAAKmyI,SAAStD,EAAQt1F,EAAO6xB,EAAQ8wD,EAASj9H,EAEzD,EAEA,IAAIozI,EAAW,IAAI3D,EAEnB,SAASt3B,IACP,OAAOi7B,EAASj7B,UAAU19G,MAAM24I,EAAU94I,UAC5C,CAEAy0I,EAAO52B,EAAWi7B,EAAU,CAC1BC,SAAU5D,EACV6D,WAAY7D,IAGd52I,EAAOC,QAAUq/G,qEClajBt/G,EAAOC,QAAU,CACfy6I,YAAa,CACXh+E,MAAO,EAAQ,mCACfi+E,UAAW,EAAQ,oCAEnBC,QAAS,CACP/9B,KAAM,CACJ,QAAY,eACZg+B,KAAY,gBACZC,MAAY,SAGdnwF,KAAM,CACJ,QAAY,QACZkwF,KAAY,cACZC,MAAY,SAGdC,SAAU,CACR,QAAY,qBACZF,KAAY,4BACZC,MAAY,mFCvBpB,IAAIE,EAAY,EAAQ,sCAgExB,SAASC,EAAI36I,EAAG+d,EAASzd,GACA,iBAAZyd,IACTzd,EAASyd,EACTA,EAAU,KAGI,OAAZA,IACFA,EAAU,KAGZzd,EAASA,GAAU,EAEnB,IAAI8S,EAAI3Q,OAAOzC,GAEf,GAAI+d,EACF,KAAO3K,EAAE9S,OAASA,GAChB8S,EAAI2K,EAAU3K,EAIlB,OAAOA,CACT,CAEA,SAASwnI,EAAQr+B,GACf,IAAIs+B,EAAOt+B,EAAKu+B,WAQhB,OANa,IAATD,EACFA,EAAO,GACEA,EAAO,KAChBA,GAAQ,IAGHA,CACT,CAgBA,SAASE,EAAWx+B,EAAMy+B,GACxBA,EAAeA,GAAgB,SAE/B,IAAIC,EAAO1+B,EAAK2+B,SAEI,UAAhBF,IACW,IAATC,EACFA,EAAO,EAEPA,KAIJ,IACEE,EAAiB,IAAItkF,KAAK0lD,EAAK6+B,cAAe,EAAG,GAEjDC,IADQ9+B,EAAO4+B,GAAkB,MACf,EAAIF,GAAQ,EAEhC,OAAOz+H,KAAKE,MAAM2+H,EACpB,CAEA37I,EAAOC,QApIP,SAASq2I,EAASz5B,EAAM5zG,EAAQyzD,GAC9B,IAAIhP,EAAYmvD,EAAKn+B,UAIrB,OAFAhiB,EAAQA,GAASs+E,EAEV/xI,EAAO4C,QAAQ,eAAe,SAASiE,EAAG9D,GAC/C,IAAIqS,EAAU,KAEd,GAAgB,GAAZrS,EAAEpL,OAAa,CACjB,OAAQoL,EAAE,IACR,IAAK,IAAKqS,EAAU,GAAK,MACzB,IAAK,IAAKA,EAAU,IAAK,MACzB,IAAK,IAAKA,EAAU,IAAK,MACzB,QAAS,OAAOvO,EAGlB9D,EAAIA,EAAE,EACR,CAEA,OAAQA,GACN,IAAK,IAAK,OAAO0wD,EAAMk/E,KAAK/+B,EAAK2+B,UACjC,IAAK,IAAK,OAAO9+E,EAAMm/E,iBAAiBh/B,EAAK2+B,UAC7C,IAAK,IAAK,OAAO9+E,EAAMo/E,OAAOj/B,EAAKk/B,YACnC,IAAK,IAOL,IAAK,IAAK,OAAOr/E,EAAMs/E,mBAAmBn/B,EAAKk/B,YAN/C,IAAK,IAAK,OAAOd,EAAIn+H,KAAKE,MAAM6/F,EAAK6+B,cAAgB,KAAMr9H,GAC3D,IAAK,IAAK,OAAOi4H,EAASz5B,EAAM,YAChC,IAAK,IAAK,OAAOo+B,EAAIp+B,EAAKo/B,UAAW59H,GACrC,IAAK,IAAK,OAAOw+F,EAAKo/B,UACtB,IAAK,IAAK,OAAO3F,EAASz5B,EAAM,YAChC,IAAK,IAAK,OAAOo+B,EAAIp+B,EAAKu+B,WAAY/8H,GAEtC,IAAK,IAAK,OAAO48H,EAAIC,EAAQr+B,GAAOx+F,GACpC,IAAK,IAAK,OAAO48H,EAAIn+H,KAAKo/H,MAAMr/B,EAAKn+B,UAAY,IAAKvnB,KAAK0lD,EAAK6+B,cAAe,EAAG,GAAIh9D,WAAa,OAAwB,GAC3H,IAAK,IAAK,OAAOu8D,EAAIp+B,EAAKu+B,WAAwB,OAAZ/8H,EAAmB,IAAMA,GAC/D,IAAK,IAAK,OAAO48H,EAAIn+H,KAAKE,MAAM0wC,EAAY,KAAO,GACnD,IAAK,IAAK,OAAOutF,EAAIC,EAAQr+B,GAAmB,OAAZx+F,EAAmB,IAAMA,GAC7D,IAAK,IAAK,OAAO48H,EAAIp+B,EAAKs/B,aAAc99H,GACxC,IAAK,IAAK,OAAO48H,EAAIp+B,EAAKk/B,WAAa,EAAG19H,GAC1C,IAAK,IAAK,MAAO,KACjB,IAAK,IAAK,OAAOtb,OAAO85G,EAAKo/B,WA0DnC,SAAiB37I,GACf,IAAI2B,EAAI3B,EAAI,GAAIo5I,EAAKp5I,EAAI,IAEzB,GAAKo5I,GAAM,IAAMA,GAAM,IAAa,IAANz3I,GAAWA,GAAK,EAC5C,MAAO,KAGT,OAAQA,GACN,KAAK,EAAG,MAAO,KACf,KAAK,EAAG,MAAO,KACf,KAAK,EAAG,MAAO,KAEnB,CAtEgDm6I,CAAQv/B,EAAKo/B,WACvD,IAAK,IAAK,OAAOp/B,EAAKu+B,WAAa,GAAK1+E,EAAM2/E,GAAG3sI,cAAgBgtD,EAAM4/E,GAAG5sI,cAC1E,IAAK,IAAK,OAAOmtG,EAAKu+B,WAAa,GAAK1+E,EAAM2/E,GAAGvxF,cAAgB4R,EAAM4/E,GAAGxxF,cAC1E,IAAK,IAAK,OAAOwrF,EAASz5B,EAAM,SAChC,IAAK,IAAK,OAAOy5B,EAASz5B,EAAM,eAChC,IAAK,IAAK,OAAOo+B,EAAIp+B,EAAK0/B,aAAcl+H,GACxC,IAAK,IAAK,OAAOvB,KAAKE,MAAM0wC,EAAY,KACxC,IAAK,IAAK,OAAO4oF,EAASz5B,EAAM,YAChC,IAAK,IAAK,MAAO,KACjB,IAAK,IAAK,OAAOo+B,EAAII,EAAWx+B,EAAM,UAAWx+F,GACjD,IAAK,IAAK,OAAyB,IAAlBw+F,EAAK2+B,SAAiB,EAAI3+B,EAAK2+B,SAChD,IAAK,IAAK,OAAOlF,EAASz5B,EAAM,YAChC,IAAK,IAAK,OAAOo+B,EAAII,EAAWx+B,EAAM,UAAWx+F,GACjD,IAAK,IAAK,OAAOw+F,EAAK2+B,SACtB,IAAK,IAAK,OAAO3+B,EAAK6+B,cACtB,IAAK,IAAK,IAAIv+H,EAAIpa,OAAO85G,EAAK6+B,eAAgB,OAAOv+H,EAAElO,MAAMkO,EAAEvc,OAAS,GACxE,IAAK,IAAK,IAAI47I,EAAW3/B,EAAK3zG,WAAWb,MAAM,aAAc,OAAOm0I,GAAYA,EAAS,IAAM,GAC/F,IAAK,IAAK,IAAI58G,EAAMi9E,EAAK4/B,oBAAqB,OAAQ78G,EAAM,EAAI,IAAM,KAAOq7G,EAAIn+H,KAAKC,MAAMD,KAAKqkF,IAAIvhE,EAAM,KAAM,GAAK,IAAMq7G,EAAIr7G,EAAM,GAAI,GAC1I,QAAS,OAAO5zB,EAEpB,GACF,sDC9DAhM,EAAOC,QAAU,CACfy8I,SAAU,KACVd,KAAM,CAAC,SAAU,SAAU,UAAW,YAAa,WAAY,SAAU,YACzEC,iBAAkB,CAAC,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,OAC7DC,OAAQ,CAAC,UAAW,WAAY,QAAS,QAAS,MAAO,OAAQ,OAAQ,SAAU,YAAa,UAAW,WAAY,YACvHE,mBAAoB,CAAC,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,OAClGK,GAAI,KACJC,GAAI,mECRNt8I,EAAOC,QAAU,EAAjB,4FCCA,IAAI08I,EAAoB,SAA2Bt7I,GAClD,OAID,SAAyBA,GACxB,QAASA,GAA0B,iBAAVA,CAC1B,CANQu7I,CAAgBv7I,KAQxB,SAAmBA,GAClB,IAAIw7I,EAAc57I,OAAOG,UAAU8H,SAASvH,KAAKN,GAEjD,MAAuB,oBAAhBw7I,GACa,kBAAhBA,GAQL,SAAwBx7I,GACvB,OAAOA,EAAMowB,WAAaqrH,CAC3B,CATKC,CAAe17I,EACpB,CAbM27I,CAAU37I,EAChB,EAeA,IACIy7I,EADiC,mBAAXj6I,QAAyBA,OAAOsgD,IAClBtgD,OAAOsgD,IAAI,iBAAmB,MAUtE,SAAS85F,EAA8B57I,EAAO8F,GAC7C,OAA0B,IAAlBA,EAAQo9D,OAAmBp9D,EAAQw1I,kBAAkBt7I,GAC1D67I,GANiBtlG,EAMKv2C,EALlB4lB,MAAMuK,QAAQomB,GAAO,GAAK,CAAC,GAKDv2C,EAAO8F,GACrC9F,EAPJ,IAAqBu2C,CAQrB,CAEA,SAASulG,EAAkB1zH,EAAQyT,EAAQ/1B,GAC1C,OAAOsiB,EAAOpD,OAAO6W,GAAQr0B,KAAI,SAASsX,GACzC,OAAO88H,EAA8B98H,EAAShZ,EAC/C,GACD,CAkBA,SAASi2I,EAAQ3zH,GAChB,OAAOxoB,OAAO4N,KAAK4a,GAAQpD,OAT5B,SAAyCoD,GACxC,OAAOxoB,OAAOiB,sBACXjB,OAAOiB,sBAAsBunB,GAAQ1d,QAAO,SAASsxI,GACtD,OAAOp8I,OAAOmB,qBAAqBT,KAAK8nB,EAAQ4zH,EACjD,IACE,EACJ,CAGmCC,CAAgC7zH,GACnE,CAEA,SAAS8zH,EAAmBjqE,EAAQ3qB,GACnC,IACC,OAAOA,KAAY2qB,CACpB,CAAE,MAAMxjE,GACP,OAAO,CACR,CACD,CASA,SAAS0tI,EAAY/zH,EAAQyT,EAAQ/1B,GACpC,IAAIshI,EAAc,CAAC,EAiBnB,OAhBIthI,EAAQw1I,kBAAkBlzH,IAC7B2zH,EAAQ3zH,GAAQtW,SAAQ,SAAShS,GAChCsnI,EAAYtnI,GAAO87I,EAA8BxzH,EAAOtoB,GAAMgG,EAC/D,IAEDi2I,EAAQlgH,GAAQ/pB,SAAQ,SAAShS,IAblC,SAA0BsoB,EAAQtoB,GACjC,OAAOo8I,EAAmB9zH,EAAQtoB,MAC5BF,OAAOS,eAAeC,KAAK8nB,EAAQtoB,IACpCF,OAAOmB,qBAAqBT,KAAK8nB,EAAQtoB,GAC/C,EAUMs8I,CAAiBh0H,EAAQtoB,KAIzBo8I,EAAmB9zH,EAAQtoB,IAAQgG,EAAQw1I,kBAAkBz/G,EAAO/7B,IACvEsnI,EAAYtnI,GAhDf,SAA0BA,EAAKgG,GAC9B,IAAKA,EAAQu2I,YACZ,OAAOR,EAER,IAAIQ,EAAcv2I,EAAQu2I,YAAYv8I,GACtC,MAA8B,mBAAhBu8I,EAA6BA,EAAcR,CAC1D,CA0CsBS,CAAiBx8I,EAAKgG,EAAtBw2I,CAA+Bl0H,EAAOtoB,GAAM+7B,EAAO/7B,GAAMgG,GAE5EshI,EAAYtnI,GAAO87I,EAA8B//G,EAAO/7B,GAAMgG,GAEhE,IACOshI,CACR,CAEA,SAASyU,EAAUzzH,EAAQyT,EAAQ/1B,IAClCA,EAAUA,GAAW,CAAC,GACdy2I,WAAaz2I,EAAQy2I,YAAcT,EAC3Ch2I,EAAQw1I,kBAAoBx1I,EAAQw1I,mBAAqBA,EAGzDx1I,EAAQ81I,8BAAgCA,EAExC,IAAIY,EAAgB52H,MAAMuK,QAAQ0L,GAIlC,OAFgC2gH,IADZ52H,MAAMuK,QAAQ/H,GAKvBo0H,EACH12I,EAAQy2I,WAAWn0H,EAAQyT,EAAQ/1B,GAEnCq2I,EAAY/zH,EAAQyT,EAAQ/1B,GAJ5B81I,EAA8B//G,EAAQ/1B,EAM/C,CAEA+1I,EAAUvgI,IAAM,SAAsB+xE,EAAOvnF,GAC5C,IAAK8f,MAAMuK,QAAQk9D,GAClB,MAAM,IAAI7kF,MAAM,qCAGjB,OAAO6kF,EAAMloE,QAAO,SAAShN,EAAM1K,GAClC,OAAOouI,EAAU1jI,EAAM1K,EAAM3H,EAC9B,GAAG,CAAC,EACL,EAEA,IAAI22I,EAAcZ,EAElBl9I,EAAOC,QAAU69I,yEClIjB,IAAIzqB,EAAkB,EAAQ,8CAE1B0qB,EAAe,EAAQ,sCACvBlrB,EAAa,EAAQ,oCAErBmrB,EAAO,EAAQ,gCAGnBh+I,EAAOC,QAAU,SAChB6b,EACA6sC,EACAtnD,GAEA,IAAKya,GAAuB,iBAARA,GAAmC,mBAARA,EAC9C,MAAM,IAAI+2G,EAAW,0CAEtB,GAAwB,iBAAblqE,GAA6C,iBAAbA,EAC1C,MAAM,IAAIkqE,EAAW,4CAEtB,GAAIpxH,UAAUb,OAAS,GAA6B,kBAAjBa,UAAU,IAAqC,OAAjBA,UAAU,GAC1E,MAAM,IAAIoxH,EAAW,2DAEtB,GAAIpxH,UAAUb,OAAS,GAA6B,kBAAjBa,UAAU,IAAqC,OAAjBA,UAAU,GAC1E,MAAM,IAAIoxH,EAAW,yDAEtB,GAAIpxH,UAAUb,OAAS,GAA6B,kBAAjBa,UAAU,IAAqC,OAAjBA,UAAU,GAC1E,MAAM,IAAIoxH,EAAW,6DAEtB,GAAIpxH,UAAUb,OAAS,GAA6B,kBAAjBa,UAAU,GAC5C,MAAM,IAAIoxH,EAAW,2CAGtB,IAAIorB,EAAgBx8I,UAAUb,OAAS,EAAIa,UAAU,GAAK,KACtDy8I,EAAcz8I,UAAUb,OAAS,EAAIa,UAAU,GAAK,KACpD08I,EAAkB18I,UAAUb,OAAS,EAAIa,UAAU,GAAK,KACxDuF,EAAQvF,UAAUb,OAAS,GAAIa,UAAU,GAGzC89C,IAASy+F,GAAQA,EAAKliI,EAAK6sC,GAE/B,GAAI0qE,EACHA,EAAgBv3G,EAAK6sC,EAAU,CAC9B5nD,aAAkC,OAApBo9I,GAA4B5+F,EAAOA,EAAKx+C,cAAgBo9I,EACtEr9I,WAA8B,OAAlBm9I,GAA0B1+F,EAAOA,EAAKz+C,YAAcm9I,EAChE58I,MAAOA,EACPL,SAA0B,OAAhBk9I,GAAwB3+F,EAAOA,EAAKv+C,UAAYk9I,QAErD,KAAIl3I,IAAWi3I,GAAkBC,GAAgBC,GAIvD,MAAM,IAAIJ,EAAa,+GAFvBjiI,EAAI6sC,GAAYtnD,CAGjB,CACD,qFCxBO,IAAI+6F,EAAW,WAQlB,OAPAA,EAAWn7F,OAAOM,QAAU,SAAkBZ,GAC1C,QAAS+S,cAAGzR,EAAI,EAAG3B,EAAImB,UAAUb,OAAQqB,EAAI3B,EAAG2B,IAE5C,IAAK,IAAI+N,KADT0D,EAAIjS,EAAUQ,GACOhB,OAAOG,UAAUM,eAAeC,KAAK+R,EAAG1D,KAAIrP,EAAEqP,GAAK0D,EAAE1D,IAE9E,OAAOrP,CACX,EACOy7F,EAASx6F,MAAMsG,KAAMzG,UAChC,EA6KO,SAASm/F,EAAclvF,EAAIN,EAAMgtI,GACpC,GAAIA,GAA6B,IAArB38I,UAAUb,OAAc,IAAK,IAA4By9I,EAAxBp8I,EAAI,EAAG69B,EAAI1uB,EAAKxQ,OAAYqB,EAAI69B,EAAG79B,KACxEo8I,GAAQp8I,KAAKmP,IACRitI,IAAIA,EAAKp3H,MAAM7lB,UAAU6N,MAAMtN,KAAKyP,EAAM,EAAGnP,IAClDo8I,EAAGp8I,GAAKmP,EAAKnP,IAGrB,OAAOyP,EAAG2U,OAAOg4H,GAAMp3H,MAAM7lB,UAAU6N,MAAMtN,KAAKyP,GACtD,CA8FkD,mBAApBktI,iBAAiCA,gBCzT/D,iBACI,WAAYn3I,QAAA,IAAAA,IAAAA,EAAY,IAAxB,IAEC,OADGlG,OAAO8nB,QAAQ5hB,GAASgM,SAAQ,SAAC,OAAChS,EAAG,KAAEE,EAAK,KAAM,OAAC,EAAKF,GAAOE,CAAb,IAoB1D,OAjBI,YAAA6H,SAAA,WACI,OAAO+qD,KAAKC,UAAUhsD,OAG1B,YAAAkvG,SAAA,SACImnC,EACAC,GASA,OADAt2I,KAAKq2I,GAAQC,EACNt2I,MAEd,CAAD,CAtBA,GAwBM,SAAUu2I,EAAiBt+H,uBAAsC,SAA7B,EAA6B,iBAA7B,MAA6B,KAAA1e,EAAA,GACnE,OAAI,MAAO0e,GAGJu+H,EAAiBxwI,MACpB,SAACywI,WAGG,MACI,mBADyC,QAAtC,EAAwB,QAAxB,EAAAx+H,aAAO,EAAPA,EAAS8D,qBAAe,eAAA2N,mBAAc,eAAA+sH,KAE7Cx+H,aACIA,EAAQ8D,cAAc2N,YAAY+sH,EAAgB,GAElE,UCpCgBC,EACZC,EACAC,EACA33I,GAEA,IAAI+rB,EAyEJ,MAxEyB,UAArB2rH,EAAQ5lG,SACR/lB,EAAO/rB,EAAQiqB,SAASgsE,eAAgByhD,EAAyBl4H,MACrC,aAArBk4H,EAAQ5lG,SACf/lB,EAAO/rB,EAAQiqB,SAAS2tH,cAAeF,EAAyBl4H,OAE5Dm4H,GACA5rH,EAAO/rB,EAAQiqB,SAAS4tH,gBACpB,6BACAH,EAAQ5lG,UAEa,kBAArB4lG,EAAQ5lG,WACR6lG,GAAY,IAE0B,QAAnCD,EAAQ5lG,SAASvpC,eACxBwjB,EAAO/rB,EAAQiqB,SAAS4tH,gBACpB,6BACA,OAEJF,GAAY,GAEZ5rH,EAAO/rB,EAAQiqB,SAASsZ,cAAcm0G,EAAQ5lG,UAE9C4lG,EAAQxtG,YACRpwC,OAAO8nB,QAAQ81H,EAAQxtG,YAAYl+B,SAAQ,SAAC,OAAChS,EAAG,KAAEE,EAAK,KACnD,OAAC6xB,EAAiBwQ,aAAaviC,EAAKE,EAApC,IAGJw9I,EAAQI,YAERJ,EAAQI,WAAW9rI,SACf,SAAC+rI,GACG,OAAAhsH,EAAKyX,YAAYi0G,EAAUM,EAAWJ,EAAW33I,GAAjD,IAGRA,EAAQg4I,eAEJN,EAAQx9I,OACRo9I,EACIvrH,EACA,oBACA,kBACA,mBACA,gBACA,mBACA,oBACA,sBACA,sBAIAA,EASF7xB,MAAQw9I,EAAQx9I,OAElBw9I,EAAQtlH,SAAWklH,EAAiBvrH,EAAM,sBACxCA,EAA0BqG,QAAUslH,EAAQtlH,SAG9CslH,EAAQjmG,UACR6lG,EAAiBvrH,EAAM,uBAErBA,EAA2B0lB,SAAWimG,EAAQjmG,YAIrD1lB,CACX,CC3EA,IAAMksH,EAAe,SACjBlsH,EACAmsH,GAGA,IADAA,EAAQA,EAAMpwI,QACPowI,EAAMz+I,OAAS,GAAG,CACrB,IAAMoL,EAAIqzI,EAAM/+E,OAAO,EAAG,GAAG,GAC7BptC,EAAOA,EAAK+rH,WAAWjzI,EAC1B,CACD,OAAOknB,CACX,WAEgBosH,EACZr+G,EACArtB,EACAzM,GAEA,IAEI+rB,EAWAqsH,EACA3gI,EAdE4gI,EAAS5rI,EAAKzM,EAAQs4I,OAAOD,QAC7BH,EAAQzrI,EAAKzM,EAAQs4I,OAAOJ,OAI7B,CAACl4I,EAAQs4I,OAAOC,WAAYv4I,EAAQs4I,OAAOE,gBAAgBrtI,SACxDktI,KAIJtsH,EAAOksH,EAAan+G,EAAMo+G,IAQ9B,IAAMpS,EAAO,CACTr5H,KAAI,EACJsf,KAAI,GAGR,GAAI/rB,EAAQy4I,aAAa3S,GACrB,OAAO,EAGX,OAAQuS,GACJ,KAAKr4I,EAAQs4I,OAAOI,aAChB,IAAK3sH,IAASurH,EAAiBvrH,EAAM,WACjC,OAAO,EAEXA,EAAKwQ,aACD9vB,EAAKzM,EAAQs4I,OAAO56I,MACpB+O,EAAKzM,EAAQs4I,OAAOp+I,QAExB,MACJ,KAAK8F,EAAQs4I,OAAOK,gBAChB,IAAK5sH,IAASurH,EAAiBvrH,EAAM,WACjC,OAAO,EAEXA,EAAKwQ,aACD9vB,EAAKzM,EAAQs4I,OAAO56I,MACpB+O,EAAKzM,EAAQs4I,OAAOnlD,WAGpBmkD,EAAiBvrH,EAAM,qBACO,UAA9Btf,EAAKzM,EAAQs4I,OAAO56I,QAEpBquB,EAAK7xB,MAAQuS,EAAKzM,EAAQs4I,OAAOnlD,WAErC,MACJ,KAAKnzF,EAAQs4I,OAAOl9G,gBAChB,IAAKrP,IAASurH,EAAiBvrH,EAAM,WACjC,OAAO,EAEXA,EAAKqP,gBAAgB3uB,EAAKzM,EAAQs4I,OAAO56I,OACzC,MACJ,KAAKsC,EAAQs4I,OAAOM,kBAChB,IAAK7sH,IAASurH,EAAiBvrH,EAAM,QACjC,OAAO,EAEX/rB,EAAQ64I,SACJ9sH,EACAA,EAAKvM,KACL/S,EAAKzM,EAAQs4I,OAAOhlD,UACpB7mF,EAAKzM,EAAQs4I,OAAOnlD,WAEpBmkD,EAAiBvrH,EAAKxO,WAAY,yBAClCwO,EAAKxO,WAAWrjB,MAAQuS,EAAKzM,EAAQs4I,OAAOnlD,WAEhD,MACJ,KAAKnzF,EAAQs4I,OAAOQ,YAChB,IAAK/sH,QAA8B,IAAfA,EAAK7xB,MACrB,OAAO,EAEX6xB,EAAK7xB,MAAQuS,EAAKzM,EAAQs4I,OAAOnlD,UACjC,MACJ,KAAKnzF,EAAQs4I,OAAOS,cAChB,IAAKhtH,IAASurH,EAAiBvrH,EAAM,WACjC,OAAO,EAEX/rB,EAAQ64I,SACJ9sH,EACAA,EAAKvM,KACL/S,EAAKzM,EAAQs4I,OAAOhlD,UACpB7mF,EAAKzM,EAAQs4I,OAAOnlD,WAExB,MACJ,KAAKnzF,EAAQs4I,OAAOU,cAChB,IAAKjtH,QAAgC,IAAjBA,EAAKqG,QACrB,OAAO,EAEXrG,EAAKqG,QAAU3lB,EAAKzM,EAAQs4I,OAAOnlD,UACnC,MACJ,KAAKnzF,EAAQs4I,OAAOW,eAChB,IAAKltH,QAAiC,IAAlBA,EAAK0lB,SACrB,OAAO,EAEX1lB,EAAK0lB,SAAWhlC,EAAKzM,EAAQs4I,OAAOnlD,UACpC,MACJ,KAAKnzF,EAAQs4I,OAAOY,eAChB,IAAMvB,EAG2B,QADzBlrI,EAAKzM,EAAQs4I,OAAOnlD,UACtBrhD,SAASvpC,eACsB,+BAAjCwjB,EAAKxO,WAAW47H,aACpBptH,EAAKxO,WAAW67H,aACZ3B,EACIhrI,EAAKzM,EAAQs4I,OAAOnlD,UACpBwkD,EACA33I,GAEJ+rB,GAEJ,MAEJ,KAAK/rB,EAAQs4I,OAAOe,cACJ,EAAI,OAAIv5H,MAAMrT,EAAKzM,EAAQs4I,OAAOgB,eAAa,GAAE53I,KACzD,WACI,OAAAqqB,EAAKgtC,YACDhtC,EAAK+rH,WAAWrrI,EAAKzM,EAAQs4I,OAAOruI,OADxC,IAIE+B,SAAQ,SAAC+rI,EAAW75I,GACZ,IAAVA,IACAuZ,EACIsU,EAAK+rH,WAAWrrI,EAAKzM,EAAQs4I,OAAO/tI,MAE5CwhB,EAAKkuG,aAAa8d,EAAWtgI,GAAa,KAC9C,IACA,MACJ,KAAKzX,EAAQs4I,OAAOiB,cAChBxtH,EAAKxO,WAAWw7C,YAAYhtC,GAC5B,MACJ,KAAK/rB,EAAQs4I,OAAOC,WAChB,IACM1zI,GADA20I,EAActB,EAAMpwI,SACIqxD,OAAOqgF,EAAY//I,OAAS,EAAG,GAAG,GAEhE,IAAK69I,EADLvrH,EAAOksH,EAAan+G,EAAM0/G,GACE,WACxB,OAAO,EAEXztH,EAAKkuG,aACDwd,EACIhrI,EAAKzM,EAAQs4I,OAAOt/H,SACE,+BAAtB+S,EAAKotH,aACLn5I,GAEJ+rB,EAAK+rH,WAAWjzI,IAAM,MAE1B,MAEJ,KAAK7E,EAAQs4I,OAAOmB,kBAChB,IAAK1tH,GAA0B,IAAlBA,EAAKysG,SACd,OAAO,EAEX,IAAMj7G,EAAawO,EAAKxO,WACxBA,EAAWw7C,YAAYhtC,GACnBurH,EAAiB/5H,EAAY,yBAC7BA,EAAWrjB,MAAQ,IAEvB,MAEJ,KAAK8F,EAAQs4I,OAAOE,eAChB,IAAMgB,EACA30I,GADA20I,EAActB,EAAMpwI,SACIqxD,OAAOqgF,EAAY//I,OAAS,EAAG,GAAG,GAKhE,GAJA2+I,EAAUp4I,EAAQiqB,SAASgsE,eACvBxpF,EAAKzM,EAAQs4I,OAAOp+I,UAExB6xB,EAAOksH,EAAan+G,EAAM0/G,IAChB1B,WACN,OAAO,EAEX/rH,EAAKkuG,aAAame,EAASrsH,EAAK+rH,WAAWjzI,IAAM,MAC7CyyI,EAAiBvrH,EAAKxO,WAAY,yBAClCwO,EAAKxO,WAAWrjB,MAAQuS,EAAKzM,EAAQs4I,OAAOp+I,QAEhD,MAEJ,QACI4C,QAAQo8C,IAAI,kBAWpB,OANAl5C,EAAQ05I,cAAc,CAClBjtI,KAAMq5H,EAAKr5H,KACXsf,KAAM+5G,EAAK/5G,KACXqsH,QAAO,KAGJ,CACX,CClNA,SAASuB,EAAKhlI,EAAailI,EAAqBC,GAC5C,IAAMja,EAAMjrH,EAAIilI,GAChBjlI,EAAIilI,GAAMjlI,EAAIklI,GACdllI,EAAIklI,GAAMja,CACd,UAqEgBka,EACZhgH,EACAigH,EACA/5I,IAEA+5I,EAAQA,EAAMjyI,SACRs5B,UACN24G,EAAM/tI,SAAQ,SAACS,IA1EnB,SACIqtB,EACArtB,EACAzM,GAEA,OAAQyM,EAAKzM,EAAQs4I,OAAOD,SACxB,KAAKr4I,EAAQs4I,OAAOI,aAChBjsI,EAAKzM,EAAQs4I,OAAOD,QAAUr4I,EAAQs4I,OAAOl9G,gBAC7C+8G,EAAUr+G,EAAMrtB,EAAMzM,GACtB,MACJ,KAAKA,EAAQs4I,OAAOK,gBAChBgB,EAAKltI,EAAMzM,EAAQs4I,OAAOhlD,SAAUtzF,EAAQs4I,OAAOnlD,UACnDglD,EAAUr+G,EAAMrtB,EAAMzM,GACtB,MACJ,KAAKA,EAAQs4I,OAAOl9G,gBAChB3uB,EAAKzM,EAAQs4I,OAAOD,QAAUr4I,EAAQs4I,OAAOI,aAC7CP,EAAUr+G,EAAMrtB,EAAMzM,GACtB,MACJ,KAAKA,EAAQs4I,OAAOM,kBAIpB,KAAK54I,EAAQs4I,OAAOQ,YAIpB,KAAK94I,EAAQs4I,OAAOS,cAIpB,KAAK/4I,EAAQs4I,OAAOU,cAIpB,KAAKh5I,EAAQs4I,OAAOW,eAIpB,KAAKj5I,EAAQs4I,OAAOY,eAChBS,EAAKltI,EAAMzM,EAAQs4I,OAAOhlD,SAAUtzF,EAAQs4I,OAAOnlD,UACnDglD,EAAUr+G,EAAMrtB,EAAMzM,GACtB,MACJ,KAAKA,EAAQs4I,OAAOe,cAChBM,EAAKltI,EAAMzM,EAAQs4I,OAAOruI,KAAMjK,EAAQs4I,OAAO/tI,IAC/C4tI,EAAUr+G,EAAMrtB,EAAMzM,GACtB,MACJ,KAAKA,EAAQs4I,OAAOiB,cAChB9sI,EAAKzM,EAAQs4I,OAAOD,QAAUr4I,EAAQs4I,OAAOC,WAC7CJ,EAAUr+G,EAAMrtB,EAAMzM,GACtB,MACJ,KAAKA,EAAQs4I,OAAOC,WAChB9rI,EAAKzM,EAAQs4I,OAAOD,QAAUr4I,EAAQs4I,OAAOiB,cAC7CpB,EAAUr+G,EAAMrtB,EAAMzM,GACtB,MACJ,KAAKA,EAAQs4I,OAAOmB,kBAChBhtI,EAAKzM,EAAQs4I,OAAOD,QAAUr4I,EAAQs4I,OAAOE,eAC7CL,EAAUr+G,EAAMrtB,EAAMzM,GACtB,MACJ,KAAKA,EAAQs4I,OAAOE,eAChB/rI,EAAKzM,EAAQs4I,OAAOD,QAAUr4I,EAAQs4I,OAAOmB,kBAC7CtB,EAAUr+G,EAAMrtB,EAAMzM,GACtB,MACJ,QACIlD,QAAQo8C,IAAI,kBAExB,CAUQ8gG,CAASlgH,EAAMrtB,EAAkBzM,EACrC,GACJ,CC/EA,IAAMi6I,EAAqB,SAACx7H,GACxB,IAAMs0D,EAAS,GAkBf,OAjBAA,EAAOpwE,KAAK8b,EAAGqzB,UACK,UAAhBrzB,EAAGqzB,UAAwC,aAAhBrzB,EAAGqzB,UAE1BrzB,EAAGyrB,aACCzrB,EAAGyrB,WAAkB,OACrB6oC,EAAOpwE,KACH,UAAG8b,EAAGqzB,SAAY,YAAArzB,EAAGyrB,WAAkB,MAAExlC,QACrC,KACA,OAIR+Z,EAAGyrB,WAAWvoC,IACdoxE,EAAOpwE,KAAK,UAAG8b,EAAGqzB,SAAY,YAAArzB,EAAGyrB,WAAWvoC,MAIjDoxE,CACX,EAEMmnE,EAAwB,SAACC,GAC3B,IAAMC,EAAoB,CAAC,EACrBC,EAAuB,CAAC,EAe9B,OAbAF,EAAGnuI,SAAQ,SAAC+f,GACRkuH,EAAmBluH,GAAM/f,SAAQ,SAACsuI,GAC9B,IAAMC,EAAWD,KAAcF,EAE1BG,GADWD,KAAcD,EAGnBE,WACAH,EAAkBE,GACzBD,EAAqBC,IAAc,GAHnCF,EAAkBE,IAAc,CAKxC,GACJ,IAEOF,CACX,EAEaI,EAAe,SAACC,EAAoBC,GAC7C,IAAMC,EAAWT,EAAsBO,GACjCG,EAAWV,EAAsBQ,GACjCG,EAAS,CAAC,EAQhB,OANA/gJ,OAAO4N,KAAKizI,GAAU3uI,SAAQ,SAAChS,GACvB4gJ,EAAS5gJ,KACT6gJ,EAAO7gJ,IAAO,EAEtB,IAEO6gJ,CACX,EAEaC,EAAa,SAAChhH,GAIvB,cAHOA,EAAKihH,iBACLjhH,EAAKkhH,iBACLlhH,EAAKmhH,WACRnhH,EAAKg+G,YACEh+G,EAAKg+G,WAAW3wI,MAAM2zI,EAIrC,EAEaI,EAAY,SAACC,GACtB,GAAIrhJ,OAAOG,UAAUM,eAAeC,KAAK2gJ,EAAU,QAK/C,MAJ+B,CAC3BrpG,SAAgC,UAAtBqpG,EAASrpG,SAAuB,QAAU,WACpDtyB,KAAO27H,EAA8B37H,MAIzC,IAAM47H,EAA+B,CACjCtpG,SAAUqpG,EAASrpG,UAoBvB,OAjBIh4C,OAAOG,UAAUM,eAAeC,KAAK2gJ,EAAU,gBAC/CC,EAAYlxG,WAAa,EAAH,GAAQixG,EAASjxG,aAEvCpwC,OAAOG,UAAUM,eAAeC,KAAK2gJ,EAAU,aAC/CC,EAAYhpH,QAAU+oH,EAAS/oH,SAE/Bt4B,OAAOG,UAAUM,eAAeC,KAAK2gJ,EAAU,WAC/CC,EAAYlhJ,MAAQihJ,EAASjhJ,OAE7BJ,OAAOG,UAAUM,eAAeC,KAAK2gJ,EAAU,cAC/CC,EAAY3pG,SAAW0pG,EAAS1pG,UAEhC33C,OAAOG,UAAUM,eAAeC,KAAK2gJ,EAAU,gBAC/CC,EAAYtD,WAAaqD,EAASrD,WAAWp2I,KAAI,SAAC25I,GAC9C,OAAAH,EAAUG,EAAV,KAGDD,CAEf,EAEaE,EAAU,SAACC,EAAkBC,GACtC,IACK,CAAC,WAAY,QAAS,UAAW,WAAY,QAAQr0I,OAClD,SAAC6R,GACG,OAAIuiI,EAAGviI,KAAawiI,EAAGxiI,EAI3B,IAGJ,OAAO,EAEX,GAAIlf,OAAOG,UAAUM,eAAeC,KAAK+gJ,EAAI,QAEzC,OAAO,EAIX,GAAI5xH,QAAQ4xH,EAAGrxG,cAAgBvgB,QAAQ6xH,EAAGtxG,YACtC,OAAO,EAGX,GAAIvgB,QAAQ4xH,EAAGzD,cAAgBnuH,QAAQ6xH,EAAG1D,YACtC,OAAO,EAEX,GAAIyD,EAAGrxG,WAAY,CACf,IAAMuxG,EAAe3hJ,OAAO4N,KAAK6zI,EAAGrxG,YAC9BwxG,EAAe5hJ,OAAO4N,KAAK8zI,EAAGtxG,YAEpC,GAAIuxG,EAAahiJ,SAAWiiJ,EAAajiJ,OACrC,OAAO,EAEX,IACKgiJ,EAAat0I,OAAM,SAACw0I,GACjB,OACKJ,EAA2BrxG,WAAWyxG,KACtCH,EAA2BtxG,WAAWyxG,EAK/C,IAEA,OAAO,CAEd,CACD,GAAIJ,EAAGzD,WAAY,CACf,GAAIyD,EAAGzD,WAAWr+I,SAAW+hJ,EAAG1D,WAAWr+I,OACvC,OAAO,EAEX,IACK8hJ,EAAGzD,WAAW3wI,OAAM,SAAC4wI,EAAqB75I,GACvC,OAAAo9I,EAAQvD,EAAWyD,EAAG1D,WAAW55I,GAAjC,IAGJ,OAAO,CAEd,CAED,OAAO,CACX,EAEa09I,EAAe,SACxBL,EACAC,EACApB,EACAyB,EACAC,GAEA,QAFA,IAAAA,IAAAA,GAAwB,IAEnBP,IAAOC,EACR,OAAO,EAGX,GAAID,EAAGzpG,WAAa0pG,EAAG1pG,SACnB,OAAO,EAGX,GAAI,CAAC,QAAS,YAAY3mC,SAASowI,EAAGzpG,UAIlC,QAAOgqG,GAEAP,EAAwB/7H,OAAUg8H,EAAwBh8H,KAMrE,GAAI+7H,EAAGzpG,YAAYsoG,EACf,OAAO,EAGX,GAAImB,EAAGrxG,YAAcsxG,EAAGtxG,WAAY,CAChC,GAAIqxG,EAAGrxG,WAAWvoC,GAAI,CAClB,GAAI45I,EAAGrxG,WAAWvoC,KAAO65I,EAAGtxG,WAAWvoC,GACnC,OAAO,EAGP,GADqB,GAAG,OAAA45I,EAAGzpG,SAAY,YAAAypG,EAAGrxG,WAAWvoC,MACjCy4I,EAChB,OAAO,CAGlB,CACD,GACImB,EAAGrxG,WAAkB,OACrBqxG,EAAGrxG,WAAkB,QAAMsxG,EAAGtxG,WAAkB,MAKhD,GAHwB,GAAG,OAAAqxG,EAAGzpG,SAAQ,YAAIypG,EAAGrxG,WAClC,MACTxlC,QAAQ,KAAM,QACO01I,EACnB,OAAO,CAGlB,CAED,GAAIyB,EACA,OAAO,EAGX,IAAME,EAAYR,EAAGzD,WAAayD,EAAGzD,WAAWhwI,QAAQs5B,UAAY,GAC9D46G,EAAYR,EAAG1D,WAAa0D,EAAG1D,WAAWhwI,QAAQs5B,UAAY,GAEpE,GAAI26G,EAAUtiJ,SAAWuiJ,EAAUviJ,OAC/B,OAAO,EAGX,GAAIqiJ,EACA,OAAOC,EAAU50I,OACb,SAAC6R,EAAmB9a,GAChB,OAAA8a,EAAQ84B,WAAakqG,EAAU99I,GAAO4zC,QAAtC,IAKR,IAAM,EAAyB0oG,EAAauB,EAAWC,GACvD,OAAOD,EAAU50I,OAAM,SAAC6R,EAAmB9a,GACvC,OAAA09I,EACI5iI,EACAgjI,EAAU99I,GACV,GACA,GACA,EALJ,GASZ,EAqFM+9I,EAAmB,SAAC9iJ,EAAWiT,GACjC,SAAI,OAAI0T,MAAM3mB,IAAE,GAAEuI,KAAI,WAAM,OAAA0K,CAAC,GAA7B,EA+DS8vI,EAAe,SACxBC,EACAC,GAgBA,IAbA,IAAMC,EAAcF,EAAQrE,WAAaqE,EAAQrE,WAAa,GAExDp7F,EAAc0/F,EAAQtE,WAAasE,EAAQtE,WAAa,GACxDwE,EAAUL,EAAiBI,EAAY5iJ,QAAQ,GAC/C8iJ,EAAUN,EAAiBv/F,EAAYjjD,QAAQ,GAC/C+iJ,EAAU,GAEVC,EAAc,WAChB,OAAOniJ,UAAU,EACrB,EAEIoiJ,GAAkB,eAGlB,IAAMhqI,EAnKY,SACtBiqI,EACAC,EACAN,EACAC,GAEA,IAAIM,EAAU,EACV3+I,EAAkB,GAChB4+I,EAAWH,EAAGljJ,OACdsjJ,EAAWH,EAAGnjJ,OAGhBu1B,EAAU,EAAI,OAAIlP,MAAMg9H,EAAW,IAAI,GAAAp7I,KAAI,WAAM,YAE/C04I,EAAoBI,EAAamC,EAAIC,GAKvCI,EAAcF,IAAaC,EAE3BC,GACAL,EAAG51I,MAAK,SAACiS,EAAmBle,GACxB,IAAMmiJ,EAAShD,EAAmBjhI,GAC5BkkI,EAASjD,EAAmB2C,EAAG9hJ,IACrC,OAAImiJ,EAAOxjJ,SAAWyjJ,EAAOzjJ,QACzBujJ,GAAc,GACP,IAEXC,EAAOl2I,MAAK,SAACwtD,EAAaz5D,GACtB,GAAIy5D,IAAgB2oF,EAAOpiJ,GAEvB,OADAkiJ,GAAc,GACP,CAEf,KACKA,QAAL,EAGJ,IAIJ,IAAK,IAAIG,EAAU,EAAGA,EAAUL,EAAUK,IAEtC,IADA,IAAMC,EAAYT,EAAGQ,GACZE,EAAU,EAAGA,EAAUN,EAAUM,IAAW,CACjD,IAAMC,EAAYV,EAAGS,GAEhBf,EAAQa,IACRZ,EAAQc,KACTzB,EACIwB,EACAE,EACAlD,EACA4C,GAWJhuH,EAAQmuH,EAAU,GAAGE,EAAU,GAAK,GARpCruH,EAAQmuH,EAAU,GAAGE,EAAU,GAAKruH,EAAQmuH,GAASE,GAC/CruH,EAAQmuH,GAASE,GAAW,EAC5B,EACFruH,EAAQmuH,EAAU,GAAGE,EAAU,IAAMR,IACrCA,EAAU7tH,EAAQmuH,EAAU,GAAGE,EAAU,GACzCn/I,EAAQ,CAACi/I,EAAU,EAAGE,EAAU,IAK3C,CAGL,OAAgB,IAAZR,GAIG,CACHvpD,SAAUp1F,EAAM,GAAK2+I,EACrB1pD,SAAUj1F,EAAM,GAAK2+I,EACrBpjJ,OAAQojJ,EAEhB,CAqFuBU,CACXlB,EACA3/F,EACA4/F,EACAC,GAEA7pI,GACA8pI,EAAQ75I,KAAK+P,GACO,EAAI,OAAIoN,MAAMpN,EAAOjZ,SAAS,GAAAiI,IAAI+6I,GAC1CzwI,SAAQ,SAACioB,GACjB,OAlCC,SAACqoH,EAASC,EAAS7pI,EAAoB5X,GACpDwhJ,EAAQ5pI,EAAO4gF,SAAWx4F,IAAK,EAC/ByhJ,EAAQ7pI,EAAOygF,SAAWr4F,IAAK,CACnC,CA+BgB0iJ,CAASlB,EAASC,EAAS7pI,EAAQuhB,EAAnC,KAGJyoH,GAAkB,IAdlBA,OAoBR,OAFAP,EAAQK,QAAUA,EAClBL,EAAQsB,WAAa,IACdjB,CACX,EAEA,aAEI,aACIz7I,KAAK0N,KAAO,GASpB,OANI,EAAG,cAAH,SAAIsrI,UACA,EAAAh5I,KAAK0N,MAAK9L,KAAQ,QAAAo3I,IAEtB,EAAO,kBAAP,SAAQ/2H,GACJjiB,KAAK0N,KAAKzC,SAAQ,SAACmuI,GAAa,OAAAn3H,EAAGm3H,EAAH,KAEvC,CAAD,CAZA,GC3bA,SAASuD,EAAoB5jH,EAAuBo+G,GAChD,IACI36H,EACAogI,EAFA5xH,EAAO+N,EAKX,IADAo+G,EAAQA,EAAMpwI,QACPowI,EAAMz+I,OAAS,GAClBkkJ,EAAYzF,EAAM/+E,OAAO,EAAG,GAAG,GAC/B57C,EAAawO,EACbA,EAAOA,EAAK+rH,WAAa/rH,EAAK+rH,WAAW6F,QAAa/uH,EAE1D,MAAO,CACH7C,KAAI,EACJxO,WAAU,EACVogI,UAAS,EAEjB,UA8TgBC,EACZ9jH,EACAigH,EACA/5I,GAKA,OAHA+5I,EAAM/tI,SAAQ,SAACS,IAjUnB,SACIqtB,EACArtB,EACAzM,SAEI+rB,EAAMxO,EAAYogI,EAEtB,IACK,CAAC39I,EAAQs4I,OAAOC,WAAYv4I,EAAQs4I,OAAOE,gBAAgBrtI,SACxDsB,EAAKzM,EAAQs4I,OAAOD,SAE1B,CAEE,IAAMwF,EAAYH,EAAoB5jH,EAAMrtB,EAAKzM,EAAQs4I,OAAOJ,QAChEnsH,EAAO8xH,EAAU9xH,KACjBxO,EAAasgI,EAAUtgI,WACvBogI,EAAYE,EAAUF,SACzB,CAED,IAYIvF,EAEAF,EAdE4F,EAA2B,GAG3BhY,EAAO,CACTr5H,KAAI,EACJsf,KAAI,GAGR,GAAI/rB,EAAQ+9I,oBAAoBjY,GAC5B,OAAO,EAOX,OAAQr5H,EAAKzM,EAAQs4I,OAAOD,SACxB,KAAKr4I,EAAQs4I,OAAOI,aACX3sH,EAAKme,aACNne,EAAKme,WAAa,CAAC,GAGvBne,EAAKme,WAAWz9B,EAAKzM,EAAQs4I,OAAO56I,OAChC+O,EAAKzM,EAAQs4I,OAAOp+I,OAEU,YAA9BuS,EAAKzM,EAAQs4I,OAAO56I,MACpBquB,EAAKqG,SAAU,EACsB,aAA9B3lB,EAAKzM,EAAQs4I,OAAO56I,MAC3BquB,EAAK0lB,UAAW,EAEE,UAAlB1lB,EAAK+lB,UACyB,UAA9BrlC,EAAKzM,EAAQs4I,OAAO56I,QAEpBquB,EAAK7xB,MAAQuS,EAAKzM,EAAQs4I,OAAOp+I,QAGrC,MACJ,KAAK8F,EAAQs4I,OAAOK,gBAChB5sH,EAAKme,WAAWz9B,EAAKzM,EAAQs4I,OAAO56I,OAChC+O,EAAKzM,EAAQs4I,OAAOnlD,UACxB,MACJ,KAAKnzF,EAAQs4I,OAAOl9G,uBACTrP,EAAKme,WAAWz9B,EAAKzM,EAAQs4I,OAAO56I,OAEC,IAAxC5D,OAAO4N,KAAKqkB,EAAKme,YAAYzwC,eACtBsyB,EAAKme,WAGkB,YAA9Bz9B,EAAKzM,EAAQs4I,OAAO56I,MACpBquB,EAAKqG,SAAU,EACsB,aAA9B3lB,EAAKzM,EAAQs4I,OAAO56I,aACpBquB,EAAK0lB,SAEM,UAAlB1lB,EAAK+lB,UACyB,UAA9BrlC,EAAKzM,EAAQs4I,OAAO56I,cAEbquB,EAAK7xB,MAGhB,MACJ,KAAK8F,EAAQs4I,OAAOM,kBAChB7sH,EAAKvM,KAAO/S,EAAKzM,EAAQs4I,OAAOnlD,UACJ,aAAxB51E,EAAWu0B,WACXv0B,EAAWrjB,MAAQuS,EAAKzM,EAAQs4I,OAAOnlD,WAE3C,MACJ,KAAKnzF,EAAQs4I,OAAOQ,YAChB/sH,EAAK7xB,MAAQuS,EAAKzM,EAAQs4I,OAAOnlD,UACjC,MACJ,KAAKnzF,EAAQs4I,OAAOS,cAChBhtH,EAAKvM,KAAO/S,EAAKzM,EAAQs4I,OAAOnlD,UAChC,MACJ,KAAKnzF,EAAQs4I,OAAOU,cAChBjtH,EAAKqG,QAAU3lB,EAAKzM,EAAQs4I,OAAOnlD,UACnC,MACJ,KAAKnzF,EAAQs4I,OAAOW,eAChBltH,EAAK0lB,SAAWhlC,EAAKzM,EAAQs4I,OAAOnlD,UACpC,MACJ,KAAKnzF,EAAQs4I,OAAOY,eAChBd,EAAU8C,EAAUzuI,EAAKzM,EAAQs4I,OAAOnlD,WACxC51E,EAAWu6H,WAAW6F,GAAavF,EACnC,MACJ,KAAKp4I,EAAQs4I,OAAOe,cACJttH,EAAK+rH,WACZ3+E,OACG1sD,EAAKzM,EAAQs4I,OAAOruI,MACpBwC,EAAKzM,EAAQs4I,OAAOgB,cAEvBl4G,UACKp1B,SAAQ,SAACgyI,GACf,OAAAjyH,EAAK+rH,WAAW3+E,OAAO1sD,EAAKzM,EAAQs4I,OAAO/tI,IAAK,EAAGyzI,EAAnD,IAEAjyH,EAAKywH,SACLzwH,EAAKywH,QAAQxwI,SAAQ,SAACtK,GAClB,GACI+K,EAAKzM,EAAQs4I,OAAOruI,MAAQwC,EAAKzM,EAAQs4I,OAAO/tI,KAChD7I,EAAI4xF,UAAY7mF,EAAKzM,EAAQs4I,OAAO/tI,KACpC7I,EAAI4xF,SAAW7mF,EAAKzM,EAAQs4I,OAAOruI,MAEnCvI,EAAI4xF,UAAY7mF,EAAKzM,EAAQs4I,OAAOgB,cAC9B2E,EACFv8I,EAAI4xF,SAAW5xF,EAAIjI,OAASgT,EAAKzM,EAAQs4I,OAAO/tI,KAClC,IAEduzI,EAAWn7I,KAAK,CACZ2wF,SACI7mF,EAAKzM,EAAQs4I,OAAO/tI,IACpBkC,EAAKzM,EAAQs4I,OAAOgB,aACxBnmD,SACIzxF,EAAIyxF,SAAWzxF,EAAIjI,OAASwkJ,EAChCxkJ,OAAQwkJ,IAEZv8I,EAAIjI,QAAUwkJ,QAEf,GACHxxI,EAAKzM,EAAQs4I,OAAOruI,MAAQwC,EAAKzM,EAAQs4I,OAAO/tI,KAChD7I,EAAI4xF,SAAW7mF,EAAKzM,EAAQs4I,OAAO/tI,KACnC7I,EAAI4xF,SAAW7mF,EAAKzM,EAAQs4I,OAAOruI,MACrC,CAEE,IAAMg0I,EADNv8I,EAAI4xF,UAAY7mF,EAAKzM,EAAQs4I,OAAOgB,cAC9B2E,EACFv8I,EAAI4xF,SAAW5xF,EAAIjI,OAASgT,EAAKzM,EAAQs4I,OAAO/tI,KAClC,IAEduzI,EAAWn7I,KAAK,CACZ2wF,SACI7mF,EAAKzM,EAAQs4I,OAAO/tI,IACpBkC,EAAKzM,EAAQs4I,OAAOgB,aACxBnmD,SACIzxF,EAAIyxF,SAAWzxF,EAAIjI,OAASwkJ,EAChCxkJ,OAAQwkJ,IAEZv8I,EAAIjI,QAAUwkJ,EAErB,MAAUv8I,EAAI4xF,WAAa7mF,EAAKzM,EAAQs4I,OAAOruI,QAC5CvI,EAAI4xF,SAAW7mF,EAAKzM,EAAQs4I,OAAO/tI,IAE3C,IAGJ,MACJ,KAAKvK,EAAQs4I,OAAOiB,cAChBh8H,EAAWu6H,WAAW3+E,OAAOwkF,EAAW,GACpCpgI,EAAWi/H,SACXj/H,EAAWi/H,QAAQxwI,SAAQ,SAACtK,GACpBA,EAAI4xF,SAAWqqD,EACfj8I,EAAI4xF,UAAY,EACT5xF,EAAI4xF,WAAaqqD,EACxBj8I,EAAU,QAAG,EAEbA,EAAI4xF,SAAWqqD,GACfj8I,EAAI4xF,SAAW5xF,EAAIjI,OAASkkJ,IAExBj8I,EAAI4xF,SAAW5xF,EAAIjI,OAAS,IAAMkkJ,EAClCj8I,EAAIjI,UAEJqkJ,EAAWn7I,KAAK,CACZwwF,SACIzxF,EAAIyxF,SAAWwqD,EAAYj8I,EAAI4xF,SACnCA,SAAUqqD,EACVlkJ,OACIiI,EAAIjI,OAASkkJ,EAAYj8I,EAAI4xF,SAAW,IAEhD5xF,EAAIjI,OAASkkJ,EAAYj8I,EAAI4xF,UAGzC,IAEJvnE,EAAOxO,EACP,MACJ,KAAKvd,EAAQs4I,OAAOC,WAEhB,IAAM,GADNL,EAAQzrI,EAAKzM,EAAQs4I,OAAOJ,OAAOpwI,SACXqxD,OAAO++E,EAAMz+I,OAAS,EAAG,GAAG,GACpDsyB,EAAyC,QAAlC,EAAA2xH,EAAoB5jH,EAAMo+G,UAAQ,eAAAnsH,KACzCqsH,EAAU8C,EAAUzuI,EAAKzM,EAAQs4I,OAAOt/H,UAEnC+S,EAAK+rH,aACN/rH,EAAK+rH,WAAa,IAGlB,GAAK/rH,EAAK+rH,WAAWr+I,OACrBsyB,EAAK+rH,WAAWn1I,KAAKy1I,GAErBrsH,EAAK+rH,WAAW3+E,OAAO,EAAG,EAAGi/E,GAE7BrsH,EAAKywH,SACLzwH,EAAKywH,QAAQxwI,SAAQ,SAACtK,GAClB,GAAIA,EAAI4xF,UAAY,EAChB5xF,EAAI4xF,UAAY,OACb,GACH5xF,EAAI4xF,SAAW,GACf5xF,EAAI4xF,SAAW5xF,EAAIjI,OAAS,EAC9B,CACE,IAAMwkJ,EAAcv8I,EAAI4xF,SAAW5xF,EAAIjI,OAAS,EAChDqkJ,EAAWn7I,KAAK,CACZwwF,SAAUzxF,EAAIyxF,SAAWzxF,EAAIjI,OAASwkJ,EACtC3qD,SAAU,EAAI,EACd75F,OAAQwkJ,IAEZv8I,EAAIjI,QAAUwkJ,CACjB,CACL,IAEJ,MAEJ,KAAKj+I,EAAQs4I,OAAOmB,kBAChBl8H,EAAWu6H,WAAW3+E,OAAOwkF,EAAW,GACZ,aAAxBpgI,EAAWu0B,iBACJv0B,EAAWrjB,MAElBqjB,EAAWi/H,SACXj/H,EAAWi/H,QAAQxwI,SAAQ,SAACtK,GACpBA,EAAI4xF,SAAWqqD,EACfj8I,EAAI4xF,UAAY,EACT5xF,EAAI4xF,WAAaqqD,EACxBj8I,EAAU,QAAG,EAEbA,EAAI4xF,SAAWqqD,GACfj8I,EAAI4xF,SAAW5xF,EAAIjI,OAASkkJ,IAExBj8I,EAAI4xF,SAAW5xF,EAAIjI,OAAS,IAAMkkJ,EAClCj8I,EAAIjI,UAEJqkJ,EAAWn7I,KAAK,CACZwwF,SACIzxF,EAAIyxF,SAAWwqD,EAAYj8I,EAAI4xF,SACnCA,SAAUqqD,EACVlkJ,OACIiI,EAAIjI,OAASkkJ,EAAYj8I,EAAI4xF,SAAW,IAEhD5xF,EAAIjI,OAASkkJ,EAAYj8I,EAAI4xF,UAGzC,IAEJvnE,EAAOxO,EACP,MACJ,KAAKvd,EAAQs4I,OAAOE,eAEhB,IAAM,GADNN,EAAQzrI,EAAKzM,EAAQs4I,OAAOJ,OAAOpwI,SACXqxD,OAAO++E,EAAMz+I,OAAS,EAAG,GAAG,GACpD2+I,EAAU,CACNtmG,SAAU,QACVtyB,KAAM/S,EAAKzM,EAAQs4I,OAAOp+I,SAE9B6xB,EAAO2xH,EAAoB5jH,EAAMo+G,GAAOnsH,MAC9B+rH,aACN/rH,EAAK+rH,WAAa,IAGlB,GAAK/rH,EAAK+rH,WAAWr+I,OACrBsyB,EAAK+rH,WAAWn1I,KAAKy1I,GAErBrsH,EAAK+rH,WAAW3+E,OAAO,EAAG,EAAGi/E,GAEX,aAAlBrsH,EAAK+lB,WACL/lB,EAAK7xB,MAAQuS,EAAKzM,EAAQs4I,OAAOnlD,WAEjCpnE,EAAKywH,SACLzwH,EAAKywH,QAAQxwI,SAAQ,SAACtK,GAIlB,GAHIA,EAAI4xF,UAAY,IAChB5xF,EAAI4xF,UAAY,GAEhB5xF,EAAI4xF,SAAW,GAAK5xF,EAAI4xF,SAAW5xF,EAAIjI,OAAS,EAAG,CACnD,IAAMwkJ,EAAcv8I,EAAI4xF,SAAW5xF,EAAIjI,OAAS,EAChDqkJ,EAAWn7I,KAAK,CACZwwF,SAAUzxF,EAAIyxF,SAAWzxF,EAAIjI,OAASwkJ,EACtC3qD,SAAU,EAAI,EACd75F,OAAQwkJ,IAEZv8I,EAAIjI,QAAUwkJ,CACjB,CACL,IAEJ,MAEJ,QACInhJ,QAAQo8C,IAAI,kBAGhBntB,EAAKywH,UACLzwH,EAAKywH,QAAUzwH,EAAKywH,QAAQ53I,QACxB,SAAClD,GAAoB,OAACA,EAAU,QAAIA,EAAI4xF,WAAa5xF,EAAIyxF,QAApC,IAErB2qD,EAAWrkJ,SACXsyB,EAAKywH,QAAUzwH,EAAKywH,QAAQt9H,OAAO4+H,KAI3C99I,EAAQk+I,qBAAqB,CACzBnyH,KAAM+5G,EAAK/5G,KACXtf,KAAMq5H,EAAKr5H,KACX2rI,QAAO,GAIf,CAQQ+F,CAAiBrkH,EAAMrtB,EAAMzM,EACjC,KACO,CACX,CCzVgB,SAAAo+I,EACZC,EACAr+I,QAAA,IAAAA,IAAAA,EAAA,CAAmCg4I,cAAc,IAEjD,IAAMN,EAA0C,CAC5C5lG,SAAUusG,EAAMvsG,UAEpB,GAAIwlG,EAAiB+G,EAAO,OAAQ,WAC9B3G,EAAoCl4H,KAClC6+H,EACF7+H,SACC,CACH,GAAI6+H,EAAMn0G,YAAcm0G,EAAMn0G,WAAWzwC,OAAS,EAC9Ci+I,EAAQxtG,WAAa,CAAC,EACJpqB,MAAM7lB,UAAU6N,MAAMtN,KAAK6jJ,EAAMn0G,YACzCl+B,SACN,SAAC2vI,GACG,OAACjE,EAAQxtG,WAAWyxG,EAAUj+I,MAAQi+I,EAAUzhJ,KAAhD,IAGZ,GAAImkJ,EAAMvG,YAAcuG,EAAMvG,WAAWr+I,OAAS,EAC9Ci+I,EAAQI,WAAa,GACHh4H,MAAM7lB,UAAU6N,MAAMtN,KAAK6jJ,EAAMvG,YACzC9rI,SAAQ,SAAC+rI,GACf,OAAAL,EAAQI,WAAWn1I,KAAKy7I,EAAUrG,EAAW/3I,GAA7C,IAGJA,EAAQg4I,eACJV,EAAiB+G,EAAO,yBACxB3G,EAAQx9I,MAASmkJ,EAA8BnkJ,OAG/Co9I,EAAiB+G,EAAO,qBACxB,CAAC,QAAS,YAAYlzI,SACjBkzI,EAA2BzpI,KAAKrM,qBAEGqmB,IAAvCyvH,EAA2BjsH,QAE5BslH,EAAQtlH,QAAWisH,EAA2BjsH,QAE9CklH,EACI+G,EACA,oBACA,kBACA,mBACA,gBACA,mBACA,oBACA,sBACA,sBAGJ3G,EAAQx9I,MACJmkJ,EASFnkJ,OAEFo9I,EAAiB+G,EAAO,uBACxB3G,EAAQjmG,SAAY4sG,EAA4B5sG,UAG3D,CACD,OAAOimG,CACX,CCrEA,IAAM4G,EACF,2GAEEC,EAAS,qDAEf,SAASC,EAASvzB,GACd,OAAOA,EACFvmH,QAAQ,QAAS,KACjBA,QAAQ,QAAS,KACjBA,QAAQ,SAAU,IAC3B,CAKA,IAAM+5I,EAAS,CACXn/C,MAAM,EACN78F,MAAM,EACNi8I,IAAI,EACJxmF,KAAK,EACLymF,OAAO,EACPp5I,IAAI,EACJq5I,KAAK,EACLtyF,OAAO,EACPuyF,QAAQ,EACRzd,MAAM,EACN7/B,UAAU,EACVu9C,MAAM,EACNroI,OAAO,EACPsf,QAAQ,EACRgpH,OAAO,EACPC,KAAK,GAGHC,EAAW,SAACtpD,EAAaupD,GAC3B,IAAMniF,EAAM,CACRjrB,SAAU,GACV5H,WAAY,CAAC,GAEbi1G,GAAc,EAGdC,EAAWzpD,EAAIz0F,MAAM,uBACzB,GAAIk+I,IACAriF,EAAIjrB,SACAotG,GAAiC,QAAhBE,EAAS,GACpBA,EAAS,GACTA,EAAS,GAAGz7F,eAClB86F,EAAOW,EAAS,KAAsC,MAA/BzpD,EAAIklC,OAAOllC,EAAIl8F,OAAS,MAC/C0lJ,GAAc,GAIdpiF,EAAIjrB,SAAS5mC,WAAW,QAAQ,CAChC,IAAMm0I,EAAW1pD,EAAI36F,QAAQ,UAC7B,MAAO,CACH4Z,KAAM,UACNmX,KAAM,CACF+lB,SAAU,WACVtyB,MAAoB,IAAd6/H,EAAkB1pD,EAAI7tF,MAAM,EAAGu3I,GAAY,IAErDF,YAAW,EAElB,CAML,IAHA,IAAIG,EAAM,IAAInhJ,OAAOogJ,GACjB33I,EAAS,KACTg0E,GAAO,GACHA,GAGJ,GAAe,QAFfh0E,EAAS04I,EAAI3vI,KAAKgmF,IAGd/a,GAAO,OACJ,GAAIh0E,EAAO,GAAG3F,OACjB,GAAI2F,EAAO,GAAI,CACX,IAAI+5B,EAAO/5B,EAAO,GAAG3F,OACjB+uE,EAAM,CAACrvC,EAAM,IAEbA,EAAK3lC,QAAQ,MAAQ,IAAGg1E,EAAMrvC,EAAK5iC,MAAM,MAC7Cg/D,EAAI7yB,WAAW8lC,EAAI,IAAMA,EAAI,GAC7BsvE,EAAI1vI,WACP,MAAUhJ,EAAO,KACdm2D,EAAI7yB,WAAWtjC,EAAO,IAAMA,EAAO,GAC9B3F,OACAguE,UAAU,EAAGroE,EAAO,GAAGnN,OAAS,IAIjD,MAAO,CACHmb,KAlDO,MAmDPmX,KAAMgxC,EACNoiF,YAAW,EAEnB,EAEaI,EAAc,SACvBhjI,EACAvc,QAAA,IAAAA,IAAAA,EAAA,CACIg4I,cAAc,EACdkH,eAAe,IAGnB,IACIn0H,EADEnkB,EAAqB,GAEvB45C,GAAS,EACPwvB,EAAgE,GAElE2nE,GAAY,EAGhB,GAA0B,IAAtBp7H,EAAKvhB,QAAQ,KAAY,CACzB,IAAMub,EAAMgG,EAAKvhB,QAAQ,KACzB4L,EAAOjE,KAAK,CACRmvC,SAAU,QACVtyB,MAAe,IAATjJ,EAAagG,EAAOA,EAAK0yD,UAAU,EAAG14D,IAEnD,CAoHD,OAlHAgG,EAAK7X,QAAQ45I,GAAO,SAAC3oD,EAAaz3F,GAQ9B,IAAMguG,EAA2B,MAAlBvW,EAAIklC,OAAO,GACpB2kB,EAAY7pD,EAAIzqF,WAAW,WAC3BoK,EAAQpX,EAAQy3F,EAAIl8F,OACpBgmJ,EAAWljI,EAAKs+G,OAAOvlH,GAE7B,GAAIkqI,EAAW,CACX,IAAME,EAAUT,EAAStpD,EAAK31F,EAAQk/I,eAAenzH,KAGrD,GAAIy0B,EAAQ,EAER,OADA55C,EAAOjE,KAAK+8I,GACL,GAEX,IAAM,EAAS1vE,EAAIxvB,GAOnB,OANI,GAAUk/F,EAAQ5tG,WACb,EAAO/lB,KAAK+rH,aACb,EAAO/rH,KAAK+rH,WAAa,IAE7B,EAAO/rH,KAAK+rH,WAAWn1I,KAAK+8I,IAEzB,EACV,CAED,GAAIxzC,EAAQ,CAMR,GAJ8B,SAD9BnhF,EAAUk0H,EAAStpD,EAAK31F,EAAQk/I,eAAiBvH,IACrC5rH,KAAK+lB,WACb6lG,GAAY,GAEhBn3F,KAEKz1B,EAAQo0H,aAETM,GACa,MAAbA,EACF,CACO10H,EAAQgB,KAAK+rH,aACd/sH,EAAQgB,KAAK+rH,WAAa,IAE9B,IAAMt4H,EAAOg/H,EACTjiI,EAAKzU,MAAMwN,EAAOiH,EAAKvhB,QAAQ,IAAKsa,KAExCyV,EAAQgB,KAAK+rH,WAAWn1I,KAAK,CACzBmvC,SAAU,QACVtyB,KAAI,IAGJxf,EAAQg4I,cACkB,aAA1BjtH,EAAQgB,KAAK+lB,WAEb/mB,EAAQgB,KAAK7xB,MAAQslB,EAE5B,CAEa,IAAVghC,GAAez1B,EAAQgB,KAAK+lB,UAC5BlrC,EAAOjE,KAAKooB,EAAQgB,MAGxB,IAAM,EAASikD,EAAIxvB,EAAQ,GACvB,GAAUz1B,EAAQgB,KAAK+lB,WAClB,EAAO/lB,KAAK+rH,aACb,EAAO/rH,KAAK+rH,WAAa,IAE7B,EAAO/rH,KAAK+rH,WAAWn1I,KAAKooB,EAAQgB,OAExCikD,EAAIxvB,GAASz1B,CAChB,CACD,KAAKmhF,GAAUnhF,EAAQo0H,eAEf3+F,GAAS,IACRz1B,EAAQo0H,aACJn/I,EAAQk/I,eACLn0H,EAAQgB,KAAK+lB,WAAa6jD,EAAI7tF,MAAM,GAAI,KAC1C9H,EAAQk/I,eACNn0H,EAAQgB,KAAK+lB,SAAS6R,gBAClBgyC,EAAI7tF,MAAM,GAAI,GAAG67C,kBAE7BnD,GAEa,IACqB,QAA1Bz1B,EAAQgB,KAAK+lB,WACb6lG,GAAY,GAEhB5sH,EAAUilD,EAAIxvB,IAGW,MAAbi/F,GAAoBA,GAAU,CAI9C,IAAM3H,GACS,IAAXt3F,EAAe55C,EAASopE,EAAIxvB,GAAOz0B,KAAK+rH,YAAc,GAIpDvhI,EAAMgG,EAAKvhB,QAAQ,IAAKsa,GAC1BkK,EAAOg/H,EACPjiI,EAAKzU,MAAMwN,GAAgB,IAATiB,OAAaqY,EAAYrY,IAE/CuhI,EAAWn1I,KAAK,CACZmvC,SAAU,QACVtyB,KAAI,GAEX,CAEL,MAAO,EACX,IACO5Y,EAAO,EAClB,ECtNA,aAUI,WACI+4I,EACAC,EACA5/I,GAEAe,KAAKf,QAAUA,EACfe,KAAK8+I,GACkB,oBAAZvwH,SACPgoH,EAAiBqI,EAAQ,WACnBvB,EAAUuB,EAAmB5+I,KAAKf,SAChB,iBAAX2/I,EACLJ,EAAYI,EAAQ5+I,KAAKf,SACzB8sD,KAAKhiD,MAAMgiD,KAAKC,UAAU4yF,IAEtC5+I,KAAK++I,GACkB,oBAAZxwH,SACPgoH,EAAiBsI,EAAQ,WACnBxB,EAAUwB,EAAmB7+I,KAAKf,SAChB,iBAAX4/I,EACLL,EAAYK,EAAQ7+I,KAAKf,SACzB8sD,KAAKhiD,MAAMgiD,KAAKC,UAAU6yF,IAEtC7+I,KAAKg/I,UAAY,EACjBh/I,KAAKi/I,UAAW,EACZj/I,KAAK9D,QACL8D,KAAKk/I,OACkB,oBAAZ3wH,SACPgoH,EAAiBqI,EAAQ,WACnBvB,EAAUuB,EAAmB5+I,KAAKf,SAChB,iBAAX2/I,EACLJ,EAAYI,EAAQ5+I,KAAKf,SACzB8sD,KAAKhiD,MAAMgiD,KAAKC,UAAU4yF,IACtC5+I,KAAKm/I,OACkB,oBAAZ5wH,SACPgoH,EAAiBsI,EAAQ,WACnBxB,EAAUwB,EAAmB7+I,KAAKf,SAChB,iBAAX4/I,EACLL,EAAYK,EAAQ7+I,KAAKf,SACzB8sD,KAAKhiD,MAAMgiD,KAAKC,UAAU6yF,KAG1C7+I,KAAKo/I,QAAU,IAAIC,EA2wB3B,OAxwBI,YAAA/0F,KAAA,WACI,OAAOtqD,KAAKs/I,UAAUt/I,KAAK8+I,GAAI9+I,KAAK++I,KAGxC,YAAAO,UAAA,SAAUR,EAAyBC,GAC/B,IAAI/F,EACJ,EAAG,CACC,GAAIh5I,KAAKf,QAAQ/C,QACb8D,KAAKg/I,WAAa,EACdh/I,KAAKg/I,UAAYh/I,KAAKf,QAAQsgJ,SAC9B,MAAM,IAAI59I,MACN,4BAAqBoqD,KAAKC,UACtBhsD,KAAKk/I,QACD,eAAAnzF,KAAKC,UAAUhsD,KAAKm/I,UAMnB,KAFrBnG,EAAQh5I,KAAKw/I,aAAaV,EAAIC,EAAI,KAExBrmJ,SAID6hJ,EAAQuE,EAAIC,KACT/+I,KAAKi/I,SACLljJ,QAAQC,MAAM,oCAEdgE,KAAKi/I,UAAW,EAChBlF,EAAW+E,GACX9F,EAAQh5I,KAAKw/I,aAAaV,EAAIC,EAAI,OAI1C/F,EAAMtgJ,OAAS,IACfsH,KAAKi/I,UAAW,EAChBj/I,KAAKo/I,QAAQ9sI,IAAI0mI,GACjB6D,EAAaiC,EAAI9F,EAAOh5I,KAAKf,SAEpC,OAAQ+5I,EAAMtgJ,OAAS,GAExB,OAAOsH,KAAKo/I,QAAQ1xI,MAGxB,YAAA8xI,aAAA,SAAaV,EAAkBC,EAAkB5H,GAC7C,IAAI6B,EACAyG,EAEJ,GAAIz/I,KAAKf,QAAQygJ,UAAYvI,EAAMz+I,OAASsH,KAAKf,QAAQygJ,SACrD,MAAO,GAGX,IAAKZ,EAAG9E,UAAW,CAMf,GALAhB,EAAQh5I,KAAK2/I,cAAcb,EAAIC,EAAI5H,GAC/Bn3I,KAAKf,QAAQ2gJ,kBACbH,EAASz/I,KAAKf,QAAQ2gJ,gBAAgBd,EAAIC,EAAI/F,MAClCA,EAAQyG,GAEpBzG,EAAMtgJ,OAAS,EAEf,OADAomJ,EAAG9E,WAAY,EACRhB,EAEP8F,EAAG9E,WAAY,CAEtB,CACD,GAAIjhJ,OAAOG,UAAUM,eAAeC,KAAKqlJ,EAAI,QAEzC,MAAO,GAMX,IAAKA,EAAG7E,UAAW,CAEf,IADAjB,EAAQh5I,KAAK6/I,cAAcf,EAAIC,EAAI5H,IACzBz+I,OAAS,EACf,OAAOsgJ,EAEP8F,EAAG7E,WAAY,CAEtB,CAED,GAAIj6I,KAAKf,QAAQg4I,eAAiB6H,EAAG5E,UAAW,CAI5C,IAFAlB,EAAQh5I,KAAK8/I,cAAchB,EAAIC,EAAI5H,IAEzBz+I,OAAS,EAEf,OADAomJ,EAAG5E,WAAY,EACRlB,EAEP8F,EAAG5E,WAAY,CAEtB,CAGD,MAAO,IAGX,YAAAyF,cAAA,SAAcb,EAAkBC,EAAkB5H,GAC9C,IACIv3G,EACAmgH,EACAC,EACAC,EACA9jB,EACApiI,EANEi/I,EAAQ,GAOd,GAAI8F,EAAG/tG,WAAaguG,EAAGhuG,SAAU,CAC7B,IAAKomG,EAAMz+I,OACP,MAAM,IAAIiJ,MAAM,gDAEpB,MAAO,EACH,IAAIu+I,GACChxC,SACGlvG,KAAKf,QAAQs4I,OAAOD,OACpBt3I,KAAKf,QAAQs4I,OAAOY,gBAEvBjpC,SAASlvG,KAAKf,QAAQs4I,OAAOhlD,SAAU4nD,EAAU2E,IACjD5vC,SAASlvG,KAAKf,QAAQs4I,OAAOnlD,SAAU+nD,EAAU4E,IACjD7vC,SAASlvG,KAAKf,QAAQs4I,OAAOJ,MAAOA,GAEhD,CACD,GACIA,EAAMz+I,QACNsH,KAAKf,QAAQsgJ,QACT3qI,KAAKqkF,KACA6lD,EAAG/H,YAAc,IAAIr+I,QAAUqmJ,EAAGhI,YAAc,IAAIr+I,QAG7D,MAAO,EACH,IAAIwnJ,GACChxC,SACGlvG,KAAKf,QAAQs4I,OAAOD,OACpBt3I,KAAKf,QAAQs4I,OAAOY,gBAEvBjpC,SAASlvG,KAAKf,QAAQs4I,OAAOhlD,SAAU4nD,EAAU2E,IACjD5vC,SAASlvG,KAAKf,QAAQs4I,OAAOnlD,SAAU+nD,EAAU4E,IACjD7vC,SAASlvG,KAAKf,QAAQs4I,OAAOJ,MAAOA,IAIjD,GACIp+I,OAAOG,UAAUM,eAAeC,KAAKqlJ,EAAI,SACxCA,EAAwBrgI,OAAUsgI,EAAwBtgI,KAG3D,MAAoB,UAAhBqgI,EAAG/tG,SACI,EACH,IAAImvG,GACChxC,SACGlvG,KAAKf,QAAQs4I,OAAOD,OACpBt3I,KAAKf,QAAQs4I,OAAOM,mBAEvB3oC,SAASlvG,KAAKf,QAAQs4I,OAAOJ,MAAOA,GACpCjoC,SACGlvG,KAAKf,QAAQs4I,OAAOhlD,SACnBusD,EAAwBrgI,MAE5BywF,SACGlvG,KAAKf,QAAQs4I,OAAOnlD,SACnB2sD,EAAwBtgI,OAI9B,EACH,IAAIyhI,GACChxC,SACGlvG,KAAKf,QAAQs4I,OAAOD,OACpBt3I,KAAKf,QAAQs4I,OAAOS,eAEvB9oC,SAASlvG,KAAKf,QAAQs4I,OAAOJ,MAAOA,GACpCjoC,SACGlvG,KAAKf,QAAQs4I,OAAOhlD,SACnBusD,EAAwBrgI,MAE5BywF,SACGlvG,KAAKf,QAAQs4I,OAAOnlD,SACnB2sD,EAAwBtgI,OAa7C,IAJAshI,EAAQjB,EAAG31G,WAAapwC,OAAO4N,KAAKm4I,EAAG31G,YAAY37B,OAAS,GAC5DwyI,EAAQjB,EAAG51G,WAAapwC,OAAO4N,KAAKo4I,EAAG51G,YAAY37B,OAAS,GAE5DyyI,EAAaF,EAAMrnJ,OACdqB,EAAI,EAAGA,EAAIkmJ,EAAYlmJ,IACxB6lC,EAAOmgH,EAAMhmJ,IAEA,KADboiI,EAAM6jB,EAAM/lJ,QAAQ2lC,IAEhBo5G,EAAMp3I,MACF,IAAIs+I,GACChxC,SACGlvG,KAAKf,QAAQs4I,OAAOD,OACpBt3I,KAAKf,QAAQs4I,OAAOl9G,iBAEvB60E,SAASlvG,KAAKf,QAAQs4I,OAAOJ,MAAOA,GACpCjoC,SAASlvG,KAAKf,QAAQs4I,OAAO56I,KAAMijC,GACnCsvE,SACGlvG,KAAKf,QAAQs4I,OAAOp+I,MACpB2lJ,EAAG31G,WAAWvJ,MAI1BogH,EAAM5nF,OAAO+jE,EAAK,GACd2iB,EAAG31G,WAAWvJ,KAAUm/G,EAAG51G,WAAWvJ,IACtCo5G,EAAMp3I,MACF,IAAIs+I,GACChxC,SACGlvG,KAAKf,QAAQs4I,OAAOD,OACpBt3I,KAAKf,QAAQs4I,OAAOK,iBAEvB1oC,SAASlvG,KAAKf,QAAQs4I,OAAOJ,MAAOA,GACpCjoC,SAASlvG,KAAKf,QAAQs4I,OAAO56I,KAAMijC,GACnCsvE,SACGlvG,KAAKf,QAAQs4I,OAAOhlD,SACpBusD,EAAG31G,WAAWvJ,IAEjBsvE,SACGlvG,KAAKf,QAAQs4I,OAAOnlD,SACpB2sD,EAAG51G,WAAWvJ,MAQtC,IADAqgH,EAAaD,EAAMtnJ,OACdqB,EAAI,EAAGA,EAAIkmJ,EAAYlmJ,IACxB6lC,EAAOogH,EAAMjmJ,GACbi/I,EAAMp3I,MACF,IAAIs+I,GACChxC,SACGlvG,KAAKf,QAAQs4I,OAAOD,OACpBt3I,KAAKf,QAAQs4I,OAAOI,cAEvBzoC,SAASlvG,KAAKf,QAAQs4I,OAAOJ,MAAOA,GACpCjoC,SAASlvG,KAAKf,QAAQs4I,OAAO56I,KAAMijC,GACnCsvE,SAASlvG,KAAKf,QAAQs4I,OAAOp+I,MAAO4lJ,EAAG51G,WAAWvJ,KAI/D,OAAOo5G,GAGX,YAAA6G,cAAA,SACIf,EACAC,EACA5H,GAEA,IAAMgJ,EAAerB,EAAG/H,WAAa+H,EAAG/H,WAAWhwI,QAAU,GACvDq5I,EAAerB,EAAGhI,WAAagI,EAAGhI,WAAWhwI,QAAU,GACvDw+E,EAAO3wE,KAAK7X,IAAIojJ,EAAaznJ,OAAQ0nJ,EAAa1nJ,QACpD2nJ,EAA6BzrI,KAAKqkF,IAClCknD,EAAaznJ,OAAS0nJ,EAAa1nJ,QAEnCsgJ,EAAgB,GAChB77I,EAAQ,EACZ,IAAK6C,KAAKf,QAAQqhJ,eAAiB/6D,EAAOvlF,KAAKf,QAAQqhJ,cAAe,CAClE,IAAMC,EAAiB33H,QAAQk2H,EAAGrD,SAAWqD,EAAGpC,cAC1C8D,EAAWD,EACXzB,EAAGrD,QACHqD,EAAG/H,YAAcgI,EAAGhI,WAClBoE,EAAa2D,EAAIC,GACjB,GACR,GAAIyB,EAAS9nJ,OAAS,IAIlBsgJ,EAAQh5I,KAAKygJ,uBACT3B,EACAC,EACAyB,EACArJ,EACAoJ,IAEM7nJ,OAAS,EACf,OAAOsgJ,CAGlB,CASD,IAAK,IAAIj/I,EAAI,EAAGA,EAAIwrF,EAAMxrF,GAAK,EAAG,CAC9B,IAAMygJ,EAAK2F,EAAapmJ,GAClB0gJ,EAAK2F,EAAarmJ,GAEpBsmJ,IAGI7F,IAAOC,EACa,UAAhBD,EAAGzpG,UACHioG,EAAMp3I,MACF,IAAIs+I,GACChxC,SACGlvG,KAAKf,QAAQs4I,OAAOD,OACpBt3I,KAAKf,QAAQs4I,OAAOmB,mBAEvBxpC,SACGlvG,KAAKf,QAAQs4I,OAAOJ,MACpBA,EAAMh5H,OAAOhhB,IAEhB+xG,SACGlvG,KAAKf,QAAQs4I,OAAOp+I,MACnBqhJ,EAAwB/7H,OAGrCthB,GAAS,IAET67I,EAAMp3I,MACF,IAAIs+I,GACChxC,SACGlvG,KAAKf,QAAQs4I,OAAOD,OACpBt3I,KAAKf,QAAQs4I,OAAOiB,eAEvBtpC,SACGlvG,KAAKf,QAAQs4I,OAAOJ,MACpBA,EAAMh5H,OAAOhhB,IAEhB+xG,SACGlvG,KAAKf,QAAQs4I,OAAOt/H,QACpBkiI,EAAUK,KAGtBr9I,GAAS,GAENs9I,IAAOD,IACM,UAAhBC,EAAG1pG,SACHioG,EAAMp3I,MACF,IAAIs+I,GACChxC,SACGlvG,KAAKf,QAAQs4I,OAAOD,OACpBt3I,KAAKf,QAAQs4I,OAAOE,gBAEvBvoC,SACGlvG,KAAKf,QAAQs4I,OAAOJ,MACpBA,EAAMh5H,OAAOhhB,IAEhB+xG,SACGlvG,KAAKf,QAAQs4I,OAAOp+I,MACnBshJ,EAAwBh8H,OAIrCu6H,EAAMp3I,MACF,IAAIs+I,GACChxC,SACGlvG,KAAKf,QAAQs4I,OAAOD,OACpBt3I,KAAKf,QAAQs4I,OAAOC,YAEvBtoC,SACGlvG,KAAKf,QAAQs4I,OAAOJ,MACpBA,EAAMh5H,OAAOhhB,IAEhB+xG,SACGlvG,KAAKf,QAAQs4I,OAAOt/H,QACpBkiI,EAAUM,OAc9BD,GAAMC,KAEDz6I,KAAKf,QAAQqhJ,eACd/6D,EAAOvlF,KAAKf,QAAQqhJ,cAEpBtH,EAAQA,EAAM76H,OACVne,KAAKw/I,aAAahF,EAAIC,EAAItD,EAAMh5H,OAAOhhB,KAEnCo9I,EAAQC,EAAIC,KAChB0F,EAAaznJ,OAAS0nJ,EAAa1nJ,QACf,UAAhB8hJ,EAAGzpG,SACHioG,EAAMp3I,MACF,IAAIs+I,GACChxC,SACGlvG,KAAKf,QAAQs4I,OAAOD,OACpBt3I,KAAKf,QAAQs4I,OAAOmB,mBAEvBxpC,SACGlvG,KAAKf,QAAQs4I,OAAOJ,MACpBA,EAAMh5H,OAAOhhB,IAEhB+xG,SACGlvG,KAAKf,QAAQs4I,OAAOp+I,MACnBqhJ,EAAwB/7H,OAIrCu6H,EAAMp3I,MACF,IAAIs+I,GACChxC,SACGlvG,KAAKf,QAAQs4I,OAAOD,OACpBt3I,KAAKf,QAAQs4I,OAAOiB,eAEvBtpC,SACGlvG,KAAKf,QAAQs4I,OAAOt/H,QACpBkiI,EAAUK,IAEbtrC,SACGlvG,KAAKf,QAAQs4I,OAAOJ,MACpBA,EAAMh5H,OAAOhhB,KAI7BgjJ,EAAa/nF,OAAOr+D,EAAG,GACvBA,GAAK,EACLoD,GAAS,EAETkjJ,GAA8B,GACvBF,EAAaznJ,OAAS0nJ,EAAa1nJ,QAC1CsgJ,EAAQA,EAAM76H,OAAO,EACjB,IAAI+hI,GACChxC,SACGlvG,KAAKf,QAAQs4I,OAAOD,OACpBt3I,KAAKf,QAAQs4I,OAAOC,YAEvBtoC,SACGlvG,KAAKf,QAAQs4I,OAAOt/H,QACpBkiI,EAAUM,IAEbvrC,SACGlvG,KAAKf,QAAQs4I,OAAOJ,MACpBA,EAAMh5H,OAAOhhB,MAGzBgjJ,EAAa/nF,OAAOr+D,EAAG,EAAGogJ,EAAUM,IACpC4F,GAA8B,GAE9BrH,EAAQA,EAAM76H,OAAO,EACjB,IAAI+hI,GACChxC,SACGlvG,KAAKf,QAAQs4I,OAAOD,OACpBt3I,KAAKf,QAAQs4I,OAAOY,gBAEvBjpC,SACGlvG,KAAKf,QAAQs4I,OAAOhlD,SACpB4nD,EAAUK,IAEbtrC,SACGlvG,KAAKf,QAAQs4I,OAAOnlD,SACpB+nD,EAAUM,IAEbvrC,SACGlvG,KAAKf,QAAQs4I,OAAOJ,MACpBA,EAAMh5H,OAAOhhB,QAMrCA,GAAS,CACZ,CAED,OADA2hJ,EAAG7E,WAAY,EACRjB,GAGX,EAAsB,iCAAtB,SACI8F,EACAC,EACAyB,EACArJ,EACAoJ,GAqBA,IAZA,IAMIG,EACAC,EACAxrG,EACAnqB,EACA41H,EAVEC,EJvMmB,SAC7B/B,EACAC,EACA+B,GAEA,IAAMC,EAA2BjC,EAAG/H,WAC7BmE,EAAiB4D,EAAG/H,WAAWr+I,QAAQ,GACxC,GACAsoJ,EAA2BjC,EAAGhI,WAC7BmE,EAAiB6D,EAAGhI,WAAWr+I,QAAQ,GACxC,GACFy8C,EAAQ,EAgBZ,OAbA2rG,EAAO71I,SAAQ,SAAC0G,GAIZ,IAHA,IAAMsvI,EAAStvI,EAAO4gF,SAAW5gF,EAAOjZ,OAClCwoJ,EAASvvI,EAAOygF,SAAWzgF,EAAOjZ,OAE/BkmG,EAAIjtF,EAAO4gF,SAAUqM,EAAIqiD,EAAQriD,GAAK,EAC3CmiD,EAAMniD,GAAKzpD,EAEf,IAASypD,EAAIjtF,EAAOygF,SAAUwM,EAAIsiD,EAAQtiD,GAAK,EAC3CoiD,EAAMpiD,GAAKzpD,EAEfA,GAAS,CACb,IAEO,CACH4rG,MAAK,EACLC,MAAK,EAEb,CIwK+BG,CAAkBrC,EAAIC,EAAIyB,GAC3CO,EAAQF,EAAeE,MACvBC,EAAQH,EAAeG,MACvBb,EAAerB,EAAG/H,WAAWhwI,QAC7Bq5I,EAAerB,EAAGhI,WAAWhwI,QAC/Bq6I,EAAWxsI,KAAK/E,IAAIkxI,EAAMroJ,OAAQsoJ,EAAMtoJ,QAMtCsgJ,EAAQ,GAENqI,EAAS,EAAGC,EAAS,EACzBD,EAASD,EACTE,GAAU,EAAGD,GAAU,EAEvB,IACId,IACmB,IAAlBQ,EAAMM,KAAsC,IAAlBL,EAAMK,IAG9B,IAAsB,IAAlBN,EAAMO,GAEb,GAAsB,WADtBt2H,EAAOm1H,EAAamB,IACXvwG,SACL,GAAsC,UAAlCqvG,EAAaiB,GAAQtwG,UACrB,GACK/lB,EAA0BvM,OAC1B2hI,EAAaiB,GAA6B5iI,KAC7C,CAGE,IADA,IAAI8iI,EAAQD,EAERnB,EAAaznJ,OAAS6oJ,EAAQ,GACO,UAArCpB,EAAaoB,EAAQ,GAAGxwG,UAGxB,GADAwwG,GAAS,EAEJnB,EAAaiB,GACT5iI,OACJ0hI,EAAaoB,GACT9iI,KACP,CACEmiI,GAAc,EACd,KACH,CAEAA,GACD5H,EAAMp3I,MACF,IAAIs+I,GACChxC,SACGlvG,KAAKf,QAAQs4I,OAAOD,OACpBt3I,KAAKf,QAAQs4I,OACRM,mBAER3oC,SACGlvG,KAAKf,QAAQs4I,OAAOJ,MACpBA,EAAMh5H,OAAOmjI,IAEhBpyC,SACGlvG,KAAKf,QAAQs4I,OAAOhlD,SACpBvnE,EAAKvM,MAERywF,SACGlvG,KAAKf,QAAQs4I,OAAOnlD,SAEhBguD,EACIiB,GAEN5iI,MAMrB,OAEDu6H,EAAMp3I,MACF,IAAIs+I,GACChxC,SACGlvG,KAAKf,QAAQs4I,OAAOD,OACpBt3I,KAAKf,QAAQs4I,OAAOmB,mBAEvBxpC,SACGlvG,KAAKf,QAAQs4I,OAAOJ,MACpBA,EAAMh5H,OAAOmjI,IAEhBpyC,SAASlvG,KAAKf,QAAQs4I,OAAOp+I,MAAO6xB,EAAKvM,OAElDsiI,EAAM3oF,OAAOkpF,EAAQ,GACrBnB,EAAa/nF,OAAOkpF,EAAQ,GAC5BF,EAAWxsI,KAAK/E,IAAIkxI,EAAMroJ,OAAQsoJ,EAAMtoJ,QACxC4oJ,GAAU,EACVD,GAAU,OAEW,IAAlBL,EAAMK,GAGbrI,EAAMp3I,MACF,IAAIs+I,GACChxC,SACGlvG,KAAKf,QAAQs4I,OAAOD,OACpBt3I,KAAKf,QAAQs4I,OAAOY,gBAEvBjpC,SACGlvG,KAAKf,QAAQs4I,OAAOhlD,SACpB4nD,EAAUnvH,IAEbkkF,SACGlvG,KAAKf,QAAQs4I,OAAOnlD,SACpB+nD,EAAUiG,EAAaiB,KAE1BnyC,SACGlvG,KAAKf,QAAQs4I,OAAOJ,MACpBA,EAAMh5H,OAAOmjI,MAMzBtI,EAAMp3I,MACF,IAAIs+I,GACChxC,SACGlvG,KAAKf,QAAQs4I,OAAOD,OACpBt3I,KAAKf,QAAQs4I,OAAOiB,eAEvBtpC,SACGlvG,KAAKf,QAAQs4I,OAAOJ,MACpBA,EAAMh5H,OAAOmjI,IAEhBpyC,SACGlvG,KAAKf,QAAQs4I,OAAOt/H,QACpBkiI,EAAUnvH,KAGtB+1H,EAAM3oF,OAAOkpF,EAAQ,GACrBnB,EAAa/nF,OAAOkpF,EAAQ,GAC5BF,EAAWxsI,KAAK/E,IAAIkxI,EAAMroJ,OAAQsoJ,EAAMtoJ,QACxC4oJ,GAAU,EACVD,GAAU,QAEX,IAAsB,IAAlBL,EAAMK,GAES,WADtBr2H,EAAOo1H,EAAaiB,IACXtwG,UACLioG,EAAMp3I,MACF,IAAIs+I,GACChxC,SACGlvG,KAAKf,QAAQs4I,OAAOD,OACpBt3I,KAAKf,QAAQs4I,OAAOE,gBAEvBvoC,SACGlvG,KAAKf,QAAQs4I,OAAOJ,MACpBA,EAAMh5H,OAAOmjI,IAEhBpyC,SAASlvG,KAAKf,QAAQs4I,OAAOp+I,MAAO6xB,EAAKvM,OAElDsiI,EAAM3oF,OAAOkpF,EAAQ,GAAG,GACxBnB,EAAa/nF,OAAOkpF,EAAQ,EAAG,CAC3BvwG,SAAU,QACVtyB,KAAMuM,EAAKvM,OAEf2iI,EAAWxsI,KAAK/E,IAAIkxI,EAAMroJ,OAAQsoJ,EAAMtoJ,UAGxCsgJ,EAAMp3I,MACF,IAAIs+I,GACChxC,SACGlvG,KAAKf,QAAQs4I,OAAOD,OACpBt3I,KAAKf,QAAQs4I,OAAOC,YAEvBtoC,SACGlvG,KAAKf,QAAQs4I,OAAOJ,MACpBA,EAAMh5H,OAAOmjI,IAEhBpyC,SACGlvG,KAAKf,QAAQs4I,OAAOt/H,QACpBkiI,EAAUnvH,KAGtB+1H,EAAM3oF,OAAOkpF,EAAQ,GAAG,GACxBnB,EAAa/nF,OAAOkpF,EAAQ,EAAGnH,EAAUnvH,IACzCo2H,EAAWxsI,KAAK/E,IAAIkxI,EAAMroJ,OAAQsoJ,EAAMtoJ,cAGzC,GAAIqoJ,EAAMO,KAAYN,EAAMK,GAAS,CACxC,GAAIrI,EAAMtgJ,OAAS,EACf,OAAOsgJ,EAQX,GALA7jG,EAAQqrG,EAASO,EAAMO,KACvBX,EAAU/rI,KAAK/E,IACXslC,EAAMi9C,SACN+tD,EAAaznJ,OAASy8C,EAAMz8C,WAEhBy8C,EAAMo9C,UAAYouD,GAAW,EAAG,CAE5CD,GAAuB,EACvB,IAAK,IAAI9hD,EAAI,EAAGA,EAAIzpD,EAAMz8C,OAAQkmG,GAAK,EAE9Bi8C,EACGsF,EAAaQ,EAAU/hD,GACvBuhD,EAAahrG,EAAMo9C,SAAWqM,GAC9B,CAAC,GACD,GACA,KAGJ8hD,GAAuB,GAG/B,GAAIA,EACA,MAAO,EACH,IAAIR,GACChxC,SACGlvG,KAAKf,QAAQs4I,OAAOD,OACpBt3I,KAAKf,QAAQs4I,OAAOe,eAEvBppC,SACGlvG,KAAKf,QAAQs4I,OAAOgB,YACpBpjG,EAAMz8C,QAETw2G,SACGlvG,KAAKf,QAAQs4I,OAAOruI,KACpBisC,EAAMo9C,UAET2c,SAASlvG,KAAKf,QAAQs4I,OAAO/tI,GAAIm3I,GACjCzxC,SAASlvG,KAAKf,QAAQs4I,OAAOJ,MAAOA,GAGpD,CACJ,OAEL,OAAO6B,GAGX,YAAA8G,cAAA,SACIhB,EACAC,EACA5H,GAKA,IAAM6B,EAAQ,GA4Cd,OA1CI8F,EAAGpuG,WAAaquG,EAAGruG,UACnBsoG,EAAMp3I,MACF,IAAIs+I,GACChxC,SACGlvG,KAAKf,QAAQs4I,OAAOD,OACpBt3I,KAAKf,QAAQs4I,OAAOW,gBAEvBhpC,SAASlvG,KAAKf,QAAQs4I,OAAOhlD,SAAUusD,EAAGpuG,UAC1Cw+D,SAASlvG,KAAKf,QAAQs4I,OAAOnlD,SAAU2sD,EAAGruG,UAC1Cw+D,SAASlvG,KAAKf,QAAQs4I,OAAOJ,MAAOA,KAK5C2H,EAAG3lJ,OAAS4lJ,EAAG5lJ,QAChB2lJ,EAAG3lJ,QAAU4lJ,EAAG5lJ,OACA,WAAhB2lJ,EAAG/tG,UAEHioG,EAAMp3I,MACF,IAAIs+I,GACChxC,SACGlvG,KAAKf,QAAQs4I,OAAOD,OACpBt3I,KAAKf,QAAQs4I,OAAOQ,aAEvB7oC,SAASlvG,KAAKf,QAAQs4I,OAAOhlD,SAAUusD,EAAG3lJ,OAAS,IACnD+1G,SAASlvG,KAAKf,QAAQs4I,OAAOnlD,SAAU2sD,EAAG5lJ,OAAS,IACnD+1G,SAASlvG,KAAKf,QAAQs4I,OAAOJ,MAAOA,IAG7C2H,EAAGztH,UAAY0tH,EAAG1tH,SAClB2nH,EAAMp3I,MACF,IAAIs+I,GACChxC,SACGlvG,KAAKf,QAAQs4I,OAAOD,OACpBt3I,KAAKf,QAAQs4I,OAAOU,eAEvB/oC,SAASlvG,KAAKf,QAAQs4I,OAAOhlD,SAAUusD,EAAGztH,SAC1C69E,SAASlvG,KAAKf,QAAQs4I,OAAOnlD,SAAU2sD,EAAG1tH,SAC1C69E,SAASlvG,KAAKf,QAAQs4I,OAAOJ,MAAOA,IAI1C6B,GAEd,CAAD,CA9zBA,GCVMwI,EAAkB,CACpBtlJ,OAAO,EACPqjJ,QAAS,GACTG,UAAU,EACVY,cAAe,GACfrJ,cAAc,EAEda,SAAQ,SACJ9sH,EACAy2H,EACAC,EACAtvD,GAEApnE,EAAKvM,KAAO2zE,GAKhB4qD,oBAAmB,aACnBG,qBAAoB,aACpBzF,aAAY,aACZiB,cAAa,aACbiH,gBAAiB,KACjB+B,UAAU,EACVpK,QAAQ,EACRruH,WACsB,oBAAXO,SAA0BA,OAAOP,WAClCO,OAAOP,SAEjB04H,WAAY,IAGhB,aAEI,WAAY3iJ,GASR,QATQ,IAAAA,IAAAA,EAAmC,IAG3ClG,OAAO8nB,QAAQ2gI,GAAiBv2I,SAAQ,SAAC,OAAChS,EAAG,KAAEE,EAAK,KAC3CJ,OAAOG,UAAUM,eAAeC,KAAKwF,EAAShG,KAC/CgG,EAAQhG,GAAOE,EAEvB,KAEK8F,EAAQs4I,OAAQ,CACjB,IAAMsK,EAAW,CACb,eACA,kBACA,kBACA,oBACA,gBACA,gBACA,aACA,oBACA,iBACA,iBACA,cACA,gBACA,iBACA,gBACA,SACA,QACA,WACA,WACA,UACA,QACA,cACA,OACA,KACA,OACA,QACA,OACA,aACA,WACA,aACA,UACA,YAEE,EAAgC,CAAC,EACnC5iJ,EAAQ0iJ,SACRE,EAAS52I,SACL,SAAC62I,EAAS3kJ,GAAU,OAAC,EAAW2kJ,GAAW3kJ,CAAvB,IAGxB0kJ,EAAS52I,SAAQ,SAAC62I,GAAY,OAAC,EAAWA,GAAWA,CAAvB,IAElC7iJ,EAAQs4I,OAAS,CACpB,CAEDv3I,KAAKf,QAAUA,EAkBvB,OAfI,YAAAvF,MAAA,SAAMq/B,EAAeigH,GACjB,gBPiHJjgH,EACAigH,EACA/5I,GAEA,OAAO+5I,EAAM5yI,OAAM,SAACsF,GAChB,OAAA0rI,EAAUr+G,EAAMrtB,EAAkBzM,EAAlC,GAER,COxHe8iJ,CAAShpH,EAAMigH,EAAOh5I,KAAKf,UAGtC,YAAA+iJ,KAAA,SAAKjpH,EAAeigH,GAChB,OAAOD,EAAQhgH,EAAMigH,EAAOh5I,KAAKf,UAGrC,YAAAyM,KAAA,SACIkzI,EACAC,GAGA,OADe,IAAIoD,EAAWrD,EAAQC,EAAQ7+I,KAAKf,SACrCqrD,QAErB,CAAD,CA1EA,IC3BA,WAKI,WAAY12C,QAAA,IAAAA,IAAAA,EAAQ,IAApB,IAiCC,OAhCG5T,KAAK+yI,IAAM,OACX/yI,KAAKmW,QAAU,GACfnW,KAAKkiJ,KAAO,EACZliJ,KAAKmiJ,SAAW,GAChB,IAAMC,EAAU,SAACxuI,EAAa3a,GAE1B,IAAMopJ,EAAQzuI,EAAI3a,GAClB2a,EAAI3a,GAAO,+BAUK,SATZ,EASY,iBATZ,MASY,GAAAM,EAAA,GAEZ,EAAK+oJ,IAAIrpJ,EAAK8lB,MAAM7lB,UAAU6N,MAAMtN,KAAKqC,IACzC,IAAM+J,EAASw8I,EAAM3oJ,MAAMka,EAAK9X,GAEhC,OADA,EAAKymJ,KAAKtpJ,EAAK4M,GACRA,CACX,CACJ,EAEA,IAAK,IAAI5M,KAAO2a,EACY,mBAAbA,EAAI3a,IACXmpJ,EAAQxuI,EAAK3a,GAGrB+G,KAAKm4C,IAAI,oBAGb,YAAAmqG,IAAA,SACIrgI,EACAnmB,GAQAkE,KAAKmW,SAAWnW,KAAK+yI,IACrB/yI,KAAKm4C,IAAI,uBAAgBl2B,GAAMnmB,IAGnC,YAAAymJ,KAAA,SACItgI,EACApc,GAQA7F,KAAKm4C,IAAI,+BAAgCtyC,GACzC7F,KAAKmW,QAAUnW,KAAKmW,QAAQ+3D,UACxB,EACAluE,KAAKmW,QAAQzd,OAASsH,KAAK+yI,IAAIr6I,SAIvC,YAAAqI,OAAA,SAAOyK,EAAW02I,GAQd,MAAO,GAAG,OAPD,SAAUzpJ,GAEf,IADA,IAAI+pJ,EAAO,GAAG,OAAA/pJ,GACP+pJ,EAAK9pJ,OAAS,GACjB8pJ,EAAO,WAAI/pJ,GAEf,OAAO+pJ,CACX,CACUC,CAAGP,GAAK,aAAKliJ,KAAKmW,SAAO,OAAG3K,IAG1C,YAAA2sC,IAAA,+BAAW,SAAP,EAAO,iBAAP,MAAO,GAAA5+C,EAAA,GACP,IAAMmpJ,EAAiB,SACnBr3I,GAQA,OAAKA,EAGY,iBAANA,EACAA,EAEPkrI,EAAiBlrI,EAAG,eACZA,EAAkBs3I,WAAa,UAEvCt3I,aAAa0T,MACN,IAAI,OAAA1T,EAAE1K,IAAI+hJ,GAAgBzlJ,KAAK,KAAI,KAEvCoO,EAAErK,YAAcqK,EAAEqrC,WAAa,YAX3B,UAYf,EACMlrC,EAAI1P,EAAK6E,IAAI+hJ,GAAgBzlJ,KAAK,MACxC+C,KAAKmiJ,SAASvgJ,KAAK5B,KAAKe,OAAOyK,EAAGxL,KAAKkiJ,UAI3C,YAAAlhJ,SAAA,WAGI,IAFA,IACI4hJ,EAAa,OACVA,EAAWlqJ,QAAUsH,KAAKmW,QAAQzd,OAASsH,KAAK+yI,IAAIr6I,QACvDkqJ,GAHM,OAKV,IAAIh7I,EAAI5H,KAAKmW,QAIb,OAHAnW,KAAKmW,QAAU,GACfysI,EAAa5iJ,KAAKe,OAAO6hJ,EAAY5iJ,KAAKkiJ,MAC1CliJ,KAAKmW,QAAUvO,EACR,GAAG,OAAA5H,KAAKmiJ,SAASllJ,KAAK,MAAK,aAAK2lJ,GAE/C,CA3HA,mDCSA,IAAIC,EAAmB,WAMrB7iJ,KAAK8iJ,aAAe,EAEpB9iJ,KAAK+iJ,cAAgB,EAErB/iJ,KAAKgjJ,gBAAkB,GAIvBhjJ,KAAKijJ,eAAiB,IAKtBjjJ,KAAKkjJ,sBAAwB,GAE7BljJ,KAAKmjJ,aAAe,EAGpBnjJ,KAAKojJ,cAAgB,EACvB,EAWIC,GAAe,EAanBR,EAAiB3C,KAAO,SAAS98I,EAAIukI,GACnC,MAAO,CAACvkI,EAAIukI,EACd,EAeAkb,EAAiB3pJ,UAAUoqJ,UAAY,SAASC,EAAOC,EAAOC,EAC1DC,QAEyB,IAAhBA,IAEPA,EADE1jJ,KAAK8iJ,cAAgB,EACRhoJ,OAAO6oJ,WAEP,IAAK10F,MAAMunB,UAAgC,IAApBx2E,KAAK8iJ,cAG/C,IAAIc,EAAWF,EAGf,GAAa,MAATH,GAA0B,MAATC,EACnB,MAAM,IAAI7hJ,MAAM,2BAIlB,GAAI4hJ,GAASC,EACX,OAAID,EACK,CAAC,IAAIV,EAAiB3C,KAhDlB,EAgDmCqD,IAEzC,QAGoB,IAAlBE,IACTA,GAAiB,GAEnB,IAAII,EAAaJ,EAGbK,EAAe9jJ,KAAK+jJ,kBAAkBR,EAAOC,GAC7CQ,EAAeT,EAAMr1E,UAAU,EAAG41E,GACtCP,EAAQA,EAAMr1E,UAAU41E,GACxBN,EAAQA,EAAMt1E,UAAU41E,GAGxBA,EAAe9jJ,KAAKikJ,kBAAkBV,EAAOC,GAC7C,IAAIU,EAAeX,EAAMr1E,UAAUq1E,EAAM7qJ,OAASorJ,GAClDP,EAAQA,EAAMr1E,UAAU,EAAGq1E,EAAM7qJ,OAASorJ,GAC1CN,EAAQA,EAAMt1E,UAAU,EAAGs1E,EAAM9qJ,OAASorJ,GAG1C,IAAI9K,EAAQh5I,KAAKmkJ,cAAcZ,EAAOC,EAAOK,EAAYD,GAUzD,OAPII,GACFhL,EAAM5pH,QAAQ,IAAIyzH,EAAiB3C,KA3EtB,EA2EuC8D,IAElDE,GACFlL,EAAMp3I,KAAK,IAAIihJ,EAAiB3C,KA9EnB,EA8EoCgE,IAEnDlkJ,KAAKokJ,kBAAkBpL,GAChBA,CACT,EAeA6J,EAAiB3pJ,UAAUirJ,cAAgB,SAASZ,EAAOC,EAAOK,EAC9DD,GACF,IAAI5K,EAEJ,IAAKuK,EAEH,MAAO,CAAC,IAAIV,EAAiB3C,KAxGf,EAwGiCsD,IAGjD,IAAKA,EAEH,MAAO,CAAC,IAAIX,EAAiB3C,KAAKmD,EAAaE,IAGjD,IAAIc,EAAWd,EAAM7qJ,OAAS8qJ,EAAM9qJ,OAAS6qJ,EAAQC,EACjDc,EAAYf,EAAM7qJ,OAAS8qJ,EAAM9qJ,OAAS8qJ,EAAQD,EAClDxpJ,EAAIsqJ,EAASpqJ,QAAQqqJ,GACzB,IAAU,GAANvqJ,EAUF,OARAi/I,EAAQ,CAAC,IAAI6J,EAAiB3C,KArHhB,EAqHkCmE,EAASn2E,UAAU,EAAGn0E,IAC7D,IAAI8oJ,EAAiB3C,KArHjB,EAqHkCoE,GACtC,IAAIzB,EAAiB3C,KAvHhB,EAwHDmE,EAASn2E,UAAUn0E,EAAIuqJ,EAAU5rJ,UAE1C6qJ,EAAM7qJ,OAAS8qJ,EAAM9qJ,SACvBsgJ,EAAM,GAAG,GAAKA,EAAM,GAAG,GAAKqK,GAEvBrK,EAGT,GAAwB,GAApBsL,EAAU5rJ,OAGZ,MAAO,CAAC,IAAImqJ,EAAiB3C,KAAKmD,EAAaE,GACvC,IAAIV,EAAiB3C,KApIf,EAoIiCsD,IAIjD,IAAIe,EAAKvkJ,KAAKwkJ,gBAAgBjB,EAAOC,GACrC,GAAIe,EAAI,CAEN,IAAIE,EAAUF,EAAG,GACbG,EAAUH,EAAG,GACbI,EAAUJ,EAAG,GACbK,EAAUL,EAAG,GACbM,EAAaN,EAAG,GAEhBO,EAAU9kJ,KAAKsjJ,UAAUmB,EAASE,EAASd,EAAYD,GACvDmB,EAAU/kJ,KAAKsjJ,UAAUoB,EAASE,EAASf,EAAYD,GAE3D,OAAOkB,EAAQ3mI,OAAO,CAAC,IAAI0kI,EAAiB3C,KAnJ/B,EAmJgD2E,IACvCE,EACxB,CAEA,OAAIlB,GAAcN,EAAM7qJ,OAAS,KAAO8qJ,EAAM9qJ,OAAS,IAC9CsH,KAAKglJ,eAAezB,EAAOC,EAAOI,GAGpC5jJ,KAAKilJ,aAAa1B,EAAOC,EAAOI,EACzC,EAaAf,EAAiB3pJ,UAAU8rJ,eAAiB,SAASzB,EAAOC,EAAOI,GAEjE,IAAIzrJ,EAAI6H,KAAKklJ,mBAAmB3B,EAAOC,GACvCD,EAAQprJ,EAAEgtJ,OACV3B,EAAQrrJ,EAAEitJ,OACV,IAAIC,EAAYltJ,EAAEmtJ,UAEdtM,EAAQh5I,KAAKsjJ,UAAUC,EAAOC,GAAO,EAAOI,GAGhD5jJ,KAAKulJ,mBAAmBvM,EAAOqM,GAE/BrlJ,KAAKwlJ,qBAAqBxM,GAI1BA,EAAMp3I,KAAK,IAAIihJ,EAAiB3C,KAzLjB,EAyLkC,KAMjD,IALA,IAAIuF,EAAU,EACVC,EAAe,EACfC,EAAe,EACfC,EAAc,GACdC,EAAc,GACXJ,EAAUzM,EAAMtgJ,QAAQ,CAC7B,OAAQsgJ,EAAMyM,GAAS,IACrB,KAlMY,EAmMVE,IACAE,GAAe7M,EAAMyM,GAAS,GAC9B,MACF,KAAKpC,EACHqC,IACAE,GAAe5M,EAAMyM,GAAS,GAC9B,MACF,KAzMW,EA2MT,GAAIC,GAAgB,GAAKC,GAAgB,EAAG,CAE1C3M,EAAM5gF,OAAOqtF,EAAUC,EAAeC,EACzBD,EAAeC,GAC5BF,EAAUA,EAAUC,EAAeC,EAGnC,IAFA,IAAIG,EACA9lJ,KAAKsjJ,UAAUsC,EAAaC,GAAa,EAAOjC,GAC3ChlD,EAAIknD,EAAQptJ,OAAS,EAAGkmG,GAAK,EAAGA,IACvCo6C,EAAM5gF,OAAOqtF,EAAS,EAAGK,EAAQlnD,IAEnC6mD,GAAoBK,EAAQptJ,MAC9B,CACAitJ,EAAe,EACfD,EAAe,EACfE,EAAc,GACdC,EAAc,GAGlBJ,GACF,CAGA,OAFAzM,EAAM/xI,MAEC+xI,CACT,EAaA6J,EAAiB3pJ,UAAU+rJ,aAAe,SAAS1B,EAAOC,EAAOI,GAW/D,IATA,IAAImC,EAAexC,EAAM7qJ,OACrBstJ,EAAexC,EAAM9qJ,OACrButJ,EAAQrxI,KAAKo/H,MAAM+R,EAAeC,GAAgB,GAClDE,EAAWD,EACXE,EAAW,EAAIF,EACfn6I,EAAK,IAAIiT,MAAMonI,GACfp6I,EAAK,IAAIgT,MAAMonI,GAGVnxI,EAAI,EAAGA,EAAImxI,EAAUnxI,IAC5BlJ,EAAGkJ,IAAM,EACTjJ,EAAGiJ,IAAM,EAEXlJ,EAAGo6I,EAAW,GAAK,EACnBn6I,EAAGm6I,EAAW,GAAK,EAWnB,IAVA,IAAIzsD,EAAQssD,EAAeC,EAGvBI,EAAS3sD,EAAQ,GAAK,EAGtB4sD,EAAU,EACVC,EAAQ,EACRC,EAAU,EACVC,EAAQ,EACHlhI,EAAI,EAAGA,EAAI2gI,MAEd,IAAKh3F,MAAQunB,UAAYotE,GAFJt+H,IAAK,CAO9B,IAAK,IAAImhI,GAAMnhI,EAAI+gI,EAASI,GAAMnhI,EAAIghI,EAAOG,GAAM,EAAG,CASpD,IARA,IAAIC,EAAYR,EAAWO,EAOvBE,GAJFC,EADEH,IAAOnhI,GAAMmhI,GAAMnhI,GAAKxZ,EAAG46I,EAAY,GAAK56I,EAAG46I,EAAY,GACxD56I,EAAG46I,EAAY,GAEf56I,EAAG46I,EAAY,GAAK,GAEbD,EACPG,EAAKb,GAAgBY,EAAKX,GAC1BzC,EAAMzpB,OAAO8sB,IAAOpD,EAAM1pB,OAAO6sB,IACtCC,IACAD,IAGF,GADA76I,EAAG46I,GAAaE,EACZA,EAAKb,EAEPO,GAAS,OACJ,GAAIK,EAAKX,EAEdK,GAAW,OACN,GAAID,EAAO,CAEhB,IADIS,EAAYX,EAAWzsD,EAAQgtD,IAClB,GAAKI,EAAYV,IAA8B,GAAlBp6I,EAAG86I,GAG/C,GAAID,IADAE,EAAKf,EAAeh6I,EAAG86I,IAGzB,OAAO7mJ,KAAK+mJ,kBAAkBxD,EAAOC,EAAOoD,EAAID,EAAI/C,EAG1D,CACF,CAGA,IAAK,IAAIoD,GAAM1hI,EAAIihI,EAASS,GAAM1hI,EAAIkhI,EAAOQ,GAAM,EAAG,CASpD,IARA,IACIF,EADAD,EAAYX,EAAWc,EAOvBC,GAJFH,EADEE,IAAO1hI,GAAM0hI,GAAM1hI,GAAKvZ,EAAG86I,EAAY,GAAK96I,EAAG86I,EAAY,GACxD96I,EAAG86I,EAAY,GAEf96I,EAAG86I,EAAY,GAAK,GAEbG,EACPF,EAAKf,GAAgBkB,EAAKjB,GAC1BzC,EAAMzpB,OAAOisB,EAAee,EAAK,IACjCtD,EAAM1pB,OAAOksB,EAAeiB,EAAK,IACtCH,IACAG,IAGF,GADAl7I,EAAG86I,GAAaC,EACZA,EAAKf,EAEPS,GAAS,OACJ,GAAIS,EAAKjB,EAEdO,GAAW,OACN,IAAKH,EAAO,CAEjB,IADIM,EAAYR,EAAWzsD,EAAQutD,IAClB,GAAKN,EAAYP,IAA8B,GAAlBr6I,EAAG46I,GAAkB,CACjE,IAAIE,EACAD,EAAKT,GADLU,EAAK96I,EAAG46I,IACaA,EAGzB,GAAIE,IADJE,EAAKf,EAAee,GAGlB,OAAO9mJ,KAAK+mJ,kBAAkBxD,EAAOC,EAAOoD,EAAID,EAAI/C,EAExD,CACF,CACF,CACF,CAGA,MAAO,CAAC,IAAIf,EAAiB3C,KAAKmD,EAAaE,GACvC,IAAIV,EAAiB3C,KA7Vb,EA6V+BsD,GACjD,EAcAX,EAAiB3pJ,UAAU6tJ,kBAAoB,SAASxD,EAAOC,EAAOxuI,EAAGC,EACrE2uI,GACF,IAAIsD,EAAS3D,EAAMr1E,UAAU,EAAGl5D,GAC5BmyI,EAAS3D,EAAMt1E,UAAU,EAAGj5D,GAC5BmyI,EAAS7D,EAAMr1E,UAAUl5D,GACzBqyI,EAAS7D,EAAMt1E,UAAUj5D,GAGzB+jI,EAAQh5I,KAAKsjJ,UAAU4D,EAAQC,GAAQ,EAAOvD,GAC9C0D,EAAStnJ,KAAKsjJ,UAAU8D,EAAQC,GAAQ,EAAOzD,GAEnD,OAAO5K,EAAM76H,OAAOmpI,EACtB,EAcAzE,EAAiB3pJ,UAAUgsJ,mBAAqB,SAAS3B,EAAOC,GAC9D,IAAI8B,EAAY,GACZiC,EAAW,CAAC,EAchB,SAASC,EAAwB7f,GAS/B,IARA,IAAIhH,EAAQ,GAIR8mB,EAAY,EACZC,GAAW,EAEXC,EAAkBrC,EAAU5sJ,OACzBgvJ,EAAU/f,EAAKjvI,OAAS,GAAG,EAEhB,IADhBgvJ,EAAU/f,EAAK1tI,QAAQ,KAAMwtJ,MAE3BC,EAAU/f,EAAKjvI,OAAS,GAE1B,IAAI+vD,EAAOk/E,EAAKz5D,UAAUu5E,EAAWC,EAAU,IAE3CH,EAAS/tJ,eAAiB+tJ,EAAS/tJ,eAAeivD,QAC9B56B,IAAnB05H,EAAS9+F,IACZk4E,GAAS9lI,OAAOu/H,aAAamtB,EAAS9+F,KAElCk/F,GAAmBC,IAGrBn/F,EAAOk/E,EAAKz5D,UAAUu5E,GACtBC,EAAU/f,EAAKjvI,QAEjBioI,GAAS9lI,OAAOu/H,aAAautB,GAC7BJ,EAAS9+F,GAAQk/F,EACjBrC,EAAUqC,KAAqBl/F,GAEjCg/F,EAAYC,EAAU,CACxB,CACA,OAAO/mB,CACT,CA3CA2kB,EAAU,GAAK,GA6Cf,IAAIsC,EAAW,IACXzC,EAASqC,EAAwBjE,GAGrC,OAFAqE,EAAW,MAEJ,CAACzC,OAAQA,EAAQC,OADXoC,EAAwBhE,GACG8B,UAAWA,EACrD,EAUAzC,EAAiB3pJ,UAAUqsJ,mBAAqB,SAASvM,EAAOsM,GAC9D,IAAK,IAAIvrJ,EAAI,EAAGA,EAAIi/I,EAAMtgJ,OAAQqB,IAAK,CAGrC,IAFA,IAAI4mI,EAAQqY,EAAMj/I,GAAG,GACjB4tI,EAAO,GACF/oC,EAAI,EAAGA,EAAI+hC,EAAMjoI,OAAQkmG,IAChC+oC,EAAK/oC,GAAK0mD,EAAU3kB,EAAM1lD,WAAW2jB,IAEvCo6C,EAAMj/I,GAAG,GAAK4tI,EAAK1qI,KAAK,GAC1B,CACF,EAUA4lJ,EAAiB3pJ,UAAU6qJ,kBAAoB,SAASR,EAAOC,GAE7D,IAAKD,IAAUC,GAASD,EAAMzpB,OAAO,IAAM0pB,EAAM1pB,OAAO,GACtD,OAAO,EAQT,IAJA,IAAI+tB,EAAa,EACbC,EAAalzI,KAAK/E,IAAI0zI,EAAM7qJ,OAAQ8qJ,EAAM9qJ,QAC1CqvJ,EAAaD,EACbE,EAAe,EACZH,EAAaE,GACdxE,EAAMr1E,UAAU85E,EAAcD,IAC9BvE,EAAMt1E,UAAU85E,EAAcD,GAEhCC,EADAH,EAAaE,EAGbD,EAAaC,EAEfA,EAAanzI,KAAKE,OAAOgzI,EAAaD,GAAc,EAAIA,GAE1D,OAAOE,CACT,EASAlF,EAAiB3pJ,UAAU+qJ,kBAAoB,SAASV,EAAOC,GAE7D,IAAKD,IAAUC,GACXD,EAAMzpB,OAAOypB,EAAM7qJ,OAAS,IAAM8qJ,EAAM1pB,OAAO0pB,EAAM9qJ,OAAS,GAChE,OAAO,EAQT,IAJA,IAAImvJ,EAAa,EACbC,EAAalzI,KAAK/E,IAAI0zI,EAAM7qJ,OAAQ8qJ,EAAM9qJ,QAC1CqvJ,EAAaD,EACbG,EAAa,EACVJ,EAAaE,GACdxE,EAAMr1E,UAAUq1E,EAAM7qJ,OAASqvJ,EAAYxE,EAAM7qJ,OAASuvJ,IAC1DzE,EAAMt1E,UAAUs1E,EAAM9qJ,OAASqvJ,EAAYvE,EAAM9qJ,OAASuvJ,GAE5DA,EADAJ,EAAaE,EAGbD,EAAaC,EAEfA,EAAanzI,KAAKE,OAAOgzI,EAAaD,GAAc,EAAIA,GAE1D,OAAOE,CACT,EAWAlF,EAAiB3pJ,UAAUgvJ,oBAAsB,SAAS3E,EAAOC,GAE/D,IAAIuC,EAAexC,EAAM7qJ,OACrBstJ,EAAexC,EAAM9qJ,OAEzB,GAAoB,GAAhBqtJ,GAAqC,GAAhBC,EACvB,OAAO,EAGLD,EAAeC,EACjBzC,EAAQA,EAAMr1E,UAAU63E,EAAeC,GAC9BD,EAAeC,IACxBxC,EAAQA,EAAMt1E,UAAU,EAAG63E,IAE7B,IAAIoC,EAAcvzI,KAAK/E,IAAIk2I,EAAcC,GAEzC,GAAIzC,GAASC,EACX,OAAO2E,EAQT,IAFA,IAAIC,EAAO,EACP1vJ,EAAS,IACA,CACX,IAAI2vJ,EAAU9E,EAAMr1E,UAAUi6E,EAAczvJ,GACxC4vJ,EAAQ9E,EAAMvpJ,QAAQouJ,GAC1B,IAAc,GAAVC,EACF,OAAOF,EAET1vJ,GAAU4vJ,EACG,GAATA,GAAc/E,EAAMr1E,UAAUi6E,EAAczvJ,IAC5C8qJ,EAAMt1E,UAAU,EAAGx1E,KACrB0vJ,EAAO1vJ,EACPA,IAEJ,CACF,EAcAmqJ,EAAiB3pJ,UAAUsrJ,gBAAkB,SAASjB,EAAOC,GAC3D,GAAIxjJ,KAAK8iJ,cAAgB,EAEvB,OAAO,KAET,IAAIuB,EAAWd,EAAM7qJ,OAAS8qJ,EAAM9qJ,OAAS6qJ,EAAQC,EACjDc,EAAYf,EAAM7qJ,OAAS8qJ,EAAM9qJ,OAAS8qJ,EAAQD,EACtD,GAAIc,EAAS3rJ,OAAS,GAAwB,EAAnB4rJ,EAAU5rJ,OAAa2rJ,EAAS3rJ,OACzD,OAAO,KAET,IAAI6vJ,EAAMvoJ,KAcV,SAASwoJ,EAAiBnE,EAAUC,EAAWvqJ,GAM7C,IAJA,IAGI0uJ,EAAiBC,EAAiBC,EAAkBC,EAHpDC,EAAOxE,EAASn2E,UAAUn0E,EAAGA,EAAI6a,KAAKE,MAAMuvI,EAAS3rJ,OAAS,IAC9DkmG,GAAK,EACLkqD,EAAc,IAE8B,IAAxClqD,EAAI0lD,EAAUrqJ,QAAQ4uJ,EAAMjqD,EAAI,KAAW,CACjD,IAAImqD,EAAeR,EAAIxE,kBAAkBM,EAASn2E,UAAUn0E,GACnBuqJ,EAAUp2E,UAAU0wB,IACzDoqD,EAAeT,EAAItE,kBAAkBI,EAASn2E,UAAU,EAAGn0E,GACtBuqJ,EAAUp2E,UAAU,EAAG0wB,IAC5DkqD,EAAYpwJ,OAASswJ,EAAeD,IACtCD,EAAcxE,EAAUp2E,UAAU0wB,EAAIoqD,EAAcpqD,GAChD0lD,EAAUp2E,UAAU0wB,EAAGA,EAAImqD,GAC/BN,EAAkBpE,EAASn2E,UAAU,EAAGn0E,EAAIivJ,GAC5CN,EAAkBrE,EAASn2E,UAAUn0E,EAAIgvJ,GACzCJ,EAAmBrE,EAAUp2E,UAAU,EAAG0wB,EAAIoqD,GAC9CJ,EAAmBtE,EAAUp2E,UAAU0wB,EAAImqD,GAE/C,CACA,OAAyB,EAArBD,EAAYpwJ,QAAc2rJ,EAAS3rJ,OAC9B,CAAC+vJ,EAAiBC,EACjBC,EAAkBC,EAAkBE,GAErC,IAEX,CAGA,IAKIvE,EAaAE,EAASC,EAASC,EAASC,EAlB3BqE,EAAMT,EAAiBnE,EAAUC,EACV1vI,KAAKo/H,KAAKqQ,EAAS3rJ,OAAS,IAEnDwwJ,EAAMV,EAAiBnE,EAAUC,EACV1vI,KAAKo/H,KAAKqQ,EAAS3rJ,OAAS,IAEvD,OAAKuwJ,GAAQC,GAQX3E,EANU2E,EAEAD,GAILA,EAAI,GAAGvwJ,OAASwwJ,EAAI,GAAGxwJ,OAASuwJ,EAHhCC,EAFAD,EAUH1F,EAAM7qJ,OAAS8qJ,EAAM9qJ,QACvB+rJ,EAAUF,EAAG,GACbG,EAAUH,EAAG,GACbI,EAAUJ,EAAG,GACbK,EAAUL,EAAG,KAEbI,EAAUJ,EAAG,GACbK,EAAUL,EAAG,GACbE,EAAUF,EAAG,GACbG,EAAUH,EAAG,IAGR,CAACE,EAASC,EAASC,EAASC,EADlBL,EAAG,KAvBX,IAyBX,EAOA1B,EAAiB3pJ,UAAUssJ,qBAAuB,SAASxM,GAczD,IAbA,IAAImQ,GAAU,EACVC,EAAa,GACbC,EAAmB,EAEnBC,EAAe,KAEf7D,EAAU,EAEV8D,EAAqB,EACrBC,EAAoB,EAEpBC,EAAqB,EACrBC,EAAoB,EACjBjE,EAAUzM,EAAMtgJ,QAzrBR,GA0rBTsgJ,EAAMyM,GAAS,IACjB2D,EAAWC,KAAsB5D,EACjC8D,EAAqBE,EACrBD,EAAoBE,EACpBD,EAAqB,EACrBC,EAAoB,EACpBJ,EAAetQ,EAAMyM,GAAS,KAjsBlB,GAmsBRzM,EAAMyM,GAAS,GACjBgE,GAAsBzQ,EAAMyM,GAAS,GAAG/sJ,OAExCgxJ,GAAqB1Q,EAAMyM,GAAS,GAAG/sJ,OAIrC4wJ,GAAiBA,EAAa5wJ,QAC9Bkc,KAAK7X,IAAIwsJ,EAAoBC,IAC5BF,EAAa5wJ,QAAUkc,KAAK7X,IAAI0sJ,EACAC,KAEnC1Q,EAAM5gF,OAAOgxF,EAAWC,EAAmB,GAAI,EAClC,IAAIxG,EAAiB3C,KAAKmD,EAAaiG,IAEpDtQ,EAAMoQ,EAAWC,EAAmB,GAAK,GAAG,GAltBlC,EAotBVA,IAGA5D,IADA4D,EAC6B,EAAID,EAAWC,EAAmB,IAAM,EACrEE,EAAqB,EACrBC,EAAoB,EACpBC,EAAqB,EACrBC,EAAoB,EACpBJ,EAAe,KACfH,GAAU,IAGd1D,IAgBF,IAZI0D,GACFnpJ,KAAKokJ,kBAAkBpL,GAEzBh5I,KAAK2pJ,6BAA6B3Q,GAQlCyM,EAAU,EACHA,EAAUzM,EAAMtgJ,QAAQ,CAC7B,GAAIsgJ,EAAMyM,EAAU,GAAG,IAAMpC,GAjvBf,GAkvBVrK,EAAMyM,GAAS,GAAmB,CACpC,IAAImE,EAAW5Q,EAAMyM,EAAU,GAAG,GAC9BoE,EAAY7Q,EAAMyM,GAAS,GAC3BqE,EAAkB9pJ,KAAKkoJ,oBAAoB0B,EAAUC,GACrDE,EAAkB/pJ,KAAKkoJ,oBAAoB2B,EAAWD,GACtDE,GAAmBC,GACjBD,GAAmBF,EAASlxJ,OAAS,GACrCoxJ,GAAmBD,EAAUnxJ,OAAS,KAExCsgJ,EAAM5gF,OAAOqtF,EAAS,EAAG,IAAI5C,EAAiB3C,KA1vBvC,EA2vBH2J,EAAU37E,UAAU,EAAG47E,KAC3B9Q,EAAMyM,EAAU,GAAG,GACfmE,EAAS17E,UAAU,EAAG07E,EAASlxJ,OAASoxJ,GAC5C9Q,EAAMyM,EAAU,GAAG,GAAKoE,EAAU37E,UAAU47E,GAC5CrE,MAGEsE,GAAmBH,EAASlxJ,OAAS,GACrCqxJ,GAAmBF,EAAUnxJ,OAAS,KAGxCsgJ,EAAM5gF,OAAOqtF,EAAS,EAAG,IAAI5C,EAAiB3C,KAtwBvC,EAuwBH0J,EAAS17E,UAAU,EAAG67E,KAC1B/Q,EAAMyM,EAAU,GAAG,GAzwBX,EA0wBRzM,EAAMyM,EAAU,GAAG,GACfoE,EAAU37E,UAAU,EAAG27E,EAAUnxJ,OAASqxJ,GAC9C/Q,EAAMyM,EAAU,GAAG,GAAKpC,EACxBrK,EAAMyM,EAAU,GAAG,GACfmE,EAAS17E,UAAU67E,GACvBtE,KAGJA,GACF,CACAA,GACF,CACF,EASA5C,EAAiB3pJ,UAAUywJ,6BAA+B,SAAS3Q,GAWjE,SAASgR,EAA2BC,EAAKC,GACvC,IAAKD,IAAQC,EAEX,OAAO,EAQT,IAAIC,EAAQF,EAAInwB,OAAOmwB,EAAIvxJ,OAAS,GAChC0xJ,EAAQF,EAAIpwB,OAAO,GACnBuwB,EAAmBF,EAAMhqJ,MAAM0iJ,EAAiByH,uBAChDC,EAAmBH,EAAMjqJ,MAAM0iJ,EAAiByH,uBAChDE,EAAcH,GACdF,EAAMhqJ,MAAM0iJ,EAAiB4H,kBAC7BC,EAAcH,GACdH,EAAMjqJ,MAAM0iJ,EAAiB4H,kBAC7BE,EAAaH,GACbL,EAAMhqJ,MAAM0iJ,EAAiB+H,iBAC7BC,EAAaH,GACbN,EAAMjqJ,MAAM0iJ,EAAiB+H,iBAC7BE,EAAaH,GACbV,EAAI9pJ,MAAM0iJ,EAAiBkI,oBAC3BC,EAAaH,GACbX,EAAI/pJ,MAAM0iJ,EAAiBoI,sBAE/B,OAAIH,GAAcE,EAET,EACEL,GAAcE,EAEhB,EACER,IAAqBG,GAAeE,EAEtC,EACEF,GAAeE,EAEjB,EACEL,GAAoBE,EAEtB,EAEF,CACT,CAIA,IAFA,IAAI9E,EAAU,EAEPA,EAAUzM,EAAMtgJ,OAAS,GAAG,CACjC,GA31Ba,GA21BTsgJ,EAAMyM,EAAU,GAAG,IA31BV,GA41BTzM,EAAMyM,EAAU,GAAG,GAAkB,CAEvC,IAAIyF,EAAYlS,EAAMyM,EAAU,GAAG,GAC/B0F,EAAOnS,EAAMyM,GAAS,GACtB2F,EAAYpS,EAAMyM,EAAU,GAAG,GAG/B4F,EAAerrJ,KAAKikJ,kBAAkBiH,EAAWC,GACrD,GAAIE,EAAc,CAChB,IAAIC,EAAeH,EAAKj9E,UAAUi9E,EAAKzyJ,OAAS2yJ,GAChDH,EAAYA,EAAUh9E,UAAU,EAAGg9E,EAAUxyJ,OAAS2yJ,GACtDF,EAAOG,EAAeH,EAAKj9E,UAAU,EAAGi9E,EAAKzyJ,OAAS2yJ,GACtDD,EAAYE,EAAeF,CAC7B,CAQA,IALA,IAAIG,EAAgBL,EAChBM,EAAWL,EACXM,EAAgBL,EAChBM,EAAY1B,EAA2BkB,EAAWC,GAClDnB,EAA2BmB,EAAMC,GAC9BD,EAAKrxB,OAAO,KAAOsxB,EAAUtxB,OAAO,IAAI,CAC7CoxB,GAAaC,EAAKrxB,OAAO,GACzBqxB,EAAOA,EAAKj9E,UAAU,GAAKk9E,EAAUtxB,OAAO,GAC5CsxB,EAAYA,EAAUl9E,UAAU,GAChC,IAAIy9E,EAAQ3B,EAA2BkB,EAAWC,GAC9CnB,EAA2BmB,EAAMC,GAEjCO,GAASD,IACXA,EAAYC,EACZJ,EAAgBL,EAChBM,EAAWL,EACXM,EAAgBL,EAEpB,CAEIpS,EAAMyM,EAAU,GAAG,IAAM8F,IAEvBA,EACFvS,EAAMyM,EAAU,GAAG,GAAK8F,GAExBvS,EAAM5gF,OAAOqtF,EAAU,EAAG,GAC1BA,KAEFzM,EAAMyM,GAAS,GAAK+F,EAChBC,EACFzS,EAAMyM,EAAU,GAAG,GAAKgG,GAExBzS,EAAM5gF,OAAOqtF,EAAU,EAAG,GAC1BA,KAGN,CACAA,GACF,CACF,EAGA5C,EAAiByH,sBAAwB,eACzCzH,EAAiB4H,iBAAmB,KACpC5H,EAAiB+H,gBAAkB,SACnC/H,EAAiBkI,mBAAqB,WACtClI,EAAiBoI,qBAAuB,cAMxCpI,EAAiB3pJ,UAAU0yJ,uBAAyB,SAAS5S,GAgB3D,IAfA,IAAImQ,GAAU,EACVC,EAAa,GACbC,EAAmB,EAEnBC,EAAe,KAEf7D,EAAU,EAEVoG,GAAU,EAEVC,GAAU,EAEVC,GAAW,EAEXC,GAAW,EACRvG,EAAUzM,EAAMtgJ,QAh7BR,GAi7BTsgJ,EAAMyM,GAAS,IACbzM,EAAMyM,GAAS,GAAG/sJ,OAASsH,KAAK+iJ,gBAC/BgJ,GAAYC,IAEf5C,EAAWC,KAAsB5D,EACjCoG,EAAUE,EACVD,EAAUE,EACV1C,EAAetQ,EAAMyM,GAAS,KAG9B4D,EAAmB,EACnBC,EAAe,MAEjByC,EAAWC,GAAW,IAElBhT,EAAMyM,GAAS,IAAMpC,EACvB2I,GAAW,EAEXD,GAAW,EAUTzC,IAAkBuC,GAAWC,GAAWC,GAAYC,GACjC1C,EAAa5wJ,OAASsH,KAAK+iJ,cAAgB,GAC3C8I,EAAUC,EAAUC,EAAWC,GAAa,KAEjEhT,EAAM5gF,OAAOgxF,EAAWC,EAAmB,GAAI,EAClC,IAAIxG,EAAiB3C,KAAKmD,EAAaiG,IAEpDtQ,EAAMoQ,EAAWC,EAAmB,GAAK,GAAG,GAr9BlC,EAs9BVA,IACAC,EAAe,KACXuC,GAAWC,GAEbC,EAAWC,GAAW,EACtB3C,EAAmB,IAGnB5D,IADA4D,EAC6B,EACzBD,EAAWC,EAAmB,IAAM,EACxC0C,EAAWC,GAAW,GAExB7C,GAAU,IAGd1D,IAGE0D,GACFnpJ,KAAKokJ,kBAAkBpL,EAE3B,EAQA6J,EAAiB3pJ,UAAUkrJ,kBAAoB,SAASpL,GAEtDA,EAAMp3I,KAAK,IAAIihJ,EAAiB3C,KAp/BjB,EAo/BkC,KAOjD,IANA,IAKI4D,EALA2B,EAAU,EACVC,EAAe,EACfC,EAAe,EACfC,EAAc,GACdC,EAAc,GAEXJ,EAAUzM,EAAMtgJ,QACrB,OAAQsgJ,EAAMyM,GAAS,IACrB,KA9/BY,EA+/BVE,IACAE,GAAe7M,EAAMyM,GAAS,GAC9BA,IACA,MACF,KAAKpC,EACHqC,IACAE,GAAe5M,EAAMyM,GAAS,GAC9BA,IACA,MACF,KAvgCW,EAygCLC,EAAeC,EAAe,GACX,IAAjBD,GAAuC,IAAjBC,IAGH,KADrB7B,EAAe9jJ,KAAK+jJ,kBAAkB8B,EAAaD,MAE5CH,EAAUC,EAAeC,EAAgB,GA9gC3C,GA+gCC3M,EAAMyM,EAAUC,EAAeC,EAAe,GAAG,GAEnD3M,EAAMyM,EAAUC,EAAeC,EAAe,GAAG,IAC7CE,EAAY33E,UAAU,EAAG41E,IAE7B9K,EAAM5gF,OAAO,EAAG,EAAG,IAAIyqF,EAAiB3C,KAphCvC,EAqhCG2F,EAAY33E,UAAU,EAAG41E,KAC7B2B,KAEFI,EAAcA,EAAY33E,UAAU41E,GACpC8B,EAAcA,EAAY13E,UAAU41E,IAIjB,KADrBA,EAAe9jJ,KAAKikJ,kBAAkB4B,EAAaD,MAEjD5M,EAAMyM,GAAS,GAAKI,EAAY33E,UAAU23E,EAAYntJ,OAClDorJ,GAAgB9K,EAAMyM,GAAS,GACnCI,EAAcA,EAAY33E,UAAU,EAAG23E,EAAYntJ,OAC/CorJ,GACJ8B,EAAcA,EAAY13E,UAAU,EAAG03E,EAAYltJ,OAC/CorJ,KAIR2B,GAAWC,EAAeC,EAC1B3M,EAAM5gF,OAAOqtF,EAASC,EAAeC,GACjCC,EAAYltJ,SACdsgJ,EAAM5gF,OAAOqtF,EAAS,EAClB,IAAI5C,EAAiB3C,KAAKmD,EAAauC,IAC3CH,KAEEI,EAAYntJ,SACdsgJ,EAAM5gF,OAAOqtF,EAAS,EAClB,IAAI5C,EAAiB3C,KAjjCnB,EAijCqC2F,IAC3CJ,KAEFA,KACqB,IAAZA,GApjCF,GAojCmBzM,EAAMyM,EAAU,GAAG,IAE7CzM,EAAMyM,EAAU,GAAG,IAAMzM,EAAMyM,GAAS,GACxCzM,EAAM5gF,OAAOqtF,EAAS,IAEtBA,IAEFE,EAAe,EACfD,EAAe,EACfE,EAAc,GACdC,EAAc,GAIe,KAA/B7M,EAAMA,EAAMtgJ,OAAS,GAAG,IAC1BsgJ,EAAM/xI,MAMR,IAAIkiJ,GAAU,EAGd,IAFA1D,EAAU,EAEHA,EAAUzM,EAAMtgJ,OAAS,GA5kCjB,GA6kCTsgJ,EAAMyM,EAAU,GAAG,IA7kCV,GA8kCTzM,EAAMyM,EAAU,GAAG,KAEjBzM,EAAMyM,GAAS,GAAGv3E,UAAU8qE,EAAMyM,GAAS,GAAG/sJ,OAC9CsgJ,EAAMyM,EAAU,GAAG,GAAG/sJ,SAAWsgJ,EAAMyM,EAAU,GAAG,IAEtDzM,EAAMyM,GAAS,GAAKzM,EAAMyM,EAAU,GAAG,GACnCzM,EAAMyM,GAAS,GAAGv3E,UAAU,EAAG8qE,EAAMyM,GAAS,GAAG/sJ,OACrBsgJ,EAAMyM,EAAU,GAAG,GAAG/sJ,QACtDsgJ,EAAMyM,EAAU,GAAG,GAAKzM,EAAMyM,EAAU,GAAG,GAAKzM,EAAMyM,EAAU,GAAG,GACnEzM,EAAM5gF,OAAOqtF,EAAU,EAAG,GAC1B0D,GAAU,GACDnQ,EAAMyM,GAAS,GAAGv3E,UAAU,EAAG8qE,EAAMyM,EAAU,GAAG,GAAG/sJ,SAC5DsgJ,EAAMyM,EAAU,GAAG,KAErBzM,EAAMyM,EAAU,GAAG,IAAMzM,EAAMyM,EAAU,GAAG,GAC5CzM,EAAMyM,GAAS,GACXzM,EAAMyM,GAAS,GAAGv3E,UAAU8qE,EAAMyM,EAAU,GAAG,GAAG/sJ,QAClDsgJ,EAAMyM,EAAU,GAAG,GACvBzM,EAAM5gF,OAAOqtF,EAAU,EAAG,GAC1B0D,GAAU,IAGd1D,IAGE0D,GACFnpJ,KAAKokJ,kBAAkBpL,EAE3B,EAWA6J,EAAiB3pJ,UAAU+yJ,YAAc,SAASjT,EAAOkT,GACvD,IAIIl3I,EAJAmwI,EAAS,EACTC,EAAS,EACT+G,EAAc,EACdC,EAAc,EAElB,IAAKp3I,EAAI,EAAGA,EAAIgkI,EAAMtgJ,SA5nCN,IA6nCVsgJ,EAAMhkI,GAAG,KACXmwI,GAAUnM,EAAMhkI,GAAG,GAAGtc,QAEpBsgJ,EAAMhkI,GAAG,KAAOquI,IAClB+B,GAAUpM,EAAMhkI,GAAG,GAAGtc,UAEpBysJ,EAAS+G,IAPel3I,IAU5Bm3I,EAAchH,EACdiH,EAAchH,EAGhB,OAAIpM,EAAMtgJ,QAAUsc,GAAKgkI,EAAMhkI,GAAG,KAAOquI,EAChC+I,EAGFA,GAAeF,EAAMC,EAC9B,EAQAtJ,EAAiB3pJ,UAAUmzJ,gBAAkB,SAASrT,GAMpD,IALA,IAAIx9H,EAAO,GACP8wI,EAAc,KACdC,EAAa,KACbC,EAAa,KACbC,EAAe,MACVz3I,EAAI,EAAGA,EAAIgkI,EAAMtgJ,OAAQsc,IAAK,CACrC,IAAI5R,EAAK41I,EAAMhkI,GAAG,GAEd2yH,EADOqR,EAAMhkI,GAAG,GACJrR,QAAQ2oJ,EAAa,SAAS3oJ,QAAQ4oJ,EAAY,QAC7D5oJ,QAAQ6oJ,EAAY,QAAQ7oJ,QAAQ8oJ,EAAc,cACvD,OAAQrpJ,GACN,KAnqCY,EAoqCVoY,EAAKxG,GAAK,oCAAsC2yH,EAAO,SACvD,MACF,KAAK0b,EACH7nI,EAAKxG,GAAK,oCAAsC2yH,EAAO,SACvD,MACF,KAxqCW,EAyqCTnsH,EAAKxG,GAAK,SAAW2yH,EAAO,UAGlC,CACA,OAAOnsH,EAAKve,KAAK,GACnB,EAQA4lJ,EAAiB3pJ,UAAUwzJ,WAAa,SAAS1T,GAE/C,IADA,IAAIrR,EAAO,GACF3yH,EAAI,EAAGA,EAAIgkI,EAAMtgJ,OAAQsc,IAzrClB,IA0rCVgkI,EAAMhkI,GAAG,KACX2yH,EAAK3yH,GAAKgkI,EAAMhkI,GAAG,IAGvB,OAAO2yH,EAAK1qI,KAAK,GACnB,EAQA4lJ,EAAiB3pJ,UAAUyzJ,WAAa,SAAS3T,GAE/C,IADA,IAAIrR,EAAO,GACF3yH,EAAI,EAAGA,EAAIgkI,EAAMtgJ,OAAQsc,IAC5BgkI,EAAMhkI,GAAG,KAAOquI,IAClB1b,EAAK3yH,GAAKgkI,EAAMhkI,GAAG,IAGvB,OAAO2yH,EAAK1qI,KAAK,GACnB,EASA4lJ,EAAiB3pJ,UAAU0zJ,iBAAmB,SAAS5T,GAIrD,IAHA,IAAI6T,EAAc,EACdC,EAAa,EACbC,EAAY,EACP/3I,EAAI,EAAGA,EAAIgkI,EAAMtgJ,OAAQsc,IAAK,CACrC,IAAI5R,EAAK41I,EAAMhkI,GAAG,GACdyJ,EAAOu6H,EAAMhkI,GAAG,GACpB,OAAQ5R,GACN,KAhuCY,EAiuCV0pJ,GAAcruI,EAAK/lB,OACnB,MACF,KAAK2qJ,EACH0J,GAAatuI,EAAK/lB,OAClB,MACF,KAruCW,EAuuCTm0J,GAAej4I,KAAK7X,IAAI+vJ,EAAYC,GACpCD,EAAa,EACbC,EAAY,EAGlB,CAEA,OADAF,GAAej4I,KAAK7X,IAAI+vJ,EAAYC,EAEtC,EAWAlK,EAAiB3pJ,UAAU8zJ,aAAe,SAAShU,GAEjD,IADA,IAAIrR,EAAO,GACF3yH,EAAI,EAAGA,EAAIgkI,EAAMtgJ,OAAQsc,IAChC,OAAQgkI,EAAMhkI,GAAG,IACf,KA/vCY,EAgwCV2yH,EAAK3yH,GAAK,IAAMu2D,UAAUytE,EAAMhkI,GAAG,IACnC,MACF,KAAKquI,EACH1b,EAAK3yH,GAAK,IAAMgkI,EAAMhkI,GAAG,GAAGtc,OAC5B,MACF,KApwCW,EAqwCTivI,EAAK3yH,GAAK,IAAMgkI,EAAMhkI,GAAG,GAAGtc,OAIlC,OAAOivI,EAAK1qI,KAAK,MAAM0G,QAAQ,OAAQ,IACzC,EAWAk/I,EAAiB3pJ,UAAU+zJ,eAAiB,SAAS1J,EAAO9pD,GAK1D,IAJA,IAAIu/C,EAAQ,GACRkU,EAAc,EACdzH,EAAU,EACVryI,EAASqmF,EAAMz8F,MAAM,OAChBgY,EAAI,EAAGA,EAAI5B,EAAO1a,OAAQsc,IAAK,CAGtC,IAAIU,EAAQtC,EAAO4B,GAAGk5D,UAAU,GAChC,OAAQ96D,EAAO4B,GAAG8kH,OAAO,IACvB,IAAK,IACH,IACEkf,EAAMkU,KACF,IAAIrK,EAAiB3C,KAnyCjB,EAmyCmCiN,UAAUz3I,GACvD,CAAE,MAAO+nC,GAEP,MAAM,IAAI97C,MAAM,qCAAuC+T,EACzD,CACA,MACF,IAAK,IAEL,IAAK,IACH,IAAItd,EAAI83B,SAASxa,EAAO,IACxB,GAAI7T,MAAMzJ,IAAMA,EAAI,EAClB,MAAM,IAAIuJ,MAAM,qCAAuC+T,GAEzD,IAAIiyH,EAAO4b,EAAMr1E,UAAUu3E,EAASA,GAAWrtJ,GACpB,KAAvBgb,EAAO4B,GAAG8kH,OAAO,GACnBkf,EAAMkU,KAAiB,IAAIrK,EAAiB3C,KAjzCrC,EAizCsDvY,GAE7DqR,EAAMkU,KAAiB,IAAIrK,EAAiB3C,KAAKmD,EAAa1b,GAEhE,MACF,QAGE,GAAIv0H,EAAO4B,GACT,MAAM,IAAIrT,MAAM,6CACAyR,EAAO4B,IAG/B,CACA,GAAIywI,GAAWlC,EAAM7qJ,OACnB,MAAM,IAAIiJ,MAAM,iBAAmB8jJ,EAC/B,wCAA0ClC,EAAM7qJ,OAAS,MAE/D,OAAOsgJ,CACT,EAaA6J,EAAiB3pJ,UAAUk0J,WAAa,SAASzlB,EAAM0gB,EAAS6D,GAE9D,GAAY,MAARvkB,GAA2B,MAAX0gB,GAA0B,MAAP6D,EACrC,MAAM,IAAIvqJ,MAAM,4BAIlB,OADAuqJ,EAAMt3I,KAAK7X,IAAI,EAAG6X,KAAK/E,IAAIq8I,EAAKvkB,EAAKjvI,SACjCivI,GAAQ0gB,EAEH,EACG1gB,EAAKjvI,OAGNivI,EAAKz5D,UAAUg+E,EAAKA,EAAM7D,EAAQ3vJ,SAAW2vJ,EAE/C6D,EAGAlsJ,KAAKqtJ,aAAa1lB,EAAM0gB,EAAS6D,IANhC,CAQZ,EAYArJ,EAAiB3pJ,UAAUm0J,aAAe,SAAS1lB,EAAM0gB,EAAS6D,GAChE,GAAI7D,EAAQ3vJ,OAASsH,KAAKojJ,cACxB,MAAM,IAAIzhJ,MAAM,sCAIlB,IAAI6J,EAAIxL,KAAKstJ,gBAAgBjF,GAEzBE,EAAMvoJ,KAUV,SAASutJ,EAAkBv1J,EAAGgd,GAC5B,IAAIw4I,EAAWx1J,EAAIqwJ,EAAQ3vJ,OACvB+0J,EAAY74I,KAAKqkF,IAAIizD,EAAMl3I,GAC/B,OAAKuzI,EAAItF,eAIFuK,EAAYC,EAAYlF,EAAItF,eAF1BwK,EAAY,EAAMD,CAG7B,CAGA,IAAIE,EAAkB1tJ,KAAKgjJ,gBAEvB2K,EAAWhmB,EAAK1tI,QAAQouJ,EAAS6D,IACpB,GAAbyB,IACFD,EAAkB94I,KAAK/E,IAAI09I,EAAkB,EAAGI,GAAWD,IAG1C,IADjBC,EAAWhmB,EAAKimB,YAAYvF,EAAS6D,EAAM7D,EAAQ3vJ,WAEjDg1J,EACI94I,KAAK/E,IAAI09I,EAAkB,EAAGI,GAAWD,KAKjD,IAGIG,EAASC,EAHTC,EAAY,GAAM1F,EAAQ3vJ,OAAS,EACvCi1J,GAAY,EAKZ,IAFA,IACIK,EADAC,EAAU5F,EAAQ3vJ,OAASivI,EAAKjvI,OAE3B4sB,EAAI,EAAGA,EAAI+iI,EAAQ3vJ,OAAQ4sB,IAAK,CAMvC,IAFAuoI,EAAU,EACVC,EAAUG,EACHJ,EAAUC,GACXP,EAAkBjoI,EAAG4mI,EAAM4B,IAAYJ,EACzCG,EAAUC,EAEVG,EAAUH,EAEZA,EAAUl5I,KAAKE,OAAOm5I,EAAUJ,GAAW,EAAIA,GAGjDI,EAAUH,EACV,IAAIv5I,EAAQK,KAAK7X,IAAI,EAAGmvJ,EAAM4B,EAAU,GACpCI,EAASt5I,KAAK/E,IAAIq8I,EAAM4B,EAASnmB,EAAKjvI,QAAU2vJ,EAAQ3vJ,OAExDy1J,EAAKpvI,MAAMmvI,EAAS,GACxBC,EAAGD,EAAS,IAAM,GAAK5oI,GAAK,EAC5B,IAAK,IAAIs5E,EAAIsvD,EAAQtvD,GAAKrqF,EAAOqqF,IAAK,CAGpC,IAAIwvD,EAAY5iJ,EAAEm8H,EAAK7N,OAAOl7B,EAAI,IAQlC,GANEuvD,EAAGvvD,GADK,IAANt5E,GACQ6oI,EAAGvvD,EAAI,IAAM,EAAK,GAAKwvD,GAEtBD,EAAGvvD,EAAI,IAAM,EAAK,GAAKwvD,GACvBJ,EAAQpvD,EAAI,GAAKovD,EAAQpvD,KAAO,EAAK,EACxCovD,EAAQpvD,EAAI,GAElBuvD,EAAGvvD,GAAKmvD,EAAW,CACrB,IAAIpC,EAAQ4B,EAAkBjoI,EAAGs5E,EAAI,GAGrC,GAAI+sD,GAAS+B,EAAiB,CAI5B,GAFAA,EAAkB/B,KAClBgC,EAAW/uD,EAAI,GACAstD,GAKb,MAHA33I,EAAQK,KAAK7X,IAAI,EAAG,EAAImvJ,EAAMyB,EAKlC,CACF,CACF,CAEA,GAAIJ,EAAkBjoI,EAAI,EAAG4mI,GAAOwB,EAClC,MAEFM,EAAUG,CACZ,CACA,OAAOR,CACT,EASA9K,EAAiB3pJ,UAAUo0J,gBAAkB,SAASjF,GAEpD,IADA,IAAI78I,EAAI,CAAC,EACAzR,EAAI,EAAGA,EAAIsuJ,EAAQ3vJ,OAAQqB,IAClCyR,EAAE68I,EAAQvuB,OAAO//H,IAAM,EAEzB,IAASA,EAAI,EAAGA,EAAIsuJ,EAAQ3vJ,OAAQqB,IAClCyR,EAAE68I,EAAQvuB,OAAO//H,KAAO,GAAMsuJ,EAAQ3vJ,OAASqB,EAAI,EAErD,OAAOyR,CACT,EAaAq3I,EAAiB3pJ,UAAUm1J,kBAAoB,SAAS5tJ,EAAOknI,GAC7D,GAAmB,GAAfA,EAAKjvI,OAAT,CAGA,GAAqB,OAAjB+H,EAAM6tJ,OACR,MAAM3sJ,MAAM,yBAOd,IALA,IAAI0mJ,EAAU1gB,EAAKz5D,UAAUztE,EAAM6tJ,OAAQ7tJ,EAAM6tJ,OAAS7tJ,EAAM8tJ,SAC5Dp4I,EAAU,EAIPwxH,EAAK1tI,QAAQouJ,IAAY1gB,EAAKimB,YAAYvF,IAC1CA,EAAQ3vJ,OAASsH,KAAKojJ,cAAgBpjJ,KAAKmjJ,aAC3CnjJ,KAAKmjJ,cACVhtI,GAAWnW,KAAKmjJ,aAChBkF,EAAU1gB,EAAKz5D,UAAUztE,EAAM6tJ,OAASn4I,EACf1V,EAAM6tJ,OAAS7tJ,EAAM8tJ,QAAUp4I,GAG1DA,GAAWnW,KAAKmjJ,aAGhB,IAAI92I,EAASs7H,EAAKz5D,UAAUztE,EAAM6tJ,OAASn4I,EAAS1V,EAAM6tJ,QACtDjiJ,GACF5L,EAAMu4I,MAAM5pH,QAAQ,IAAIyzH,EAAiB3C,KAnhD5B,EAmhD6C7zI,IAG5D,IAAImiJ,EAAS7mB,EAAKz5D,UAAUztE,EAAM6tJ,OAAS7tJ,EAAM8tJ,QACrB9tJ,EAAM6tJ,OAAS7tJ,EAAM8tJ,QAAUp4I,GACvDq4I,GACF/tJ,EAAMu4I,MAAMp3I,KAAK,IAAIihJ,EAAiB3C,KAzhDzB,EAyhD0CsO,IAIzD/tJ,EAAMguJ,QAAUpiJ,EAAO3T,OACvB+H,EAAM6tJ,QAAUjiJ,EAAO3T,OAEvB+H,EAAM8tJ,SAAWliJ,EAAO3T,OAAS81J,EAAO91J,OACxC+H,EAAMiuJ,SAAWriJ,EAAO3T,OAAS81J,EAAO91J,MApCxC,CAqCF,EAyBAmqJ,EAAiB3pJ,UAAUy1J,WAAa,SAASx2J,EAAGy2J,EAAOC,GACzD,IAAItL,EAAOvK,EACX,GAAgB,iBAAL7gJ,GAAiC,iBAATy2J,QACf,IAATC,EAGTtL,EAA6B,GAC7BvK,EAAQh5I,KAAKsjJ,UAAUC,EAA4B,GAAS,IAClD7qJ,OAAS,IACjBsH,KAAKwlJ,qBAAqBxM,GAC1Bh5I,KAAK4rJ,uBAAuB5S,SAEzB,GAAI7gJ,GAAiB,iBAALA,QAAiC,IAATy2J,QAC3B,IAATC,EAGT7V,EAAsD,EACtDuK,EAAQvjJ,KAAK0sJ,WAAW1T,QACnB,GAAgB,iBAAL7gJ,GAAiBy2J,GAAyB,iBAATA,QAC/B,IAATC,EAETtL,EAA6B,EAC7BvK,EAAsD,MACjD,IAAgB,iBAAL7gJ,GAAiC,iBAATy2J,IACtCC,GAAyB,iBAATA,EAMlB,MAAM,IAAIltJ,MAAM,sCAHhB4hJ,EAA6B,EAC7BvK,EAAsD,CAGxD,CAEA,GAAqB,IAAjBA,EAAMtgJ,OACR,MAAO,GAYT,IAVA,IAAIo2J,EAAU,GACVruJ,EAAQ,IAAIoiJ,EAAiBkM,UAC7BC,EAAkB,EAClBC,EAAc,EACdC,EAAc,EAIdC,EAAgB5L,EAChB6L,EAAiB7L,EACZvuI,EAAI,EAAGA,EAAIgkI,EAAMtgJ,OAAQsc,IAAK,CACrC,IAAIq6I,EAAYrW,EAAMhkI,GAAG,GACrBs6I,EAAYtW,EAAMhkI,GAAG,GAQzB,OANKg6I,GA7mDQ,IA6mDWK,IAEtB5uJ,EAAMguJ,OAASQ,EACfxuJ,EAAM6tJ,OAASY,GAGTG,GACN,KArnDY,EAsnDV5uJ,EAAMu4I,MAAMgW,KAAqBhW,EAAMhkI,GACvCvU,EAAMiuJ,SAAWY,EAAU52J,OAC3B02J,EAAiBA,EAAelhF,UAAU,EAAGghF,GAAeI,EAC3CF,EAAelhF,UAAUghF,GAC1C,MACF,KAAK7L,EACH5iJ,EAAM8tJ,SAAWe,EAAU52J,OAC3B+H,EAAMu4I,MAAMgW,KAAqBhW,EAAMhkI,GACvCo6I,EAAiBA,EAAelhF,UAAU,EAAGghF,GAC5BE,EAAelhF,UAAUghF,EACrBI,EAAU52J,QAC/B,MACF,KAjoDW,EAkoDL42J,EAAU52J,QAAU,EAAIsH,KAAKmjJ,cAC7B6L,GAAmBhW,EAAMtgJ,QAAUsc,EAAI,GAEzCvU,EAAMu4I,MAAMgW,KAAqBhW,EAAMhkI,GACvCvU,EAAM8tJ,SAAWe,EAAU52J,OAC3B+H,EAAMiuJ,SAAWY,EAAU52J,QAClB42J,EAAU52J,QAAU,EAAIsH,KAAKmjJ,cAElC6L,IACFhvJ,KAAKquJ,kBAAkB5tJ,EAAO0uJ,GAC9BL,EAAQltJ,KAAKnB,GACbA,EAAQ,IAAIoiJ,EAAiBkM,UAC7BC,EAAkB,EAKlBG,EAAgBC,EAChBH,EAAcC,GArpDR,IA4pDVG,IACFJ,GAAeK,EAAU52J,QAEvB22J,IAAchM,IAChB6L,GAAeI,EAAU52J,OAE7B,CAOA,OALIs2J,IACFhvJ,KAAKquJ,kBAAkB5tJ,EAAO0uJ,GAC9BL,EAAQltJ,KAAKnB,IAGRquJ,CACT,EAQAjM,EAAiB3pJ,UAAUq2J,eAAiB,SAAST,GAGnD,IADA,IAAIU,EAAc,GACTx6I,EAAI,EAAGA,EAAI85I,EAAQp2J,OAAQsc,IAAK,CACvC,IAAIvU,EAAQquJ,EAAQ95I,GAChBy6I,EAAY,IAAI5M,EAAiBkM,UACrCU,EAAUzW,MAAQ,GAClB,IAAK,IAAI/jI,EAAI,EAAGA,EAAIxU,EAAMu4I,MAAMtgJ,OAAQuc,IACtCw6I,EAAUzW,MAAM/jI,GACZ,IAAI4tI,EAAiB3C,KAAKz/I,EAAMu4I,MAAM/jI,GAAG,GAAIxU,EAAMu4I,MAAM/jI,GAAG,IAElEw6I,EAAUhB,OAAShuJ,EAAMguJ,OACzBgB,EAAUnB,OAAS7tJ,EAAM6tJ,OACzBmB,EAAUlB,QAAU9tJ,EAAM8tJ,QAC1BkB,EAAUf,QAAUjuJ,EAAMiuJ,QAC1Bc,EAAYx6I,GAAKy6I,CACnB,CACA,OAAOD,CACT,EAWA3M,EAAiB3pJ,UAAUw2J,YAAc,SAASZ,EAASnnB,GACzD,GAAsB,GAAlBmnB,EAAQp2J,OACV,MAAO,CAACivI,EAAM,IAIhBmnB,EAAU9uJ,KAAKuvJ,eAAeT,GAE9B,IAAIa,EAAc3vJ,KAAK4vJ,iBAAiBd,GACxCnnB,EAAOgoB,EAAchoB,EAAOgoB,EAE5B3vJ,KAAK6vJ,eAAef,GAOpB,IAFA,IAAIr1D,EAAQ,EACRq2D,EAAU,GACL96I,EAAI,EAAGA,EAAI85I,EAAQp2J,OAAQsc,IAAK,CACvC,IAEI+6I,EA4BEvM,EA9BFwM,EAAelB,EAAQ95I,GAAGs5I,OAAS70D,EACnC8pD,EAAQvjJ,KAAK0sJ,WAAWoC,EAAQ95I,GAAGgkI,OAEnCiX,GAAW,EAkBf,GAjBI1M,EAAM7qJ,OAASsH,KAAKojJ,eAKJ,IAFlB2M,EAAY/vJ,KAAKotJ,WAAWzlB,EAAM4b,EAAMr1E,UAAU,EAAGluE,KAAKojJ,eAC9B4M,OAKV,IAHhBC,EAAUjwJ,KAAKotJ,WAAWzlB,EACtB4b,EAAMr1E,UAAUq1E,EAAM7qJ,OAASsH,KAAKojJ,eACpC4M,EAAezM,EAAM7qJ,OAASsH,KAAKojJ,iBAClB2M,GAAaE,KAEhCF,GAAa,GAIjBA,EAAY/vJ,KAAKotJ,WAAWzlB,EAAM4b,EAAOyM,IAEzB,GAAdD,EAEFD,EAAQ96I,IAAK,EAEbykF,GAASq1D,EAAQ95I,GAAG05I,QAAUI,EAAQ95I,GAAGu5I,aAWzC,GARAuB,EAAQ96I,IAAK,EACbykF,EAAQs2D,EAAYC,EAOhBzM,IAJFC,GADc,GAAZyM,EACMtoB,EAAKz5D,UAAU6hF,EAAWA,EAAYxM,EAAM7qJ,QAE5CivI,EAAKz5D,UAAU6hF,EAAWE,EAAUjwJ,KAAKojJ,gBAIjDzb,EAAOA,EAAKz5D,UAAU,EAAG6hF,GAClB/vJ,KAAK2sJ,WAAWmC,EAAQ95I,GAAGgkI,OAC3BrR,EAAKz5D,UAAU6hF,EAAYxM,EAAM7qJ,YACnC,CAGL,IAAIsgJ,EAAQh5I,KAAKsjJ,UAAUC,EAAOC,GAAO,GACzC,GAAID,EAAM7qJ,OAASsH,KAAKojJ,eACpBpjJ,KAAK4sJ,iBAAiB5T,GAASuK,EAAM7qJ,OACrCsH,KAAKkjJ,sBAEP4M,EAAQ96I,IAAK,MACR,CACLhV,KAAK2pJ,6BAA6B3Q,GAGlC,IAFA,IACIqI,EADAC,EAAS,EAEJrsI,EAAI,EAAGA,EAAI65I,EAAQ95I,GAAGgkI,MAAMtgJ,OAAQuc,IAAK,CAChD,IAAIi+B,EAAM47G,EAAQ95I,GAAGgkI,MAAM/jI,GAxxDtB,IAyxDDi+B,EAAI,KACNmuG,EAASrhJ,KAAKisJ,YAAYjT,EAAOsI,IA3xD7B,IA6xDFpuG,EAAI,GACNy0F,EAAOA,EAAKz5D,UAAU,EAAG6hF,EAAY1O,GAAUnuG,EAAI,GAC5Cy0F,EAAKz5D,UAAU6hF,EAAY1O,GACzBnuG,EAAI,KAAOmwG,IACpB1b,EAAOA,EAAKz5D,UAAU,EAAG6hF,EAAY1O,GAC9B1Z,EAAKz5D,UAAU6hF,EAAY/vJ,KAAKisJ,YAAYjT,EACxCsI,EAASpuG,EAAI,GAAGx6C,UAEzBw6C,EAAI,KAAOmwG,IACb/B,GAAUpuG,EAAI,GAAGx6C,OAErB,CACF,CACF,CAEJ,CAGA,MAAO,CADPivI,EAAOA,EAAKz5D,UAAUyhF,EAAYj3J,OAAQivI,EAAKjvI,OAASi3J,EAAYj3J,QACtDo3J,EAChB,EASAjN,EAAiB3pJ,UAAU02J,iBAAmB,SAASd,GAGrD,IAFA,IAAIoB,EAAgBlwJ,KAAKmjJ,aACrBwM,EAAc,GACT36I,EAAI,EAAGA,GAAKk7I,EAAel7I,IAClC26I,GAAe90J,OAAOu/H,aAAaplH,GAIrC,IAASA,EAAI,EAAGA,EAAI85I,EAAQp2J,OAAQsc,IAClC85I,EAAQ95I,GAAGy5I,QAAUyB,EACrBpB,EAAQ95I,GAAGs5I,QAAU4B,EAIvB,IAAIzvJ,EAAQquJ,EAAQ,GAChB9V,EAAQv4I,EAAMu4I,MAClB,GAAoB,GAAhBA,EAAMtgJ,QAx0DK,GAw0DUsgJ,EAAM,GAAG,GAEhCA,EAAM5pH,QAAQ,IAAIyzH,EAAiB3C,KA10DtB,EA00DuCyP,IACpDlvJ,EAAMguJ,QAAUyB,EAChBzvJ,EAAM6tJ,QAAU4B,EAChBzvJ,EAAM8tJ,SAAW2B,EACjBzvJ,EAAMiuJ,SAAWwB,OACZ,GAAIA,EAAgBlX,EAAM,GAAG,GAAGtgJ,OAAQ,CAE7C,IAAIy3J,EAAcD,EAAgBlX,EAAM,GAAG,GAAGtgJ,OAC9CsgJ,EAAM,GAAG,GAAK2W,EAAYzhF,UAAU8qE,EAAM,GAAG,GAAGtgJ,QAAUsgJ,EAAM,GAAG,GACnEv4I,EAAMguJ,QAAU0B,EAChB1vJ,EAAM6tJ,QAAU6B,EAChB1vJ,EAAM8tJ,SAAW4B,EACjB1vJ,EAAMiuJ,SAAWyB,CACnB,CAKA,GAAoB,IADpBnX,GADAv4I,EAAQquJ,EAAQA,EAAQp2J,OAAS,IACnBsgJ,OACJtgJ,QA51DK,GA41DUsgJ,EAAMA,EAAMtgJ,OAAS,GAAG,GAE/CsgJ,EAAMp3I,KAAK,IAAIihJ,EAAiB3C,KA91DnB,EA81DoCyP,IACjDlvJ,EAAM8tJ,SAAW2B,EACjBzvJ,EAAMiuJ,SAAWwB,OACZ,GAAIA,EAAgBlX,EAAMA,EAAMtgJ,OAAS,GAAG,GAAGA,OAAQ,CAExDy3J,EAAcD,EAAgBlX,EAAMA,EAAMtgJ,OAAS,GAAG,GAAGA,OAC7DsgJ,EAAMA,EAAMtgJ,OAAS,GAAG,IAAMi3J,EAAYzhF,UAAU,EAAGiiF,GACvD1vJ,EAAM8tJ,SAAW4B,EACjB1vJ,EAAMiuJ,SAAWyB,CACnB,CAEA,OAAOR,CACT,EASA9M,EAAiB3pJ,UAAU22J,eAAiB,SAASf,GAEnD,IADA,IAAIsB,EAAapwJ,KAAKojJ,cACbpuI,EAAI,EAAGA,EAAI85I,EAAQp2J,OAAQsc,IAClC,KAAI85I,EAAQ95I,GAAGu5I,SAAW6B,GAA1B,CAGA,IAAIC,EAAWvB,EAAQ95I,GAEvB85I,EAAQ12F,OAAOpjD,IAAK,GAIpB,IAHA,IAAIy5I,EAAS4B,EAAS5B,OAClBH,EAAS+B,EAAS/B,OAClBgC,EAAa,GACgB,IAA1BD,EAASrX,MAAMtgJ,QAAc,CAElC,IAAI+H,EAAQ,IAAIoiJ,EAAiBkM,UAC7BwB,GAAQ,EAOZ,IANA9vJ,EAAMguJ,OAASA,EAAS6B,EAAW53J,OACnC+H,EAAM6tJ,OAASA,EAASgC,EAAW53J,OAChB,KAAf43J,IACF7vJ,EAAM8tJ,QAAU9tJ,EAAMiuJ,QAAU4B,EAAW53J,OAC3C+H,EAAMu4I,MAAMp3I,KAAK,IAAIihJ,EAAiB3C,KAv4D7B,EAu4D8CoQ,KAExB,IAA1BD,EAASrX,MAAMtgJ,QACf+H,EAAM8tJ,QAAU6B,EAAapwJ,KAAKmjJ,cAAc,CACrD,IAAIkM,EAAYgB,EAASrX,MAAM,GAAG,GAC9BsW,EAAYe,EAASrX,MAAM,GAAG,GA74DxB,IA84DNqW,GAEF5uJ,EAAMiuJ,SAAWY,EAAU52J,OAC3B41J,GAAUgB,EAAU52J,OACpB+H,EAAMu4I,MAAMp3I,KAAKyuJ,EAASrX,MAAM5yH,SAChCmqI,GAAQ,GACClB,IAAchM,GAAqC,GAAtB5iJ,EAAMu4I,MAAMtgJ,QAn5D3C,GAo5DE+H,EAAMu4I,MAAM,GAAG,IACfsW,EAAU52J,OAAS,EAAI03J,GAEhC3vJ,EAAM8tJ,SAAWe,EAAU52J,OAC3B+1J,GAAUa,EAAU52J,OACpB63J,GAAQ,EACR9vJ,EAAMu4I,MAAMp3I,KAAK,IAAIihJ,EAAiB3C,KAAKmP,EAAWC,IACtDe,EAASrX,MAAM5yH,UAGfkpI,EAAYA,EAAUphF,UAAU,EAC5BkiF,EAAa3vJ,EAAM8tJ,QAAUvuJ,KAAKmjJ,cACtC1iJ,EAAM8tJ,SAAWe,EAAU52J,OAC3B+1J,GAAUa,EAAU52J,OAj6Db,IAk6DH22J,GACF5uJ,EAAMiuJ,SAAWY,EAAU52J,OAC3B41J,GAAUgB,EAAU52J,QAEpB63J,GAAQ,EAEV9vJ,EAAMu4I,MAAMp3I,KAAK,IAAIihJ,EAAiB3C,KAAKmP,EAAWC,IAClDA,GAAae,EAASrX,MAAM,GAAG,GACjCqX,EAASrX,MAAM5yH,QAEfiqI,EAASrX,MAAM,GAAG,GACdqX,EAASrX,MAAM,GAAG,GAAG9qE,UAAUohF,EAAU52J,QAGnD,CAGA43J,GADAA,EAAatwJ,KAAK2sJ,WAAWlsJ,EAAMu4I,QAEpB9qE,UAAUoiF,EAAW53J,OAASsH,KAAKmjJ,cAElD,IAAIqN,EAAcxwJ,KAAK0sJ,WAAW2D,EAASrX,OACpB9qE,UAAU,EAAGluE,KAAKmjJ,cACrB,KAAhBqN,IACF/vJ,EAAM8tJ,SAAWiC,EAAY93J,OAC7B+H,EAAMiuJ,SAAW8B,EAAY93J,OACF,IAAvB+H,EAAMu4I,MAAMtgJ,QA37DP,IA47DL+H,EAAMu4I,MAAMv4I,EAAMu4I,MAAMtgJ,OAAS,GAAG,GACtC+H,EAAMu4I,MAAMv4I,EAAMu4I,MAAMtgJ,OAAS,GAAG,IAAM83J,EAE1C/vJ,EAAMu4I,MAAMp3I,KAAK,IAAIihJ,EAAiB3C,KA/7D/B,EA+7DgDsQ,KAGtDD,GACHzB,EAAQ12F,SAASpjD,EAAG,EAAGvU,EAE3B,CA7EA,CA+EJ,EAQAoiJ,EAAiB3pJ,UAAUu3J,aAAe,SAAS3B,GAEjD,IADA,IAAInnB,EAAO,GACF3yH,EAAI,EAAGA,EAAI85I,EAAQp2J,OAAQsc,IAClC2yH,EAAK3yH,GAAK85I,EAAQ95I,GAEpB,OAAO2yH,EAAK1qI,KAAK,GACnB,EASA4lJ,EAAiB3pJ,UAAUw3J,eAAiB,SAASC,GACnD,IAAI7B,EAAU,GACd,IAAK6B,EACH,OAAO7B,EAKT,IAHA,IAAInnB,EAAOgpB,EAAS3zJ,MAAM,MACtB4zJ,EAAc,EACdC,EAAc,uCACXD,EAAcjpB,EAAKjvI,QAAQ,CAChC,IAAIuH,EAAI0nI,EAAKipB,GAAazwJ,MAAM0wJ,GAChC,IAAK5wJ,EACH,MAAM,IAAI0B,MAAM,yBAA2BgmI,EAAKipB,IAElD,IAAInwJ,EAAQ,IAAIoiJ,EAAiBkM,UAyBjC,IAxBAD,EAAQltJ,KAAKnB,GACbA,EAAMguJ,OAASv+H,SAASjwB,EAAE,GAAI,IACjB,KAATA,EAAE,IACJQ,EAAMguJ,SACNhuJ,EAAM8tJ,QAAU,GACC,KAARtuJ,EAAE,GACXQ,EAAM8tJ,QAAU,GAEhB9tJ,EAAMguJ,SACNhuJ,EAAM8tJ,QAAUr+H,SAASjwB,EAAE,GAAI,KAGjCQ,EAAM6tJ,OAASp+H,SAASjwB,EAAE,GAAI,IACjB,KAATA,EAAE,IACJQ,EAAM6tJ,SACN7tJ,EAAMiuJ,QAAU,GACC,KAARzuJ,EAAE,GACXQ,EAAMiuJ,QAAU,GAEhBjuJ,EAAM6tJ,SACN7tJ,EAAMiuJ,QAAUx+H,SAASjwB,EAAE,GAAI,KAEjC2wJ,IAEOA,EAAcjpB,EAAKjvI,QAAQ,CAChC,IAAIqoH,EAAO4mB,EAAKipB,GAAa92B,OAAO,GACpC,IACE,IAAIrxE,EAAO0kG,UAAUxlB,EAAKipB,GAAa1iF,UAAU,GACnD,CAAE,MAAOzwB,GAEP,MAAM,IAAI97C,MAAM,qCAAuC8mD,EACzD,CACA,GAAY,KAARs4D,EAEFtgH,EAAMu4I,MAAMp3I,KAAK,IAAIihJ,EAAiB3C,KAAKmD,EAAa56F,SACnD,GAAY,KAARs4D,EAETtgH,EAAMu4I,MAAMp3I,KAAK,IAAIihJ,EAAiB3C,KAlhE5B,EAkhE8Cz3F,SACnD,GAAY,KAARs4D,EAETtgH,EAAMu4I,MAAMp3I,KAAK,IAAIihJ,EAAiB3C,KAphE7B,EAohE8Cz3F,QAClD,IAAY,KAARs4D,EAET,MACK,GAAa,KAATA,EAIT,MAAM,IAAIp/G,MAAM,uBAAyBo/G,EAAO,SAAWt4D,EAC7D,CACAmoG,GACF,CACF,CACA,OAAO9B,CACT,GAOAjM,EAAiBkM,UAAY,WAE3B/uJ,KAAKg5I,MAAQ,GAEbh5I,KAAKyuJ,OAAS,KAEdzuJ,KAAKsuJ,OAAS,KAEdtuJ,KAAKuuJ,QAAU,EAEfvuJ,KAAK0uJ,QAAU,CACjB,GAS2Bx1J,UAAU8H,SAAW,WAmB9C,IAlBA,IAgBIoC,EADAukI,EAAO,CAAC,QAdS,IAAjB3nI,KAAKuuJ,QACGvuJ,KAAKyuJ,OAAS,KACC,GAAhBzuJ,KAAKuuJ,QACJvuJ,KAAKyuJ,OAAS,EAEbzuJ,KAAKyuJ,OAAS,EAAK,IAAMzuJ,KAAKuuJ,SASZ,MAPV,IAAjBvuJ,KAAK0uJ,QACG1uJ,KAAKsuJ,OAAS,KACC,GAAhBtuJ,KAAK0uJ,QACJ1uJ,KAAKsuJ,OAAS,EAEbtuJ,KAAKsuJ,OAAS,EAAK,IAAMtuJ,KAAK0uJ,SAEK,SAGvC15I,EAAI,EAAGA,EAAIhV,KAAKg5I,MAAMtgJ,OAAQsc,IAAK,CAC1C,OAAQhV,KAAKg5I,MAAMhkI,GAAG,IACpB,KAnlEY,EAolEV5R,EAAK,IACL,MACF,KAAKigJ,EACHjgJ,EAAK,IACL,MACF,KAxlEW,EAylETA,EAAK,IAGTukI,EAAK3yH,EAAI,GAAK5R,EAAKmoE,UAAUvrE,KAAKg5I,MAAMhkI,GAAG,IAAM,IACnD,CACA,OAAO2yH,EAAK1qI,KAAK,IAAI0G,QAAQ,OAAQ,IACvC,EAIA7L,EAAOC,QAAU8qJ,EACjB/qJ,EAAOC,QAAP,iBAAqC8qJ,EACrC/qJ,EAAOC,QAAP,YAAgCsrJ,EAChCvrJ,EAAOC,QAAP,YAvmEkB,EAwmElBD,EAAOC,QAAP,WAvmEiB,4DC3CjB,IAAI+4J,EAAW,CACbC,6BAA8B,SAASC,EAAOxlJ,EAAG8Z,GAG/C,IAAI2rI,EAAe,CAAC,EAIhBC,EAAQ,CAAC,EACbA,EAAM1lJ,GAAK,EAMX,IAGIk0F,EACAutB,EAAG5hH,EACH8lJ,EACAC,EAEAC,EACAC,EATAhnI,EAAOwmI,EAASS,cAAcC,OAWlC,IAVAlnI,EAAK1oB,KAAK4J,EAAG,IAUL8e,EAAKimI,SAaX,IAAKllJ,KATL4hH,GADAvtB,EAAUp1E,EAAKrjB,OACH9N,MACZg4J,EAAiBzxD,EAAQ+xD,KAGzBL,EAAiBJ,EAAM/jC,IAAM,CAAC,EAMxBmkC,EAAe53J,eAAe6R,KAOhCgmJ,EAAgCF,EALpBC,EAAe/lJ,GAW3BimJ,EAAiBJ,EAAM7lJ,SACY,IAAb6lJ,EAAM7lJ,IACTimJ,EAAiBD,KAClCH,EAAM7lJ,GAAKgmJ,EACX/mI,EAAK1oB,KAAKyJ,EAAGgmJ,GACbJ,EAAa5lJ,GAAK4hH,IAM1B,QAAiB,IAAN3nG,QAAyC,IAAb4rI,EAAM5rI,GAAoB,CAC/D,IAAIkjC,EAAM,CAAC,8BAA+Bh9C,EAAG,OAAQ8Z,EAAG,KAAKroB,KAAK,IAClE,MAAM,IAAI0E,MAAM6mD,EAClB,CAEA,OAAOyoG,CACT,EAEAS,4CAA6C,SAAST,EAAc3rI,GAIlE,IAHA,IAAIgM,EAAQ,GACR27F,EAAI3nG,EAED2nG,GACL37F,EAAM1vB,KAAKqrH,GACGgkC,EAAahkC,GAC3BA,EAAIgkC,EAAahkC,GAGnB,OADA37F,EAAM+O,UACC/O,CACT,EAEAqgI,UAAW,SAASX,EAAOxlJ,EAAG8Z,GAC5B,IAAI2rI,EAAeH,EAASC,6BAA6BC,EAAOxlJ,EAAG8Z,GACnE,OAAOwrI,EAASY,4CACdT,EAAc3rI,EAClB,EAKAisI,cAAe,CACbC,KAAM,SAAUl9F,GACd,IAEIr7D,EAFAszH,EAAIukC,EAASS,cACb94J,EAAI,CAAC,EAGT,IAAKQ,KADLq7D,EAAOA,GAAQ,CAAC,EACJi4D,EACNA,EAAE/yH,eAAeP,KACnBR,EAAEQ,GAAOszH,EAAEtzH,IAKf,OAFAR,EAAEm5J,MAAQ,GACVn5J,EAAEo5J,OAASv9F,EAAKu9F,QAAUtlC,EAAEulC,eACrBr5J,CACT,EAEAq5J,eAAgB,SAAU35J,EAAGiH,GAC3B,OAAOjH,EAAEs5J,KAAOryJ,EAAEqyJ,IACpB,EAMA7vJ,KAAM,SAAUzI,EAAOs4J,GACrB,IAAIv+H,EAAO,CAAC/5B,MAAOA,EAAOs4J,KAAMA,GAChCzxJ,KAAK4xJ,MAAMhwJ,KAAKsxB,GAChBlzB,KAAK4xJ,MAAMpkJ,KAAKxN,KAAK6xJ,OACvB,EAKA5qJ,IAAK,WACH,OAAOjH,KAAK4xJ,MAAMxrI,OACpB,EAEAmqI,MAAO,WACL,OAA6B,IAAtBvwJ,KAAK4xJ,MAAMl5J,MACpB,IAOFZ,EAAOC,QAAU+4J,qEC/JnB,IAAIiB,EAHJh5J,OAAOC,eAAejB,EAAS,aAAc,CAAEoB,OAAO,IACtDpB,EAAQi6J,QAAUj6J,EAAQk6J,MAAQl6J,EAAQm6J,IAAMn6J,EAAQm+F,MAAQn+F,EAAQo6J,OAASp6J,EAAQq6J,QAAUr6J,EAAQs6J,UAAYt6J,EAAQuvG,KAAOvvG,EAAQyhH,KAAOzhH,EAAQu6J,MAAQv6J,EAAQg6J,iBAAc,EAG3L,SAAWA,GAEPA,EAAkB,KAAI,OAEtBA,EAAkB,KAAI,OAEtBA,EAAuB,UAAI,YAE3BA,EAAqB,QAAI,UAEzBA,EAAoB,OAAI,SAExBA,EAAmB,MAAI,QAEvBA,EAAiB,IAAI,MAErBA,EAAmB,MAAI,QAEvBA,EAAqB,QAAI,SAC5B,CAnBD,CAmBGA,EAAch6J,EAAQg6J,cAAgBh6J,EAAQg6J,YAAc,CAAC,IAWhEh6J,EAAQu6J,MALR,SAAelrF,GACX,OAAQA,EAAKvzD,OAASk+I,EAAYG,KAC9B9qF,EAAKvzD,OAASk+I,EAAYI,QAC1B/qF,EAAKvzD,OAASk+I,EAAY77D,KAClC,EAIAn+F,EAAQyhH,KAAOu4C,EAAYv4C,KAE3BzhH,EAAQuvG,KAAOyqD,EAAYzqD,KAE3BvvG,EAAQs6J,UAAYN,EAAYM,UAEhCt6J,EAAQq6J,QAAUL,EAAYK,QAE9Br6J,EAAQo6J,OAASJ,EAAYI,OAE7Bp6J,EAAQm+F,MAAQ67D,EAAY77D,MAE5Bn+F,EAAQm6J,IAAMH,EAAYG,IAE1Bn6J,EAAQk6J,MAAQF,EAAYE,MAE5Bl6J,EAAQi6J,QAAUD,EAAYC,qECpD9B,IAGIO,EAHAznC,EAAW,EAAQ,mDACnB0nC,EAAO,EAAQ,gCAGnB,IAECD,EAAyE,GAAKj4J,YAAcykB,MAAM7lB,SACnG,CAAE,MAAOlB,GACR,IAAKA,GAAkB,iBAANA,KAAoB,SAAUA,IAAiB,qBAAXA,EAAEi/E,KACtD,MAAMj/E,CAER,CAGA,IAAIq/C,IAASk7G,GAAoBC,GAAQA,EAAKz5J,OAAOG,UAAwD,aAEzGu5J,EAAU15J,OACV25J,EAAkBD,EAAQj4J,eAG9B1C,EAAOC,QAAUs/C,GAA4B,mBAAbA,EAAK9yC,IAClCumH,EAAS,CAACzzE,EAAK9yC,MACY,mBAApBmuJ,GACyB,SAAmBv5J,GAEnD,OAAOu5J,EAAyB,MAATv5J,EAAgBA,EAAQs5J,EAAQt5J,GACxD,yDC5BFrB,EAAOC,QAAU,CAChB,OAAQ,KACR,IAAQ,KACR,IAAQ,KACR,IAAQ,KACR,IAAQ,KACR,IAAQ,KACR,IAAQ,KACR,IAAQ,KACR,IAAQ,KACR,IAAQ,KACR,OAAQ,KACR,IAAQ,KACR,IAAQ,KACR,IAAQ,KACR,IAAQ,KACR,IAAQ,KACR,IAAQ,KACR,IAAQ,KACR,MAAO,KACP,IAAO,KACP,IAAO,KACP,IAAO,KACP,IAAO,KACP,IAAO,KACP,IAAO,KACP,IAAO,KACP,IAAO,KACP,MAAO,KACP,IAAO,KACP,MAAO,KACP,IAAO,KACP,MAAO,KACP,IAAO,KACP,IAAO,KACP,MAAO,KACP,MAAO,KACP,IAAO,KACP,MAAO,KACP,IAAO,KACP,IAAO,KACP,IAAO,KACP,MAAO,KACP,IAAO,KACP,IAAO,KACP,IAAO,KACP,IAAO,KACP,IAAO,KACP,MAAO,KACP,IAAO,KACP,IAAO,KACP,IAAO,KACP,IAAO,KACP,OAAQ,KACR,KAAQ,KACR,KAAQ,KACR,KAAQ,KACR,KAAQ,KACR,OAAQ,KACR,KAAQ,KACR,KAAQ,KACR,KAAQ,KACR,KAAQ,KACR,KAAQ,KACR,OAAQ,KACR,KAAQ,KACR,KAAQ,KACR,OAAQ,KACR,KAAQ,KACR,KAAQ,KACR,KAAQ,KACR,KAAQ,KACR,KAAQ,KACR,KAAQ,KACR,OAAQ,KACR,KAAQ,KACR,KAAQ,KACR,OAAQ,KACR,KAAQ,KACR,KAAQ,KACR,KAAQ,KACR,KAAQ,KACR,KAAQ,KACR,OAAQ,KACR,KAAQ,KACR,KAAQ,KACR,OAAQ,KACR,KAAQ,KACR,KAAQ,KACR,KAAQ,KACR,KAAQ,KACR,OAAQ,MACR,KAAQ,MACR,KAAQ,MACR,KAAQ,MACR,OAAQ,MACR,KAAQ,MACR,OAAQ,MACR,KAAQ,MACR,KAAQ,MACR,KAAQ,MACR,OAAQ,MACR,KAAQ,MACR,KAAQ,MACR,KAAQ,MACR,KAAQ,MACR,OAAQ,MACR,KAAQ,MACR,KAAQ,MACR,KAAQ,MACR,OAAQ,MACR,KAAQ,MACR,KAAQ,MACR,KAAQ,MACR,OAAQ,MACR,KAAQ,MACR,KAAQ,MACR,KAAQ,MACR,KAAQ,MACR,KAAQ,MACR,KAAQ,MACR,KAAQ,MACR,KAAQ,MACR,OAAQ,MACR,KAAQ,MACR,KAAQ,MACR,KAAQ,MACR,KAAQ,MACR,KAAQ,MACR,KAAQ,MACR,KAAQ,MACR,KAAQ,MACR,KAAQ,MACR,OAAQ,MACR,KAAQ,MACR,KAA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AAE,UAAU,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,WAAW,CAAC,EAAE,UAAU,CAAC,EAAE,SAAS,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,WAAW,CAAC,EAAE,YAAY,CAAC,EAAE,UAAU,CAAC,EAAE,SAAS,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,WAAW,CAAC,EAAE,UAAU,CAAC,EAAE,YAAY,CAAC,EAAE,WAAW,CAAC,EAAE,UAAU,CAAC,EAAE,WAAW,CAAC,EAAE,WAAW,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,WAAW,CAAC,EAAE,WAAW,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,WAAW,CAAC,EAAE,WAAW,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,WAAW,CAAC,EAAE,WAAW,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,WAAW,CAAC,EAAE,WAAW,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,WAAW,CAAC,EAAE,WAAW,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,YAAY,CAAC,EAAE,WAAW,CAAC,EAAE,WAAW,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,WAAW,CAAC,EAAE,WAAW,CAAC,EAAE,WAAW,CAAC,EAAE,WAAW,CAAC,EAAE,UAAU,CAAC,EAAE,WAAW,CAAC,EAAE,WAAW,CAAC,EAAE,WAAW,CAAC,EAAE,WAAW,CAAC,EAAE,WAAW,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,E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CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,SAAS,CAAC,EAAE,YAAY,CAAC,EAAE,SAAS,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,SAAS,CAAC,EAAE,YAAY,CAAC,EAAE,SAAS,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,WAAW,CAAC,EAAE,UAAU,CAAC,EAAE,WAAW,CAAC,EAAE,UAAU,CAAC,EAAE,YAAY,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,WAAW,CAAC,EAAE,UAAU,CAAC,EAAE,WAAW,CAAC,EAAE,UAAU,CAAC,KAAK,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,EAAE,WAAW,CAAC,EAAE,YAAY,CAAC,EAAE,eAAe,CAAC,EAAE,YAAY,CAAC,EAAE,yBAAyB,CAAC,EAAE,UAAU,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,UAAU,CAAC,EAAE,WAA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,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,GAAG,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,UAAU,CAAC,EAAE,eAAe,CAAC,KAAK,WAAW,CAAC,EAAE,WAAW,CAAC,EAAE,WAAW,CAAC,EAAE,YAAY,CAAC,EAAE,0fChBr9tB,IAUY,EAOA,EAjBZ,6CACA,6CACA,6CAsEA,SAAgB,EACZ,EACA,GAIA,QAJA,UAAyC,EAAY,MAEpB,iBAAZ,EAAuB,EAAU,EAAQ,SAEhD,EAAY,KAAM,CAC5B,IAAM,EAA0B,iBAAZ,EAAuB,EAAQ,UAAO,EAC1D,OAAO,gBAAW,EAAM,GAG5B,OAAO,eAAU,EACrB,EA1EA,SAAY,GAER,iBAEA,kBACH,CALD,CAAY,gCAAW,KAOvB,SAAY,GAKR,mBAMA,qBAKA,6BAKA,6BAKA,kBACH,CA3BD,CAAY,kCAAY,KAuDxB,WAqBA,wBACI,EACA,wBAAyC,EAAY,KAErD,IAAM,EAA0B,iBAAZ,EAAuB,CAAE,MAAO,GAAY,EAGhE,OAFS,QAAT,IAAK,YAAI,QAAT,EAAK,KAAS,eAAa,QAEpB,EAAO,EAAM,EACxB,EAwBA,kBACI,EACA,kBAAyC,EAAY,KAErD,IAAM,EAA0B,iBAAZ,EAAuB,CAAE,MAAO,GAAY,EAGhE,OAAI,EAAK,OAAS,EAAa,MAAa,gBAAW,GACnD,EAAK,OAAS,EAAa,WAAkB,qBAAgB,GAC7D,EAAK,OAAS,EAAa,MAAa,gBAAW,GAEnD,EAAK,QAAU,EAAY,KACvB,EAAK,OAAS,EAAa,OACpB,wBAAmB,IAGvB,gBAAW,IAIf,eAAU,EACrB,EAEA,iDACI,oFAAS,IACT,8EAAM,IACN,sFAAU,IACV,gGAAe,IACf,sFAAU,IAGd,iDACI,sFAAU,IACV,sGAAkB,IAElB,uFAAU,IACV,uFAAU,IAGd,iDACI,4FAAa,IACb,0FAAY,IACZ,oFAAS,IACT,sFAAU,IACV,kGAAgB,IAChB,wGAAmB,IAEnB,uFAAU,IACV,uFAAU,IACV,mGAAgB,IAChB,mGAAgB,IAChB,0FAAS,mEC7Kb,IAAIznC,EAAkBpyH,OAAOC,iBAAkB,EAC/C,GAAImyH,EACH,IACCA,EAAgB,CAAC,EAAG,IAAK,CAAEhyH,MAAO,GACnC,CAAE,MAAOnB,GAERmzH,GAAkB,CACnB,CAGDrzH,EAAOC,QAAUozH,uDCVjBrzH,EAAOC,QAAUy9J,gECAjB19J,EAAOC,QAAU4J,4DCAjB7J,EAAOC,QAAUoiI,+DCAjBriI,EAAOC,QAAUE,sECAjBH,EAAOC,QAAU09J,iECAjB39J,EAAOC,QAAUM,8DCAjBP,EAAOC,QAAU29J,qECAjB59J,EAAOC,QAAUgB,+DCYjB,IAAI48J,EAAkB,UAOtB79J,EAAOC,QAUP,SAAoBmyH,GAClB,IAOIh5F,EAPA0jB,EAAM,GAAKs1E,EACX/pH,EAAQw1J,EAAgB/mJ,KAAKgmC,GAEjC,IAAKz0C,EACH,OAAOy0C,EAIT,IAAIp5B,EAAO,GACPre,EAAQ,EACR0R,EAAY,EAEhB,IAAK1R,EAAQgD,EAAMhD,MAAOA,EAAQy3C,EAAIl8C,OAAQyE,IAAS,CACrD,OAAQy3C,EAAIqmC,WAAW99E,IACrB,KAAK,GACH+zB,EAAS,SACT,MACF,KAAK,GACHA,EAAS,QACT,MACF,KAAK,GACHA,EAAS,QACT,MACF,KAAK,GACHA,EAAS,OACT,MACF,KAAK,GACHA,EAAS,OACT,MACF,QACE,SAGAriB,IAAc1R,IAChBqe,GAAQo5B,EAAIs5B,UAAUr/D,EAAW1R,IAGnC0R,EAAY1R,EAAQ,EACpBqe,GAAQ0V,CACV,CAEA,OAAOriB,IAAc1R,EACjBqe,EAAOo5B,EAAIs5B,UAAUr/D,EAAW1R,GAChCqe,CACN,mEC3EA1jB,EAAOC,QAAUmyH,IAChB,GAAsB,iBAAXA,EACV,MAAM,IAAI7xH,UAAU,qBAKrB,OAAO6xH,EACLvmH,QAAQ,sBAAuB,QAC/BA,QAAQ,KAAM,QAAQ,sDCYzB,IAOIiyJ,EAPAr5J,EAAuB,iBAAZ+5C,QAAuBA,QAAU,KAC5Cu/G,EAAet5J,GAAwB,mBAAZA,EAAE7C,MAC7B6C,EAAE7C,MACF,SAAsB6nB,EAAQu0I,EAAUh6J,GACxC,OAAOolE,SAAShoE,UAAUQ,MAAMD,KAAK8nB,EAAQu0I,EAAUh6J,EACzD,EAIA85J,EADEr5J,GAA0B,mBAAdA,EAAEw5J,QACCx5J,EAAEw5J,QACVh9J,OAAOiB,sBACC,SAAwBunB,GACvC,OAAOxoB,OAAOqhE,oBAAoB74C,GAC/BpD,OAAOplB,OAAOiB,sBAAsBunB,GACzC,EAEiB,SAAwBA,GACvC,OAAOxoB,OAAOqhE,oBAAoB74C,EACpC,EAOF,IAAIy0I,EAAcl7J,OAAO+G,OAAS,SAAqB1I,GACrD,OAAOA,GAAUA,CACnB,EAEA,SAASw1I,IACPA,EAAarkF,KAAK7wD,KAAKuG,KACzB,CACAlI,EAAOC,QAAU42I,EACjB72I,EAAOC,QAAQ4iC,KAwYf,SAAcs7H,EAASt5J,GACrB,OAAO,IAAI6X,SAAQ,SAAU6jD,EAASG,GACpC,SAAS09F,EAAc/kI,GACrB8kI,EAAQrlB,eAAej0I,EAAMwhH,GAC7B3lD,EAAOrnC,EACT,CAEA,SAASgtF,IAC+B,mBAA3B83C,EAAQrlB,gBACjBqlB,EAAQrlB,eAAe,QAASslB,GAElC79F,EAAQ,GAAGtxD,MAAMtN,KAAKF,WACxB,CAEA48J,EAA+BF,EAASt5J,EAAMwhH,EAAU,CAAExjF,MAAM,IACnD,UAATh+B,GAMR,SAAuCs5J,EAAS1+H,EAAS+c,GAC7B,mBAAf2hH,EAAQz+H,IACjB2+H,EAA+BF,EAAS,QAAS1+H,EAAS+c,EAE9D,CATM8hH,CAA8BH,EAASC,EAAe,CAAEv7H,MAAM,GAElE,GACF,EAxZAg0G,EAAaA,aAAeA,EAE5BA,EAAaz1I,UAAU6yE,aAAUl+C,EACjC8gH,EAAaz1I,UAAUm9J,aAAe,EACtC1nB,EAAaz1I,UAAUo9J,mBAAgBzoI,EAIvC,IAAI0oI,EAAsB,GAE1B,SAASC,EAAc/+H,GACrB,GAAwB,mBAAbA,EACT,MAAM,IAAIp/B,UAAU,0EAA4Eo/B,EAEpG,CAoCA,SAASg/H,EAAiBC,GACxB,YAA2B7oI,IAAvB6oI,EAAKJ,cACA3nB,EAAa4nB,oBACfG,EAAKJ,aACd,CAkDA,SAASK,EAAap1I,EAAQ1N,EAAM4jB,EAAUm/H,GAC5C,IAAI32J,EACAw4B,EACAo+H,EA1HsBC,EAgJ1B,GApBAN,EAAc/+H,QAGC5J,KADf4K,EAASlX,EAAOwqD,UAEdtzC,EAASlX,EAAOwqD,QAAUhzE,OAAOa,OAAO,MACxC2nB,EAAO80I,aAAe,SAIKxoI,IAAvB4K,EAAOs+H,cACTx1I,EAAO8V,KAAK,cAAexjB,EACf4jB,EAASA,SAAWA,EAASA,SAAWA,GAIpDgB,EAASlX,EAAOwqD,SAElB8qF,EAAWp+H,EAAO5kB,SAGHga,IAAbgpI,EAEFA,EAAWp+H,EAAO5kB,GAAQ4jB,IACxBlW,EAAO80I,kBAeT,GAbwB,mBAAbQ,EAETA,EAAWp+H,EAAO5kB,GAChB+iJ,EAAU,CAACn/H,EAAUo/H,GAAY,CAACA,EAAUp/H,GAErCm/H,EACTC,EAASznI,QAAQqI,GAEjBo/H,EAASj1J,KAAK61B,IAIhBx3B,EAAIw2J,EAAiBl1I,IACb,GAAKs1I,EAASn+J,OAASuH,IAAM42J,EAASG,OAAQ,CACpDH,EAASG,QAAS,EAGlB,IAAI9pC,EAAI,IAAIvrH,MAAM,+CACEk1J,EAASn+J,OAAS,IAAMmC,OAAOgZ,GADjC,qEAIlBq5G,EAAEvwH,KAAO,8BACTuwH,EAAE+oC,QAAU10I,EACZ2rG,EAAEr5G,KAAOA,EACTq5G,EAAEh4F,MAAQ2hI,EAASn+J,OA7KGo+J,EA8KH5pC,EA7KnBnxH,SAAWA,QAAQmuD,MAAMnuD,QAAQmuD,KAAK4sG,EA8KxC,CAGF,OAAOv1I,CACT,CAaA,SAAS01I,IACP,IAAKj3J,KAAKk3J,MAGR,OAFAl3J,KAAKuhB,OAAOqvH,eAAe5wI,KAAK6T,KAAM7T,KAAKm3J,QAC3Cn3J,KAAKk3J,OAAQ,EACY,IAArB39J,UAAUb,OACLsH,KAAKy3B,SAASh+B,KAAKuG,KAAKuhB,QAC1BvhB,KAAKy3B,SAAS/9B,MAAMsG,KAAKuhB,OAAQhoB,UAE5C,CAEA,SAAS69J,EAAU71I,EAAQ1N,EAAM4jB,GAC/B,IAAIngB,EAAQ,CAAE4/I,OAAO,EAAOC,YAAQtpI,EAAWtM,OAAQA,EAAQ1N,KAAMA,EAAM4jB,SAAUA,GACjFi1C,EAAUuqF,EAAY39J,KAAKge,GAG/B,OAFAo1D,EAAQj1C,SAAWA,EACnBngB,EAAM6/I,OAASzqF,EACRA,CACT,CAyHA,SAAS2qF,EAAW91I,EAAQ1N,EAAMyjJ,GAChC,IAAI7+H,EAASlX,EAAOwqD,QAEpB,QAAel+C,IAAX4K,EACF,MAAO,GAET,IAAI8+H,EAAa9+H,EAAO5kB,GACxB,YAAmBga,IAAf0pI,EACK,GAEiB,mBAAfA,EACFD,EAAS,CAACC,EAAW9/H,UAAY8/H,GAAc,CAACA,GAElDD,EAsDT,SAAyBroF,GAEvB,IADA,IAAIjnE,EAAM,IAAI+W,MAAMkwD,EAAIv2E,QACfqB,EAAI,EAAGA,EAAIiO,EAAItP,SAAUqB,EAChCiO,EAAIjO,GAAKk1E,EAAIl1E,GAAG09B,UAAYw3C,EAAIl1E,GAElC,OAAOiO,CACT,CA3DIwvJ,CAAgBD,GAAcE,EAAWF,EAAYA,EAAW7+J,OACpE,CAmBA,SAASw5I,EAAcr+H,GACrB,IAAI4kB,EAASz4B,KAAK+rE,QAElB,QAAel+C,IAAX4K,EAAsB,CACxB,IAAI8+H,EAAa9+H,EAAO5kB,GAExB,GAA0B,mBAAf0jJ,EACT,OAAO,EACF,QAAmB1pI,IAAf0pI,EACT,OAAOA,EAAW7+J,MAEtB,CAEA,OAAO,CACT,CAMA,SAAS++J,EAAWxoF,EAAK72E,GAEvB,IADA,IAAIgqH,EAAO,IAAIrjG,MAAM3mB,GACZ2B,EAAI,EAAGA,EAAI3B,IAAK2B,EACvBqoH,EAAKroH,GAAKk1E,EAAIl1E,GAChB,OAAOqoH,CACT,CA2CA,SAAS+zC,EAA+BF,EAASt5J,EAAM86B,EAAU6c,GAC/D,GAA0B,mBAAf2hH,EAAQz+H,GACb8c,EAAM3Z,KACRs7H,EAAQt7H,KAAKh+B,EAAM86B,GAEnBw+H,EAAQz+H,GAAG76B,EAAM86B,OAEd,IAAwC,mBAA7Bw+H,EAAQr2I,iBAYxB,MAAM,IAAIvnB,UAAU,6EAA+E49J,GATnGA,EAAQr2I,iBAAiBjjB,GAAM,SAAS+6J,EAAap3G,GAG/ChM,EAAM3Z,MACRs7H,EAAQj0I,oBAAoBrlB,EAAM+6J,GAEpCjgI,EAAS6oB,EACX,GAGF,CACF,CAraAvnD,OAAOC,eAAe21I,EAAc,sBAAuB,CACzD/1I,YAAY,EACZ2L,IAAK,WACH,OAAOgyJ,CACT,EACA9yJ,IAAK,SAAS68C,GACZ,GAAmB,iBAARA,GAAoBA,EAAM,GAAK01G,EAAY11G,GACpD,MAAM,IAAI65E,WAAW,kGAAoG75E,EAAM,KAEjIi2G,EAAsBj2G,CACxB,IAGFquF,EAAarkF,KAAO,gBAEGz8B,IAAjB7tB,KAAK+rE,SACL/rE,KAAK+rE,UAAYhzE,OAAOyB,eAAewF,MAAM+rE,UAC/C/rE,KAAK+rE,QAAUhzE,OAAOa,OAAO,MAC7BoG,KAAKq2J,aAAe,GAGtBr2J,KAAKs2J,cAAgBt2J,KAAKs2J,oBAAiBzoI,CAC7C,EAIA8gH,EAAaz1I,UAAUo2I,gBAAkB,SAAyBl3I,GAChE,GAAiB,iBAANA,GAAkBA,EAAI,GAAK49J,EAAY59J,GAChD,MAAM,IAAI+hI,WAAW,gFAAkF/hI,EAAI,KAG7G,OADA4H,KAAKs2J,cAAgBl+J,EACd4H,IACT,EAQA2uI,EAAaz1I,UAAUy+J,gBAAkB,WACvC,OAAOlB,EAAiBz2J,KAC1B,EAEA2uI,EAAaz1I,UAAUm+B,KAAO,SAAcxjB,GAE1C,IADA,IAAI/X,EAAO,GACF/B,EAAI,EAAGA,EAAIR,UAAUb,OAAQqB,IAAK+B,EAAK8F,KAAKrI,UAAUQ,IAC/D,IAAI69J,EAAoB,UAAT/jJ,EAEX4kB,EAASz4B,KAAK+rE,QAClB,QAAel+C,IAAX4K,EACFm/H,EAAWA,QAA4B/pI,IAAjB4K,EAAOz8B,WAC1B,IAAK47J,EACR,OAAO,EAGT,GAAIA,EAAS,CACX,IAAI31J,EAGJ,GAFInG,EAAKpD,OAAS,IAChBuJ,EAAKnG,EAAK,IACRmG,aAAcN,MAGhB,MAAMM,EAGR,IAAIkvB,EAAM,IAAIxvB,MAAM,oBAAsBM,EAAK,KAAOA,EAAGmvB,QAAU,IAAM,KAEzE,MADAD,EAAIsE,QAAUxzB,EACRkvB,CACR,CAEA,IAAIoG,EAAUkB,EAAO5kB,GAErB,QAAgBga,IAAZ0J,EACF,OAAO,EAET,GAAuB,mBAAZA,EACTs+H,EAAat+H,EAASv3B,KAAMlE,OAE5B,KAAIosB,EAAMqP,EAAQ7+B,OACdm/J,EAAYJ,EAAWlgI,EAASrP,GACpC,IAASnuB,EAAI,EAAGA,EAAImuB,IAAOnuB,EACzB87J,EAAagC,EAAU99J,GAAIiG,KAAMlE,EAHX,CAM1B,OAAO,CACT,EAgEA6yI,EAAaz1I,UAAUu3I,YAAc,SAAqB58H,EAAM4jB,GAC9D,OAAOk/H,EAAa32J,KAAM6T,EAAM4jB,GAAU,EAC5C,EAEAk3G,EAAaz1I,UAAUs+B,GAAKm3G,EAAaz1I,UAAUu3I,YAEnD9B,EAAaz1I,UAAU4+J,gBACnB,SAAyBjkJ,EAAM4jB,GAC7B,OAAOk/H,EAAa32J,KAAM6T,EAAM4jB,GAAU,EAC5C,EAoBJk3G,EAAaz1I,UAAUyhC,KAAO,SAAc9mB,EAAM4jB,GAGhD,OAFA++H,EAAc/+H,GACdz3B,KAAKw3B,GAAG3jB,EAAMujJ,EAAUp3J,KAAM6T,EAAM4jB,IAC7Bz3B,IACT,EAEA2uI,EAAaz1I,UAAU6+J,oBACnB,SAA6BlkJ,EAAM4jB,GAGjC,OAFA++H,EAAc/+H,GACdz3B,KAAK83J,gBAAgBjkJ,EAAMujJ,EAAUp3J,KAAM6T,EAAM4jB,IAC1Cz3B,IACT,EAGJ2uI,EAAaz1I,UAAU03I,eACnB,SAAwB/8H,EAAM4jB,GAC5B,IAAI/pB,EAAM+qB,EAAQhc,EAAU1iB,EAAGi+J,EAK/B,GAHAxB,EAAc/+H,QAGC5J,KADf4K,EAASz4B,KAAK+rE,SAEZ,OAAO/rE,KAGT,QAAa6tB,KADbngB,EAAO+qB,EAAO5kB,IAEZ,OAAO7T,KAET,GAAI0N,IAAS+pB,GAAY/pB,EAAK+pB,WAAaA,EACb,KAAtBz3B,KAAKq2J,aACTr2J,KAAK+rE,QAAUhzE,OAAOa,OAAO,cAEtB6+B,EAAO5kB,GACV4kB,EAAOm4G,gBACT5wI,KAAKq3B,KAAK,iBAAkBxjB,EAAMnG,EAAK+pB,UAAYA,SAElD,GAAoB,mBAAT/pB,EAAqB,CAGrC,IAFA+O,GAAY,EAEP1iB,EAAI2T,EAAKhV,OAAS,EAAGqB,GAAK,EAAGA,IAChC,GAAI2T,EAAK3T,KAAO09B,GAAY/pB,EAAK3T,GAAG09B,WAAaA,EAAU,CACzDugI,EAAmBtqJ,EAAK3T,GAAG09B,SAC3Bhb,EAAW1iB,EACX,KACF,CAGF,GAAI0iB,EAAW,EACb,OAAOzc,KAEQ,IAAbyc,EACF/O,EAAK0Y,QAiIf,SAAmB1Y,EAAMvQ,GACvB,KAAOA,EAAQ,EAAIuQ,EAAKhV,OAAQyE,IAC9BuQ,EAAKvQ,GAASuQ,EAAKvQ,EAAQ,GAC7BuQ,EAAKzG,KACP,CAnIUgxJ,CAAUvqJ,EAAM+O,GAGE,IAAhB/O,EAAKhV,SACP+/B,EAAO5kB,GAAQnG,EAAK,SAEQmgB,IAA1B4K,EAAOm4G,gBACT5wI,KAAKq3B,KAAK,iBAAkBxjB,EAAMmkJ,GAAoBvgI,EAC1D,CAEA,OAAOz3B,IACT,EAEJ2uI,EAAaz1I,UAAUw+B,IAAMi3G,EAAaz1I,UAAU03I,eAEpDjC,EAAaz1I,UAAUg/J,mBACnB,SAA4BrkJ,GAC1B,IAAIgkJ,EAAWp/H,EAAQ1+B,EAGvB,QAAe8zB,KADf4K,EAASz4B,KAAK+rE,SAEZ,OAAO/rE,KAGT,QAA8B6tB,IAA1B4K,EAAOm4G,eAUT,OATyB,IAArBr3I,UAAUb,QACZsH,KAAK+rE,QAAUhzE,OAAOa,OAAO,MAC7BoG,KAAKq2J,aAAe,QACMxoI,IAAjB4K,EAAO5kB,KACY,KAAtB7T,KAAKq2J,aACTr2J,KAAK+rE,QAAUhzE,OAAOa,OAAO,aAEtB6+B,EAAO5kB,IAEX7T,KAIT,GAAyB,IAArBzG,UAAUb,OAAc,CAC1B,IACIO,EADA0N,EAAO5N,OAAO4N,KAAK8xB,GAEvB,IAAK1+B,EAAI,EAAGA,EAAI4M,EAAKjO,SAAUqB,EAEjB,oBADZd,EAAM0N,EAAK5M,KAEXiG,KAAKk4J,mBAAmBj/J,GAK1B,OAHA+G,KAAKk4J,mBAAmB,kBACxBl4J,KAAK+rE,QAAUhzE,OAAOa,OAAO,MAC7BoG,KAAKq2J,aAAe,EACbr2J,IACT,CAIA,GAAyB,mBAFzB63J,EAAYp/H,EAAO5kB,IAGjB7T,KAAK4wI,eAAe/8H,EAAMgkJ,QACrB,QAAkBhqI,IAAdgqI,EAET,IAAK99J,EAAI89J,EAAUn/J,OAAS,EAAGqB,GAAK,EAAGA,IACrCiG,KAAK4wI,eAAe/8H,EAAMgkJ,EAAU99J,IAIxC,OAAOiG,IACT,EAmBJ2uI,EAAaz1I,UAAU2+J,UAAY,SAAmBhkJ,GACpD,OAAOwjJ,EAAWr3J,KAAM6T,GAAM,EAChC,EAEA86H,EAAaz1I,UAAUi/J,aAAe,SAAsBtkJ,GAC1D,OAAOwjJ,EAAWr3J,KAAM6T,GAAM,EAChC,EAEA86H,EAAauD,cAAgB,SAAS+jB,EAASpiJ,GAC7C,MAAqC,mBAA1BoiJ,EAAQ/jB,cACV+jB,EAAQ/jB,cAAcr+H,GAEtBq+H,EAAcz4I,KAAKw8J,EAASpiJ,EAEvC,EAEA86H,EAAaz1I,UAAUg5I,cAAgBA,EAiBvCvD,EAAaz1I,UAAUk/J,WAAa,WAClC,OAAOp4J,KAAKq2J,aAAe,EAAIT,EAAe51J,KAAK+rE,SAAW,EAChE,2DCvaA,IAAIssF,EAAUt5I,MAAM7lB,UAChBilB,EAAUk6I,EAAGl6I,OACbpX,EAAUsxJ,EAAGtxJ,MACb9M,EAAU,EAAQ,mCAetBnC,EAAOC,QAbP,SAAgBqzE,GACd,IAAIvlE,EAAS,CAAC,EACVc,EAAOwX,EAAOzkB,MAAM2+J,EAAItxJ,EAAMtN,KAAKF,UAAW,IAElD,IAAK,IAAIN,KAAOmyE,GACc,IAAxBnxE,EAAQ0M,EAAM1N,KAChB4M,EAAO5M,GAAOmyE,EAAOnyE,IAIzB,OAAO4M,CACT,qDChBA,IAAIgxH,EAAS99H,OAAOG,UAAUM,eAC1B8+J,EAAQv/J,OAAOG,UAAU8H,SACzBhI,EAAiBD,OAAOC,eACxBw5J,EAAOz5J,OAAOq+C,yBAEd9tB,EAAU,SAAiB2lD,GAC9B,MAA6B,mBAAlBlwD,MAAMuK,QACTvK,MAAMuK,QAAQ2lD,GAGK,mBAApBqpF,EAAM7+J,KAAKw1E,EACnB,EAEIhG,EAAgB,SAAuBr1D,GAC1C,IAAKA,GAA2B,oBAApB0kJ,EAAM7+J,KAAKma,GACtB,OAAO,EAGR,IASI3a,EATAs/J,EAAoB1hC,EAAOp9H,KAAKma,EAAK,eACrC4kJ,EAAmB5kJ,EAAI/Z,aAAe+Z,EAAI/Z,YAAYX,WAAa29H,EAAOp9H,KAAKma,EAAI/Z,YAAYX,UAAW,iBAE9G,GAAI0a,EAAI/Z,cAAgB0+J,IAAsBC,EAC7C,OAAO,EAMR,IAAKv/J,KAAO2a,GAEZ,YAAsB,IAAR3a,GAAuB49H,EAAOp9H,KAAKma,EAAK3a,EACvD,EAGI8wF,EAAc,SAAqBxoE,EAAQtiB,GAC1CjG,GAAmC,cAAjBiG,EAAQtC,KAC7B3D,EAAeuoB,EAAQtiB,EAAQtC,KAAM,CACpC/D,YAAY,EACZC,cAAc,EACdM,MAAO8F,EAAQmzF,SACft5F,UAAU,IAGXyoB,EAAOtiB,EAAQtC,MAAQsC,EAAQmzF,QAEjC,EAGIqmE,EAAc,SAAqB7kJ,EAAKjX,GAC3C,GAAa,cAATA,EAAsB,CACzB,IAAKk6H,EAAOp9H,KAAKma,EAAKjX,GACrB,OACM,GAAI61J,EAGV,OAAOA,EAAK5+I,EAAKjX,GAAMxD,KAEzB,CAEA,OAAOya,EAAIjX,EACZ,EAEA7E,EAAOC,QAAU,SAASi2I,IACzB,IAAI/uI,EAAStC,EAAML,EAAK8lH,EAAMs2C,EAAar8F,EACvC96C,EAAShoB,UAAU,GACnBQ,EAAI,EACJrB,EAASa,UAAUb,OACnBinC,GAAO,EAaX,IAVsB,kBAAXpe,IACVoe,EAAOpe,EACPA,EAAShoB,UAAU,IAAM,CAAC,EAE1BQ,EAAI,IAES,MAAVwnB,GAAqC,iBAAXA,GAAyC,mBAAXA,KAC3DA,EAAS,CAAC,GAGJxnB,EAAIrB,IAAUqB,EAGpB,GAAe,OAFfkF,EAAU1F,UAAUQ,IAInB,IAAK4C,KAAQsC,EACZ3C,EAAMm8J,EAAYl3I,EAAQ5kB,GAItB4kB,KAHJ6gG,EAAOq2C,EAAYx5J,EAAStC,MAKvBgjC,GAAQyiF,IAASn5C,EAAcm5C,KAAUs2C,EAAcpvI,EAAQ84F,MAC9Ds2C,GACHA,GAAc,EACdr8F,EAAQ//D,GAAOgtB,EAAQhtB,GAAOA,EAAM,IAEpC+/D,EAAQ//D,GAAO2sE,EAAc3sE,GAAOA,EAAM,CAAC,EAI5CytF,EAAYxoE,EAAQ,CAAE5kB,KAAMA,EAAMy1F,SAAU47C,EAAOruG,EAAM08B,EAAO+lD,WAGtC,IAATA,GACjBr4B,EAAYxoE,EAAQ,CAAE5kB,KAAMA,EAAMy1F,SAAUgwB,KAQjD,OAAO7gG,CACR,0FC7GA,MAAMo3I,EAAQ,QACRC,EAAM,MACNC,EAAO,OACPC,EAAO,OACPC,EAAQ,QACRC,EAAQ,GACRC,EAAW,WACXC,EAAW,WACXC,EAAM,MACNC,EAAiB,iBACjBC,EAAgB,0BAChBC,EAAQ,QACRC,EAAS,SACTC,EAAS,IACTC,EAAQ,QACRntC,EAAI,IACJotC,EAAK,KACLC,EAAU,OACVC,EAAW,KACXC,EAAQ,IACRC,EAAS,SACTC,EAAO,IACPC,EAAU,CACf7kB,OAAQ,CACP8kB,IAAK,CACJC,KAAM,CAAC,MAAO,QAAS,QAAS,QAAS,QAAS,QAAS,QAAS,QAAS,SAC7EC,MAAO,CAAC,IAAK,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,MAAO,QAE/DC,MAAO,CACNF,KAAM,CAAC,MAAO,OAAQ,OAAQ,OAAQ,OAAQ,OAAQ,OAAQ,OAAQ,QACtEC,MAAO,CAAC,IAAK,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,QAGzDE,SAAU,CACTJ,IAAK,CAAC,GAAI,OAAQ,OAAQ,OAAQ,OAAQ,OAAQ,OAAQ,OAAQ,QAClEG,MAAO,CAAC,GAAI,OAAQ,OAAQ,OAAQ,OAAQ,OAAQ,MAAO,QAAS,WAEpE,SAASE,EAAUh6G,GAAK,KACzB45G,GAAO,EAAK,IACZnnB,GAAM,EAAK,KACXrxI,GAAO,EAAE,MACTmT,EAAQ,EAAC,OACTg6H,EAASmqB,EAAK,cACduB,EAAgB,CAAC,EAAC,UAClB/yF,EAAYwxF,EAAK,OACjBwB,EAASX,EAAK,QACdxlH,EAAU,CAAC,EAAC,SACZomH,EAAWzB,EAAK,OAChBhnF,EAAS8nF,EAAM,SACfO,GAAW,EAAK,UAChBK,EAAY,GAAE,SACdC,GAAW,EAAE,eACbC,EAAiBnB,EAAK,UACtBoB,EAAY,GACT,CAAC,GACJ,IAAI7iK,EAAI2iK,EACP95J,EAAM/F,OAAOwlD,GACbz6C,EAAS,GACT6pC,EAAM,EACNu9E,EAAI+rC,EAGDyB,IAAaf,GAChBh4J,EAAO,GACP+4J,EAAWnB,GACDmB,IAAatB,GAAOsB,IAAanB,EAC3C53J,EAAO,EACY,IAATA,EACV+4J,EAAWtB,GAEXz3J,EAAO,GACP+4J,EAAWnB,GAGZ,MAAMtlB,EAAgB,KAATtyI,EAAc,IAAO,KACjCkoH,GAAoB,IAAbywC,EACPS,EAAMj6J,EAAM,EACZk6J,EAAenmJ,KAAKgmJ,GAErB,GAAmB,iBAARt6G,GAAoBz+C,MAAMy+C,GACpC,MAAM,IAAIjoD,UAAU+gK,GAGrB,UAAW2B,IAAiB7B,EAC3B,MAAM,IAAI7gK,UAAUghK,GA0BrB,GAtBIyB,IACHj6J,GAAOA,KAIG,IAAP7I,GAAY6J,MAAM7J,MACrBA,EAAI4c,KAAKE,MAAMF,KAAKujC,IAAIt3C,GAAO+T,KAAKujC,IAAI67F,IAEpCh8I,EAAI,IACPA,EAAI,IAKFA,EAAI,IACH6iK,EAAY,IACfA,GAAa,EAAI7iK,GAGlBA,EAAI,GAGDg6E,IAAWinF,EACd,OAAOjhK,EAIR,GAAY,IAAR6I,EACHgF,EAAO,GAAK,EACZonH,EAAIpnH,EAAO,GAAKm0J,EAAQ7kB,OAAOslB,GAAUP,EAAOrB,EAAOE,GAAO/gK,OACxD,CACN03C,EAAM7uC,GAAgB,IAATa,EAAakT,KAAK2pG,IAAI,EAAO,GAAJvmH,GAAU4c,KAAK2pG,IAAI,IAAMvmH,IAE3DkiK,IACHxqH,GAAY,EAERA,GAAOskG,GAAQh8I,EAAI,IACtB03C,GAAYskG,EACZh8I,MAIF,MAAM8P,EAAI8M,KAAK2pG,IAAI,GAAIvmH,EAAI,EAAI6c,EAAQ,GACvChP,EAAO,GAAKk1J,EAAarrH,EAAM5nC,GAAKA,EAEhCjC,EAAO,KAAOmuI,GAAQh8I,EAAI,IAAmB,IAAd2iK,IAClC90J,EAAO,GAAK,EACZ7N,KAGDi1H,EAAIpnH,EAAO,GAAc,KAATnE,GAAqB,IAAN1J,EAAUkiK,EAAOP,EAAUC,EAAWI,EAAQ7kB,OAAOslB,GAAUP,EAAOrB,EAAOE,GAAO/gK,EACpH,CAuBA,GApBI8iK,IACHj1J,EAAO,IAAMA,EAAO,IAIjBg1J,EAAY,IACfh1J,EAAO,GAAKA,EAAO,GAAGm1J,YAAYH,IAInCh1J,EAAO,GAAKwuC,EAAQxuC,EAAO,KAAOA,EAAO,IAE1B,IAAXgpI,EACHhpI,EAAO,GAAKA,EAAO,GAAGo1J,iBACZpsB,EAAOn2I,OAAS,EAC1BmN,EAAO,GAAKA,EAAO,GAAGo1J,eAAepsB,EAAQ0rB,GACnC/yF,EAAU9uE,OAAS,IAC7BmN,EAAO,GAAKA,EAAO,GAAG7E,WAAW2C,QAAQ61J,EAAQhyF,IAG9CurE,GAAOl+H,EAAQ,EAAG,CACrB,MAAM9a,EAAK8L,EAAO,GAAG7E,WACpBgU,EAAIwyD,IAAeztE,EAAEoG,MAAM,UAAY,IAAI8G,OAASuyJ,EACpD36B,EAAM9kI,EAAEiH,WAAWhE,MAAMgY,GACzBxJ,EAAIqzH,EAAI,IAAMm6B,EACdphI,EAAIpsB,EAAE9S,OACNN,EAAIyc,EAAQ+iB,EAEb/xB,EAAO,GAAK,GAAGg5H,EAAI,KAAK7pH,IAAIxJ,EAAE0vJ,OAAOtjI,EAAIx/B,EAAG2hK,IAC7C,CAOA,OALInwC,IACH/jH,EAAO,GAAK60J,EAAU1iK,GAAK0iK,EAAU1iK,GAAKgiK,EAAQK,SAASI,GAAUziK,IAAMkiK,EAAOtB,EAAME,IAAuB,IAAdjzJ,EAAO,GAAWmzJ,EAAQ1sC,IAIrHt6C,IAAW2mF,EAAQ9yJ,EAASmsE,IAAWunF,EAAS,CACtDpgK,MAAO0M,EAAO,GACdsvI,OAAQtvI,EAAO,GACf80J,SAAU3iK,EACVmjK,KAAMluC,GACHpnH,EAAO5I,KAAKu9J,EACjB,6DC7LA,IAAIY,EAAa,EAAQ,uCAErB9C,EAAQv/J,OAAOG,UAAU8H,SACzBxH,EAAiBT,OAAOG,UAAUM,eAwDtC1B,EAAOC,QAnBO,SAAiB2V,EAAM3S,EAAUsgK,GAC3C,IAAKD,EAAWrgK,GACZ,MAAM,IAAI1C,UAAU,+BAGxB,IAAIy9J,EACAv8J,UAAUb,QAAU,IACpBo9J,EAAWuF,GAGU,mBAArB/C,EAAM7+J,KAAKiU,GA7CA,SAAsB84E,EAAOzrF,EAAU+6J,GACtD,IAAK,IAAI/7J,EAAI,EAAGmuB,EAAMs+D,EAAM9tF,OAAQqB,EAAImuB,EAAKnuB,IACrCP,EAAeC,KAAK+sF,EAAOzsF,KACX,MAAZ+7J,EACA/6J,EAASyrF,EAAMzsF,GAAIA,EAAGysF,GAEtBzrF,EAAStB,KAAKq8J,EAAUtvE,EAAMzsF,GAAIA,EAAGysF,GAIrD,CAoCQ80E,CAAa5tJ,EAAM3S,EAAU+6J,GACN,iBAATpoJ,EAnCF,SAAuBw8G,EAAQnvH,EAAU+6J,GACzD,IAAK,IAAI/7J,EAAI,EAAGmuB,EAAMgiG,EAAOxxH,OAAQqB,EAAImuB,EAAKnuB,IAE1B,MAAZ+7J,EACA/6J,EAASmvH,EAAO4P,OAAO//H,GAAIA,EAAGmwH,GAE9BnvH,EAAStB,KAAKq8J,EAAU5rC,EAAO4P,OAAO//H,GAAIA,EAAGmwH,EAGzD,CA2BQqxC,CAAc7tJ,EAAM3S,EAAU+6J,GAzBlB,SAAuB1qF,EAAQrwE,EAAU+6J,GACzD,IAAK,IAAI3xJ,KAAKinE,EACN5xE,EAAeC,KAAK2xE,EAAQjnE,KACZ,MAAZ2xJ,EACA/6J,EAASqwE,EAAOjnE,GAAIA,EAAGinE,GAEvBrwE,EAAStB,KAAKq8J,EAAU1qF,EAAOjnE,GAAIA,EAAGinE,GAItD,CAiBQowF,CAAc9tJ,EAAM3S,EAAU+6J,EAEtC,qECvDA,IACIwC,EAAQv/J,OAAOG,UAAU8H,SACzBjE,EAAM6X,KAAK7X,IAGX0+J,EAAW,SAAkBtjK,EAAGiH,GAGhC,IAFA,IAAI6vE,EAAM,GAEDl1E,EAAI,EAAGA,EAAI5B,EAAEO,OAAQqB,GAAK,EAC/Bk1E,EAAIl1E,GAAK5B,EAAE4B,GAEf,IAAK,IAAI6kG,EAAI,EAAGA,EAAIx/F,EAAE1G,OAAQkmG,GAAK,EAC/B3vB,EAAI2vB,EAAIzmG,EAAEO,QAAU0G,EAAEw/F,GAG1B,OAAO3vB,CACX,EAqBAn3E,EAAOC,QAAU,SAAc2+J,GAC3B,IAAIn1I,EAASvhB,KACb,GAAsB,mBAAXuhB,GApCA,sBAoCyB+2I,EAAM5+J,MAAM6nB,GAC5C,MAAM,IAAIlpB,UAxCE,kDAwCwBkpB,GAyBxC,IAvBA,IAEIm6I,EAFA5/J,EAxBI,SAAe6/J,EAAS/4I,GAEhC,IADA,IAAIqsD,EAAM,GACDl1E,EAAI6oB,GAAU,EAAGg8E,EAAI,EAAG7kG,EAAI4hK,EAAQjjK,OAAQqB,GAAK,EAAG6kG,GAAK,EAC9D3vB,EAAI2vB,GAAK+8D,EAAQ5hK,GAErB,OAAOk1E,CACX,CAkBe2sF,CAAMriK,UAAW,GAqBxBsiK,EAAc9+J,EAAI,EAAGwkB,EAAO7oB,OAASoD,EAAKpD,QAC1CojK,EAAY,GACP/hK,EAAI,EAAGA,EAAI8hK,EAAa9hK,IAC7B+hK,EAAU/hK,GAAK,IAAMA,EAKzB,GAFA2hK,EAAQx6F,SAAS,SAAU,oBA3CnB,SAAU+N,EAAK8sF,GAEvB,IADA,IAAInnH,EAAM,GACD76C,EAAI,EAAGA,EAAIk1E,EAAIv2E,OAAQqB,GAAK,EACjC66C,GAAOq6B,EAAIl1E,GACPA,EAAI,EAAIk1E,EAAIv2E,SACZk8C,GAAOmnH,GAGf,OAAOnnH,CACX,CAkCqDonH,CAAMF,EAAW,KAAO,4CAAjE56F,EAxBK,WACT,GAAIlhE,gBAAgB07J,EAAO,CACvB,IAAI71J,EAAS0b,EAAO7nB,MAChBsG,KACAy7J,EAAS3/J,EAAMvC,YAEnB,OAAIR,OAAO8M,KAAYA,EACZA,EAEJ7F,IACX,CACA,OAAOuhB,EAAO7nB,MACVg9J,EACA+E,EAAS3/J,EAAMvC,WAGvB,IAUIgoB,EAAOroB,UAAW,CAClB,IAAI+iK,EAAQ,WAAkB,EAC9BA,EAAM/iK,UAAYqoB,EAAOroB,UACzBwiK,EAAMxiK,UAAY,IAAI+iK,EACtBA,EAAM/iK,UAAY,IACtB,CAEA,OAAOwiK,CACX,kECjFA,IAAIQ,EAAiB,EAAQ,kDAE7BpkK,EAAOC,QAAUmpE,SAAShoE,UAAUI,MAAQ4iK,kECF5C,IAAIruI,EAEA4kI,EAAU,EAAQ,2CAElB0J,EAAS,EAAQ,qCACjBC,EAAa,EAAQ,oCACrBC,EAAc,EAAQ,qCACtBC,EAAkB,EAAQ,mCAC1BzmB,EAAe,EAAQ,sCACvBlrB,EAAa,EAAQ,oCACrB4xC,EAAY,EAAQ,mCAEpBtjE,EAAM,EAAQ,yCACdnkF,EAAQ,EAAQ,2CAChB/X,EAAM,EAAQ,yCACd8S,EAAM,EAAQ,yCACd0uG,EAAM,EAAQ,yCACd1pG,EAAQ,EAAQ,2CAChBksG,EAAO,EAAQ,0CAEfy7C,EAAYt7F,SAGZu7F,EAAwB,SAAUC,GACrC,IACC,OAAOF,EAAU,yBAA2BE,EAAmB,iBAAxDF,EACR,CAAE,MAAOxkK,GAAI,CACd,EAEI2kK,EAAQ,EAAQ,gCAChBxxC,EAAkB,EAAQ,8CAE1ByxC,EAAiB,WACpB,MAAM,IAAIjyC,CACX,EACIkyC,EAAiBF,EACjB,WACF,IAGC,OAAOC,CACR,CAAE,MAAOE,GACR,IAEC,OAAOH,EAAMpjK,UAAW,UAAUgL,GACnC,CAAE,MAAOw4J,GACR,OAAOH,CACR,CACD,CACD,CAbE,GAcAA,EAECI,EAAa,EAAQ,sCAAR,GAEbC,EAAW,EAAQ,qCACnBC,EAAa,EAAQ,qDACrBC,EAAc,EAAQ,sDAEtB5yC,EAAS,EAAQ,2DACjBC,EAAQ,EAAQ,0DAEhB4yC,EAAY,CAAC,EAEbC,EAAmC,oBAAfjxG,YAA+B6wG,EAAuBA,EAAS7wG,YAArBv+B,EAE9DyvI,EAAa,CAChBhjK,UAAW,KACX,mBAA8C,oBAAnBijK,eAAiC1vI,EAAY0vI,eACxE,UAAWx+I,MACX,gBAAwC,oBAAhBy+I,YAA8B3vI,EAAY2vI,YAClE,2BAA4BR,GAAcC,EAAWA,EAAS,GAAGtiK,OAAOI,aAAe8yB,EACvF,mCAAoCA,EACpC,kBAAmBuvI,EACnB,mBAAoBA,EACpB,2BAA4BA,EAC5B,2BAA4BA,EAC5B,YAAgC,oBAAZK,QAA0B5vI,EAAY4vI,QAC1D,WAA8B,oBAAXC,OAAyB7vI,EAAY6vI,OACxD,kBAA4C,oBAAlBC,cAAgC9vI,EAAY8vI,cACtE,mBAA8C,oBAAnBC,eAAiC/vI,EAAY+vI,eACxE,YAAah1I,QACb,aAAkC,oBAAbi1I,SAA2BhwI,EAAYgwI,SAC5D,SAAU5uG,KACV,cAAek+F,UACf,uBAAwB2Q,mBACxB,cAAevyF,UACf,uBAAwBwyF,mBACxB,UAAW5B,EACX,SAAU6B,KACV,cAAe5B,EACf,iBAA0C,oBAAjB6B,aAA+BpwI,EAAYowI,aACpE,iBAA0C,oBAAjBC,aAA+BrwI,EAAYqwI,aACpE,yBAA0D,oBAAzBC,qBAAuCtwI,EAAYswI,qBACpF,aAAc3B,EACd,sBAAuBY,EACvB,cAAoC,oBAAdgB,UAA4BvwI,EAAYuwI,UAC9D,eAAsC,oBAAfC,WAA6BxwI,EAAYwwI,WAChE,eAAsC,oBAAfC,WAA6BzwI,EAAYywI,WAChE,aAAc3kJ,SACd,UAAW9X,MACX,sBAAuBm7J,GAAcC,EAAWA,EAASA,EAAS,GAAGtiK,OAAOI,cAAgB8yB,EAC5F,SAA0B,iBAATk+B,KAAoBA,KAAOl+B,EAC5C,QAAwB,oBAARroB,IAAsBqoB,EAAYroB,IAClD,yBAAyC,oBAARA,KAAwBw3J,GAAeC,EAAuBA,GAAS,IAAIz3J,KAAM7K,OAAOI,aAAtC8yB,EACnF,SAAUjZ,KACV,WAAY9Z,OACZ,WAAY23J,EACZ,oCAAqCkK,EACrC,eAAgBzjJ,WAChB,aAAcgX,SACd,YAAgC,oBAAZ1b,QAA0BqZ,EAAYrZ,QAC1D,UAA4B,oBAAViiC,MAAwB5oB,EAAY4oB,MACtD,eAAgB4lH,EAChB,mBAAoBC,EACpB,YAAgC,oBAAZhmH,QAA0BzoB,EAAYyoB,QAC1D,WAAYl5C,OACZ,QAAwB,oBAAR8U,IAAsB2b,EAAY3b,IAClD,yBAAyC,oBAARA,KAAwB8qJ,GAAeC,EAAuBA,GAAS,IAAI/qJ,KAAMvX,OAAOI,aAAtC8yB,EACnF,sBAAoD,oBAAtB0wI,kBAAoC1wI,EAAY0wI,kBAC9E,WAAY1jK,OACZ,4BAA6BmiK,GAAcC,EAAWA,EAAS,GAAGtiK,OAAOI,aAAe8yB,EACxF,WAAYmvI,EAAariK,OAASkzB,EAClC,gBAAiBgoH,EACjB,mBAAoBgnB,EACpB,eAAgBQ,EAChB,cAAe1yC,EACf,eAAsC,oBAAfv+D,WAA6Bv+B,EAAYu+B,WAChE,sBAAoD,oBAAtBqyD,kBAAoC5wF,EAAY4wF,kBAC9E,gBAAwC,oBAAhBouB,YAA8Bh/G,EAAYg/G,YAClE,gBAAwC,oBAAhB2xB,YAA8B3wI,EAAY2wI,YAClE,aAAcjC,EACd,YAAgC,oBAAZn+H,QAA0BvQ,EAAYuQ,QAC1D,YAAgC,oBAAZqgI,QAA0B5wI,EAAY4wI,QAC1D,YAAgC,oBAAZngI,QAA0BzQ,EAAYyQ,QAE1D,4BAA6BksF,EAC7B,6BAA8BD,EAC9B,0BAA2BY,EAC3B,0BAA2B+xC,EAC3B,aAAcjkE,EACd,eAAgBnkF,EAChB,aAAc/X,EACd,aAAc8S,EACd,aAAc0uG,EACd,eAAgB1pG,EAChB,cAAeksG,EACf,2BAA4Bo8C,GAG7B,GAAIF,EACH,IACC,KAAKjhK,KACN,CAAE,MAAOhE,GAER,IAAI0mK,EAAazB,EAASA,EAASjlK,IACnCslK,EAAW,qBAAuBoB,CACnC,CAGD,IAAIC,EAAS,SAASA,EAAOhiK,GAC5B,IAAIxD,EACJ,GAAa,oBAATwD,EACHxD,EAAQsjK,EAAsB,6BACxB,GAAa,wBAAT9/J,EACVxD,EAAQsjK,EAAsB,wBACxB,GAAa,6BAAT9/J,EACVxD,EAAQsjK,EAAsB,8BACxB,GAAa,qBAAT9/J,EAA6B,CACvC,IAAIslB,EAAK08I,EAAO,4BACZ18I,IACH9oB,EAAQ8oB,EAAG/oB,UAEb,MAAO,GAAa,6BAATyD,EAAqC,CAC/C,IAAIiiK,EAAMD,EAAO,oBACbC,GAAO3B,IACV9jK,EAAQ8jK,EAAS2B,EAAI1lK,WAEvB,CAIA,OAFAokK,EAAW3gK,GAAQxD,EAEZA,CACR,EAEI0lK,EAAiB,CACpBvkK,UAAW,KACX,yBAA0B,CAAC,cAAe,aAC1C,mBAAoB,CAAC,QAAS,aAC9B,uBAAwB,CAAC,QAAS,YAAa,WAC/C,uBAAwB,CAAC,QAAS,YAAa,WAC/C,oBAAqB,CAAC,QAAS,YAAa,QAC5C,sBAAuB,CAAC,QAAS,YAAa,UAC9C,2BAA4B,CAAC,gBAAiB,aAC9C,mBAAoB,CAAC,yBAA0B,aAC/C,4BAA6B,CAAC,yBAA0B,YAAa,aACrE,qBAAsB,CAAC,UAAW,aAClC,sBAAuB,CAAC,WAAY,aACpC,kBAAmB,CAAC,OAAQ,aAC5B,mBAAoB,CAAC,QAAS,aAC9B,uBAAwB,CAAC,YAAa,aACtC,0BAA2B,CAAC,eAAgB,aAC5C,0BAA2B,CAAC,eAAgB,aAC5C,sBAAuB,CAAC,WAAY,aACpC,cAAe,CAAC,oBAAqB,aACrC,uBAAwB,CAAC,oBAAqB,YAAa,aAC3D,uBAAwB,CAAC,YAAa,aACtC,wBAAyB,CAAC,aAAc,aACxC,wBAAyB,CAAC,aAAc,aACxC,cAAe,CAAC,OAAQ,SACxB,kBAAmB,CAAC,OAAQ,aAC5B,iBAAkB,CAAC,MAAO,aAC1B,oBAAqB,CAAC,SAAU,aAChC,oBAAqB,CAAC,SAAU,aAChC,sBAAuB,CAAC,SAAU,YAAa,YAC/C,qBAAsB,CAAC,SAAU,YAAa,WAC9C,qBAAsB,CAAC,UAAW,aAClC,sBAAuB,CAAC,UAAW,YAAa,QAChD,gBAAiB,CAAC,UAAW,OAC7B,mBAAoB,CAAC,UAAW,UAChC,oBAAqB,CAAC,UAAW,WACjC,wBAAyB,CAAC,aAAc,aACxC,4BAA6B,CAAC,iBAAkB,aAChD,oBAAqB,CAAC,SAAU,aAChC,iBAAkB,CAAC,MAAO,aAC1B,+BAAgC,CAAC,oBAAqB,aACtD,oBAAqB,CAAC,SAAU,aAChC,oBAAqB,CAAC,SAAU,aAChC,yBAA0B,CAAC,cAAe,aAC1C,wBAAyB,CAAC,aAAc,aACxC,uBAAwB,CAAC,YAAa,aACtC,wBAAyB,CAAC,aAAc,aACxC,+BAAgC,CAAC,oBAAqB,aACtD,yBAA0B,CAAC,cAAe,aAC1C,yBAA0B,CAAC,cAAe,aAC1C,sBAAuB,CAAC,WAAY,aACpC,qBAAsB,CAAC,UAAW,aAClC,qBAAsB,CAAC,UAAW,cAG/BhB,EAAO,EAAQ,yCACfu9H,EAAS,EAAQ,kCACjBioC,EAAUxlK,EAAKG,KAAK+wH,EAAOzrG,MAAM7lB,UAAUilB,QAC3C4gJ,EAAezlK,EAAKG,KAAK8wH,EAAQxrG,MAAM7lB,UAAUk/D,QACjD4mG,EAAW1lK,EAAKG,KAAK+wH,EAAO3vH,OAAO3B,UAAUyK,SAC7Cs7J,EAAY3lK,EAAKG,KAAK+wH,EAAO3vH,OAAO3B,UAAU6N,OAC9Cm4J,EAAQ5lK,EAAKG,KAAK+wH,EAAOptH,OAAOlE,UAAU0V,MAG1CuwJ,EAAa,qGACbC,EAAe,WAiBfC,EAAmB,SAA0B1iK,EAAMquH,GACtD,IACItC,EADA42C,EAAgB3iK,EAOpB,GALIk6H,EAAOgoC,EAAgBS,KAE1BA,EAAgB,KADhB52C,EAAQm2C,EAAeS,IACK,GAAK,KAG9BzoC,EAAOymC,EAAYgC,GAAgB,CACtC,IAAInmK,EAAQmkK,EAAWgC,GAIvB,GAHInmK,IAAUikK,IACbjkK,EAAQwlK,EAAOW,SAEK,IAAVnmK,IAA0B6xH,EACpC,MAAM,IAAIL,EAAW,aAAehuH,EAAO,wDAG5C,MAAO,CACN+rH,MAAOA,EACP/rH,KAAM2iK,EACNnmK,MAAOA,EAET,CAEA,MAAM,IAAI08I,EAAa,aAAel5I,EAAO,mBAC9C,EAEA7E,EAAOC,QAAU,SAAsB4E,EAAMquH,GAC5C,GAAoB,iBAATruH,GAAqC,IAAhBA,EAAKjE,OACpC,MAAM,IAAIiyH,EAAW,6CAEtB,GAAIpxH,UAAUb,OAAS,GAA6B,kBAAjBsyH,EAClC,MAAM,IAAIL,EAAW,6CAGtB,GAAmC,OAA/Bu0C,EAAM,cAAeviK,GACxB,MAAM,IAAIk5I,EAAa,sFAExB,IAAI/pF,EAtDc,SAAsBo+D,GACxC,IAAInmH,EAAQk7J,EAAU/0C,EAAQ,EAAG,GAC7B3kC,EAAO05E,EAAU/0C,GAAS,GAC9B,GAAc,MAAVnmH,GAA0B,MAATwhF,EACpB,MAAM,IAAIswD,EAAa,kDACjB,GAAa,MAATtwD,GAA0B,MAAVxhF,EAC1B,MAAM,IAAI8xI,EAAa,kDAExB,IAAIhwI,EAAS,GAIb,OAHAm5J,EAAS90C,EAAQi1C,GAAY,SAAUh/J,EAAOqgH,EAAQ++C,EAAOC,GAC5D35J,EAAOA,EAAOnN,QAAU6mK,EAAQP,EAASQ,EAAWJ,EAAc,MAAQ5+C,GAAUrgH,CACrF,IACO0F,CACR,CAyCa45J,CAAa9iK,GACrB+iK,EAAoB5zG,EAAMpzD,OAAS,EAAIozD,EAAM,GAAK,GAElDm/D,EAAYo0C,EAAiB,IAAMK,EAAoB,IAAK10C,GAC5D20C,EAAoB10C,EAAUtuH,KAC9BxD,EAAQ8xH,EAAU9xH,MAClBymK,GAAqB,EAErBl3C,EAAQuC,EAAUvC,MAClBA,IACHg3C,EAAoBh3C,EAAM,GAC1Bq2C,EAAajzG,EAAOgzG,EAAQ,CAAC,EAAG,GAAIp2C,KAGrC,IAAK,IAAI3uH,EAAI,EAAG8lK,GAAQ,EAAM9lK,EAAI+xD,EAAMpzD,OAAQqB,GAAK,EAAG,CACvD,IAAI+lK,EAAOh0G,EAAM/xD,GACbgK,EAAQk7J,EAAUa,EAAM,EAAG,GAC3Bv6E,EAAO05E,EAAUa,GAAO,GAC5B,IAEa,MAAV/7J,GAA2B,MAAVA,GAA2B,MAAVA,GACtB,MAATwhF,GAAyB,MAATA,GAAyB,MAATA,IAElCxhF,IAAUwhF,EAEb,MAAM,IAAIswD,EAAa,wDASxB,GAPa,gBAATiqB,GAA2BD,IAC9BD,GAAqB,GAMlB/oC,EAAOymC,EAFXqC,EAAoB,KADpBD,GAAqB,IAAMI,GACmB,KAG7C3mK,EAAQmkK,EAAWqC,QACb,GAAa,MAATxmK,EAAe,CACzB,KAAM2mK,KAAQ3mK,GAAQ,CACrB,IAAK6xH,EACJ,MAAM,IAAIL,EAAW,sBAAwBhuH,EAAO,+CAErD,MACD,CACA,GAAIggK,GAAU5iK,EAAI,GAAM+xD,EAAMpzD,OAAQ,CACrC,IAAI2+C,EAAOslH,EAAMxjK,EAAO2mK,GAWvB3mK,GAVD0mK,IAAUxoH,IASG,QAASA,KAAU,kBAAmBA,EAAK9yC,KAC/C8yC,EAAK9yC,IAELpL,EAAM2mK,EAEhB,MACCD,EAAQhpC,EAAO19H,EAAO2mK,GACtB3mK,EAAQA,EAAM2mK,GAGXD,IAAUD,IACbtC,EAAWqC,GAAqBxmK,EAElC,CACD,CACA,OAAOA,CACR,8ECtXA,IAAIs5J,EAAU,EAAQ,2CAGtB36J,EAAOC,QAAU06J,EAAQj4J,gBAAkB,4ECF3C1C,EAAOC,QAA8B,oBAAZu+C,SAA2BA,QAAQ97C,gBAAmB,iECD/E,IAAIulK,EAAkB,EAAQ,sDAC1BC,EAAmB,EAAQ,qDAE3BC,EAAiB,EAAQ,sCAG7BnoK,EAAOC,QAAUgoK,EACd,SAAkB7zC,GAEnB,OAAO6zC,EAAgB7zC,EACxB,EACE8zC,EACC,SAAkB9zC,GACnB,IAAKA,GAAmB,iBAANA,GAA+B,mBAANA,EAC1C,MAAM,IAAI7zH,UAAU,2BAGrB,OAAO2nK,EAAiB9zC,EACzB,EACE+zC,EACC,SAAkB/zC,GAEnB,OAAO+zC,EAAe/zC,EACvB,EACE,mDC1BLp0H,EAAOC,QAAU,SAAUmoK,EAAM5rG,GAC/B,GAAoB,iBAAT4rG,EACT,MAAM,IAAI7nK,UAAU,qBAgCtB,IA7BA,IA4BIyL,EA5BA8wC,EAAM/5C,OAAOqlK,GAGbC,EAAQ,GAKRC,IAAW9rG,KAASA,EAAK8rG,SAWzBC,IAAW/rG,KAASA,EAAK+rG,SAIzBC,GAAU,EAGVhsH,EAAQggB,GAAiC,iBAAjBA,EAAW,MAAiBA,EAAKhgB,MAAQ,GAG5Dv6C,EAAI,EAAGmuB,EAAM0sB,EAAIl8C,OAAQqB,EAAImuB,EAAKnuB,IAGzC,OAFA+J,EAAI8wC,EAAI76C,IAGR,IAAK,IACL,IAAK,IACL,IAAK,IACL,IAAK,IACL,IAAK,IACL,IAAK,IACL,IAAK,IACL,IAAK,IACL,IAAK,IACL,IAAK,IACHomK,GAAS,KAAOr8J,EAChB,MAEF,IAAK,IACH,GAAIs8J,EAAU,CACZD,GAAS,IACZ,KACC,CAEF,IAAK,IACL,IAAK,IACH,GAAIC,EAAU,CACZD,GAASr8J,EACZ,KACC,CAEF,IAAK,IACH,GAAIs8J,EAAU,CACZE,GAAU,EACbH,GAAS,IACT,KACC,CAEF,IAAK,IACH,GAAIC,EAAU,CACZE,GAAU,EACbH,GAAS,IACT,KACC,CAEF,IAAK,IACH,GAAIG,EAAS,CACXH,GAAS,IACZ,KACC,CACAA,GAAS,KAAOr8J,EAChB,MAEF,IAAK,IAKH,IAFA,IAAIy8J,EAAW3rH,EAAI76C,EAAI,GACnBymK,EAAY,EACK,MAAf5rH,EAAI76C,EAAI,IACZymK,IACAzmK,IAEF,IAAI2kJ,EAAW9pG,EAAI76C,EAAI,GAEvB,GAAKsmK,EAKcG,EAAY,IACV,MAAbD,QAAiC1yI,IAAb0yI,KACP,MAAb7hB,QAAiC7wH,IAAb6wH,IAIxByhB,GAAS,sBACTpmK,KAGAomK,GAAS,eAbXA,GAAS,KAgBX,MAEF,QACEA,GAASr8J,EAUb,OAJKwwC,IAAWA,EAAMr6C,QAAQ,OAC5BkmK,EAAQ,IAAMA,EAAQ,KAGjB,IAAI/iK,OAAO+iK,EAAO7rH,EAC3B,kDC9HAx8C,EAAOC,QAAUgB,OAAOq+C,gFCAxB,IAAIulH,EAAQ,EAAQ,+BAEpB,GAAIA,EACH,IACCA,EAAM,GAAI,SACX,CAAE,MAAO3kK,GAER2kK,EAAQ,IACT,CAGD7kK,EAAOC,QAAU4kK,6ECZjB,IAAIxxC,EAAkB,EAAQ,8CAE1Bs1C,EAAyB,WAC5B,QAASt1C,CACV,EAEAs1C,EAAuBC,wBAA0B,WAEhD,IAAKv1C,EACJ,OAAO,KAER,IACC,OAA8D,IAAvDA,EAAgB,GAAI,SAAU,CAAEhyH,MAAO,IAAKT,MACpD,CAAE,MAAOV,GAER,OAAO,CACR,CACD,EAEAF,EAAOC,QAAU0oK,gECnBjB,IAAIE,EAA+B,oBAAXhmK,QAA0BA,OAC9CimK,EAAgB,EAAQ,uCAG5B9oK,EAAOC,QAAU,WAChB,MAA0B,mBAAf4oK,IACW,mBAAXhmK,SACsB,iBAAtBgmK,EAAW,SACO,iBAAlBhmK,OAAO,QAEXimK,MACR,0DCTA9oK,EAAOC,QAAU,WAChB,GAAsB,mBAAX4C,QAAiE,mBAAjC5B,OAAOiB,sBAAwC,OAAO,EACjG,GAA+B,iBAApBW,OAAOI,SAAyB,OAAO,EAGlD,IAAI6Y,EAAM,CAAC,EACPitJ,EAAMlmK,OAAO,QACbmmK,EAAS/nK,OAAO8nK,GACpB,GAAmB,iBAARA,EAAoB,OAAO,EAEtC,GAA4C,oBAAxC9nK,OAAOG,UAAU8H,SAASvH,KAAKonK,GAA8B,OAAO,EACxE,GAA+C,oBAA3C9nK,OAAOG,UAAU8H,SAASvH,KAAKqnK,GAAiC,OAAO,EAY3E,IAAK,IAAIl5J,KADTgM,EAAIitJ,GADS,GAECjtJ,EAAO,OAAO,EAC5B,GAA2B,mBAAhB7a,OAAO4N,MAAmD,IAA5B5N,OAAO4N,KAAKiN,GAAKlb,OAAgB,OAAO,EAEjF,GAA0C,mBAA/BK,OAAOqhE,qBAAiF,IAA3CrhE,OAAOqhE,oBAAoBxmD,GAAKlb,OAAgB,OAAO,EAE/G,IAAIqoK,EAAOhoK,OAAOiB,sBAAsB4Z,GACxC,GAAoB,IAAhBmtJ,EAAKroK,QAAgBqoK,EAAK,KAAOF,EAAO,OAAO,EAEnD,IAAK9nK,OAAOG,UAAUgB,qBAAqBT,KAAKma,EAAKitJ,GAAQ,OAAO,EAEpE,GAA+C,mBAApC9nK,OAAOq+C,yBAAyC,CAE1D,IAAImiG,EAAgDxgJ,OAAOq+C,yBAAyBxjC,EAAKitJ,GACzF,GAfY,KAeRtnB,EAAWpgJ,QAA8C,IAA1BogJ,EAAW3gJ,WAAuB,OAAO,CAC7E,CAEA,OAAO,CACR,oEC1CA,IAAIokK,EAAa,EAAQ,uCAGzBllK,EAAOC,QAAU,WAChB,OAAOilK,OAAkBriK,OAAOqmK,WACjC,2DCLA,IAAIvnK,EAAOynE,SAAShoE,UAAUO,KAC1BwnK,EAAUloK,OAAOG,UAAUM,eAC3BF,EAAO,EAAQ,yCAGnBxB,EAAOC,QAAUuB,EAAKG,KAAKA,EAAMwnK,uWCPjC,IAAAC,EAAAC,EAAA,wDACAC,EAAAD,EAAA,2DACAE,EAAAF,EAAA,uDAEMG,EAAkBptE,EAAAA,EAAA,GACjBgtE,EAAAK,iBAAe,CAClB9sJ,IAAKysJ,EAAAK,gBAAgBC,QAGzB,SAASC,EAAmBC,EAAmBC,EAAqBC,GAChED,EAAY9yJ,UAAY,EACxB,IACIgzJ,EADAC,EAAeH,EAAY/yJ,KAAK8yJ,GAEpC,GAAII,EAAc,CACdD,EAAgB,GAChB,IAAIE,EAAmB,EACvB,EAAG,CACKA,IAAqBD,EAAa3kK,QAClC0kK,GAAiBH,EAAUxzF,UAAU6zF,EAAkBD,EAAa3kK,QAExE,IAAM6kK,EAAeF,EAAa,GAClCD,GAAiBD,EAAcI,GAC/BD,EAAmBD,EAAa3kK,MAAQ6kK,EAAatpK,MAAM,OACrDopK,EAAeH,EAAY/yJ,KAAK8yJ,IAEtCK,IAAqBL,EAAUhpK,SAC/BmpK,GAAiBH,EAAUxzF,UAAU6zF,GAAAA,MAGzCF,EAAgBH,EAEpB,OAAOG,CACX,CAqBA,IAAMI,EAA4C,CAC9CC,aAAc,WACdt1B,SAAU,6IACVu1B,kBAAmB,sKACnBC,sBAAuB,iKACvBC,UAAW,sMAGTC,EAAsC,CACxCC,KAAM,eACN9iH,MAAO,MACPvgD,QAAS,WAIbnH,EAAAA,OAAA,SACI4vI,EACA50C,GAAAA,IAAAY,OAAAZ,IAAAA,EAAAuvE,EAAAvvE,EAAC70E,EAAAy1E,EAAA4uE,KAAAA,OAAArkJ,IAAAA,EAAA,eAAAA,EAAuB0tH,EAAAj4C,EAAAz0F,QAAAA,OAAA0sI,IAAAA,EAAA,UAAAA,EAAqBriE,EAAAoqB,EAAAl0C,MAE7C,IAAKkoF,EACD,MAAO,GAGX,IAAM66B,EAAeP,EAAcM,GAC7BE,EAAanB,OAP0B/3F,IAAAA,EAAA,MAAAA,GAOAm5F,WACvCC,EAAoB,gBAAZzjK,EAEd,OAAOuiK,EAAmB95B,EAAM66B,GAAa,SAAEj3G,GAC3C,IAAI1lD,EAAS48J,EAAWl3G,GACxB,IAAK1lD,EAAQ,CACT,IAAMoxE,EAAO1rB,EAAM7yD,OAAS,EAAI2oK,EAAA91B,aAAahgF,EAAO,GAAMA,EAAM0vB,WAAW,GAC3Ep1E,GAAU88J,EAAQ,MAAQ1rF,EAAKj2E,SAAS,IAAM,KAAOi2E,GAAQ,IAEjE,OAAOpxE,CACV,GACL,EAEA,IAAM+8J,EAAsC,CACxCrpH,MAAO,OACPkG,MAAO,OAGL7xB,EAAS,4CACTgtH,EAAY,gDAEZioB,EAAgF,CAClFC,IAAK,CACDl1I,OAAMA,EACNgtH,UAASA,EACT9+H,KAAMolJ,EAAA6B,YAAYD,KAEtBE,MAAO,CACHp1I,OAAMA,EACNgtH,UAASA,EACT9+H,KAAMolJ,EAAA6B,YAAYC,OAEtBxB,MAAO,CACH5zI,OAAMA,EACNgtH,UAASA,EACT9+H,KAAMolJ,EAAA6B,YAAYvB,QAIpByB,EAAa/uE,EAAAA,EAAA,GACZ2uE,GAAiB,CACpBpuJ,IAAKouJ,EAAkBrB,QAGrBpnC,EAAev/H,OAAOu/H,aACtB8oC,EAAkB9oC,EAAa,OAE/B+oC,EAA4C,CAC9C1jH,MAAO,OAGX,SAAS2jH,EACL54B,EACAi4B,EACAY,EACAC,GAEA,IAAIC,EAAe/4B,EACbg5B,EAAuBh5B,EAAOA,EAAO9xI,OAAS,GACpD,GAAI2qK,GAAwC,MAAzBG,EACfD,EAAe/4B,OACZ,GAAI84B,GAAqC,MAAzBE,EACnBD,EAAe/4B,MACZ,CACH,IAAMi5B,EAA0BhB,EAAWj4B,GAC3C,GAAIi5B,EACAF,EAAeE,OACZ,GAAkB,MAAdj5B,EAAO,IAA4B,MAAdA,EAAO,GAAY,CAC/C,IAAMk5B,EAAmBl5B,EAAO,GAC1Bm5B,EACkB,KAApBD,GAA+C,KAApBA,EACrBxzI,SAASs6G,EAAOngB,OAAO,GAAI,IAC3Bn6F,SAASs6G,EAAOngB,OAAO,IAEjCk5C,EACII,GAAc,QACRT,EACAS,EAAa,MACbtC,EAAAnnC,cAAcypC,GACdvpC,EAAagnC,EAAAwC,kBAAkBD,IAAeA,EAAW,CAAXA,CAGhE,OAAOJ,CACX,CAGAxrK,EAAAA,aAAA,SACIyyI,EACAz3C,GAAAA,IAACY,QAAAZ,IAAAA,EAAAowE,EAAApwE,GAAAtzC,MAED,OAAK+qF,EAGE44B,EAAiB54B,EAAQ82B,OAL/B3tE,IAAAA,EAAA,MAAAA,GAKyDkwE,UAAU,GAAO,GAFhE,EAGf,EAGA9rK,EAAAA,OAAA,SACI4vI,EACA50C,GAAAA,IAAAY,OAAAZ,IAAAA,EAAA6vE,EAAA7vE,EAAC70E,EAAAy1E,EAAAl0C,MAAAA,OAAAvhC,IAAAA,EAAA,MAAAA,EAAe0tH,EAAAj4C,EAAAp6C,MAAAA,OAAAqyF,IAAAA,EAAA,QAAAnsF,EAAA,gBAAAmsF,EAEhB,IAAKjE,EACD,MAAO,GAGX,IAAMm8B,EAAeb,EAAcxjH,GAAOlG,GACpCkpH,EAAanB,EAAmB7hH,GAAOokH,SACvCR,EAAwB,cAAV9pH,EACd+pH,EAAqB,WAAV/pH,EAEjB,OAAOkoH,EAAmB95B,EAAMm8B,GAAa,SAAEt5B,GAC3C,OAAA44B,EAAiB54B,EAAQi4B,EAAYY,EAAaC,EAAlD,GAER,gICrLavrK,EAAAA,YAAc,CACvB+qK,IAAK,6CACLE,MAAO,uoBACPxB,MAAO,qhCAEEzpK,EAAAA,gBAAmC,CAC5C+qK,IAAO,CACHe,SAAY,CACR,OAAQ,IACR,OAAQ,IACR,SAAU,IACV,SAAU,IACV,QAAS,KAEbnB,WAAc,CACV,IAAK,OACL,IAAK,OACL,IAAM,SACN,IAAK,SACL,IAAK,UAGbM,MAAS,CACLa,SAAY,CACR,SAAU,IACV,QAAS,IACT,SAAU,IACV,SAAU,IACV,UAAW,IACX,QAAS,IACT,SAAU,IACV,SAAU,IACV,UAAW,IACX,UAAW,IACX,WAAY,IACZ,OAAQ,IACR,QAAS,IACT,UAAW,IACX,WAAY,IACZ,QAAS,IACT,SAAU,IACV,OAAQ,IACR,QAAS,IACT,QAAS,IACT,SAAU,IACV,QAAS,IACT,SAAU,IACV,SAAU,IACV,UAAW,IACX,OAAQ,IACR,QAAS,IACT,OAAQ,IACR,QAAS,IACT,OAAQ,IACR,QAAS,IACT,QAAS,IACT,SAAU,IACV,OAAQ,IACR,QAAS,IACT,UAAW,IACX,WAAY,IACZ,QAAS,IACT,SAAU,IACV,QAAS,IACT,SAAU,IACV,SAAU,IACV,UAAW,IACX,SAAU,IACV,UAAW,IACX,QAAS,IACT,SAAU,IACV,UAAW,IACX,WAAY,IACZ,SAAU,IACV,UAAW,IACX,QAAS,IACT,SAAU,IACV,QAAS,IACT,SAAU,IACV,SAAU,IACV,UAAW,IACX,UAAW,IACX,WAAY,IACZ,UAAW,IACX,WAAY,IACZ,UAAW,IACX,WAAY,IACZ,UAAW,IACX,WAAY,IACZ,UAAW,IACX,WAAY,IACZ,UAAW,IACX,WAAY,IACZ,SAAU,IACV,UAAW,IACX,UAAW,IACX,WAAY,IACZ,QAAS,IACT,SAAU,IACV,SAAU,IACV,UAAW,IACX,SAAU,IACV,UAAW,IACX,UAAW,IACX,WAAY,IACZ,UAAW,IACX,WAAY,IACZ,UAAW,IACX,WAAY,IACZ,SAAU,IACV,UAAW,IACX,QAAS,IACT,SAAU,IACV,UAAW,IACX,WAAY,IACZ,UAAW,IACX,WAAY,IACZ,SAAU,IACV,UAAW,IACX,QAAS,IACT,SAAU,IACV,OAAQ,IACR,QAAS,IACT,UAAW,IACX,WAAY,IACZ,UAAW,IACX,WAAY,IACZ,UAAW,IACX,WAAY,IACZ,SAAU,IACV,UAAW,IACX,UAAW,IACX,WAAY,IACZ,QAAS,IACT,SAAU,IACV,SAAU,IACV,UAAW,IACX,UAAW,IACX,WAAY,IACZ,UAAW,IACX,WAAY,IACZ,UAAW,IACX,WAAY,IACZ,SAAU,IACV,UAAW,IACX,QAAS,IACT,SAAU,IACV,UAAW,IACX,WAAY,IACZ,SAAU,IACV,UAAW,IACX,SAAU,IACV,UAAW,IACX,UAAW,IACX,WAAY,IACZ,UAAW,IACX,WAAY,IACZ,SAAU,IACV,UAAW,IACX,UAAW,IACX,WAAY,IACZ,QAAS,IACT,SAAU,IACV,SAAU,IACV,UAAW,IACX,SAAU,IACV,UAAW,IACX,UAAW,IACX,WAAY,IACZ,UAAW,IACX,WAAY,IACZ,UAAW,IACX,WAAY,IACZ,SAAU,IACV,UAAW,IACX,QAAS,IACT,SAAU,IACV,UAAW,IACX,WAAY,IACZ,UAAW,IACX,WAAY,IACZ,SAAU,IACV,UAAW,IACX,QAAS,IACT,SAAU,IACV,OAAQ,IACR,QAAS,IACT,UAAW,IACX,WAAY,IACZ,UAAW,IACX,WAAY,IACZ,UAAW,IACX,WAAY,IACZ,SAAU,IACV,UAAW,IACX,UAAW,IACX,WAAY,IACZ,QAAS,IACT,SAAU,IACV,UAAW,IACX,WAAY,IACZ,UAAW,IACX,WAAY,IACZ,UAAW,IACX,WAAY,IACZ,UAAW,IACX,WAAY,IACZ,SAAU,IACV,UAAW,IACX,QAAS,IACT,SAAU,IACV,UAAW,IACX,WAAY,IACZ,SAAU,IACV,UAAW,IACX,QAAS,IACT,SAAU,IACV,QAAS,IACT,SAAU,IACV,OAAQ,IACR,QAAS,IACT,MAAO,IACP,OAAQ,IACR,MAAO,IACP,OAAQ,IACR,UAAW,IACX,UAAW,IACX,WAAY,IACZ,WAAY,IACZ,SAAU,IACV,SAAU,IACV,UAAW,IACX,SAAU,IACV,SAAU,IACV,WAAY,IACZ,SAAU,IACV,QAAS,IACT,QAAS,IACT,QAAS,IACT,UAAW,IACX,UAAW,IACX,UAAW,IACX,UAAW,IACX,UAAW,IACX,UAAW,IACX,UAAW,IACX,UAAW,IACX,WAAY,IACZ,WAAY,IACZ,WAAY,IACZ,WAAY,IACZ,WAAY,IACZ,SAAU,IACV,SAAU,IACV,UAAW,IACX,SAAU,IACV,UAAW,IACX,UAAW,IACX,YAAa,IACb,SAAU,IACV,QAAS,IACT,UAAW,IACX,SAAU,IACV,UAAW,IACX,WAAY,IACZ,OAAQ,IACR,OAAQ,IACR,OAAQ,IACR,YAAa,IACb,OAAQ,IACR,QAAS,IACT,UAAW,IACX,QAAS,IACT,YAAa,IACb,QAAS,IACT,QAAS,IACT,QAAS,IACT,UAAW,IACX,UAAW,IACX,SAAU,IACV,UAAW,IACX,UAAW,IACX,YAAa,IACb,SAAU,IACV,QAAS,IACT,UAAW,IACX,SAAU,IACV,UAAW,IACX,WAAY,IACZ,OAAQ,IACR,OAAQ,IACR,OAAQ,IACR,YAAa,IACb,OAAQ,IACR,QAAS,IACT,WAAY,IACZ,UAAW,IACX,QAAS,IACT,YAAa,IACb,QAAS,IACT,QAAS,IACT,QAAS,IACT,UAAW,IACX,aAAc,IACd,UAAW,IACX,QAAS,IACT,SAAU,IACV,WAAY,IACZ,UAAW,IACX,UAAW,IACX,UAAW,IACX,UAAW,IACX,WAAY,IACZ,UAAW,IACX,SAAU,IACV,UAAW,IACX,YAAa,IACb,SAAU,IACV,SAAU,IACV,SAAU,IACV,SAAU,IACV,SAAU,IACV,UAAW,IACX,SAAU,IACV,SAAU,IACV,SAAU,IACV,SAAU,IACV,SAAU,IACV,WAAY,IACZ,SAAU,IACV,UAAW,IACX,UAAW,IACX,UAAW,IACX,SAAU,IACV,UAAW,IACX,OAAQ,IACR,SAAU,IACV,QAAS,IACT,UAAW,IACX,WAAY,IACZ,UAAW,IACX,SAAU,IACV,UAAW,IACX,QAAS,IACT,QAAS,IACT,OAAQ,IACR,QAAS,IACT,QAAS,IACT,QAAS,IACT,WAAY,IACZ,QAAS,IACT,SAAU,IACV,UAAW,IACX,OAAQ,IACR,UAAW,IACX,OAAQ,IACR,OAAQ,IACR,QAAS,IACT,QAAS,IACT,SAAU,IACV,SAAU,IACV,SAAU,IACV,UAAW,IACX,WAAY,IACZ,SAAU,IACV,SAAU,IACV,UAAW,IACX,UAAW,IACX,WAAY,IACZ,WAAY,IACZ,SAAU,IACV,SAAU,IACV,QAAS,IACT,WAAY,IACZ,UAAW,IACX,WAAY,IACZ,UAAW,KAEfnB,WAAc,CACV,IAAK,SACL,IAAK,SACL,IAAK,UACL,IAAK,SACL,IAAK,UACL,IAAK,WACL,IAAK,QACL,IAAK,WACL,IAAK,SACL,IAAK,QACL,IAAK,SACL,EAAK,SACL,IAAK,UACL,IAAK,QACL,IAAK,QACL,IAAK,QACL,IAAK,SACL,IAAK,QACL,IAAK,WACL,IAAK,SACL,IAAK,SACL,IAAK,UACL,EAAK,UACL,IAAK,SACL,IAAK,WACL,IAAK,UACL,IAAK,SACL,EAAK,SACL,IAAK,UACL,IAAK,WACL,IAAK,WACL,IAAK,WACL,IAAK,WACL,EAAK,WACL,EAAK,WACL,EAAK,UACL,EAAK,WACL,EAAK,SACL,EAAK,UACL,EAAK,UACL,EAAK,WACL,EAAK,WACL,EAAK,WACL,EAAK,UACL,EAAK,SACL,EAAK,WACL,EAAK,WACL,EAAK,UACL,EAAK,SACL,EAAK,QACL,EAAK,WACL,EAAK,WACL,EAAK,WACL,EAAK,UACL,EAAK,WACL,EAAK,SACL,IAAK,UACL,EAAK,WACL,EAAK,WACL,EAAK,WACL,EAAK,UACL,EAAK,SACL,EAAK,WACL,EAAK,UACL,EAAK,UACL,EAAK,WACL,EAAK,WACL,EAAK,UACL,EAAK,WACL,EAAK,SACL,EAAK,UACL,EAAK,UACL,EAAK,WACL,EAAK,WACL,EAAK,WACL,EAAK,UACL,EAAK,SACL,EAAK,WACL,EAAK,WACL,EAAK,UACL,EAAK,SACL,EAAK,QACL,EAAK,WACL,EAAK,WACL,EAAK,WACL,EAAK,UACL,EAAK,WACL,EAAK,SACL,IAAK,WACL,EAAK,WACL,EAAK,WACL,EAAK,WACL,EAAK,UACL,EAAK,SACL,EAAK,WACL,EAAK,UACL,EAAK,SACL,IAAM,SACN,IAAK,QACL,IAAK,OACL,IAAK,OACL,EAAK,UACL,EAAK,UACL,EAAK,WACL,EAAK,WACL,EAAK,SACL,EAAK,SACL,IAAK,UACL,IAAK,SACL,IAAK,SACL,IAAK,WACL,IAAK,SACL,IAAK,QACL,IAAK,QACL,IAAK,QACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,WACL,IAAK,WACL,IAAK,WACL,IAAK,WACL,IAAK,WACL,IAAK,SACL,EAAK,SACL,EAAK,UACL,EAAK,SACL,EAAK,UACL,EAAK,UACL,EAAK,YACL,EAAK,SACL,EAAK,QACL,EAAK,UACL,EAAK,SACL,EAAK,UACL,EAAK,WACL,EAAK,OACL,EAAK,OACL,EAAK,OACL,EAAK,YACL,EAAK,OACL,EAAK,QACL,EAAK,UACL,EAAK,QACL,EAAK,YACL,EAAK,QACL,EAAK,QACL,EAAK,QACL,EAAK,UACL,EAAK,UACL,EAAK,SACL,EAAK,UACL,EAAK,UACL,EAAK,YACL,EAAK,SACL,EAAK,QACL,EAAK,UACL,EAAK,SACL,EAAK,UACL,EAAK,WACL,EAAK,OACL,EAAK,OACL,EAAK,OACL,EAAK,YACL,EAAK,OACL,EAAK,QACL,EAAK,WACL,EAAK,UACL,EAAK,QACL,EAAK,YACL,EAAK,QACL,EAAK,QACL,EAAK,QACL,EAAK,UACL,EAAK,aACL,EAAK,UACL,EAAK,QACL,IAAK,SACL,IAAK,WACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,EAAK,WACL,EAAK,UACL,EAAK,SACL,IAAK,UACL,EAAK,YACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,UACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,WACL,IAAK,SACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,S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WACL,EAAK,SACL,GAAM,QACN,GAAM,SACN,IAAK,UACL,IAAK,SACL,EAAK,SACL,IAAK,SACL,EAAK,WACL,IAAK,QACL,EAAK,OACL,EAAK,QACL,EAAK,WACL,EAAK,WACL,EAAK,UACL,IAAK,YACL,EAAK,SACL,IAAK,UACL,IAAK,WACL,EAAK,QACL,IAAK,SACL,IAAK,WACL,IAAK,UACL,IAAK,WACL,IAAK,aACL,IAAK,WACL,IAAK,WACL,IAAK,eACL,IAAK,WACL,IAAK,UACL,IAAK,0BACL,IAAK,SACL,EAAK,cACL,IAAK,WACL,IAAK,aACL,IAAK,UACL,GAAM,SACN,IAAK,QACL,IAAK,YACL,IAAK,aACL,EAAK,SACL,EAAK,SACL,EAAK,SACL,IAAK,YACL,IAAK,SACL,IAAK,kBACL,EAAK,WACL,EAAK,QACL,IAAK,UACL,EAAK,UACL,GAAM,QACN,IAAK,UACL,IAAK,QACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,YACL,EAAK,OACL,GAAM,SACN,IAAK,QACL,IAAK,WACL,IAAK,UACL,IAAK,SACL,IAAK,SACL,IAAK,QACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,SACL,IAAK,UACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,cACL,IAAK,iBACL,IAAK,UACL,IAAK,cACL,IAAK,wBACL,IAAK,sBACL,IAAK,UACL,IAAK,sBACL,IAAK,uBACL,IAAK,qBACL,IAAK,uBACL,IAAK,QACL,IAAK,eACL,GAAM,SACN,EAAK,WACL,EAAK,QACL,EAAK,QACL,EAAK,WACL,EAAK,WACL,EAAK,UACL,EAAK,QACL,EAAK,SACL,GAAM,QACN,EAAK,WACL,IAAK,UACL,EAAK,UACL,IAAK,qBACL,IAAK,yBACL,EAAK,UACL,GAAM,SACN,EAAK,YACL,IAAK,UACL,IAAK,SACL,IAAK,UACL,EAAK,gBACL,IAAK,SACL,EAAK,QACL,EAAK,SACL,IAAK,UACL,EAAK,iBACL,EAAK,QACL,GAAM,QACN,IAAK,sBACL,IAAK,SACL,GAAM,SACN,IAAK,WACL,EAAK,SACL,EAAK,SACL,IAAK,OACL,EAAK,UACL,EAAK,WACL,EAAK,WACL,EAAK,WACL,EAAK,UACL,EAAK,QACL,EAAK,SACL,GAAM,QACN,IAAK,QACL,GAAM,SACN,IAAK,QACL,IAAK,cACL,IAAK,SACL,IAAK,mBACL,IAAK,YACL,IAAK,QACL,IAAK,WACL,GAAM,SACN,IAAK,OACL,EAAK,WACL,EAAK,UACL,IAAK,QACL,EAAK,UACL,EAAK,kBACL,EAAK,WACL,EAAK,gBACL,IAAK,SACL,EAAK,WACL,IAAK,WACL,EAAK,SACL,EAAK,UACL,EAAK,SACL,EAAK,WACL,EAAK,UACL,EAAK,QACL,EAAK,SACL,EAAK,aACL,EAAK,WACL,EAAK,UACL,EAAK,OACL,IAAK,QACL,IAAK,QACL,IAAK,SACL,IAAK,OACL,IAAK,OACL,EAAK,UACL,GAAM,SACN,EAAK,SACL,EAAK,aACL,EAAK,WACL,EAAK,UACL,EAAK,SACL,EAAK,UACL,EAAK,QACL,GAAM,QACN,GAAM,SACN,GAAM,SACN,EAAK,WACL,EAAK,UACL,EAAK,SACL,EAAK,SACL,EAAK,UACL,EAAK,WACL,EAAK,QACL,GAAM,QACN,GAAM,SACN,GAAM,SACN,EAAK,SACL,IAAK,OACL,EAAK,WACL,EAAK,WACL,IAAK,SACL,EAAK,WACL,IAAK,qBACL,EAAK,WACL,EAAK,WACL,EAAK,QACL,IAAK,WACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,sBACL,IAAK,oBACL,IAAK,sBACL,IAAK,WACL,IAAK,mBACL,IAAK,oBACL,IAAK,UACL,IAAK,eACL,IAAK,kBACL,IAAK,UACL,IAAK,oBACL,IAAK,mBACL,IAAK,qBACL,IAAK,oBACL,IAAK,kBACL,IAAK,oBACL,IAAK,UACL,IAAK,kBACL,IAAK,cACL,IAAK,SACL,IAAK,OACL,IAAK,aACL,IAAK,QACL,IAAK,SACL,GAAM,QACN,IAAK,OACL,IAAK,UACL,EAAK,WACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,GAAM,SACN,IAAK,YACL,IAAK,YACL,IAAK,QACL,EAAK,WACL,IAAK,OACL,IAAK,QACL,EAAK,QACL,IAAK,gBACL,EAAK,WACL,GAAM,QACN,IAAK,OACL,GAAM,SACN,EAAK,OACL,EAAK,SACL,EAAK,WACL,EAAK,WACL,EAAK,WACL,EAAK,QACL,IAAK,mBACL,KAAM,YACN,GAAM,QACN,IAAK,YACL,IAAK,SACL,EAAK,aACL,IAAK,QACL,IAAK,WACL,IAAK,cACL,IAAK,UACL,IAAK,YACL,IAAK,OACL,KAAM,UACN,IAAK,YACL,IAAK,SACL,IAAK,SACL,KAAM,UACN,KAAM,SACN,IAAK,SACL,KAAM,SACN,IAAK,UACL,KAAM,UACN,KAAM,WACN,IAAK,kBACL,KAAM,uBACN,IAAK,oBACL,IAAK,QACL,IAAK,SACL,IAAK,SACL,KAAM,SACN,KAAM,SACN,IAAK,UACL,KAAM,4BACN,KAAM,sBACN,IAAK,UACL,KAAM,YACN,IAAK,WACL,IAAK,YACL,IAAK,mBACL,KAAM,wBACN,IAAK,qBACL,KAAM,oBACN,IAAK,YACL,KAAM,sBACN,IAAK,YACL,KAAM,UACN,IAAK,cACL,IAAK,UACL,KAAM,YACN,IAAK,WACL,KAAM,qBACN,KAAM,UACN,IAAK,cACL,IAAK,SACL,IAAK,WACL,IAAK,UACL,IAAK,YACL,IAAK,UACL,GAAM,SACN,EAAK,WACL,EAAK,OACL,EAAK,UACL,EAAK,WACL,EAAK,UACL,EAAK,QACL,EAAK,WACL,GAAM,QACN,EAAK,WACL,EAAK,UACL,EAAK,QACL,EAAK,YACL,GAAM,SACN,IAAK,UACL,IAAK,UACL,IAAK,OACL,GAAM,SACN,EAAK,WACL,EAAK,WACL,IAAK,WACL,EAAK,SACL,IAAK,UACL,IAAK,cACL,IAAK,SACL,IAAK,oBACL,IAAK,SACL,EAAK,QACL,GAAM,QACN,EAAK,QACL,EAAK,OACL,IAAK,OACL,EAAK,WACL,IAAK,OACL,IAAK,SACL,IAAK,WACL,IAAK,gBACL,IAAK,UACL,IAAK,UACL,IAAK,SACL,IAAK,UACL,GAAM,SACN,EAAK,QACL,IAAM,SACN,GAAM,QACN,EAAK,cACL,GAAM,SACN,IAAK,aACL,IAAK,QACL,EAAK,WACL,IAAK,SACL,IAAK,sBACL,IAAK,WACL,EAAK,WACL,EAAK,WACL,EAAK,QACL,EAAK,aACL,IAAK,QACL,IAAK,UACL,IAAK,UACL,EAAK,QACL,IAAK,WACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,uBACL,IAAK,qBACL,IAAK,uBACL,IAAK,WACL,IAAK,UACL,IAAK,WACL,IAAK,mBACL,IAAK,UACL,IAAK,qBACL,IAAK,oBACL,IAAK,sBACL,IAAK,qBACL,IAAK,mBACL,IAAK,qBACL,IAAK,mBACL,IAAK,mBACL,EAAK,UACL,IAAK,iBACL,IAAK,UACL,EAAK,YACL,IAAK,QACL,IAAK,gBACL,EAAK,WACL,EAAK,SACL,EAAK,WACL,EAAK,WACL,IAAK,OACL,EAAK,WACL,EAAK,WACL,EAAK,UACL,EAAK,QACL,GAAM,QACN,IAAK,YACL,EAAK,UACL,IAAK,WACL,GAAM,SACN,IAAK,UACL,IAAK,WACL,IAAK,UACL,IAAK,aACL,IAAK,eACL,IAAK,aACL,IAAK,eACL,IAAK,UACL,GAAM,SACN,IAAK,WACL,IAAK,WACL,IAAK,aACL,IAAK,SACL,IAAK,WACL,IAAK,gBACL,IAAK,YACL,IAAK,QACL,IAAK,WACL,IAAK,WACL,IAAK,aACL,EAAK,UACL,IAAK,UACL,EAAK,UACL,EAAK,SACL,KAAM,QACN,EAAK,QACL,EAAK,WACL,EAAK,WACL,EAAK,QACL,GAAM,QACN,IAAK,cACL,EAAK,UACL,KAAM,eACN,IAAK,WACL,IAAK,WACL,IAAK,UACL,IAAK,SACL,IAAK,UACL,GAAM,SACN,IAAK,SACL,GAAM,SACN,EAAK,WACL,EAAK,WACL,IAAK,SACL,IAAK,aACL,EAAK,UACL,EAAK,WACL,EAAK,UACL,EAAK,QACL,EAAK,WACL,GAAM,QACN,EAAK,WACL,EAAK,UACL96J,EAAK,WACL,IAAK,eACL,IAAK,SACL,IAAK,qBACL,IAAK,SACL,IAAK,UACL,EAAK,UACL,GAAM,SACN,IAAK,eACL,IAAK,UACL,IAAK,SACL,IAAK,UACL,IAAK,SACL,IAAK,aACL,IAAK,YACL,IAAK,YACL,EAAK,UACL,EAAK,YACL,EAAK,UACL,GAAM,SACN,EAAK,WACL,EAAK,SACL,IAAK,UACL,IAAK,SACL,EAAK,QACL,IAAK,UACL,IAAK,WACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,sBACL,IAAK,WACL,IAAK,WACL,GAAM,QACN,GAAM,SACN,GAAM,SACN,IAAK,WACL,EAAK,UACL,IAAK,WACL,GAAM,QACN,GAAM,SACN,GAAM,SACN,GAAM,QACN,EAAK,OACL,GAAM,SACN,GAAM,SACN,EAAK,SACL,EAAK,SACL,EAAK,SACL,EAAK,WACL,EAAK,UACL,EAAK,QACL,GAAM,QACN,GAAM,SACN,GAAM,SACN,EAAK,SACL,EAAK,SACL,EAAK,WACL,EAAK,WACL,EAAK,QACL,EAAK,SACL,EAAK,SACL,EAAK,WACL,EAAK,aACL,GAAM,SACN,EAAK,WACL,EAAK,WACL,IAAK,WACL,KAAM,QACN,IAAK,QACL,EAAK,UACL,EAAK,QACL,EAAK,UACL,GAAM,QACN,EAAK,WACL,EAAK,UACL,EAAK,UACL,EAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,WACL,IAAK,SACL,IAAK,aACL,IAAK,SACL,IAAK,UACL,IAAK,SACL,IAAK,kBACL,IAAK,aACL,IAAK,aACL,IAAK,aACL,IAAK,aACL,IAAK,aACL,IAAK,aACL,IAAK,aACL,IAAK,aACL,IAAK,UACL,IAAK,YACL,IAAK,aACL,IAAK,WACL,IAAK,YACL,EAAK,UACL,GAAM,SACN,IAAK,QACL,IAAK,WACL,IAAK,aACL,IAAK,SACL,IAAK,SACL,EAAK,UACL,GAAM,SACN,IAAK,WACL,EAAK,WACL,EAAK,SACL,IAAK,UACL,IAAK,SACL,IAAK,UACL,IAAK,UACL,IAAK,WACL,IAAK,SACL,IAAK,UACL,IAAK,WACL,IAAK,aACL,IAAK,aACL,EAAK,QACL,IAAK,WACL,IAAK,YACL,EAAK,SACL,EAAK,SACL,IAAK,UACL,GAAM,QACN,IAAK,UACL,IAAK,UACL,IAAK,WACL,IAAK,WACL,IAAK,WACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,WACL,IAAK,UACL,IAAK,SACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,KAAM,QACN,KAAM,YACN,IAAK,SACL,GAAM,SACN,IAAK,WACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,SACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,SACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,WACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,WACL,IAAK,UACL,IAAK,WACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,SACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,WACL,GAAM,SACN,IAAK,UACL,KAAM,SACN,IAAK,UACL,IAAK,aACL,IAAK,WACL,IAAK,UACL,EAAK,WACL,IAAK,QACL,IAAK,WACL,IAAK,aACL,IAAK,WACL,IAAK,WACL,IAAK,WACL,KAAM,SACN,IAAK,UACL,IAAK,UACL,EAAK,WACL,EAAK,WACL,EAAK,UACL,IAAK,UACL,IAAK,YACL,EAAK,SACL,IAAK,YACL,IAAK,SACL,GAAM,QACN,EAAK,SACL,IAAK,cACL,EAAK,QACL,IAAK,QACL,IAAK,SACL,EAAK,SACL,IAAK,SACL,IAAK,UACL,IAAK,UACL,IAAK,OACL,IAAK,SACL,IAAK,SACL,IAAK,UACL,IAAK,aACL,IAAK,WACL,IAAK,YACL,IAAK,aACL,IAAK,UACL,IAAK,UACL,IAAK,WACL,IAAK,eACL,IAAK,YACL,GAAM,SACN,IAAK,WACL,IAAK,UACL,IAAK,UACL,GAAM,SACN,IAAK,SACL,IAAK,UACL,IAAK,SACL,IAAK,UACL,IAAK,UACL,IAAK,YACL,IAAK,YACL,IAAK,gBACL,IAAK,gBACL,IAAK,mBACL,IAAK,YACL,IAAK,QACL,IAAK,aACL,IAAK,WACL,IAAK,WACL,IAAK,WACL,IAAK,UACL,KAAM,SACN,IAAK,oBACL,IAAK,YACL,IAAK,UACL,IAAK,UACL,IAAK,WACL,IAAK,UACL,IAAK,WACL,IAAK,SACL,IAAK,WACL,EAAK,WACL,IAAK,WACL,IAAK,UACL,EAAK,WACL,EAAK,QACL,IAAK,mBACL,IAAK,UACL,IAAK,QACL,EAAK,UACL,IAAK,YACL,IAAK,WACL,GAAM,QACN,IAAK,UACL,EAAK,WACL,IAAK,UACL,IAAK,WACL,IAAK,WACL,EAAK,SACL,IAAK,aACL,IAAK,WACL2R,EAAK,WACL,GAAM,SACN,IAAK,SACL,IAAK,WACL,IAAK,WACL,IAAK,UACL,IAAK,aACL,IAAK,WACL,GAAM,SACN,EAAK,SACL,IAAK,SACL,EAAK,WACL,IAAK,UACL,IAAK,iBACL,IAAK,YACL,EAAK,SACL,IAAK,aACL,EAAK,WACL,IAAK,WACL,EAAK,WACL,IAAK,WACL,EAAK,UACL,IAAK,YACL,EAAK,QACL,EAAK,SACL,IAAK,kBACL,GAAM,QACN,IAAK,OACL,EAAK,WACL,IAAK,eACL,IAAK,WACL,IAAK,OACL,IAAK,aACL,EAAK,QACL,IAAK,gBACL,IAAK,WACL,EAAK,UACL,IAAK,eACL,IAAK,WACL,IAAK,WACL,IAAK,SACL,EAAK,QACL,IAAK,SACL,EAAK,UACL,GAAM,SACN,IAAK,SACL,IAAK,WACL,IAAK,UACL,EAAK,YACL,EAAK,eACL,IAAK,WACL,IAAK,YACL,IAAK,YACL,IAAK,aACL,IAAK,iBACL,IAAK,UACL,EAAK,SACL,EAAK,QACL,EAAK,QACL,EAAK,SACL,IAAK,SACL,IAAK,SACL,EAAK,QACL,IAAK,WACL,EAAK,WACL,EAAK,UACL,EAAK,WACL,GAAM,QACN,EAAK,UACLwqJ,GAAM,UACN,IAAK,SACL,EAAK,UACL,IAAK,UACL,EAAK,SACL,GAAM,SACN,IAAK,cACL,IAAK,UACL,IAAK,aACL,IAAK,SACL,IAAK,WACL,IAAK,WACL,IAAK,WACL,IAAK,WACL,IAAK,WACL,IAAK,WACL,IAAK,WACL,IAAK,WACL,IAAK,WACL,IAAK,WACL,IAAK,WACL,IAAK,WACL,IAAK,WACL,IAAK,WACL,IAAK,UACL,IAAK,WACL,GAAM,SACN,IAAK,eACL,EAAK,WACL,EAAK,UACL,IAAK,cACL,EAAK,WACL,EAAK,UACL,EAAK,QACL,EAAK,SACL,IAAK,UACL,IAAK,WACL,IAAK,YACL,IAAK,aACL,KAAM,SACN,IAAK,WACL,GAAM,QACN,EAAK,UACL,EAAK,SACL,IAAK,QACL,IAAK,QACL,IAAK,QACL,IAAK,UACL,IAAK,aACL,IAAK,SACL,IAAK,UACL,GAAM,SACN,EAAK,SACL,IAAK,UACL,IAAK,UACL,IAAK,SACL,IAAK,UACL,IAAK,WACL,IAAK,WACL,IAAK,YACL,IAAK,WACL,KAAM,SACN,EAAK,WACL,IAAK,YACL,IAAK,wBACL,EAAK,WACL,EAAK,UACL,IAAK,cACL,IAAK,SACL,IAAK,WACL,GAAM,QACN,IAAK,WACL,IAAK,WACL,IAAK,UACL,IAAK,WACL,IAAK,WACL,IAAK,WACL,GAAM,SACN,IAAK,WACL,GAAM,SACN,EAAK,WACL,IAAK,WACL,EAAK,WACL,EAAK,UACL,EAAK,QACL,EAAK,SACL,IAAK,UACL,GAAM,QACN,EAAK,WACL,IAAK,SACL,IAAK,SACL,IAAK,WACL,IAAK,UACL,EAAK,UACL,EAAK,UACL,EAAK,WACL,IAAK,SACL,EAAK,UACL,IAAK,WACL,IAAK,UACL,IAAK,aACL,IAAK,aACL,IAAK,aACL,IAAK,UACL,EAAK,SACL,EAAK,UACL,GAAM,SACN,EAAK,SACL,IAAK,WACL,GAAM,SACN,IAAK,UACL,IAAK,YACL,IAAK,UACL,IAAK,WACL,EAAK,WACL,EAAK,UACL,EAAK,SACL,EAAK,UACL,EAAK,QACL,GAAM,QACN,EAAK,UACL,GAAM,SACN,GAAM,SACN,EAAK,WACL,EAAK,UACL,EAAK,UACL,EAAK,aACL,EAAK,WACL,EAAK,QACL,GAAM,QACN,EAAK,WACL,EAAK,SACL,EAAK,SACL,GAAM,SACN,GAAM,SACN,IAAK,WACL,IAAK,UACL,IAAK,eACL,IAAK,SACL,EAAK,WACL,IAAK,aACL,EAAK,WACL,IAAK,UACL,IAAK,eACL,IAAK,UACL,IAAK,YACL,IAAK,WACL,IAAK,kBACL,IAAK,WACL,IAAK,YACL,IAAK,kBACL,IAAK,QACL,IAAK,WACL,IAAK,SACL,KAAM,UACN,IAAK,UACL,IAAK,UACL,IAAK,SACL,IAAK,SACL,IAAK,UACL,IAAK,YACL,IAAK,YACL,EAAK,WACL,EAAK,WACL,EAAK,QACL,IAAK,SACL,IAAK,YACL,IAAK,aACL,IAAK,SACL,IAAK,QACL,IAAK,UACL,IAAK,WACL,IAAK,UACL,IAAK,WACL,IAAK,YACL,IAAK,aACL,KAAM,SACN,IAAK,WACL,IAAK,UACL,IAAK,WACL,GAAM,QACN,IAAK,QACL,IAAK,WACL,IAAK,UACL,EAAK,SACL,IAAK,WACL,IAAK,UACL,EAAK,WACL,IAAK,eACL,IAAK,UACL,IAAK,aACL,IAAK,SACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,SACL,IAAK,WACL,IAAK,UACL,GAAM,SACN,IAAK,WACL,IAAK,YACL,IAAK,WACL,IAAK,YACL,IAAK,SACL,IAAK,WACL,IAAK,WACL,IAAK,QACL,IAAK,UACL,IAAK,WACL,GAAM,SACN,IAAK,UACL,IAAK,UACL,IAAK,UACL,EAAK,WACL,IAAK,SACL,IAAK,UACL,IAAK,WACL,IAAK,WACL,IAAK,YACL,IAAK,WACL,IAAK,iBACL,IAAK,aACL,IAAK,YACL,KAAM,SACN,IAAK,UACL,IAAK,UACL,IAAK,SACL,IAAK,YACL,IAAK,WACL,IAAK,WACL,EAAK,QACL,IAAK,UACL,GAAM,QACN,IAAK,QACL,EAAK,UACL,IAAK,WACL,IAAK,UACL,IAAK,YACL,IAAK,SACL,IAAK,WACL,GAAM,SACN,GAAM,SACN,EAAK,OACL,IAAK,UACL,KAAM,QACN,KAAM,QACN,IAAK,UACL,IAAK,UACL,KAAM,QACN,KAAM,QACN,IAAK,UACL,IAAK,WACL,IAAK,WACL,EAAK,WACL,KAAM,SACN,KAAM,SACN,KAAM,UACN,EAAK,UACL,IAAK,YACL,IAAK,SACL,EAAK,WACL,EAAK,WACL,KAAM,aACN,IAAK,SACL,EAAK,QACL,IAAK,UACL,IAAK,UACL,IAAK,WACL,KAAM,UACN,IAAK,SACL,GAAM,QACN,IAAK,oBACL,IAAK,UACL,IAAK,QACL,IAAK,SACL,EAAK,SACL,KAAM,UACN,IAAK,eACL,IAAK,SACL,GAAM,SACN,IAAK,QACL,KAAM,WACN,KAAM,aACN,IAAK,YACL,IAAK,YACL,IAAK,YACL,IAAK,YACL,KAAM,WACN,KAAM,UACN,IAAK,YACL,IAAK,gBACL,KAAM,WACN,KAAM,WACN,GAAM,SACN,IAAK,SACL,KAAM,eACN,IAAK,SACL,KAAM,eACN,EAAK,WACL,EAAK,OACL,IAAK,QACL,IAAK,WACL,IAAK,UACL,IAAK,WACL,IAAK,WACL,KAAM,SACN,IAAK,WACL,KAAM,SACN,KAAM,SACN,IAAK,YACL,IAAK,WACL,KAAM,SACN,KAAM,SACN,KAAM,YACN,IAAK,WACL,KAAM,YACN,KAAM,UACN,IAAK,UACL,IAAK,WACL,IAAK,WACL,EAAK,WACL,EAAK,UACL,EAAK,QACL,EAAK,WACL,IAAK,SACL,IAAK,WACL,EAAK,UACL,IAAK,UACL,GAAM,QACN,IAAK,SACL,EAAK,WACL,IAAK,QACL,IAAK,UACL,IAAK,UACL,IAAK,YACL,IAAK,QACL,EAAK,UACL,EAAK,UACL,EAAK,YACL,IAAK,SACL,GAAM,SACN,IAAK,SACL,IAAK,UACL,IAAK,QACL,IAAK,QACL,EAAK,SACL,EAAK,SACL,EAAK,SACL,IAAK,WACL,IAAK,SACL,IAAK,YACL,IAAK,QACL,EAAK,WACL,IAAK,SACL,EAAK,WACL,IAAK,aACL,EAAK,SACL,IAAK,UACL,IAAK,SACL,IAAK,WACL,IAAK,UACL,EAAK,QACL,IAAK,WACL,IAAK,WACL,IAAK,WACL,IAAK,YACL,GAAM,QACN,EAAK,QACL,EAAK,WACL,IAAK,UACL,EAAK,OACL,EAAK,UACL,EAAK,YACL,IAAK,SACL,IAAK,aACL,IAAK,YACL,IAAK,WACL,IAAK,UACL,IAAK,YACL,IAAK,YACL,IAAK,aACL,GAAM,SACN,IAAK,UACL,IAAK,QACL,IAAK,eACL,IAAK,UACL,IAAK,SACL,IAAK,WACL,IAAK,UACL,IAAK,aACL,IAAK,aACL,IAAK,aACL,IAAK,WACL,GAAM,SACN,EAAK,QACL,IAAK,WACL,GAAM,QACN,GAAM,SACN,IAAK,WACL,GAAM,SACN,IAAK,YACL,IAAK,UACL,IAAK,WACL,IAAK,SACL,KAAM,SACN,EAAK,WACL,IAAK,aACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,WACL,IAAK,YACL,IAAK,UACL,IAAK,WACL,IAAK,WACL,IAAK,YACL,IAAK,mBACL,IAAK,oBACL,IAAK,WACL,IAAK,UACL,IAAK,UACL,IAAK,SACL,IAAK,SACL,IAAK,UACL,IAAK,YACL,IAAK,YACL,EAAK,WACL,EAAK,WACL,EAAK,QACL,IAAK,SACL,IAAK,YACL,IAAK,SACL,IAAK,SACL,IAAK,WACL,GAAM,QACN,IAAK,WACL,EAAK,QACL,EAAK,WACL,IAAK,UACL,IAAK,WACL,IAAK,SACL,IAAK,QACL,IAAK,eACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,GAAM,SACN,IAAK,WACL,IAAK,YACL,IAAK,SACL,IAAK,WACL,IAAK,aACL,IAAK,WACL,GAAM,SACN,IAAK,WACL,IAAK,kBACL,IAAK,aACL,IAAK,YACL,IAAK,OACL,EAAK,WACL,IAAK,QACL,IAAK,eACL,EAAK,WACL,EAAK,WACL,EAAK,UACL,IAAK,aACL,IAAK,gBACL,IAAK,aACL,IAAK,aACL,EAAK,QACL,IAAK,SACL,IAAK,UACL,IAAK,UACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,GAAM,QACN,IAAK,UACL,EAAK,WACL,EAAK,SACL,IAAK,QACL,EAAK,UACL,EAAK,aACL,IAAK,WACL,IAAK,SACL,IAAK,UACL,IAAK,SACL,IAAK,UACL,IAAK,UACL,IAAK,YACL,IAAK,YACL,IAAK,WACL,IAAK,aACL,IAAK,WACL,IAAK,QACL,IAAK,SACL,KAAM,UACN,EAAK,WACL,IAAK,QACL,IAAK,SACL,IAAK,WACL,GAAM,SACN,IAAK,cACL,KAAM,WACN,KAAM,WACN,GAAM,SACN,IAAK,SACL,IAAK,WACL,IAAK,cACL,IAAK,WACL,IAAK,YACL,IAAK,YACL,IAAK,eACL,IAAK,cACL,IAAK,YACL,IAAK,YACL,IAAK,WACL,IAAK,WACL,IAAK,WACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,cACL,IAAK,WACL,IAAK,YACL,IAAK,YACL,IAAK,YACL,IAAK,YACL,IAAK,YACL,IAAK,YACL,IAAK,eACL,IAAK,cACL,IAAK,YACL,IAAK,WACL,IAAK,WACL,IAAK,WACL,IAAK,UACL,IAAK,WACL,EAAK,UACL,IAAK,WACL,EAAK,QACL,EAAK,WACL,EAAK,WACL,EAAK,QACL,IAAK,WACL,GAAM,QACN,EAAK,UACL,EAAK,aACL,EAAK,UACL,IAAK,UACL,IAAK,aACL,IAAK,WACL,IAAK,WACL,IAAK,WACL,GAAM,SACN,IAAK,YACL,IAAK,WACL,IAAK,SACL,IAAK,SACL,IAAK,WACL,IAAK,aACL,IAAK,YACL,IAAK,UACL,IAAK,YACL,IAAK,aACL,GAAM,SACN,EAAK,SACL,EAAK,UACL,EAAK,WACL,IAAK,SACL,EAAK,WACL,EAAK,UACL,EAAK,WACL,EAAK,UACL,EAAK,QACL,EAAK,WACL,IAAK,WACL,GAAM,QACN,EAAK,WACL,IAAK,UACL,IAAK,aACL,IAAK,WACL,IAAK,UACL,EAAK,UACL,EAAK,UACL,GAAM,SACN,EAAK,YACL,IAAK,UACL,IAAK,aACL,IAAK,WACL,EAAK,UACL,IAA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SAAgB,EAAc,EAAc,GACxC,IAAM,EAAU,IAAI,kBAAW,EAAW,GAE1C,OADA,IAAI,SAAO,EAAS,GAAS,IAAI,GAC1B,EAAQ,IACnB,CAWA,SAAgB,EAAS,EAAc,GACnC,OAAO,EAAc,EAAM,GAAS,QACxC,CAjCI,sFAAU,IAEV,0FAAU,IAcd,kBAeA,aAUA,2BACI,EACA,EACA,GAEA,IAAM,EAAU,IAAI,aAAW,EAAU,EAAS,GAClD,OAAO,IAAI,SAAO,EAAS,EAC/B,EAEA,uDACI,qFAAO,IAQX,iEAEA,yEAEA,qEAAS,gFAAO,IAEhB,IAAM,EAA0B,CAAE,SAAS,GAQ3C,qBACI,EACA,GAEA,YAFA,cAEO,aAAQ,EAAS,EAAM,GAClC,EAEA,oLC3FAgB,OAAOC,eAAejB,EAAS,aAAc,CAAEoB,OAAO,IACtDpB,EAAQksK,eAAiBlsK,EAAQmsK,kBAAe,EAChDnsK,EAAQmsK,aAAe,IAAI1+J,IAAI,CAC3B,WACA,cACA,eACA,eACA,gBACA,mBACA,WACA,UACA,gBACA,sBACA,cACA,mBACA,oBACA,oBACA,iBACA,eACA,UACA,UACA,UACA,UACA,UACA,iBACA,UACA,UACA,cACA,eACA,WACA,eACA,qBACA,cACA,SACA,eACA,gBACA,WACA,iBACA,iBACA,YACF7E,KAAI,SAAU+uC,GAAO,MAAO,CAACA,EAAIloC,cAAekoC,EAAM,KACxD33C,EAAQksK,eAAiB,IAAIz+J,IAAI,CAC7B,gBACA,gBACA,gBACA,gBACA,cACA,WACA,gBACA,kBACA,WACA,cACA,WACA,oBACA,gBACA,eACA,mBACA,YACA,aACA,WACA,eACA,oBACA,eACA,cACA,cACA,mBACA,YACA,aACA,aACA,sBACA,mBACA,eACA,YACA,YACA,YACA,gBACA,sBACA,iBACA,OACA,OACA,cACA,YACA,qBACA,mBACA,mBACA,mBACA,eACA,cACA,eACA,cACA,eACA,iBACA,cACA,UACA,UACA,aACA,UACA,aACA,mBACA,mBACA,cACF7E,KAAI,SAAU+uC,GAAO,MAAO,CAACA,EAAIloC,cAAekoC,EAAM,yGCrGxD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AS,OAAS,EAAG,EAAG,QAClC,MAAS,CAAC,OAAS,OAAS,EAAG,EAAG,QAClC,MAAS,CAAC,OAAS,OAAS,EAAG,EAAG,QAClC,MAAS,CAAC,OAAS,OAAS,EAAG,EAAG,QAClC,MAAS,CAAC,OAAS,OAAS,EAAG,EAAG,QAClC,MAAS,CAAC,OAAS,OAAS,EAAG,EAAG,QAClC,MAAS,CAAC,OAAS,OAAS,EAAG,EAAG,QAClC,MAAS,CAAC,OAAS,OAAS,EAAG,EAAG,QAClC,MAAS,CAAC,OAAS,OAAS,EAAG,EAAG,QAClC,MAAS,CAAC,OAAS,OAAS,EAAG,EAAG,QAClC,MAAS,CAAC,OAAS,OAAS,EAAG,EAAG,QAClC,MAAS,CAAC,OAAS,OAAS,EAAG,EAAG,QAClC,MAAS,CAAC,OAAS,OAAS,EAAG,EAAG,QAClC,MAAS,CAAC,OAAS,OAAS,EAAG,EAAG,QAClC,MAAS,CAAC,OAAS,OAAS,EAAG,EAAG,QAClC,MAAS,CAAC,OAAS,OAAS,EAAG,EAAG,QAClC,MAAS,CAAC,OAAS,OAAS,EAAG,EAAG,QAClC,MAAS,CAAC,OAAS,OAAS,EAAG,EAAG,QAClC,MAAS,CAAC,OAAS,OAAS,EAAG,EAAG,QAClC,MAAS,CAAC,OAAS,OAAS,EAAG,EAAG,QAClC,MAAS,CAAC,OAAS,OAAS,EAAG,EAAG,QAClC,MAAS,CAAC,OAAS,OAAS,EAAG,EAAG,QAClC,MAAS,CAAC,OAAS,OAAS,EAAG,EAAG,QAClC,MAAS,CAAC,OAAS,OAAS,EAAG,EAAG,QAClC,MAAS,CAAC,EAAG,OAAS,OAAS,EAAG,QAClC,MAAS,CAAC,OAAS,OAAS,EAAG,EAAG,QAClC,MAAS,CAAC,OAAS,OAAS,EAAG,EAAG,QAClC,MAAS,CAAC,OAAS,OAAS,EAAG,EAAG,QAClC,MAAS,CAAC,OAAS,OAAS,EAAG,EAAG,QAClC,MAAS,CAAC,OAAS,OAAS,EAAG,EAAG,QAClC,MAAS,CAAC,OAAS,OAAS,EAAG,EAAG,QAClC,MAAS,CAAC,OAAS,OAAS,EAAG,EAAG,QAClC,MAAS,CAAC,OAAS,OAAS,EAAG,EAAG,QAClC,MAAS,CAAC,OAAS,OAAS,EAAG,EAAG,QAClC,MAAS,CAAC,OAAS,OAAS,EAAG,EAAG,QAClC,MAAS,CAAC,OAAS,OAAS,EAAG,EAAG,QAClC,MAAS,CAAC,OAAS,OAAS,EAAG,EAAG,SAEpC,sBAAuB,CACrB,GAAM,CAAC,EAAG,EAAG,EAAG,EAAG,KACnB,GAAM,CAAC,EAAG,OAAS,EAAG,OAAS,QAC/B,GAAM,CAAC,EAAG,OAAS,OAAS,OAAS,QACrC,GAAM,CAAC,EAAG,OAAS,OAAS,OAAS,QACrC,GAAM,CAAC,EAAG,OAAS,OAAS,OAAS,QACrC,GAAM,CAAC,EAAG,OAAS,OAAS,OAAS,QACrC,GAAM,CAAC,EAAG,OAAS,OAAS,OAAS,QACrC,GAAM,CAAC,OAAS,OAAS,MAAQ,OAAS,QAC1C,GAAM,CAAC,EAAG,OAAS,OAAS,OAAS,QACrC,GAAM,CAAC,EAAG,OAAS,OAAS,EAAG,QAC/B,GAAM,CAAC,OAAS,OAAS,OAAS,OAAS,QAC3C,GAAM,CAAC,EAAG,OAAS,OAAS,OAAS,QACrC,GAAM,CAAC,EAAG,OAAS,EAAG,OAAS,QAC/B,GAAM,CAAC,EAAG,OAAS,EAAG,OAAS,QAC/B,GAAM,CAAC,EAAG,OAAS,OAAS,OAAS,QACrC,GAAM,CAAC,EAAG,OAAS,OAAS,OAAS,QACrC,GAAM,CAAC,EAAG,OAAS,OAAS,OAAS,QACrC,GAAM,CAAC,OAAS,OAAS,EAAG,OAAS,QACrC,GAAM,CAAC,EAAG,OAAS,EAAG,OAAS,OAC/B,GAAM,CAAC,EAAG,OAAS,KAAO,OAAS,QACnC,GAAM,CAAC,EAAG,OAAS,OAAS,EAAG,QAC/B,GAAM,CAAC,EAAG,OAAS,OAAS,OAAS,QACrC,GAAM,CAAC,EAAG,OAAS,OAAS,EAAG,QAC/B,GAAM,CAAC,EAAG,OAAS,OAAS,OAAS,QACrC,GAAM,CAAC,EAAG,OAAS,OAAS,OAAS,OACrC,GAAM,CAAC,OAAS,OAAS,OAAS,OAAS,QAC3C,GAAM,CAAC,EAAG,OAAS,OAAS,OAAS,QACrC,IAAO,CAAC,EAAG,EAAG,EAAG,EAAG,MAEtB,kBAAmB,CACjB,GAAM,CAAC,EAAG,EAAG,EAAG,EAAG,KACnB,GAAM,CAAC,EAAG,OAAS,EAAG,EAAG,QACzB,GAAM,CAAC,EAAG,OAAS,EAAG,EAAG,QACzB,GAAM,CAAC,EAAG,OAAS,EAAG,EAAG,QACzB,GAAM,CAAC,EAAG,OAAS,EAAG,EAAG,QACzB,GAAM,CAAC,OAAS,OAAS,EAAG,EAAG,QAC/B,GAAM,CAAC,OAAS,OAAS,EAAG,EAAG,QAC/B,GAAM,CAAC,EAAG,OAAS,EAAG,EAAG,QACzB,GAAM,CAAC,OAAS,OAAS,EAAG,EAAG,QAC/B,GAAM,CAAC,EAAG,OAAS,EAAG,EAAG,QACzB,GAAM,CAAC,OAAS,OAAS,EAAG,EAAG,QAC/B,GAAM,CAAC,EAAG,OAAS,EAAG,EAAG,QACzB,GAAM,CAAC,OAAS,OAAS,EAAG,EAAG,QAC/B,GAAM,CAAC,EAAG,OAAS,EAAG,EAAG,QACzB,GAAM,CAAC,EAAG,OAAS,EAAG,EAAG,QACzB,GAAM,CAAC,EAAG,OAAS,EAAG,EAAG,QACzB,GAAM,CAAC,OAAS,OAAS,EAAG,EAAG,QAC/B,GAAM,CAAC,OAAS,OAAS,EAAG,EAAG,QAC/B,GAAM,CAAC,OAAS,OAAS,EAAG,EAAG,QAC/B,GAAM,CAAC,EAAG,OAAS,EAAG,EAAG,QACzB,GAAM,CAAC,OAAS,OAAS,EAAG,EAAG,QAC/B,GAAM,CAAC,EAAG,OAAS,EAAG,EAAG,QACzB,GAAM,CAAC,OAAS,OAAS,EAAG,EAAG,QAC/B,GAAM,CAAC,EAAG,OAAS,EAAG,EAAG,QACzB,GAAM,CAAC,OAAS,OAAS,EAAG,EAAG,QAC/B,GAAM,EAAE,OAAS,OAAS,EAAG,EAAG,QAChC,GAAM,CAAC,EAAG,OAAS,EAAG,EAAG,QACzB,GAAM,CAAC,EAAG,OAAS,EAAG,EAAG,OACzB,GAAM,CAAC,EAAG,OAAS,EAAG,EAAG,QACzB,GAAM,CAAC,EAAG,OAAS,EAAG,EAAG,QACzB,GAAM,CAAC,EAAG,OAAS,EAAG,EAAG,QACzB,GAAM,CAAC,EAAG,OAAS,EAAG,EAAG,QACzB,GAAM,CAAC,OAAS,OAAS,EAAG,EAAG,QAC/B,GAAM,CAAC,EAAG,OAAS,EAAG,EAAG,QACzB,GAAM,CAAC,OAAS,OAAS,EA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B,GAAM,CAAC,EAAG,OAAS,EAAG,EAAG,MACzB,GAAM,CAAC,EAAG,OAAS,EAAG,EAAG,MACzB,GAAM,CAAC,EAAG,OAAS,EAAG,EAAG,MACzB,GAAM,CAAC,EAAG,OAAS,EAAG,EAAG,MACzB,GAAM,CAAC,EAAG,OAAS,EAAG,EAAG,MACzB,GAAM,CAAC,EAAG,OAAS,EAAG,EAAG,MACzB,GAAM,CAAC,EAAG,OAAS,EAAG,EAAG,MACzB,GAAM,CAAC,EAAG,OAAS,EAAG,EAAG,MACzB,GAAM,CAAC,EAAG,OAAS,EAAG,EAAG,MACzB,GAAM,CAAC,EAAG,OAAS,EAAG,EAAG,MACzB,GAAM,CAAC,EAAG,OAAS,EAAG,EAAG,MACzB,GAAM,CAAC,EAAG,OAAS,EAAG,EAAG,MACzB,GAAM,CAAC,EAAG,OAAS,EAAG,EAAG,MACzB,GAAM,CAAC,EAAG,OAAS,EAAG,EAAG,MACzB,GAAM,CAAC,OAAS,OAAS,EAAG,EAAG,MAC/B,GAAM,CAAC,EAAG,OAAS,EAAG,EAAG,MACzB,GAAM,CAAC,EAAG,OAAS,EAAG,EAAG,MACzB,GAAM,CAAC,EAAG,OAAS,EAAG,EAAG,MACzB,GAAM,CAAC,EAAG,OAAS,EAAG,EAAG,MACzB,GAAM,CAAC,EAAG,OAAS,EAAG,EAAG,MACzB,GAAM,CAAC,EAAG,OAAS,EAAG,EAAG,MACzB,GAAM,CAAC,EAAG,OAAS,EAAG,EAAG,MACzB,GAAM,CAAC,EAAG,OAAS,EAAG,EAAG,MACzB,GAAM,CAAC,EAAG,OAAS,EAAG,EAAG,MACzB,GAAM,CAAC,OAAS,OAAS,EAAG,EAAG,MAC/B,GAAM,CAAC,OAAS,OAAS,EAAG,EAAG,MAC/B,GAAM,CAAC,OAAS,OAAS,EAAG,EAAG,MAC/B,GAAM,CAAC,EAAG,OAAS,EAAG,EAAG,MACzB,GAAM,CAAC,OAAS,EAAG,EAAG,EAAG,MACzB,GAAM,CAAC,EAAG,OAAS,EAAG,EAAG,MACzB,GAAM,CAAC,EAAG,OAAS,EAAG,EAAG,MACzB,GAAM,CAAC,EAAG,OAAS,EAAG,EAAG,MACzB,GAAM,CAAC,EAAG,OAAS,EAAG,EAAG,MACzB,IAAO,CAAC,EAAG,OAAS,EAAG,EAAG,MAC1B,IAAO,CAAC,EAAG,OAAS,EAAG,EAAG,MAC1B,IAAO,CAAC,EAAG,OAAS,EAAG,EAAG,MAC1B,IAAO,CAAC,OAAS,OAAS,EAAG,EAAG,MAChC,IAAO,CAAC,EAAG,OAAS,EAAG,EAAG,MAC1B,IAAO,CAAC,EAAG,OAAS,EAAG,EAAG,MAC1B,IAAO,CAAC,OAAS,OAAS,EAAG,EAAG,MAChC,IAAO,CAAC,EAAG,OAAS,EAAG,EAAG,MAC1B,IAAO,CAAC,EAAG,OAAS,EAAG,EAAG,MAC1B,IAAO,CAAC,EAAG,OAAS,EAAG,EAAG,MAC1B,IAAO,CAAC,EAAG,OAAS,EAAG,EAAG,MAC1B,IAAO,CAAC,EAAG,OAAS,EAAG,EAAG,MAC1B,IAAO,CAAC,OAAS,OAAS,EAAG,EAAG,MAChC,IAAO,CAAC,OAAS,OAAS,EAAG,EAAG,MAChC,IAAO,CAAC,EAAG,OAAS,EAAG,EAAG,MAC1B,IAAO,CAAC,EAAG,OAAS,EAAG,EAAG,MAC1B,IAAO,CAAC,EAAG,OAAS,EAAG,EAAG,MAC1B,IAAO,CAAC,EAAG,OAAS,EAAG,EAAG,MAC1B,IAAO,CAAC,EAAG,OAAS,EAAG,EAAG,MAC1B,IAAO,CAAC,EAAG,OAAS,EAAG,EAAG,MAC1B,IAAO,CAAC,EAAG,OAAS,EAAG,EAAG,MAC1B,IAAO,CAAC,OAAS,OAAS,EAAG,EAAG,MAChC,IAAO,CAAC,EAAG,OAAS,EAAG,EAAG,MAC1B,IAAO,CAAC,OAAS,OAAS,EAAG,EAAG,MAChC,IAAO,CAAC,OAAS,OAAS,EAAG,EAAG,MAChC,IAAO,CAAC,OAAS,OAAS,EAAG,EAAG,MAChC,IAAO,CAAC,EAAG,OAAS,EAAG,EAAG,MAC1B,IAAO,CAAC,EAAG,OAAS,EAAG,EAAG,MAC1B,IAAO,CAAC,EAAG,EAAG,EAAG,EAAG,MACpB,IAAO,CAAC,EAAG,OAAS,EAAG,EAAG,MAC1B,IAAO,CAAC,OAAS,EAAG,EAAG,EAAG,MAC1B,IAAO,CAAC,EAAG,OAAS,EAAG,EAAG,MAC1B,IAAO,CAAC,OAAS,OAAS,EAAG,EAAG,MAChC,IAAO,CAAC,EAAG,OAAS,EA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,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,MACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,MACL,EAAK,MACL,EAAK,MACL,EAAK,KACL,EAAK,KACL,EAAK,MACL,EAAK,MACL,EAAK,MACL,EAAK,KACL,EAAK,MACL,EAAK,KACL,EAAK,MACL,EAAK,KACL,EAAK,KACL,EAAK,MACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,MACL,EAAK,MACL,EAAK,KACL,EAAK,MACL,EAAK,KACL,EAAK,KACL,EAAK,MACL,EAAK,MACL,EAAK,MACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,MACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,MACL,EAAK,KACL,EAAK,MACL,EAAK,MACL,EAAK,MACL,EAAK,KACL,EAAK,MACL,EAAK,MACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,MACL,EAAK,MACL,EAAK,MACL,EAAK,KACL,EAAK,MACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,MACL,EAAK,KACL,EAAK,MACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,MACL,EAAK,MACL,EAAK,MACL,EAAK,MACL,EAAK,KACL,EAAK,MACL,EAAK,KACL,EAAK,MACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,MACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,MACL,EAAK,MACL,EAAK,MACL,EAAK,KACL,EAAK,KACL,EAAK,MACL,EAAK,MACL,EAAK,MACL,EAAK,KACL,EAAK,MACL,EAAK,KACL,EAAK,MACL,EAAK,KACL,EAAK,KACL,EAAK,MACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,MACL,EAAK,MACL,EAAK,KACL,EAAK,MACL,EAAK,KACL,EAAK,KACL,EAAK,MACL,EAAK,MACL,EAAK,MACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,MACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL,EAAK,KACL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","sources":["webpack://element-web/./node_modules/@babel/runtime/helpers/assertThisInitialized.js","webpack://element-web/./node_modules/@babel/runtime/helpers/classCallCheck.js","webpack://element-web/./node_modules/@babel/runtime/helpers/createClass.js","webpack://element-web/./node_modules/@babel/runtime/helpers/defineProperty.js","webpack://element-web/./node_modules/@babel/runtime/helpers/esm/extends.js","webpack://element-web/./node_modules/@babel/runtime/helpers/esm/inheritsLoose.js","webpack://element-web/./node_modules/@babel/runtime/helpers/esm/objectWithoutProperties.js","webpack://element-web/./node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js","webpack://element-web/./node_modules/@babel/runtime/helpers/esm/setPrototypeOf.js","webpack://element-web/./node_modules/@babel/runtime/helpers/getPrototypeOf.js","webpack://element-web/./node_modules/@babel/runtime/helpers/inherits.js","webpack://element-web/./node_modules/@babel/runtime/helpers/interopRequireDefault.js","webpack://element-web/./node_modules/@babel/runtime/helpers/possibleConstructorReturn.js","webpack://element-web/./node_modules/@babel/runtime/helpers/setPrototypeOf.js","webpack://element-web/./node_modules/@babel/runtime/helpers/toPrimitive.js","webpack://element-web/./node_modules/@babel/runtime/helpers/toPropertyKey.js","webpack://element-web/./node_modules/@babel/runtime/helpers/typeof.js","webpack://element-web/./node_modules/@element-hq/element-web-module-api/node_modules/semver/internal/constants.js","webpack://element-web/./node_modules/@element-hq/element-web-module-api/node_modules/semver/internal/debug.js","webpack://element-web/./node_modules/@element-hq/element-web-module-api/node_modules/semver/internal/re.js","webpack://element-web/./node_modules/@element-hq/element-web-module-api/node_modules/semver/internal/parse-options.js","webpack://element-web/./node_modules/@element-hq/element-web-module-api/node_modules/semver/internal/identifiers.js","webpack://element-web/./node_modules/@element-hq/element-web-module-api/node_modules/semver/classes/semver.js","webpack://element-web/./node_modules/@element-hq/element-web-module-api/node_modules/semver/functions/parse.js","webpack://element-web/./node_modules/@element-hq/element-web-module-api/node_modules/semver/functions/compare.js","webpack://element-web/./node_modules/@element-hq/element-web-module-api/node_modules/semver/functions/compare-build.js","webpack://element-web/./node_modules/@element-hq/element-web-module-api/node_modules/semver/functions/gt.js","webpack://element-web/./node_modules/@element-hq/element-web-module-api/node_modules/semver/functions/lt.js","webpack://element-web/./node_modules/@element-hq/element-web-module-api/node_modules/semver/functions/eq.js","webpack://element-web/./node_modules/@element-hq/element-web-module-api/node_modules/semver/functions/neq.js","webpack://element-web/./node_modules/@element-hq/element-web-module-api/node_modules/semver/functions/gte.js","webpack://element-web/./node_modules/@element-hq/element-web-module-api/node_modules/semver/functions/lte.js","webpack://element-web/./node_modules/@element-hq/element-web-module-api/node_modules/semver/functions/cmp.js","webpack://element-web/./node_modules/@element-hq/element-web-module-api/node_modules/semver/classes/range.js","webpack://element-web/./node_modules/@element-hq/element-web-module-api/node_modules/semver/internal/lrucache.js","webpack://element-web/./node_modules/@element-hq/element-web-module-api/node_modules/semver/classes/comparator.js","webpack://element-web/./node_modules/@element-hq/element-web-module-api/node_modules/semver/functions/satisfies.js","webpack://element-web/./node_modules/@element-hq/element-web-module-api/node_modules/semver/ranges/outside.js","webpack://element-web/./node_modules/@element-hq/element-web-module-api/node_modules/semver/index.js","webpack://element-web/./node_modules/@element-hq/element-web-module-api/node_modules/semver/functions/valid.js","webpack://element-web/./node_modules/@element-hq/element-web-module-api/node_modules/semver/functions/clean.js","webpack://element-web/./node_modules/@element-hq/element-web-module-api/node_modules/semver/functions/inc.js","webpack://element-web/./node_modules/@element-hq/element-web-module-api/node_modules/semver/functions/diff.js","webpack://element-web/./node_modules/@element-hq/element-web-module-api/node_modules/semver/functions/major.js","webpack://element-web/./node_modules/@element-hq/element-web-module-api/node_modules/semver/functions/minor.js","webpack://element-web/./node_modules/@element-hq/element-web-module-api/node_modules/semver/functions/patch.js","webpack://element-web/./node_modules/@element-hq/element-web-module-api/node_modules/semver/functions/prerelease.js","webpack://element-web/./node_modules/@element-hq/element-web-module-api/node_modules/semver/functions/rcompare.js","webpack://element-web/./node_modules/@element-hq/element-web-module-api/node_modules/semver/functions/compare-loose.js","webpack://element-web/./node_modules/@element-hq/element-web-module-api/node_modules/semver/functions/sort.js","webpack://element-web/./node_modules/@element-hq/element-web-module-api/node_modules/semver/functions/rsort.js","webpack://element-web/./node_modules/@element-hq/element-web-module-api/node_modules/semver/functions/coerce.js","webpack://element-web/./node_modules/@element-hq/element-web-module-api/node_modules/semver/ranges/to-comparators.js","webpack://element-web/./node_modules/@element-hq/element-web-module-api/node_modules/semver/ranges/max-satisfying.js","webpack://element-web/./node_modules/@element-hq/element-web-module-api/node_modules/semver/ranges/min-satisfying.js","webpack://element-web/./node_modules/@element-hq/element-web-module-api/node_modules/semver/ranges/min-version.js","webpack://element-web/./node_modules/@element-hq/element-web-module-api/node_modules/semver/ranges/valid.js","webpack://element-web/./node_modules/@element-hq/element-web-module-api/node_modules/semver/ranges/gtr.js","webpack://element-web/./node_modules/@element-hq/element-web-module-api/node_modules/semver/ranges/ltr.js","webpack://element-web/./node_modules/@element-hq/element-web-module-api/node_modules/semver/ranges/intersects.js","webpack://element-web/./node_modules/@element-hq/element-web-module-api/node_modules/semver/ranges/simplify.js","webpack://element-web/./node_modules/@element-hq/element-web-module-api/node_modules/semver/ranges/subset.js","webpack://element-web/./node_modules/@element-hq/element-web-module-api/src/api.ts","webpack://element-web/./node_modules/@element-hq/element-web-module-api/src/loader.ts","webpack://element-web/./node_modules/@floating-ui/utils/dist/floating-ui.utils.mjs","webpack://element-web/./node_modules/@floating-ui/core/dist/floating-ui.core.mjs","webpack://element-web/./node_modules/@floating-ui/dom/dist/floating-ui.dom.mjs","webpack://element-web/./node_modules/@floating-ui/react-dom/dist/floating-ui.react-dom.mjs","webpack://element-web/./node_modules/@floating-ui/react/dist/floating-ui.react.utils.mjs","webpack://element-web/./node_modules/tabbable/src/index.js","webpack://element-web/./node_modules/@floating-ui/react/dist/floating-ui.react.mjs","webpack://element-web/./node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.mjs","webpack://element-web/./node_modules/@matrix-org/emojibase-bindings/build/emoji.js","webpack://element-web/./node_modules/@matrix-org/react-sdk-module-api/lib/components/Spinner.js","webpack://element-web/./node_modules/@matrix-org/react-sdk-module-api/lib/components/TextInputField.js","webpack://element-web/./node_modules/@matrix-org/react-sdk-module-api/lib/lifecycles/CryptoSetupExtensions.js","webpack://element-web/./node_modules/@matrix-org/react-sdk-module-api/lib/lifecycles/ExperimentalExtensions.js","webpack://element-web/./node_modules/@matrix-org/react-sdk-module-api/lib/lifecycles/RoomViewLifecycle.js","webpack://element-web/./node_modules/@radix-ui/primitive/dist/index.mjs","webpack://element-web/./node_modules/@radix-ui/react-compose-refs/dist/index.mjs","webpack://element-web/./node_modules/@radix-ui/react-context/dist/index.mjs","webpack://element-web/./node_modules/@radix-ui/react-id/dist/index.mjs","webpack://element-web/./node_modules/@radix-ui/react-primitive/dist/index.mjs","webpack://element-web/./node_modules/@radix-ui/react-slot/dist/index.mjs","webpack://element-web/./node_modules/@radix-ui/react-use-layout-effect/dist/index.mjs","webpack://element-web/./node_modules/@sentry-internal/browser-utils/src/instrument/history.ts","webpack://element-web/./node_modules/@sentry-internal/browser-utils/src/types.ts","webpack://element-web/./node_modules/@sentry/browser/src/debug-build.ts","webpack://element-web/./node_modules/@sentry/browser/src/eventbuilder.ts","webpack://element-web/./node_modules/@sentry/browser/src/helpers.ts","webpack://element-web/./node_modules/@sentry-internal/browser-utils/src/instrument/dom.ts","webpack://element-web/./node_modules/@sentry-internal/browser-utils/src/instrument/xhr.ts","webpack://element-web/./node_modules/@sentry/core/src/utils-hoist/instrument/console.ts","webpack://element-web/./node_modules/@sentry/core/src/utils-hoist/instrument/fetch.ts","webpack://element-web/./node_modules/@sentry/core/src/breadcrumbs.ts","webpack://element-web/./node_modules/@sentry/core/src/utils-hoist/severity.ts","webpack://element-web/./node_modules/@sentry/core/src/utils-hoist/breadcrumb-log-level.ts","webpack://element-web/./node_modules/@sentry/core/src/utils-hoist/url.ts","webpack://element-web/./node_modules/@sentry/browser/src/integrations/breadcrumbs.ts","webpack://element-web/./node_modules/@sentry/browser/src/integrations/browserapierrors.ts","webpack://element-web/./node_modules/@sentry/core/src/utils-hoist/instrument/globalError.ts","webpack://element-web/./node_modules/@sentry/core/src/utils-hoist/instrument/globalUnhandledRejection.ts","webpack://element-web/./node_modules/@sentry/browser/src/integrations/globalhandlers.ts","webpack://element-web/./node_modules/@sentry/browser/src/integrations/httpcontext.ts","webpack://element-web/./node_modules/@sentry/core/src/sdk.ts","webpack://element-web/./node_modules/@sentry/core/src/api.ts","webpack://element-web/./node_modules/@sentry/core/src/utils-hoist/dsn.ts","webpack://element-web/./node_modules/@sentry/core/src/utils-hoist/envelope.ts","webpack://element-web/./node_modules/@sentry/core/src/envelope.ts","webpack://element-web/./node_modules/@sentry/core/src/utils-hoist/error.ts","webpack://element-web/./node_modules/@sentry/core/src/client.ts","webpack://element-web/./node_modules/@sentry/core/src/utils/parseSampleRate.ts","webpack://element-web/./node_modules/@sentry/core/src/utils/transactionEvent.ts","webpack://element-web/./node_modules/@sentry/core/src/utils-hoist/clientreport.ts","webpack://element-web/./node_modules/@sentry/core/src/utils/ipAddress.ts","webpack://element-web/./node_modules/@sentry/browser/src/client.ts","webpack://element-web/./node_modules/@sentry/core/src/utils/sdkMetadata.ts","webpack://element-web/./node_modules/@sentry/core/src/utils-hoist/env.ts","webpack://element-web/./node_modules/@sentry/browser/src/integrations/browsersession.ts","webpack://element-web/./node_modules/@sentry/core/src/utils-hoist/aggregate-errors.ts","webpack://element-web/./node_modules/@sentry/browser/src/integrations/linkederrors.ts","webpack://element-web/./node_modules/@sentry/browser/src/stack-parsers.ts","webpack://element-web/./node_modules/@sentry-internal/browser-utils/src/debug-build.ts","webpack://element-web/./node_modules/@sentry-internal/browser-utils/src/getNativeImplementation.ts","webpack://element-web/./node_modules/@sentry/core/src/utils-hoist/promisebuffer.ts","webpack://element-web/./node_modules/@sentry/core/src/utils-hoist/ratelimit.ts","webpack://element-web/./node_modules/@sentry/core/src/transports/base.ts","webpack://element-web/./node_modules/@sentry/browser/src/transports/fetch.ts","webpack://element-web/./node_modules/@sentry/browser/src/sdk.ts","webpack://element-web/./node_modules/@sentry/core/src/carrier.ts","webpack://element-web/./node_modules/@sentry/core/src/constants.ts","webpack://element-web/./node_modules/@sentry/core/src/asyncContext/stackStrategy.ts","webpack://element-web/./node_modules/@sentry/core/src/defaultScopes.ts","webpack://element-web/./node_modules/@sentry/core/src/asyncContext/index.ts","webpack://element-web/./node_modules/@sentry/core/src/currentScopes.ts","webpack://element-web/./node_modules/@sentry/core/src/debug-build.ts","webpack://element-web/./node_modules/@sentry/core/src/exports.ts","webpack://element-web/./node_modules/@sentry/core/src/integration.ts","webpack://element-web/./node_modules/@sentry/core/src/integrations/dedupe.ts","webpack://element-web/./node_modules/@sentry/core/src/integrations/eventFilters.ts","webpack://element-web/./node_modules/@sentry/core/src/integrations/functiontostring.ts","webpack://element-web/./node_modules/@sentry/core/src/utils/spanOnScope.ts","webpack://element-web/./node_modules/@sentry/core/src/scope.ts","webpack://element-web/./node_modules/@sentry/core/src/semanticAttributes.ts","webpack://element-web/./node_modules/@sentry/core/src/session.ts","webpack://element-web/./node_modules/@sentry/core/src/utils-hoist/baggage.ts","webpack://element-web/./node_modules/@sentry/core/src/utils/hasSpansEnabled.ts","webpack://element-web/./node_modules/@sentry/core/src/tracing/dynamicSamplingContext.ts","webpack://element-web/./node_modules/@sentry/core/src/tracing/utils.ts","webpack://element-web/./node_modules/@sentry/core/src/utils-hoist/browser.ts","webpack://element-web/./node_modules/@sentry/core/src/utils-hoist/debug-build.ts","webpack://element-web/./node_modules/@sentry/core/src/utils-hoist/instrument/handlers.ts","webpack://element-web/./node_modules/@sentry/core/src/utils-hoist/is.ts","webpack://element-web/./node_modules/@sentry/core/src/utils-hoist/logger.ts","webpack://element-web/./node_modules/@sentry/core/src/utils-hoist/misc.ts","webpack://element-web/./node_modules/@sentry/core/src/utils-hoist/normalize.ts","webpack://element-web/./node_modules/@sentry/core/src/utils-hoist/object.ts","webpack://element-web/./node_modules/@sentry/core/src/utils-hoist/propagationContext.ts","webpack://element-web/./node_modules/@sentry/core/src/utils-hoist/stacktrace.ts","webpack://element-web/./node_modules/@sentry/core/src/utils-hoist/string.ts","webpack://element-web/./node_modules/@sentry/core/src/utils-hoist/supports.ts","webpack://element-web/./node_modules/@sentry/core/src/utils-hoist/syncpromise.ts","webpack://element-web/./node_modules/@sentry/core/src/utils-hoist/time.ts","webpack://element-web/./node_modules/@sentry/core/src/utils-hoist/version.ts","webpack://element-web/./node_modules/@sentry/core/src/utils-hoist/worldwide.ts","webpack://element-web/./node_modules/@sentry/core/src/utils/eventUtils.ts","webpack://element-web/./node_modules/@sentry/core/src/utils/merge.ts","webpack://element-web/./node_modules/@sentry/core/src/eventProcessors.ts","webpack://element-web/./node_modules/@sentry/core/src/utils-hoist/debug-ids.ts","webpack://element-web/./node_modules/@sentry/core/src/utils/applyScopeDataToEvent.ts","webpack://element-web/./node_modules/@sentry/core/src/utils/prepareEvent.ts","webpack://element-web/./node_modules/@sentry/core/src/tracing/spanstatus.ts","webpack://element-web/./node_modules/@sentry/core/src/utils/spanUtils.ts","webpack://element-web/./node_modules/@vector-im/compound-design-tokens/assets/web/icons/block.js","webpack://element-web/./node_modules/@vector-im/compound-design-tokens/assets/web/icons/chat-problem.js","webpack://element-web/./node_modules/@vector-im/compound-design-tokens/assets/web/icons/chat.js","webpack://element-web/./node_modules/@vector-im/compound-design-tokens/assets/web/icons/check.js","webpack://element-web/./node_modules/@vector-im/compound-design-tokens/assets/web/icons/chevron-left.js","webpack://element-web/./node_modules/@vector-im/compound-design-tokens/assets/web/icons/close.js","webpack://element-web/./node_modules/@vector-im/compound-design-tokens/assets/web/icons/collapse.js","webpack://element-web/./node_modules/@vector-im/compound-design-tokens/assets/web/icons/delete.js","webpack://element-web/./node_modules/@vector-im/compound-design-tokens/assets/web/icons/download.js","webpack://element-web/./node_modules/@vector-im/compound-design-tokens/assets/web/icons/edit.js","webpack://element-web/./node_modules/@vector-im/compound-design-tokens/assets/web/icons/error.js","webpack://element-web/./node_modules/@vector-im/compound-design-tokens/assets/web/icons/expand.js","webpack://element-web/./node_modules/@vector-im/compound-design-tokens/assets/web/icons/files.js","webpack://element-web/./node_modules/@vector-im/compound-design-tokens/assets/web/icons/leave.js","webpack://element-web/./node_modules/@vector-im/compound-design-tokens/assets/web/icons/link.js","webpack://element-web/./node_modules/@vector-im/compound-design-tokens/assets/web/icons/location-pin-solid.js","webpack://element-web/./node_modules/@vector-im/compound-design-tokens/assets/web/icons/mention.js","webpack://element-web/./node_modules/@vector-im/compound-design-tokens/assets/web/icons/pop-out.js","webpack://element-web/./node_modules/@vector-im/compound-design-tokens/assets/web/icons/search.js","webpack://element-web/./node_modules/@vector-im/compound-design-tokens/assets/web/icons/share.js","webpack://element-web/./node_modules/@vector-im/compound-design-tokens/assets/web/icons/threads.js","webpack://element-web/./node_modules/@vector-im/compound-design-tokens/assets/web/icons/user-add.js","webpack://element-web/./node_modules/@vector-im/compound-design-tokens/assets/web/icons/user-solid.js","webpack://element-web/./node_modules/@vector-im/compound-design-tokens/assets/web/icons/verified.js","webpack://element-web/./node_modules/@vector-im/compound-design-tokens/assets/web/icons/video-call-solid.js","webpack://element-web/./node_modules/@vector-im/compound-design-tokens/assets/web/icons/visibility-off.js","webpack://element-web/./node_modules/@vector-im/compound-design-tokens/assets/web/icons/warning.js","webpack://element-web/./node_modules/@vector-im/compound-design-tokens/icons/download.svg","webpack://element-web/./node_modules/@vector-im/compound-web/src/utils/string.ts","webpack://element-web/./node_modules/@vector-im/compound-web/src/components/Avatar/Avatar.tsx","webpack://element-web/./node_modules/@vector-im/compound-web/src/components/Avatar/avatar-clip.mask.svg","webpack://element-web/./node_modules/@vector-im/compound-web/src/components/Avatar/AvatarStack.tsx","webpack://element-web/./node_modules/@vector-im/compound-web/src/components/Avatar/useIdColorHash.ts","webpack://element-web/./node_modules/@vector-im/compound-web/src/components/Badge/Badge.tsx","webpack://element-web/./node_modules/@vector-im/compound-web/src/components/Button/Button.tsx","webpack://element-web/./node_modules/@vector-im/compound-web/src/components/Button/IconButton/IconButton.tsx","webpack://element-web/./node_modules/@vector-im/compound-web/src/components/Button/UnstyledButton.tsx","webpack://element-web/./node_modules/@vector-im/compound-web/src/components/Form/Controls/Checkbox/Checkbox.tsx","webpack://element-web/./node_modules/@vector-im/compound-web/src/components/Glass/Glass.tsx","webpack://element-web/./node_modules/@vector-im/compound-web/src/components/Icon/IndicatorIcon/IndicatorIcon.tsx","webpack://element-web/./node_modules/@vector-im/compound-design-tokens/assets/web/icons/spinner.js","webpack://element-web/./node_modules/@vector-im/compound-web/src/components/InlineSpinner/InlineSpinner.tsx","webpack://element-web/./node_modules/@vector-im/compound-web/src/components/Link/Link.tsx","webpack://element-web/./node_modules/@radix-ui/react-dropdown-menu/node_modules/@radix-ui/react-context/dist/index.mjs","webpack://element-web/./node_modules/@radix-ui/react-use-callback-ref/dist/index.mjs","webpack://element-web/./node_modules/@radix-ui/react-use-controllable-state/dist/index.mjs","webpack://element-web/./node_modules/@radix-ui/react-collection/dist/index.mjs","webpack://element-web/./node_modules/@radix-ui/react-menu/node_modules/@radix-ui/react-context/dist/index.mjs","webpack://element-web/./node_modules/@radix-ui/react-direction/dist/index.mjs","webpack://element-web/./node_modules/@radix-ui/react-dismissable-layer/dist/index.mjs","webpack://element-web/./node_modules/@radix-ui/react-use-escape-keydown/dist/index.mjs","webpack://element-web/./node_modules/@radix-ui/react-focus-guards/dist/index.mjs","webpack://element-web/./node_modules/@radix-ui/react-focus-scope/dist/index.mjs","webpack://element-web/./node_modules/@radix-ui/react-arrow/dist/index.mjs","webpack://element-web/./node_modules/@radix-ui/react-popper/dist/index.mjs","webpack://element-web/./node_modules/@radix-ui/react-use-size/dist/index.mjs","webpack://element-web/./node_modules/@radix-ui/react-portal/dist/index.mjs","webpack://element-web/./node_modules/@radix-ui/react-presence/dist/index.mjs","webpack://element-web/./node_modules/@radix-ui/react-roving-focus/dist/index.mjs","webpack://element-web/./node_modules/aria-hidden/dist/es2015/index.js","webpack://element-web/./node_modules/react-remove-scroll-bar/dist/es2015/constants.js","webpack://element-web/./node_modules/react-remove-scroll/node_modules/use-callback-ref/dist/es2015/assignRef.js","webpack://element-web/./node_modules/react-remove-scroll/node_modules/use-callback-ref/dist/es2015/useMergeRef.js","webpack://element-web/./node_modules/react-remove-scroll/node_modules/use-callback-ref/dist/es2015/useRef.js","webpack://element-web/./node_modules/react-remove-scroll/dist/es2015/medium.js","webpack://element-web/./node_modules/react-remove-scroll/dist/es2015/UI.js","webpack://element-web/./node_modules/use-sidecar/dist/es2015/exports.js","webpack://element-web/./node_modules/get-nonce/dist/es2015/index.js","webpack://element-web/./node_modules/react-style-singleton/dist/es2015/singleton.js","webpack://element-web/./node_modules/react-style-singleton/dist/es2015/component.js","webpack://element-web/./node_modules/react-style-singleton/dist/es2015/hook.js","webpack://element-web/./node_modules/react-remove-scroll-bar/dist/es2015/utils.js","webpack://element-web/./node_modules/react-remove-scroll-bar/dist/es2015/component.js","webpack://element-web/./node_modules/react-remove-scroll/dist/es2015/aggresiveCapture.js","webpack://element-web/./node_modules/react-remove-scroll/dist/es2015/handleScroll.js","webpack://element-web/./node_modules/react-remove-scroll/dist/es2015/SideEffect.js","webpack://element-web/./node_modules/react-remove-scroll/dist/es2015/sidecar.js","webpack://element-web/./node_modules/react-remove-scroll/dist/es2015/Combination.js","webpack://element-web/./node_modules/@radix-ui/react-menu/dist/index.mjs","webpack://element-web/./node_modules/@radix-ui/react-dropdown-menu/dist/index.mjs","webpack://element-web/./node_modules/@vector-im/compound-web/src/components/Menu/MenuTitle.tsx","webpack://element-web/./node_modules/@vector-im/compound-web/src/components/Menu/FloatingMenu.tsx","webpack://element-web/./node_modules/@radix-ui/react-dialog/node_modules/@radix-ui/react-context/dist/index.mjs","webpack://element-web/./node_modules/@radix-ui/react-dialog/dist/index.mjs","webpack://element-web/./node_modules/vaul/dist/index.mjs","webpack://element-web/./node_modules/@vector-im/compound-web/src/utils/platform.ts","webpack://element-web/./node_modules/@vector-im/compound-web/src/components/Menu/DrawerMenu.tsx","webpack://element-web/./node_modules/@vector-im/compound-web/src/components/Menu/Menu.tsx","webpack://element-web/./node_modules/@vector-im/compound-web/src/components/Menu/MenuContext.tsx","webpack://element-web/./node_modules/@vector-im/compound-design-tokens/assets/web/icons/chevron-right.js","webpack://element-web/./node_modules/@vector-im/compound-web/src/components/Menu/MenuItem.tsx","webpack://element-web/./node_modules/@radix-ui/react-separator/dist/index.mjs","webpack://element-web/./node_modules/@vector-im/compound-web/src/components/Separator/Separator.tsx","webpack://element-web/./node_modules/@vector-im/compound-web/src/components/Tooltip/TooltipContext.ts","webpack://element-web/./node_modules/@vector-im/compound-web/src/components/Tooltip/Tooltip.tsx","webpack://element-web/./node_modules/@vector-im/compound-web/src/components/Tooltip/useTooltip.ts","webpack://element-web/./node_modules/@vector-im/compound-web/src/components/Tooltip/TooltipProvider.tsx","webpack://element-web/./node_modules/@vector-im/compound-web/src/components/Typography/Heading.tsx","webpack://element-web/./node_modules/@vector-im/compound-web/src/components/Typography/Text.tsx","webpack://element-web/./node_modules/@vector-im/compound-web/src/components/Typography/Typography.tsx","webpack://element-web/./node_modules/available-typed-arrays/index.js","webpack://element-web/./node_modules/await-lock/src/AwaitLock.ts","webpack://element-web/./node_modules/blurhash/src/base83.ts","webpack://element-web/./node_modules/blurhash/src/utils.ts","webpack://element-web/./node_modules/blurhash/src/error.ts","webpack://element-web/./node_modules/blurhash/src/decode.ts","webpack://element-web/./node_modules/browserslist/browser.js","webpack://element-web/./node_modules/browserslist/error.js","webpack://element-web/./node_modules/browserslist/index.js","webpack://element-web/./node_modules/browserslist/parse.js","webpack://element-web/./node_modules/call-bind-apply-helpers/actualApply.js","webpack://element-web/./node_modules/call-bind-apply-helpers/applyBind.js","webpack://element-web/./node_modules/call-bind-apply-helpers/functionApply.js","webpack://element-web/./node_modules/call-bind-apply-helpers/functionCall.js","webpack://element-web/./node_modules/call-bind-apply-helpers/index.js","webpack://element-web/./node_modules/call-bind-apply-helpers/reflectApply.js","webpack://element-web/./node_modules/call-bind/callBound.js","webpack://element-web/./node_modules/call-bind/index.js","webpack://element-web/./node_modules/call-bound/index.js","webpack://element-web/./node_modules/caniuse-lite/data/agents.js","webpack://element-web/./node_modules/caniuse-lite/data/browserVersions.js","webpack://element-web/./node_modules/caniuse-lite/data/browsers.js","webpack://element-web/./node_modules/caniuse-lite/dist/unpacker/agents.js","webpack://element-web/./node_modules/caniuse-lite/dist/unpacker/browserVersions.js","webpack://element-web/./node_modules/caniuse-lite/dist/unpacker/browsers.js","webpack://element-web/./node_modules/classnames/index.js","webpack://element-web/./node_modules/commonmark/lib/node.js","webpack://element-web/./node_modules/commonmark/lib/from-code-point.js","webpack://element-web/./node_modules/commonmark/lib/common.js","webpack://element-web/./node_modules/commonmark/lib/inlines.js","webpack://element-web/./node_modules/commonmark/lib/blocks.js","webpack://element-web/./node_modules/commonmark/lib/render/renderer.js","webpack://element-web/./node_modules/commonmark/lib/render/html.js","webpack://element-web/./node_modules/commonmark/lib/render/xml.js","webpack://element-web/./node_modules/commonmark/node_modules/entities/lib/decode.js","webpack://element-web/./node_modules/commonmark/node_modules/entities/lib/decode_codepoint.js","webpack://element-web/./node_modules/commonmark/node_modules/entities/lib/encode-trie.js","webpack://element-web/./node_modules/commonmark/node_modules/entities/lib/encode.js","webpack://element-web/./node_modules/commonmark/node_modules/entities/lib/generated/decode-data-html.js","webpack://element-web/./node_modules/commonmark/node_modules/entities/lib/generated/decode-data-xml.js","webpack://element-web/./node_modules/commonmark/node_modules/entities/lib/index.js","webpack://element-web/./node_modules/content-type/index.js","webpack://element-web/./node_modules/counterpart/index.js","webpack://element-web/./node_modules/counterpart/locales/en.js","webpack://element-web/./node_modules/counterpart/strftime.js","webpack://element-web/./node_modules/date-names/en.js","webpack://element-web/./node_modules/date-names/index.js","webpack://element-web/./node_modules/deepmerge/dist/cjs.js","webpack://element-web/./node_modules/define-data-property/index.js","webpack://element-web/./node_modules/diff-dom/node_modules/tslib/tslib.es6.js","webpack://element-web/./node_modules/diff-dom/src/diffDOM/helpers.ts","webpack://element-web/./node_modules/diff-dom/src/diffDOM/dom/fromVirtual.ts","webpack://element-web/./node_modules/diff-dom/src/diffDOM/dom/apply.ts","webpack://element-web/./node_modules/diff-dom/src/diffDOM/dom/undo.ts","webpack://element-web/./node_modules/diff-dom/src/diffDOM/virtual/helpers.ts","webpack://element-web/./node_modules/diff-dom/src/diffDOM/virtual/apply.ts","webpack://element-web/./node_modules/diff-dom/src/diffDOM/virtual/fromDOM.ts","webpack://element-web/./node_modules/diff-dom/src/diffDOM/virtual/fromString.ts","webpack://element-web/./node_modules/diff-dom/src/diffDOM/virtual/diff.ts","webpack://element-web/./node_modules/diff-dom/src/diffDOM/index.ts","webpack://element-web/./node_modules/diff-dom/src/TraceLogger.ts","webpack://element-web/./node_modules/diff-match-patch/index.js","webpack://element-web/./node_modules/dijkstrajs/dijkstra.js","webpack://element-web/./node_modules/domelementtype/lib/index.js","webpack://element-web/./node_modules/dunder-proto/get.js","webpack://element-web/./node_modules/electron-to-chromium/versions.js","webpack://element-web/./node_modules/emojibase-regex/emoticon.js","webpack://element-web/./node_modules/emojibase/src/appendSkinToneIndex.ts","webpack://element-web/./node_modules/emojibase/src/constants.ts","webpack://element-web/./node_modules/emojibase/src/fetchFromCDN.ts","webpack://element-web/./node_modules/emojibase/src/fetchShortcodes.ts","webpack://element-web/./node_modules/emojibase/src/joinShortcodesToEmoji.ts","webpack://element-web/./node_modules/emojibase/src/flattenEmojiData.ts","webpack://element-web/./node_modules/emojibase/src/joinShortcodes.ts","webpack://element-web/./node_modules/emojibase/src/fetchEmojis.ts","webpack://element-web/./node_modules/emojibase/src/fetchMessages.ts","webpack://element-web/./node_modules/emojibase/src/fromCodepointToUnicode.ts","webpack://element-web/./node_modules/emojibase/src/fromHexcodeToCodepoint.ts","webpack://element-web/./node_modules/emojibase/src/fromUnicodeToHexcode.ts","webpack://element-web/./node_modules/emojibase/src/generateEmoticonPermutations.ts","webpack://element-web/./node_modules/emojibase/src/stripHexcode.ts","https://raw.githubusercontent.com/fb55/entities/61afd4701eaa736978b13c7351cd3de9a96b04bc/src/decode.ts","https://raw.githubusercontent.com/fb55/entities/61afd4701eaa736978b13c7351cd3de9a96b04bc/src/decode_codepoint.ts","https://raw.githubusercontent.com/fb55/entities/61afd4701eaa736978b13c7351cd3de9a96b04bc/src/encode.ts","https://raw.githubusercontent.com/fb55/entities/61afd4701eaa736978b13c7351cd3de9a96b04bc/src/escape.ts","https://raw.githubusercontent.com/fb55/entities/61afd4701eaa736978b13c7351cd3de9a96b04bc/src/generated/decode-data-html.ts","https://raw.githubusercontent.com/fb55/entities/61afd4701eaa736978b13c7351cd3de9a96b04bc/src/generated/decode-data-xml.ts","https://raw.githubusercontent.com/fb55/entities/61afd4701eaa736978b13c7351cd3de9a96b04bc/src/generated/encode-html.ts","https://raw.githubusercontent.com/fb55/entities/61afd4701eaa736978b13c7351cd3de9a96b04bc/src/index.ts","webpack://element-web/./node_modules/es-define-property/index.js","webpack://element-web/./node_modules/es-errors/eval.js","webpack://element-web/./node_modules/es-errors/index.js","webpack://element-web/./node_modules/es-errors/range.js","webpack://element-web/./node_modules/es-errors/ref.js","webpack://element-web/./node_modules/es-errors/syntax.js","webpack://element-web/./node_modules/es-errors/type.js","webpack://element-web/./node_modules/es-errors/uri.js","webpack://element-web/./node_modules/es-object-atoms/index.js","webpack://element-web/./node_modules/escape-html/index.js","webpack://element-web/./node_modules/escape-string-regexp/index.js","webpack://element-web/./node_modules/events/events.js","webpack://element-web/./node_modules/except/index.js","webpack://element-web/./node_modules/extend/index.js","webpack://element-web/./node_modules/filesize/dist/filesize.esm.js","webpack://element-web/./node_modules/for-each/index.js","webpack://element-web/./node_modules/function-bind/implementation.js","webpack://element-web/./node_modules/function-bind/index.js","webpack://element-web/./node_modules/get-intrinsic/index.js","webpack://element-web/./node_modules/get-proto/Object.getPrototypeOf.js","webpack://element-web/./node_modules/get-proto/Reflect.getPrototypeOf.js","webpack://element-web/./node_modules/get-proto/index.js","webpack://element-web/./node_modules/glob-to-regexp/index.js","webpack://element-web/./node_modules/gopd/gOPD.js","webpack://element-web/./node_modules/gopd/index.js","webpack://element-web/./node_modules/has-property-descriptors/index.js","webpack://element-web/./node_modules/has-symbols/index.js","webpack://element-web/./node_modules/has-symbols/shams.js","webpack://element-web/./node_modules/has-tostringtag/shams.js","webpack://element-web/./node_modules/hasown/index.js","webpack://element-web/./node_modules/html-entities/src/index.ts","webpack://element-web/./node_modules/html-entities/src/named-references.ts","webpack://element-web/./node_modules/html-entities/src/numeric-unicode-map.ts","webpack://element-web/./node_modules/html-entities/src/surrogate-pairs.ts","https://raw.githubusercontent.com/fb55/htmlparser2/c123610e003a1eaebc61febed01cabb6e41eb658/src/Parser.ts","https://raw.githubusercontent.com/fb55/htmlparser2/c123610e003a1eaebc61febed01cabb6e41eb658/src/Tokenizer.ts","https://raw.githubusercontent.com/fb55/htmlparser2/c123610e003a1eaebc61febed01cabb6e41eb658/src/index.ts","webpack://element-web/./node_modules/htmlparser2/node_modules/dom-serializer/lib/foreignNames.js","webpack://element-web/./node_modules/htmlparser2/node_modules/dom-serializer/lib/index.js","webpack://element-web/./node_modules/htmlparser2/node_modules/domhandler/lib/index.js","webpack://element-web/./node_modules/htmlparser2/node_modules/domhandler/lib/node.js","https://raw.githubusercontent.com/fb55/domutils/96c989e159c98218958f375ea04210f2d1b43c0c/src/feeds.ts","https://raw.githubusercontent.com/fb55/domutils/96c989e159c98218958f375ea04210f2d1b43c0c/src/helpers.ts","https://raw.githubusercontent.com/fb55/domutils/96c989e159c98218958f375ea04210f2d1b43c0c/src/index.ts","https://raw.githubusercontent.com/fb55/domutils/96c989e159c98218958f375ea04210f2d1b43c0c/src/legacy.ts","https://raw.githubusercontent.com/fb55/domutils/96c989e159c98218958f375ea04210f2d1b43c0c/src/manipulation.ts","https://raw.githubusercontent.com/fb55/domutils/96c989e159c98218958f375ea04210f2d1b43c0c/src/querying.ts","https://raw.githubusercontent.com/fb55/domutils/96c989e159c98218958f375ea04210f2d1b43c0c/src/stringify.ts","https://raw.githubusercontent.com/fb55/domutils/96c989e159c98218958f375ea04210f2d1b43c0c/src/traversal.ts","webpack://element-web/./node_modules/indexof/index.js","webpack://element-web/./node_modules/inherits/inherits_browser.js","webpack://element-web/./node_modules/ip-regex/index.js","webpack://element-web/./node_modules/is-arguments/index.js","webpack://element-web/./node_modules/is-callable/index.js","webpack://element-web/./node_modules/is-generator-function/index.js","webpack://element-web/./node_modules/is-ip/index.js","webpack://element-web/./node_modules/is-plain-object/dist/is-plain-object.js","webpack://element-web/./node_modules/jwt-decode/build/cjs/index.js","webpack://element-web/./node_modules/katex/dist/katex.mjs","webpack://element-web/./node_modules/linkify-element/dist/linkify-element.es.js","webpack://element-web/./node_modules/linkify-react/dist/linkify-react.es.js","webpack://element-web/./node_modules/linkify-string/dist/linkify-string.es.js","webpack://element-web/./node_modules/linkifyjs/dist/linkify.es.js","webpack://element-web/./node_modules/lodash/lodash.js","webpack://element-web/./node_modules/math-intrinsics/abs.js","webpack://element-web/./node_modules/math-intrinsics/floor.js","webpack://element-web/./node_modules/math-intrinsics/isNaN.js","webpack://element-web/./node_modules/math-intrinsics/max.js","webpack://element-web/./node_modules/math-intrinsics/min.js","webpack://element-web/./node_modules/math-intrinsics/pow.js","webpack://element-web/./node_modules/math-intrinsics/round.js","webpack://element-web/./node_modules/math-intrinsics/sign.js","webpack://element-web/./node_modules/matrix-encrypt-attachment/lib/node_modules/browser-pack/_prelude.js","webpack://element-web/./node_modules/matrix-encrypt-attachment/lib/src/webcrypto.ts","webpack://element-web/./node_modules/matrix-events-sdk/lib/ExtensibleEvents.js","webpack://element-web/./node_modules/matrix-events-sdk/lib/IPartialEvent.js","webpack://element-web/./node_modules/matrix-events-sdk/lib/InvalidEventError.js","webpack://element-web/./node_modules/matrix-events-sdk/lib/NamespacedMap.js","webpack://element-web/./node_modules/matrix-events-sdk/lib/NamespacedValue.js","webpack://element-web/./node_modules/matrix-events-sdk/lib/events/EmoteEvent.js","webpack://element-web/./node_modules/matrix-events-sdk/lib/events/ExtensibleEvent.js","webpack://element-web/./node_modules/matrix-events-sdk/lib/events/MessageEvent.js","webpack://element-web/./node_modules/matrix-events-sdk/lib/events/NoticeEvent.js","webpack://element-web/./node_modules/matrix-events-sdk/lib/events/PollEndEvent.js","webpack://element-web/./node_modules/matrix-events-sdk/lib/events/PollResponseEvent.js","webpack://element-web/./node_modules/matrix-events-sdk/lib/events/PollStartEvent.js","webpack://element-web/./node_modules/matrix-events-sdk/lib/events/message_types.js","webpack://element-web/./node_modules/matrix-events-sdk/lib/events/poll_types.js","webpack://element-web/./node_modules/matrix-events-sdk/lib/events/relationship_types.js","webpack://element-web/./node_modules/matrix-events-sdk/lib/index.js","webpack://element-web/./node_modules/matrix-events-sdk/lib/interpreters/legacy/MRoomMessage.js","webpack://element-web/./node_modules/matrix-events-sdk/lib/interpreters/modern/MMessage.js","webpack://element-web/./node_modules/matrix-events-sdk/lib/interpreters/modern/MPoll.js","webpack://element-web/./node_modules/matrix-events-sdk/lib/types.js","webpack://element-web/./node_modules/matrix-events-sdk/lib/utility/MessageMatchers.js","webpack://element-web/./node_modules/matrix-events-sdk/lib/utility/events.js","webpack://element-web/./node_modules/matrix-js-sdk/src/@types/PushRules.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/@types/beacon.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/@types/event.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/@types/extensible_events.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/@types/membership.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/@types/partials.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/@types/polls.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/@types/requests.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/@types/search.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/@types/sync.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/@types/topic.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/ReEmitter.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/autodiscovery.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/base64.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/store/stub.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/models/MSC3089Branch.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/models/MSC3089TreeSpace.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/ToDeviceMessageQueue.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/rust-crypto/constants.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/thread-utils.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/client.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/event-mapper.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/common-crypto/CryptoBackend.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/content-helpers.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/content-repo.ts","webpack://element-web/./node_modules/base-x/src/esm/index.js","webpack://element-web/./node_modules/bs58/src/esm/index.js","webpack://element-web/./node_modules/matrix-js-sdk/src/crypto-api/recovery-key.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/crypto-api/key-passphrase.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/crypto-api/CryptoEvent.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/crypto-api/index.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/crypto-api/verification.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/crypto/store/base.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/crypto/store/indexeddb-crypto-store-backend.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/crypto/store/indexeddb-crypto-store.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/crypto/store/localStorage-crypto-store.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/crypto/store/memory-crypto-store.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/digest.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/errors.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/extensible_events_v1/ExtensibleEvent.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/extensible_events_v1/InvalidEventError.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/extensible_events_v1/MessageEvent.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/extensible_events_v1/PollEndEvent.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/extensible_events_v1/PollResponseEvent.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/extensible_events_v1/PollStartEvent.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/extensible_events_v1/utilities.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/feature.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/filter-component.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/filter.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/http-api/errors.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/http-api/method.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/http-api/interface.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/http-api/utils.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/http-api/fetch.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/utils/decorators.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/http-api/prefix.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/realtime-callbacks.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/http-api/index.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/interactive-auth.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/store/memory.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/embedded.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/timeline-window.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/store/indexeddb-remote-backend.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/store/indexeddb.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/@types/threepids.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/@types/auth.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/models/profile-keys.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/store/local-storage-events-emitter.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/matrix.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/matrixrtc/CallMembership.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/matrixrtc/LivekitFocus.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/matrixrtc/NewMembershipManagerActionScheduler.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/matrixrtc/NewMembershipManager.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/matrixrtc/EncryptionManager.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/matrixrtc/LegacyMembershipManager.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/matrixrtc/MatrixRTCSession.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/matrixrtc/MatrixRTCSessionManager.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/models/beacon.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/models/device.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/models/event-status.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/models/event-timeline-set.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/models/event-timeline.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/models/event.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/models/invites-ignorer-types.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/models/invites-ignorer.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/models/poll.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/models/read-receipt.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/models/related-relations.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/models/relations-container.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/models/relations.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/models/room-member.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/models/room-state.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/models/room-summary.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/models/room-receipts.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/models/compare-event-ordering.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/models/room.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/models/event-context.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/models/search-result.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/models/thread.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/models/typed-event-emitter.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/models/user.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/oidc/authorize.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/oidc/error.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/oidc/discovery.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/oidc/register.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/oidc/tokenRefresher.ts","webpack://element-web/./node_modules/jwt-decode/build/esm/index.js","webpack://element-web/./node_modules/matrix-js-sdk/src/oidc/validate.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/pushprocessor.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/randomstring.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/scheduler.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/secret-storage.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/serverCapabilities.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/service-types.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/sliding-sync-sdk.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/sliding-sync.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/receipt-accumulator.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/sync-accumulator.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/sync.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/types.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/utils/decryptAESSecretStorageItem.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/utils/encryptAESSecretStorageItem.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/utils/internal/deriveKeys.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/version-support.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/webrtc/call.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/webrtc/callEventHandler.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/webrtc/callEventTypes.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/webrtc/audioContext.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/webrtc/callFeed.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/webrtc/stats/connectionStats.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/webrtc/stats/connectionStatsBuilder.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/webrtc/stats/transportStatsBuilder.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/webrtc/stats/media/mediaSsrcHandler.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/webrtc/stats/media/mediaTrackHandler.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/webrtc/stats/media/mediaTrackStats.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/webrtc/stats/media/mediaTrackStatsHandler.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/webrtc/stats/valueFormatter.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/webrtc/stats/trackStatsBuilder.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/webrtc/stats/connectionStatsReportBuilder.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/webrtc/stats/callFeedStatsReporter.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/webrtc/stats/callStatsReportGatherer.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/webrtc/stats/statsReportEmitter.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/webrtc/stats/summaryStatsReportGatherer.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/webrtc/stats/groupCallStats.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/webrtc/groupCall.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/webrtc/groupCallEventHandler.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/webrtc/mediaHandler.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/webrtc/stats/statsReport.ts","webpack://element-web/./node_modules/matrix-web-i18n/lib/index.js","webpack://element-web/./node_modules/matrix-web-i18n/lib/types.js","webpack://element-web/./node_modules/matrix-web-i18n/lib/utils.js","webpack://element-web/./node_modules/matrix-widget-api/src/ClientWidgetApi.ts","webpack://element-web/./node_modules/matrix-widget-api/src/Symbols.ts","webpack://element-web/./node_modules/matrix-widget-api/src/WidgetApi.ts","webpack://element-web/./node_modules/matrix-widget-api/src/driver/WidgetDriver.ts","webpack://element-web/./node_modules/matrix-widget-api/src/index.ts","webpack://element-web/./node_modules/matrix-widget-api/src/interfaces/ApiVersion.ts","webpack://element-web/./node_modules/matrix-widget-api/src/interfaces/Capabilities.ts","webpack://element-web/./node_modules/matrix-widget-api/src/interfaces/GetOpenIDAction.ts","webpack://element-web/./node_modules/matrix-widget-api/src/interfaces/IWidgetApiErrorResponse.ts","webpack://element-web/./node_modules/matrix-widget-api/src/interfaces/ModalButtonKind.ts","webpack://element-web/./node_modules/matrix-widget-api/src/interfaces/ModalWidgetActions.ts","webpack://element-web/./node_modules/matrix-widget-api/src/interfaces/UpdateDelayedEventAction.ts","webpack://element-web/./node_modules/matrix-widget-api/src/interfaces/WidgetApiAction.ts","webpack://element-web/./node_modules/matrix-widget-api/src/interfaces/WidgetApiDirection.ts","webpack://element-web/./node_modules/matrix-widget-api/src/interfaces/WidgetKind.ts","webpack://element-web/./node_modules/matrix-widget-api/src/interfaces/WidgetType.ts","webpack://element-web/./node_modules/matrix-widget-api/src/models/Widget.ts","webpack://element-web/./node_modules/matrix-widget-api/src/models/WidgetEventCapability.ts","webpack://element-web/./node_modules/matrix-widget-api/src/models/WidgetParser.ts","webpack://element-web/./node_modules/matrix-widget-api/src/models/validation/url.ts","webpack://element-web/./node_modules/matrix-widget-api/src/models/validation/utils.ts","webpack://element-web/./node_modules/matrix-widget-api/src/templating/url-template.ts","webpack://element-web/./node_modules/matrix-widget-api/src/transport/PostmessageTransport.ts","webpack://element-web/./node_modules/matrix-widget-api/src/util/SimpleObservable.ts","webpack://element-web/./node_modules/mdurl/encode.js","webpack://element-web/./node_modules/memoize-one/dist/memoize-one.esm.js","webpack://element-web/./node_modules/mime/dist/types/other.js","webpack://element-web/./node_modules/mime/dist/types/standard.js","webpack://element-web/./node_modules/mime/dist/src/Mime.js","webpack://element-web/./node_modules/mime/dist/src/index.js","webpack://element-web/./node_modules/nanoid/non-secure/index.cjs","webpack://element-web/./node_modules/oidc-client-ts/src/index.ts","webpack://element-web/./node_modules/oidc-client-ts/src/utils/Logger.ts","webpack://element-web/./node_modules/oidc-client-ts/src/utils/JwtUtils.ts","webpack://element-web/./node_modules/oidc-client-ts/src/utils/CryptoUtils.ts","webpack://element-web/./node_modules/oidc-client-ts/src/utils/Event.ts","webpack://element-web/./node_modules/oidc-client-ts/src/utils/PopupUtils.ts","webpack://element-web/./node_modules/oidc-client-ts/src/utils/Timer.ts","webpack://element-web/./node_modules/oidc-client-ts/src/utils/UrlUtils.ts","webpack://element-web/./node_modules/oidc-client-ts/src/errors/ErrorResponse.ts","webpack://element-web/./node_modules/oidc-client-ts/src/errors/ErrorTimeout.ts","webpack://element-web/./node_modules/oidc-client-ts/src/AccessTokenEvents.ts","webpack://element-web/./node_modules/oidc-client-ts/src/CheckSessionIFrame.ts","webpack://element-web/./node_modules/oidc-client-ts/src/InMemoryWebStorage.ts","webpack://element-web/./node_modules/oidc-client-ts/src/errors/ErrorDPoPNonce.ts","webpack://element-web/./node_modules/oidc-client-ts/src/JsonService.ts","webpack://element-web/./node_modules/oidc-client-ts/src/MetadataService.ts","webpack://element-web/./node_modules/oidc-client-ts/src/WebStorageStateStore.ts","webpack://element-web/./node_modules/oidc-client-ts/src/OidcClientSettings.ts","webpack://element-web/./node_modules/oidc-client-ts/src/UserInfoService.ts","webpack://element-web/./node_modules/oidc-client-ts/src/TokenClient.ts","webpack://element-web/./node_modules/oidc-client-ts/src/ResponseValidator.ts","webpack://element-web/./node_modules/oidc-client-ts/src/State.ts","webpack://element-web/./node_modules/oidc-client-ts/src/SigninState.ts","webpack://element-web/./node_modules/oidc-client-ts/src/SigninRequest.ts","webpack://element-web/./node_modules/oidc-client-ts/src/SigninResponse.ts","webpack://element-web/./node_modules/oidc-client-ts/src/SignoutRequest.ts","webpack://element-web/./node_modules/oidc-client-ts/src/SignoutResponse.ts","webpack://element-web/./node_modules/oidc-client-ts/src/ClaimsService.ts","webpack://element-web/./node_modules/oidc-client-ts/src/DPoPStore.ts","webpack://element-web/./node_modules/oidc-client-ts/src/OidcClient.ts","webpack://element-web/./node_modules/oidc-client-ts/src/SessionMonitor.ts","webpack://element-web/./node_modules/oidc-client-ts/src/User.ts","webpack://element-web/./node_modules/oidc-client-ts/src/navigators/AbstractChildWindow.ts","webpack://element-web/./node_modules/oidc-client-ts/src/UserManagerSettings.ts","webpack://element-web/./node_modules/oidc-client-ts/src/navigators/IFrameWindow.ts","webpack://element-web/./node_modules/oidc-client-ts/src/navigators/IFrameNavigator.ts","webpack://element-web/./node_modules/oidc-client-ts/src/navigators/PopupWindow.ts","webpack://element-web/./node_modules/oidc-client-ts/src/navigators/PopupNavigator.ts","webpack://element-web/./node_modules/oidc-client-ts/src/navigators/RedirectNavigator.ts","webpack://element-web/./node_modules/oidc-client-ts/src/UserManagerEvents.ts","webpack://element-web/./node_modules/oidc-client-ts/src/SilentRenewService.ts","webpack://element-web/./node_modules/oidc-client-ts/src/RefreshState.ts","webpack://element-web/./node_modules/oidc-client-ts/src/UserManager.ts","webpack://element-web/./node_modules/oidc-client-ts/src/Version.ts","webpack://element-web/./node_modules/oidc-client-ts/package.json","webpack://element-web/./node_modules/oidc-client-ts/src/IndexedDbDPoPStore.ts","webpack://element-web/./node_modules/opus-recorder/dist/decoderWorker.min.js","webpack://element-web/./node_modules/opus-recorder/dist/decoderWorker.min.wasm","webpack://element-web/./node_modules/opus-recorder/dist/encoderWorker.min.js","webpack://element-web/./node_modules/opus-recorder/dist/recorder.min.js","webpack://element-web/./node_modules/opus-recorder/dist/waveWorker.min.js","webpack://element-web/./node_modules/parse-srcset/src/parse-srcset.js","webpack://element-web/./node_modules/picocolors/picocolors.browser.js","webpack://element-web/./node_modules/pluralizers/en.js","webpack://element-web/./node_modules/png-chunks-extract/index.js","webpack://element-web/./node_modules/png-chunks-extract/node_modules/crc-32/crc32.js","webpack://element-web/./node_modules/possible-typed-array-names/index.js","webpack://element-web/./node_modules/posthog-js/src/config.ts","webpack://element-web/./node_modules/posthog-js/src/utils/type-utils.ts","webpack://element-web/./node_modules/posthog-js/src/utils/globals.ts","webpack://element-web/./node_modules/posthog-js/src/utils/logger.ts","webpack://element-web/./node_modules/posthog-js/src/utils/index.ts","webpack://element-web/./node_modules/posthog-js/src/types.ts","webpack://element-web/./node_modules/posthog-js/src/constants.ts","webpack://element-web/./node_modules/posthog-js/src/posthog-featureflags.ts","webpack://element-web/./node_modules/posthog-js/src/uuidv7.ts","webpack://element-web/./node_modules/posthog-js/src/storage.ts","webpack://element-web/./node_modules/posthog-js/src/utils/request-utils.ts","webpack://element-web/./node_modules/posthog-js/src/utils/user-agent-utils.ts","webpack://element-web/./node_modules/posthog-js/src/utils/event-utils.ts","webpack://element-web/./node_modules/posthog-js/src/posthog-persistence.ts","webpack://element-web/./node_modules/posthog-js/src/extensions/replay/sessionrecording-utils.ts","webpack://element-web/./node_modules/posthog-js/node_modules/.pnpm/@rrweb+types@2.0.0-alpha.13/node_modules/@rrweb/types/dist/types.js","webpack://element-web/./node_modules/posthog-js/src/autocapture-utils.ts","webpack://element-web/./node_modules/posthog-js/src/extensions/replay/config.ts","webpack://element-web/./node_modules/posthog-js/src/extensions/toolbar.ts","webpack://element-web/./node_modules/posthog-js/src/extensions/replay/mutation-rate-limiter.ts","webpack://element-web/./node_modules/posthog-js/src/extensions/replay/sessionrecording.ts","webpack://element-web/./node_modules/posthog-js/src/decide.ts","webpack://element-web/./node_modules/posthog-js/src/request-queue.ts","webpack://element-web/./node_modules/posthog-js/node_modules/.pnpm/fflate@0.4.8/node_modules/fflate/esm/browser.js","webpack://element-web/./node_modules/posthog-js/src/request.ts","webpack://element-web/./node_modules/posthog-js/src/utils/request-router.ts","webpack://element-web/./node_modules/posthog-js/src/retry-queue.ts","webpack://element-web/./node_modules/posthog-js/src/sessionid.ts","webpack://element-web/./node_modules/posthog-js/src/extensions/exception-autocapture/index.ts","webpack://element-web/./node_modules/posthog-js/src/extensions/sentry-integration.ts","webpack://element-web/./node_modules/posthog-js/src/page-view.ts","webpack://element-web/./node_modules/posthog-js/src/posthog-surveys-types.ts","webpack://element-web/./node_modules/posthog-js/src/utils/simple-event-emitter.ts","webpack://element-web/./node_modules/posthog-js/src/extensions/surveys/action-matcher.ts","webpack://element-web/./node_modules/posthog-js/src/utils/survey-event-receiver.ts","webpack://element-web/./node_modules/posthog-js/src/posthog-surveys.ts","webpack://element-web/./node_modules/posthog-js/src/rate-limiter.ts","webpack://element-web/./node_modules/posthog-js/src/session-props.ts","webpack://element-web/./node_modules/posthog-js/src/utils/blocked-uas.ts","webpack://element-web/./node_modules/posthog-js/src/extensions/rageclick.ts","webpack://element-web/./node_modules/posthog-js/src/heatmaps.ts","webpack://element-web/./node_modules/posthog-js/src/scroll-manager.ts","webpack://element-web/./node_modules/posthog-js/src/autocapture.ts","webpack://element-web/./node_modules/posthog-js/src/consent.ts","webpack://element-web/./node_modules/posthog-js/src/extensions/tracing-headers.ts","webpack://element-web/./node_modules/posthog-js/src/extensions/web-vitals/index.ts","webpack://element-web/./node_modules/posthog-js/src/posthog-core.ts","webpack://element-web/./node_modules/posthog-js/src/extensions/segment-integration.ts","webpack://element-web/./node_modules/posthog-js/src/entrypoints/module.es.ts","webpack://element-web/./node_modules/process/browser.js","webpack://element-web/./node_modules/qrcode/lib/browser.js","webpack://element-web/./node_modules/qrcode/lib/can-promise.js","webpack://element-web/./node_modules/qrcode/lib/core/alignment-pattern.js","webpack://element-web/./node_modules/qrcode/lib/core/alphanumeric-data.js","webpack://element-web/./node_modules/qrcode/lib/core/bit-buffer.js","webpack://element-web/./node_modules/qrcode/lib/core/bit-matrix.js","webpack://element-web/./node_modules/qrcode/lib/core/byte-data.js","webpack://element-web/./node_modules/qrcode/lib/core/error-correction-code.js","webpack://element-web/./node_modules/qrcode/lib/core/error-correction-level.js","webpack://element-web/./node_modules/qrcode/lib/core/finder-pattern.js","webpack://element-web/./node_modules/qrcode/lib/core/format-info.js","webpack://element-web/./node_modules/qrcode/lib/core/galois-field.js","webpack://element-web/./node_modules/qrcode/lib/core/kanji-data.js","webpack://element-web/./node_modules/qrcode/lib/core/mask-pattern.js","webpack://element-web/./node_modules/qrcode/lib/core/mode.js","webpack://element-web/./node_modules/qrcode/lib/core/numeric-data.js","webpack://element-web/./node_modules/qrcode/lib/core/polynomial.js","webpack://element-web/./node_modules/qrcode/lib/core/qrcode.js","webpack://element-web/./node_modules/qrcode/lib/core/reed-solomon-encoder.js","webpack://element-web/./node_modules/qrcode/lib/core/regex.js","webpack://element-web/./node_modules/qrcode/lib/core/segments.js","webpack://element-web/./node_modules/qrcode/lib/core/utils.js","webpack://element-web/./node_modules/qrcode/lib/core/version-check.js","webpack://element-web/./node_modules/qrcode/lib/core/version.js","webpack://element-web/./node_modules/qrcode/lib/renderer/canvas.js","webpack://element-web/./node_modules/qrcode/lib/renderer/svg-tag.js","webpack://element-web/./node_modules/qrcode/lib/renderer/utils.js","webpack://element-web/./node_modules/re-resizable/lib/index.js","webpack://element-web/./node_modules/re-resizable/lib/resizer.js","webpack://element-web/./node_modules/react-blurhash/src/BlurhashCanvas.tsx","webpack://element-web/./node_modules/react-blurhash/src/Blurhash.tsx","webpack://element-web/./node_modules/react-dom/cjs/react-dom.production.min.js","webpack://element-web/./node_modules/react-dom/client.js","webpack://element-web/./node_modules/react-dom/index.js","webpack://element-web/./node_modules/focus-lock/dist/es2015/constants.js","webpack://element-web/./node_modules/use-callback-ref/dist/es2015/assignRef.js","webpack://element-web/./node_modules/use-callback-ref/dist/es2015/useMergeRef.js","webpack://element-web/./node_modules/use-callback-ref/dist/es2015/useRef.js","webpack://element-web/./node_modules/react-focus-lock/dist/es2015/FocusGuard.js","webpack://element-web/./node_modules/react-focus-lock/dist/es2015/medium.js","webpack://element-web/./node_modules/react-focus-lock/dist/es2015/scope.js","webpack://element-web/./node_modules/react-focus-lock/dist/es2015/Lock.js","webpack://element-web/./node_modules/react-clientside-effect/lib/index.es.js","webpack://element-web/./node_modules/focus-lock/dist/es2015/utils/array.js","webpack://element-web/./node_modules/focus-lock/dist/es2015/utils/is.js","webpack://element-web/./node_modules/focus-lock/dist/es2015/utils/tabOrder.js","webpack://element-web/./node_modules/focus-lock/dist/es2015/utils/tabUtils.js","webpack://element-web/./node_modules/focus-lock/dist/es2015/utils/tabbables.js","webpack://element-web/./node_modules/focus-lock/dist/es2015/utils/DOMutils.js","webpack://element-web/./node_modules/focus-lock/dist/es2015/utils/getActiveElement.js","webpack://element-web/./node_modules/focus-lock/dist/es2015/utils/safe.js","webpack://element-web/./node_modules/focus-lock/dist/es2015/utils/all-affected.js","webpack://element-web/./node_modules/focus-lock/dist/es2015/focusInside.js","webpack://element-web/./node_modules/focus-lock/dist/es2015/commands.js","webpack://element-web/./node_modules/focus-lock/dist/es2015/utils/correctFocus.js","webpack://element-web/./node_modules/focus-lock/dist/es2015/utils/firstFocus.js","webpack://element-web/./node_modules/focus-lock/dist/es2015/solver.js","webpack://element-web/./node_modules/focus-lock/dist/es2015/utils/auto-focus.js","webpack://element-web/./node_modules/focus-lock/dist/es2015/utils/parenting.js","webpack://element-web/./node_modules/focus-lock/dist/es2015/focusSolver.js","webpack://element-web/./node_modules/focus-lock/dist/es2015/moveFocusInside.js","webpack://element-web/./node_modules/focus-lock/dist/es2015/return-focus.js","webpack://element-web/./node_modules/focus-lock/dist/es2015/sibling.js","webpack://element-web/./node_modules/react-focus-lock/dist/es2015/util.js","webpack://element-web/./node_modules/react-focus-lock/dist/es2015/Trap.js","webpack://element-web/./node_modules/focus-lock/dist/es2015/focusIsHidden.js","webpack://element-web/./node_modules/focus-lock/dist/es2015/focusables.js","webpack://element-web/./node_modules/react-focus-lock/dist/es2015/Combination.js","webpack://element-web/./node_modules/react-focus-lock/dist/es2015/index.js","webpack://element-web/./node_modules/dom-helpers/esm/removeClass.js","webpack://element-web/./node_modules/react-transition-group/esm/CSSTransition.js","webpack://element-web/./node_modules/dom-helpers/esm/addClass.js","webpack://element-web/./node_modules/dom-helpers/esm/hasClass.js","webpack://element-web/./node_modules/react-transition-group/esm/SwitchTransition.js","webpack://element-web/./node_modules/react-transition-group/esm/config.js","webpack://element-web/./node_modules/react-transition-group/esm/Transition.js","webpack://element-web/./node_modules/react-transition-group/esm/TransitionGroupContext.js","webpack://element-web/./node_modules/react-transition-group/esm/utils/reflow.js","webpack://element-web/./node_modules/react/cjs/react-jsx-runtime.production.min.js","webpack://element-web/./node_modules/react/cjs/react.production.min.js","webpack://element-web/./node_modules/react/index.js","webpack://element-web/./node_modules/react/jsx-runtime.js","webpack://element-web/./node_modules/rfc4648/lib/rfc4648.js","webpack://element-web/./node_modules/sanitize-html/index.js","webpack://element-web/./node_modules/sanitize-html/node_modules/postcss/lib/at-rule.js","webpack://element-web/./node_modules/sanitize-html/node_modules/postcss/lib/comment.js","webpack://element-web/./node_modules/sanitize-html/node_modules/postcss/lib/container.js","webpack://element-web/./node_modules/sanitize-html/node_modules/postcss/lib/css-syntax-error.js","webpack://element-web/./node_modules/sanitize-html/node_modules/postcss/lib/declaration.js","webpack://element-web/./node_modules/sanitize-html/node_modules/postcss/lib/document.js","webpack://element-web/./node_modules/sanitize-html/node_modules/postcss/lib/fromJSON.js","webpack://element-web/./node_modules/sanitize-html/node_modules/postcss/lib/input.js","webpack://element-web/./node_modules/sanitize-html/node_modules/postcss/lib/lazy-result.js","webpack://element-web/./node_modules/sanitize-html/node_modules/postcss/lib/list.js","webpack://element-web/./node_modules/sanitize-html/node_modules/postcss/lib/map-generator.js","webpack://element-web/./node_modules/sanitize-html/node_modules/postcss/lib/no-work-result.js","webpack://element-web/./node_modules/sanitize-html/node_modules/postcss/lib/node.js","webpack://element-web/./node_modules/sanitize-html/node_modules/postcss/lib/parse.js","webpack://element-web/./node_modules/sanitize-html/node_modules/postcss/lib/parser.js","webpack://element-web/./node_modules/sanitize-html/node_modules/postcss/lib/postcss.js","webpack://element-web/./node_modules/sanitize-html/node_modules/postcss/lib/previous-map.js","webpack://element-web/./node_modules/sanitize-html/node_modules/postcss/lib/processor.js","webpack://element-web/./node_modules/sanitize-html/node_modules/postcss/lib/result.js","webpack://element-web/./node_modules/sanitize-html/node_modules/postcss/lib/root.js","webpack://element-web/./node_modules/sanitize-html/node_modules/postcss/lib/rule.js","webpack://element-web/./node_modules/sanitize-html/node_modules/postcss/lib/stringifier.js","webpack://element-web/./node_modules/sanitize-html/node_modules/postcss/lib/stringify.js","webpack://element-web/./node_modules/sanitize-html/node_modules/postcss/lib/symbols.js","webpack://element-web/./node_modules/sanitize-html/node_modules/postcss/lib/tokenize.js","webpack://element-web/./node_modules/sanitize-html/node_modules/postcss/lib/warn-once.js","webpack://element-web/./node_modules/sanitize-html/node_modules/postcss/lib/warning.js","webpack://element-web/./node_modules/scheduler/cjs/scheduler.production.min.js","webpack://element-web/./node_modules/scheduler/index.js","webpack://element-web/./node_modules/sdp-transform/lib/grammar.js","webpack://element-web/./node_modules/sdp-transform/lib/index.js","webpack://element-web/./node_modules/sdp-transform/lib/parser.js","webpack://element-web/./node_modules/sdp-transform/lib/writer.js","webpack://element-web/./node_modules/set-function-length/index.js","webpack://element-web/./node_modules/sprintf-js/src/sprintf.js","webpack://element-web/./node_modules/temporal-polyfill/chunks/internal.js","webpack://element-web/./node_modules/temporal-polyfill/chunks/classApi.js","webpack://element-web/./node_modules/tslib/tslib.es6.mjs","webpack://element-web/./node_modules/ua-parser-js/src/ua-parser.js","webpack://element-web/./node_modules/use-sidecar/dist/es2015/medium.js","webpack://element-web/./node_modules/util/node_modules/is-typed-array/index.js","webpack://element-web/./node_modules/util/node_modules/is-typed-array/node_modules/which-typed-array/index.js","webpack://element-web/./node_modules/util/node_modules/which-typed-array/index.js","webpack://element-web/./node_modules/util/support/isBufferBrowser.js","webpack://element-web/./node_modules/util/support/types.js","webpack://element-web/./node_modules/util/util.js","webpack://element-web/./node_modules/uuid/dist/esm-browser/native.js","webpack://element-web/./node_modules/uuid/dist/esm-browser/rng.js","webpack://element-web/./node_modules/uuid/dist/esm-browser/stringify.js","webpack://element-web/./node_modules/uuid/dist/esm-browser/v4.js"],"sourcesContent":["function _assertThisInitialized(e) {\n  if (void 0 === e) throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n  return e;\n}\nmodule.exports = _assertThisInitialized, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _classCallCheck(a, n) {\n  if (!(a instanceof n)) throw new TypeError(\"Cannot call a class as a function\");\n}\nmodule.exports = _classCallCheck, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var toPropertyKey = require(\"./toPropertyKey.js\");\nfunction _defineProperties(e, r) {\n  for (var t = 0; t < r.length; t++) {\n    var o = r[t];\n    o.enumerable = o.enumerable || !1, o.configurable = !0, \"value\" in o && (o.writable = !0), Object.defineProperty(e, toPropertyKey(o.key), o);\n  }\n}\nfunction _createClass(e, r, t) {\n  return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, \"prototype\", {\n    writable: !1\n  }), e;\n}\nmodule.exports = _createClass, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var toPropertyKey = require(\"./toPropertyKey.js\");\nfunction _defineProperty(e, r, t) {\n  return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {\n    value: t,\n    enumerable: !0,\n    configurable: !0,\n    writable: !0\n  }) : e[r] = t, e;\n}\nmodule.exports = _defineProperty, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _extends() {\n  return _extends = Object.assign ? Object.assign.bind() : function (n) {\n    for (var e = 1; e < arguments.length; e++) {\n      var t = arguments[e];\n      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);\n    }\n    return n;\n  }, _extends.apply(null, arguments);\n}\nexport { _extends as default };","import setPrototypeOf from \"./setPrototypeOf.js\";\nfunction _inheritsLoose(t, o) {\n  t.prototype = Object.create(o.prototype), t.prototype.constructor = t, setPrototypeOf(t, o);\n}\nexport { _inheritsLoose as default };","import objectWithoutPropertiesLoose from \"./objectWithoutPropertiesLoose.js\";\nfunction _objectWithoutProperties(e, t) {\n  if (null == e) return {};\n  var o,\n    r,\n    i = objectWithoutPropertiesLoose(e, t);\n  if (Object.getOwnPropertySymbols) {\n    var n = Object.getOwnPropertySymbols(e);\n    for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);\n  }\n  return i;\n}\nexport { _objectWithoutProperties as default };","function _objectWithoutPropertiesLoose(r, e) {\n  if (null == r) return {};\n  var t = {};\n  for (var n in r) if ({}.hasOwnProperty.call(r, n)) {\n    if (-1 !== e.indexOf(n)) continue;\n    t[n] = r[n];\n  }\n  return t;\n}\nexport { _objectWithoutPropertiesLoose as default };","function _setPrototypeOf(t, e) {\n  return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) {\n    return t.__proto__ = e, t;\n  }, _setPrototypeOf(t, e);\n}\nexport { _setPrototypeOf as default };","function _getPrototypeOf(t) {\n  return module.exports = _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) {\n    return t.__proto__ || Object.getPrototypeOf(t);\n  }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports, _getPrototypeOf(t);\n}\nmodule.exports = _getPrototypeOf, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var setPrototypeOf = require(\"./setPrototypeOf.js\");\nfunction _inherits(t, e) {\n  if (\"function\" != typeof e && null !== e) throw new TypeError(\"Super expression must either be null or a function\");\n  t.prototype = Object.create(e && e.prototype, {\n    constructor: {\n      value: t,\n      writable: !0,\n      configurable: !0\n    }\n  }), Object.defineProperty(t, \"prototype\", {\n    writable: !1\n  }), e && setPrototypeOf(t, e);\n}\nmodule.exports = _inherits, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _interopRequireDefault(e) {\n  return e && e.__esModule ? e : {\n    \"default\": e\n  };\n}\nmodule.exports = _interopRequireDefault, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var _typeof = require(\"./typeof.js\")[\"default\"];\nvar assertThisInitialized = require(\"./assertThisInitialized.js\");\nfunction _possibleConstructorReturn(t, e) {\n  if (e && (\"object\" == _typeof(e) || \"function\" == typeof e)) return e;\n  if (void 0 !== e) throw new TypeError(\"Derived constructors may only return object or undefined\");\n  return assertThisInitialized(t);\n}\nmodule.exports = _possibleConstructorReturn, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _setPrototypeOf(t, e) {\n  return module.exports = _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) {\n    return t.__proto__ = e, t;\n  }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports, _setPrototypeOf(t, e);\n}\nmodule.exports = _setPrototypeOf, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var _typeof = require(\"./typeof.js\")[\"default\"];\nfunction toPrimitive(t, r) {\n  if (\"object\" != _typeof(t) || !t) return t;\n  var e = t[Symbol.toPrimitive];\n  if (void 0 !== e) {\n    var i = e.call(t, r || \"default\");\n    if (\"object\" != _typeof(i)) return i;\n    throw new TypeError(\"@@toPrimitive must return a primitive value.\");\n  }\n  return (\"string\" === r ? String : Number)(t);\n}\nmodule.exports = toPrimitive, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var _typeof = require(\"./typeof.js\")[\"default\"];\nvar toPrimitive = require(\"./toPrimitive.js\");\nfunction toPropertyKey(t) {\n  var i = toPrimitive(t, \"string\");\n  return \"symbol\" == _typeof(i) ? i : i + \"\";\n}\nmodule.exports = toPropertyKey, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _typeof(o) {\n  \"@babel/helpers - typeof\";\n\n  return module.exports = _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (o) {\n    return typeof o;\n  } : function (o) {\n    return o && \"function\" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? \"symbol\" : typeof o;\n  }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports, _typeof(o);\n}\nmodule.exports = _typeof, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","// Note: this is the semver.org version of the spec that it implements\n// Not necessarily the package version of this code.\nconst SEMVER_SPEC_VERSION = '2.0.0'\n\nconst MAX_LENGTH = 256\nconst MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER ||\n/* istanbul ignore next */ 9007199254740991\n\n// Max safe segment length for coercion.\nconst MAX_SAFE_COMPONENT_LENGTH = 16\n\n// Max safe length for a build identifier. The max length minus 6 characters for\n// the shortest version with a build 0.0.0+BUILD.\nconst MAX_SAFE_BUILD_LENGTH = MAX_LENGTH - 6\n\nconst RELEASE_TYPES = [\n  'major',\n  'premajor',\n  'minor',\n  'preminor',\n  'patch',\n  'prepatch',\n  'prerelease',\n]\n\nmodule.exports = {\n  MAX_LENGTH,\n  MAX_SAFE_COMPONENT_LENGTH,\n  MAX_SAFE_BUILD_LENGTH,\n  MAX_SAFE_INTEGER,\n  RELEASE_TYPES,\n  SEMVER_SPEC_VERSION,\n  FLAG_INCLUDE_PRERELEASE: 0b001,\n  FLAG_LOOSE: 0b010,\n}\n","const debug = (\n  typeof process === 'object' &&\n  process.env &&\n  process.env.NODE_DEBUG &&\n  /\\bsemver\\b/i.test(process.env.NODE_DEBUG)\n) ? (...args) => console.error('SEMVER', ...args)\n  : () => {}\n\nmodule.exports = debug\n","const {\n  MAX_SAFE_COMPONENT_LENGTH,\n  MAX_SAFE_BUILD_LENGTH,\n  MAX_LENGTH,\n} = require('./constants')\nconst debug = require('./debug')\nexports = module.exports = {}\n\n// The actual regexps go on exports.re\nconst re = exports.re = []\nconst safeRe = exports.safeRe = []\nconst src = exports.src = []\nconst t = exports.t = {}\nlet R = 0\n\nconst LETTERDASHNUMBER = '[a-zA-Z0-9-]'\n\n// Replace some greedy regex tokens to prevent regex dos issues. These regex are\n// used internally via the safeRe object since all inputs in this library get\n// normalized first to trim and collapse all extra whitespace. The original\n// regexes are exported for userland consumption and lower level usage. A\n// future breaking change could export the safer regex only with a note that\n// all input should have extra whitespace removed.\nconst safeRegexReplacements = [\n  ['\\\\s', 1],\n  ['\\\\d', MAX_LENGTH],\n  [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH],\n]\n\nconst makeSafeRegex = (value) => {\n  for (const [token, max] of safeRegexReplacements) {\n    value = value\n      .split(`${token}*`).join(`${token}{0,${max}}`)\n      .split(`${token}+`).join(`${token}{1,${max}}`)\n  }\n  return value\n}\n\nconst createToken = (name, value, isGlobal) => {\n  const safe = makeSafeRegex(value)\n  const index = R++\n  debug(name, index, value)\n  t[name] = index\n  src[index] = value\n  re[index] = new RegExp(value, isGlobal ? 'g' : undefined)\n  safeRe[index] = new RegExp(safe, isGlobal ? 'g' : undefined)\n}\n\n// The following Regular Expressions can be used for tokenizing,\n// validating, and parsing SemVer version strings.\n\n// ## Numeric Identifier\n// A single `0`, or a non-zero digit followed by zero or more digits.\n\ncreateToken('NUMERICIDENTIFIER', '0|[1-9]\\\\d*')\ncreateToken('NUMERICIDENTIFIERLOOSE', '\\\\d+')\n\n// ## Non-numeric Identifier\n// Zero or more digits, followed by a letter or hyphen, and then zero or\n// more letters, digits, or hyphens.\n\ncreateToken('NONNUMERICIDENTIFIER', `\\\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`)\n\n// ## Main Version\n// Three dot-separated numeric identifiers.\n\ncreateToken('MAINVERSION', `(${src[t.NUMERICIDENTIFIER]})\\\\.` +\n                   `(${src[t.NUMERICIDENTIFIER]})\\\\.` +\n                   `(${src[t.NUMERICIDENTIFIER]})`)\n\ncreateToken('MAINVERSIONLOOSE', `(${src[t.NUMERICIDENTIFIERLOOSE]})\\\\.` +\n                        `(${src[t.NUMERICIDENTIFIERLOOSE]})\\\\.` +\n                        `(${src[t.NUMERICIDENTIFIERLOOSE]})`)\n\n// ## Pre-release Version Identifier\n// A numeric identifier, or a non-numeric identifier.\n\ncreateToken('PRERELEASEIDENTIFIER', `(?:${src[t.NUMERICIDENTIFIER]\n}|${src[t.NONNUMERICIDENTIFIER]})`)\n\ncreateToken('PRERELEASEIDENTIFIERLOOSE', `(?:${src[t.NUMERICIDENTIFIERLOOSE]\n}|${src[t.NONNUMERICIDENTIFIER]})`)\n\n// ## Pre-release Version\n// Hyphen, followed by one or more dot-separated pre-release version\n// identifiers.\n\ncreateToken('PRERELEASE', `(?:-(${src[t.PRERELEASEIDENTIFIER]\n}(?:\\\\.${src[t.PRERELEASEIDENTIFIER]})*))`)\n\ncreateToken('PRERELEASELOOSE', `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]\n}(?:\\\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`)\n\n// ## Build Metadata Identifier\n// Any combination of digits, letters, or hyphens.\n\ncreateToken('BUILDIDENTIFIER', `${LETTERDASHNUMBER}+`)\n\n// ## Build Metadata\n// Plus sign, followed by one or more period-separated build metadata\n// identifiers.\n\ncreateToken('BUILD', `(?:\\\\+(${src[t.BUILDIDENTIFIER]\n}(?:\\\\.${src[t.BUILDIDENTIFIER]})*))`)\n\n// ## Full Version String\n// A main version, followed optionally by a pre-release version and\n// build metadata.\n\n// Note that the only major, minor, patch, and pre-release sections of\n// the version string are capturing groups.  The build metadata is not a\n// capturing group, because it should not ever be used in version\n// comparison.\n\ncreateToken('FULLPLAIN', `v?${src[t.MAINVERSION]\n}${src[t.PRERELEASE]}?${\n  src[t.BUILD]}?`)\n\ncreateToken('FULL', `^${src[t.FULLPLAIN]}$`)\n\n// like full, but allows v1.2.3 and =1.2.3, which people do sometimes.\n// also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty\n// common in the npm registry.\ncreateToken('LOOSEPLAIN', `[v=\\\\s]*${src[t.MAINVERSIONLOOSE]\n}${src[t.PRERELEASELOOSE]}?${\n  src[t.BUILD]}?`)\n\ncreateToken('LOOSE', `^${src[t.LOOSEPLAIN]}$`)\n\ncreateToken('GTLT', '((?:<|>)?=?)')\n\n// Something like \"2.*\" or \"1.2.x\".\n// Note that \"x.x\" is a valid xRange identifer, meaning \"any version\"\n// Only the first item is strictly required.\ncreateToken('XRANGEIDENTIFIERLOOSE', `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\\\*`)\ncreateToken('XRANGEIDENTIFIER', `${src[t.NUMERICIDENTIFIER]}|x|X|\\\\*`)\n\ncreateToken('XRANGEPLAIN', `[v=\\\\s]*(${src[t.XRANGEIDENTIFIER]})` +\n                   `(?:\\\\.(${src[t.XRANGEIDENTIFIER]})` +\n                   `(?:\\\\.(${src[t.XRANGEIDENTIFIER]})` +\n                   `(?:${src[t.PRERELEASE]})?${\n                     src[t.BUILD]}?` +\n                   `)?)?`)\n\ncreateToken('XRANGEPLAINLOOSE', `[v=\\\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})` +\n                        `(?:\\\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` +\n                        `(?:\\\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` +\n                        `(?:${src[t.PRERELEASELOOSE]})?${\n                          src[t.BUILD]}?` +\n                        `)?)?`)\n\ncreateToken('XRANGE', `^${src[t.GTLT]}\\\\s*${src[t.XRANGEPLAIN]}$`)\ncreateToken('XRANGELOOSE', `^${src[t.GTLT]}\\\\s*${src[t.XRANGEPLAINLOOSE]}$`)\n\n// Coercion.\n// Extract anything that could conceivably be a part of a valid semver\ncreateToken('COERCEPLAIN', `${'(^|[^\\\\d])' +\n              '(\\\\d{1,'}${MAX_SAFE_COMPONENT_LENGTH}})` +\n              `(?:\\\\.(\\\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` +\n              `(?:\\\\.(\\\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?`)\ncreateToken('COERCE', `${src[t.COERCEPLAIN]}(?:$|[^\\\\d])`)\ncreateToken('COERCEFULL', src[t.COERCEPLAIN] +\n              `(?:${src[t.PRERELEASE]})?` +\n              `(?:${src[t.BUILD]})?` +\n              `(?:$|[^\\\\d])`)\ncreateToken('COERCERTL', src[t.COERCE], true)\ncreateToken('COERCERTLFULL', src[t.COERCEFULL], true)\n\n// Tilde ranges.\n// Meaning is \"reasonably at or greater than\"\ncreateToken('LONETILDE', '(?:~>?)')\n\ncreateToken('TILDETRIM', `(\\\\s*)${src[t.LONETILDE]}\\\\s+`, true)\nexports.tildeTrimReplace = '$1~'\n\ncreateToken('TILDE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`)\ncreateToken('TILDELOOSE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`)\n\n// Caret ranges.\n// Meaning is \"at least and backwards compatible with\"\ncreateToken('LONECARET', '(?:\\\\^)')\n\ncreateToken('CARETTRIM', `(\\\\s*)${src[t.LONECARET]}\\\\s+`, true)\nexports.caretTrimReplace = '$1^'\n\ncreateToken('CARET', `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`)\ncreateToken('CARETLOOSE', `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`)\n\n// A simple gt/lt/eq thing, or just \"\" to indicate \"any version\"\ncreateToken('COMPARATORLOOSE', `^${src[t.GTLT]}\\\\s*(${src[t.LOOSEPLAIN]})$|^$`)\ncreateToken('COMPARATOR', `^${src[t.GTLT]}\\\\s*(${src[t.FULLPLAIN]})$|^$`)\n\n// An expression to strip any whitespace between the gtlt and the thing\n// it modifies, so that `> 1.2.3` ==> `>1.2.3`\ncreateToken('COMPARATORTRIM', `(\\\\s*)${src[t.GTLT]\n}\\\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true)\nexports.comparatorTrimReplace = '$1$2$3'\n\n// Something like `1.2.3 - 1.2.4`\n// Note that these all use the loose form, because they'll be\n// checked against either the strict or loose comparator form\n// later.\ncreateToken('HYPHENRANGE', `^\\\\s*(${src[t.XRANGEPLAIN]})` +\n                   `\\\\s+-\\\\s+` +\n                   `(${src[t.XRANGEPLAIN]})` +\n                   `\\\\s*$`)\n\ncreateToken('HYPHENRANGELOOSE', `^\\\\s*(${src[t.XRANGEPLAINLOOSE]})` +\n                        `\\\\s+-\\\\s+` +\n                        `(${src[t.XRANGEPLAINLOOSE]})` +\n                        `\\\\s*$`)\n\n// Star ranges basically just allow anything at all.\ncreateToken('STAR', '(<|>)?=?\\\\s*\\\\*')\n// >=0.0.0 is like a star\ncreateToken('GTE0', '^\\\\s*>=\\\\s*0\\\\.0\\\\.0\\\\s*$')\ncreateToken('GTE0PRE', '^\\\\s*>=\\\\s*0\\\\.0\\\\.0-0\\\\s*$')\n","// parse out just the options we care about\nconst looseOption = Object.freeze({ loose: true })\nconst emptyOpts = Object.freeze({ })\nconst parseOptions = options => {\n  if (!options) {\n    return emptyOpts\n  }\n\n  if (typeof options !== 'object') {\n    return looseOption\n  }\n\n  return options\n}\nmodule.exports = parseOptions\n","const numeric = /^[0-9]+$/\nconst compareIdentifiers = (a, b) => {\n  const anum = numeric.test(a)\n  const bnum = numeric.test(b)\n\n  if (anum && bnum) {\n    a = +a\n    b = +b\n  }\n\n  return a === b ? 0\n    : (anum && !bnum) ? -1\n    : (bnum && !anum) ? 1\n    : a < b ? -1\n    : 1\n}\n\nconst rcompareIdentifiers = (a, b) => compareIdentifiers(b, a)\n\nmodule.exports = {\n  compareIdentifiers,\n  rcompareIdentifiers,\n}\n","const debug = require('../internal/debug')\nconst { MAX_LENGTH, MAX_SAFE_INTEGER } = require('../internal/constants')\nconst { safeRe: re, t } = require('../internal/re')\n\nconst parseOptions = require('../internal/parse-options')\nconst { compareIdentifiers } = require('../internal/identifiers')\nclass SemVer {\n  constructor (version, options) {\n    options = parseOptions(options)\n\n    if (version instanceof SemVer) {\n      if (version.loose === !!options.loose &&\n          version.includePrerelease === !!options.includePrerelease) {\n        return version\n      } else {\n        version = version.version\n      }\n    } else if (typeof version !== 'string') {\n      throw new TypeError(`Invalid version. Must be a string. Got type \"${typeof version}\".`)\n    }\n\n    if (version.length > MAX_LENGTH) {\n      throw new TypeError(\n        `version is longer than ${MAX_LENGTH} characters`\n      )\n    }\n\n    debug('SemVer', version, options)\n    this.options = options\n    this.loose = !!options.loose\n    // this isn't actually relevant for versions, but keep it so that we\n    // don't run into trouble passing this.options around.\n    this.includePrerelease = !!options.includePrerelease\n\n    const m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL])\n\n    if (!m) {\n      throw new TypeError(`Invalid Version: ${version}`)\n    }\n\n    this.raw = version\n\n    // these are actually numbers\n    this.major = +m[1]\n    this.minor = +m[2]\n    this.patch = +m[3]\n\n    if (this.major > MAX_SAFE_INTEGER || this.major < 0) {\n      throw new TypeError('Invalid major version')\n    }\n\n    if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {\n      throw new TypeError('Invalid minor version')\n    }\n\n    if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {\n      throw new TypeError('Invalid patch version')\n    }\n\n    // numberify any prerelease numeric ids\n    if (!m[4]) {\n      this.prerelease = []\n    } else {\n      this.prerelease = m[4].split('.').map((id) => {\n        if (/^[0-9]+$/.test(id)) {\n          const num = +id\n          if (num >= 0 && num < MAX_SAFE_INTEGER) {\n            return num\n          }\n        }\n        return id\n      })\n    }\n\n    this.build = m[5] ? m[5].split('.') : []\n    this.format()\n  }\n\n  format () {\n    this.version = `${this.major}.${this.minor}.${this.patch}`\n    if (this.prerelease.length) {\n      this.version += `-${this.prerelease.join('.')}`\n    }\n    return this.version\n  }\n\n  toString () {\n    return this.version\n  }\n\n  compare (other) {\n    debug('SemVer.compare', this.version, this.options, other)\n    if (!(other instanceof SemVer)) {\n      if (typeof other === 'string' && other === this.version) {\n        return 0\n      }\n      other = new SemVer(other, this.options)\n    }\n\n    if (other.version === this.version) {\n      return 0\n    }\n\n    return this.compareMain(other) || this.comparePre(other)\n  }\n\n  compareMain (other) {\n    if (!(other instanceof SemVer)) {\n      other = new SemVer(other, this.options)\n    }\n\n    return (\n      compareIdentifiers(this.major, other.major) ||\n      compareIdentifiers(this.minor, other.minor) ||\n      compareIdentifiers(this.patch, other.patch)\n    )\n  }\n\n  comparePre (other) {\n    if (!(other instanceof SemVer)) {\n      other = new SemVer(other, this.options)\n    }\n\n    // NOT having a prerelease is > having one\n    if (this.prerelease.length && !other.prerelease.length) {\n      return -1\n    } else if (!this.prerelease.length && other.prerelease.length) {\n      return 1\n    } else if (!this.prerelease.length && !other.prerelease.length) {\n      return 0\n    }\n\n    let i = 0\n    do {\n      const a = this.prerelease[i]\n      const b = other.prerelease[i]\n      debug('prerelease compare', i, a, b)\n      if (a === undefined && b === undefined) {\n        return 0\n      } else if (b === undefined) {\n        return 1\n      } else if (a === undefined) {\n        return -1\n      } else if (a === b) {\n        continue\n      } else {\n        return compareIdentifiers(a, b)\n      }\n    } while (++i)\n  }\n\n  compareBuild (other) {\n    if (!(other instanceof SemVer)) {\n      other = new SemVer(other, this.options)\n    }\n\n    let i = 0\n    do {\n      const a = this.build[i]\n      const b = other.build[i]\n      debug('build compare', i, a, b)\n      if (a === undefined && b === undefined) {\n        return 0\n      } else if (b === undefined) {\n        return 1\n      } else if (a === undefined) {\n        return -1\n      } else if (a === b) {\n        continue\n      } else {\n        return compareIdentifiers(a, b)\n      }\n    } while (++i)\n  }\n\n  // preminor will bump the version up to the next minor release, and immediately\n  // down to pre-release. premajor and prepatch work the same way.\n  inc (release, identifier, identifierBase) {\n    switch (release) {\n      case 'premajor':\n        this.prerelease.length = 0\n        this.patch = 0\n        this.minor = 0\n        this.major++\n        this.inc('pre', identifier, identifierBase)\n        break\n      case 'preminor':\n        this.prerelease.length = 0\n        this.patch = 0\n        this.minor++\n        this.inc('pre', identifier, identifierBase)\n        break\n      case 'prepatch':\n        // If this is already a prerelease, it will bump to the next version\n        // drop any prereleases that might already exist, since they are not\n        // relevant at this point.\n        this.prerelease.length = 0\n        this.inc('patch', identifier, identifierBase)\n        this.inc('pre', identifier, identifierBase)\n        break\n      // If the input is a non-prerelease version, this acts the same as\n      // prepatch.\n      case 'prerelease':\n        if (this.prerelease.length === 0) {\n          this.inc('patch', identifier, identifierBase)\n        }\n        this.inc('pre', identifier, identifierBase)\n        break\n\n      case 'major':\n        // If this is a pre-major version, bump up to the same major version.\n        // Otherwise increment major.\n        // 1.0.0-5 bumps to 1.0.0\n        // 1.1.0 bumps to 2.0.0\n        if (\n          this.minor !== 0 ||\n          this.patch !== 0 ||\n          this.prerelease.length === 0\n        ) {\n          this.major++\n        }\n        this.minor = 0\n        this.patch = 0\n        this.prerelease = []\n        break\n      case 'minor':\n        // If this is a pre-minor version, bump up to the same minor version.\n        // Otherwise increment minor.\n        // 1.2.0-5 bumps to 1.2.0\n        // 1.2.1 bumps to 1.3.0\n        if (this.patch !== 0 || this.prerelease.length === 0) {\n          this.minor++\n        }\n        this.patch = 0\n        this.prerelease = []\n        break\n      case 'patch':\n        // If this is not a pre-release version, it will increment the patch.\n        // If it is a pre-release it will bump up to the same patch version.\n        // 1.2.0-5 patches to 1.2.0\n        // 1.2.0 patches to 1.2.1\n        if (this.prerelease.length === 0) {\n          this.patch++\n        }\n        this.prerelease = []\n        break\n      // This probably shouldn't be used publicly.\n      // 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction.\n      case 'pre': {\n        const base = Number(identifierBase) ? 1 : 0\n\n        if (!identifier && identifierBase === false) {\n          throw new Error('invalid increment argument: identifier is empty')\n        }\n\n        if (this.prerelease.length === 0) {\n          this.prerelease = [base]\n        } else {\n          let i = this.prerelease.length\n          while (--i >= 0) {\n            if (typeof this.prerelease[i] === 'number') {\n              this.prerelease[i]++\n              i = -2\n            }\n          }\n          if (i === -1) {\n            // didn't increment anything\n            if (identifier === this.prerelease.join('.') && identifierBase === false) {\n              throw new Error('invalid increment argument: identifier already exists')\n            }\n            this.prerelease.push(base)\n          }\n        }\n        if (identifier) {\n          // 1.2.0-beta.1 bumps to 1.2.0-beta.2,\n          // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0\n          let prerelease = [identifier, base]\n          if (identifierBase === false) {\n            prerelease = [identifier]\n          }\n          if (compareIdentifiers(this.prerelease[0], identifier) === 0) {\n            if (isNaN(this.prerelease[1])) {\n              this.prerelease = prerelease\n            }\n          } else {\n            this.prerelease = prerelease\n          }\n        }\n        break\n      }\n      default:\n        throw new Error(`invalid increment argument: ${release}`)\n    }\n    this.raw = this.format()\n    if (this.build.length) {\n      this.raw += `+${this.build.join('.')}`\n    }\n    return this\n  }\n}\n\nmodule.exports = SemVer\n","const SemVer = require('../classes/semver')\nconst parse = (version, options, throwErrors = false) => {\n  if (version instanceof SemVer) {\n    return version\n  }\n  try {\n    return new SemVer(version, options)\n  } catch (er) {\n    if (!throwErrors) {\n      return null\n    }\n    throw er\n  }\n}\n\nmodule.exports = parse\n","const SemVer = require('../classes/semver')\nconst compare = (a, b, loose) =>\n  new SemVer(a, loose).compare(new SemVer(b, loose))\n\nmodule.exports = compare\n","const SemVer = require('../classes/semver')\nconst compareBuild = (a, b, loose) => {\n  const versionA = new SemVer(a, loose)\n  const versionB = new SemVer(b, loose)\n  return versionA.compare(versionB) || versionA.compareBuild(versionB)\n}\nmodule.exports = compareBuild\n","const compare = require('./compare')\nconst gt = (a, b, loose) => compare(a, b, loose) > 0\nmodule.exports = gt\n","const compare = require('./compare')\nconst lt = (a, b, loose) => compare(a, b, loose) < 0\nmodule.exports = lt\n","const compare = require('./compare')\nconst eq = (a, b, loose) => compare(a, b, loose) === 0\nmodule.exports = eq\n","const compare = require('./compare')\nconst neq = (a, b, loose) => compare(a, b, loose) !== 0\nmodule.exports = neq\n","const compare = require('./compare')\nconst gte = (a, b, loose) => compare(a, b, loose) >= 0\nmodule.exports = gte\n","const compare = require('./compare')\nconst lte = (a, b, loose) => compare(a, b, loose) <= 0\nmodule.exports = lte\n","const eq = require('./eq')\nconst neq = require('./neq')\nconst gt = require('./gt')\nconst gte = require('./gte')\nconst lt = require('./lt')\nconst lte = require('./lte')\n\nconst cmp = (a, op, b, loose) => {\n  switch (op) {\n    case '===':\n      if (typeof a === 'object') {\n        a = a.version\n      }\n      if (typeof b === 'object') {\n        b = b.version\n      }\n      return a === b\n\n    case '!==':\n      if (typeof a === 'object') {\n        a = a.version\n      }\n      if (typeof b === 'object') {\n        b = b.version\n      }\n      return a !== b\n\n    case '':\n    case '=':\n    case '==':\n      return eq(a, b, loose)\n\n    case '!=':\n      return neq(a, b, loose)\n\n    case '>':\n      return gt(a, b, loose)\n\n    case '>=':\n      return gte(a, b, loose)\n\n    case '<':\n      return lt(a, b, loose)\n\n    case '<=':\n      return lte(a, b, loose)\n\n    default:\n      throw new TypeError(`Invalid operator: ${op}`)\n  }\n}\nmodule.exports = cmp\n","const SPACE_CHARACTERS = /\\s+/g\n\n// hoisted class for cyclic dependency\nclass Range {\n  constructor (range, options) {\n    options = parseOptions(options)\n\n    if (range instanceof Range) {\n      if (\n        range.loose === !!options.loose &&\n        range.includePrerelease === !!options.includePrerelease\n      ) {\n        return range\n      } else {\n        return new Range(range.raw, options)\n      }\n    }\n\n    if (range instanceof Comparator) {\n      // just put it in the set and return\n      this.raw = range.value\n      this.set = [[range]]\n      this.formatted = undefined\n      return this\n    }\n\n    this.options = options\n    this.loose = !!options.loose\n    this.includePrerelease = !!options.includePrerelease\n\n    // First reduce all whitespace as much as possible so we do not have to rely\n    // on potentially slow regexes like \\s*. This is then stored and used for\n    // future error messages as well.\n    this.raw = range.trim().replace(SPACE_CHARACTERS, ' ')\n\n    // First, split on ||\n    this.set = this.raw\n      .split('||')\n      // map the range to a 2d array of comparators\n      .map(r => this.parseRange(r.trim()))\n      // throw out any comparator lists that are empty\n      // this generally means that it was not a valid range, which is allowed\n      // in loose mode, but will still throw if the WHOLE range is invalid.\n      .filter(c => c.length)\n\n    if (!this.set.length) {\n      throw new TypeError(`Invalid SemVer Range: ${this.raw}`)\n    }\n\n    // if we have any that are not the null set, throw out null sets.\n    if (this.set.length > 1) {\n      // keep the first one, in case they're all null sets\n      const first = this.set[0]\n      this.set = this.set.filter(c => !isNullSet(c[0]))\n      if (this.set.length === 0) {\n        this.set = [first]\n      } else if (this.set.length > 1) {\n        // if we have any that are *, then the range is just *\n        for (const c of this.set) {\n          if (c.length === 1 && isAny(c[0])) {\n            this.set = [c]\n            break\n          }\n        }\n      }\n    }\n\n    this.formatted = undefined\n  }\n\n  get range () {\n    if (this.formatted === undefined) {\n      this.formatted = ''\n      for (let i = 0; i < this.set.length; i++) {\n        if (i > 0) {\n          this.formatted += '||'\n        }\n        const comps = this.set[i]\n        for (let k = 0; k < comps.length; k++) {\n          if (k > 0) {\n            this.formatted += ' '\n          }\n          this.formatted += comps[k].toString().trim()\n        }\n      }\n    }\n    return this.formatted\n  }\n\n  format () {\n    return this.range\n  }\n\n  toString () {\n    return this.range\n  }\n\n  parseRange (range) {\n    // memoize range parsing for performance.\n    // this is a very hot path, and fully deterministic.\n    const memoOpts =\n      (this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) |\n      (this.options.loose && FLAG_LOOSE)\n    const memoKey = memoOpts + ':' + range\n    const cached = cache.get(memoKey)\n    if (cached) {\n      return cached\n    }\n\n    const loose = this.options.loose\n    // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`\n    const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE]\n    range = range.replace(hr, hyphenReplace(this.options.includePrerelease))\n    debug('hyphen replace', range)\n\n    // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`\n    range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace)\n    debug('comparator trim', range)\n\n    // `~ 1.2.3` => `~1.2.3`\n    range = range.replace(re[t.TILDETRIM], tildeTrimReplace)\n    debug('tilde trim', range)\n\n    // `^ 1.2.3` => `^1.2.3`\n    range = range.replace(re[t.CARETTRIM], caretTrimReplace)\n    debug('caret trim', range)\n\n    // At this point, the range is completely trimmed and\n    // ready to be split into comparators.\n\n    let rangeList = range\n      .split(' ')\n      .map(comp => parseComparator(comp, this.options))\n      .join(' ')\n      .split(/\\s+/)\n      // >=0.0.0 is equivalent to *\n      .map(comp => replaceGTE0(comp, this.options))\n\n    if (loose) {\n      // in loose mode, throw out any that are not valid comparators\n      rangeList = rangeList.filter(comp => {\n        debug('loose invalid filter', comp, this.options)\n        return !!comp.match(re[t.COMPARATORLOOSE])\n      })\n    }\n    debug('range list', rangeList)\n\n    // if any comparators are the null set, then replace with JUST null set\n    // if more than one comparator, remove any * comparators\n    // also, don't include the same comparator more than once\n    const rangeMap = new Map()\n    const comparators = rangeList.map(comp => new Comparator(comp, this.options))\n    for (const comp of comparators) {\n      if (isNullSet(comp)) {\n        return [comp]\n      }\n      rangeMap.set(comp.value, comp)\n    }\n    if (rangeMap.size > 1 && rangeMap.has('')) {\n      rangeMap.delete('')\n    }\n\n    const result = [...rangeMap.values()]\n    cache.set(memoKey, result)\n    return result\n  }\n\n  intersects (range, options) {\n    if (!(range instanceof Range)) {\n      throw new TypeError('a Range is required')\n    }\n\n    return this.set.some((thisComparators) => {\n      return (\n        isSatisfiable(thisComparators, options) &&\n        range.set.some((rangeComparators) => {\n          return (\n            isSatisfiable(rangeComparators, options) &&\n            thisComparators.every((thisComparator) => {\n              return rangeComparators.every((rangeComparator) => {\n                return thisComparator.intersects(rangeComparator, options)\n              })\n            })\n          )\n        })\n      )\n    })\n  }\n\n  // if ANY of the sets match ALL of its comparators, then pass\n  test (version) {\n    if (!version) {\n      return false\n    }\n\n    if (typeof version === 'string') {\n      try {\n        version = new SemVer(version, this.options)\n      } catch (er) {\n        return false\n      }\n    }\n\n    for (let i = 0; i < this.set.length; i++) {\n      if (testSet(this.set[i], version, this.options)) {\n        return true\n      }\n    }\n    return false\n  }\n}\n\nmodule.exports = Range\n\nconst LRU = require('../internal/lrucache')\nconst cache = new LRU()\n\nconst parseOptions = require('../internal/parse-options')\nconst Comparator = require('./comparator')\nconst debug = require('../internal/debug')\nconst SemVer = require('./semver')\nconst {\n  safeRe: re,\n  t,\n  comparatorTrimReplace,\n  tildeTrimReplace,\n  caretTrimReplace,\n} = require('../internal/re')\nconst { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = require('../internal/constants')\n\nconst isNullSet = c => c.value === '<0.0.0-0'\nconst isAny = c => c.value === ''\n\n// take a set of comparators and determine whether there\n// exists a version which can satisfy it\nconst isSatisfiable = (comparators, options) => {\n  let result = true\n  const remainingComparators = comparators.slice()\n  let testComparator = remainingComparators.pop()\n\n  while (result && remainingComparators.length) {\n    result = remainingComparators.every((otherComparator) => {\n      return testComparator.intersects(otherComparator, options)\n    })\n\n    testComparator = remainingComparators.pop()\n  }\n\n  return result\n}\n\n// comprised of xranges, tildes, stars, and gtlt's at this point.\n// already replaced the hyphen ranges\n// turn into a set of JUST comparators.\nconst parseComparator = (comp, options) => {\n  debug('comp', comp, options)\n  comp = replaceCarets(comp, options)\n  debug('caret', comp)\n  comp = replaceTildes(comp, options)\n  debug('tildes', comp)\n  comp = replaceXRanges(comp, options)\n  debug('xrange', comp)\n  comp = replaceStars(comp, options)\n  debug('stars', comp)\n  return comp\n}\n\nconst isX = id => !id || id.toLowerCase() === 'x' || id === '*'\n\n// ~, ~> --> * (any, kinda silly)\n// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0-0\n// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0-0\n// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0-0\n// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0-0\n// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0-0\n// ~0.0.1 --> >=0.0.1 <0.1.0-0\nconst replaceTildes = (comp, options) => {\n  return comp\n    .trim()\n    .split(/\\s+/)\n    .map((c) => replaceTilde(c, options))\n    .join(' ')\n}\n\nconst replaceTilde = (comp, options) => {\n  const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE]\n  return comp.replace(r, (_, M, m, p, pr) => {\n    debug('tilde', comp, _, M, m, p, pr)\n    let ret\n\n    if (isX(M)) {\n      ret = ''\n    } else if (isX(m)) {\n      ret = `>=${M}.0.0 <${+M + 1}.0.0-0`\n    } else if (isX(p)) {\n      // ~1.2 == >=1.2.0 <1.3.0-0\n      ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`\n    } else if (pr) {\n      debug('replaceTilde pr', pr)\n      ret = `>=${M}.${m}.${p}-${pr\n      } <${M}.${+m + 1}.0-0`\n    } else {\n      // ~1.2.3 == >=1.2.3 <1.3.0-0\n      ret = `>=${M}.${m}.${p\n      } <${M}.${+m + 1}.0-0`\n    }\n\n    debug('tilde return', ret)\n    return ret\n  })\n}\n\n// ^ --> * (any, kinda silly)\n// ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0-0\n// ^2.0, ^2.0.x --> >=2.0.0 <3.0.0-0\n// ^1.2, ^1.2.x --> >=1.2.0 <2.0.0-0\n// ^1.2.3 --> >=1.2.3 <2.0.0-0\n// ^1.2.0 --> >=1.2.0 <2.0.0-0\n// ^0.0.1 --> >=0.0.1 <0.0.2-0\n// ^0.1.0 --> >=0.1.0 <0.2.0-0\nconst replaceCarets = (comp, options) => {\n  return comp\n    .trim()\n    .split(/\\s+/)\n    .map((c) => replaceCaret(c, options))\n    .join(' ')\n}\n\nconst replaceCaret = (comp, options) => {\n  debug('caret', comp, options)\n  const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET]\n  const z = options.includePrerelease ? '-0' : ''\n  return comp.replace(r, (_, M, m, p, pr) => {\n    debug('caret', comp, _, M, m, p, pr)\n    let ret\n\n    if (isX(M)) {\n      ret = ''\n    } else if (isX(m)) {\n      ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`\n    } else if (isX(p)) {\n      if (M === '0') {\n        ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`\n      } else {\n        ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`\n      }\n    } else if (pr) {\n      debug('replaceCaret pr', pr)\n      if (M === '0') {\n        if (m === '0') {\n          ret = `>=${M}.${m}.${p}-${pr\n          } <${M}.${m}.${+p + 1}-0`\n        } else {\n          ret = `>=${M}.${m}.${p}-${pr\n          } <${M}.${+m + 1}.0-0`\n        }\n      } else {\n        ret = `>=${M}.${m}.${p}-${pr\n        } <${+M + 1}.0.0-0`\n      }\n    } else {\n      debug('no pr')\n      if (M === '0') {\n        if (m === '0') {\n          ret = `>=${M}.${m}.${p\n          }${z} <${M}.${m}.${+p + 1}-0`\n        } else {\n          ret = `>=${M}.${m}.${p\n          }${z} <${M}.${+m + 1}.0-0`\n        }\n      } else {\n        ret = `>=${M}.${m}.${p\n        } <${+M + 1}.0.0-0`\n      }\n    }\n\n    debug('caret return', ret)\n    return ret\n  })\n}\n\nconst replaceXRanges = (comp, options) => {\n  debug('replaceXRanges', comp, options)\n  return comp\n    .split(/\\s+/)\n    .map((c) => replaceXRange(c, options))\n    .join(' ')\n}\n\nconst replaceXRange = (comp, options) => {\n  comp = comp.trim()\n  const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE]\n  return comp.replace(r, (ret, gtlt, M, m, p, pr) => {\n    debug('xRange', comp, ret, gtlt, M, m, p, pr)\n    const xM = isX(M)\n    const xm = xM || isX(m)\n    const xp = xm || isX(p)\n    const anyX = xp\n\n    if (gtlt === '=' && anyX) {\n      gtlt = ''\n    }\n\n    // if we're including prereleases in the match, then we need\n    // to fix this to -0, the lowest possible prerelease value\n    pr = options.includePrerelease ? '-0' : ''\n\n    if (xM) {\n      if (gtlt === '>' || gtlt === '<') {\n        // nothing is allowed\n        ret = '<0.0.0-0'\n      } else {\n        // nothing is forbidden\n        ret = '*'\n      }\n    } else if (gtlt && anyX) {\n      // we know patch is an x, because we have any x at all.\n      // replace X with 0\n      if (xm) {\n        m = 0\n      }\n      p = 0\n\n      if (gtlt === '>') {\n        // >1 => >=2.0.0\n        // >1.2 => >=1.3.0\n        gtlt = '>='\n        if (xm) {\n          M = +M + 1\n          m = 0\n          p = 0\n        } else {\n          m = +m + 1\n          p = 0\n        }\n      } else if (gtlt === '<=') {\n        // <=0.7.x is actually <0.8.0, since any 0.7.x should\n        // pass.  Similarly, <=7.x is actually <8.0.0, etc.\n        gtlt = '<'\n        if (xm) {\n          M = +M + 1\n        } else {\n          m = +m + 1\n        }\n      }\n\n      if (gtlt === '<') {\n        pr = '-0'\n      }\n\n      ret = `${gtlt + M}.${m}.${p}${pr}`\n    } else if (xm) {\n      ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`\n    } else if (xp) {\n      ret = `>=${M}.${m}.0${pr\n      } <${M}.${+m + 1}.0-0`\n    }\n\n    debug('xRange return', ret)\n\n    return ret\n  })\n}\n\n// Because * is AND-ed with everything else in the comparator,\n// and '' means \"any version\", just remove the *s entirely.\nconst replaceStars = (comp, options) => {\n  debug('replaceStars', comp, options)\n  // Looseness is ignored here.  star is always as loose as it gets!\n  return comp\n    .trim()\n    .replace(re[t.STAR], '')\n}\n\nconst replaceGTE0 = (comp, options) => {\n  debug('replaceGTE0', comp, options)\n  return comp\n    .trim()\n    .replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], '')\n}\n\n// This function is passed to string.replace(re[t.HYPHENRANGE])\n// M, m, patch, prerelease, build\n// 1.2 - 3.4.5 => >=1.2.0 <=3.4.5\n// 1.2.3 - 3.4 => >=1.2.0 <3.5.0-0 Any 3.4.x will do\n// 1.2 - 3.4 => >=1.2.0 <3.5.0-0\n// TODO build?\nconst hyphenReplace = incPr => ($0,\n  from, fM, fm, fp, fpr, fb,\n  to, tM, tm, tp, tpr) => {\n  if (isX(fM)) {\n    from = ''\n  } else if (isX(fm)) {\n    from = `>=${fM}.0.0${incPr ? '-0' : ''}`\n  } else if (isX(fp)) {\n    from = `>=${fM}.${fm}.0${incPr ? '-0' : ''}`\n  } else if (fpr) {\n    from = `>=${from}`\n  } else {\n    from = `>=${from}${incPr ? '-0' : ''}`\n  }\n\n  if (isX(tM)) {\n    to = ''\n  } else if (isX(tm)) {\n    to = `<${+tM + 1}.0.0-0`\n  } else if (isX(tp)) {\n    to = `<${tM}.${+tm + 1}.0-0`\n  } else if (tpr) {\n    to = `<=${tM}.${tm}.${tp}-${tpr}`\n  } else if (incPr) {\n    to = `<${tM}.${tm}.${+tp + 1}-0`\n  } else {\n    to = `<=${to}`\n  }\n\n  return `${from} ${to}`.trim()\n}\n\nconst testSet = (set, version, options) => {\n  for (let i = 0; i < set.length; i++) {\n    if (!set[i].test(version)) {\n      return false\n    }\n  }\n\n  if (version.prerelease.length && !options.includePrerelease) {\n    // Find the set of versions that are allowed to have prereleases\n    // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0\n    // That should allow `1.2.3-pr.2` to pass.\n    // However, `1.2.4-alpha.notready` should NOT be allowed,\n    // even though it's within the range set by the comparators.\n    for (let i = 0; i < set.length; i++) {\n      debug(set[i].semver)\n      if (set[i].semver === Comparator.ANY) {\n        continue\n      }\n\n      if (set[i].semver.prerelease.length > 0) {\n        const allowed = set[i].semver\n        if (allowed.major === version.major &&\n            allowed.minor === version.minor &&\n            allowed.patch === version.patch) {\n          return true\n        }\n      }\n    }\n\n    // Version has a -pre, but it's not one of the ones we like.\n    return false\n  }\n\n  return true\n}\n","class LRUCache {\n  constructor () {\n    this.max = 1000\n    this.map = new Map()\n  }\n\n  get (key) {\n    const value = this.map.get(key)\n    if (value === undefined) {\n      return undefined\n    } else {\n      // Remove the key from the map and add it to the end\n      this.map.delete(key)\n      this.map.set(key, value)\n      return value\n    }\n  }\n\n  delete (key) {\n    return this.map.delete(key)\n  }\n\n  set (key, value) {\n    const deleted = this.delete(key)\n\n    if (!deleted && value !== undefined) {\n      // If cache is full, delete the least recently used item\n      if (this.map.size >= this.max) {\n        const firstKey = this.map.keys().next().value\n        this.delete(firstKey)\n      }\n\n      this.map.set(key, value)\n    }\n\n    return this\n  }\n}\n\nmodule.exports = LRUCache\n","const ANY = Symbol('SemVer ANY')\n// hoisted class for cyclic dependency\nclass Comparator {\n  static get ANY () {\n    return ANY\n  }\n\n  constructor (comp, options) {\n    options = parseOptions(options)\n\n    if (comp instanceof Comparator) {\n      if (comp.loose === !!options.loose) {\n        return comp\n      } else {\n        comp = comp.value\n      }\n    }\n\n    comp = comp.trim().split(/\\s+/).join(' ')\n    debug('comparator', comp, options)\n    this.options = options\n    this.loose = !!options.loose\n    this.parse(comp)\n\n    if (this.semver === ANY) {\n      this.value = ''\n    } else {\n      this.value = this.operator + this.semver.version\n    }\n\n    debug('comp', this)\n  }\n\n  parse (comp) {\n    const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR]\n    const m = comp.match(r)\n\n    if (!m) {\n      throw new TypeError(`Invalid comparator: ${comp}`)\n    }\n\n    this.operator = m[1] !== undefined ? m[1] : ''\n    if (this.operator === '=') {\n      this.operator = ''\n    }\n\n    // if it literally is just '>' or '' then allow anything.\n    if (!m[2]) {\n      this.semver = ANY\n    } else {\n      this.semver = new SemVer(m[2], this.options.loose)\n    }\n  }\n\n  toString () {\n    return this.value\n  }\n\n  test (version) {\n    debug('Comparator.test', version, this.options.loose)\n\n    if (this.semver === ANY || version === ANY) {\n      return true\n    }\n\n    if (typeof version === 'string') {\n      try {\n        version = new SemVer(version, this.options)\n      } catch (er) {\n        return false\n      }\n    }\n\n    return cmp(version, this.operator, this.semver, this.options)\n  }\n\n  intersects (comp, options) {\n    if (!(comp instanceof Comparator)) {\n      throw new TypeError('a Comparator is required')\n    }\n\n    if (this.operator === '') {\n      if (this.value === '') {\n        return true\n      }\n      return new Range(comp.value, options).test(this.value)\n    } else if (comp.operator === '') {\n      if (comp.value === '') {\n        return true\n      }\n      return new Range(this.value, options).test(comp.semver)\n    }\n\n    options = parseOptions(options)\n\n    // Special cases where nothing can possibly be lower\n    if (options.includePrerelease &&\n      (this.value === '<0.0.0-0' || comp.value === '<0.0.0-0')) {\n      return false\n    }\n    if (!options.includePrerelease &&\n      (this.value.startsWith('<0.0.0') || comp.value.startsWith('<0.0.0'))) {\n      return false\n    }\n\n    // Same direction increasing (> or >=)\n    if (this.operator.startsWith('>') && comp.operator.startsWith('>')) {\n      return true\n    }\n    // Same direction decreasing (< or <=)\n    if (this.operator.startsWith('<') && comp.operator.startsWith('<')) {\n      return true\n    }\n    // same SemVer and both sides are inclusive (<= or >=)\n    if (\n      (this.semver.version === comp.semver.version) &&\n      this.operator.includes('=') && comp.operator.includes('=')) {\n      return true\n    }\n    // opposite directions less than\n    if (cmp(this.semver, '<', comp.semver, options) &&\n      this.operator.startsWith('>') && comp.operator.startsWith('<')) {\n      return true\n    }\n    // opposite directions greater than\n    if (cmp(this.semver, '>', comp.semver, options) &&\n      this.operator.startsWith('<') && comp.operator.startsWith('>')) {\n      return true\n    }\n    return false\n  }\n}\n\nmodule.exports = Comparator\n\nconst parseOptions = require('../internal/parse-options')\nconst { safeRe: re, t } = require('../internal/re')\nconst cmp = require('../functions/cmp')\nconst debug = require('../internal/debug')\nconst SemVer = require('./semver')\nconst Range = require('./range')\n","const Range = require('../classes/range')\nconst satisfies = (version, range, options) => {\n  try {\n    range = new Range(range, options)\n  } catch (er) {\n    return false\n  }\n  return range.test(version)\n}\nmodule.exports = satisfies\n","const SemVer = require('../classes/semver')\nconst Comparator = require('../classes/comparator')\nconst { ANY } = Comparator\nconst Range = require('../classes/range')\nconst satisfies = require('../functions/satisfies')\nconst gt = require('../functions/gt')\nconst lt = require('../functions/lt')\nconst lte = require('../functions/lte')\nconst gte = require('../functions/gte')\n\nconst outside = (version, range, hilo, options) => {\n  version = new SemVer(version, options)\n  range = new Range(range, options)\n\n  let gtfn, ltefn, ltfn, comp, ecomp\n  switch (hilo) {\n    case '>':\n      gtfn = gt\n      ltefn = lte\n      ltfn = lt\n      comp = '>'\n      ecomp = '>='\n      break\n    case '<':\n      gtfn = lt\n      ltefn = gte\n      ltfn = gt\n      comp = '<'\n      ecomp = '<='\n      break\n    default:\n      throw new TypeError('Must provide a hilo val of \"<\" or \">\"')\n  }\n\n  // If it satisfies the range it is not outside\n  if (satisfies(version, range, options)) {\n    return false\n  }\n\n  // From now on, variable terms are as if we're in \"gtr\" mode.\n  // but note that everything is flipped for the \"ltr\" function.\n\n  for (let i = 0; i < range.set.length; ++i) {\n    const comparators = range.set[i]\n\n    let high = null\n    let low = null\n\n    comparators.forEach((comparator) => {\n      if (comparator.semver === ANY) {\n        comparator = new Comparator('>=0.0.0')\n      }\n      high = high || comparator\n      low = low || comparator\n      if (gtfn(comparator.semver, high.semver, options)) {\n        high = comparator\n      } else if (ltfn(comparator.semver, low.semver, options)) {\n        low = comparator\n      }\n    })\n\n    // If the edge version comparator has a operator then our version\n    // isn't outside it\n    if (high.operator === comp || high.operator === ecomp) {\n      return false\n    }\n\n    // If the lowest version comparator has an operator and our version\n    // is less than it then it isn't higher than the range\n    if ((!low.operator || low.operator === comp) &&\n        ltefn(version, low.semver)) {\n      return false\n    } else if (low.operator === ecomp && ltfn(version, low.semver)) {\n      return false\n    }\n  }\n  return true\n}\n\nmodule.exports = outside\n","// just pre-load all the stuff that index.js lazily exports\nconst internalRe = require('./internal/re')\nconst constants = require('./internal/constants')\nconst SemVer = require('./classes/semver')\nconst identifiers = require('./internal/identifiers')\nconst parse = require('./functions/parse')\nconst valid = require('./functions/valid')\nconst clean = require('./functions/clean')\nconst inc = require('./functions/inc')\nconst diff = require('./functions/diff')\nconst major = require('./functions/major')\nconst minor = require('./functions/minor')\nconst patch = require('./functions/patch')\nconst prerelease = require('./functions/prerelease')\nconst compare = require('./functions/compare')\nconst rcompare = require('./functions/rcompare')\nconst compareLoose = require('./functions/compare-loose')\nconst compareBuild = require('./functions/compare-build')\nconst sort = require('./functions/sort')\nconst rsort = require('./functions/rsort')\nconst gt = require('./functions/gt')\nconst lt = require('./functions/lt')\nconst eq = require('./functions/eq')\nconst neq = require('./functions/neq')\nconst gte = require('./functions/gte')\nconst lte = require('./functions/lte')\nconst cmp = require('./functions/cmp')\nconst coerce = require('./functions/coerce')\nconst Comparator = require('./classes/comparator')\nconst Range = require('./classes/range')\nconst satisfies = require('./functions/satisfies')\nconst toComparators = require('./ranges/to-comparators')\nconst maxSatisfying = require('./ranges/max-satisfying')\nconst minSatisfying = require('./ranges/min-satisfying')\nconst minVersion = require('./ranges/min-version')\nconst validRange = require('./ranges/valid')\nconst outside = require('./ranges/outside')\nconst gtr = require('./ranges/gtr')\nconst ltr = require('./ranges/ltr')\nconst intersects = require('./ranges/intersects')\nconst simplifyRange = require('./ranges/simplify')\nconst subset = require('./ranges/subset')\nmodule.exports = {\n  parse,\n  valid,\n  clean,\n  inc,\n  diff,\n  major,\n  minor,\n  patch,\n  prerelease,\n  compare,\n  rcompare,\n  compareLoose,\n  compareBuild,\n  sort,\n  rsort,\n  gt,\n  lt,\n  eq,\n  neq,\n  gte,\n  lte,\n  cmp,\n  coerce,\n  Comparator,\n  Range,\n  satisfies,\n  toComparators,\n  maxSatisfying,\n  minSatisfying,\n  minVersion,\n  validRange,\n  outside,\n  gtr,\n  ltr,\n  intersects,\n  simplifyRange,\n  subset,\n  SemVer,\n  re: internalRe.re,\n  src: internalRe.src,\n  tokens: internalRe.t,\n  SEMVER_SPEC_VERSION: constants.SEMVER_SPEC_VERSION,\n  RELEASE_TYPES: constants.RELEASE_TYPES,\n  compareIdentifiers: identifiers.compareIdentifiers,\n  rcompareIdentifiers: identifiers.rcompareIdentifiers,\n}\n","const parse = require('./parse')\nconst valid = (version, options) => {\n  const v = parse(version, options)\n  return v ? v.version : null\n}\nmodule.exports = valid\n","const parse = require('./parse')\nconst clean = (version, options) => {\n  const s = parse(version.trim().replace(/^[=v]+/, ''), options)\n  return s ? s.version : null\n}\nmodule.exports = clean\n","const SemVer = require('../classes/semver')\n\nconst inc = (version, release, options, identifier, identifierBase) => {\n  if (typeof (options) === 'string') {\n    identifierBase = identifier\n    identifier = options\n    options = undefined\n  }\n\n  try {\n    return new SemVer(\n      version instanceof SemVer ? version.version : version,\n      options\n    ).inc(release, identifier, identifierBase).version\n  } catch (er) {\n    return null\n  }\n}\nmodule.exports = inc\n","const parse = require('./parse.js')\n\nconst diff = (version1, version2) => {\n  const v1 = parse(version1, null, true)\n  const v2 = parse(version2, null, true)\n  const comparison = v1.compare(v2)\n\n  if (comparison === 0) {\n    return null\n  }\n\n  const v1Higher = comparison > 0\n  const highVersion = v1Higher ? v1 : v2\n  const lowVersion = v1Higher ? v2 : v1\n  const highHasPre = !!highVersion.prerelease.length\n  const lowHasPre = !!lowVersion.prerelease.length\n\n  if (lowHasPre && !highHasPre) {\n    // Going from prerelease -> no prerelease requires some special casing\n\n    // If the low version has only a major, then it will always be a major\n    // Some examples:\n    // 1.0.0-1 -> 1.0.0\n    // 1.0.0-1 -> 1.1.1\n    // 1.0.0-1 -> 2.0.0\n    if (!lowVersion.patch && !lowVersion.minor) {\n      return 'major'\n    }\n\n    // Otherwise it can be determined by checking the high version\n\n    if (highVersion.patch) {\n      // anything higher than a patch bump would result in the wrong version\n      return 'patch'\n    }\n\n    if (highVersion.minor) {\n      // anything higher than a minor bump would result in the wrong version\n      return 'minor'\n    }\n\n    // bumping major/minor/patch all have same result\n    return 'major'\n  }\n\n  // add the `pre` prefix if we are going to a prerelease version\n  const prefix = highHasPre ? 'pre' : ''\n\n  if (v1.major !== v2.major) {\n    return prefix + 'major'\n  }\n\n  if (v1.minor !== v2.minor) {\n    return prefix + 'minor'\n  }\n\n  if (v1.patch !== v2.patch) {\n    return prefix + 'patch'\n  }\n\n  // high and low are preleases\n  return 'prerelease'\n}\n\nmodule.exports = diff\n","const SemVer = require('../classes/semver')\nconst major = (a, loose) => new SemVer(a, loose).major\nmodule.exports = major\n","const SemVer = require('../classes/semver')\nconst minor = (a, loose) => new SemVer(a, loose).minor\nmodule.exports = minor\n","const SemVer = require('../classes/semver')\nconst patch = (a, loose) => new SemVer(a, loose).patch\nmodule.exports = patch\n","const parse = require('./parse')\nconst prerelease = (version, options) => {\n  const parsed = parse(version, options)\n  return (parsed && parsed.prerelease.length) ? parsed.prerelease : null\n}\nmodule.exports = prerelease\n","const compare = require('./compare')\nconst rcompare = (a, b, loose) => compare(b, a, loose)\nmodule.exports = rcompare\n","const compare = require('./compare')\nconst compareLoose = (a, b) => compare(a, b, true)\nmodule.exports = compareLoose\n","const compareBuild = require('./compare-build')\nconst sort = (list, loose) => list.sort((a, b) => compareBuild(a, b, loose))\nmodule.exports = sort\n","const compareBuild = require('./compare-build')\nconst rsort = (list, loose) => list.sort((a, b) => compareBuild(b, a, loose))\nmodule.exports = rsort\n","const SemVer = require('../classes/semver')\nconst parse = require('./parse')\nconst { safeRe: re, t } = require('../internal/re')\n\nconst coerce = (version, options) => {\n  if (version instanceof SemVer) {\n    return version\n  }\n\n  if (typeof version === 'number') {\n    version = String(version)\n  }\n\n  if (typeof version !== 'string') {\n    return null\n  }\n\n  options = options || {}\n\n  let match = null\n  if (!options.rtl) {\n    match = version.match(options.includePrerelease ? re[t.COERCEFULL] : re[t.COERCE])\n  } else {\n    // Find the right-most coercible string that does not share\n    // a terminus with a more left-ward coercible string.\n    // Eg, '1.2.3.4' wants to coerce '2.3.4', not '3.4' or '4'\n    // With includePrerelease option set, '1.2.3.4-rc' wants to coerce '2.3.4-rc', not '2.3.4'\n    //\n    // Walk through the string checking with a /g regexp\n    // Manually set the index so as to pick up overlapping matches.\n    // Stop when we get a match that ends at the string end, since no\n    // coercible string can be more right-ward without the same terminus.\n    const coerceRtlRegex = options.includePrerelease ? re[t.COERCERTLFULL] : re[t.COERCERTL]\n    let next\n    while ((next = coerceRtlRegex.exec(version)) &&\n        (!match || match.index + match[0].length !== version.length)\n    ) {\n      if (!match ||\n            next.index + next[0].length !== match.index + match[0].length) {\n        match = next\n      }\n      coerceRtlRegex.lastIndex = next.index + next[1].length + next[2].length\n    }\n    // leave it in a clean state\n    coerceRtlRegex.lastIndex = -1\n  }\n\n  if (match === null) {\n    return null\n  }\n\n  const major = match[2]\n  const minor = match[3] || '0'\n  const patch = match[4] || '0'\n  const prerelease = options.includePrerelease && match[5] ? `-${match[5]}` : ''\n  const build = options.includePrerelease && match[6] ? `+${match[6]}` : ''\n\n  return parse(`${major}.${minor}.${patch}${prerelease}${build}`, options)\n}\nmodule.exports = coerce\n","const Range = require('../classes/range')\n\n// Mostly just for testing and legacy API reasons\nconst toComparators = (range, options) =>\n  new Range(range, options).set\n    .map(comp => comp.map(c => c.value).join(' ').trim().split(' '))\n\nmodule.exports = toComparators\n","const SemVer = require('../classes/semver')\nconst Range = require('../classes/range')\n\nconst maxSatisfying = (versions, range, options) => {\n  let max = null\n  let maxSV = null\n  let rangeObj = null\n  try {\n    rangeObj = new Range(range, options)\n  } catch (er) {\n    return null\n  }\n  versions.forEach((v) => {\n    if (rangeObj.test(v)) {\n      // satisfies(v, range, options)\n      if (!max || maxSV.compare(v) === -1) {\n        // compare(max, v, true)\n        max = v\n        maxSV = new SemVer(max, options)\n      }\n    }\n  })\n  return max\n}\nmodule.exports = maxSatisfying\n","const SemVer = require('../classes/semver')\nconst Range = require('../classes/range')\nconst minSatisfying = (versions, range, options) => {\n  let min = null\n  let minSV = null\n  let rangeObj = null\n  try {\n    rangeObj = new Range(range, options)\n  } catch (er) {\n    return null\n  }\n  versions.forEach((v) => {\n    if (rangeObj.test(v)) {\n      // satisfies(v, range, options)\n      if (!min || minSV.compare(v) === 1) {\n        // compare(min, v, true)\n        min = v\n        minSV = new SemVer(min, options)\n      }\n    }\n  })\n  return min\n}\nmodule.exports = minSatisfying\n","const SemVer = require('../classes/semver')\nconst Range = require('../classes/range')\nconst gt = require('../functions/gt')\n\nconst minVersion = (range, loose) => {\n  range = new Range(range, loose)\n\n  let minver = new SemVer('0.0.0')\n  if (range.test(minver)) {\n    return minver\n  }\n\n  minver = new SemVer('0.0.0-0')\n  if (range.test(minver)) {\n    return minver\n  }\n\n  minver = null\n  for (let i = 0; i < range.set.length; ++i) {\n    const comparators = range.set[i]\n\n    let setMin = null\n    comparators.forEach((comparator) => {\n      // Clone to avoid manipulating the comparator's semver object.\n      const compver = new SemVer(comparator.semver.version)\n      switch (comparator.operator) {\n        case '>':\n          if (compver.prerelease.length === 0) {\n            compver.patch++\n          } else {\n            compver.prerelease.push(0)\n          }\n          compver.raw = compver.format()\n          /* fallthrough */\n        case '':\n        case '>=':\n          if (!setMin || gt(compver, setMin)) {\n            setMin = compver\n          }\n          break\n        case '<':\n        case '<=':\n          /* Ignore maximum versions */\n          break\n        /* istanbul ignore next */\n        default:\n          throw new Error(`Unexpected operation: ${comparator.operator}`)\n      }\n    })\n    if (setMin && (!minver || gt(minver, setMin))) {\n      minver = setMin\n    }\n  }\n\n  if (minver && range.test(minver)) {\n    return minver\n  }\n\n  return null\n}\nmodule.exports = minVersion\n","const Range = require('../classes/range')\nconst validRange = (range, options) => {\n  try {\n    // Return '*' instead of '' so that truthiness works.\n    // This will throw if it's invalid anyway\n    return new Range(range, options).range || '*'\n  } catch (er) {\n    return null\n  }\n}\nmodule.exports = validRange\n","// Determine if version is greater than all the versions possible in the range.\nconst outside = require('./outside')\nconst gtr = (version, range, options) => outside(version, range, '>', options)\nmodule.exports = gtr\n","const outside = require('./outside')\n// Determine if version is less than all the versions possible in the range\nconst ltr = (version, range, options) => outside(version, range, '<', options)\nmodule.exports = ltr\n","const Range = require('../classes/range')\nconst intersects = (r1, r2, options) => {\n  r1 = new Range(r1, options)\n  r2 = new Range(r2, options)\n  return r1.intersects(r2, options)\n}\nmodule.exports = intersects\n","// given a set of versions and a range, create a \"simplified\" range\n// that includes the same versions that the original range does\n// If the original range is shorter than the simplified one, return that.\nconst satisfies = require('../functions/satisfies.js')\nconst compare = require('../functions/compare.js')\nmodule.exports = (versions, range, options) => {\n  const set = []\n  let first = null\n  let prev = null\n  const v = versions.sort((a, b) => compare(a, b, options))\n  for (const version of v) {\n    const included = satisfies(version, range, options)\n    if (included) {\n      prev = version\n      if (!first) {\n        first = version\n      }\n    } else {\n      if (prev) {\n        set.push([first, prev])\n      }\n      prev = null\n      first = null\n    }\n  }\n  if (first) {\n    set.push([first, null])\n  }\n\n  const ranges = []\n  for (const [min, max] of set) {\n    if (min === max) {\n      ranges.push(min)\n    } else if (!max && min === v[0]) {\n      ranges.push('*')\n    } else if (!max) {\n      ranges.push(`>=${min}`)\n    } else if (min === v[0]) {\n      ranges.push(`<=${max}`)\n    } else {\n      ranges.push(`${min} - ${max}`)\n    }\n  }\n  const simplified = ranges.join(' || ')\n  const original = typeof range.raw === 'string' ? range.raw : String(range)\n  return simplified.length < original.length ? simplified : range\n}\n","const Range = require('../classes/range.js')\nconst Comparator = require('../classes/comparator.js')\nconst { ANY } = Comparator\nconst satisfies = require('../functions/satisfies.js')\nconst compare = require('../functions/compare.js')\n\n// Complex range `r1 || r2 || ...` is a subset of `R1 || R2 || ...` iff:\n// - Every simple range `r1, r2, ...` is a null set, OR\n// - Every simple range `r1, r2, ...` which is not a null set is a subset of\n//   some `R1, R2, ...`\n//\n// Simple range `c1 c2 ...` is a subset of simple range `C1 C2 ...` iff:\n// - If c is only the ANY comparator\n//   - If C is only the ANY comparator, return true\n//   - Else if in prerelease mode, return false\n//   - else replace c with `[>=0.0.0]`\n// - If C is only the ANY comparator\n//   - if in prerelease mode, return true\n//   - else replace C with `[>=0.0.0]`\n// - Let EQ be the set of = comparators in c\n// - If EQ is more than one, return true (null set)\n// - Let GT be the highest > or >= comparator in c\n// - Let LT be the lowest < or <= comparator in c\n// - If GT and LT, and GT.semver > LT.semver, return true (null set)\n// - If any C is a = range, and GT or LT are set, return false\n// - If EQ\n//   - If GT, and EQ does not satisfy GT, return true (null set)\n//   - If LT, and EQ does not satisfy LT, return true (null set)\n//   - If EQ satisfies every C, return true\n//   - Else return false\n// - If GT\n//   - If GT.semver is lower than any > or >= comp in C, return false\n//   - If GT is >=, and GT.semver does not satisfy every C, return false\n//   - If GT.semver has a prerelease, and not in prerelease mode\n//     - If no C has a prerelease and the GT.semver tuple, return false\n// - If LT\n//   - If LT.semver is greater than any < or <= comp in C, return false\n//   - If LT is <=, and LT.semver does not satisfy every C, return false\n//   - If GT.semver has a prerelease, and not in prerelease mode\n//     - If no C has a prerelease and the LT.semver tuple, return false\n// - Else return true\n\nconst subset = (sub, dom, options = {}) => {\n  if (sub === dom) {\n    return true\n  }\n\n  sub = new Range(sub, options)\n  dom = new Range(dom, options)\n  let sawNonNull = false\n\n  OUTER: for (const simpleSub of sub.set) {\n    for (const simpleDom of dom.set) {\n      const isSub = simpleSubset(simpleSub, simpleDom, options)\n      sawNonNull = sawNonNull || isSub !== null\n      if (isSub) {\n        continue OUTER\n      }\n    }\n    // the null set is a subset of everything, but null simple ranges in\n    // a complex range should be ignored.  so if we saw a non-null range,\n    // then we know this isn't a subset, but if EVERY simple range was null,\n    // then it is a subset.\n    if (sawNonNull) {\n      return false\n    }\n  }\n  return true\n}\n\nconst minimumVersionWithPreRelease = [new Comparator('>=0.0.0-0')]\nconst minimumVersion = [new Comparator('>=0.0.0')]\n\nconst simpleSubset = (sub, dom, options) => {\n  if (sub === dom) {\n    return true\n  }\n\n  if (sub.length === 1 && sub[0].semver === ANY) {\n    if (dom.length === 1 && dom[0].semver === ANY) {\n      return true\n    } else if (options.includePrerelease) {\n      sub = minimumVersionWithPreRelease\n    } else {\n      sub = minimumVersion\n    }\n  }\n\n  if (dom.length === 1 && dom[0].semver === ANY) {\n    if (options.includePrerelease) {\n      return true\n    } else {\n      dom = minimumVersion\n    }\n  }\n\n  const eqSet = new Set()\n  let gt, lt\n  for (const c of sub) {\n    if (c.operator === '>' || c.operator === '>=') {\n      gt = higherGT(gt, c, options)\n    } else if (c.operator === '<' || c.operator === '<=') {\n      lt = lowerLT(lt, c, options)\n    } else {\n      eqSet.add(c.semver)\n    }\n  }\n\n  if (eqSet.size > 1) {\n    return null\n  }\n\n  let gtltComp\n  if (gt && lt) {\n    gtltComp = compare(gt.semver, lt.semver, options)\n    if (gtltComp > 0) {\n      return null\n    } else if (gtltComp === 0 && (gt.operator !== '>=' || lt.operator !== '<=')) {\n      return null\n    }\n  }\n\n  // will iterate one or zero times\n  for (const eq of eqSet) {\n    if (gt && !satisfies(eq, String(gt), options)) {\n      return null\n    }\n\n    if (lt && !satisfies(eq, String(lt), options)) {\n      return null\n    }\n\n    for (const c of dom) {\n      if (!satisfies(eq, String(c), options)) {\n        return false\n      }\n    }\n\n    return true\n  }\n\n  let higher, lower\n  let hasDomLT, hasDomGT\n  // if the subset has a prerelease, we need a comparator in the superset\n  // with the same tuple and a prerelease, or it's not a subset\n  let needDomLTPre = lt &&\n    !options.includePrerelease &&\n    lt.semver.prerelease.length ? lt.semver : false\n  let needDomGTPre = gt &&\n    !options.includePrerelease &&\n    gt.semver.prerelease.length ? gt.semver : false\n  // exception: <1.2.3-0 is the same as <1.2.3\n  if (needDomLTPre && needDomLTPre.prerelease.length === 1 &&\n      lt.operator === '<' && needDomLTPre.prerelease[0] === 0) {\n    needDomLTPre = false\n  }\n\n  for (const c of dom) {\n    hasDomGT = hasDomGT || c.operator === '>' || c.operator === '>='\n    hasDomLT = hasDomLT || c.operator === '<' || c.operator === '<='\n    if (gt) {\n      if (needDomGTPre) {\n        if (c.semver.prerelease && c.semver.prerelease.length &&\n            c.semver.major === needDomGTPre.major &&\n            c.semver.minor === needDomGTPre.minor &&\n            c.semver.patch === needDomGTPre.patch) {\n          needDomGTPre = false\n        }\n      }\n      if (c.operator === '>' || c.operator === '>=') {\n        higher = higherGT(gt, c, options)\n        if (higher === c && higher !== gt) {\n          return false\n        }\n      } else if (gt.operator === '>=' && !satisfies(gt.semver, String(c), options)) {\n        return false\n      }\n    }\n    if (lt) {\n      if (needDomLTPre) {\n        if (c.semver.prerelease && c.semver.prerelease.length &&\n            c.semver.major === needDomLTPre.major &&\n            c.semver.minor === needDomLTPre.minor &&\n            c.semver.patch === needDomLTPre.patch) {\n          needDomLTPre = false\n        }\n      }\n      if (c.operator === '<' || c.operator === '<=') {\n        lower = lowerLT(lt, c, options)\n        if (lower === c && lower !== lt) {\n          return false\n        }\n      } else if (lt.operator === '<=' && !satisfies(lt.semver, String(c), options)) {\n        return false\n      }\n    }\n    if (!c.operator && (lt || gt) && gtltComp !== 0) {\n      return false\n    }\n  }\n\n  // if there was a < or >, and nothing in the dom, then must be false\n  // UNLESS it was limited by another range in the other direction.\n  // Eg, >1.0.0 <1.0.1 is still a subset of <2.0.0\n  if (gt && hasDomLT && !lt && gtltComp !== 0) {\n    return false\n  }\n\n  if (lt && hasDomGT && !gt && gtltComp !== 0) {\n    return false\n  }\n\n  // we needed a prerelease range in a specific tuple, but didn't get one\n  // then this isn't a subset.  eg >=1.2.3-pre is not a subset of >=1.0.0,\n  // because it includes prereleases in the 1.2.3 tuple\n  if (needDomGTPre || needDomLTPre) {\n    return false\n  }\n\n  return true\n}\n\n// >=1.2.3 is lower than >1.2.3\nconst higherGT = (a, b, options) => {\n  if (!a) {\n    return b\n  }\n  const comp = compare(a.semver, b.semver, options)\n  return comp > 0 ? a\n    : comp < 0 ? b\n    : b.operator === '>' && a.operator === '>=' ? b\n    : a\n}\n\n// <=1.2.3 is higher than <1.2.3\nconst lowerLT = (a, b, options) => {\n  if (!a) {\n    return b\n  }\n  const comp = compare(a.semver, b.semver, options)\n  return comp < 0 ? a\n    : comp > 0 ? b\n    : b.operator === '<' && a.operator === '<=' ? b\n    : a\n}\n\nmodule.exports = subset\n","/*\nCopyright 2025 New Vector Ltd.\n\nSPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial\nPlease see LICENSE files in the repository root for full details.\n*/\n\nimport { LegacyModuleApiExtension } from \"./legacy-modules\";\nimport { LegacyCustomisationsApiExtension } from \"./legacy-customisations\";\n\n/**\n * Module interface for modules to implement.\n * @public\n */\nexport interface Module {\n    load(): Promise<void>;\n}\n\nconst moduleSignature: Record<keyof Module, Type> = {\n    load: \"function\",\n};\n\n/**\n * Module interface for modules to export as the default export.\n * @public\n */\nexport interface ModuleFactory {\n    readonly moduleApiVersion: string;\n    new (api: Api): Module;\n    readonly prototype: Module;\n}\n\nconst moduleFactorySignature: Record<keyof ModuleFactory, Type> = {\n    moduleApiVersion: \"string\",\n    prototype: \"object\",\n};\n\nexport interface ModuleExport {\n    default: ModuleFactory;\n}\n\nconst moduleExportSignature: Record<keyof ModuleExport, Type> = {\n    default: \"function\",\n};\n\ntype Type = \"function\" | \"string\" | \"number\" | \"boolean\" | \"object\";\n\nfunction isInterface<T>(obj: unknown, type: \"object\" | \"function\", keys: Record<keyof T, Type>): obj is T {\n    if (obj === null || typeof obj !== type) return false;\n    for (const key in keys) {\n        if (typeof (obj as Record<keyof T, unknown>)[key] !== keys[key]) return false;\n    }\n    return true;\n}\n\nexport function isModule(module: unknown): module is ModuleExport {\n    return (\n        isInterface(module, \"object\", moduleExportSignature) &&\n        isInterface(module.default, \"function\", moduleFactorySignature) &&\n        isInterface(module.default.prototype, \"object\", moduleSignature)\n    );\n}\n\n/**\n * The configuration for the application.\n * Should be extended via declaration merging.\n * @public\n */\nexport interface Config {\n    // The branding name of the application\n    brand: string;\n    // Other config options are available but not specified in the types as that would make it difficult to change for element-web\n    // they are accessible at runtime all the same, see list at https://github.com/element-hq/element-web/blob/develop/docs/config.md\n}\n\n/**\n * API for accessing the configuration.\n * @public\n */\nexport interface ConfigApi {\n    get(): Config;\n    get<K extends keyof Config>(key: K): Config[K];\n    get<K extends keyof Config = never>(key?: K): Config | Config[K];\n}\n\n/**\n * The API for modules to interact with the application.\n * @public\n */\nexport interface Api extends LegacyModuleApiExtension, LegacyCustomisationsApiExtension {\n    config: ConfigApi;\n}\n","/*\nCopyright 2025 New Vector Ltd.\n\nSPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial\nPlease see LICENSE files in the repository root for full details.\n*/\n\nimport { satisfies } from \"semver\";\n\nimport { Api, isModule, Module, ModuleExport } from \"./api\";\n\n/**\n * Error thrown when a module is incompatible with the engine version.\n * @public\n */\nexport class ModuleIncompatibleError extends Error {\n    public constructor(pluginVersion: string) {\n        super(`Plugin version ${pluginVersion} is incompatible with engine version ${__VERSION__}`);\n    }\n}\n\n/**\n * A module loader for loading and starting modules.\n * @public\n */\nexport class ModuleLoader {\n    private modules: Module[] = [];\n    private started = false;\n\n    public constructor(private api: Api) {}\n\n    public async load(moduleExport: ModuleExport): Promise<void> {\n        if (this.started) {\n            throw new Error(\"PluginEngine.start() has already been called\");\n        }\n\n        if (!isModule(moduleExport)) {\n            throw new Error(\"Invalid plugin\");\n        }\n        if (!satisfies(__VERSION__, moduleExport.default.moduleApiVersion)) {\n            throw new ModuleIncompatibleError(moduleExport.default.moduleApiVersion);\n        }\n        const { default: Module } = moduleExport;\n        this.modules.push(new Module(this.api));\n    }\n\n    public async start(): Promise<void> {\n        if (this.started) {\n            throw new Error(\"PluginEngine.start() has already been called\");\n        }\n        this.started = true;\n\n        await Promise.all(this.modules.map((plugin) => plugin.load()));\n    }\n}\n","/**\n * Custom positioning reference element.\n * @see https://floating-ui.com/docs/virtual-elements\n */\n\nconst sides = ['top', 'right', 'bottom', 'left'];\nconst alignments = ['start', 'end'];\nconst placements = /*#__PURE__*/sides.reduce((acc, side) => acc.concat(side, side + \"-\" + alignments[0], side + \"-\" + alignments[1]), []);\nconst min = Math.min;\nconst max = Math.max;\nconst round = Math.round;\nconst floor = Math.floor;\nconst createCoords = v => ({\n  x: v,\n  y: v\n});\nconst oppositeSideMap = {\n  left: 'right',\n  right: 'left',\n  bottom: 'top',\n  top: 'bottom'\n};\nconst oppositeAlignmentMap = {\n  start: 'end',\n  end: 'start'\n};\nfunction clamp(start, value, end) {\n  return max(start, min(value, end));\n}\nfunction evaluate(value, param) {\n  return typeof value === 'function' ? value(param) : value;\n}\nfunction getSide(placement) {\n  return placement.split('-')[0];\n}\nfunction getAlignment(placement) {\n  return placement.split('-')[1];\n}\nfunction getOppositeAxis(axis) {\n  return axis === 'x' ? 'y' : 'x';\n}\nfunction getAxisLength(axis) {\n  return axis === 'y' ? 'height' : 'width';\n}\nfunction getSideAxis(placement) {\n  return ['top', 'bottom'].includes(getSide(placement)) ? 'y' : 'x';\n}\nfunction getAlignmentAxis(placement) {\n  return getOppositeAxis(getSideAxis(placement));\n}\nfunction getAlignmentSides(placement, rects, rtl) {\n  if (rtl === void 0) {\n    rtl = false;\n  }\n  const alignment = getAlignment(placement);\n  const alignmentAxis = getAlignmentAxis(placement);\n  const length = getAxisLength(alignmentAxis);\n  let mainAlignmentSide = alignmentAxis === 'x' ? alignment === (rtl ? 'end' : 'start') ? 'right' : 'left' : alignment === 'start' ? 'bottom' : 'top';\n  if (rects.reference[length] > rects.floating[length]) {\n    mainAlignmentSide = getOppositePlacement(mainAlignmentSide);\n  }\n  return [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)];\n}\nfunction getExpandedPlacements(placement) {\n  const oppositePlacement = getOppositePlacement(placement);\n  return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];\n}\nfunction getOppositeAlignmentPlacement(placement) {\n  return placement.replace(/start|end/g, alignment => oppositeAlignmentMap[alignment]);\n}\nfunction getSideList(side, isStart, rtl) {\n  const lr = ['left', 'right'];\n  const rl = ['right', 'left'];\n  const tb = ['top', 'bottom'];\n  const bt = ['bottom', 'top'];\n  switch (side) {\n    case 'top':\n    case 'bottom':\n      if (rtl) return isStart ? rl : lr;\n      return isStart ? lr : rl;\n    case 'left':\n    case 'right':\n      return isStart ? tb : bt;\n    default:\n      return [];\n  }\n}\nfunction getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {\n  const alignment = getAlignment(placement);\n  let list = getSideList(getSide(placement), direction === 'start', rtl);\n  if (alignment) {\n    list = list.map(side => side + \"-\" + alignment);\n    if (flipAlignment) {\n      list = list.concat(list.map(getOppositeAlignmentPlacement));\n    }\n  }\n  return list;\n}\nfunction getOppositePlacement(placement) {\n  return placement.replace(/left|right|bottom|top/g, side => oppositeSideMap[side]);\n}\nfunction expandPaddingObject(padding) {\n  return {\n    top: 0,\n    right: 0,\n    bottom: 0,\n    left: 0,\n    ...padding\n  };\n}\nfunction getPaddingObject(padding) {\n  return typeof padding !== 'number' ? expandPaddingObject(padding) : {\n    top: padding,\n    right: padding,\n    bottom: padding,\n    left: padding\n  };\n}\nfunction rectToClientRect(rect) {\n  const {\n    x,\n    y,\n    width,\n    height\n  } = rect;\n  return {\n    width,\n    height,\n    top: y,\n    left: x,\n    right: x + width,\n    bottom: y + height,\n    x,\n    y\n  };\n}\n\nexport { alignments, clamp, createCoords, evaluate, expandPaddingObject, floor, getAlignment, getAlignmentAxis, getAlignmentSides, getAxisLength, getExpandedPlacements, getOppositeAlignmentPlacement, getOppositeAxis, getOppositeAxisPlacements, getOppositePlacement, getPaddingObject, getSide, getSideAxis, max, min, placements, rectToClientRect, round, sides };\n","import { getSideAxis, getAlignmentAxis, getAxisLength, getSide, getAlignment, evaluate, getPaddingObject, rectToClientRect, min, clamp, placements, getAlignmentSides, getOppositeAlignmentPlacement, getOppositePlacement, getExpandedPlacements, getOppositeAxisPlacements, sides, max, getOppositeAxis } from '@floating-ui/utils';\nexport { rectToClientRect } from '@floating-ui/utils';\n\nfunction computeCoordsFromPlacement(_ref, placement, rtl) {\n  let {\n    reference,\n    floating\n  } = _ref;\n  const sideAxis = getSideAxis(placement);\n  const alignmentAxis = getAlignmentAxis(placement);\n  const alignLength = getAxisLength(alignmentAxis);\n  const side = getSide(placement);\n  const isVertical = sideAxis === 'y';\n  const commonX = reference.x + reference.width / 2 - floating.width / 2;\n  const commonY = reference.y + reference.height / 2 - floating.height / 2;\n  const commonAlign = reference[alignLength] / 2 - floating[alignLength] / 2;\n  let coords;\n  switch (side) {\n    case 'top':\n      coords = {\n        x: commonX,\n        y: reference.y - floating.height\n      };\n      break;\n    case 'bottom':\n      coords = {\n        x: commonX,\n        y: reference.y + reference.height\n      };\n      break;\n    case 'right':\n      coords = {\n        x: reference.x + reference.width,\n        y: commonY\n      };\n      break;\n    case 'left':\n      coords = {\n        x: reference.x - floating.width,\n        y: commonY\n      };\n      break;\n    default:\n      coords = {\n        x: reference.x,\n        y: reference.y\n      };\n  }\n  switch (getAlignment(placement)) {\n    case 'start':\n      coords[alignmentAxis] -= commonAlign * (rtl && isVertical ? -1 : 1);\n      break;\n    case 'end':\n      coords[alignmentAxis] += commonAlign * (rtl && isVertical ? -1 : 1);\n      break;\n  }\n  return coords;\n}\n\n/**\n * Computes the `x` and `y` coordinates that will place the floating element\n * next to a given reference element.\n *\n * This export does not have any `platform` interface logic. You will need to\n * write one for the platform you are using Floating UI with.\n */\nconst computePosition = async (reference, floating, config) => {\n  const {\n    placement = 'bottom',\n    strategy = 'absolute',\n    middleware = [],\n    platform\n  } = config;\n  const validMiddleware = middleware.filter(Boolean);\n  const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(floating));\n  let rects = await platform.getElementRects({\n    reference,\n    floating,\n    strategy\n  });\n  let {\n    x,\n    y\n  } = computeCoordsFromPlacement(rects, placement, rtl);\n  let statefulPlacement = placement;\n  let middlewareData = {};\n  let resetCount = 0;\n  for (let i = 0; i < validMiddleware.length; i++) {\n    const {\n      name,\n      fn\n    } = validMiddleware[i];\n    const {\n      x: nextX,\n      y: nextY,\n      data,\n      reset\n    } = await fn({\n      x,\n      y,\n      initialPlacement: placement,\n      placement: statefulPlacement,\n      strategy,\n      middlewareData,\n      rects,\n      platform,\n      elements: {\n        reference,\n        floating\n      }\n    });\n    x = nextX != null ? nextX : x;\n    y = nextY != null ? nextY : y;\n    middlewareData = {\n      ...middlewareData,\n      [name]: {\n        ...middlewareData[name],\n        ...data\n      }\n    };\n    if (reset && resetCount <= 50) {\n      resetCount++;\n      if (typeof reset === 'object') {\n        if (reset.placement) {\n          statefulPlacement = reset.placement;\n        }\n        if (reset.rects) {\n          rects = reset.rects === true ? await platform.getElementRects({\n            reference,\n            floating,\n            strategy\n          }) : reset.rects;\n        }\n        ({\n          x,\n          y\n        } = computeCoordsFromPlacement(rects, statefulPlacement, rtl));\n      }\n      i = -1;\n    }\n  }\n  return {\n    x,\n    y,\n    placement: statefulPlacement,\n    strategy,\n    middlewareData\n  };\n};\n\n/**\n * Resolves with an object of overflow side offsets that determine how much the\n * element is overflowing a given clipping boundary on each side.\n * - positive = overflowing the boundary by that number of pixels\n * - negative = how many pixels left before it will overflow\n * - 0 = lies flush with the boundary\n * @see https://floating-ui.com/docs/detectOverflow\n */\nasync function detectOverflow(state, options) {\n  var _await$platform$isEle;\n  if (options === void 0) {\n    options = {};\n  }\n  const {\n    x,\n    y,\n    platform,\n    rects,\n    elements,\n    strategy\n  } = state;\n  const {\n    boundary = 'clippingAncestors',\n    rootBoundary = 'viewport',\n    elementContext = 'floating',\n    altBoundary = false,\n    padding = 0\n  } = evaluate(options, state);\n  const paddingObject = getPaddingObject(padding);\n  const altContext = elementContext === 'floating' ? 'reference' : 'floating';\n  const element = elements[altBoundary ? altContext : elementContext];\n  const clippingClientRect = rectToClientRect(await platform.getClippingRect({\n    element: ((_await$platform$isEle = await (platform.isElement == null ? void 0 : platform.isElement(element))) != null ? _await$platform$isEle : true) ? element : element.contextElement || (await (platform.getDocumentElement == null ? void 0 : platform.getDocumentElement(elements.floating))),\n    boundary,\n    rootBoundary,\n    strategy\n  }));\n  const rect = elementContext === 'floating' ? {\n    x,\n    y,\n    width: rects.floating.width,\n    height: rects.floating.height\n  } : rects.reference;\n  const offsetParent = await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(elements.floating));\n  const offsetScale = (await (platform.isElement == null ? void 0 : platform.isElement(offsetParent))) ? (await (platform.getScale == null ? void 0 : platform.getScale(offsetParent))) || {\n    x: 1,\n    y: 1\n  } : {\n    x: 1,\n    y: 1\n  };\n  const elementClientRect = rectToClientRect(platform.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform.convertOffsetParentRelativeRectToViewportRelativeRect({\n    elements,\n    rect,\n    offsetParent,\n    strategy\n  }) : rect);\n  return {\n    top: (clippingClientRect.top - elementClientRect.top + paddingObject.top) / offsetScale.y,\n    bottom: (elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom) / offsetScale.y,\n    left: (clippingClientRect.left - elementClientRect.left + paddingObject.left) / offsetScale.x,\n    right: (elementClientRect.right - clippingClientRect.right + paddingObject.right) / offsetScale.x\n  };\n}\n\n/**\n * Provides data to position an inner element of the floating element so that it\n * appears centered to the reference element.\n * @see https://floating-ui.com/docs/arrow\n */\nconst arrow = options => ({\n  name: 'arrow',\n  options,\n  async fn(state) {\n    const {\n      x,\n      y,\n      placement,\n      rects,\n      platform,\n      elements,\n      middlewareData\n    } = state;\n    // Since `element` is required, we don't Partial<> the type.\n    const {\n      element,\n      padding = 0\n    } = evaluate(options, state) || {};\n    if (element == null) {\n      return {};\n    }\n    const paddingObject = getPaddingObject(padding);\n    const coords = {\n      x,\n      y\n    };\n    const axis = getAlignmentAxis(placement);\n    const length = getAxisLength(axis);\n    const arrowDimensions = await platform.getDimensions(element);\n    const isYAxis = axis === 'y';\n    const minProp = isYAxis ? 'top' : 'left';\n    const maxProp = isYAxis ? 'bottom' : 'right';\n    const clientProp = isYAxis ? 'clientHeight' : 'clientWidth';\n    const endDiff = rects.reference[length] + rects.reference[axis] - coords[axis] - rects.floating[length];\n    const startDiff = coords[axis] - rects.reference[axis];\n    const arrowOffsetParent = await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(element));\n    let clientSize = arrowOffsetParent ? arrowOffsetParent[clientProp] : 0;\n\n    // DOM platform can return `window` as the `offsetParent`.\n    if (!clientSize || !(await (platform.isElement == null ? void 0 : platform.isElement(arrowOffsetParent)))) {\n      clientSize = elements.floating[clientProp] || rects.floating[length];\n    }\n    const centerToReference = endDiff / 2 - startDiff / 2;\n\n    // If the padding is large enough that it causes the arrow to no longer be\n    // centered, modify the padding so that it is centered.\n    const largestPossiblePadding = clientSize / 2 - arrowDimensions[length] / 2 - 1;\n    const minPadding = min(paddingObject[minProp], largestPossiblePadding);\n    const maxPadding = min(paddingObject[maxProp], largestPossiblePadding);\n\n    // Make sure the arrow doesn't overflow the floating element if the center\n    // point is outside the floating element's bounds.\n    const min$1 = minPadding;\n    const max = clientSize - arrowDimensions[length] - maxPadding;\n    const center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference;\n    const offset = clamp(min$1, center, max);\n\n    // If the reference is small enough that the arrow's padding causes it to\n    // to point to nothing for an aligned placement, adjust the offset of the\n    // floating element itself. To ensure `shift()` continues to take action,\n    // a single reset is performed when this is true.\n    const shouldAddOffset = !middlewareData.arrow && getAlignment(placement) != null && center !== offset && rects.reference[length] / 2 - (center < min$1 ? minPadding : maxPadding) - arrowDimensions[length] / 2 < 0;\n    const alignmentOffset = shouldAddOffset ? center < min$1 ? center - min$1 : center - max : 0;\n    return {\n      [axis]: coords[axis] + alignmentOffset,\n      data: {\n        [axis]: offset,\n        centerOffset: center - offset - alignmentOffset,\n        ...(shouldAddOffset && {\n          alignmentOffset\n        })\n      },\n      reset: shouldAddOffset\n    };\n  }\n});\n\nfunction getPlacementList(alignment, autoAlignment, allowedPlacements) {\n  const allowedPlacementsSortedByAlignment = alignment ? [...allowedPlacements.filter(placement => getAlignment(placement) === alignment), ...allowedPlacements.filter(placement => getAlignment(placement) !== alignment)] : allowedPlacements.filter(placement => getSide(placement) === placement);\n  return allowedPlacementsSortedByAlignment.filter(placement => {\n    if (alignment) {\n      return getAlignment(placement) === alignment || (autoAlignment ? getOppositeAlignmentPlacement(placement) !== placement : false);\n    }\n    return true;\n  });\n}\n/**\n * Optimizes the visibility of the floating element by choosing the placement\n * that has the most space available automatically, without needing to specify a\n * preferred placement. Alternative to `flip`.\n * @see https://floating-ui.com/docs/autoPlacement\n */\nconst autoPlacement = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'autoPlacement',\n    options,\n    async fn(state) {\n      var _middlewareData$autoP, _middlewareData$autoP2, _placementsThatFitOnE;\n      const {\n        rects,\n        middlewareData,\n        placement,\n        platform,\n        elements\n      } = state;\n      const {\n        crossAxis = false,\n        alignment,\n        allowedPlacements = placements,\n        autoAlignment = true,\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n      const placements$1 = alignment !== undefined || allowedPlacements === placements ? getPlacementList(alignment || null, autoAlignment, allowedPlacements) : allowedPlacements;\n      const overflow = await detectOverflow(state, detectOverflowOptions);\n      const currentIndex = ((_middlewareData$autoP = middlewareData.autoPlacement) == null ? void 0 : _middlewareData$autoP.index) || 0;\n      const currentPlacement = placements$1[currentIndex];\n      if (currentPlacement == null) {\n        return {};\n      }\n      const alignmentSides = getAlignmentSides(currentPlacement, rects, await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating)));\n\n      // Make `computeCoords` start from the right place.\n      if (placement !== currentPlacement) {\n        return {\n          reset: {\n            placement: placements$1[0]\n          }\n        };\n      }\n      const currentOverflows = [overflow[getSide(currentPlacement)], overflow[alignmentSides[0]], overflow[alignmentSides[1]]];\n      const allOverflows = [...(((_middlewareData$autoP2 = middlewareData.autoPlacement) == null ? void 0 : _middlewareData$autoP2.overflows) || []), {\n        placement: currentPlacement,\n        overflows: currentOverflows\n      }];\n      const nextPlacement = placements$1[currentIndex + 1];\n\n      // There are more placements to check.\n      if (nextPlacement) {\n        return {\n          data: {\n            index: currentIndex + 1,\n            overflows: allOverflows\n          },\n          reset: {\n            placement: nextPlacement\n          }\n        };\n      }\n      const placementsSortedByMostSpace = allOverflows.map(d => {\n        const alignment = getAlignment(d.placement);\n        return [d.placement, alignment && crossAxis ?\n        // Check along the mainAxis and main crossAxis side.\n        d.overflows.slice(0, 2).reduce((acc, v) => acc + v, 0) :\n        // Check only the mainAxis.\n        d.overflows[0], d.overflows];\n      }).sort((a, b) => a[1] - b[1]);\n      const placementsThatFitOnEachSide = placementsSortedByMostSpace.filter(d => d[2].slice(0,\n      // Aligned placements should not check their opposite crossAxis\n      // side.\n      getAlignment(d[0]) ? 2 : 3).every(v => v <= 0));\n      const resetPlacement = ((_placementsThatFitOnE = placementsThatFitOnEachSide[0]) == null ? void 0 : _placementsThatFitOnE[0]) || placementsSortedByMostSpace[0][0];\n      if (resetPlacement !== placement) {\n        return {\n          data: {\n            index: currentIndex + 1,\n            overflows: allOverflows\n          },\n          reset: {\n            placement: resetPlacement\n          }\n        };\n      }\n      return {};\n    }\n  };\n};\n\n/**\n * Optimizes the visibility of the floating element by flipping the `placement`\n * in order to keep it in view when the preferred placement(s) will overflow the\n * clipping boundary. Alternative to `autoPlacement`.\n * @see https://floating-ui.com/docs/flip\n */\nconst flip = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'flip',\n    options,\n    async fn(state) {\n      var _middlewareData$arrow, _middlewareData$flip;\n      const {\n        placement,\n        middlewareData,\n        rects,\n        initialPlacement,\n        platform,\n        elements\n      } = state;\n      const {\n        mainAxis: checkMainAxis = true,\n        crossAxis: checkCrossAxis = true,\n        fallbackPlacements: specifiedFallbackPlacements,\n        fallbackStrategy = 'bestFit',\n        fallbackAxisSideDirection = 'none',\n        flipAlignment = true,\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n\n      // If a reset by the arrow was caused due to an alignment offset being\n      // added, we should skip any logic now since `flip()` has already done its\n      // work.\n      // https://github.com/floating-ui/floating-ui/issues/2549#issuecomment-1719601643\n      if ((_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {\n        return {};\n      }\n      const side = getSide(placement);\n      const initialSideAxis = getSideAxis(initialPlacement);\n      const isBasePlacement = getSide(initialPlacement) === initialPlacement;\n      const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));\n      const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement(initialPlacement)] : getExpandedPlacements(initialPlacement));\n      const hasFallbackAxisSideDirection = fallbackAxisSideDirection !== 'none';\n      if (!specifiedFallbackPlacements && hasFallbackAxisSideDirection) {\n        fallbackPlacements.push(...getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));\n      }\n      const placements = [initialPlacement, ...fallbackPlacements];\n      const overflow = await detectOverflow(state, detectOverflowOptions);\n      const overflows = [];\n      let overflowsData = ((_middlewareData$flip = middlewareData.flip) == null ? void 0 : _middlewareData$flip.overflows) || [];\n      if (checkMainAxis) {\n        overflows.push(overflow[side]);\n      }\n      if (checkCrossAxis) {\n        const sides = getAlignmentSides(placement, rects, rtl);\n        overflows.push(overflow[sides[0]], overflow[sides[1]]);\n      }\n      overflowsData = [...overflowsData, {\n        placement,\n        overflows\n      }];\n\n      // One or more sides is overflowing.\n      if (!overflows.every(side => side <= 0)) {\n        var _middlewareData$flip2, _overflowsData$filter;\n        const nextIndex = (((_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) || 0) + 1;\n        const nextPlacement = placements[nextIndex];\n        if (nextPlacement) {\n          // Try next placement and re-run the lifecycle.\n          return {\n            data: {\n              index: nextIndex,\n              overflows: overflowsData\n            },\n            reset: {\n              placement: nextPlacement\n            }\n          };\n        }\n\n        // First, find the candidates that fit on the mainAxis side of overflow,\n        // then find the placement that fits the best on the main crossAxis side.\n        let resetPlacement = (_overflowsData$filter = overflowsData.filter(d => d.overflows[0] <= 0).sort((a, b) => a.overflows[1] - b.overflows[1])[0]) == null ? void 0 : _overflowsData$filter.placement;\n\n        // Otherwise fallback.\n        if (!resetPlacement) {\n          switch (fallbackStrategy) {\n            case 'bestFit':\n              {\n                var _overflowsData$filter2;\n                const placement = (_overflowsData$filter2 = overflowsData.filter(d => {\n                  if (hasFallbackAxisSideDirection) {\n                    const currentSideAxis = getSideAxis(d.placement);\n                    return currentSideAxis === initialSideAxis ||\n                    // Create a bias to the `y` side axis due to horizontal\n                    // reading directions favoring greater width.\n                    currentSideAxis === 'y';\n                  }\n                  return true;\n                }).map(d => [d.placement, d.overflows.filter(overflow => overflow > 0).reduce((acc, overflow) => acc + overflow, 0)]).sort((a, b) => a[1] - b[1])[0]) == null ? void 0 : _overflowsData$filter2[0];\n                if (placement) {\n                  resetPlacement = placement;\n                }\n                break;\n              }\n            case 'initialPlacement':\n              resetPlacement = initialPlacement;\n              break;\n          }\n        }\n        if (placement !== resetPlacement) {\n          return {\n            reset: {\n              placement: resetPlacement\n            }\n          };\n        }\n      }\n      return {};\n    }\n  };\n};\n\nfunction getSideOffsets(overflow, rect) {\n  return {\n    top: overflow.top - rect.height,\n    right: overflow.right - rect.width,\n    bottom: overflow.bottom - rect.height,\n    left: overflow.left - rect.width\n  };\n}\nfunction isAnySideFullyClipped(overflow) {\n  return sides.some(side => overflow[side] >= 0);\n}\n/**\n * Provides data to hide the floating element in applicable situations, such as\n * when it is not in the same clipping context as the reference element.\n * @see https://floating-ui.com/docs/hide\n */\nconst hide = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'hide',\n    options,\n    async fn(state) {\n      const {\n        rects\n      } = state;\n      const {\n        strategy = 'referenceHidden',\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n      switch (strategy) {\n        case 'referenceHidden':\n          {\n            const overflow = await detectOverflow(state, {\n              ...detectOverflowOptions,\n              elementContext: 'reference'\n            });\n            const offsets = getSideOffsets(overflow, rects.reference);\n            return {\n              data: {\n                referenceHiddenOffsets: offsets,\n                referenceHidden: isAnySideFullyClipped(offsets)\n              }\n            };\n          }\n        case 'escaped':\n          {\n            const overflow = await detectOverflow(state, {\n              ...detectOverflowOptions,\n              altBoundary: true\n            });\n            const offsets = getSideOffsets(overflow, rects.floating);\n            return {\n              data: {\n                escapedOffsets: offsets,\n                escaped: isAnySideFullyClipped(offsets)\n              }\n            };\n          }\n        default:\n          {\n            return {};\n          }\n      }\n    }\n  };\n};\n\nfunction getBoundingRect(rects) {\n  const minX = min(...rects.map(rect => rect.left));\n  const minY = min(...rects.map(rect => rect.top));\n  const maxX = max(...rects.map(rect => rect.right));\n  const maxY = max(...rects.map(rect => rect.bottom));\n  return {\n    x: minX,\n    y: minY,\n    width: maxX - minX,\n    height: maxY - minY\n  };\n}\nfunction getRectsByLine(rects) {\n  const sortedRects = rects.slice().sort((a, b) => a.y - b.y);\n  const groups = [];\n  let prevRect = null;\n  for (let i = 0; i < sortedRects.length; i++) {\n    const rect = sortedRects[i];\n    if (!prevRect || rect.y - prevRect.y > prevRect.height / 2) {\n      groups.push([rect]);\n    } else {\n      groups[groups.length - 1].push(rect);\n    }\n    prevRect = rect;\n  }\n  return groups.map(rect => rectToClientRect(getBoundingRect(rect)));\n}\n/**\n * Provides improved positioning for inline reference elements that can span\n * over multiple lines, such as hyperlinks or range selections.\n * @see https://floating-ui.com/docs/inline\n */\nconst inline = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'inline',\n    options,\n    async fn(state) {\n      const {\n        placement,\n        elements,\n        rects,\n        platform,\n        strategy\n      } = state;\n      // A MouseEvent's client{X,Y} coords can be up to 2 pixels off a\n      // ClientRect's bounds, despite the event listener being triggered. A\n      // padding of 2 seems to handle this issue.\n      const {\n        padding = 2,\n        x,\n        y\n      } = evaluate(options, state);\n      const nativeClientRects = Array.from((await (platform.getClientRects == null ? void 0 : platform.getClientRects(elements.reference))) || []);\n      const clientRects = getRectsByLine(nativeClientRects);\n      const fallback = rectToClientRect(getBoundingRect(nativeClientRects));\n      const paddingObject = getPaddingObject(padding);\n      function getBoundingClientRect() {\n        // There are two rects and they are disjoined.\n        if (clientRects.length === 2 && clientRects[0].left > clientRects[1].right && x != null && y != null) {\n          // Find the first rect in which the point is fully inside.\n          return clientRects.find(rect => x > rect.left - paddingObject.left && x < rect.right + paddingObject.right && y > rect.top - paddingObject.top && y < rect.bottom + paddingObject.bottom) || fallback;\n        }\n\n        // There are 2 or more connected rects.\n        if (clientRects.length >= 2) {\n          if (getSideAxis(placement) === 'y') {\n            const firstRect = clientRects[0];\n            const lastRect = clientRects[clientRects.length - 1];\n            const isTop = getSide(placement) === 'top';\n            const top = firstRect.top;\n            const bottom = lastRect.bottom;\n            const left = isTop ? firstRect.left : lastRect.left;\n            const right = isTop ? firstRect.right : lastRect.right;\n            const width = right - left;\n            const height = bottom - top;\n            return {\n              top,\n              bottom,\n              left,\n              right,\n              width,\n              height,\n              x: left,\n              y: top\n            };\n          }\n          const isLeftSide = getSide(placement) === 'left';\n          const maxRight = max(...clientRects.map(rect => rect.right));\n          const minLeft = min(...clientRects.map(rect => rect.left));\n          const measureRects = clientRects.filter(rect => isLeftSide ? rect.left === minLeft : rect.right === maxRight);\n          const top = measureRects[0].top;\n          const bottom = measureRects[measureRects.length - 1].bottom;\n          const left = minLeft;\n          const right = maxRight;\n          const width = right - left;\n          const height = bottom - top;\n          return {\n            top,\n            bottom,\n            left,\n            right,\n            width,\n            height,\n            x: left,\n            y: top\n          };\n        }\n        return fallback;\n      }\n      const resetRects = await platform.getElementRects({\n        reference: {\n          getBoundingClientRect\n        },\n        floating: elements.floating,\n        strategy\n      });\n      if (rects.reference.x !== resetRects.reference.x || rects.reference.y !== resetRects.reference.y || rects.reference.width !== resetRects.reference.width || rects.reference.height !== resetRects.reference.height) {\n        return {\n          reset: {\n            rects: resetRects\n          }\n        };\n      }\n      return {};\n    }\n  };\n};\n\n// For type backwards-compatibility, the `OffsetOptions` type was also\n// Derivable.\n\nasync function convertValueToCoords(state, options) {\n  const {\n    placement,\n    platform,\n    elements\n  } = state;\n  const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));\n  const side = getSide(placement);\n  const alignment = getAlignment(placement);\n  const isVertical = getSideAxis(placement) === 'y';\n  const mainAxisMulti = ['left', 'top'].includes(side) ? -1 : 1;\n  const crossAxisMulti = rtl && isVertical ? -1 : 1;\n  const rawValue = evaluate(options, state);\n\n  // eslint-disable-next-line prefer-const\n  let {\n    mainAxis,\n    crossAxis,\n    alignmentAxis\n  } = typeof rawValue === 'number' ? {\n    mainAxis: rawValue,\n    crossAxis: 0,\n    alignmentAxis: null\n  } : {\n    mainAxis: rawValue.mainAxis || 0,\n    crossAxis: rawValue.crossAxis || 0,\n    alignmentAxis: rawValue.alignmentAxis\n  };\n  if (alignment && typeof alignmentAxis === 'number') {\n    crossAxis = alignment === 'end' ? alignmentAxis * -1 : alignmentAxis;\n  }\n  return isVertical ? {\n    x: crossAxis * crossAxisMulti,\n    y: mainAxis * mainAxisMulti\n  } : {\n    x: mainAxis * mainAxisMulti,\n    y: crossAxis * crossAxisMulti\n  };\n}\n\n/**\n * Modifies the placement by translating the floating element along the\n * specified axes.\n * A number (shorthand for `mainAxis` or distance), or an axes configuration\n * object may be passed.\n * @see https://floating-ui.com/docs/offset\n */\nconst offset = function (options) {\n  if (options === void 0) {\n    options = 0;\n  }\n  return {\n    name: 'offset',\n    options,\n    async fn(state) {\n      var _middlewareData$offse, _middlewareData$arrow;\n      const {\n        x,\n        y,\n        placement,\n        middlewareData\n      } = state;\n      const diffCoords = await convertValueToCoords(state, options);\n\n      // If the placement is the same and the arrow caused an alignment offset\n      // then we don't need to change the positioning coordinates.\n      if (placement === ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse.placement) && (_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {\n        return {};\n      }\n      return {\n        x: x + diffCoords.x,\n        y: y + diffCoords.y,\n        data: {\n          ...diffCoords,\n          placement\n        }\n      };\n    }\n  };\n};\n\n/**\n * Optimizes the visibility of the floating element by shifting it in order to\n * keep it in view when it will overflow the clipping boundary.\n * @see https://floating-ui.com/docs/shift\n */\nconst shift = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'shift',\n    options,\n    async fn(state) {\n      const {\n        x,\n        y,\n        placement\n      } = state;\n      const {\n        mainAxis: checkMainAxis = true,\n        crossAxis: checkCrossAxis = false,\n        limiter = {\n          fn: _ref => {\n            let {\n              x,\n              y\n            } = _ref;\n            return {\n              x,\n              y\n            };\n          }\n        },\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n      const coords = {\n        x,\n        y\n      };\n      const overflow = await detectOverflow(state, detectOverflowOptions);\n      const crossAxis = getSideAxis(getSide(placement));\n      const mainAxis = getOppositeAxis(crossAxis);\n      let mainAxisCoord = coords[mainAxis];\n      let crossAxisCoord = coords[crossAxis];\n      if (checkMainAxis) {\n        const minSide = mainAxis === 'y' ? 'top' : 'left';\n        const maxSide = mainAxis === 'y' ? 'bottom' : 'right';\n        const min = mainAxisCoord + overflow[minSide];\n        const max = mainAxisCoord - overflow[maxSide];\n        mainAxisCoord = clamp(min, mainAxisCoord, max);\n      }\n      if (checkCrossAxis) {\n        const minSide = crossAxis === 'y' ? 'top' : 'left';\n        const maxSide = crossAxis === 'y' ? 'bottom' : 'right';\n        const min = crossAxisCoord + overflow[minSide];\n        const max = crossAxisCoord - overflow[maxSide];\n        crossAxisCoord = clamp(min, crossAxisCoord, max);\n      }\n      const limitedCoords = limiter.fn({\n        ...state,\n        [mainAxis]: mainAxisCoord,\n        [crossAxis]: crossAxisCoord\n      });\n      return {\n        ...limitedCoords,\n        data: {\n          x: limitedCoords.x - x,\n          y: limitedCoords.y - y,\n          enabled: {\n            [mainAxis]: checkMainAxis,\n            [crossAxis]: checkCrossAxis\n          }\n        }\n      };\n    }\n  };\n};\n/**\n * Built-in `limiter` that will stop `shift()` at a certain point.\n */\nconst limitShift = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    options,\n    fn(state) {\n      const {\n        x,\n        y,\n        placement,\n        rects,\n        middlewareData\n      } = state;\n      const {\n        offset = 0,\n        mainAxis: checkMainAxis = true,\n        crossAxis: checkCrossAxis = true\n      } = evaluate(options, state);\n      const coords = {\n        x,\n        y\n      };\n      const crossAxis = getSideAxis(placement);\n      const mainAxis = getOppositeAxis(crossAxis);\n      let mainAxisCoord = coords[mainAxis];\n      let crossAxisCoord = coords[crossAxis];\n      const rawOffset = evaluate(offset, state);\n      const computedOffset = typeof rawOffset === 'number' ? {\n        mainAxis: rawOffset,\n        crossAxis: 0\n      } : {\n        mainAxis: 0,\n        crossAxis: 0,\n        ...rawOffset\n      };\n      if (checkMainAxis) {\n        const len = mainAxis === 'y' ? 'height' : 'width';\n        const limitMin = rects.reference[mainAxis] - rects.floating[len] + computedOffset.mainAxis;\n        const limitMax = rects.reference[mainAxis] + rects.reference[len] - computedOffset.mainAxis;\n        if (mainAxisCoord < limitMin) {\n          mainAxisCoord = limitMin;\n        } else if (mainAxisCoord > limitMax) {\n          mainAxisCoord = limitMax;\n        }\n      }\n      if (checkCrossAxis) {\n        var _middlewareData$offse, _middlewareData$offse2;\n        const len = mainAxis === 'y' ? 'width' : 'height';\n        const isOriginSide = ['top', 'left'].includes(getSide(placement));\n        const limitMin = rects.reference[crossAxis] - rects.floating[len] + (isOriginSide ? ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse[crossAxis]) || 0 : 0) + (isOriginSide ? 0 : computedOffset.crossAxis);\n        const limitMax = rects.reference[crossAxis] + rects.reference[len] + (isOriginSide ? 0 : ((_middlewareData$offse2 = middlewareData.offset) == null ? void 0 : _middlewareData$offse2[crossAxis]) || 0) - (isOriginSide ? computedOffset.crossAxis : 0);\n        if (crossAxisCoord < limitMin) {\n          crossAxisCoord = limitMin;\n        } else if (crossAxisCoord > limitMax) {\n          crossAxisCoord = limitMax;\n        }\n      }\n      return {\n        [mainAxis]: mainAxisCoord,\n        [crossAxis]: crossAxisCoord\n      };\n    }\n  };\n};\n\n/**\n * Provides data that allows you to change the size of the floating element —\n * for instance, prevent it from overflowing the clipping boundary or match the\n * width of the reference element.\n * @see https://floating-ui.com/docs/size\n */\nconst size = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'size',\n    options,\n    async fn(state) {\n      var _state$middlewareData, _state$middlewareData2;\n      const {\n        placement,\n        rects,\n        platform,\n        elements\n      } = state;\n      const {\n        apply = () => {},\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n      const overflow = await detectOverflow(state, detectOverflowOptions);\n      const side = getSide(placement);\n      const alignment = getAlignment(placement);\n      const isYAxis = getSideAxis(placement) === 'y';\n      const {\n        width,\n        height\n      } = rects.floating;\n      let heightSide;\n      let widthSide;\n      if (side === 'top' || side === 'bottom') {\n        heightSide = side;\n        widthSide = alignment === ((await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating))) ? 'start' : 'end') ? 'left' : 'right';\n      } else {\n        widthSide = side;\n        heightSide = alignment === 'end' ? 'top' : 'bottom';\n      }\n      const maximumClippingHeight = height - overflow.top - overflow.bottom;\n      const maximumClippingWidth = width - overflow.left - overflow.right;\n      const overflowAvailableHeight = min(height - overflow[heightSide], maximumClippingHeight);\n      const overflowAvailableWidth = min(width - overflow[widthSide], maximumClippingWidth);\n      const noShift = !state.middlewareData.shift;\n      let availableHeight = overflowAvailableHeight;\n      let availableWidth = overflowAvailableWidth;\n      if ((_state$middlewareData = state.middlewareData.shift) != null && _state$middlewareData.enabled.x) {\n        availableWidth = maximumClippingWidth;\n      }\n      if ((_state$middlewareData2 = state.middlewareData.shift) != null && _state$middlewareData2.enabled.y) {\n        availableHeight = maximumClippingHeight;\n      }\n      if (noShift && !alignment) {\n        const xMin = max(overflow.left, 0);\n        const xMax = max(overflow.right, 0);\n        const yMin = max(overflow.top, 0);\n        const yMax = max(overflow.bottom, 0);\n        if (isYAxis) {\n          availableWidth = width - 2 * (xMin !== 0 || xMax !== 0 ? xMin + xMax : max(overflow.left, overflow.right));\n        } else {\n          availableHeight = height - 2 * (yMin !== 0 || yMax !== 0 ? yMin + yMax : max(overflow.top, overflow.bottom));\n        }\n      }\n      await apply({\n        ...state,\n        availableWidth,\n        availableHeight\n      });\n      const nextDimensions = await platform.getDimensions(elements.floating);\n      if (width !== nextDimensions.width || height !== nextDimensions.height) {\n        return {\n          reset: {\n            rects: true\n          }\n        };\n      }\n      return {};\n    }\n  };\n};\n\nexport { arrow, autoPlacement, computePosition, detectOverflow, flip, hide, inline, limitShift, offset, shift, size };\n","import { rectToClientRect, detectOverflow as detectOverflow$1, offset as offset$1, autoPlacement as autoPlacement$1, shift as shift$1, flip as flip$1, size as size$1, hide as hide$1, arrow as arrow$1, inline as inline$1, limitShift as limitShift$1, computePosition as computePosition$1 } from '@floating-ui/core';\nimport { round, createCoords, max, min, floor } from '@floating-ui/utils';\nimport { getComputedStyle, isHTMLElement, isElement, getWindow, isWebKit, getFrameElement, getDocumentElement, isTopLayer, getNodeName, isOverflowElement, getNodeScroll, getOverflowAncestors, getParentNode, isLastTraversableNode, isContainingBlock, isTableElement, getContainingBlock } from '@floating-ui/utils/dom';\nexport { getOverflowAncestors } from '@floating-ui/utils/dom';\n\nfunction getCssDimensions(element) {\n  const css = getComputedStyle(element);\n  // In testing environments, the `width` and `height` properties are empty\n  // strings for SVG elements, returning NaN. Fallback to `0` in this case.\n  let width = parseFloat(css.width) || 0;\n  let height = parseFloat(css.height) || 0;\n  const hasOffset = isHTMLElement(element);\n  const offsetWidth = hasOffset ? element.offsetWidth : width;\n  const offsetHeight = hasOffset ? element.offsetHeight : height;\n  const shouldFallback = round(width) !== offsetWidth || round(height) !== offsetHeight;\n  if (shouldFallback) {\n    width = offsetWidth;\n    height = offsetHeight;\n  }\n  return {\n    width,\n    height,\n    $: shouldFallback\n  };\n}\n\nfunction unwrapElement(element) {\n  return !isElement(element) ? element.contextElement : element;\n}\n\nfunction getScale(element) {\n  const domElement = unwrapElement(element);\n  if (!isHTMLElement(domElement)) {\n    return createCoords(1);\n  }\n  const rect = domElement.getBoundingClientRect();\n  const {\n    width,\n    height,\n    $\n  } = getCssDimensions(domElement);\n  let x = ($ ? round(rect.width) : rect.width) / width;\n  let y = ($ ? round(rect.height) : rect.height) / height;\n\n  // 0, NaN, or Infinity should always fallback to 1.\n\n  if (!x || !Number.isFinite(x)) {\n    x = 1;\n  }\n  if (!y || !Number.isFinite(y)) {\n    y = 1;\n  }\n  return {\n    x,\n    y\n  };\n}\n\nconst noOffsets = /*#__PURE__*/createCoords(0);\nfunction getVisualOffsets(element) {\n  const win = getWindow(element);\n  if (!isWebKit() || !win.visualViewport) {\n    return noOffsets;\n  }\n  return {\n    x: win.visualViewport.offsetLeft,\n    y: win.visualViewport.offsetTop\n  };\n}\nfunction shouldAddVisualOffsets(element, isFixed, floatingOffsetParent) {\n  if (isFixed === void 0) {\n    isFixed = false;\n  }\n  if (!floatingOffsetParent || isFixed && floatingOffsetParent !== getWindow(element)) {\n    return false;\n  }\n  return isFixed;\n}\n\nfunction getBoundingClientRect(element, includeScale, isFixedStrategy, offsetParent) {\n  if (includeScale === void 0) {\n    includeScale = false;\n  }\n  if (isFixedStrategy === void 0) {\n    isFixedStrategy = false;\n  }\n  const clientRect = element.getBoundingClientRect();\n  const domElement = unwrapElement(element);\n  let scale = createCoords(1);\n  if (includeScale) {\n    if (offsetParent) {\n      if (isElement(offsetParent)) {\n        scale = getScale(offsetParent);\n      }\n    } else {\n      scale = getScale(element);\n    }\n  }\n  const visualOffsets = shouldAddVisualOffsets(domElement, isFixedStrategy, offsetParent) ? getVisualOffsets(domElement) : createCoords(0);\n  let x = (clientRect.left + visualOffsets.x) / scale.x;\n  let y = (clientRect.top + visualOffsets.y) / scale.y;\n  let width = clientRect.width / scale.x;\n  let height = clientRect.height / scale.y;\n  if (domElement) {\n    const win = getWindow(domElement);\n    const offsetWin = offsetParent && isElement(offsetParent) ? getWindow(offsetParent) : offsetParent;\n    let currentWin = win;\n    let currentIFrame = getFrameElement(currentWin);\n    while (currentIFrame && offsetParent && offsetWin !== currentWin) {\n      const iframeScale = getScale(currentIFrame);\n      const iframeRect = currentIFrame.getBoundingClientRect();\n      const css = getComputedStyle(currentIFrame);\n      const left = iframeRect.left + (currentIFrame.clientLeft + parseFloat(css.paddingLeft)) * iframeScale.x;\n      const top = iframeRect.top + (currentIFrame.clientTop + parseFloat(css.paddingTop)) * iframeScale.y;\n      x *= iframeScale.x;\n      y *= iframeScale.y;\n      width *= iframeScale.x;\n      height *= iframeScale.y;\n      x += left;\n      y += top;\n      currentWin = getWindow(currentIFrame);\n      currentIFrame = getFrameElement(currentWin);\n    }\n  }\n  return rectToClientRect({\n    width,\n    height,\n    x,\n    y\n  });\n}\n\nfunction convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {\n  let {\n    elements,\n    rect,\n    offsetParent,\n    strategy\n  } = _ref;\n  const isFixed = strategy === 'fixed';\n  const documentElement = getDocumentElement(offsetParent);\n  const topLayer = elements ? isTopLayer(elements.floating) : false;\n  if (offsetParent === documentElement || topLayer && isFixed) {\n    return rect;\n  }\n  let scroll = {\n    scrollLeft: 0,\n    scrollTop: 0\n  };\n  let scale = createCoords(1);\n  const offsets = createCoords(0);\n  const isOffsetParentAnElement = isHTMLElement(offsetParent);\n  if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {\n    if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) {\n      scroll = getNodeScroll(offsetParent);\n    }\n    if (isHTMLElement(offsetParent)) {\n      const offsetRect = getBoundingClientRect(offsetParent);\n      scale = getScale(offsetParent);\n      offsets.x = offsetRect.x + offsetParent.clientLeft;\n      offsets.y = offsetRect.y + offsetParent.clientTop;\n    }\n  }\n  return {\n    width: rect.width * scale.x,\n    height: rect.height * scale.y,\n    x: rect.x * scale.x - scroll.scrollLeft * scale.x + offsets.x,\n    y: rect.y * scale.y - scroll.scrollTop * scale.y + offsets.y\n  };\n}\n\nfunction getClientRects(element) {\n  return Array.from(element.getClientRects());\n}\n\n// If <html> has a CSS width greater than the viewport, then this will be\n// incorrect for RTL.\nfunction getWindowScrollBarX(element, rect) {\n  const leftScroll = getNodeScroll(element).scrollLeft;\n  if (!rect) {\n    return getBoundingClientRect(getDocumentElement(element)).left + leftScroll;\n  }\n  return rect.left + leftScroll;\n}\n\n// Gets the entire size of the scrollable document area, even extending outside\n// of the `<html>` and `<body>` rect bounds if horizontally scrollable.\nfunction getDocumentRect(element) {\n  const html = getDocumentElement(element);\n  const scroll = getNodeScroll(element);\n  const body = element.ownerDocument.body;\n  const width = max(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth);\n  const height = max(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight);\n  let x = -scroll.scrollLeft + getWindowScrollBarX(element);\n  const y = -scroll.scrollTop;\n  if (getComputedStyle(body).direction === 'rtl') {\n    x += max(html.clientWidth, body.clientWidth) - width;\n  }\n  return {\n    width,\n    height,\n    x,\n    y\n  };\n}\n\nfunction getViewportRect(element, strategy) {\n  const win = getWindow(element);\n  const html = getDocumentElement(element);\n  const visualViewport = win.visualViewport;\n  let width = html.clientWidth;\n  let height = html.clientHeight;\n  let x = 0;\n  let y = 0;\n  if (visualViewport) {\n    width = visualViewport.width;\n    height = visualViewport.height;\n    const visualViewportBased = isWebKit();\n    if (!visualViewportBased || visualViewportBased && strategy === 'fixed') {\n      x = visualViewport.offsetLeft;\n      y = visualViewport.offsetTop;\n    }\n  }\n  return {\n    width,\n    height,\n    x,\n    y\n  };\n}\n\n// Returns the inner client rect, subtracting scrollbars if present.\nfunction getInnerBoundingClientRect(element, strategy) {\n  const clientRect = getBoundingClientRect(element, true, strategy === 'fixed');\n  const top = clientRect.top + element.clientTop;\n  const left = clientRect.left + element.clientLeft;\n  const scale = isHTMLElement(element) ? getScale(element) : createCoords(1);\n  const width = element.clientWidth * scale.x;\n  const height = element.clientHeight * scale.y;\n  const x = left * scale.x;\n  const y = top * scale.y;\n  return {\n    width,\n    height,\n    x,\n    y\n  };\n}\nfunction getClientRectFromClippingAncestor(element, clippingAncestor, strategy) {\n  let rect;\n  if (clippingAncestor === 'viewport') {\n    rect = getViewportRect(element, strategy);\n  } else if (clippingAncestor === 'document') {\n    rect = getDocumentRect(getDocumentElement(element));\n  } else if (isElement(clippingAncestor)) {\n    rect = getInnerBoundingClientRect(clippingAncestor, strategy);\n  } else {\n    const visualOffsets = getVisualOffsets(element);\n    rect = {\n      ...clippingAncestor,\n      x: clippingAncestor.x - visualOffsets.x,\n      y: clippingAncestor.y - visualOffsets.y\n    };\n  }\n  return rectToClientRect(rect);\n}\nfunction hasFixedPositionAncestor(element, stopNode) {\n  const parentNode = getParentNode(element);\n  if (parentNode === stopNode || !isElement(parentNode) || isLastTraversableNode(parentNode)) {\n    return false;\n  }\n  return getComputedStyle(parentNode).position === 'fixed' || hasFixedPositionAncestor(parentNode, stopNode);\n}\n\n// A \"clipping ancestor\" is an `overflow` element with the characteristic of\n// clipping (or hiding) child elements. This returns all clipping ancestors\n// of the given element up the tree.\nfunction getClippingElementAncestors(element, cache) {\n  const cachedResult = cache.get(element);\n  if (cachedResult) {\n    return cachedResult;\n  }\n  let result = getOverflowAncestors(element, [], false).filter(el => isElement(el) && getNodeName(el) !== 'body');\n  let currentContainingBlockComputedStyle = null;\n  const elementIsFixed = getComputedStyle(element).position === 'fixed';\n  let currentNode = elementIsFixed ? getParentNode(element) : element;\n\n  // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block\n  while (isElement(currentNode) && !isLastTraversableNode(currentNode)) {\n    const computedStyle = getComputedStyle(currentNode);\n    const currentNodeIsContaining = isContainingBlock(currentNode);\n    if (!currentNodeIsContaining && computedStyle.position === 'fixed') {\n      currentContainingBlockComputedStyle = null;\n    }\n    const shouldDropCurrentNode = elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && computedStyle.position === 'static' && !!currentContainingBlockComputedStyle && ['absolute', 'fixed'].includes(currentContainingBlockComputedStyle.position) || isOverflowElement(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode);\n    if (shouldDropCurrentNode) {\n      // Drop non-containing blocks.\n      result = result.filter(ancestor => ancestor !== currentNode);\n    } else {\n      // Record last containing block for next iteration.\n      currentContainingBlockComputedStyle = computedStyle;\n    }\n    currentNode = getParentNode(currentNode);\n  }\n  cache.set(element, result);\n  return result;\n}\n\n// Gets the maximum area that the element is visible in due to any number of\n// clipping ancestors.\nfunction getClippingRect(_ref) {\n  let {\n    element,\n    boundary,\n    rootBoundary,\n    strategy\n  } = _ref;\n  const elementClippingAncestors = boundary === 'clippingAncestors' ? isTopLayer(element) ? [] : getClippingElementAncestors(element, this._c) : [].concat(boundary);\n  const clippingAncestors = [...elementClippingAncestors, rootBoundary];\n  const firstClippingAncestor = clippingAncestors[0];\n  const clippingRect = clippingAncestors.reduce((accRect, clippingAncestor) => {\n    const rect = getClientRectFromClippingAncestor(element, clippingAncestor, strategy);\n    accRect.top = max(rect.top, accRect.top);\n    accRect.right = min(rect.right, accRect.right);\n    accRect.bottom = min(rect.bottom, accRect.bottom);\n    accRect.left = max(rect.left, accRect.left);\n    return accRect;\n  }, getClientRectFromClippingAncestor(element, firstClippingAncestor, strategy));\n  return {\n    width: clippingRect.right - clippingRect.left,\n    height: clippingRect.bottom - clippingRect.top,\n    x: clippingRect.left,\n    y: clippingRect.top\n  };\n}\n\nfunction getDimensions(element) {\n  const {\n    width,\n    height\n  } = getCssDimensions(element);\n  return {\n    width,\n    height\n  };\n}\n\nfunction getRectRelativeToOffsetParent(element, offsetParent, strategy) {\n  const isOffsetParentAnElement = isHTMLElement(offsetParent);\n  const documentElement = getDocumentElement(offsetParent);\n  const isFixed = strategy === 'fixed';\n  const rect = getBoundingClientRect(element, true, isFixed, offsetParent);\n  let scroll = {\n    scrollLeft: 0,\n    scrollTop: 0\n  };\n  const offsets = createCoords(0);\n  if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {\n    if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) {\n      scroll = getNodeScroll(offsetParent);\n    }\n    if (isOffsetParentAnElement) {\n      const offsetRect = getBoundingClientRect(offsetParent, true, isFixed, offsetParent);\n      offsets.x = offsetRect.x + offsetParent.clientLeft;\n      offsets.y = offsetRect.y + offsetParent.clientTop;\n    } else if (documentElement) {\n      // If the <body> scrollbar appears on the left (e.g. RTL systems). Use\n      // Firefox with layout.scrollbar.side = 3 in about:config to test this.\n      offsets.x = getWindowScrollBarX(documentElement);\n    }\n  }\n  let htmlX = 0;\n  let htmlY = 0;\n  if (documentElement && !isOffsetParentAnElement && !isFixed) {\n    const htmlRect = documentElement.getBoundingClientRect();\n    htmlY = htmlRect.top + scroll.scrollTop;\n    htmlX = htmlRect.left + scroll.scrollLeft -\n    // RTL <body> scrollbar.\n    getWindowScrollBarX(documentElement, htmlRect);\n  }\n  const x = rect.left + scroll.scrollLeft - offsets.x - htmlX;\n  const y = rect.top + scroll.scrollTop - offsets.y - htmlY;\n  return {\n    x,\n    y,\n    width: rect.width,\n    height: rect.height\n  };\n}\n\nfunction isStaticPositioned(element) {\n  return getComputedStyle(element).position === 'static';\n}\n\nfunction getTrueOffsetParent(element, polyfill) {\n  if (!isHTMLElement(element) || getComputedStyle(element).position === 'fixed') {\n    return null;\n  }\n  if (polyfill) {\n    return polyfill(element);\n  }\n  let rawOffsetParent = element.offsetParent;\n\n  // Firefox returns the <html> element as the offsetParent if it's non-static,\n  // while Chrome and Safari return the <body> element. The <body> element must\n  // be used to perform the correct calculations even if the <html> element is\n  // non-static.\n  if (getDocumentElement(element) === rawOffsetParent) {\n    rawOffsetParent = rawOffsetParent.ownerDocument.body;\n  }\n  return rawOffsetParent;\n}\n\n// Gets the closest ancestor positioned element. Handles some edge cases,\n// such as table ancestors and cross browser bugs.\nfunction getOffsetParent(element, polyfill) {\n  const win = getWindow(element);\n  if (isTopLayer(element)) {\n    return win;\n  }\n  if (!isHTMLElement(element)) {\n    let svgOffsetParent = getParentNode(element);\n    while (svgOffsetParent && !isLastTraversableNode(svgOffsetParent)) {\n      if (isElement(svgOffsetParent) && !isStaticPositioned(svgOffsetParent)) {\n        return svgOffsetParent;\n      }\n      svgOffsetParent = getParentNode(svgOffsetParent);\n    }\n    return win;\n  }\n  let offsetParent = getTrueOffsetParent(element, polyfill);\n  while (offsetParent && isTableElement(offsetParent) && isStaticPositioned(offsetParent)) {\n    offsetParent = getTrueOffsetParent(offsetParent, polyfill);\n  }\n  if (offsetParent && isLastTraversableNode(offsetParent) && isStaticPositioned(offsetParent) && !isContainingBlock(offsetParent)) {\n    return win;\n  }\n  return offsetParent || getContainingBlock(element) || win;\n}\n\nconst getElementRects = async function (data) {\n  const getOffsetParentFn = this.getOffsetParent || getOffsetParent;\n  const getDimensionsFn = this.getDimensions;\n  const floatingDimensions = await getDimensionsFn(data.floating);\n  return {\n    reference: getRectRelativeToOffsetParent(data.reference, await getOffsetParentFn(data.floating), data.strategy),\n    floating: {\n      x: 0,\n      y: 0,\n      width: floatingDimensions.width,\n      height: floatingDimensions.height\n    }\n  };\n};\n\nfunction isRTL(element) {\n  return getComputedStyle(element).direction === 'rtl';\n}\n\nconst platform = {\n  convertOffsetParentRelativeRectToViewportRelativeRect,\n  getDocumentElement,\n  getClippingRect,\n  getOffsetParent,\n  getElementRects,\n  getClientRects,\n  getDimensions,\n  getScale,\n  isElement,\n  isRTL\n};\n\n// https://samthor.au/2021/observing-dom/\nfunction observeMove(element, onMove) {\n  let io = null;\n  let timeoutId;\n  const root = getDocumentElement(element);\n  function cleanup() {\n    var _io;\n    clearTimeout(timeoutId);\n    (_io = io) == null || _io.disconnect();\n    io = null;\n  }\n  function refresh(skip, threshold) {\n    if (skip === void 0) {\n      skip = false;\n    }\n    if (threshold === void 0) {\n      threshold = 1;\n    }\n    cleanup();\n    const {\n      left,\n      top,\n      width,\n      height\n    } = element.getBoundingClientRect();\n    if (!skip) {\n      onMove();\n    }\n    if (!width || !height) {\n      return;\n    }\n    const insetTop = floor(top);\n    const insetRight = floor(root.clientWidth - (left + width));\n    const insetBottom = floor(root.clientHeight - (top + height));\n    const insetLeft = floor(left);\n    const rootMargin = -insetTop + \"px \" + -insetRight + \"px \" + -insetBottom + \"px \" + -insetLeft + \"px\";\n    const options = {\n      rootMargin,\n      threshold: max(0, min(1, threshold)) || 1\n    };\n    let isFirstUpdate = true;\n    function handleObserve(entries) {\n      const ratio = entries[0].intersectionRatio;\n      if (ratio !== threshold) {\n        if (!isFirstUpdate) {\n          return refresh();\n        }\n        if (!ratio) {\n          // If the reference is clipped, the ratio is 0. Throttle the refresh\n          // to prevent an infinite loop of updates.\n          timeoutId = setTimeout(() => {\n            refresh(false, 1e-7);\n          }, 1000);\n        } else {\n          refresh(false, ratio);\n        }\n      }\n      isFirstUpdate = false;\n    }\n\n    // Older browsers don't support a `document` as the root and will throw an\n    // error.\n    try {\n      io = new IntersectionObserver(handleObserve, {\n        ...options,\n        // Handle <iframe>s\n        root: root.ownerDocument\n      });\n    } catch (e) {\n      io = new IntersectionObserver(handleObserve, options);\n    }\n    io.observe(element);\n  }\n  refresh(true);\n  return cleanup;\n}\n\n/**\n * Automatically updates the position of the floating element when necessary.\n * Should only be called when the floating element is mounted on the DOM or\n * visible on the screen.\n * @returns cleanup function that should be invoked when the floating element is\n * removed from the DOM or hidden from the screen.\n * @see https://floating-ui.com/docs/autoUpdate\n */\nfunction autoUpdate(reference, floating, update, options) {\n  if (options === void 0) {\n    options = {};\n  }\n  const {\n    ancestorScroll = true,\n    ancestorResize = true,\n    elementResize = typeof ResizeObserver === 'function',\n    layoutShift = typeof IntersectionObserver === 'function',\n    animationFrame = false\n  } = options;\n  const referenceEl = unwrapElement(reference);\n  const ancestors = ancestorScroll || ancestorResize ? [...(referenceEl ? getOverflowAncestors(referenceEl) : []), ...getOverflowAncestors(floating)] : [];\n  ancestors.forEach(ancestor => {\n    ancestorScroll && ancestor.addEventListener('scroll', update, {\n      passive: true\n    });\n    ancestorResize && ancestor.addEventListener('resize', update);\n  });\n  const cleanupIo = referenceEl && layoutShift ? observeMove(referenceEl, update) : null;\n  let reobserveFrame = -1;\n  let resizeObserver = null;\n  if (elementResize) {\n    resizeObserver = new ResizeObserver(_ref => {\n      let [firstEntry] = _ref;\n      if (firstEntry && firstEntry.target === referenceEl && resizeObserver) {\n        // Prevent update loops when using the `size` middleware.\n        // https://github.com/floating-ui/floating-ui/issues/1740\n        resizeObserver.unobserve(floating);\n        cancelAnimationFrame(reobserveFrame);\n        reobserveFrame = requestAnimationFrame(() => {\n          var _resizeObserver;\n          (_resizeObserver = resizeObserver) == null || _resizeObserver.observe(floating);\n        });\n      }\n      update();\n    });\n    if (referenceEl && !animationFrame) {\n      resizeObserver.observe(referenceEl);\n    }\n    resizeObserver.observe(floating);\n  }\n  let frameId;\n  let prevRefRect = animationFrame ? getBoundingClientRect(reference) : null;\n  if (animationFrame) {\n    frameLoop();\n  }\n  function frameLoop() {\n    const nextRefRect = getBoundingClientRect(reference);\n    if (prevRefRect && (nextRefRect.x !== prevRefRect.x || nextRefRect.y !== prevRefRect.y || nextRefRect.width !== prevRefRect.width || nextRefRect.height !== prevRefRect.height)) {\n      update();\n    }\n    prevRefRect = nextRefRect;\n    frameId = requestAnimationFrame(frameLoop);\n  }\n  update();\n  return () => {\n    var _resizeObserver2;\n    ancestors.forEach(ancestor => {\n      ancestorScroll && ancestor.removeEventListener('scroll', update);\n      ancestorResize && ancestor.removeEventListener('resize', update);\n    });\n    cleanupIo == null || cleanupIo();\n    (_resizeObserver2 = resizeObserver) == null || _resizeObserver2.disconnect();\n    resizeObserver = null;\n    if (animationFrame) {\n      cancelAnimationFrame(frameId);\n    }\n  };\n}\n\n/**\n * Resolves with an object of overflow side offsets that determine how much the\n * element is overflowing a given clipping boundary on each side.\n * - positive = overflowing the boundary by that number of pixels\n * - negative = how many pixels left before it will overflow\n * - 0 = lies flush with the boundary\n * @see https://floating-ui.com/docs/detectOverflow\n */\nconst detectOverflow = detectOverflow$1;\n\n/**\n * Modifies the placement by translating the floating element along the\n * specified axes.\n * A number (shorthand for `mainAxis` or distance), or an axes configuration\n * object may be passed.\n * @see https://floating-ui.com/docs/offset\n */\nconst offset = offset$1;\n\n/**\n * Optimizes the visibility of the floating element by choosing the placement\n * that has the most space available automatically, without needing to specify a\n * preferred placement. Alternative to `flip`.\n * @see https://floating-ui.com/docs/autoPlacement\n */\nconst autoPlacement = autoPlacement$1;\n\n/**\n * Optimizes the visibility of the floating element by shifting it in order to\n * keep it in view when it will overflow the clipping boundary.\n * @see https://floating-ui.com/docs/shift\n */\nconst shift = shift$1;\n\n/**\n * Optimizes the visibility of the floating element by flipping the `placement`\n * in order to keep it in view when the preferred placement(s) will overflow the\n * clipping boundary. Alternative to `autoPlacement`.\n * @see https://floating-ui.com/docs/flip\n */\nconst flip = flip$1;\n\n/**\n * Provides data that allows you to change the size of the floating element —\n * for instance, prevent it from overflowing the clipping boundary or match the\n * width of the reference element.\n * @see https://floating-ui.com/docs/size\n */\nconst size = size$1;\n\n/**\n * Provides data to hide the floating element in applicable situations, such as\n * when it is not in the same clipping context as the reference element.\n * @see https://floating-ui.com/docs/hide\n */\nconst hide = hide$1;\n\n/**\n * Provides data to position an inner element of the floating element so that it\n * appears centered to the reference element.\n * @see https://floating-ui.com/docs/arrow\n */\nconst arrow = arrow$1;\n\n/**\n * Provides improved positioning for inline reference elements that can span\n * over multiple lines, such as hyperlinks or range selections.\n * @see https://floating-ui.com/docs/inline\n */\nconst inline = inline$1;\n\n/**\n * Built-in `limiter` that will stop `shift()` at a certain point.\n */\nconst limitShift = limitShift$1;\n\n/**\n * Computes the `x` and `y` coordinates that will place the floating element\n * next to a given reference element.\n */\nconst computePosition = (reference, floating, options) => {\n  // This caches the expensive `getClippingElementAncestors` function so that\n  // multiple lifecycle resets re-use the same result. It only lives for a\n  // single call. If other functions become expensive, we can add them as well.\n  const cache = new Map();\n  const mergedOptions = {\n    platform,\n    ...options\n  };\n  const platformWithCache = {\n    ...mergedOptions.platform,\n    _c: cache\n  };\n  return computePosition$1(reference, floating, {\n    ...mergedOptions,\n    platform: platformWithCache\n  });\n};\n\nexport { arrow, autoPlacement, autoUpdate, computePosition, detectOverflow, flip, hide, inline, limitShift, offset, platform, shift, size };\n","import { computePosition, arrow as arrow$2, offset as offset$1, shift as shift$1, limitShift as limitShift$1, flip as flip$1, size as size$1, autoPlacement as autoPlacement$1, hide as hide$1, inline as inline$1 } from '@floating-ui/dom';\nexport { autoUpdate, computePosition, detectOverflow, getOverflowAncestors, platform } from '@floating-ui/dom';\nimport * as React from 'react';\nimport { useLayoutEffect, useEffect } from 'react';\nimport * as ReactDOM from 'react-dom';\n\nvar index = typeof document !== 'undefined' ? useLayoutEffect : useEffect;\n\n// Fork of `fast-deep-equal` that only does the comparisons we need and compares\n// functions\nfunction deepEqual(a, b) {\n  if (a === b) {\n    return true;\n  }\n  if (typeof a !== typeof b) {\n    return false;\n  }\n  if (typeof a === 'function' && a.toString() === b.toString()) {\n    return true;\n  }\n  let length;\n  let i;\n  let keys;\n  if (a && b && typeof a === 'object') {\n    if (Array.isArray(a)) {\n      length = a.length;\n      if (length !== b.length) return false;\n      for (i = length; i-- !== 0;) {\n        if (!deepEqual(a[i], b[i])) {\n          return false;\n        }\n      }\n      return true;\n    }\n    keys = Object.keys(a);\n    length = keys.length;\n    if (length !== Object.keys(b).length) {\n      return false;\n    }\n    for (i = length; i-- !== 0;) {\n      if (!{}.hasOwnProperty.call(b, keys[i])) {\n        return false;\n      }\n    }\n    for (i = length; i-- !== 0;) {\n      const key = keys[i];\n      if (key === '_owner' && a.$$typeof) {\n        continue;\n      }\n      if (!deepEqual(a[key], b[key])) {\n        return false;\n      }\n    }\n    return true;\n  }\n  return a !== a && b !== b;\n}\n\nfunction getDPR(element) {\n  if (typeof window === 'undefined') {\n    return 1;\n  }\n  const win = element.ownerDocument.defaultView || window;\n  return win.devicePixelRatio || 1;\n}\n\nfunction roundByDPR(element, value) {\n  const dpr = getDPR(element);\n  return Math.round(value * dpr) / dpr;\n}\n\nfunction useLatestRef(value) {\n  const ref = React.useRef(value);\n  index(() => {\n    ref.current = value;\n  });\n  return ref;\n}\n\n/**\n * Provides data to position a floating element.\n * @see https://floating-ui.com/docs/useFloating\n */\nfunction useFloating(options) {\n  if (options === void 0) {\n    options = {};\n  }\n  const {\n    placement = 'bottom',\n    strategy = 'absolute',\n    middleware = [],\n    platform,\n    elements: {\n      reference: externalReference,\n      floating: externalFloating\n    } = {},\n    transform = true,\n    whileElementsMounted,\n    open\n  } = options;\n  const [data, setData] = React.useState({\n    x: 0,\n    y: 0,\n    strategy,\n    placement,\n    middlewareData: {},\n    isPositioned: false\n  });\n  const [latestMiddleware, setLatestMiddleware] = React.useState(middleware);\n  if (!deepEqual(latestMiddleware, middleware)) {\n    setLatestMiddleware(middleware);\n  }\n  const [_reference, _setReference] = React.useState(null);\n  const [_floating, _setFloating] = React.useState(null);\n  const setReference = React.useCallback(node => {\n    if (node !== referenceRef.current) {\n      referenceRef.current = node;\n      _setReference(node);\n    }\n  }, []);\n  const setFloating = React.useCallback(node => {\n    if (node !== floatingRef.current) {\n      floatingRef.current = node;\n      _setFloating(node);\n    }\n  }, []);\n  const referenceEl = externalReference || _reference;\n  const floatingEl = externalFloating || _floating;\n  const referenceRef = React.useRef(null);\n  const floatingRef = React.useRef(null);\n  const dataRef = React.useRef(data);\n  const hasWhileElementsMounted = whileElementsMounted != null;\n  const whileElementsMountedRef = useLatestRef(whileElementsMounted);\n  const platformRef = useLatestRef(platform);\n  const openRef = useLatestRef(open);\n  const update = React.useCallback(() => {\n    if (!referenceRef.current || !floatingRef.current) {\n      return;\n    }\n    const config = {\n      placement,\n      strategy,\n      middleware: latestMiddleware\n    };\n    if (platformRef.current) {\n      config.platform = platformRef.current;\n    }\n    computePosition(referenceRef.current, floatingRef.current, config).then(data => {\n      const fullData = {\n        ...data,\n        // The floating element's position may be recomputed while it's closed\n        // but still mounted (such as when transitioning out). To ensure\n        // `isPositioned` will be `false` initially on the next open, avoid\n        // setting it to `true` when `open === false` (must be specified).\n        isPositioned: openRef.current !== false\n      };\n      if (isMountedRef.current && !deepEqual(dataRef.current, fullData)) {\n        dataRef.current = fullData;\n        ReactDOM.flushSync(() => {\n          setData(fullData);\n        });\n      }\n    });\n  }, [latestMiddleware, placement, strategy, platformRef, openRef]);\n  index(() => {\n    if (open === false && dataRef.current.isPositioned) {\n      dataRef.current.isPositioned = false;\n      setData(data => ({\n        ...data,\n        isPositioned: false\n      }));\n    }\n  }, [open]);\n  const isMountedRef = React.useRef(false);\n  index(() => {\n    isMountedRef.current = true;\n    return () => {\n      isMountedRef.current = false;\n    };\n  }, []);\n  index(() => {\n    if (referenceEl) referenceRef.current = referenceEl;\n    if (floatingEl) floatingRef.current = floatingEl;\n    if (referenceEl && floatingEl) {\n      if (whileElementsMountedRef.current) {\n        return whileElementsMountedRef.current(referenceEl, floatingEl, update);\n      }\n      update();\n    }\n  }, [referenceEl, floatingEl, update, whileElementsMountedRef, hasWhileElementsMounted]);\n  const refs = React.useMemo(() => ({\n    reference: referenceRef,\n    floating: floatingRef,\n    setReference,\n    setFloating\n  }), [setReference, setFloating]);\n  const elements = React.useMemo(() => ({\n    reference: referenceEl,\n    floating: floatingEl\n  }), [referenceEl, floatingEl]);\n  const floatingStyles = React.useMemo(() => {\n    const initialStyles = {\n      position: strategy,\n      left: 0,\n      top: 0\n    };\n    if (!elements.floating) {\n      return initialStyles;\n    }\n    const x = roundByDPR(elements.floating, data.x);\n    const y = roundByDPR(elements.floating, data.y);\n    if (transform) {\n      return {\n        ...initialStyles,\n        transform: \"translate(\" + x + \"px, \" + y + \"px)\",\n        ...(getDPR(elements.floating) >= 1.5 && {\n          willChange: 'transform'\n        })\n      };\n    }\n    return {\n      position: strategy,\n      left: x,\n      top: y\n    };\n  }, [strategy, transform, elements.floating, data.x, data.y]);\n  return React.useMemo(() => ({\n    ...data,\n    update,\n    refs,\n    elements,\n    floatingStyles\n  }), [data, update, refs, elements, floatingStyles]);\n}\n\n/**\n * Provides data to position an inner element of the floating element so that it\n * appears centered to the reference element.\n * This wraps the core `arrow` middleware to allow React refs as the element.\n * @see https://floating-ui.com/docs/arrow\n */\nconst arrow$1 = options => {\n  function isRef(value) {\n    return {}.hasOwnProperty.call(value, 'current');\n  }\n  return {\n    name: 'arrow',\n    options,\n    fn(state) {\n      const {\n        element,\n        padding\n      } = typeof options === 'function' ? options(state) : options;\n      if (element && isRef(element)) {\n        if (element.current != null) {\n          return arrow$2({\n            element: element.current,\n            padding\n          }).fn(state);\n        }\n        return {};\n      }\n      if (element) {\n        return arrow$2({\n          element,\n          padding\n        }).fn(state);\n      }\n      return {};\n    }\n  };\n};\n\n/**\n * Modifies the placement by translating the floating element along the\n * specified axes.\n * A number (shorthand for `mainAxis` or distance), or an axes configuration\n * object may be passed.\n * @see https://floating-ui.com/docs/offset\n */\nconst offset = (options, deps) => ({\n  ...offset$1(options),\n  options: [options, deps]\n});\n\n/**\n * Optimizes the visibility of the floating element by shifting it in order to\n * keep it in view when it will overflow the clipping boundary.\n * @see https://floating-ui.com/docs/shift\n */\nconst shift = (options, deps) => ({\n  ...shift$1(options),\n  options: [options, deps]\n});\n\n/**\n * Built-in `limiter` that will stop `shift()` at a certain point.\n */\nconst limitShift = (options, deps) => ({\n  ...limitShift$1(options),\n  options: [options, deps]\n});\n\n/**\n * Optimizes the visibility of the floating element by flipping the `placement`\n * in order to keep it in view when the preferred placement(s) will overflow the\n * clipping boundary. Alternative to `autoPlacement`.\n * @see https://floating-ui.com/docs/flip\n */\nconst flip = (options, deps) => ({\n  ...flip$1(options),\n  options: [options, deps]\n});\n\n/**\n * Provides data that allows you to change the size of the floating element —\n * for instance, prevent it from overflowing the clipping boundary or match the\n * width of the reference element.\n * @see https://floating-ui.com/docs/size\n */\nconst size = (options, deps) => ({\n  ...size$1(options),\n  options: [options, deps]\n});\n\n/**\n * Optimizes the visibility of the floating element by choosing the placement\n * that has the most space available automatically, without needing to specify a\n * preferred placement. Alternative to `flip`.\n * @see https://floating-ui.com/docs/autoPlacement\n */\nconst autoPlacement = (options, deps) => ({\n  ...autoPlacement$1(options),\n  options: [options, deps]\n});\n\n/**\n * Provides data to hide the floating element in applicable situations, such as\n * when it is not in the same clipping context as the reference element.\n * @see https://floating-ui.com/docs/hide\n */\nconst hide = (options, deps) => ({\n  ...hide$1(options),\n  options: [options, deps]\n});\n\n/**\n * Provides improved positioning for inline reference elements that can span\n * over multiple lines, such as hyperlinks or range selections.\n * @see https://floating-ui.com/docs/inline\n */\nconst inline = (options, deps) => ({\n  ...inline$1(options),\n  options: [options, deps]\n});\n\n/**\n * Provides data to position an inner element of the floating element so that it\n * appears centered to the reference element.\n * This wraps the core `arrow` middleware to allow React refs as the element.\n * @see https://floating-ui.com/docs/arrow\n */\nconst arrow = (options, deps) => ({\n  ...arrow$1(options),\n  options: [options, deps]\n});\n\nexport { arrow, autoPlacement, flip, hide, inline, limitShift, offset, shift, size, useFloating };\n","import { isShadowRoot, isHTMLElement } from '@floating-ui/utils/dom';\n\nfunction activeElement(doc) {\n  let activeElement = doc.activeElement;\n  while (((_activeElement = activeElement) == null || (_activeElement = _activeElement.shadowRoot) == null ? void 0 : _activeElement.activeElement) != null) {\n    var _activeElement;\n    activeElement = activeElement.shadowRoot.activeElement;\n  }\n  return activeElement;\n}\nfunction contains(parent, child) {\n  if (!parent || !child) {\n    return false;\n  }\n  const rootNode = child.getRootNode == null ? void 0 : child.getRootNode();\n\n  // First, attempt with faster native method\n  if (parent.contains(child)) {\n    return true;\n  }\n\n  // then fallback to custom implementation with Shadow DOM support\n  if (rootNode && isShadowRoot(rootNode)) {\n    let next = child;\n    while (next) {\n      if (parent === next) {\n        return true;\n      }\n      // @ts-ignore\n      next = next.parentNode || next.host;\n    }\n  }\n\n  // Give up, the result is false\n  return false;\n}\n// Avoid Chrome DevTools blue warning.\nfunction getPlatform() {\n  const uaData = navigator.userAgentData;\n  if (uaData != null && uaData.platform) {\n    return uaData.platform;\n  }\n  return navigator.platform;\n}\nfunction getUserAgent() {\n  const uaData = navigator.userAgentData;\n  if (uaData && Array.isArray(uaData.brands)) {\n    return uaData.brands.map(_ref => {\n      let {\n        brand,\n        version\n      } = _ref;\n      return brand + \"/\" + version;\n    }).join(' ');\n  }\n  return navigator.userAgent;\n}\n\n// License: https://github.com/adobe/react-spectrum/blob/b35d5c02fe900badccd0cf1a8f23bb593419f238/packages/@react-aria/utils/src/isVirtualEvent.ts\nfunction isVirtualClick(event) {\n  // FIXME: Firefox is now emitting a deprecation warning for `mozInputSource`.\n  // Try to find a workaround for this. `react-aria` source still has the check.\n  if (event.mozInputSource === 0 && event.isTrusted) {\n    return true;\n  }\n  if (isAndroid() && event.pointerType) {\n    return event.type === 'click' && event.buttons === 1;\n  }\n  return event.detail === 0 && !event.pointerType;\n}\nfunction isVirtualPointerEvent(event) {\n  if (isJSDOM()) return false;\n  return !isAndroid() && event.width === 0 && event.height === 0 || isAndroid() && event.width === 1 && event.height === 1 && event.pressure === 0 && event.detail === 0 && event.pointerType === 'mouse' ||\n  // iOS VoiceOver returns 0.333• for width/height.\n  event.width < 1 && event.height < 1 && event.pressure === 0 && event.detail === 0 && event.pointerType === 'touch';\n}\nfunction isSafari() {\n  // Chrome DevTools does not complain about navigator.vendor\n  return /apple/i.test(navigator.vendor);\n}\nfunction isAndroid() {\n  const re = /android/i;\n  return re.test(getPlatform()) || re.test(getUserAgent());\n}\nfunction isMac() {\n  return getPlatform().toLowerCase().startsWith('mac') && !navigator.maxTouchPoints;\n}\nfunction isJSDOM() {\n  return getUserAgent().includes('jsdom/');\n}\nfunction isMouseLikePointerType(pointerType, strict) {\n  // On some Linux machines with Chromium, mouse inputs return a `pointerType`\n  // of \"pen\": https://github.com/floating-ui/floating-ui/issues/2015\n  const values = ['mouse', 'pen'];\n  if (!strict) {\n    values.push('', undefined);\n  }\n  return values.includes(pointerType);\n}\nfunction isReactEvent(event) {\n  return 'nativeEvent' in event;\n}\nfunction isRootElement(element) {\n  return element.matches('html,body');\n}\nfunction getDocument(node) {\n  return (node == null ? void 0 : node.ownerDocument) || document;\n}\nfunction isEventTargetWithin(event, node) {\n  if (node == null) {\n    return false;\n  }\n  if ('composedPath' in event) {\n    return event.composedPath().includes(node);\n  }\n\n  // TS thinks `event` is of type never as it assumes all browsers support composedPath, but browsers without shadow dom don't\n  const e = event;\n  return e.target != null && node.contains(e.target);\n}\nfunction getTarget(event) {\n  if ('composedPath' in event) {\n    return event.composedPath()[0];\n  }\n\n  // TS thinks `event` is of type never as it assumes all browsers support\n  // `composedPath()`, but browsers without shadow DOM don't.\n  return event.target;\n}\nconst TYPEABLE_SELECTOR = \"input:not([type='hidden']):not([disabled]),\" + \"[contenteditable]:not([contenteditable='false']),textarea:not([disabled])\";\nfunction isTypeableElement(element) {\n  return isHTMLElement(element) && element.matches(TYPEABLE_SELECTOR);\n}\nfunction stopEvent(event) {\n  event.preventDefault();\n  event.stopPropagation();\n}\nfunction isTypeableCombobox(element) {\n  if (!element) return false;\n  return element.getAttribute('role') === 'combobox' && isTypeableElement(element);\n}\n\nexport { TYPEABLE_SELECTOR, activeElement, contains, getDocument, getPlatform, getTarget, getUserAgent, isAndroid, isEventTargetWithin, isJSDOM, isMac, isMouseLikePointerType, isReactEvent, isRootElement, isSafari, isTypeableCombobox, isTypeableElement, isVirtualClick, isVirtualPointerEvent, stopEvent };\n","// NOTE: separate `:not()` selectors has broader browser support than the newer\n//  `:not([inert], [inert] *)` (Feb 2023)\n// CAREFUL: JSDom does not support `:not([inert] *)` as a selector; using it causes\n//  the entire query to fail, resulting in no nodes found, which will break a lot\n//  of things... so we have to rely on JS to identify nodes inside an inert container\nconst candidateSelectors = [\n  'input:not([inert])',\n  'select:not([inert])',\n  'textarea:not([inert])',\n  'a[href]:not([inert])',\n  'button:not([inert])',\n  '[tabindex]:not(slot):not([inert])',\n  'audio[controls]:not([inert])',\n  'video[controls]:not([inert])',\n  '[contenteditable]:not([contenteditable=\"false\"]):not([inert])',\n  'details>summary:first-of-type:not([inert])',\n  'details:not([inert])',\n];\nconst candidateSelector = /* #__PURE__ */ candidateSelectors.join(',');\n\nconst NoElement = typeof Element === 'undefined';\n\nconst matches = NoElement\n  ? function () {}\n  : Element.prototype.matches ||\n    Element.prototype.msMatchesSelector ||\n    Element.prototype.webkitMatchesSelector;\n\nconst getRootNode =\n  !NoElement && Element.prototype.getRootNode\n    ? (element) => element?.getRootNode?.()\n    : (element) => element?.ownerDocument;\n\n/**\n * Determines if a node is inert or in an inert ancestor.\n * @param {Element} [node]\n * @param {boolean} [lookUp] If true and `node` is not inert, looks up at ancestors to\n *  see if any of them are inert. If false, only `node` itself is considered.\n * @returns {boolean} True if inert itself or by way of being in an inert ancestor.\n *  False if `node` is falsy.\n */\nconst isInert = function (node, lookUp = true) {\n  // CAREFUL: JSDom does not support inert at all, so we can't use the `HTMLElement.inert`\n  //  JS API property; we have to check the attribute, which can either be empty or 'true';\n  //  if it's `null` (not specified) or 'false', it's an active element\n  const inertAtt = node?.getAttribute?.('inert');\n  const inert = inertAtt === '' || inertAtt === 'true';\n\n  // NOTE: this could also be handled with `node.matches('[inert], :is([inert] *)')`\n  //  if it weren't for `matches()` not being a function on shadow roots; the following\n  //  code works for any kind of node\n  // CAREFUL: JSDom does not appear to support certain selectors like `:not([inert] *)`\n  //  so it likely would not support `:is([inert] *)` either...\n  const result = inert || (lookUp && node && isInert(node.parentNode)); // recursive\n\n  return result;\n};\n\n/**\n * Determines if a node's content is editable.\n * @param {Element} [node]\n * @returns True if it's content-editable; false if it's not or `node` is falsy.\n */\nconst isContentEditable = function (node) {\n  // CAREFUL: JSDom does not support the `HTMLElement.isContentEditable` API so we have\n  //  to use the attribute directly to check for this, which can either be empty or 'true';\n  //  if it's `null` (not specified) or 'false', it's a non-editable element\n  const attValue = node?.getAttribute?.('contenteditable');\n  return attValue === '' || attValue === 'true';\n};\n\n/**\n * @param {Element} el container to check in\n * @param {boolean} includeContainer add container to check\n * @param {(node: Element) => boolean} filter filter candidates\n * @returns {Element[]}\n */\nconst getCandidates = function (el, includeContainer, filter) {\n  // even if `includeContainer=false`, we still have to check it for inertness because\n  //  if it's inert, all its children are inert\n  if (isInert(el)) {\n    return [];\n  }\n\n  let candidates = Array.prototype.slice.apply(\n    el.querySelectorAll(candidateSelector)\n  );\n  if (includeContainer && matches.call(el, candidateSelector)) {\n    candidates.unshift(el);\n  }\n  candidates = candidates.filter(filter);\n  return candidates;\n};\n\n/**\n * @callback GetShadowRoot\n * @param {Element} element to check for shadow root\n * @returns {ShadowRoot|boolean} ShadowRoot if available or boolean indicating if a shadowRoot is attached but not available.\n */\n\n/**\n * @callback ShadowRootFilter\n * @param {Element} shadowHostNode the element which contains shadow content\n * @returns {boolean} true if a shadow root could potentially contain valid candidates.\n */\n\n/**\n * @typedef {Object} CandidateScope\n * @property {Element} scopeParent contains inner candidates\n * @property {Element[]} candidates list of candidates found in the scope parent\n */\n\n/**\n * @typedef {Object} IterativeOptions\n * @property {GetShadowRoot|boolean} getShadowRoot true if shadow support is enabled; falsy if not;\n *  if a function, implies shadow support is enabled and either returns the shadow root of an element\n *  or a boolean stating if it has an undisclosed shadow root\n * @property {(node: Element) => boolean} filter filter candidates\n * @property {boolean} flatten if true then result will flatten any CandidateScope into the returned list\n * @property {ShadowRootFilter} shadowRootFilter filter shadow roots;\n */\n\n/**\n * @param {Element[]} elements list of element containers to match candidates from\n * @param {boolean} includeContainer add container list to check\n * @param {IterativeOptions} options\n * @returns {Array.<Element|CandidateScope>}\n */\nconst getCandidatesIteratively = function (\n  elements,\n  includeContainer,\n  options\n) {\n  const candidates = [];\n  const elementsToCheck = Array.from(elements);\n  while (elementsToCheck.length) {\n    const element = elementsToCheck.shift();\n    if (isInert(element, false)) {\n      // no need to look up since we're drilling down\n      // anything inside this container will also be inert\n      continue;\n    }\n\n    if (element.tagName === 'SLOT') {\n      // add shadow dom slot scope (slot itself cannot be focusable)\n      const assigned = element.assignedElements();\n      const content = assigned.length ? assigned : element.children;\n      const nestedCandidates = getCandidatesIteratively(content, true, options);\n      if (options.flatten) {\n        candidates.push(...nestedCandidates);\n      } else {\n        candidates.push({\n          scopeParent: element,\n          candidates: nestedCandidates,\n        });\n      }\n    } else {\n      // check candidate element\n      const validCandidate = matches.call(element, candidateSelector);\n      if (\n        validCandidate &&\n        options.filter(element) &&\n        (includeContainer || !elements.includes(element))\n      ) {\n        candidates.push(element);\n      }\n\n      // iterate over shadow content if possible\n      const shadowRoot =\n        element.shadowRoot ||\n        // check for an undisclosed shadow\n        (typeof options.getShadowRoot === 'function' &&\n          options.getShadowRoot(element));\n\n      // no inert look up because we're already drilling down and checking for inertness\n      //  on the way down, so all containers to this root node should have already been\n      //  vetted as non-inert\n      const validShadowRoot =\n        !isInert(shadowRoot, false) &&\n        (!options.shadowRootFilter || options.shadowRootFilter(element));\n\n      if (shadowRoot && validShadowRoot) {\n        // add shadow dom scope IIF a shadow root node was given; otherwise, an undisclosed\n        //  shadow exists, so look at light dom children as fallback BUT create a scope for any\n        //  child candidates found because they're likely slotted elements (elements that are\n        //  children of the web component element (which has the shadow), in the light dom, but\n        //  slotted somewhere _inside_ the undisclosed shadow) -- the scope is created below,\n        //  _after_ we return from this recursive call\n        const nestedCandidates = getCandidatesIteratively(\n          shadowRoot === true ? element.children : shadowRoot.children,\n          true,\n          options\n        );\n\n        if (options.flatten) {\n          candidates.push(...nestedCandidates);\n        } else {\n          candidates.push({\n            scopeParent: element,\n            candidates: nestedCandidates,\n          });\n        }\n      } else {\n        // there's not shadow so just dig into the element's (light dom) children\n        //  __without__ giving the element special scope treatment\n        elementsToCheck.unshift(...element.children);\n      }\n    }\n  }\n  return candidates;\n};\n\n/**\n * @private\n * Determines if the node has an explicitly specified `tabindex` attribute.\n * @param {HTMLElement} node\n * @returns {boolean} True if so; false if not.\n */\nconst hasTabIndex = function (node) {\n  return !isNaN(parseInt(node.getAttribute('tabindex'), 10));\n};\n\n/**\n * Determine the tab index of a given node.\n * @param {HTMLElement} node\n * @returns {number} Tab order (negative, 0, or positive number).\n * @throws {Error} If `node` is falsy.\n */\nconst getTabIndex = function (node) {\n  if (!node) {\n    throw new Error('No node provided');\n  }\n\n  if (node.tabIndex < 0) {\n    // in Chrome, <details/>, <audio controls/> and <video controls/> elements get a default\n    // `tabIndex` of -1 when the 'tabindex' attribute isn't specified in the DOM,\n    // yet they are still part of the regular tab order; in FF, they get a default\n    // `tabIndex` of 0; since Chrome still puts those elements in the regular tab\n    // order, consider their tab index to be 0.\n    // Also browsers do not return `tabIndex` correctly for contentEditable nodes;\n    // so if they don't have a tabindex attribute specifically set, assume it's 0.\n    if (\n      (/^(AUDIO|VIDEO|DETAILS)$/.test(node.tagName) ||\n        isContentEditable(node)) &&\n      !hasTabIndex(node)\n    ) {\n      return 0;\n    }\n  }\n\n  return node.tabIndex;\n};\n\n/**\n * Determine the tab index of a given node __for sort order purposes__.\n * @param {HTMLElement} node\n * @param {boolean} [isScope] True for a custom element with shadow root or slot that, by default,\n *  has tabIndex -1, but needs to be sorted by document order in order for its content to be\n *  inserted into the correct sort position.\n * @returns {number} Tab order (negative, 0, or positive number).\n */\nconst getSortOrderTabIndex = function (node, isScope) {\n  const tabIndex = getTabIndex(node);\n\n  if (tabIndex < 0 && isScope && !hasTabIndex(node)) {\n    return 0;\n  }\n\n  return tabIndex;\n};\n\nconst sortOrderedTabbables = function (a, b) {\n  return a.tabIndex === b.tabIndex\n    ? a.documentOrder - b.documentOrder\n    : a.tabIndex - b.tabIndex;\n};\n\nconst isInput = function (node) {\n  return node.tagName === 'INPUT';\n};\n\nconst isHiddenInput = function (node) {\n  return isInput(node) && node.type === 'hidden';\n};\n\nconst isDetailsWithSummary = function (node) {\n  const r =\n    node.tagName === 'DETAILS' &&\n    Array.prototype.slice\n      .apply(node.children)\n      .some((child) => child.tagName === 'SUMMARY');\n  return r;\n};\n\nconst getCheckedRadio = function (nodes, form) {\n  for (let i = 0; i < nodes.length; i++) {\n    if (nodes[i].checked && nodes[i].form === form) {\n      return nodes[i];\n    }\n  }\n};\n\nconst isTabbableRadio = function (node) {\n  if (!node.name) {\n    return true;\n  }\n  const radioScope = node.form || getRootNode(node);\n  const queryRadios = function (name) {\n    return radioScope.querySelectorAll(\n      'input[type=\"radio\"][name=\"' + name + '\"]'\n    );\n  };\n\n  let radioSet;\n  if (\n    typeof window !== 'undefined' &&\n    typeof window.CSS !== 'undefined' &&\n    typeof window.CSS.escape === 'function'\n  ) {\n    radioSet = queryRadios(window.CSS.escape(node.name));\n  } else {\n    try {\n      radioSet = queryRadios(node.name);\n    } catch (err) {\n      // eslint-disable-next-line no-console\n      console.error(\n        'Looks like you have a radio button with a name attribute containing invalid CSS selector characters and need the CSS.escape polyfill: %s',\n        err.message\n      );\n      return false;\n    }\n  }\n\n  const checked = getCheckedRadio(radioSet, node.form);\n  return !checked || checked === node;\n};\n\nconst isRadio = function (node) {\n  return isInput(node) && node.type === 'radio';\n};\n\nconst isNonTabbableRadio = function (node) {\n  return isRadio(node) && !isTabbableRadio(node);\n};\n\n// determines if a node is ultimately attached to the window's document\nconst isNodeAttached = function (node) {\n  // The root node is the shadow root if the node is in a shadow DOM; some document otherwise\n  //  (but NOT _the_ document; see second 'If' comment below for more).\n  // If rootNode is shadow root, it'll have a host, which is the element to which the shadow\n  //  is attached, and the one we need to check if it's in the document or not (because the\n  //  shadow, and all nodes it contains, is never considered in the document since shadows\n  //  behave like self-contained DOMs; but if the shadow's HOST, which is part of the document,\n  //  is hidden, or is not in the document itself but is detached, it will affect the shadow's\n  //  visibility, including all the nodes it contains). The host could be any normal node,\n  //  or a custom element (i.e. web component). Either way, that's the one that is considered\n  //  part of the document, not the shadow root, nor any of its children (i.e. the node being\n  //  tested).\n  // To further complicate things, we have to look all the way up until we find a shadow HOST\n  //  that is attached (or find none) because the node might be in nested shadows...\n  // If rootNode is not a shadow root, it won't have a host, and so rootNode should be the\n  //  document (per the docs) and while it's a Document-type object, that document does not\n  //  appear to be the same as the node's `ownerDocument` for some reason, so it's safer\n  //  to ignore the rootNode at this point, and use `node.ownerDocument`. Otherwise,\n  //  using `rootNode.contains(node)` will _always_ be true we'll get false-positives when\n  //  node is actually detached.\n  // NOTE: If `nodeRootHost` or `node` happens to be the `document` itself (which is possible\n  //  if a tabbable/focusable node was quickly added to the DOM, focused, and then removed\n  //  from the DOM as in https://github.com/focus-trap/focus-trap-react/issues/905), then\n  //  `ownerDocument` will be `null`, hence the optional chaining on it.\n  let nodeRoot = node && getRootNode(node);\n  let nodeRootHost = nodeRoot?.host;\n\n  // in some cases, a detached node will return itself as the root instead of a document or\n  //  shadow root object, in which case, we shouldn't try to look further up the host chain\n  let attached = false;\n  if (nodeRoot && nodeRoot !== node) {\n    attached = !!(\n      nodeRootHost?.ownerDocument?.contains(nodeRootHost) ||\n      node?.ownerDocument?.contains(node)\n    );\n\n    while (!attached && nodeRootHost) {\n      // since it's not attached and we have a root host, the node MUST be in a nested shadow DOM,\n      //  which means we need to get the host's host and check if that parent host is contained\n      //  in (i.e. attached to) the document\n      nodeRoot = getRootNode(nodeRootHost);\n      nodeRootHost = nodeRoot?.host;\n      attached = !!nodeRootHost?.ownerDocument?.contains(nodeRootHost);\n    }\n  }\n\n  return attached;\n};\n\nconst isZeroArea = function (node) {\n  const { width, height } = node.getBoundingClientRect();\n  return width === 0 && height === 0;\n};\nconst isHidden = function (node, { displayCheck, getShadowRoot }) {\n  // NOTE: visibility will be `undefined` if node is detached from the document\n  //  (see notes about this further down), which means we will consider it visible\n  //  (this is legacy behavior from a very long way back)\n  // NOTE: we check this regardless of `displayCheck=\"none\"` because this is a\n  //  _visibility_ check, not a _display_ check\n  if (getComputedStyle(node).visibility === 'hidden') {\n    return true;\n  }\n\n  const isDirectSummary = matches.call(node, 'details>summary:first-of-type');\n  const nodeUnderDetails = isDirectSummary ? node.parentElement : node;\n  if (matches.call(nodeUnderDetails, 'details:not([open]) *')) {\n    return true;\n  }\n\n  if (\n    !displayCheck ||\n    displayCheck === 'full' ||\n    displayCheck === 'legacy-full'\n  ) {\n    if (typeof getShadowRoot === 'function') {\n      // figure out if we should consider the node to be in an undisclosed shadow and use the\n      //  'non-zero-area' fallback\n      const originalNode = node;\n      while (node) {\n        const parentElement = node.parentElement;\n        const rootNode = getRootNode(node);\n        if (\n          parentElement &&\n          !parentElement.shadowRoot &&\n          getShadowRoot(parentElement) === true // check if there's an undisclosed shadow\n        ) {\n          // node has an undisclosed shadow which means we can only treat it as a black box, so we\n          //  fall back to a non-zero-area test\n          return isZeroArea(node);\n        } else if (node.assignedSlot) {\n          // iterate up slot\n          node = node.assignedSlot;\n        } else if (!parentElement && rootNode !== node.ownerDocument) {\n          // cross shadow boundary\n          node = rootNode.host;\n        } else {\n          // iterate up normal dom\n          node = parentElement;\n        }\n      }\n\n      node = originalNode;\n    }\n    // else, `getShadowRoot` might be true, but all that does is enable shadow DOM support\n    //  (i.e. it does not also presume that all nodes might have undisclosed shadows); or\n    //  it might be a falsy value, which means shadow DOM support is disabled\n\n    // Since we didn't find it sitting in an undisclosed shadow (or shadows are disabled)\n    //  now we can just test to see if it would normally be visible or not, provided it's\n    //  attached to the main document.\n    // NOTE: We must consider case where node is inside a shadow DOM and given directly to\n    //  `isTabbable()` or `isFocusable()` -- regardless of `getShadowRoot` option setting.\n\n    if (isNodeAttached(node)) {\n      // this works wherever the node is: if there's at least one client rect, it's\n      //  somehow displayed; it also covers the CSS 'display: contents' case where the\n      //  node itself is hidden in place of its contents; and there's no need to search\n      //  up the hierarchy either\n      return !node.getClientRects().length;\n    }\n\n    // Else, the node isn't attached to the document, which means the `getClientRects()`\n    //  API will __always__ return zero rects (this can happen, for example, if React\n    //  is used to render nodes onto a detached tree, as confirmed in this thread:\n    //  https://github.com/facebook/react/issues/9117#issuecomment-284228870)\n    //\n    // It also means that even window.getComputedStyle(node).display will return `undefined`\n    //  because styles are only computed for nodes that are in the document.\n    //\n    // NOTE: THIS HAS BEEN THE CASE FOR YEARS. It is not new, nor is it caused by tabbable\n    //  somehow. Though it was never stated officially, anyone who has ever used tabbable\n    //  APIs on nodes in detached containers has actually implicitly used tabbable in what\n    //  was later (as of v5.2.0 on Apr 9, 2021) called `displayCheck=\"none\"` mode -- essentially\n    //  considering __everything__ to be visible because of the innability to determine styles.\n    //\n    // v6.0.0: As of this major release, the default 'full' option __no longer treats detached\n    //  nodes as visible with the 'none' fallback.__\n    if (displayCheck !== 'legacy-full') {\n      return true; // hidden\n    }\n    // else, fallback to 'none' mode and consider the node visible\n  } else if (displayCheck === 'non-zero-area') {\n    // NOTE: Even though this tests that the node's client rect is non-zero to determine\n    //  whether it's displayed, and that a detached node will __always__ have a zero-area\n    //  client rect, we don't special-case for whether the node is attached or not. In\n    //  this mode, we do want to consider nodes that have a zero area to be hidden at all\n    //  times, and that includes attached or not.\n    return isZeroArea(node);\n  }\n\n  // visible, as far as we can tell, or per current `displayCheck=none` mode, we assume\n  //  it's visible\n  return false;\n};\n\n// form fields (nested) inside a disabled fieldset are not focusable/tabbable\n//  unless they are in the _first_ <legend> element of the top-most disabled\n//  fieldset\nconst isDisabledFromFieldset = function (node) {\n  if (/^(INPUT|BUTTON|SELECT|TEXTAREA)$/.test(node.tagName)) {\n    let parentNode = node.parentElement;\n    // check if `node` is contained in a disabled <fieldset>\n    while (parentNode) {\n      if (parentNode.tagName === 'FIELDSET' && parentNode.disabled) {\n        // look for the first <legend> among the children of the disabled <fieldset>\n        for (let i = 0; i < parentNode.children.length; i++) {\n          const child = parentNode.children.item(i);\n          // when the first <legend> (in document order) is found\n          if (child.tagName === 'LEGEND') {\n            // if its parent <fieldset> is not nested in another disabled <fieldset>,\n            // return whether `node` is a descendant of its first <legend>\n            return matches.call(parentNode, 'fieldset[disabled] *')\n              ? true\n              : !child.contains(node);\n          }\n        }\n        // the disabled <fieldset> containing `node` has no <legend>\n        return true;\n      }\n      parentNode = parentNode.parentElement;\n    }\n  }\n\n  // else, node's tabbable/focusable state should not be affected by a fieldset's\n  //  enabled/disabled state\n  return false;\n};\n\nconst isNodeMatchingSelectorFocusable = function (options, node) {\n  if (\n    node.disabled ||\n    // we must do an inert look up to filter out any elements inside an inert ancestor\n    //  because we're limited in the type of selectors we can use in JSDom (see related\n    //  note related to `candidateSelectors`)\n    isInert(node) ||\n    isHiddenInput(node) ||\n    isHidden(node, options) ||\n    // For a details element with a summary, the summary element gets the focus\n    isDetailsWithSummary(node) ||\n    isDisabledFromFieldset(node)\n  ) {\n    return false;\n  }\n  return true;\n};\n\nconst isNodeMatchingSelectorTabbable = function (options, node) {\n  if (\n    isNonTabbableRadio(node) ||\n    getTabIndex(node) < 0 ||\n    !isNodeMatchingSelectorFocusable(options, node)\n  ) {\n    return false;\n  }\n  return true;\n};\n\nconst isValidShadowRootTabbable = function (shadowHostNode) {\n  const tabIndex = parseInt(shadowHostNode.getAttribute('tabindex'), 10);\n  if (isNaN(tabIndex) || tabIndex >= 0) {\n    return true;\n  }\n  // If a custom element has an explicit negative tabindex,\n  // browsers will not allow tab targeting said element's children.\n  return false;\n};\n\n/**\n * @param {Array.<Element|CandidateScope>} candidates\n * @returns Element[]\n */\nconst sortByOrder = function (candidates) {\n  const regularTabbables = [];\n  const orderedTabbables = [];\n  candidates.forEach(function (item, i) {\n    const isScope = !!item.scopeParent;\n    const element = isScope ? item.scopeParent : item;\n    const candidateTabindex = getSortOrderTabIndex(element, isScope);\n    const elements = isScope ? sortByOrder(item.candidates) : element;\n    if (candidateTabindex === 0) {\n      isScope\n        ? regularTabbables.push(...elements)\n        : regularTabbables.push(element);\n    } else {\n      orderedTabbables.push({\n        documentOrder: i,\n        tabIndex: candidateTabindex,\n        item: item,\n        isScope: isScope,\n        content: elements,\n      });\n    }\n  });\n\n  return orderedTabbables\n    .sort(sortOrderedTabbables)\n    .reduce((acc, sortable) => {\n      sortable.isScope\n        ? acc.push(...sortable.content)\n        : acc.push(sortable.content);\n      return acc;\n    }, [])\n    .concat(regularTabbables);\n};\n\nconst tabbable = function (container, options) {\n  options = options || {};\n\n  let candidates;\n  if (options.getShadowRoot) {\n    candidates = getCandidatesIteratively(\n      [container],\n      options.includeContainer,\n      {\n        filter: isNodeMatchingSelectorTabbable.bind(null, options),\n        flatten: false,\n        getShadowRoot: options.getShadowRoot,\n        shadowRootFilter: isValidShadowRootTabbable,\n      }\n    );\n  } else {\n    candidates = getCandidates(\n      container,\n      options.includeContainer,\n      isNodeMatchingSelectorTabbable.bind(null, options)\n    );\n  }\n  return sortByOrder(candidates);\n};\n\nconst focusable = function (container, options) {\n  options = options || {};\n\n  let candidates;\n  if (options.getShadowRoot) {\n    candidates = getCandidatesIteratively(\n      [container],\n      options.includeContainer,\n      {\n        filter: isNodeMatchingSelectorFocusable.bind(null, options),\n        flatten: true,\n        getShadowRoot: options.getShadowRoot,\n      }\n    );\n  } else {\n    candidates = getCandidates(\n      container,\n      options.includeContainer,\n      isNodeMatchingSelectorFocusable.bind(null, options)\n    );\n  }\n\n  return candidates;\n};\n\nconst isTabbable = function (node, options) {\n  options = options || {};\n  if (!node) {\n    throw new Error('No node provided');\n  }\n  if (matches.call(node, candidateSelector) === false) {\n    return false;\n  }\n  return isNodeMatchingSelectorTabbable(options, node);\n};\n\nconst focusableCandidateSelector = /* #__PURE__ */ candidateSelectors\n  .concat('iframe')\n  .join(',');\n\nconst isFocusable = function (node, options) {\n  options = options || {};\n  if (!node) {\n    throw new Error('No node provided');\n  }\n  if (matches.call(node, focusableCandidateSelector) === false) {\n    return false;\n  }\n  return isNodeMatchingSelectorFocusable(options, node);\n};\n\nexport { tabbable, focusable, isTabbable, isFocusable, getTabIndex };\n","import * as React from 'react';\nimport { useLayoutEffect, useEffect, useRef } from 'react';\nimport { stopEvent, getDocument, isMouseLikePointerType, contains, activeElement, isSafari, isTypeableCombobox, isVirtualClick, isVirtualPointerEvent, getTarget, getPlatform, isTypeableElement, isReactEvent, isRootElement, isEventTargetWithin, isMac, getUserAgent } from '@floating-ui/react/utils';\nimport { floor, evaluate, max, min, round } from '@floating-ui/utils';\nimport { getComputedStyle, isElement, getNodeName, isHTMLElement, getWindow, isLastTraversableNode, getParentNode, isWebKit } from '@floating-ui/utils/dom';\nimport { tabbable, isTabbable } from 'tabbable';\nimport * as ReactDOM from 'react-dom';\nimport { getOverflowAncestors, useFloating as useFloating$1, offset, detectOverflow } from '@floating-ui/react-dom';\nexport { arrow, autoPlacement, autoUpdate, computePosition, detectOverflow, flip, getOverflowAncestors, hide, inline, limitShift, offset, platform, shift, size } from '@floating-ui/react-dom';\n\n/**\n * Merges an array of refs into a single memoized callback ref or `null`.\n * @see https://floating-ui.com/docs/react-utils#usemergerefs\n */\nfunction useMergeRefs(refs) {\n  return React.useMemo(() => {\n    if (refs.every(ref => ref == null)) {\n      return null;\n    }\n    return value => {\n      refs.forEach(ref => {\n        if (typeof ref === 'function') {\n          ref(value);\n        } else if (ref != null) {\n          ref.current = value;\n        }\n      });\n    };\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, refs);\n}\n\n// https://github.com/mui/material-ui/issues/41190#issuecomment-2040873379\nconst SafeReact = {\n  ...React\n};\n\nconst useInsertionEffect = SafeReact.useInsertionEffect;\nconst useSafeInsertionEffect = useInsertionEffect || (fn => fn());\nfunction useEffectEvent(callback) {\n  const ref = React.useRef(() => {\n    if (process.env.NODE_ENV !== \"production\") {\n      throw new Error('Cannot call an event handler while rendering.');\n    }\n  });\n  useSafeInsertionEffect(() => {\n    ref.current = callback;\n  });\n  return React.useCallback(function () {\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n    return ref.current == null ? void 0 : ref.current(...args);\n  }, []);\n}\n\nconst ARROW_UP = 'ArrowUp';\nconst ARROW_DOWN = 'ArrowDown';\nconst ARROW_LEFT = 'ArrowLeft';\nconst ARROW_RIGHT = 'ArrowRight';\nfunction isDifferentRow(index, cols, prevRow) {\n  return Math.floor(index / cols) !== prevRow;\n}\nfunction isIndexOutOfBounds(listRef, index) {\n  return index < 0 || index >= listRef.current.length;\n}\nfunction getMinIndex(listRef, disabledIndices) {\n  return findNonDisabledIndex(listRef, {\n    disabledIndices\n  });\n}\nfunction getMaxIndex(listRef, disabledIndices) {\n  return findNonDisabledIndex(listRef, {\n    decrement: true,\n    startingIndex: listRef.current.length,\n    disabledIndices\n  });\n}\nfunction findNonDisabledIndex(listRef, _temp) {\n  let {\n    startingIndex = -1,\n    decrement = false,\n    disabledIndices,\n    amount = 1\n  } = _temp === void 0 ? {} : _temp;\n  const list = listRef.current;\n  let index = startingIndex;\n  do {\n    index += decrement ? -amount : amount;\n  } while (index >= 0 && index <= list.length - 1 && isDisabled(list, index, disabledIndices));\n  return index;\n}\nfunction getGridNavigatedIndex(elementsRef, _ref) {\n  let {\n    event,\n    orientation,\n    loop,\n    rtl,\n    cols,\n    disabledIndices,\n    minIndex,\n    maxIndex,\n    prevIndex,\n    stopEvent: stop = false\n  } = _ref;\n  let nextIndex = prevIndex;\n  if (event.key === ARROW_UP) {\n    stop && stopEvent(event);\n    if (prevIndex === -1) {\n      nextIndex = maxIndex;\n    } else {\n      nextIndex = findNonDisabledIndex(elementsRef, {\n        startingIndex: nextIndex,\n        amount: cols,\n        decrement: true,\n        disabledIndices\n      });\n      if (loop && (prevIndex - cols < minIndex || nextIndex < 0)) {\n        const col = prevIndex % cols;\n        const maxCol = maxIndex % cols;\n        const offset = maxIndex - (maxCol - col);\n        if (maxCol === col) {\n          nextIndex = maxIndex;\n        } else {\n          nextIndex = maxCol > col ? offset : offset - cols;\n        }\n      }\n    }\n    if (isIndexOutOfBounds(elementsRef, nextIndex)) {\n      nextIndex = prevIndex;\n    }\n  }\n  if (event.key === ARROW_DOWN) {\n    stop && stopEvent(event);\n    if (prevIndex === -1) {\n      nextIndex = minIndex;\n    } else {\n      nextIndex = findNonDisabledIndex(elementsRef, {\n        startingIndex: prevIndex,\n        amount: cols,\n        disabledIndices\n      });\n      if (loop && prevIndex + cols > maxIndex) {\n        nextIndex = findNonDisabledIndex(elementsRef, {\n          startingIndex: prevIndex % cols - cols,\n          amount: cols,\n          disabledIndices\n        });\n      }\n    }\n    if (isIndexOutOfBounds(elementsRef, nextIndex)) {\n      nextIndex = prevIndex;\n    }\n  }\n\n  // Remains on the same row/column.\n  if (orientation === 'both') {\n    const prevRow = floor(prevIndex / cols);\n    if (event.key === (rtl ? ARROW_LEFT : ARROW_RIGHT)) {\n      stop && stopEvent(event);\n      if (prevIndex % cols !== cols - 1) {\n        nextIndex = findNonDisabledIndex(elementsRef, {\n          startingIndex: prevIndex,\n          disabledIndices\n        });\n        if (loop && isDifferentRow(nextIndex, cols, prevRow)) {\n          nextIndex = findNonDisabledIndex(elementsRef, {\n            startingIndex: prevIndex - prevIndex % cols - 1,\n            disabledIndices\n          });\n        }\n      } else if (loop) {\n        nextIndex = findNonDisabledIndex(elementsRef, {\n          startingIndex: prevIndex - prevIndex % cols - 1,\n          disabledIndices\n        });\n      }\n      if (isDifferentRow(nextIndex, cols, prevRow)) {\n        nextIndex = prevIndex;\n      }\n    }\n    if (event.key === (rtl ? ARROW_RIGHT : ARROW_LEFT)) {\n      stop && stopEvent(event);\n      if (prevIndex % cols !== 0) {\n        nextIndex = findNonDisabledIndex(elementsRef, {\n          startingIndex: prevIndex,\n          decrement: true,\n          disabledIndices\n        });\n        if (loop && isDifferentRow(nextIndex, cols, prevRow)) {\n          nextIndex = findNonDisabledIndex(elementsRef, {\n            startingIndex: prevIndex + (cols - prevIndex % cols),\n            decrement: true,\n            disabledIndices\n          });\n        }\n      } else if (loop) {\n        nextIndex = findNonDisabledIndex(elementsRef, {\n          startingIndex: prevIndex + (cols - prevIndex % cols),\n          decrement: true,\n          disabledIndices\n        });\n      }\n      if (isDifferentRow(nextIndex, cols, prevRow)) {\n        nextIndex = prevIndex;\n      }\n    }\n    const lastRow = floor(maxIndex / cols) === prevRow;\n    if (isIndexOutOfBounds(elementsRef, nextIndex)) {\n      if (loop && lastRow) {\n        nextIndex = event.key === (rtl ? ARROW_RIGHT : ARROW_LEFT) ? maxIndex : findNonDisabledIndex(elementsRef, {\n          startingIndex: prevIndex - prevIndex % cols - 1,\n          disabledIndices\n        });\n      } else {\n        nextIndex = prevIndex;\n      }\n    }\n  }\n  return nextIndex;\n}\n\n/** For each cell index, gets the item index that occupies that cell */\nfunction buildCellMap(sizes, cols, dense) {\n  const cellMap = [];\n  let startIndex = 0;\n  sizes.forEach((_ref2, index) => {\n    let {\n      width,\n      height\n    } = _ref2;\n    if (width > cols) {\n      if (process.env.NODE_ENV !== \"production\") {\n        throw new Error(\"[Floating UI]: Invalid grid - item width at index \" + index + \" is greater than grid columns\");\n      }\n    }\n    let itemPlaced = false;\n    if (dense) {\n      startIndex = 0;\n    }\n    while (!itemPlaced) {\n      const targetCells = [];\n      for (let i = 0; i < width; i++) {\n        for (let j = 0; j < height; j++) {\n          targetCells.push(startIndex + i + j * cols);\n        }\n      }\n      if (startIndex % cols + width <= cols && targetCells.every(cell => cellMap[cell] == null)) {\n        targetCells.forEach(cell => {\n          cellMap[cell] = index;\n        });\n        itemPlaced = true;\n      } else {\n        startIndex++;\n      }\n    }\n  });\n\n  // convert into a non-sparse array\n  return [...cellMap];\n}\n\n/** Gets cell index of an item's corner or -1 when index is -1. */\nfunction getCellIndexOfCorner(index, sizes, cellMap, cols, corner) {\n  if (index === -1) return -1;\n  const firstCellIndex = cellMap.indexOf(index);\n  const sizeItem = sizes[index];\n  switch (corner) {\n    case 'tl':\n      return firstCellIndex;\n    case 'tr':\n      if (!sizeItem) {\n        return firstCellIndex;\n      }\n      return firstCellIndex + sizeItem.width - 1;\n    case 'bl':\n      if (!sizeItem) {\n        return firstCellIndex;\n      }\n      return firstCellIndex + (sizeItem.height - 1) * cols;\n    case 'br':\n      return cellMap.lastIndexOf(index);\n  }\n}\n\n/** Gets all cell indices that correspond to the specified indices */\nfunction getCellIndices(indices, cellMap) {\n  return cellMap.flatMap((index, cellIndex) => indices.includes(index) ? [cellIndex] : []);\n}\nfunction isDisabled(list, index, disabledIndices) {\n  if (disabledIndices) {\n    return disabledIndices.includes(index);\n  }\n  const element = list[index];\n  return element == null || element.hasAttribute('disabled') || element.getAttribute('aria-disabled') === 'true';\n}\n\nvar index = typeof document !== 'undefined' ? useLayoutEffect : useEffect;\n\nfunction sortByDocumentPosition(a, b) {\n  const position = a.compareDocumentPosition(b);\n  if (position & Node.DOCUMENT_POSITION_FOLLOWING || position & Node.DOCUMENT_POSITION_CONTAINED_BY) {\n    return -1;\n  }\n  if (position & Node.DOCUMENT_POSITION_PRECEDING || position & Node.DOCUMENT_POSITION_CONTAINS) {\n    return 1;\n  }\n  return 0;\n}\nfunction areMapsEqual(map1, map2) {\n  if (map1.size !== map2.size) {\n    return false;\n  }\n  for (const [key, value] of map1.entries()) {\n    if (value !== map2.get(key)) {\n      return false;\n    }\n  }\n  return true;\n}\nconst FloatingListContext = /*#__PURE__*/React.createContext({\n  register: () => {},\n  unregister: () => {},\n  map: /*#__PURE__*/new Map(),\n  elementsRef: {\n    current: []\n  }\n});\n/**\n * Provides context for a list of items within the floating element.\n * @see https://floating-ui.com/docs/FloatingList\n */\nfunction FloatingList(props) {\n  const {\n    children,\n    elementsRef,\n    labelsRef\n  } = props;\n  const [map, setMap] = React.useState(() => new Map());\n  const register = React.useCallback(node => {\n    setMap(prevMap => new Map(prevMap).set(node, null));\n  }, []);\n  const unregister = React.useCallback(node => {\n    setMap(prevMap => {\n      const map = new Map(prevMap);\n      map.delete(node);\n      return map;\n    });\n  }, []);\n  index(() => {\n    const newMap = new Map(map);\n    const nodes = Array.from(newMap.keys()).sort(sortByDocumentPosition);\n    nodes.forEach((node, index) => {\n      newMap.set(node, index);\n    });\n    if (!areMapsEqual(map, newMap)) {\n      setMap(newMap);\n    }\n  }, [map]);\n  return /*#__PURE__*/React.createElement(FloatingListContext.Provider, {\n    value: React.useMemo(() => ({\n      register,\n      unregister,\n      map,\n      elementsRef,\n      labelsRef\n    }), [register, unregister, map, elementsRef, labelsRef])\n  }, children);\n}\n/**\n * Used to register a list item and its index (DOM position) in the\n * `FloatingList`.\n * @see https://floating-ui.com/docs/FloatingList#uselistitem\n */\nfunction useListItem(props) {\n  if (props === void 0) {\n    props = {};\n  }\n  const {\n    label\n  } = props;\n  const {\n    register,\n    unregister,\n    map,\n    elementsRef,\n    labelsRef\n  } = React.useContext(FloatingListContext);\n  const [index$1, setIndex] = React.useState(null);\n  const componentRef = React.useRef(null);\n  const ref = React.useCallback(node => {\n    componentRef.current = node;\n    if (index$1 !== null) {\n      elementsRef.current[index$1] = node;\n      if (labelsRef) {\n        var _node$textContent;\n        const isLabelDefined = label !== undefined;\n        labelsRef.current[index$1] = isLabelDefined ? label : (_node$textContent = node == null ? void 0 : node.textContent) != null ? _node$textContent : null;\n      }\n    }\n  }, [index$1, elementsRef, labelsRef, label]);\n  index(() => {\n    const node = componentRef.current;\n    if (node) {\n      register(node);\n      return () => {\n        unregister(node);\n      };\n    }\n  }, [register, unregister]);\n  index(() => {\n    const index = componentRef.current ? map.get(componentRef.current) : null;\n    if (index != null) {\n      setIndex(index);\n    }\n  }, [map]);\n  return React.useMemo(() => ({\n    ref,\n    index: index$1 == null ? -1 : index$1\n  }), [index$1, ref]);\n}\n\nfunction renderJsx(render, computedProps) {\n  if (typeof render === 'function') {\n    return render(computedProps);\n  }\n  if (render) {\n    return /*#__PURE__*/React.cloneElement(render, computedProps);\n  }\n  return /*#__PURE__*/React.createElement(\"div\", computedProps);\n}\nconst CompositeContext = /*#__PURE__*/React.createContext({\n  activeIndex: 0,\n  onNavigate: () => {}\n});\nconst horizontalKeys = [ARROW_LEFT, ARROW_RIGHT];\nconst verticalKeys = [ARROW_UP, ARROW_DOWN];\nconst allKeys = [...horizontalKeys, ...verticalKeys];\n\n/**\n * Creates a single tab stop whose items are navigated by arrow keys, which\n * provides list navigation outside of floating element contexts.\n *\n * This is useful to enable navigation of a list of items that aren’t part of a\n * floating element. A menubar is an example of a composite, with each reference\n * element being an item.\n * @see https://floating-ui.com/docs/Composite\n */\nconst Composite = /*#__PURE__*/React.forwardRef(function Composite(props, forwardedRef) {\n  const {\n    render,\n    orientation = 'both',\n    loop = true,\n    rtl = false,\n    cols = 1,\n    disabledIndices,\n    activeIndex: externalActiveIndex,\n    onNavigate: externalSetActiveIndex,\n    itemSizes,\n    dense = false,\n    ...domProps\n  } = props;\n  const [internalActiveIndex, internalSetActiveIndex] = React.useState(0);\n  const activeIndex = externalActiveIndex != null ? externalActiveIndex : internalActiveIndex;\n  const onNavigate = useEffectEvent(externalSetActiveIndex != null ? externalSetActiveIndex : internalSetActiveIndex);\n  const elementsRef = React.useRef([]);\n  const renderElementProps = render && typeof render !== 'function' ? render.props : {};\n  const contextValue = React.useMemo(() => ({\n    activeIndex,\n    onNavigate\n  }), [activeIndex, onNavigate]);\n  const isGrid = cols > 1;\n  function handleKeyDown(event) {\n    if (!allKeys.includes(event.key)) return;\n    let nextIndex = activeIndex;\n    const minIndex = getMinIndex(elementsRef, disabledIndices);\n    const maxIndex = getMaxIndex(elementsRef, disabledIndices);\n    const horizontalEndKey = rtl ? ARROW_LEFT : ARROW_RIGHT;\n    const horizontalStartKey = rtl ? ARROW_RIGHT : ARROW_LEFT;\n    if (isGrid) {\n      const sizes = itemSizes || Array.from({\n        length: elementsRef.current.length\n      }, () => ({\n        width: 1,\n        height: 1\n      }));\n      // To calculate movements on the grid, we use hypothetical cell indices\n      // as if every item was 1x1, then convert back to real indices.\n      const cellMap = buildCellMap(sizes, cols, dense);\n      const minGridIndex = cellMap.findIndex(index => index != null && !isDisabled(elementsRef.current, index, disabledIndices));\n      // last enabled index\n      const maxGridIndex = cellMap.reduce((foundIndex, index, cellIndex) => index != null && !isDisabled(elementsRef.current, index, disabledIndices) ? cellIndex : foundIndex, -1);\n      const maybeNextIndex = cellMap[getGridNavigatedIndex({\n        current: cellMap.map(itemIndex => itemIndex ? elementsRef.current[itemIndex] : null)\n      }, {\n        event,\n        orientation,\n        loop,\n        rtl,\n        cols,\n        // treat undefined (empty grid spaces) as disabled indices so we\n        // don't end up in them\n        disabledIndices: getCellIndices([...(disabledIndices || elementsRef.current.map((_, index) => isDisabled(elementsRef.current, index) ? index : undefined)), undefined], cellMap),\n        minIndex: minGridIndex,\n        maxIndex: maxGridIndex,\n        prevIndex: getCellIndexOfCorner(activeIndex > maxIndex ? minIndex : activeIndex, sizes, cellMap, cols,\n        // use a corner matching the edge closest to the direction we're\n        // moving in so we don't end up in the same item. Prefer\n        // top/left over bottom/right.\n        event.key === ARROW_DOWN ? 'bl' : event.key === horizontalEndKey ? 'tr' : 'tl')\n      })];\n      if (maybeNextIndex != null) {\n        nextIndex = maybeNextIndex;\n      }\n    }\n    const toEndKeys = {\n      horizontal: [horizontalEndKey],\n      vertical: [ARROW_DOWN],\n      both: [horizontalEndKey, ARROW_DOWN]\n    }[orientation];\n    const toStartKeys = {\n      horizontal: [horizontalStartKey],\n      vertical: [ARROW_UP],\n      both: [horizontalStartKey, ARROW_UP]\n    }[orientation];\n    const preventedKeys = isGrid ? allKeys : {\n      horizontal: horizontalKeys,\n      vertical: verticalKeys,\n      both: allKeys\n    }[orientation];\n    if (nextIndex === activeIndex && [...toEndKeys, ...toStartKeys].includes(event.key)) {\n      if (loop && nextIndex === maxIndex && toEndKeys.includes(event.key)) {\n        nextIndex = minIndex;\n      } else if (loop && nextIndex === minIndex && toStartKeys.includes(event.key)) {\n        nextIndex = maxIndex;\n      } else {\n        nextIndex = findNonDisabledIndex(elementsRef, {\n          startingIndex: nextIndex,\n          decrement: toStartKeys.includes(event.key),\n          disabledIndices\n        });\n      }\n    }\n    if (nextIndex !== activeIndex && !isIndexOutOfBounds(elementsRef, nextIndex)) {\n      var _elementsRef$current$;\n      event.stopPropagation();\n      if (preventedKeys.includes(event.key)) {\n        event.preventDefault();\n      }\n      onNavigate(nextIndex);\n      (_elementsRef$current$ = elementsRef.current[nextIndex]) == null || _elementsRef$current$.focus();\n    }\n  }\n  const computedProps = {\n    ...domProps,\n    ...renderElementProps,\n    ref: forwardedRef,\n    'aria-orientation': orientation === 'both' ? undefined : orientation,\n    onKeyDown(e) {\n      domProps.onKeyDown == null || domProps.onKeyDown(e);\n      renderElementProps.onKeyDown == null || renderElementProps.onKeyDown(e);\n      handleKeyDown(e);\n    }\n  };\n  return /*#__PURE__*/React.createElement(CompositeContext.Provider, {\n    value: contextValue\n  }, /*#__PURE__*/React.createElement(FloatingList, {\n    elementsRef: elementsRef\n  }, renderJsx(render, computedProps)));\n});\n/**\n * @see https://floating-ui.com/docs/Composite\n */\nconst CompositeItem = /*#__PURE__*/React.forwardRef(function CompositeItem(props, forwardedRef) {\n  const {\n    render,\n    ...domProps\n  } = props;\n  const renderElementProps = render && typeof render !== 'function' ? render.props : {};\n  const {\n    activeIndex,\n    onNavigate\n  } = React.useContext(CompositeContext);\n  const {\n    ref,\n    index\n  } = useListItem();\n  const mergedRef = useMergeRefs([ref, forwardedRef, renderElementProps.ref]);\n  const isActive = activeIndex === index;\n  const computedProps = {\n    ...domProps,\n    ...renderElementProps,\n    ref: mergedRef,\n    tabIndex: isActive ? 0 : -1,\n    'data-active': isActive ? '' : undefined,\n    onFocus(e) {\n      domProps.onFocus == null || domProps.onFocus(e);\n      renderElementProps.onFocus == null || renderElementProps.onFocus(e);\n      onNavigate(index);\n    }\n  };\n  return renderJsx(render, computedProps);\n});\n\nfunction _extends() {\n  _extends = Object.assign ? Object.assign.bind() : function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n    return target;\n  };\n  return _extends.apply(this, arguments);\n}\n\nlet serverHandoffComplete = false;\nlet count = 0;\nconst genId = () => // Ensure the id is unique with multiple independent versions of Floating UI\n// on <React 18\n\"floating-ui-\" + Math.random().toString(36).slice(2, 6) + count++;\nfunction useFloatingId() {\n  const [id, setId] = React.useState(() => serverHandoffComplete ? genId() : undefined);\n  index(() => {\n    if (id == null) {\n      setId(genId());\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, []);\n  React.useEffect(() => {\n    serverHandoffComplete = true;\n  }, []);\n  return id;\n}\nconst useReactId = SafeReact.useId;\n\n/**\n * Uses React 18's built-in `useId()` when available, or falls back to a\n * slightly less performant (requiring a double render) implementation for\n * earlier React versions.\n * @see https://floating-ui.com/docs/react-utils#useid\n */\nconst useId = useReactId || useFloatingId;\n\nlet devMessageSet;\nif (process.env.NODE_ENV !== \"production\") {\n  devMessageSet = /*#__PURE__*/new Set();\n}\nfunction warn() {\n  var _devMessageSet;\n  for (var _len = arguments.length, messages = new Array(_len), _key = 0; _key < _len; _key++) {\n    messages[_key] = arguments[_key];\n  }\n  const message = \"Floating UI: \" + messages.join(' ');\n  if (!((_devMessageSet = devMessageSet) != null && _devMessageSet.has(message))) {\n    var _devMessageSet2;\n    (_devMessageSet2 = devMessageSet) == null || _devMessageSet2.add(message);\n    console.warn(message);\n  }\n}\nfunction error() {\n  var _devMessageSet3;\n  for (var _len2 = arguments.length, messages = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n    messages[_key2] = arguments[_key2];\n  }\n  const message = \"Floating UI: \" + messages.join(' ');\n  if (!((_devMessageSet3 = devMessageSet) != null && _devMessageSet3.has(message))) {\n    var _devMessageSet4;\n    (_devMessageSet4 = devMessageSet) == null || _devMessageSet4.add(message);\n    console.error(message);\n  }\n}\n\n/**\n * Renders a pointing arrow triangle.\n * @see https://floating-ui.com/docs/FloatingArrow\n */\nconst FloatingArrow = /*#__PURE__*/React.forwardRef(function FloatingArrow(props, ref) {\n  const {\n    context: {\n      placement,\n      elements: {\n        floating\n      },\n      middlewareData: {\n        arrow,\n        shift\n      }\n    },\n    width = 14,\n    height = 7,\n    tipRadius = 0,\n    strokeWidth = 0,\n    staticOffset,\n    stroke,\n    d,\n    style: {\n      transform,\n      ...restStyle\n    } = {},\n    ...rest\n  } = props;\n  if (process.env.NODE_ENV !== \"production\") {\n    if (!ref) {\n      warn('The `ref` prop is required for `FloatingArrow`.');\n    }\n  }\n  const clipPathId = useId();\n  const [isRTL, setIsRTL] = React.useState(false);\n\n  // https://github.com/floating-ui/floating-ui/issues/2932\n  index(() => {\n    if (!floating) return;\n    const isRTL = getComputedStyle(floating).direction === 'rtl';\n    if (isRTL) {\n      setIsRTL(true);\n    }\n  }, [floating]);\n  if (!floating) {\n    return null;\n  }\n  const [side, alignment] = placement.split('-');\n  const isVerticalSide = side === 'top' || side === 'bottom';\n  let computedStaticOffset = staticOffset;\n  if (isVerticalSide && shift != null && shift.x || !isVerticalSide && shift != null && shift.y) {\n    computedStaticOffset = null;\n  }\n\n  // Strokes must be double the border width, this ensures the stroke's width\n  // works as you'd expect.\n  const computedStrokeWidth = strokeWidth * 2;\n  const halfStrokeWidth = computedStrokeWidth / 2;\n  const svgX = width / 2 * (tipRadius / -8 + 1);\n  const svgY = height / 2 * tipRadius / 4;\n  const isCustomShape = !!d;\n  const yOffsetProp = computedStaticOffset && alignment === 'end' ? 'bottom' : 'top';\n  let xOffsetProp = computedStaticOffset && alignment === 'end' ? 'right' : 'left';\n  if (computedStaticOffset && isRTL) {\n    xOffsetProp = alignment === 'end' ? 'left' : 'right';\n  }\n  const arrowX = (arrow == null ? void 0 : arrow.x) != null ? computedStaticOffset || arrow.x : '';\n  const arrowY = (arrow == null ? void 0 : arrow.y) != null ? computedStaticOffset || arrow.y : '';\n  const dValue = d || 'M0,0' + (\" H\" + width) + (\" L\" + (width - svgX) + \",\" + (height - svgY)) + (\" Q\" + width / 2 + \",\" + height + \" \" + svgX + \",\" + (height - svgY)) + ' Z';\n  const rotation = {\n    top: isCustomShape ? 'rotate(180deg)' : '',\n    left: isCustomShape ? 'rotate(90deg)' : 'rotate(-90deg)',\n    bottom: isCustomShape ? '' : 'rotate(180deg)',\n    right: isCustomShape ? 'rotate(-90deg)' : 'rotate(90deg)'\n  }[side];\n  return /*#__PURE__*/React.createElement(\"svg\", _extends({}, rest, {\n    \"aria-hidden\": true,\n    ref: ref,\n    width: isCustomShape ? width : width + computedStrokeWidth,\n    height: width,\n    viewBox: \"0 0 \" + width + \" \" + (height > width ? height : width),\n    style: {\n      position: 'absolute',\n      pointerEvents: 'none',\n      [xOffsetProp]: arrowX,\n      [yOffsetProp]: arrowY,\n      [side]: isVerticalSide || isCustomShape ? '100%' : \"calc(100% - \" + computedStrokeWidth / 2 + \"px)\",\n      transform: [rotation, transform].filter(t => !!t).join(' '),\n      ...restStyle\n    }\n  }), computedStrokeWidth > 0 && /*#__PURE__*/React.createElement(\"path\", {\n    clipPath: \"url(#\" + clipPathId + \")\",\n    fill: \"none\",\n    stroke: stroke\n    // Account for the stroke on the fill path rendered below.\n    ,\n    strokeWidth: computedStrokeWidth + (d ? 0 : 1),\n    d: dValue\n  }), /*#__PURE__*/React.createElement(\"path\", {\n    stroke: computedStrokeWidth && !d ? rest.fill : 'none',\n    d: dValue\n  }), /*#__PURE__*/React.createElement(\"clipPath\", {\n    id: clipPathId\n  }, /*#__PURE__*/React.createElement(\"rect\", {\n    x: -halfStrokeWidth,\n    y: halfStrokeWidth * (isCustomShape ? -1 : 1),\n    width: width + computedStrokeWidth,\n    height: width\n  })));\n});\n\nfunction createPubSub() {\n  const map = new Map();\n  return {\n    emit(event, data) {\n      var _map$get;\n      (_map$get = map.get(event)) == null || _map$get.forEach(handler => handler(data));\n    },\n    on(event, listener) {\n      map.set(event, [...(map.get(event) || []), listener]);\n    },\n    off(event, listener) {\n      var _map$get2;\n      map.set(event, ((_map$get2 = map.get(event)) == null ? void 0 : _map$get2.filter(l => l !== listener)) || []);\n    }\n  };\n}\n\nconst FloatingNodeContext = /*#__PURE__*/React.createContext(null);\nconst FloatingTreeContext = /*#__PURE__*/React.createContext(null);\n\n/**\n * Returns the parent node id for nested floating elements, if available.\n * Returns `null` for top-level floating elements.\n */\nconst useFloatingParentNodeId = () => {\n  var _React$useContext;\n  return ((_React$useContext = React.useContext(FloatingNodeContext)) == null ? void 0 : _React$useContext.id) || null;\n};\n\n/**\n * Returns the nearest floating tree context, if available.\n */\nconst useFloatingTree = () => React.useContext(FloatingTreeContext);\n\n/**\n * Registers a node into the `FloatingTree`, returning its id.\n * @see https://floating-ui.com/docs/FloatingTree\n */\nfunction useFloatingNodeId(customParentId) {\n  const id = useId();\n  const tree = useFloatingTree();\n  const reactParentId = useFloatingParentNodeId();\n  const parentId = customParentId || reactParentId;\n  index(() => {\n    if (!id) return;\n    const node = {\n      id,\n      parentId\n    };\n    tree == null || tree.addNode(node);\n    return () => {\n      tree == null || tree.removeNode(node);\n    };\n  }, [tree, id, parentId]);\n  return id;\n}\n/**\n * Provides parent node context for nested floating elements.\n * @see https://floating-ui.com/docs/FloatingTree\n */\nfunction FloatingNode(props) {\n  const {\n    children,\n    id\n  } = props;\n  const parentId = useFloatingParentNodeId();\n  return /*#__PURE__*/React.createElement(FloatingNodeContext.Provider, {\n    value: React.useMemo(() => ({\n      id,\n      parentId\n    }), [id, parentId])\n  }, children);\n}\n/**\n * Provides context for nested floating elements when they are not children of\n * each other on the DOM.\n * This is not necessary in all cases, except when there must be explicit communication between parent and child floating elements. It is necessary for:\n * - The `bubbles` option in the `useDismiss()` Hook\n * - Nested virtual list navigation\n * - Nested floating elements that each open on hover\n * - Custom communication between parent and child floating elements\n * @see https://floating-ui.com/docs/FloatingTree\n */\nfunction FloatingTree(props) {\n  const {\n    children\n  } = props;\n  const nodesRef = React.useRef([]);\n  const addNode = React.useCallback(node => {\n    nodesRef.current = [...nodesRef.current, node];\n  }, []);\n  const removeNode = React.useCallback(node => {\n    nodesRef.current = nodesRef.current.filter(n => n !== node);\n  }, []);\n  const events = React.useState(() => createPubSub())[0];\n  return /*#__PURE__*/React.createElement(FloatingTreeContext.Provider, {\n    value: React.useMemo(() => ({\n      nodesRef,\n      addNode,\n      removeNode,\n      events\n    }), [addNode, removeNode, events])\n  }, children);\n}\n\nfunction createAttribute(name) {\n  return \"data-floating-ui-\" + name;\n}\n\nfunction useLatestRef(value) {\n  const ref = useRef(value);\n  index(() => {\n    ref.current = value;\n  });\n  return ref;\n}\n\nconst safePolygonIdentifier = /*#__PURE__*/createAttribute('safe-polygon');\nfunction getDelay(value, prop, pointerType) {\n  if (pointerType && !isMouseLikePointerType(pointerType)) {\n    return 0;\n  }\n  if (typeof value === 'number') {\n    return value;\n  }\n  return value == null ? void 0 : value[prop];\n}\n/**\n * Opens the floating element while hovering over the reference element, like\n * CSS `:hover`.\n * @see https://floating-ui.com/docs/useHover\n */\nfunction useHover(context, props) {\n  if (props === void 0) {\n    props = {};\n  }\n  const {\n    open,\n    onOpenChange,\n    dataRef,\n    events,\n    elements\n  } = context;\n  const {\n    enabled = true,\n    delay = 0,\n    handleClose = null,\n    mouseOnly = false,\n    restMs = 0,\n    move = true\n  } = props;\n  const tree = useFloatingTree();\n  const parentId = useFloatingParentNodeId();\n  const handleCloseRef = useLatestRef(handleClose);\n  const delayRef = useLatestRef(delay);\n  const openRef = useLatestRef(open);\n  const pointerTypeRef = React.useRef();\n  const timeoutRef = React.useRef(-1);\n  const handlerRef = React.useRef();\n  const restTimeoutRef = React.useRef(-1);\n  const blockMouseMoveRef = React.useRef(true);\n  const performedPointerEventsMutationRef = React.useRef(false);\n  const unbindMouseMoveRef = React.useRef(() => {});\n  const restTimeoutPendingRef = React.useRef(false);\n  const isHoverOpen = React.useCallback(() => {\n    var _dataRef$current$open;\n    const type = (_dataRef$current$open = dataRef.current.openEvent) == null ? void 0 : _dataRef$current$open.type;\n    return (type == null ? void 0 : type.includes('mouse')) && type !== 'mousedown';\n  }, [dataRef]);\n\n  // When closing before opening, clear the delay timeouts to cancel it\n  // from showing.\n  React.useEffect(() => {\n    if (!enabled) return;\n    function onOpenChange(_ref) {\n      let {\n        open\n      } = _ref;\n      if (!open) {\n        clearTimeout(timeoutRef.current);\n        clearTimeout(restTimeoutRef.current);\n        blockMouseMoveRef.current = true;\n        restTimeoutPendingRef.current = false;\n      }\n    }\n    events.on('openchange', onOpenChange);\n    return () => {\n      events.off('openchange', onOpenChange);\n    };\n  }, [enabled, events]);\n  React.useEffect(() => {\n    if (!enabled) return;\n    if (!handleCloseRef.current) return;\n    if (!open) return;\n    function onLeave(event) {\n      if (isHoverOpen()) {\n        onOpenChange(false, event, 'hover');\n      }\n    }\n    const html = getDocument(elements.floating).documentElement;\n    html.addEventListener('mouseleave', onLeave);\n    return () => {\n      html.removeEventListener('mouseleave', onLeave);\n    };\n  }, [elements.floating, open, onOpenChange, enabled, handleCloseRef, isHoverOpen]);\n  const closeWithDelay = React.useCallback(function (event, runElseBranch, reason) {\n    if (runElseBranch === void 0) {\n      runElseBranch = true;\n    }\n    if (reason === void 0) {\n      reason = 'hover';\n    }\n    const closeDelay = getDelay(delayRef.current, 'close', pointerTypeRef.current);\n    if (closeDelay && !handlerRef.current) {\n      clearTimeout(timeoutRef.current);\n      timeoutRef.current = window.setTimeout(() => onOpenChange(false, event, reason), closeDelay);\n    } else if (runElseBranch) {\n      clearTimeout(timeoutRef.current);\n      onOpenChange(false, event, reason);\n    }\n  }, [delayRef, onOpenChange]);\n  const cleanupMouseMoveHandler = useEffectEvent(() => {\n    unbindMouseMoveRef.current();\n    handlerRef.current = undefined;\n  });\n  const clearPointerEvents = useEffectEvent(() => {\n    if (performedPointerEventsMutationRef.current) {\n      const body = getDocument(elements.floating).body;\n      body.style.pointerEvents = '';\n      body.removeAttribute(safePolygonIdentifier);\n      performedPointerEventsMutationRef.current = false;\n    }\n  });\n  const isClickLikeOpenEvent = useEffectEvent(() => {\n    return dataRef.current.openEvent ? ['click', 'mousedown'].includes(dataRef.current.openEvent.type) : false;\n  });\n\n  // Registering the mouse events on the reference directly to bypass React's\n  // delegation system. If the cursor was on a disabled element and then entered\n  // the reference (no gap), `mouseenter` doesn't fire in the delegation system.\n  React.useEffect(() => {\n    if (!enabled) return;\n    function onMouseEnter(event) {\n      clearTimeout(timeoutRef.current);\n      blockMouseMoveRef.current = false;\n      if (mouseOnly && !isMouseLikePointerType(pointerTypeRef.current) || restMs > 0 && !getDelay(delayRef.current, 'open')) {\n        return;\n      }\n      const openDelay = getDelay(delayRef.current, 'open', pointerTypeRef.current);\n      if (openDelay) {\n        timeoutRef.current = window.setTimeout(() => {\n          if (!openRef.current) {\n            onOpenChange(true, event, 'hover');\n          }\n        }, openDelay);\n      } else if (!open) {\n        onOpenChange(true, event, 'hover');\n      }\n    }\n    function onMouseLeave(event) {\n      if (isClickLikeOpenEvent()) return;\n      unbindMouseMoveRef.current();\n      const doc = getDocument(elements.floating);\n      clearTimeout(restTimeoutRef.current);\n      restTimeoutPendingRef.current = false;\n      if (handleCloseRef.current && dataRef.current.floatingContext) {\n        // Prevent clearing `onScrollMouseLeave` timeout.\n        if (!open) {\n          clearTimeout(timeoutRef.current);\n        }\n        handlerRef.current = handleCloseRef.current({\n          ...dataRef.current.floatingContext,\n          tree,\n          x: event.clientX,\n          y: event.clientY,\n          onClose() {\n            clearPointerEvents();\n            cleanupMouseMoveHandler();\n            if (!isClickLikeOpenEvent()) {\n              closeWithDelay(event, true, 'safe-polygon');\n            }\n          }\n        });\n        const handler = handlerRef.current;\n        doc.addEventListener('mousemove', handler);\n        unbindMouseMoveRef.current = () => {\n          doc.removeEventListener('mousemove', handler);\n        };\n        return;\n      }\n\n      // Allow interactivity without `safePolygon` on touch devices. With a\n      // pointer, a short close delay is an alternative, so it should work\n      // consistently.\n      const shouldClose = pointerTypeRef.current === 'touch' ? !contains(elements.floating, event.relatedTarget) : true;\n      if (shouldClose) {\n        closeWithDelay(event);\n      }\n    }\n\n    // Ensure the floating element closes after scrolling even if the pointer\n    // did not move.\n    // https://github.com/floating-ui/floating-ui/discussions/1692\n    function onScrollMouseLeave(event) {\n      if (isClickLikeOpenEvent()) return;\n      if (!dataRef.current.floatingContext) return;\n      handleCloseRef.current == null || handleCloseRef.current({\n        ...dataRef.current.floatingContext,\n        tree,\n        x: event.clientX,\n        y: event.clientY,\n        onClose() {\n          clearPointerEvents();\n          cleanupMouseMoveHandler();\n          if (!isClickLikeOpenEvent()) {\n            closeWithDelay(event);\n          }\n        }\n      })(event);\n    }\n    if (isElement(elements.domReference)) {\n      var _elements$floating;\n      const ref = elements.domReference;\n      open && ref.addEventListener('mouseleave', onScrollMouseLeave);\n      (_elements$floating = elements.floating) == null || _elements$floating.addEventListener('mouseleave', onScrollMouseLeave);\n      move && ref.addEventListener('mousemove', onMouseEnter, {\n        once: true\n      });\n      ref.addEventListener('mouseenter', onMouseEnter);\n      ref.addEventListener('mouseleave', onMouseLeave);\n      return () => {\n        var _elements$floating2;\n        open && ref.removeEventListener('mouseleave', onScrollMouseLeave);\n        (_elements$floating2 = elements.floating) == null || _elements$floating2.removeEventListener('mouseleave', onScrollMouseLeave);\n        move && ref.removeEventListener('mousemove', onMouseEnter);\n        ref.removeEventListener('mouseenter', onMouseEnter);\n        ref.removeEventListener('mouseleave', onMouseLeave);\n      };\n    }\n  }, [elements, enabled, context, mouseOnly, restMs, move, closeWithDelay, cleanupMouseMoveHandler, clearPointerEvents, onOpenChange, open, openRef, tree, delayRef, handleCloseRef, dataRef, isClickLikeOpenEvent]);\n\n  // Block pointer-events of every element other than the reference and floating\n  // while the floating element is open and has a `handleClose` handler. Also\n  // handles nested floating elements.\n  // https://github.com/floating-ui/floating-ui/issues/1722\n  index(() => {\n    var _handleCloseRef$curre;\n    if (!enabled) return;\n    if (open && (_handleCloseRef$curre = handleCloseRef.current) != null && _handleCloseRef$curre.__options.blockPointerEvents && isHoverOpen()) {\n      performedPointerEventsMutationRef.current = true;\n      const floatingEl = elements.floating;\n      if (isElement(elements.domReference) && floatingEl) {\n        var _tree$nodesRef$curren;\n        const body = getDocument(elements.floating).body;\n        body.setAttribute(safePolygonIdentifier, '');\n        const ref = elements.domReference;\n        const parentFloating = tree == null || (_tree$nodesRef$curren = tree.nodesRef.current.find(node => node.id === parentId)) == null || (_tree$nodesRef$curren = _tree$nodesRef$curren.context) == null ? void 0 : _tree$nodesRef$curren.elements.floating;\n        if (parentFloating) {\n          parentFloating.style.pointerEvents = '';\n        }\n        body.style.pointerEvents = 'none';\n        ref.style.pointerEvents = 'auto';\n        floatingEl.style.pointerEvents = 'auto';\n        return () => {\n          body.style.pointerEvents = '';\n          ref.style.pointerEvents = '';\n          floatingEl.style.pointerEvents = '';\n        };\n      }\n    }\n  }, [enabled, open, parentId, elements, tree, handleCloseRef, isHoverOpen]);\n  index(() => {\n    if (!open) {\n      pointerTypeRef.current = undefined;\n      restTimeoutPendingRef.current = false;\n      cleanupMouseMoveHandler();\n      clearPointerEvents();\n    }\n  }, [open, cleanupMouseMoveHandler, clearPointerEvents]);\n  React.useEffect(() => {\n    return () => {\n      cleanupMouseMoveHandler();\n      clearTimeout(timeoutRef.current);\n      clearTimeout(restTimeoutRef.current);\n      clearPointerEvents();\n    };\n  }, [enabled, elements.domReference, cleanupMouseMoveHandler, clearPointerEvents]);\n  const reference = React.useMemo(() => {\n    function setPointerRef(event) {\n      pointerTypeRef.current = event.pointerType;\n    }\n    return {\n      onPointerDown: setPointerRef,\n      onPointerEnter: setPointerRef,\n      onMouseMove(event) {\n        const {\n          nativeEvent\n        } = event;\n        function handleMouseMove() {\n          if (!blockMouseMoveRef.current && !openRef.current) {\n            onOpenChange(true, nativeEvent, 'hover');\n          }\n        }\n        if (mouseOnly && !isMouseLikePointerType(pointerTypeRef.current)) {\n          return;\n        }\n        if (open || restMs === 0) {\n          return;\n        }\n\n        // Ignore insignificant movements to account for tremors.\n        if (restTimeoutPendingRef.current && event.movementX ** 2 + event.movementY ** 2 < 2) {\n          return;\n        }\n        clearTimeout(restTimeoutRef.current);\n        if (pointerTypeRef.current === 'touch') {\n          handleMouseMove();\n        } else {\n          restTimeoutPendingRef.current = true;\n          restTimeoutRef.current = window.setTimeout(handleMouseMove, restMs);\n        }\n      }\n    };\n  }, [mouseOnly, onOpenChange, open, openRef, restMs]);\n  const floating = React.useMemo(() => ({\n    onMouseEnter() {\n      clearTimeout(timeoutRef.current);\n    },\n    onMouseLeave(event) {\n      if (!isClickLikeOpenEvent()) {\n        closeWithDelay(event.nativeEvent, false);\n      }\n    }\n  }), [closeWithDelay, isClickLikeOpenEvent]);\n  return React.useMemo(() => enabled ? {\n    reference,\n    floating\n  } : {}, [enabled, reference, floating]);\n}\n\nconst NOOP = () => {};\nconst FloatingDelayGroupContext = /*#__PURE__*/React.createContext({\n  delay: 0,\n  initialDelay: 0,\n  timeoutMs: 0,\n  currentId: null,\n  setCurrentId: NOOP,\n  setState: NOOP,\n  isInstantPhase: false\n});\n\n/**\n * @deprecated\n * Use the return value of `useDelayGroup()` instead.\n */\nconst useDelayGroupContext = () => React.useContext(FloatingDelayGroupContext);\n/**\n * Provides context for a group of floating elements that should share a\n * `delay`.\n * @see https://floating-ui.com/docs/FloatingDelayGroup\n */\nfunction FloatingDelayGroup(props) {\n  const {\n    children,\n    delay,\n    timeoutMs = 0\n  } = props;\n  const [state, setState] = React.useReducer((prev, next) => ({\n    ...prev,\n    ...next\n  }), {\n    delay,\n    timeoutMs,\n    initialDelay: delay,\n    currentId: null,\n    isInstantPhase: false\n  });\n  const initialCurrentIdRef = React.useRef(null);\n  const setCurrentId = React.useCallback(currentId => {\n    setState({\n      currentId\n    });\n  }, []);\n  index(() => {\n    if (state.currentId) {\n      if (initialCurrentIdRef.current === null) {\n        initialCurrentIdRef.current = state.currentId;\n      } else if (!state.isInstantPhase) {\n        setState({\n          isInstantPhase: true\n        });\n      }\n    } else {\n      if (state.isInstantPhase) {\n        setState({\n          isInstantPhase: false\n        });\n      }\n      initialCurrentIdRef.current = null;\n    }\n  }, [state.currentId, state.isInstantPhase]);\n  return /*#__PURE__*/React.createElement(FloatingDelayGroupContext.Provider, {\n    value: React.useMemo(() => ({\n      ...state,\n      setState,\n      setCurrentId\n    }), [state, setCurrentId])\n  }, children);\n}\n/**\n * Enables grouping when called inside a component that's a child of a\n * `FloatingDelayGroup`.\n * @see https://floating-ui.com/docs/FloatingDelayGroup\n */\nfunction useDelayGroup(context, options) {\n  if (options === void 0) {\n    options = {};\n  }\n  const {\n    open,\n    onOpenChange,\n    floatingId\n  } = context;\n  const {\n    id: optionId,\n    enabled = true\n  } = options;\n  const id = optionId != null ? optionId : floatingId;\n  const groupContext = useDelayGroupContext();\n  const {\n    currentId,\n    setCurrentId,\n    initialDelay,\n    setState,\n    timeoutMs\n  } = groupContext;\n  index(() => {\n    if (!enabled) return;\n    if (!currentId) return;\n    setState({\n      delay: {\n        open: 1,\n        close: getDelay(initialDelay, 'close')\n      }\n    });\n    if (currentId !== id) {\n      onOpenChange(false);\n    }\n  }, [enabled, id, onOpenChange, setState, currentId, initialDelay]);\n  index(() => {\n    function unset() {\n      onOpenChange(false);\n      setState({\n        delay: initialDelay,\n        currentId: null\n      });\n    }\n    if (!enabled) return;\n    if (!currentId) return;\n    if (!open && currentId === id) {\n      if (timeoutMs) {\n        const timeout = window.setTimeout(unset, timeoutMs);\n        return () => {\n          clearTimeout(timeout);\n        };\n      }\n      unset();\n    }\n  }, [enabled, open, setState, currentId, id, onOpenChange, initialDelay, timeoutMs]);\n  index(() => {\n    if (!enabled) return;\n    if (setCurrentId === NOOP || !open) return;\n    setCurrentId(id);\n  }, [enabled, open, setCurrentId, id]);\n  return groupContext;\n}\n\nlet rafId = 0;\nfunction enqueueFocus(el, options) {\n  if (options === void 0) {\n    options = {};\n  }\n  const {\n    preventScroll = false,\n    cancelPrevious = true,\n    sync = false\n  } = options;\n  cancelPrevious && cancelAnimationFrame(rafId);\n  const exec = () => el == null ? void 0 : el.focus({\n    preventScroll\n  });\n  if (sync) {\n    exec();\n  } else {\n    rafId = requestAnimationFrame(exec);\n  }\n}\n\nfunction getAncestors(nodes, id) {\n  var _nodes$find;\n  let allAncestors = [];\n  let currentParentId = (_nodes$find = nodes.find(node => node.id === id)) == null ? void 0 : _nodes$find.parentId;\n  while (currentParentId) {\n    const currentNode = nodes.find(node => node.id === currentParentId);\n    currentParentId = currentNode == null ? void 0 : currentNode.parentId;\n    if (currentNode) {\n      allAncestors = allAncestors.concat(currentNode);\n    }\n  }\n  return allAncestors;\n}\n\nfunction getChildren(nodes, id) {\n  let allChildren = nodes.filter(node => {\n    var _node$context;\n    return node.parentId === id && ((_node$context = node.context) == null ? void 0 : _node$context.open);\n  });\n  let currentChildren = allChildren;\n  while (currentChildren.length) {\n    currentChildren = nodes.filter(node => {\n      var _currentChildren;\n      return (_currentChildren = currentChildren) == null ? void 0 : _currentChildren.some(n => {\n        var _node$context2;\n        return node.parentId === n.id && ((_node$context2 = node.context) == null ? void 0 : _node$context2.open);\n      });\n    });\n    allChildren = allChildren.concat(currentChildren);\n  }\n  return allChildren;\n}\nfunction getDeepestNode(nodes, id) {\n  let deepestNodeId;\n  let maxDepth = -1;\n  function findDeepest(nodeId, depth) {\n    if (depth > maxDepth) {\n      deepestNodeId = nodeId;\n      maxDepth = depth;\n    }\n    const children = getChildren(nodes, nodeId);\n    children.forEach(child => {\n      findDeepest(child.id, depth + 1);\n    });\n  }\n  findDeepest(id, 0);\n  return nodes.find(node => node.id === deepestNodeId);\n}\n\n// Modified to add conditional `aria-hidden` support:\n// https://github.com/theKashey/aria-hidden/blob/9220c8f4a4fd35f63bee5510a9f41a37264382d4/src/index.ts\nlet counterMap = /*#__PURE__*/new WeakMap();\nlet uncontrolledElementsSet = /*#__PURE__*/new WeakSet();\nlet markerMap = {};\nlet lockCount$1 = 0;\nconst supportsInert = () => typeof HTMLElement !== 'undefined' && 'inert' in HTMLElement.prototype;\nconst unwrapHost = node => node && (node.host || unwrapHost(node.parentNode));\nconst correctElements = (parent, targets) => targets.map(target => {\n  if (parent.contains(target)) {\n    return target;\n  }\n  const correctedTarget = unwrapHost(target);\n  if (parent.contains(correctedTarget)) {\n    return correctedTarget;\n  }\n  return null;\n}).filter(x => x != null);\nfunction applyAttributeToOthers(uncorrectedAvoidElements, body, ariaHidden, inert) {\n  const markerName = 'data-floating-ui-inert';\n  const controlAttribute = inert ? 'inert' : ariaHidden ? 'aria-hidden' : null;\n  const avoidElements = correctElements(body, uncorrectedAvoidElements);\n  const elementsToKeep = new Set();\n  const elementsToStop = new Set(avoidElements);\n  const hiddenElements = [];\n  if (!markerMap[markerName]) {\n    markerMap[markerName] = new WeakMap();\n  }\n  const markerCounter = markerMap[markerName];\n  avoidElements.forEach(keep);\n  deep(body);\n  elementsToKeep.clear();\n  function keep(el) {\n    if (!el || elementsToKeep.has(el)) {\n      return;\n    }\n    elementsToKeep.add(el);\n    el.parentNode && keep(el.parentNode);\n  }\n  function deep(parent) {\n    if (!parent || elementsToStop.has(parent)) {\n      return;\n    }\n    [].forEach.call(parent.children, node => {\n      if (getNodeName(node) === 'script') return;\n      if (elementsToKeep.has(node)) {\n        deep(node);\n      } else {\n        const attr = controlAttribute ? node.getAttribute(controlAttribute) : null;\n        const alreadyHidden = attr !== null && attr !== 'false';\n        const counterValue = (counterMap.get(node) || 0) + 1;\n        const markerValue = (markerCounter.get(node) || 0) + 1;\n        counterMap.set(node, counterValue);\n        markerCounter.set(node, markerValue);\n        hiddenElements.push(node);\n        if (counterValue === 1 && alreadyHidden) {\n          uncontrolledElementsSet.add(node);\n        }\n        if (markerValue === 1) {\n          node.setAttribute(markerName, '');\n        }\n        if (!alreadyHidden && controlAttribute) {\n          node.setAttribute(controlAttribute, 'true');\n        }\n      }\n    });\n  }\n  lockCount$1++;\n  return () => {\n    hiddenElements.forEach(element => {\n      const counterValue = (counterMap.get(element) || 0) - 1;\n      const markerValue = (markerCounter.get(element) || 0) - 1;\n      counterMap.set(element, counterValue);\n      markerCounter.set(element, markerValue);\n      if (!counterValue) {\n        if (!uncontrolledElementsSet.has(element) && controlAttribute) {\n          element.removeAttribute(controlAttribute);\n        }\n        uncontrolledElementsSet.delete(element);\n      }\n      if (!markerValue) {\n        element.removeAttribute(markerName);\n      }\n    });\n    lockCount$1--;\n    if (!lockCount$1) {\n      counterMap = new WeakMap();\n      counterMap = new WeakMap();\n      uncontrolledElementsSet = new WeakSet();\n      markerMap = {};\n    }\n  };\n}\nfunction markOthers(avoidElements, ariaHidden, inert) {\n  if (ariaHidden === void 0) {\n    ariaHidden = false;\n  }\n  if (inert === void 0) {\n    inert = false;\n  }\n  const body = getDocument(avoidElements[0]).body;\n  return applyAttributeToOthers(avoidElements.concat(Array.from(body.querySelectorAll('[aria-live]'))), body, ariaHidden, inert);\n}\n\nconst getTabbableOptions = () => ({\n  getShadowRoot: true,\n  displayCheck:\n  // JSDOM does not support the `tabbable` library. To solve this we can\n  // check if `ResizeObserver` is a real function (not polyfilled), which\n  // determines if the current environment is JSDOM-like.\n  typeof ResizeObserver === 'function' && ResizeObserver.toString().includes('[native code]') ? 'full' : 'none'\n});\nfunction getTabbableIn(container, direction) {\n  const allTabbable = tabbable(container, getTabbableOptions());\n  if (direction === 'prev') {\n    allTabbable.reverse();\n  }\n  const activeIndex = allTabbable.indexOf(activeElement(getDocument(container)));\n  const nextTabbableElements = allTabbable.slice(activeIndex + 1);\n  return nextTabbableElements[0];\n}\nfunction getNextTabbable() {\n  return getTabbableIn(document.body, 'next');\n}\nfunction getPreviousTabbable() {\n  return getTabbableIn(document.body, 'prev');\n}\nfunction isOutsideEvent(event, container) {\n  const containerElement = container || event.currentTarget;\n  const relatedTarget = event.relatedTarget;\n  return !relatedTarget || !contains(containerElement, relatedTarget);\n}\nfunction disableFocusInside(container) {\n  const tabbableElements = tabbable(container, getTabbableOptions());\n  tabbableElements.forEach(element => {\n    element.dataset.tabindex = element.getAttribute('tabindex') || '';\n    element.setAttribute('tabindex', '-1');\n  });\n}\nfunction enableFocusInside(container) {\n  const elements = container.querySelectorAll('[data-tabindex]');\n  elements.forEach(element => {\n    const tabindex = element.dataset.tabindex;\n    delete element.dataset.tabindex;\n    if (tabindex) {\n      element.setAttribute('tabindex', tabindex);\n    } else {\n      element.removeAttribute('tabindex');\n    }\n  });\n}\n\n// See Diego Haz's Sandbox for making this logic work well on Safari/iOS:\n// https://codesandbox.io/s/tabbable-portal-f4tng?file=/src/FocusTrap.tsx\n\nconst HIDDEN_STYLES = {\n  border: 0,\n  clip: 'rect(0 0 0 0)',\n  height: '1px',\n  margin: '-1px',\n  overflow: 'hidden',\n  padding: 0,\n  position: 'fixed',\n  whiteSpace: 'nowrap',\n  width: '1px',\n  top: 0,\n  left: 0\n};\nlet timeoutId;\nfunction setActiveElementOnTab(event) {\n  if (event.key === 'Tab') {\n    event.target;\n    clearTimeout(timeoutId);\n  }\n}\nconst FocusGuard = /*#__PURE__*/React.forwardRef(function FocusGuard(props, ref) {\n  const [role, setRole] = React.useState();\n  index(() => {\n    if (isSafari()) {\n      // Unlike other screen readers such as NVDA and JAWS, the virtual cursor\n      // on VoiceOver does trigger the onFocus event, so we can use the focus\n      // trap element. On Safari, only buttons trigger the onFocus event.\n      // NB: \"group\" role in the Sandbox no longer appears to work, must be a\n      // button role.\n      setRole('button');\n    }\n    document.addEventListener('keydown', setActiveElementOnTab);\n    return () => {\n      document.removeEventListener('keydown', setActiveElementOnTab);\n    };\n  }, []);\n  const restProps = {\n    ref,\n    tabIndex: 0,\n    // Role is only for VoiceOver\n    role,\n    'aria-hidden': role ? undefined : true,\n    [createAttribute('focus-guard')]: '',\n    style: HIDDEN_STYLES\n  };\n  return /*#__PURE__*/React.createElement(\"span\", _extends({}, props, restProps));\n});\n\nconst PortalContext = /*#__PURE__*/React.createContext(null);\nconst attr = /*#__PURE__*/createAttribute('portal');\n/**\n * @see https://floating-ui.com/docs/FloatingPortal#usefloatingportalnode\n */\nfunction useFloatingPortalNode(props) {\n  if (props === void 0) {\n    props = {};\n  }\n  const {\n    id,\n    root\n  } = props;\n  const uniqueId = useId();\n  const portalContext = usePortalContext();\n  const [portalNode, setPortalNode] = React.useState(null);\n  const portalNodeRef = React.useRef(null);\n  index(() => {\n    return () => {\n      portalNode == null || portalNode.remove();\n      // Allow the subsequent layout effects to create a new node on updates.\n      // The portal node will still be cleaned up on unmount.\n      // https://github.com/floating-ui/floating-ui/issues/2454\n      queueMicrotask(() => {\n        portalNodeRef.current = null;\n      });\n    };\n  }, [portalNode]);\n  index(() => {\n    // Wait for the uniqueId to be generated before creating the portal node in\n    // React <18 (using `useFloatingId` instead of the native `useId`).\n    // https://github.com/floating-ui/floating-ui/issues/2778\n    if (!uniqueId) return;\n    if (portalNodeRef.current) return;\n    const existingIdRoot = id ? document.getElementById(id) : null;\n    if (!existingIdRoot) return;\n    const subRoot = document.createElement('div');\n    subRoot.id = uniqueId;\n    subRoot.setAttribute(attr, '');\n    existingIdRoot.appendChild(subRoot);\n    portalNodeRef.current = subRoot;\n    setPortalNode(subRoot);\n  }, [id, uniqueId]);\n  index(() => {\n    // Wait for the root to exist before creating the portal node. The root must\n    // be stored in state, not a ref, for this to work reactively.\n    if (root === null) return;\n    if (!uniqueId) return;\n    if (portalNodeRef.current) return;\n    let container = root || (portalContext == null ? void 0 : portalContext.portalNode);\n    if (container && !isElement(container)) container = container.current;\n    container = container || document.body;\n    let idWrapper = null;\n    if (id) {\n      idWrapper = document.createElement('div');\n      idWrapper.id = id;\n      container.appendChild(idWrapper);\n    }\n    const subRoot = document.createElement('div');\n    subRoot.id = uniqueId;\n    subRoot.setAttribute(attr, '');\n    container = idWrapper || container;\n    container.appendChild(subRoot);\n    portalNodeRef.current = subRoot;\n    setPortalNode(subRoot);\n  }, [id, root, uniqueId, portalContext]);\n  return portalNode;\n}\n/**\n * Portals the floating element into a given container element — by default,\n * outside of the app root and into the body.\n * This is necessary to ensure the floating element can appear outside any\n * potential parent containers that cause clipping (such as `overflow: hidden`),\n * while retaining its location in the React tree.\n * @see https://floating-ui.com/docs/FloatingPortal\n */\nfunction FloatingPortal(props) {\n  const {\n    children,\n    id,\n    root,\n    preserveTabOrder = true\n  } = props;\n  const portalNode = useFloatingPortalNode({\n    id,\n    root\n  });\n  const [focusManagerState, setFocusManagerState] = React.useState(null);\n  const beforeOutsideRef = React.useRef(null);\n  const afterOutsideRef = React.useRef(null);\n  const beforeInsideRef = React.useRef(null);\n  const afterInsideRef = React.useRef(null);\n  const modal = focusManagerState == null ? void 0 : focusManagerState.modal;\n  const open = focusManagerState == null ? void 0 : focusManagerState.open;\n  const shouldRenderGuards =\n  // The FocusManager and therefore floating element are currently open/\n  // rendered.\n  !!focusManagerState &&\n  // Guards are only for non-modal focus management.\n  !focusManagerState.modal &&\n  // Don't render if unmount is transitioning.\n  focusManagerState.open && preserveTabOrder && !!(root || portalNode);\n\n  // https://codesandbox.io/s/tabbable-portal-f4tng?file=/src/TabbablePortal.tsx\n  React.useEffect(() => {\n    if (!portalNode || !preserveTabOrder || modal) {\n      return;\n    }\n\n    // Make sure elements inside the portal element are tabbable only when the\n    // portal has already been focused, either by tabbing into a focus trap\n    // element outside or using the mouse.\n    function onFocus(event) {\n      if (portalNode && isOutsideEvent(event)) {\n        const focusing = event.type === 'focusin';\n        const manageFocus = focusing ? enableFocusInside : disableFocusInside;\n        manageFocus(portalNode);\n      }\n    }\n    // Listen to the event on the capture phase so they run before the focus\n    // trap elements onFocus prop is called.\n    portalNode.addEventListener('focusin', onFocus, true);\n    portalNode.addEventListener('focusout', onFocus, true);\n    return () => {\n      portalNode.removeEventListener('focusin', onFocus, true);\n      portalNode.removeEventListener('focusout', onFocus, true);\n    };\n  }, [portalNode, preserveTabOrder, modal]);\n  React.useEffect(() => {\n    if (!portalNode) return;\n    if (open) return;\n    enableFocusInside(portalNode);\n  }, [open, portalNode]);\n  return /*#__PURE__*/React.createElement(PortalContext.Provider, {\n    value: React.useMemo(() => ({\n      preserveTabOrder,\n      beforeOutsideRef,\n      afterOutsideRef,\n      beforeInsideRef,\n      afterInsideRef,\n      portalNode,\n      setFocusManagerState\n    }), [preserveTabOrder, portalNode])\n  }, shouldRenderGuards && portalNode && /*#__PURE__*/React.createElement(FocusGuard, {\n    \"data-type\": \"outside\",\n    ref: beforeOutsideRef,\n    onFocus: event => {\n      if (isOutsideEvent(event, portalNode)) {\n        var _beforeInsideRef$curr;\n        (_beforeInsideRef$curr = beforeInsideRef.current) == null || _beforeInsideRef$curr.focus();\n      } else {\n        const prevTabbable = getPreviousTabbable() || (focusManagerState == null ? void 0 : focusManagerState.refs.domReference.current);\n        prevTabbable == null || prevTabbable.focus();\n      }\n    }\n  }), shouldRenderGuards && portalNode && /*#__PURE__*/React.createElement(\"span\", {\n    \"aria-owns\": portalNode.id,\n    style: HIDDEN_STYLES\n  }), portalNode && /*#__PURE__*/ReactDOM.createPortal(children, portalNode), shouldRenderGuards && portalNode && /*#__PURE__*/React.createElement(FocusGuard, {\n    \"data-type\": \"outside\",\n    ref: afterOutsideRef,\n    onFocus: event => {\n      if (isOutsideEvent(event, portalNode)) {\n        var _afterInsideRef$curre;\n        (_afterInsideRef$curre = afterInsideRef.current) == null || _afterInsideRef$curre.focus();\n      } else {\n        const nextTabbable = getNextTabbable() || (focusManagerState == null ? void 0 : focusManagerState.refs.domReference.current);\n        nextTabbable == null || nextTabbable.focus();\n        (focusManagerState == null ? void 0 : focusManagerState.closeOnFocusOut) && (focusManagerState == null ? void 0 : focusManagerState.onOpenChange(false, event.nativeEvent, 'focus-out'));\n      }\n    }\n  }));\n}\nconst usePortalContext = () => React.useContext(PortalContext);\n\nconst FOCUSABLE_ATTRIBUTE = 'data-floating-ui-focusable';\nfunction getFloatingFocusElement(floatingElement) {\n  if (!floatingElement) {\n    return null;\n  }\n  // Try to find the element that has `{...getFloatingProps()}` spread on it.\n  // This indicates the floating element is acting as a positioning wrapper, and\n  // so focus should be managed on the child element with the event handlers and\n  // aria props.\n  return floatingElement.hasAttribute(FOCUSABLE_ATTRIBUTE) ? floatingElement : floatingElement.querySelector(\"[\" + FOCUSABLE_ATTRIBUTE + \"]\") || floatingElement;\n}\n\nconst LIST_LIMIT = 20;\nlet previouslyFocusedElements = [];\nfunction addPreviouslyFocusedElement(element) {\n  previouslyFocusedElements = previouslyFocusedElements.filter(el => el.isConnected);\n  if (element && getNodeName(element) !== 'body') {\n    previouslyFocusedElements.push(element);\n    if (previouslyFocusedElements.length > LIST_LIMIT) {\n      previouslyFocusedElements = previouslyFocusedElements.slice(-LIST_LIMIT);\n    }\n  }\n}\nfunction getPreviouslyFocusedElement() {\n  return previouslyFocusedElements.slice().reverse().find(el => el.isConnected);\n}\nfunction getFirstTabbableElement(container) {\n  const tabbableOptions = getTabbableOptions();\n  if (isTabbable(container, tabbableOptions)) {\n    return container;\n  }\n  return tabbable(container, tabbableOptions)[0];\n}\nconst VisuallyHiddenDismiss = /*#__PURE__*/React.forwardRef(function VisuallyHiddenDismiss(props, ref) {\n  return /*#__PURE__*/React.createElement(\"button\", _extends({}, props, {\n    type: \"button\",\n    ref: ref,\n    tabIndex: -1,\n    style: HIDDEN_STYLES\n  }));\n});\n/**\n * Provides focus management for the floating element.\n * @see https://floating-ui.com/docs/FloatingFocusManager\n */\nfunction FloatingFocusManager(props) {\n  const {\n    context,\n    children,\n    disabled = false,\n    order = ['content'],\n    guards: _guards = true,\n    initialFocus = 0,\n    returnFocus = true,\n    restoreFocus = false,\n    modal = true,\n    visuallyHiddenDismiss = false,\n    closeOnFocusOut = true,\n    outsideElementsInert = false\n  } = props;\n  const {\n    open,\n    refs,\n    nodeId,\n    onOpenChange,\n    events,\n    dataRef,\n    elements: {\n      domReference,\n      floating\n    }\n  } = context;\n  const ignoreInitialFocus = typeof initialFocus === 'number' && initialFocus < 0;\n  // If the reference is a combobox and is typeable (e.g. input/textarea),\n  // there are different focus semantics. The guards should not be rendered, but\n  // aria-hidden should be applied to all nodes still. Further, the visually\n  // hidden dismiss button should only appear at the end of the list, not the\n  // start.\n  const isUntrappedTypeableCombobox = isTypeableCombobox(domReference) && ignoreInitialFocus;\n\n  // Force the guards to be rendered if the `inert` attribute is not supported.\n  const inertSupported = supportsInert();\n  const guards = inertSupported ? _guards : true;\n  const useInert = !guards || inertSupported && outsideElementsInert;\n  const orderRef = useLatestRef(order);\n  const initialFocusRef = useLatestRef(initialFocus);\n  const returnFocusRef = useLatestRef(returnFocus);\n  const tree = useFloatingTree();\n  const portalContext = usePortalContext();\n  const startDismissButtonRef = React.useRef(null);\n  const endDismissButtonRef = React.useRef(null);\n  const preventReturnFocusRef = React.useRef(false);\n  const isPointerDownRef = React.useRef(false);\n  const tabbableIndexRef = React.useRef(-1);\n  const isInsidePortal = portalContext != null;\n  const floatingFocusElement = getFloatingFocusElement(floating);\n  const getTabbableContent = useEffectEvent(function (container) {\n    if (container === void 0) {\n      container = floatingFocusElement;\n    }\n    return container ? tabbable(container, getTabbableOptions()) : [];\n  });\n  const getTabbableElements = useEffectEvent(container => {\n    const content = getTabbableContent(container);\n    return orderRef.current.map(type => {\n      if (domReference && type === 'reference') {\n        return domReference;\n      }\n      if (floatingFocusElement && type === 'floating') {\n        return floatingFocusElement;\n      }\n      return content;\n    }).filter(Boolean).flat();\n  });\n  React.useEffect(() => {\n    if (disabled) return;\n    if (!modal) return;\n    function onKeyDown(event) {\n      if (event.key === 'Tab') {\n        // The focus guards have nothing to focus, so we need to stop the event.\n        if (contains(floatingFocusElement, activeElement(getDocument(floatingFocusElement))) && getTabbableContent().length === 0 && !isUntrappedTypeableCombobox) {\n          stopEvent(event);\n        }\n        const els = getTabbableElements();\n        const target = getTarget(event);\n        if (orderRef.current[0] === 'reference' && target === domReference) {\n          stopEvent(event);\n          if (event.shiftKey) {\n            enqueueFocus(els[els.length - 1]);\n          } else {\n            enqueueFocus(els[1]);\n          }\n        }\n        if (orderRef.current[1] === 'floating' && target === floatingFocusElement && event.shiftKey) {\n          stopEvent(event);\n          enqueueFocus(els[0]);\n        }\n      }\n    }\n    const doc = getDocument(floatingFocusElement);\n    doc.addEventListener('keydown', onKeyDown);\n    return () => {\n      doc.removeEventListener('keydown', onKeyDown);\n    };\n  }, [disabled, domReference, floatingFocusElement, modal, orderRef, isUntrappedTypeableCombobox, getTabbableContent, getTabbableElements]);\n  React.useEffect(() => {\n    if (disabled) return;\n    if (!floating) return;\n    function handleFocusIn(event) {\n      const target = getTarget(event);\n      const tabbableContent = getTabbableContent();\n      const tabbableIndex = tabbableContent.indexOf(target);\n      if (tabbableIndex !== -1) {\n        tabbableIndexRef.current = tabbableIndex;\n      }\n    }\n    floating.addEventListener('focusin', handleFocusIn);\n    return () => {\n      floating.removeEventListener('focusin', handleFocusIn);\n    };\n  }, [disabled, floating, getTabbableContent]);\n  React.useEffect(() => {\n    if (disabled) return;\n    if (!closeOnFocusOut) return;\n\n    // In Safari, buttons lose focus when pressing them.\n    function handlePointerDown() {\n      isPointerDownRef.current = true;\n      setTimeout(() => {\n        isPointerDownRef.current = false;\n      });\n    }\n    function handleFocusOutside(event) {\n      const relatedTarget = event.relatedTarget;\n      queueMicrotask(() => {\n        const movedToUnrelatedNode = !(contains(domReference, relatedTarget) || contains(floating, relatedTarget) || contains(relatedTarget, floating) || contains(portalContext == null ? void 0 : portalContext.portalNode, relatedTarget) || relatedTarget != null && relatedTarget.hasAttribute(createAttribute('focus-guard')) || tree && (getChildren(tree.nodesRef.current, nodeId).find(node => {\n          var _node$context, _node$context2;\n          return contains((_node$context = node.context) == null ? void 0 : _node$context.elements.floating, relatedTarget) || contains((_node$context2 = node.context) == null ? void 0 : _node$context2.elements.domReference, relatedTarget);\n        }) || getAncestors(tree.nodesRef.current, nodeId).find(node => {\n          var _node$context3, _node$context4;\n          return ((_node$context3 = node.context) == null ? void 0 : _node$context3.elements.floating) === relatedTarget || ((_node$context4 = node.context) == null ? void 0 : _node$context4.elements.domReference) === relatedTarget;\n        })));\n\n        // Restore focus to the previous tabbable element index to prevent\n        // focus from being lost outside the floating tree.\n        if (restoreFocus && movedToUnrelatedNode && activeElement(getDocument(floatingFocusElement)) === getDocument(floatingFocusElement).body) {\n          // Let `FloatingPortal` effect knows that focus is still inside the\n          // floating tree.\n          if (isHTMLElement(floatingFocusElement)) {\n            floatingFocusElement.focus();\n          }\n          const prevTabbableIndex = tabbableIndexRef.current;\n          const tabbableContent = getTabbableContent();\n          const nodeToFocus = tabbableContent[prevTabbableIndex] || tabbableContent[tabbableContent.length - 1] || floatingFocusElement;\n          if (isHTMLElement(nodeToFocus)) {\n            nodeToFocus.focus();\n          }\n        }\n\n        // Focus did not move inside the floating tree, and there are no tabbable\n        // portal guards to handle closing.\n        if ((isUntrappedTypeableCombobox ? true : !modal) && relatedTarget && movedToUnrelatedNode && !isPointerDownRef.current &&\n        // Fix React 18 Strict Mode returnFocus due to double rendering.\n        relatedTarget !== getPreviouslyFocusedElement()) {\n          preventReturnFocusRef.current = true;\n          onOpenChange(false, event, 'focus-out');\n        }\n      });\n    }\n    if (floating && isHTMLElement(domReference)) {\n      domReference.addEventListener('focusout', handleFocusOutside);\n      domReference.addEventListener('pointerdown', handlePointerDown);\n      floating.addEventListener('focusout', handleFocusOutside);\n      return () => {\n        domReference.removeEventListener('focusout', handleFocusOutside);\n        domReference.removeEventListener('pointerdown', handlePointerDown);\n        floating.removeEventListener('focusout', handleFocusOutside);\n      };\n    }\n  }, [disabled, domReference, floating, floatingFocusElement, modal, nodeId, tree, portalContext, onOpenChange, closeOnFocusOut, restoreFocus, getTabbableContent, isUntrappedTypeableCombobox]);\n  const beforeGuardRef = React.useRef(null);\n  const afterGuardRef = React.useRef(null);\n  const mergedBeforeGuardRef = useMergeRefs([beforeGuardRef, portalContext == null ? void 0 : portalContext.beforeInsideRef]);\n  const mergedAfterGuardRef = useMergeRefs([afterGuardRef, portalContext == null ? void 0 : portalContext.afterInsideRef]);\n  React.useEffect(() => {\n    var _portalContext$portal;\n    if (disabled) return;\n\n    // Don't hide portals nested within the parent portal.\n    const portalNodes = Array.from((portalContext == null || (_portalContext$portal = portalContext.portalNode) == null ? void 0 : _portalContext$portal.querySelectorAll(\"[\" + createAttribute('portal') + \"]\")) || []);\n    if (floating) {\n      const insideElements = [floating, ...portalNodes, startDismissButtonRef.current, endDismissButtonRef.current, beforeGuardRef.current, afterGuardRef.current, portalContext == null ? void 0 : portalContext.beforeOutsideRef.current, portalContext == null ? void 0 : portalContext.afterOutsideRef.current, orderRef.current.includes('reference') || isUntrappedTypeableCombobox ? domReference : null].filter(x => x != null);\n      const cleanup = modal || isUntrappedTypeableCombobox ? markOthers(insideElements, !useInert, useInert) : markOthers(insideElements);\n      return () => {\n        cleanup();\n      };\n    }\n  }, [disabled, domReference, floating, modal, orderRef, portalContext, isUntrappedTypeableCombobox, guards, useInert]);\n  index(() => {\n    if (disabled || !isHTMLElement(floatingFocusElement)) return;\n    const doc = getDocument(floatingFocusElement);\n    const previouslyFocusedElement = activeElement(doc);\n\n    // Wait for any layout effect state setters to execute to set `tabIndex`.\n    queueMicrotask(() => {\n      const focusableElements = getTabbableElements(floatingFocusElement);\n      const initialFocusValue = initialFocusRef.current;\n      const elToFocus = (typeof initialFocusValue === 'number' ? focusableElements[initialFocusValue] : initialFocusValue.current) || floatingFocusElement;\n      const focusAlreadyInsideFloatingEl = contains(floatingFocusElement, previouslyFocusedElement);\n      if (!ignoreInitialFocus && !focusAlreadyInsideFloatingEl && open) {\n        enqueueFocus(elToFocus, {\n          preventScroll: elToFocus === floatingFocusElement\n        });\n      }\n    });\n  }, [disabled, open, floatingFocusElement, ignoreInitialFocus, getTabbableElements, initialFocusRef]);\n  index(() => {\n    if (disabled || !floatingFocusElement) return;\n    let preventReturnFocusScroll = false;\n    const doc = getDocument(floatingFocusElement);\n    const previouslyFocusedElement = activeElement(doc);\n    const contextData = dataRef.current;\n    let openEvent = contextData.openEvent;\n    addPreviouslyFocusedElement(previouslyFocusedElement);\n\n    // Dismissing via outside press should always ignore `returnFocus` to\n    // prevent unwanted scrolling.\n    function onOpenChange(_ref) {\n      let {\n        open,\n        reason,\n        event,\n        nested\n      } = _ref;\n      if (open) {\n        openEvent = event;\n      }\n      if (reason === 'escape-key' && refs.domReference.current) {\n        addPreviouslyFocusedElement(refs.domReference.current);\n      }\n      if (['hover', 'safe-polygon'].includes(reason) && event.type === 'mouseleave') {\n        preventReturnFocusRef.current = true;\n      }\n      if (reason !== 'outside-press') return;\n      if (nested) {\n        preventReturnFocusRef.current = false;\n        preventReturnFocusScroll = true;\n      } else {\n        preventReturnFocusRef.current = !(isVirtualClick(event) || isVirtualPointerEvent(event));\n      }\n    }\n    events.on('openchange', onOpenChange);\n    const fallbackEl = doc.createElement('span');\n    fallbackEl.setAttribute('tabindex', '-1');\n    fallbackEl.setAttribute('aria-hidden', 'true');\n    Object.assign(fallbackEl.style, HIDDEN_STYLES);\n    if (isInsidePortal && domReference) {\n      domReference.insertAdjacentElement('afterend', fallbackEl);\n    }\n    function getReturnElement() {\n      if (typeof returnFocusRef.current === 'boolean') {\n        return getPreviouslyFocusedElement() || fallbackEl;\n      }\n      return returnFocusRef.current.current || fallbackEl;\n    }\n    return () => {\n      events.off('openchange', onOpenChange);\n      const activeEl = activeElement(doc);\n      const isFocusInsideFloatingTree = contains(floating, activeEl) || tree && getChildren(tree.nodesRef.current, nodeId).some(node => {\n        var _node$context5;\n        return contains((_node$context5 = node.context) == null ? void 0 : _node$context5.elements.floating, activeEl);\n      });\n      const shouldFocusReference = isFocusInsideFloatingTree || openEvent && ['click', 'mousedown'].includes(openEvent.type);\n      if (shouldFocusReference && refs.domReference.current) {\n        addPreviouslyFocusedElement(refs.domReference.current);\n      }\n      const returnElement = getReturnElement();\n      queueMicrotask(() => {\n        // This is `returnElement`, if it's tabbable, or its first tabbable child.\n        const tabbableReturnElement = getFirstTabbableElement(returnElement);\n        if (\n        // eslint-disable-next-line react-hooks/exhaustive-deps\n        returnFocusRef.current && !preventReturnFocusRef.current && isHTMLElement(tabbableReturnElement) && (\n        // If the focus moved somewhere else after mount, avoid returning focus\n        // since it likely entered a different element which should be\n        // respected: https://github.com/floating-ui/floating-ui/issues/2607\n        tabbableReturnElement !== activeEl && activeEl !== doc.body ? isFocusInsideFloatingTree : true)) {\n          tabbableReturnElement.focus({\n            preventScroll: preventReturnFocusScroll\n          });\n        }\n        fallbackEl.remove();\n      });\n    };\n  }, [disabled, floating, floatingFocusElement, returnFocusRef, dataRef, refs, events, tree, nodeId, isInsidePortal, domReference]);\n  React.useEffect(() => {\n    // The `returnFocus` cleanup behavior is inside a microtask; ensure we\n    // wait for it to complete before resetting the flag.\n    queueMicrotask(() => {\n      preventReturnFocusRef.current = false;\n    });\n  }, [disabled]);\n\n  // Synchronize the `context` & `modal` value to the FloatingPortal context.\n  // It will decide whether or not it needs to render its own guards.\n  index(() => {\n    if (disabled) return;\n    if (!portalContext) return;\n    portalContext.setFocusManagerState({\n      modal,\n      closeOnFocusOut,\n      open,\n      onOpenChange,\n      refs\n    });\n    return () => {\n      portalContext.setFocusManagerState(null);\n    };\n  }, [disabled, portalContext, modal, open, onOpenChange, refs, closeOnFocusOut]);\n  index(() => {\n    if (disabled) return;\n    if (!floatingFocusElement) return;\n    if (typeof MutationObserver !== 'function') return;\n    if (ignoreInitialFocus) return;\n    const handleMutation = () => {\n      const tabIndex = floatingFocusElement.getAttribute('tabindex');\n      const tabbableContent = getTabbableContent();\n      const activeEl = activeElement(getDocument(floating));\n      const tabbableIndex = tabbableContent.indexOf(activeEl);\n      if (tabbableIndex !== -1) {\n        tabbableIndexRef.current = tabbableIndex;\n      }\n      if (orderRef.current.includes('floating') || activeEl !== refs.domReference.current && tabbableContent.length === 0) {\n        if (tabIndex !== '0') {\n          floatingFocusElement.setAttribute('tabindex', '0');\n        }\n      } else if (tabIndex !== '-1') {\n        floatingFocusElement.setAttribute('tabindex', '-1');\n      }\n    };\n    handleMutation();\n    const observer = new MutationObserver(handleMutation);\n    observer.observe(floatingFocusElement, {\n      childList: true,\n      subtree: true,\n      attributes: true\n    });\n    return () => {\n      observer.disconnect();\n    };\n  }, [disabled, floating, floatingFocusElement, refs, orderRef, getTabbableContent, ignoreInitialFocus]);\n  function renderDismissButton(location) {\n    if (disabled || !visuallyHiddenDismiss || !modal) {\n      return null;\n    }\n    return /*#__PURE__*/React.createElement(VisuallyHiddenDismiss, {\n      ref: location === 'start' ? startDismissButtonRef : endDismissButtonRef,\n      onClick: event => onOpenChange(false, event.nativeEvent)\n    }, typeof visuallyHiddenDismiss === 'string' ? visuallyHiddenDismiss : 'Dismiss');\n  }\n  const shouldRenderGuards = !disabled && guards && (modal ? !isUntrappedTypeableCombobox : true) && (isInsidePortal || modal);\n  return /*#__PURE__*/React.createElement(React.Fragment, null, shouldRenderGuards && /*#__PURE__*/React.createElement(FocusGuard, {\n    \"data-type\": \"inside\",\n    ref: mergedBeforeGuardRef,\n    onFocus: event => {\n      if (modal) {\n        const els = getTabbableElements();\n        enqueueFocus(order[0] === 'reference' ? els[0] : els[els.length - 1]);\n      } else if (portalContext != null && portalContext.preserveTabOrder && portalContext.portalNode) {\n        preventReturnFocusRef.current = false;\n        if (isOutsideEvent(event, portalContext.portalNode)) {\n          const nextTabbable = getNextTabbable() || domReference;\n          nextTabbable == null || nextTabbable.focus();\n        } else {\n          var _portalContext$before;\n          (_portalContext$before = portalContext.beforeOutsideRef.current) == null || _portalContext$before.focus();\n        }\n      }\n    }\n  }), !isUntrappedTypeableCombobox && renderDismissButton('start'), children, renderDismissButton('end'), shouldRenderGuards && /*#__PURE__*/React.createElement(FocusGuard, {\n    \"data-type\": \"inside\",\n    ref: mergedAfterGuardRef,\n    onFocus: event => {\n      if (modal) {\n        enqueueFocus(getTabbableElements()[0]);\n      } else if (portalContext != null && portalContext.preserveTabOrder && portalContext.portalNode) {\n        if (closeOnFocusOut) {\n          preventReturnFocusRef.current = true;\n        }\n        if (isOutsideEvent(event, portalContext.portalNode)) {\n          const prevTabbable = getPreviousTabbable() || domReference;\n          prevTabbable == null || prevTabbable.focus();\n        } else {\n          var _portalContext$afterO;\n          (_portalContext$afterO = portalContext.afterOutsideRef.current) == null || _portalContext$afterO.focus();\n        }\n      }\n    }\n  }));\n}\n\nlet lockCount = 0;\nfunction enableScrollLock() {\n  const isIOS = /iP(hone|ad|od)|iOS/.test(getPlatform());\n  const bodyStyle = document.body.style;\n  // RTL <body> scrollbar\n  const scrollbarX = Math.round(document.documentElement.getBoundingClientRect().left) + document.documentElement.scrollLeft;\n  const paddingProp = scrollbarX ? 'paddingLeft' : 'paddingRight';\n  const scrollbarWidth = window.innerWidth - document.documentElement.clientWidth;\n  const scrollX = bodyStyle.left ? parseFloat(bodyStyle.left) : window.scrollX;\n  const scrollY = bodyStyle.top ? parseFloat(bodyStyle.top) : window.scrollY;\n  bodyStyle.overflow = 'hidden';\n  if (scrollbarWidth) {\n    bodyStyle[paddingProp] = scrollbarWidth + \"px\";\n  }\n\n  // Only iOS doesn't respect `overflow: hidden` on document.body, and this\n  // technique has fewer side effects.\n  if (isIOS) {\n    var _window$visualViewpor, _window$visualViewpor2;\n    // iOS 12 does not support `visualViewport`.\n    const offsetLeft = ((_window$visualViewpor = window.visualViewport) == null ? void 0 : _window$visualViewpor.offsetLeft) || 0;\n    const offsetTop = ((_window$visualViewpor2 = window.visualViewport) == null ? void 0 : _window$visualViewpor2.offsetTop) || 0;\n    Object.assign(bodyStyle, {\n      position: 'fixed',\n      top: -(scrollY - Math.floor(offsetTop)) + \"px\",\n      left: -(scrollX - Math.floor(offsetLeft)) + \"px\",\n      right: '0'\n    });\n  }\n  return () => {\n    Object.assign(bodyStyle, {\n      overflow: '',\n      [paddingProp]: ''\n    });\n    if (isIOS) {\n      Object.assign(bodyStyle, {\n        position: '',\n        top: '',\n        left: '',\n        right: ''\n      });\n      window.scrollTo(scrollX, scrollY);\n    }\n  };\n}\nlet cleanup = () => {};\n\n/**\n * Provides base styling for a fixed overlay element to dim content or block\n * pointer events behind a floating element.\n * It's a regular `<div>`, so it can be styled via any CSS solution you prefer.\n * @see https://floating-ui.com/docs/FloatingOverlay\n */\nconst FloatingOverlay = /*#__PURE__*/React.forwardRef(function FloatingOverlay(props, ref) {\n  const {\n    lockScroll = false,\n    ...rest\n  } = props;\n  index(() => {\n    if (!lockScroll) return;\n    lockCount++;\n    if (lockCount === 1) {\n      cleanup = enableScrollLock();\n    }\n    return () => {\n      lockCount--;\n      if (lockCount === 0) {\n        cleanup();\n      }\n    };\n  }, [lockScroll]);\n  return /*#__PURE__*/React.createElement(\"div\", _extends({\n    ref: ref\n  }, rest, {\n    style: {\n      position: 'fixed',\n      overflow: 'auto',\n      top: 0,\n      right: 0,\n      bottom: 0,\n      left: 0,\n      ...rest.style\n    }\n  }));\n});\n\nfunction isButtonTarget(event) {\n  return isHTMLElement(event.target) && event.target.tagName === 'BUTTON';\n}\nfunction isSpaceIgnored(element) {\n  return isTypeableElement(element);\n}\n/**\n * Opens or closes the floating element when clicking the reference element.\n * @see https://floating-ui.com/docs/useClick\n */\nfunction useClick(context, props) {\n  if (props === void 0) {\n    props = {};\n  }\n  const {\n    open,\n    onOpenChange,\n    dataRef,\n    elements: {\n      domReference\n    }\n  } = context;\n  const {\n    enabled = true,\n    event: eventOption = 'click',\n    toggle = true,\n    ignoreMouse = false,\n    keyboardHandlers = true,\n    stickIfOpen = true\n  } = props;\n  const pointerTypeRef = React.useRef();\n  const didKeyDownRef = React.useRef(false);\n  const reference = React.useMemo(() => ({\n    onPointerDown(event) {\n      pointerTypeRef.current = event.pointerType;\n    },\n    onMouseDown(event) {\n      const pointerType = pointerTypeRef.current;\n\n      // Ignore all buttons except for the \"main\" button.\n      // https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/button\n      if (event.button !== 0) return;\n      if (eventOption === 'click') return;\n      if (isMouseLikePointerType(pointerType, true) && ignoreMouse) return;\n      if (open && toggle && (dataRef.current.openEvent && stickIfOpen ? dataRef.current.openEvent.type === 'mousedown' : true)) {\n        onOpenChange(false, event.nativeEvent, 'click');\n      } else {\n        // Prevent stealing focus from the floating element\n        event.preventDefault();\n        onOpenChange(true, event.nativeEvent, 'click');\n      }\n    },\n    onClick(event) {\n      const pointerType = pointerTypeRef.current;\n      if (eventOption === 'mousedown' && pointerTypeRef.current) {\n        pointerTypeRef.current = undefined;\n        return;\n      }\n      if (isMouseLikePointerType(pointerType, true) && ignoreMouse) return;\n      if (open && toggle && (dataRef.current.openEvent && stickIfOpen ? dataRef.current.openEvent.type === 'click' : true)) {\n        onOpenChange(false, event.nativeEvent, 'click');\n      } else {\n        onOpenChange(true, event.nativeEvent, 'click');\n      }\n    },\n    onKeyDown(event) {\n      pointerTypeRef.current = undefined;\n      if (event.defaultPrevented || !keyboardHandlers || isButtonTarget(event)) {\n        return;\n      }\n      if (event.key === ' ' && !isSpaceIgnored(domReference)) {\n        // Prevent scrolling\n        event.preventDefault();\n        didKeyDownRef.current = true;\n      }\n      if (event.key === 'Enter') {\n        if (open && toggle) {\n          onOpenChange(false, event.nativeEvent, 'click');\n        } else {\n          onOpenChange(true, event.nativeEvent, 'click');\n        }\n      }\n    },\n    onKeyUp(event) {\n      if (event.defaultPrevented || !keyboardHandlers || isButtonTarget(event) || isSpaceIgnored(domReference)) {\n        return;\n      }\n      if (event.key === ' ' && didKeyDownRef.current) {\n        didKeyDownRef.current = false;\n        if (open && toggle) {\n          onOpenChange(false, event.nativeEvent, 'click');\n        } else {\n          onOpenChange(true, event.nativeEvent, 'click');\n        }\n      }\n    }\n  }), [dataRef, domReference, eventOption, ignoreMouse, keyboardHandlers, onOpenChange, open, stickIfOpen, toggle]);\n  return React.useMemo(() => enabled ? {\n    reference\n  } : {}, [enabled, reference]);\n}\n\nfunction createVirtualElement(domElement, data) {\n  let offsetX = null;\n  let offsetY = null;\n  let isAutoUpdateEvent = false;\n  return {\n    contextElement: domElement || undefined,\n    getBoundingClientRect() {\n      var _data$dataRef$current;\n      const domRect = (domElement == null ? void 0 : domElement.getBoundingClientRect()) || {\n        width: 0,\n        height: 0,\n        x: 0,\n        y: 0\n      };\n      const isXAxis = data.axis === 'x' || data.axis === 'both';\n      const isYAxis = data.axis === 'y' || data.axis === 'both';\n      const canTrackCursorOnAutoUpdate = ['mouseenter', 'mousemove'].includes(((_data$dataRef$current = data.dataRef.current.openEvent) == null ? void 0 : _data$dataRef$current.type) || '') && data.pointerType !== 'touch';\n      let width = domRect.width;\n      let height = domRect.height;\n      let x = domRect.x;\n      let y = domRect.y;\n      if (offsetX == null && data.x && isXAxis) {\n        offsetX = domRect.x - data.x;\n      }\n      if (offsetY == null && data.y && isYAxis) {\n        offsetY = domRect.y - data.y;\n      }\n      x -= offsetX || 0;\n      y -= offsetY || 0;\n      width = 0;\n      height = 0;\n      if (!isAutoUpdateEvent || canTrackCursorOnAutoUpdate) {\n        width = data.axis === 'y' ? domRect.width : 0;\n        height = data.axis === 'x' ? domRect.height : 0;\n        x = isXAxis && data.x != null ? data.x : x;\n        y = isYAxis && data.y != null ? data.y : y;\n      } else if (isAutoUpdateEvent && !canTrackCursorOnAutoUpdate) {\n        height = data.axis === 'x' ? domRect.height : height;\n        width = data.axis === 'y' ? domRect.width : width;\n      }\n      isAutoUpdateEvent = true;\n      return {\n        width,\n        height,\n        x,\n        y,\n        top: y,\n        right: x + width,\n        bottom: y + height,\n        left: x\n      };\n    }\n  };\n}\nfunction isMouseBasedEvent(event) {\n  return event != null && event.clientX != null;\n}\n/**\n * Positions the floating element relative to a client point (in the viewport),\n * such as the mouse position. By default, it follows the mouse cursor.\n * @see https://floating-ui.com/docs/useClientPoint\n */\nfunction useClientPoint(context, props) {\n  if (props === void 0) {\n    props = {};\n  }\n  const {\n    open,\n    dataRef,\n    elements: {\n      floating,\n      domReference\n    },\n    refs\n  } = context;\n  const {\n    enabled = true,\n    axis = 'both',\n    x = null,\n    y = null\n  } = props;\n  const initialRef = React.useRef(false);\n  const cleanupListenerRef = React.useRef(null);\n  const [pointerType, setPointerType] = React.useState();\n  const [reactive, setReactive] = React.useState([]);\n  const setReference = useEffectEvent((x, y) => {\n    if (initialRef.current) return;\n\n    // Prevent setting if the open event was not a mouse-like one\n    // (e.g. focus to open, then hover over the reference element).\n    // Only apply if the event exists.\n    if (dataRef.current.openEvent && !isMouseBasedEvent(dataRef.current.openEvent)) {\n      return;\n    }\n    refs.setPositionReference(createVirtualElement(domReference, {\n      x,\n      y,\n      axis,\n      dataRef,\n      pointerType\n    }));\n  });\n  const handleReferenceEnterOrMove = useEffectEvent(event => {\n    if (x != null || y != null) return;\n    if (!open) {\n      setReference(event.clientX, event.clientY);\n    } else if (!cleanupListenerRef.current) {\n      // If there's no cleanup, there's no listener, but we want to ensure\n      // we add the listener if the cursor landed on the floating element and\n      // then back on the reference (i.e. it's interactive).\n      setReactive([]);\n    }\n  });\n\n  // If the pointer is a mouse-like pointer, we want to continue following the\n  // mouse even if the floating element is transitioning out. On touch\n  // devices, this is undesirable because the floating element will move to\n  // the dismissal touch point.\n  const openCheck = isMouseLikePointerType(pointerType) ? floating : open;\n  const addListener = React.useCallback(() => {\n    // Explicitly specified `x`/`y` coordinates shouldn't add a listener.\n    if (!openCheck || !enabled || x != null || y != null) return;\n    const win = getWindow(floating);\n    function handleMouseMove(event) {\n      const target = getTarget(event);\n      if (!contains(floating, target)) {\n        setReference(event.clientX, event.clientY);\n      } else {\n        win.removeEventListener('mousemove', handleMouseMove);\n        cleanupListenerRef.current = null;\n      }\n    }\n    if (!dataRef.current.openEvent || isMouseBasedEvent(dataRef.current.openEvent)) {\n      win.addEventListener('mousemove', handleMouseMove);\n      const cleanup = () => {\n        win.removeEventListener('mousemove', handleMouseMove);\n        cleanupListenerRef.current = null;\n      };\n      cleanupListenerRef.current = cleanup;\n      return cleanup;\n    }\n    refs.setPositionReference(domReference);\n  }, [openCheck, enabled, x, y, floating, dataRef, refs, domReference, setReference]);\n  React.useEffect(() => {\n    return addListener();\n  }, [addListener, reactive]);\n  React.useEffect(() => {\n    if (enabled && !floating) {\n      initialRef.current = false;\n    }\n  }, [enabled, floating]);\n  React.useEffect(() => {\n    if (!enabled && open) {\n      initialRef.current = true;\n    }\n  }, [enabled, open]);\n  index(() => {\n    if (enabled && (x != null || y != null)) {\n      initialRef.current = false;\n      setReference(x, y);\n    }\n  }, [enabled, x, y, setReference]);\n  const reference = React.useMemo(() => {\n    function setPointerTypeRef(_ref) {\n      let {\n        pointerType\n      } = _ref;\n      setPointerType(pointerType);\n    }\n    return {\n      onPointerDown: setPointerTypeRef,\n      onPointerEnter: setPointerTypeRef,\n      onMouseMove: handleReferenceEnterOrMove,\n      onMouseEnter: handleReferenceEnterOrMove\n    };\n  }, [handleReferenceEnterOrMove]);\n  return React.useMemo(() => enabled ? {\n    reference\n  } : {}, [enabled, reference]);\n}\n\nconst bubbleHandlerKeys = {\n  pointerdown: 'onPointerDown',\n  mousedown: 'onMouseDown',\n  click: 'onClick'\n};\nconst captureHandlerKeys = {\n  pointerdown: 'onPointerDownCapture',\n  mousedown: 'onMouseDownCapture',\n  click: 'onClickCapture'\n};\nconst normalizeProp = normalizable => {\n  var _normalizable$escapeK, _normalizable$outside;\n  return {\n    escapeKey: typeof normalizable === 'boolean' ? normalizable : (_normalizable$escapeK = normalizable == null ? void 0 : normalizable.escapeKey) != null ? _normalizable$escapeK : false,\n    outsidePress: typeof normalizable === 'boolean' ? normalizable : (_normalizable$outside = normalizable == null ? void 0 : normalizable.outsidePress) != null ? _normalizable$outside : true\n  };\n};\n/**\n * Closes the floating element when a dismissal is requested — by default, when\n * the user presses the `escape` key or outside of the floating element.\n * @see https://floating-ui.com/docs/useDismiss\n */\nfunction useDismiss(context, props) {\n  if (props === void 0) {\n    props = {};\n  }\n  const {\n    open,\n    onOpenChange,\n    elements,\n    dataRef\n  } = context;\n  const {\n    enabled = true,\n    escapeKey = true,\n    outsidePress: unstable_outsidePress = true,\n    outsidePressEvent = 'pointerdown',\n    referencePress = false,\n    referencePressEvent = 'pointerdown',\n    ancestorScroll = false,\n    bubbles,\n    capture\n  } = props;\n  const tree = useFloatingTree();\n  const outsidePressFn = useEffectEvent(typeof unstable_outsidePress === 'function' ? unstable_outsidePress : () => false);\n  const outsidePress = typeof unstable_outsidePress === 'function' ? outsidePressFn : unstable_outsidePress;\n  const insideReactTreeRef = React.useRef(false);\n  const endedOrStartedInsideRef = React.useRef(false);\n  const {\n    escapeKey: escapeKeyBubbles,\n    outsidePress: outsidePressBubbles\n  } = normalizeProp(bubbles);\n  const {\n    escapeKey: escapeKeyCapture,\n    outsidePress: outsidePressCapture\n  } = normalizeProp(capture);\n  const isComposingRef = React.useRef(false);\n  const closeOnEscapeKeyDown = useEffectEvent(event => {\n    var _dataRef$current$floa;\n    if (!open || !enabled || !escapeKey || event.key !== 'Escape') {\n      return;\n    }\n\n    // Wait until IME is settled. Pressing `Escape` while composing should\n    // close the compose menu, but not the floating element.\n    if (isComposingRef.current) {\n      return;\n    }\n    const nodeId = (_dataRef$current$floa = dataRef.current.floatingContext) == null ? void 0 : _dataRef$current$floa.nodeId;\n    const children = tree ? getChildren(tree.nodesRef.current, nodeId) : [];\n    if (!escapeKeyBubbles) {\n      event.stopPropagation();\n      if (children.length > 0) {\n        let shouldDismiss = true;\n        children.forEach(child => {\n          var _child$context;\n          if ((_child$context = child.context) != null && _child$context.open && !child.context.dataRef.current.__escapeKeyBubbles) {\n            shouldDismiss = false;\n            return;\n          }\n        });\n        if (!shouldDismiss) {\n          return;\n        }\n      }\n    }\n    onOpenChange(false, isReactEvent(event) ? event.nativeEvent : event, 'escape-key');\n  });\n  const closeOnEscapeKeyDownCapture = useEffectEvent(event => {\n    var _getTarget2;\n    const callback = () => {\n      var _getTarget;\n      closeOnEscapeKeyDown(event);\n      (_getTarget = getTarget(event)) == null || _getTarget.removeEventListener('keydown', callback);\n    };\n    (_getTarget2 = getTarget(event)) == null || _getTarget2.addEventListener('keydown', callback);\n  });\n  const closeOnPressOutside = useEffectEvent(event => {\n    var _dataRef$current$floa2;\n    // Given developers can stop the propagation of the synthetic event,\n    // we can only be confident with a positive value.\n    const insideReactTree = insideReactTreeRef.current;\n    insideReactTreeRef.current = false;\n\n    // When click outside is lazy (`click` event), handle dragging.\n    // Don't close if:\n    // - The click started inside the floating element.\n    // - The click ended inside the floating element.\n    const endedOrStartedInside = endedOrStartedInsideRef.current;\n    endedOrStartedInsideRef.current = false;\n    if (outsidePressEvent === 'click' && endedOrStartedInside) {\n      return;\n    }\n    if (insideReactTree) {\n      return;\n    }\n    if (typeof outsidePress === 'function' && !outsidePress(event)) {\n      return;\n    }\n    const target = getTarget(event);\n    const inertSelector = \"[\" + createAttribute('inert') + \"]\";\n    const markers = getDocument(elements.floating).querySelectorAll(inertSelector);\n    let targetRootAncestor = isElement(target) ? target : null;\n    while (targetRootAncestor && !isLastTraversableNode(targetRootAncestor)) {\n      const nextParent = getParentNode(targetRootAncestor);\n      if (isLastTraversableNode(nextParent) || !isElement(nextParent)) {\n        break;\n      }\n      targetRootAncestor = nextParent;\n    }\n\n    // Check if the click occurred on a third-party element injected after the\n    // floating element rendered.\n    if (markers.length && isElement(target) && !isRootElement(target) &&\n    // Clicked on a direct ancestor (e.g. FloatingOverlay).\n    !contains(target, elements.floating) &&\n    // If the target root element contains none of the markers, then the\n    // element was injected after the floating element rendered.\n    Array.from(markers).every(marker => !contains(targetRootAncestor, marker))) {\n      return;\n    }\n\n    // Check if the click occurred on the scrollbar\n    if (isHTMLElement(target) && floating) {\n      const lastTraversableNode = isLastTraversableNode(target);\n      const style = getComputedStyle(target);\n      const scrollRe = /auto|scroll/;\n      const isScrollableX = lastTraversableNode || scrollRe.test(style.overflowX);\n      const isScrollableY = lastTraversableNode || scrollRe.test(style.overflowY);\n      const canScrollX = isScrollableX && target.clientWidth > 0 && target.scrollWidth > target.clientWidth;\n      const canScrollY = isScrollableY && target.clientHeight > 0 && target.scrollHeight > target.clientHeight;\n      const isRTL = style.direction === 'rtl';\n\n      // Check click position relative to scrollbar.\n      // In some browsers it is possible to change the <body> (or window)\n      // scrollbar to the left side, but is very rare and is difficult to\n      // check for. Plus, for modal dialogs with backdrops, it is more\n      // important that the backdrop is checked but not so much the window.\n      const pressedVerticalScrollbar = canScrollY && (isRTL ? event.offsetX <= target.offsetWidth - target.clientWidth : event.offsetX > target.clientWidth);\n      const pressedHorizontalScrollbar = canScrollX && event.offsetY > target.clientHeight;\n      if (pressedVerticalScrollbar || pressedHorizontalScrollbar) {\n        return;\n      }\n    }\n    const nodeId = (_dataRef$current$floa2 = dataRef.current.floatingContext) == null ? void 0 : _dataRef$current$floa2.nodeId;\n    const targetIsInsideChildren = tree && getChildren(tree.nodesRef.current, nodeId).some(node => {\n      var _node$context;\n      return isEventTargetWithin(event, (_node$context = node.context) == null ? void 0 : _node$context.elements.floating);\n    });\n    if (isEventTargetWithin(event, elements.floating) || isEventTargetWithin(event, elements.domReference) || targetIsInsideChildren) {\n      return;\n    }\n    const children = tree ? getChildren(tree.nodesRef.current, nodeId) : [];\n    if (children.length > 0) {\n      let shouldDismiss = true;\n      children.forEach(child => {\n        var _child$context2;\n        if ((_child$context2 = child.context) != null && _child$context2.open && !child.context.dataRef.current.__outsidePressBubbles) {\n          shouldDismiss = false;\n          return;\n        }\n      });\n      if (!shouldDismiss) {\n        return;\n      }\n    }\n    onOpenChange(false, event, 'outside-press');\n  });\n  const closeOnPressOutsideCapture = useEffectEvent(event => {\n    var _getTarget4;\n    const callback = () => {\n      var _getTarget3;\n      closeOnPressOutside(event);\n      (_getTarget3 = getTarget(event)) == null || _getTarget3.removeEventListener(outsidePressEvent, callback);\n    };\n    (_getTarget4 = getTarget(event)) == null || _getTarget4.addEventListener(outsidePressEvent, callback);\n  });\n  React.useEffect(() => {\n    if (!open || !enabled) {\n      return;\n    }\n    dataRef.current.__escapeKeyBubbles = escapeKeyBubbles;\n    dataRef.current.__outsidePressBubbles = outsidePressBubbles;\n    let compositionTimeout = -1;\n    function onScroll(event) {\n      onOpenChange(false, event, 'ancestor-scroll');\n    }\n    function handleCompositionStart() {\n      window.clearTimeout(compositionTimeout);\n      isComposingRef.current = true;\n    }\n    function handleCompositionEnd() {\n      // Safari fires `compositionend` before `keydown`, so we need to wait\n      // until the next tick to set `isComposing` to `false`.\n      // https://bugs.webkit.org/show_bug.cgi?id=165004\n      compositionTimeout = window.setTimeout(() => {\n        isComposingRef.current = false;\n      },\n      // 0ms or 1ms don't work in Safari. 5ms appears to consistently work.\n      // Only apply to WebKit for the test to remain 0ms.\n      isWebKit() ? 5 : 0);\n    }\n    const doc = getDocument(elements.floating);\n    if (escapeKey) {\n      doc.addEventListener('keydown', escapeKeyCapture ? closeOnEscapeKeyDownCapture : closeOnEscapeKeyDown, escapeKeyCapture);\n      doc.addEventListener('compositionstart', handleCompositionStart);\n      doc.addEventListener('compositionend', handleCompositionEnd);\n    }\n    outsidePress && doc.addEventListener(outsidePressEvent, outsidePressCapture ? closeOnPressOutsideCapture : closeOnPressOutside, outsidePressCapture);\n    let ancestors = [];\n    if (ancestorScroll) {\n      if (isElement(elements.domReference)) {\n        ancestors = getOverflowAncestors(elements.domReference);\n      }\n      if (isElement(elements.floating)) {\n        ancestors = ancestors.concat(getOverflowAncestors(elements.floating));\n      }\n      if (!isElement(elements.reference) && elements.reference && elements.reference.contextElement) {\n        ancestors = ancestors.concat(getOverflowAncestors(elements.reference.contextElement));\n      }\n    }\n\n    // Ignore the visual viewport for scrolling dismissal (allow pinch-zoom)\n    ancestors = ancestors.filter(ancestor => {\n      var _doc$defaultView;\n      return ancestor !== ((_doc$defaultView = doc.defaultView) == null ? void 0 : _doc$defaultView.visualViewport);\n    });\n    ancestors.forEach(ancestor => {\n      ancestor.addEventListener('scroll', onScroll, {\n        passive: true\n      });\n    });\n    return () => {\n      if (escapeKey) {\n        doc.removeEventListener('keydown', escapeKeyCapture ? closeOnEscapeKeyDownCapture : closeOnEscapeKeyDown, escapeKeyCapture);\n        doc.removeEventListener('compositionstart', handleCompositionStart);\n        doc.removeEventListener('compositionend', handleCompositionEnd);\n      }\n      outsidePress && doc.removeEventListener(outsidePressEvent, outsidePressCapture ? closeOnPressOutsideCapture : closeOnPressOutside, outsidePressCapture);\n      ancestors.forEach(ancestor => {\n        ancestor.removeEventListener('scroll', onScroll);\n      });\n      window.clearTimeout(compositionTimeout);\n    };\n  }, [dataRef, elements, escapeKey, outsidePress, outsidePressEvent, open, onOpenChange, ancestorScroll, enabled, escapeKeyBubbles, outsidePressBubbles, closeOnEscapeKeyDown, escapeKeyCapture, closeOnEscapeKeyDownCapture, closeOnPressOutside, outsidePressCapture, closeOnPressOutsideCapture]);\n  React.useEffect(() => {\n    insideReactTreeRef.current = false;\n  }, [outsidePress, outsidePressEvent]);\n  const reference = React.useMemo(() => ({\n    onKeyDown: closeOnEscapeKeyDown,\n    ...(referencePress && {\n      [bubbleHandlerKeys[referencePressEvent]]: event => {\n        onOpenChange(false, event.nativeEvent, 'reference-press');\n      },\n      ...(referencePressEvent !== 'click' && {\n        onClick(event) {\n          onOpenChange(false, event.nativeEvent, 'reference-press');\n        }\n      })\n    })\n  }), [closeOnEscapeKeyDown, onOpenChange, referencePress, referencePressEvent]);\n  const floating = React.useMemo(() => ({\n    onKeyDown: closeOnEscapeKeyDown,\n    onMouseDown() {\n      endedOrStartedInsideRef.current = true;\n    },\n    onMouseUp() {\n      endedOrStartedInsideRef.current = true;\n    },\n    [captureHandlerKeys[outsidePressEvent]]: () => {\n      insideReactTreeRef.current = true;\n    }\n  }), [closeOnEscapeKeyDown, outsidePressEvent]);\n  return React.useMemo(() => enabled ? {\n    reference,\n    floating\n  } : {}, [enabled, reference, floating]);\n}\n\nfunction useFloatingRootContext(options) {\n  const {\n    open = false,\n    onOpenChange: onOpenChangeProp,\n    elements: elementsProp\n  } = options;\n  const floatingId = useId();\n  const dataRef = React.useRef({});\n  const [events] = React.useState(() => createPubSub());\n  const nested = useFloatingParentNodeId() != null;\n  if (process.env.NODE_ENV !== \"production\") {\n    const optionDomReference = elementsProp.reference;\n    if (optionDomReference && !isElement(optionDomReference)) {\n      error('Cannot pass a virtual element to the `elements.reference` option,', 'as it must be a real DOM element. Use `refs.setPositionReference()`', 'instead.');\n    }\n  }\n  const [positionReference, setPositionReference] = React.useState(elementsProp.reference);\n  const onOpenChange = useEffectEvent((open, event, reason) => {\n    dataRef.current.openEvent = open ? event : undefined;\n    events.emit('openchange', {\n      open,\n      event,\n      reason,\n      nested\n    });\n    onOpenChangeProp == null || onOpenChangeProp(open, event, reason);\n  });\n  const refs = React.useMemo(() => ({\n    setPositionReference\n  }), []);\n  const elements = React.useMemo(() => ({\n    reference: positionReference || elementsProp.reference || null,\n    floating: elementsProp.floating || null,\n    domReference: elementsProp.reference\n  }), [positionReference, elementsProp.reference, elementsProp.floating]);\n  return React.useMemo(() => ({\n    dataRef,\n    open,\n    onOpenChange,\n    elements,\n    events,\n    floatingId,\n    refs\n  }), [open, onOpenChange, elements, events, floatingId, refs]);\n}\n\n/**\n * Provides data to position a floating element and context to add interactions.\n * @see https://floating-ui.com/docs/useFloating\n */\nfunction useFloating(options) {\n  if (options === void 0) {\n    options = {};\n  }\n  const {\n    nodeId\n  } = options;\n  const internalRootContext = useFloatingRootContext({\n    ...options,\n    elements: {\n      reference: null,\n      floating: null,\n      ...options.elements\n    }\n  });\n  const rootContext = options.rootContext || internalRootContext;\n  const computedElements = rootContext.elements;\n  const [_domReference, setDomReference] = React.useState(null);\n  const [positionReference, _setPositionReference] = React.useState(null);\n  const optionDomReference = computedElements == null ? void 0 : computedElements.domReference;\n  const domReference = optionDomReference || _domReference;\n  const domReferenceRef = React.useRef(null);\n  const tree = useFloatingTree();\n  index(() => {\n    if (domReference) {\n      domReferenceRef.current = domReference;\n    }\n  }, [domReference]);\n  const position = useFloating$1({\n    ...options,\n    elements: {\n      ...computedElements,\n      ...(positionReference && {\n        reference: positionReference\n      })\n    }\n  });\n  const setPositionReference = React.useCallback(node => {\n    const computedPositionReference = isElement(node) ? {\n      getBoundingClientRect: () => node.getBoundingClientRect(),\n      contextElement: node\n    } : node;\n    // Store the positionReference in state if the DOM reference is specified externally via the\n    // `elements.reference` option. This ensures that it won't be overridden on future renders.\n    _setPositionReference(computedPositionReference);\n    position.refs.setReference(computedPositionReference);\n  }, [position.refs]);\n  const setReference = React.useCallback(node => {\n    if (isElement(node) || node === null) {\n      domReferenceRef.current = node;\n      setDomReference(node);\n    }\n\n    // Backwards-compatibility for passing a virtual element to `reference`\n    // after it has set the DOM reference.\n    if (isElement(position.refs.reference.current) || position.refs.reference.current === null ||\n    // Don't allow setting virtual elements using the old technique back to\n    // `null` to support `positionReference` + an unstable `reference`\n    // callback ref.\n    node !== null && !isElement(node)) {\n      position.refs.setReference(node);\n    }\n  }, [position.refs]);\n  const refs = React.useMemo(() => ({\n    ...position.refs,\n    setReference,\n    setPositionReference,\n    domReference: domReferenceRef\n  }), [position.refs, setReference, setPositionReference]);\n  const elements = React.useMemo(() => ({\n    ...position.elements,\n    domReference: domReference\n  }), [position.elements, domReference]);\n  const context = React.useMemo(() => ({\n    ...position,\n    ...rootContext,\n    refs,\n    elements,\n    nodeId\n  }), [position, refs, elements, nodeId, rootContext]);\n  index(() => {\n    rootContext.dataRef.current.floatingContext = context;\n    const node = tree == null ? void 0 : tree.nodesRef.current.find(node => node.id === nodeId);\n    if (node) {\n      node.context = context;\n    }\n  });\n  return React.useMemo(() => ({\n    ...position,\n    context,\n    refs,\n    elements\n  }), [position, refs, elements, context]);\n}\n\n/**\n * Opens the floating element while the reference element has focus, like CSS\n * `:focus`.\n * @see https://floating-ui.com/docs/useFocus\n */\nfunction useFocus(context, props) {\n  if (props === void 0) {\n    props = {};\n  }\n  const {\n    open,\n    onOpenChange,\n    events,\n    dataRef,\n    elements\n  } = context;\n  const {\n    enabled = true,\n    visibleOnly = true\n  } = props;\n  const blockFocusRef = React.useRef(false);\n  const timeoutRef = React.useRef();\n  const keyboardModalityRef = React.useRef(true);\n  React.useEffect(() => {\n    if (!enabled) return;\n    const win = getWindow(elements.domReference);\n\n    // If the reference was focused and the user left the tab/window, and the\n    // floating element was not open, the focus should be blocked when they\n    // return to the tab/window.\n    function onBlur() {\n      if (!open && isHTMLElement(elements.domReference) && elements.domReference === activeElement(getDocument(elements.domReference))) {\n        blockFocusRef.current = true;\n      }\n    }\n    function onKeyDown() {\n      keyboardModalityRef.current = true;\n    }\n    win.addEventListener('blur', onBlur);\n    win.addEventListener('keydown', onKeyDown, true);\n    return () => {\n      win.removeEventListener('blur', onBlur);\n      win.removeEventListener('keydown', onKeyDown, true);\n    };\n  }, [elements.domReference, open, enabled]);\n  React.useEffect(() => {\n    if (!enabled) return;\n    function onOpenChange(_ref) {\n      let {\n        reason\n      } = _ref;\n      if (reason === 'reference-press' || reason === 'escape-key') {\n        blockFocusRef.current = true;\n      }\n    }\n    events.on('openchange', onOpenChange);\n    return () => {\n      events.off('openchange', onOpenChange);\n    };\n  }, [events, enabled]);\n  React.useEffect(() => {\n    return () => {\n      clearTimeout(timeoutRef.current);\n    };\n  }, []);\n  const reference = React.useMemo(() => ({\n    onPointerDown(event) {\n      if (isVirtualPointerEvent(event.nativeEvent)) return;\n      keyboardModalityRef.current = false;\n    },\n    onMouseLeave() {\n      blockFocusRef.current = false;\n    },\n    onFocus(event) {\n      if (blockFocusRef.current) return;\n      const target = getTarget(event.nativeEvent);\n      if (visibleOnly && isElement(target)) {\n        try {\n          // Mac Safari unreliably matches `:focus-visible` on the reference\n          // if focus was outside the page initially - use the fallback\n          // instead.\n          if (isSafari() && isMac()) throw Error();\n          if (!target.matches(':focus-visible')) return;\n        } catch (e) {\n          // Old browsers will throw an error when using `:focus-visible`.\n          if (!keyboardModalityRef.current && !isTypeableElement(target)) {\n            return;\n          }\n        }\n      }\n      onOpenChange(true, event.nativeEvent, 'focus');\n    },\n    onBlur(event) {\n      blockFocusRef.current = false;\n      const relatedTarget = event.relatedTarget;\n      const nativeEvent = event.nativeEvent;\n\n      // Hit the non-modal focus management portal guard. Focus will be\n      // moved into the floating element immediately after.\n      const movedToFocusGuard = isElement(relatedTarget) && relatedTarget.hasAttribute(createAttribute('focus-guard')) && relatedTarget.getAttribute('data-type') === 'outside';\n\n      // Wait for the window blur listener to fire.\n      timeoutRef.current = window.setTimeout(() => {\n        var _dataRef$current$floa;\n        const activeEl = activeElement(elements.domReference ? elements.domReference.ownerDocument : document);\n\n        // Focus left the page, keep it open.\n        if (!relatedTarget && activeEl === elements.domReference) return;\n\n        // When focusing the reference element (e.g. regular click), then\n        // clicking into the floating element, prevent it from hiding.\n        // Note: it must be focusable, e.g. `tabindex=\"-1\"`.\n        // We can not rely on relatedTarget to point to the correct element\n        // as it will only point to the shadow host of the newly focused element\n        // and not the element that actually has received focus if it is located\n        // inside a shadow root.\n        if (contains((_dataRef$current$floa = dataRef.current.floatingContext) == null ? void 0 : _dataRef$current$floa.refs.floating.current, activeEl) || contains(elements.domReference, activeEl) || movedToFocusGuard) {\n          return;\n        }\n        onOpenChange(false, nativeEvent, 'focus');\n      });\n    }\n  }), [dataRef, elements.domReference, onOpenChange, visibleOnly]);\n  return React.useMemo(() => enabled ? {\n    reference\n  } : {}, [enabled, reference]);\n}\n\nconst ACTIVE_KEY = 'active';\nconst SELECTED_KEY = 'selected';\nfunction mergeProps(userProps, propsList, elementKey) {\n  const map = new Map();\n  const isItem = elementKey === 'item';\n  let domUserProps = userProps;\n  if (isItem && userProps) {\n    const {\n      [ACTIVE_KEY]: _,\n      [SELECTED_KEY]: __,\n      ...validProps\n    } = userProps;\n    domUserProps = validProps;\n  }\n  return {\n    ...(elementKey === 'floating' && {\n      tabIndex: -1,\n      [FOCUSABLE_ATTRIBUTE]: ''\n    }),\n    ...domUserProps,\n    ...propsList.map(value => {\n      const propsOrGetProps = value ? value[elementKey] : null;\n      if (typeof propsOrGetProps === 'function') {\n        return userProps ? propsOrGetProps(userProps) : null;\n      }\n      return propsOrGetProps;\n    }).concat(userProps).reduce((acc, props) => {\n      if (!props) {\n        return acc;\n      }\n      Object.entries(props).forEach(_ref => {\n        let [key, value] = _ref;\n        if (isItem && [ACTIVE_KEY, SELECTED_KEY].includes(key)) {\n          return;\n        }\n        if (key.indexOf('on') === 0) {\n          if (!map.has(key)) {\n            map.set(key, []);\n          }\n          if (typeof value === 'function') {\n            var _map$get;\n            (_map$get = map.get(key)) == null || _map$get.push(value);\n            acc[key] = function () {\n              var _map$get2;\n              for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n                args[_key] = arguments[_key];\n              }\n              return (_map$get2 = map.get(key)) == null ? void 0 : _map$get2.map(fn => fn(...args)).find(val => val !== undefined);\n            };\n          }\n        } else {\n          acc[key] = value;\n        }\n      });\n      return acc;\n    }, {})\n  };\n}\n/**\n * Merges an array of interaction hooks' props into prop getters, allowing\n * event handler functions to be composed together without overwriting one\n * another.\n * @see https://floating-ui.com/docs/useInteractions\n */\nfunction useInteractions(propsList) {\n  if (propsList === void 0) {\n    propsList = [];\n  }\n  const referenceDeps = propsList.map(key => key == null ? void 0 : key.reference);\n  const floatingDeps = propsList.map(key => key == null ? void 0 : key.floating);\n  const itemDeps = propsList.map(key => key == null ? void 0 : key.item);\n  const getReferenceProps = React.useCallback(userProps => mergeProps(userProps, propsList, 'reference'),\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  referenceDeps);\n  const getFloatingProps = React.useCallback(userProps => mergeProps(userProps, propsList, 'floating'),\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  floatingDeps);\n  const getItemProps = React.useCallback(userProps => mergeProps(userProps, propsList, 'item'),\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  itemDeps);\n  return React.useMemo(() => ({\n    getReferenceProps,\n    getFloatingProps,\n    getItemProps\n  }), [getReferenceProps, getFloatingProps, getItemProps]);\n}\n\nfunction doSwitch(orientation, vertical, horizontal) {\n  switch (orientation) {\n    case 'vertical':\n      return vertical;\n    case 'horizontal':\n      return horizontal;\n    default:\n      return vertical || horizontal;\n  }\n}\nfunction isMainOrientationKey(key, orientation) {\n  const vertical = key === ARROW_UP || key === ARROW_DOWN;\n  const horizontal = key === ARROW_LEFT || key === ARROW_RIGHT;\n  return doSwitch(orientation, vertical, horizontal);\n}\nfunction isMainOrientationToEndKey(key, orientation, rtl) {\n  const vertical = key === ARROW_DOWN;\n  const horizontal = rtl ? key === ARROW_LEFT : key === ARROW_RIGHT;\n  return doSwitch(orientation, vertical, horizontal) || key === 'Enter' || key === ' ' || key === '';\n}\nfunction isCrossOrientationOpenKey(key, orientation, rtl) {\n  const vertical = rtl ? key === ARROW_LEFT : key === ARROW_RIGHT;\n  const horizontal = key === ARROW_DOWN;\n  return doSwitch(orientation, vertical, horizontal);\n}\nfunction isCrossOrientationCloseKey(key, orientation, rtl) {\n  const vertical = rtl ? key === ARROW_RIGHT : key === ARROW_LEFT;\n  const horizontal = key === ARROW_UP;\n  return doSwitch(orientation, vertical, horizontal);\n}\n/**\n * Adds arrow key-based navigation of a list of items, either using real DOM\n * focus or virtual focus.\n * @see https://floating-ui.com/docs/useListNavigation\n */\nfunction useListNavigation(context, props) {\n  const {\n    open,\n    onOpenChange,\n    elements\n  } = context;\n  const {\n    listRef,\n    activeIndex,\n    onNavigate: unstable_onNavigate = () => {},\n    enabled = true,\n    selectedIndex = null,\n    allowEscape = false,\n    loop = false,\n    nested = false,\n    rtl = false,\n    virtual = false,\n    focusItemOnOpen = 'auto',\n    focusItemOnHover = true,\n    openOnArrowKeyDown = true,\n    disabledIndices = undefined,\n    orientation = 'vertical',\n    cols = 1,\n    scrollItemIntoView = true,\n    virtualItemRef,\n    itemSizes,\n    dense = false\n  } = props;\n  if (process.env.NODE_ENV !== \"production\") {\n    if (allowEscape) {\n      if (!loop) {\n        warn('`useListNavigation` looping must be enabled to allow escaping.');\n      }\n      if (!virtual) {\n        warn('`useListNavigation` must be virtual to allow escaping.');\n      }\n    }\n    if (orientation === 'vertical' && cols > 1) {\n      warn('In grid list navigation mode (`cols` > 1), the `orientation` should', 'be either \"horizontal\" or \"both\".');\n    }\n  }\n  const floatingFocusElement = getFloatingFocusElement(elements.floating);\n  const floatingFocusElementRef = useLatestRef(floatingFocusElement);\n  const parentId = useFloatingParentNodeId();\n  const tree = useFloatingTree();\n  const onNavigate = useEffectEvent(() => {\n    unstable_onNavigate(indexRef.current === -1 ? null : indexRef.current);\n  });\n  const typeableComboboxReference = isTypeableCombobox(elements.domReference);\n  const focusItemOnOpenRef = React.useRef(focusItemOnOpen);\n  const indexRef = React.useRef(selectedIndex != null ? selectedIndex : -1);\n  const keyRef = React.useRef(null);\n  const isPointerModalityRef = React.useRef(true);\n  const previousOnNavigateRef = React.useRef(onNavigate);\n  const previousMountedRef = React.useRef(!!elements.floating);\n  const previousOpenRef = React.useRef(open);\n  const forceSyncFocusRef = React.useRef(false);\n  const forceScrollIntoViewRef = React.useRef(false);\n  const disabledIndicesRef = useLatestRef(disabledIndices);\n  const latestOpenRef = useLatestRef(open);\n  const scrollItemIntoViewRef = useLatestRef(scrollItemIntoView);\n  const selectedIndexRef = useLatestRef(selectedIndex);\n  const [activeId, setActiveId] = React.useState();\n  const [virtualId, setVirtualId] = React.useState();\n  const focusItem = useEffectEvent(() => {\n    function runFocus(item) {\n      if (virtual) {\n        setActiveId(item.id);\n        tree == null || tree.events.emit('virtualfocus', item);\n        if (virtualItemRef) {\n          virtualItemRef.current = item;\n        }\n      } else {\n        enqueueFocus(item, {\n          sync: forceSyncFocusRef.current,\n          preventScroll: true\n        });\n      }\n    }\n    const initialItem = listRef.current[indexRef.current];\n    if (initialItem) {\n      runFocus(initialItem);\n    }\n    const scheduler = forceSyncFocusRef.current ? v => v() : requestAnimationFrame;\n    scheduler(() => {\n      const waitedItem = listRef.current[indexRef.current] || initialItem;\n      if (!waitedItem) return;\n      if (!initialItem) {\n        runFocus(waitedItem);\n      }\n      const scrollIntoViewOptions = scrollItemIntoViewRef.current;\n      const shouldScrollIntoView = scrollIntoViewOptions && item && (forceScrollIntoViewRef.current || !isPointerModalityRef.current);\n      if (shouldScrollIntoView) {\n        // JSDOM doesn't support `.scrollIntoView()` but it's widely supported\n        // by all browsers.\n        waitedItem.scrollIntoView == null || waitedItem.scrollIntoView(typeof scrollIntoViewOptions === 'boolean' ? {\n          block: 'nearest',\n          inline: 'nearest'\n        } : scrollIntoViewOptions);\n      }\n    });\n  });\n\n  // Sync `selectedIndex` to be the `activeIndex` upon opening the floating\n  // element. Also, reset `activeIndex` upon closing the floating element.\n  index(() => {\n    if (!enabled) return;\n    if (open && elements.floating) {\n      if (focusItemOnOpenRef.current && selectedIndex != null) {\n        // Regardless of the pointer modality, we want to ensure the selected\n        // item comes into view when the floating element is opened.\n        forceScrollIntoViewRef.current = true;\n        indexRef.current = selectedIndex;\n        onNavigate();\n      }\n    } else if (previousMountedRef.current) {\n      // Since the user can specify `onNavigate` conditionally\n      // (onNavigate: open ? setActiveIndex : setSelectedIndex),\n      // we store and call the previous function.\n      indexRef.current = -1;\n      previousOnNavigateRef.current();\n    }\n  }, [enabled, open, elements.floating, selectedIndex, onNavigate]);\n\n  // Sync `activeIndex` to be the focused item while the floating element is\n  // open.\n  index(() => {\n    if (!enabled) return;\n    if (!open) return;\n    if (!elements.floating) return;\n    if (activeIndex == null) {\n      forceSyncFocusRef.current = false;\n      if (selectedIndexRef.current != null) {\n        return;\n      }\n\n      // Reset while the floating element was open (e.g. the list changed).\n      if (previousMountedRef.current) {\n        indexRef.current = -1;\n        focusItem();\n      }\n\n      // Initial sync.\n      if ((!previousOpenRef.current || !previousMountedRef.current) && focusItemOnOpenRef.current && (keyRef.current != null || focusItemOnOpenRef.current === true && keyRef.current == null)) {\n        let runs = 0;\n        const waitForListPopulated = () => {\n          if (listRef.current[0] == null) {\n            // Avoid letting the browser paint if possible on the first try,\n            // otherwise use rAF. Don't try more than twice, since something\n            // is wrong otherwise.\n            if (runs < 2) {\n              const scheduler = runs ? requestAnimationFrame : queueMicrotask;\n              scheduler(waitForListPopulated);\n            }\n            runs++;\n          } else {\n            indexRef.current = keyRef.current == null || isMainOrientationToEndKey(keyRef.current, orientation, rtl) || nested ? getMinIndex(listRef, disabledIndicesRef.current) : getMaxIndex(listRef, disabledIndicesRef.current);\n            keyRef.current = null;\n            onNavigate();\n          }\n        };\n        waitForListPopulated();\n      }\n    } else if (!isIndexOutOfBounds(listRef, activeIndex)) {\n      indexRef.current = activeIndex;\n      focusItem();\n      forceScrollIntoViewRef.current = false;\n    }\n  }, [enabled, open, elements.floating, activeIndex, selectedIndexRef, nested, listRef, orientation, rtl, onNavigate, focusItem, disabledIndicesRef]);\n\n  // Ensure the parent floating element has focus when a nested child closes\n  // to allow arrow key navigation to work after the pointer leaves the child.\n  index(() => {\n    var _nodes$find;\n    if (!enabled || elements.floating || !tree || virtual || !previousMountedRef.current) {\n      return;\n    }\n    const nodes = tree.nodesRef.current;\n    const parent = (_nodes$find = nodes.find(node => node.id === parentId)) == null || (_nodes$find = _nodes$find.context) == null ? void 0 : _nodes$find.elements.floating;\n    const activeEl = activeElement(getDocument(elements.floating));\n    const treeContainsActiveEl = nodes.some(node => node.context && contains(node.context.elements.floating, activeEl));\n    if (parent && !treeContainsActiveEl && isPointerModalityRef.current) {\n      parent.focus({\n        preventScroll: true\n      });\n    }\n  }, [enabled, elements.floating, tree, parentId, virtual]);\n  index(() => {\n    if (!enabled) return;\n    if (!tree) return;\n    if (!virtual) return;\n    if (parentId) return;\n    function handleVirtualFocus(item) {\n      setVirtualId(item.id);\n      if (virtualItemRef) {\n        virtualItemRef.current = item;\n      }\n    }\n    tree.events.on('virtualfocus', handleVirtualFocus);\n    return () => {\n      tree.events.off('virtualfocus', handleVirtualFocus);\n    };\n  }, [enabled, tree, virtual, parentId, virtualItemRef]);\n  index(() => {\n    previousOnNavigateRef.current = onNavigate;\n    previousOpenRef.current = open;\n    previousMountedRef.current = !!elements.floating;\n  });\n  index(() => {\n    if (!open) {\n      keyRef.current = null;\n    }\n  }, [open]);\n  const hasActiveIndex = activeIndex != null;\n  const item = React.useMemo(() => {\n    function syncCurrentTarget(currentTarget) {\n      if (!open) return;\n      const index = listRef.current.indexOf(currentTarget);\n      if (index !== -1 && indexRef.current !== index) {\n        indexRef.current = index;\n        onNavigate();\n      }\n    }\n    const props = {\n      onFocus(_ref) {\n        let {\n          currentTarget\n        } = _ref;\n        forceSyncFocusRef.current = true;\n        syncCurrentTarget(currentTarget);\n      },\n      onClick: _ref2 => {\n        let {\n          currentTarget\n        } = _ref2;\n        return currentTarget.focus({\n          preventScroll: true\n        });\n      },\n      // Safari\n      ...(focusItemOnHover && {\n        onMouseMove(_ref3) {\n          let {\n            currentTarget\n          } = _ref3;\n          forceSyncFocusRef.current = true;\n          forceScrollIntoViewRef.current = false;\n          syncCurrentTarget(currentTarget);\n        },\n        onPointerLeave(_ref4) {\n          let {\n            pointerType\n          } = _ref4;\n          if (!isPointerModalityRef.current || pointerType === 'touch') {\n            return;\n          }\n          forceSyncFocusRef.current = true;\n          indexRef.current = -1;\n          onNavigate();\n          if (!virtual) {\n            var _floatingFocusElement;\n            (_floatingFocusElement = floatingFocusElementRef.current) == null || _floatingFocusElement.focus({\n              preventScroll: true\n            });\n          }\n        }\n      })\n    };\n    return props;\n  }, [open, floatingFocusElementRef, focusItemOnHover, listRef, onNavigate, virtual]);\n  const commonOnKeyDown = useEffectEvent(event => {\n    isPointerModalityRef.current = false;\n    forceSyncFocusRef.current = true;\n\n    // When composing a character, Chrome fires ArrowDown twice. Firefox/Safari\n    // don't appear to suffer from this. `event.isComposing` is avoided due to\n    // Safari not supporting it properly (although it's not needed in the first\n    // place for Safari, just avoiding any possible issues).\n    if (event.which === 229) {\n      return;\n    }\n\n    // If the floating element is animating out, ignore navigation. Otherwise,\n    // the `activeIndex` gets set to 0 despite not being open so the next time\n    // the user ArrowDowns, the first item won't be focused.\n    if (!latestOpenRef.current && event.currentTarget === floatingFocusElementRef.current) {\n      return;\n    }\n    if (nested && isCrossOrientationCloseKey(event.key, orientation, rtl)) {\n      stopEvent(event);\n      onOpenChange(false, event.nativeEvent, 'list-navigation');\n      if (isHTMLElement(elements.domReference)) {\n        if (virtual) {\n          tree == null || tree.events.emit('virtualfocus', elements.domReference);\n        } else {\n          elements.domReference.focus();\n        }\n      }\n      return;\n    }\n    const currentIndex = indexRef.current;\n    const minIndex = getMinIndex(listRef, disabledIndices);\n    const maxIndex = getMaxIndex(listRef, disabledIndices);\n    if (!typeableComboboxReference) {\n      if (event.key === 'Home') {\n        stopEvent(event);\n        indexRef.current = minIndex;\n        onNavigate();\n      }\n      if (event.key === 'End') {\n        stopEvent(event);\n        indexRef.current = maxIndex;\n        onNavigate();\n      }\n    }\n\n    // Grid navigation.\n    if (cols > 1) {\n      const sizes = itemSizes || Array.from({\n        length: listRef.current.length\n      }, () => ({\n        width: 1,\n        height: 1\n      }));\n      // To calculate movements on the grid, we use hypothetical cell indices\n      // as if every item was 1x1, then convert back to real indices.\n      const cellMap = buildCellMap(sizes, cols, dense);\n      const minGridIndex = cellMap.findIndex(index => index != null && !isDisabled(listRef.current, index, disabledIndices));\n      // last enabled index\n      const maxGridIndex = cellMap.reduce((foundIndex, index, cellIndex) => index != null && !isDisabled(listRef.current, index, disabledIndices) ? cellIndex : foundIndex, -1);\n      const index = cellMap[getGridNavigatedIndex({\n        current: cellMap.map(itemIndex => itemIndex != null ? listRef.current[itemIndex] : null)\n      }, {\n        event,\n        orientation,\n        loop,\n        rtl,\n        cols,\n        // treat undefined (empty grid spaces) as disabled indices so we\n        // don't end up in them\n        disabledIndices: getCellIndices([...(disabledIndices || listRef.current.map((_, index) => isDisabled(listRef.current, index) ? index : undefined)), undefined], cellMap),\n        minIndex: minGridIndex,\n        maxIndex: maxGridIndex,\n        prevIndex: getCellIndexOfCorner(indexRef.current > maxIndex ? minIndex : indexRef.current, sizes, cellMap, cols,\n        // use a corner matching the edge closest to the direction\n        // we're moving in so we don't end up in the same item. Prefer\n        // top/left over bottom/right.\n        event.key === ARROW_DOWN ? 'bl' : event.key === (rtl ? ARROW_LEFT : ARROW_RIGHT) ? 'tr' : 'tl'),\n        stopEvent: true\n      })];\n      if (index != null) {\n        indexRef.current = index;\n        onNavigate();\n      }\n      if (orientation === 'both') {\n        return;\n      }\n    }\n    if (isMainOrientationKey(event.key, orientation)) {\n      stopEvent(event);\n\n      // Reset the index if no item is focused.\n      if (open && !virtual && activeElement(event.currentTarget.ownerDocument) === event.currentTarget) {\n        indexRef.current = isMainOrientationToEndKey(event.key, orientation, rtl) ? minIndex : maxIndex;\n        onNavigate();\n        return;\n      }\n      if (isMainOrientationToEndKey(event.key, orientation, rtl)) {\n        if (loop) {\n          indexRef.current = currentIndex >= maxIndex ? allowEscape && currentIndex !== listRef.current.length ? -1 : minIndex : findNonDisabledIndex(listRef, {\n            startingIndex: currentIndex,\n            disabledIndices\n          });\n        } else {\n          indexRef.current = Math.min(maxIndex, findNonDisabledIndex(listRef, {\n            startingIndex: currentIndex,\n            disabledIndices\n          }));\n        }\n      } else {\n        if (loop) {\n          indexRef.current = currentIndex <= minIndex ? allowEscape && currentIndex !== -1 ? listRef.current.length : maxIndex : findNonDisabledIndex(listRef, {\n            startingIndex: currentIndex,\n            decrement: true,\n            disabledIndices\n          });\n        } else {\n          indexRef.current = Math.max(minIndex, findNonDisabledIndex(listRef, {\n            startingIndex: currentIndex,\n            decrement: true,\n            disabledIndices\n          }));\n        }\n      }\n      if (isIndexOutOfBounds(listRef, indexRef.current)) {\n        indexRef.current = -1;\n      }\n      onNavigate();\n    }\n  });\n  const ariaActiveDescendantProp = React.useMemo(() => {\n    return virtual && open && hasActiveIndex && {\n      'aria-activedescendant': virtualId || activeId\n    };\n  }, [virtual, open, hasActiveIndex, virtualId, activeId]);\n  const floating = React.useMemo(() => {\n    return {\n      'aria-orientation': orientation === 'both' ? undefined : orientation,\n      ...(!typeableComboboxReference ? ariaActiveDescendantProp : {}),\n      onKeyDown: commonOnKeyDown,\n      onPointerMove() {\n        isPointerModalityRef.current = true;\n      }\n    };\n  }, [ariaActiveDescendantProp, commonOnKeyDown, orientation, typeableComboboxReference]);\n  const reference = React.useMemo(() => {\n    function checkVirtualMouse(event) {\n      if (focusItemOnOpen === 'auto' && isVirtualClick(event.nativeEvent)) {\n        focusItemOnOpenRef.current = true;\n      }\n    }\n    function checkVirtualPointer(event) {\n      // `pointerdown` fires first, reset the state then perform the checks.\n      focusItemOnOpenRef.current = focusItemOnOpen;\n      if (focusItemOnOpen === 'auto' && isVirtualPointerEvent(event.nativeEvent)) {\n        focusItemOnOpenRef.current = true;\n      }\n    }\n    return {\n      ...ariaActiveDescendantProp,\n      onKeyDown(event) {\n        isPointerModalityRef.current = false;\n        const isArrowKey = event.key.startsWith('Arrow');\n        const isHomeOrEndKey = ['Home', 'End'].includes(event.key);\n        const isMoveKey = isArrowKey || isHomeOrEndKey;\n        const isCrossOpenKey = isCrossOrientationOpenKey(event.key, orientation, rtl);\n        const isCrossCloseKey = isCrossOrientationCloseKey(event.key, orientation, rtl);\n        const isMainKey = isMainOrientationKey(event.key, orientation);\n        const isNavigationKey = (nested ? isCrossOpenKey : isMainKey) || event.key === 'Enter' || event.key.trim() === '';\n        if (virtual && open) {\n          const rootNode = tree == null ? void 0 : tree.nodesRef.current.find(node => node.parentId == null);\n          const deepestNode = tree && rootNode ? getDeepestNode(tree.nodesRef.current, rootNode.id) : null;\n          if (isMoveKey && deepestNode && virtualItemRef) {\n            const eventObject = new KeyboardEvent('keydown', {\n              key: event.key,\n              bubbles: true\n            });\n            if (isCrossOpenKey || isCrossCloseKey) {\n              var _deepestNode$context, _deepestNode$context2;\n              const isCurrentTarget = ((_deepestNode$context = deepestNode.context) == null ? void 0 : _deepestNode$context.elements.domReference) === event.currentTarget;\n              const dispatchItem = isCrossCloseKey && !isCurrentTarget ? (_deepestNode$context2 = deepestNode.context) == null ? void 0 : _deepestNode$context2.elements.domReference : isCrossOpenKey ? listRef.current.find(item => (item == null ? void 0 : item.id) === activeId) : null;\n              if (dispatchItem) {\n                stopEvent(event);\n                dispatchItem.dispatchEvent(eventObject);\n                setVirtualId(undefined);\n              }\n            }\n            if ((isMainKey || isHomeOrEndKey) && deepestNode.context) {\n              if (deepestNode.context.open && deepestNode.parentId && event.currentTarget !== deepestNode.context.elements.domReference) {\n                var _deepestNode$context$;\n                stopEvent(event);\n                (_deepestNode$context$ = deepestNode.context.elements.domReference) == null || _deepestNode$context$.dispatchEvent(eventObject);\n                return;\n              }\n            }\n          }\n          return commonOnKeyDown(event);\n        }\n\n        // If a floating element should not open on arrow key down, avoid\n        // setting `activeIndex` while it's closed.\n        if (!open && !openOnArrowKeyDown && isArrowKey) {\n          return;\n        }\n        if (isNavigationKey) {\n          keyRef.current = nested && isMainKey ? null : event.key;\n        }\n        if (nested) {\n          if (isCrossOpenKey) {\n            stopEvent(event);\n            if (open) {\n              indexRef.current = getMinIndex(listRef, disabledIndicesRef.current);\n              onNavigate();\n            } else {\n              onOpenChange(true, event.nativeEvent, 'list-navigation');\n            }\n          }\n          return;\n        }\n        if (isMainKey) {\n          if (selectedIndex != null) {\n            indexRef.current = selectedIndex;\n          }\n          stopEvent(event);\n          if (!open && openOnArrowKeyDown) {\n            onOpenChange(true, event.nativeEvent, 'list-navigation');\n          } else {\n            commonOnKeyDown(event);\n          }\n          if (open) {\n            onNavigate();\n          }\n        }\n      },\n      onFocus() {\n        if (open && !virtual) {\n          indexRef.current = -1;\n          onNavigate();\n        }\n      },\n      onPointerDown: checkVirtualPointer,\n      onMouseDown: checkVirtualMouse,\n      onClick: checkVirtualMouse\n    };\n  }, [activeId, ariaActiveDescendantProp, commonOnKeyDown, disabledIndicesRef, focusItemOnOpen, listRef, nested, onNavigate, onOpenChange, open, openOnArrowKeyDown, orientation, rtl, selectedIndex, tree, virtual, virtualItemRef]);\n  return React.useMemo(() => enabled ? {\n    reference,\n    floating,\n    item\n  } : {}, [enabled, reference, floating, item]);\n}\n\nconst componentRoleToAriaRoleMap = /*#__PURE__*/new Map([['select', 'listbox'], ['combobox', 'listbox'], ['label', false]]);\n\n/**\n * Adds base screen reader props to the reference and floating elements for a\n * given floating element `role`.\n * @see https://floating-ui.com/docs/useRole\n */\nfunction useRole(context, props) {\n  var _componentRoleToAriaR;\n  if (props === void 0) {\n    props = {};\n  }\n  const {\n    open,\n    floatingId\n  } = context;\n  const {\n    enabled = true,\n    role = 'dialog'\n  } = props;\n  const ariaRole = (_componentRoleToAriaR = componentRoleToAriaRoleMap.get(role)) != null ? _componentRoleToAriaR : role;\n  const referenceId = useId();\n  const parentId = useFloatingParentNodeId();\n  const isNested = parentId != null;\n  const reference = React.useMemo(() => {\n    if (ariaRole === 'tooltip' || role === 'label') {\n      return {\n        [\"aria-\" + (role === 'label' ? 'labelledby' : 'describedby')]: open ? floatingId : undefined\n      };\n    }\n    return {\n      'aria-expanded': open ? 'true' : 'false',\n      'aria-haspopup': ariaRole === 'alertdialog' ? 'dialog' : ariaRole,\n      'aria-controls': open ? floatingId : undefined,\n      ...(ariaRole === 'listbox' && {\n        role: 'combobox'\n      }),\n      ...(ariaRole === 'menu' && {\n        id: referenceId\n      }),\n      ...(ariaRole === 'menu' && isNested && {\n        role: 'menuitem'\n      }),\n      ...(role === 'select' && {\n        'aria-autocomplete': 'none'\n      }),\n      ...(role === 'combobox' && {\n        'aria-autocomplete': 'list'\n      })\n    };\n  }, [ariaRole, floatingId, isNested, open, referenceId, role]);\n  const floating = React.useMemo(() => {\n    const floatingProps = {\n      id: floatingId,\n      ...(ariaRole && {\n        role: ariaRole\n      })\n    };\n    if (ariaRole === 'tooltip' || role === 'label') {\n      return floatingProps;\n    }\n    return {\n      ...floatingProps,\n      ...(ariaRole === 'menu' && {\n        'aria-labelledby': referenceId\n      })\n    };\n  }, [ariaRole, floatingId, referenceId, role]);\n  const item = React.useCallback(_ref => {\n    let {\n      active,\n      selected\n    } = _ref;\n    const commonProps = {\n      role: 'option',\n      ...(active && {\n        id: floatingId + \"-option\"\n      })\n    };\n\n    // For `menu`, we are unable to tell if the item is a `menuitemradio`\n    // or `menuitemcheckbox`. For backwards-compatibility reasons, also\n    // avoid defaulting to `menuitem` as it may overwrite custom role props.\n    switch (role) {\n      case 'select':\n        return {\n          ...commonProps,\n          'aria-selected': active && selected\n        };\n      case 'combobox':\n        {\n          return {\n            ...commonProps,\n            ...(active && {\n              'aria-selected': true\n            })\n          };\n        }\n    }\n    return {};\n  }, [floatingId, role]);\n  return React.useMemo(() => enabled ? {\n    reference,\n    floating,\n    item\n  } : {}, [enabled, reference, floating, item]);\n}\n\n// Converts a JS style key like `backgroundColor` to a CSS transition-property\n// like `background-color`.\nconst camelCaseToKebabCase = str => str.replace(/[A-Z]+(?![a-z])|[A-Z]/g, ($, ofs) => (ofs ? '-' : '') + $.toLowerCase());\nfunction execWithArgsOrReturn(valueOrFn, args) {\n  return typeof valueOrFn === 'function' ? valueOrFn(args) : valueOrFn;\n}\nfunction useDelayUnmount(open, durationMs) {\n  const [isMounted, setIsMounted] = React.useState(open);\n  if (open && !isMounted) {\n    setIsMounted(true);\n  }\n  React.useEffect(() => {\n    if (!open && isMounted) {\n      const timeout = setTimeout(() => setIsMounted(false), durationMs);\n      return () => clearTimeout(timeout);\n    }\n  }, [open, isMounted, durationMs]);\n  return isMounted;\n}\n/**\n * Provides a status string to apply CSS transitions to a floating element,\n * correctly handling placement-aware transitions.\n * @see https://floating-ui.com/docs/useTransition#usetransitionstatus\n */\nfunction useTransitionStatus(context, props) {\n  if (props === void 0) {\n    props = {};\n  }\n  const {\n    open,\n    elements: {\n      floating\n    }\n  } = context;\n  const {\n    duration = 250\n  } = props;\n  const isNumberDuration = typeof duration === 'number';\n  const closeDuration = (isNumberDuration ? duration : duration.close) || 0;\n  const [status, setStatus] = React.useState('unmounted');\n  const isMounted = useDelayUnmount(open, closeDuration);\n  if (!isMounted && status === 'close') {\n    setStatus('unmounted');\n  }\n  index(() => {\n    if (!floating) return;\n    if (open) {\n      setStatus('initial');\n      const frame = requestAnimationFrame(() => {\n        setStatus('open');\n      });\n      return () => {\n        cancelAnimationFrame(frame);\n      };\n    }\n    setStatus('close');\n  }, [open, floating]);\n  return {\n    isMounted,\n    status\n  };\n}\n/**\n * Provides styles to apply CSS transitions to a floating element, correctly\n * handling placement-aware transitions. Wrapper around `useTransitionStatus`.\n * @see https://floating-ui.com/docs/useTransition#usetransitionstyles\n */\nfunction useTransitionStyles(context, props) {\n  if (props === void 0) {\n    props = {};\n  }\n  const {\n    initial: unstable_initial = {\n      opacity: 0\n    },\n    open: unstable_open,\n    close: unstable_close,\n    common: unstable_common,\n    duration = 250\n  } = props;\n  const placement = context.placement;\n  const side = placement.split('-')[0];\n  const fnArgs = React.useMemo(() => ({\n    side,\n    placement\n  }), [side, placement]);\n  const isNumberDuration = typeof duration === 'number';\n  const openDuration = (isNumberDuration ? duration : duration.open) || 0;\n  const closeDuration = (isNumberDuration ? duration : duration.close) || 0;\n  const [styles, setStyles] = React.useState(() => ({\n    ...execWithArgsOrReturn(unstable_common, fnArgs),\n    ...execWithArgsOrReturn(unstable_initial, fnArgs)\n  }));\n  const {\n    isMounted,\n    status\n  } = useTransitionStatus(context, {\n    duration\n  });\n  const initialRef = useLatestRef(unstable_initial);\n  const openRef = useLatestRef(unstable_open);\n  const closeRef = useLatestRef(unstable_close);\n  const commonRef = useLatestRef(unstable_common);\n  index(() => {\n    const initialStyles = execWithArgsOrReturn(initialRef.current, fnArgs);\n    const closeStyles = execWithArgsOrReturn(closeRef.current, fnArgs);\n    const commonStyles = execWithArgsOrReturn(commonRef.current, fnArgs);\n    const openStyles = execWithArgsOrReturn(openRef.current, fnArgs) || Object.keys(initialStyles).reduce((acc, key) => {\n      acc[key] = '';\n      return acc;\n    }, {});\n    if (status === 'initial') {\n      setStyles(styles => ({\n        transitionProperty: styles.transitionProperty,\n        ...commonStyles,\n        ...initialStyles\n      }));\n    }\n    if (status === 'open') {\n      setStyles({\n        transitionProperty: Object.keys(openStyles).map(camelCaseToKebabCase).join(','),\n        transitionDuration: openDuration + \"ms\",\n        ...commonStyles,\n        ...openStyles\n      });\n    }\n    if (status === 'close') {\n      const styles = closeStyles || initialStyles;\n      setStyles({\n        transitionProperty: Object.keys(styles).map(camelCaseToKebabCase).join(','),\n        transitionDuration: closeDuration + \"ms\",\n        ...commonStyles,\n        ...styles\n      });\n    }\n  }, [closeDuration, closeRef, initialRef, openRef, commonRef, openDuration, status, fnArgs]);\n  return {\n    isMounted,\n    styles\n  };\n}\n\n/**\n * Provides a matching callback that can be used to focus an item as the user\n * types, often used in tandem with `useListNavigation()`.\n * @see https://floating-ui.com/docs/useTypeahead\n */\nfunction useTypeahead(context, props) {\n  var _ref;\n  const {\n    open,\n    dataRef\n  } = context;\n  const {\n    listRef,\n    activeIndex,\n    onMatch: unstable_onMatch,\n    onTypingChange: unstable_onTypingChange,\n    enabled = true,\n    findMatch = null,\n    resetMs = 750,\n    ignoreKeys = [],\n    selectedIndex = null\n  } = props;\n  const timeoutIdRef = React.useRef();\n  const stringRef = React.useRef('');\n  const prevIndexRef = React.useRef((_ref = selectedIndex != null ? selectedIndex : activeIndex) != null ? _ref : -1);\n  const matchIndexRef = React.useRef(null);\n  const onMatch = useEffectEvent(unstable_onMatch);\n  const onTypingChange = useEffectEvent(unstable_onTypingChange);\n  const findMatchRef = useLatestRef(findMatch);\n  const ignoreKeysRef = useLatestRef(ignoreKeys);\n  index(() => {\n    if (open) {\n      clearTimeout(timeoutIdRef.current);\n      matchIndexRef.current = null;\n      stringRef.current = '';\n    }\n  }, [open]);\n  index(() => {\n    // Sync arrow key navigation but not typeahead navigation.\n    if (open && stringRef.current === '') {\n      var _ref2;\n      prevIndexRef.current = (_ref2 = selectedIndex != null ? selectedIndex : activeIndex) != null ? _ref2 : -1;\n    }\n  }, [open, selectedIndex, activeIndex]);\n  const setTypingChange = useEffectEvent(value => {\n    if (value) {\n      if (!dataRef.current.typing) {\n        dataRef.current.typing = value;\n        onTypingChange(value);\n      }\n    } else {\n      if (dataRef.current.typing) {\n        dataRef.current.typing = value;\n        onTypingChange(value);\n      }\n    }\n  });\n  const onKeyDown = useEffectEvent(event => {\n    function getMatchingIndex(list, orderedList, string) {\n      const str = findMatchRef.current ? findMatchRef.current(orderedList, string) : orderedList.find(text => (text == null ? void 0 : text.toLocaleLowerCase().indexOf(string.toLocaleLowerCase())) === 0);\n      return str ? list.indexOf(str) : -1;\n    }\n    const listContent = listRef.current;\n    if (stringRef.current.length > 0 && stringRef.current[0] !== ' ') {\n      if (getMatchingIndex(listContent, listContent, stringRef.current) === -1) {\n        setTypingChange(false);\n      } else if (event.key === ' ') {\n        stopEvent(event);\n      }\n    }\n    if (listContent == null || ignoreKeysRef.current.includes(event.key) ||\n    // Character key.\n    event.key.length !== 1 ||\n    // Modifier key.\n    event.ctrlKey || event.metaKey || event.altKey) {\n      return;\n    }\n    if (open && event.key !== ' ') {\n      stopEvent(event);\n      setTypingChange(true);\n    }\n\n    // Bail out if the list contains a word like \"llama\" or \"aaron\". TODO:\n    // allow it in this case, too.\n    const allowRapidSuccessionOfFirstLetter = listContent.every(text => {\n      var _text$, _text$2;\n      return text ? ((_text$ = text[0]) == null ? void 0 : _text$.toLocaleLowerCase()) !== ((_text$2 = text[1]) == null ? void 0 : _text$2.toLocaleLowerCase()) : true;\n    });\n\n    // Allows the user to cycle through items that start with the same letter\n    // in rapid succession.\n    if (allowRapidSuccessionOfFirstLetter && stringRef.current === event.key) {\n      stringRef.current = '';\n      prevIndexRef.current = matchIndexRef.current;\n    }\n    stringRef.current += event.key;\n    clearTimeout(timeoutIdRef.current);\n    timeoutIdRef.current = setTimeout(() => {\n      stringRef.current = '';\n      prevIndexRef.current = matchIndexRef.current;\n      setTypingChange(false);\n    }, resetMs);\n    const prevIndex = prevIndexRef.current;\n    const index = getMatchingIndex(listContent, [...listContent.slice((prevIndex || 0) + 1), ...listContent.slice(0, (prevIndex || 0) + 1)], stringRef.current);\n    if (index !== -1) {\n      onMatch(index);\n      matchIndexRef.current = index;\n    } else if (event.key !== ' ') {\n      stringRef.current = '';\n      setTypingChange(false);\n    }\n  });\n  const reference = React.useMemo(() => ({\n    onKeyDown\n  }), [onKeyDown]);\n  const floating = React.useMemo(() => {\n    return {\n      onKeyDown,\n      onKeyUp(event) {\n        if (event.key === ' ') {\n          setTypingChange(false);\n        }\n      }\n    };\n  }, [onKeyDown, setTypingChange]);\n  return React.useMemo(() => enabled ? {\n    reference,\n    floating\n  } : {}, [enabled, reference, floating]);\n}\n\nfunction getArgsWithCustomFloatingHeight(state, height) {\n  return {\n    ...state,\n    rects: {\n      ...state.rects,\n      floating: {\n        ...state.rects.floating,\n        height\n      }\n    }\n  };\n}\n/**\n * Positions the floating element such that an inner element inside of it is\n * anchored to the reference element.\n * @see https://floating-ui.com/docs/inner\n * @deprecated\n */\nconst inner = props => ({\n  name: 'inner',\n  options: props,\n  async fn(state) {\n    const {\n      listRef,\n      overflowRef,\n      onFallbackChange,\n      offset: innerOffset = 0,\n      index = 0,\n      minItemsVisible = 4,\n      referenceOverflowThreshold = 0,\n      scrollRef,\n      ...detectOverflowOptions\n    } = evaluate(props, state);\n    const {\n      rects,\n      elements: {\n        floating\n      }\n    } = state;\n    const item = listRef.current[index];\n    const scrollEl = (scrollRef == null ? void 0 : scrollRef.current) || floating;\n\n    // Valid combinations:\n    // 1. Floating element is the scrollRef and has a border (default)\n    // 2. Floating element is not the scrollRef, floating element has a border\n    // 3. Floating element is not the scrollRef, scrollRef has a border\n    // Floating > {...getFloatingProps()} wrapper > scrollRef > items is not\n    // allowed as VoiceOver doesn't work.\n    const clientTop = floating.clientTop || scrollEl.clientTop;\n    const floatingIsBordered = floating.clientTop !== 0;\n    const scrollElIsBordered = scrollEl.clientTop !== 0;\n    const floatingIsScrollEl = floating === scrollEl;\n    if (process.env.NODE_ENV !== \"production\") {\n      if (!state.placement.startsWith('bottom')) {\n        warn('`placement` side must be \"bottom\" when using the `inner`', 'middleware.');\n      }\n    }\n    if (!item) {\n      return {};\n    }\n    const nextArgs = {\n      ...state,\n      ...(await offset(-item.offsetTop - floating.clientTop - rects.reference.height / 2 - item.offsetHeight / 2 - innerOffset).fn(state))\n    };\n    const overflow = await detectOverflow(getArgsWithCustomFloatingHeight(nextArgs, scrollEl.scrollHeight + clientTop + floating.clientTop), detectOverflowOptions);\n    const refOverflow = await detectOverflow(nextArgs, {\n      ...detectOverflowOptions,\n      elementContext: 'reference'\n    });\n    const diffY = max(0, overflow.top);\n    const nextY = nextArgs.y + diffY;\n    const isScrollable = scrollEl.scrollHeight > scrollEl.clientHeight;\n    const rounder = isScrollable ? v => v : round;\n    const maxHeight = rounder(max(0, scrollEl.scrollHeight + (floatingIsBordered && floatingIsScrollEl || scrollElIsBordered ? clientTop * 2 : 0) - diffY - max(0, overflow.bottom)));\n    scrollEl.style.maxHeight = maxHeight + \"px\";\n    scrollEl.scrollTop = diffY;\n\n    // There is not enough space, fallback to standard anchored positioning\n    if (onFallbackChange) {\n      const shouldFallback = scrollEl.offsetHeight < item.offsetHeight * min(minItemsVisible, listRef.current.length) - 1 || refOverflow.top >= -referenceOverflowThreshold || refOverflow.bottom >= -referenceOverflowThreshold;\n      ReactDOM.flushSync(() => onFallbackChange(shouldFallback));\n    }\n    if (overflowRef) {\n      overflowRef.current = await detectOverflow(getArgsWithCustomFloatingHeight({\n        ...nextArgs,\n        y: nextY\n      }, scrollEl.offsetHeight + clientTop + floating.clientTop), detectOverflowOptions);\n    }\n    return {\n      y: nextY\n    };\n  }\n});\n/**\n * Changes the `inner` middleware's `offset` upon a `wheel` event to\n * expand the floating element's height, revealing more list items.\n * @see https://floating-ui.com/docs/inner\n * @deprecated\n */\nfunction useInnerOffset(context, props) {\n  const {\n    open,\n    elements\n  } = context;\n  const {\n    enabled = true,\n    overflowRef,\n    scrollRef,\n    onChange: unstable_onChange\n  } = props;\n  const onChange = useEffectEvent(unstable_onChange);\n  const controlledScrollingRef = React.useRef(false);\n  const prevScrollTopRef = React.useRef(null);\n  const initialOverflowRef = React.useRef(null);\n  React.useEffect(() => {\n    if (!enabled) return;\n    function onWheel(e) {\n      if (e.ctrlKey || !el || overflowRef.current == null) {\n        return;\n      }\n      const dY = e.deltaY;\n      const isAtTop = overflowRef.current.top >= -0.5;\n      const isAtBottom = overflowRef.current.bottom >= -0.5;\n      const remainingScroll = el.scrollHeight - el.clientHeight;\n      const sign = dY < 0 ? -1 : 1;\n      const method = dY < 0 ? 'max' : 'min';\n      if (el.scrollHeight <= el.clientHeight) {\n        return;\n      }\n      if (!isAtTop && dY > 0 || !isAtBottom && dY < 0) {\n        e.preventDefault();\n        ReactDOM.flushSync(() => {\n          onChange(d => d + Math[method](dY, remainingScroll * sign));\n        });\n      } else if (/firefox/i.test(getUserAgent())) {\n        // Needed to propagate scrolling during momentum scrolling phase once\n        // it gets limited by the boundary. UX improvement, not critical.\n        el.scrollTop += dY;\n      }\n    }\n    const el = (scrollRef == null ? void 0 : scrollRef.current) || elements.floating;\n    if (open && el) {\n      el.addEventListener('wheel', onWheel);\n\n      // Wait for the position to be ready.\n      requestAnimationFrame(() => {\n        prevScrollTopRef.current = el.scrollTop;\n        if (overflowRef.current != null) {\n          initialOverflowRef.current = {\n            ...overflowRef.current\n          };\n        }\n      });\n      return () => {\n        prevScrollTopRef.current = null;\n        initialOverflowRef.current = null;\n        el.removeEventListener('wheel', onWheel);\n      };\n    }\n  }, [enabled, open, elements.floating, overflowRef, scrollRef, onChange]);\n  const floating = React.useMemo(() => ({\n    onKeyDown() {\n      controlledScrollingRef.current = true;\n    },\n    onWheel() {\n      controlledScrollingRef.current = false;\n    },\n    onPointerMove() {\n      controlledScrollingRef.current = false;\n    },\n    onScroll() {\n      const el = (scrollRef == null ? void 0 : scrollRef.current) || elements.floating;\n      if (!overflowRef.current || !el || !controlledScrollingRef.current) {\n        return;\n      }\n      if (prevScrollTopRef.current !== null) {\n        const scrollDiff = el.scrollTop - prevScrollTopRef.current;\n        if (overflowRef.current.bottom < -0.5 && scrollDiff < -1 || overflowRef.current.top < -0.5 && scrollDiff > 1) {\n          ReactDOM.flushSync(() => onChange(d => d + scrollDiff));\n        }\n      }\n\n      // [Firefox] Wait for the height change to have been applied.\n      requestAnimationFrame(() => {\n        prevScrollTopRef.current = el.scrollTop;\n      });\n    }\n  }), [elements.floating, onChange, overflowRef, scrollRef]);\n  return React.useMemo(() => enabled ? {\n    floating\n  } : {}, [enabled, floating]);\n}\n\nfunction isPointInPolygon(point, polygon) {\n  const [x, y] = point;\n  let isInside = false;\n  const length = polygon.length;\n  for (let i = 0, j = length - 1; i < length; j = i++) {\n    const [xi, yi] = polygon[i] || [0, 0];\n    const [xj, yj] = polygon[j] || [0, 0];\n    const intersect = yi >= y !== yj >= y && x <= (xj - xi) * (y - yi) / (yj - yi) + xi;\n    if (intersect) {\n      isInside = !isInside;\n    }\n  }\n  return isInside;\n}\nfunction isInside(point, rect) {\n  return point[0] >= rect.x && point[0] <= rect.x + rect.width && point[1] >= rect.y && point[1] <= rect.y + rect.height;\n}\n/**\n * Generates a safe polygon area that the user can traverse without closing the\n * floating element once leaving the reference element.\n * @see https://floating-ui.com/docs/useHover#safepolygon\n */\nfunction safePolygon(options) {\n  if (options === void 0) {\n    options = {};\n  }\n  const {\n    buffer = 0.5,\n    blockPointerEvents = false,\n    requireIntent = true\n  } = options;\n  let timeoutId;\n  let hasLanded = false;\n  let lastX = null;\n  let lastY = null;\n  let lastCursorTime = performance.now();\n  function getCursorSpeed(x, y) {\n    const currentTime = performance.now();\n    const elapsedTime = currentTime - lastCursorTime;\n    if (lastX === null || lastY === null || elapsedTime === 0) {\n      lastX = x;\n      lastY = y;\n      lastCursorTime = currentTime;\n      return null;\n    }\n    const deltaX = x - lastX;\n    const deltaY = y - lastY;\n    const distance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);\n    const speed = distance / elapsedTime; // px / ms\n\n    lastX = x;\n    lastY = y;\n    lastCursorTime = currentTime;\n    return speed;\n  }\n  const fn = _ref => {\n    let {\n      x,\n      y,\n      placement,\n      elements,\n      onClose,\n      nodeId,\n      tree\n    } = _ref;\n    return function onMouseMove(event) {\n      function close() {\n        clearTimeout(timeoutId);\n        onClose();\n      }\n      clearTimeout(timeoutId);\n      if (!elements.domReference || !elements.floating || placement == null || x == null || y == null) {\n        return;\n      }\n      const {\n        clientX,\n        clientY\n      } = event;\n      const clientPoint = [clientX, clientY];\n      const target = getTarget(event);\n      const isLeave = event.type === 'mouseleave';\n      const isOverFloatingEl = contains(elements.floating, target);\n      const isOverReferenceEl = contains(elements.domReference, target);\n      const refRect = elements.domReference.getBoundingClientRect();\n      const rect = elements.floating.getBoundingClientRect();\n      const side = placement.split('-')[0];\n      const cursorLeaveFromRight = x > rect.right - rect.width / 2;\n      const cursorLeaveFromBottom = y > rect.bottom - rect.height / 2;\n      const isOverReferenceRect = isInside(clientPoint, refRect);\n      const isFloatingWider = rect.width > refRect.width;\n      const isFloatingTaller = rect.height > refRect.height;\n      const left = (isFloatingWider ? refRect : rect).left;\n      const right = (isFloatingWider ? refRect : rect).right;\n      const top = (isFloatingTaller ? refRect : rect).top;\n      const bottom = (isFloatingTaller ? refRect : rect).bottom;\n      if (isOverFloatingEl) {\n        hasLanded = true;\n        if (!isLeave) {\n          return;\n        }\n      }\n      if (isOverReferenceEl) {\n        hasLanded = false;\n      }\n      if (isOverReferenceEl && !isLeave) {\n        hasLanded = true;\n        return;\n      }\n\n      // Prevent overlapping floating element from being stuck in an open-close\n      // loop: https://github.com/floating-ui/floating-ui/issues/1910\n      if (isLeave && isElement(event.relatedTarget) && contains(elements.floating, event.relatedTarget)) {\n        return;\n      }\n\n      // If any nested child is open, abort.\n      if (tree && getChildren(tree.nodesRef.current, nodeId).some(_ref2 => {\n        let {\n          context\n        } = _ref2;\n        return context == null ? void 0 : context.open;\n      })) {\n        return;\n      }\n\n      // If the pointer is leaving from the opposite side, the \"buffer\" logic\n      // creates a point where the floating element remains open, but should be\n      // ignored.\n      // A constant of 1 handles floating point rounding errors.\n      if (side === 'top' && y >= refRect.bottom - 1 || side === 'bottom' && y <= refRect.top + 1 || side === 'left' && x >= refRect.right - 1 || side === 'right' && x <= refRect.left + 1) {\n        return close();\n      }\n\n      // Ignore when the cursor is within the rectangular trough between the\n      // two elements. Since the triangle is created from the cursor point,\n      // which can start beyond the ref element's edge, traversing back and\n      // forth from the ref to the floating element can cause it to close. This\n      // ensures it always remains open in that case.\n      let rectPoly = [];\n      switch (side) {\n        case 'top':\n          rectPoly = [[left, refRect.top + 1], [left, rect.bottom - 1], [right, rect.bottom - 1], [right, refRect.top + 1]];\n          break;\n        case 'bottom':\n          rectPoly = [[left, rect.top + 1], [left, refRect.bottom - 1], [right, refRect.bottom - 1], [right, rect.top + 1]];\n          break;\n        case 'left':\n          rectPoly = [[rect.right - 1, bottom], [rect.right - 1, top], [refRect.left + 1, top], [refRect.left + 1, bottom]];\n          break;\n        case 'right':\n          rectPoly = [[refRect.right - 1, bottom], [refRect.right - 1, top], [rect.left + 1, top], [rect.left + 1, bottom]];\n          break;\n      }\n      function getPolygon(_ref3) {\n        let [x, y] = _ref3;\n        switch (side) {\n          case 'top':\n            {\n              const cursorPointOne = [isFloatingWider ? x + buffer / 2 : cursorLeaveFromRight ? x + buffer * 4 : x - buffer * 4, y + buffer + 1];\n              const cursorPointTwo = [isFloatingWider ? x - buffer / 2 : cursorLeaveFromRight ? x + buffer * 4 : x - buffer * 4, y + buffer + 1];\n              const commonPoints = [[rect.left, cursorLeaveFromRight ? rect.bottom - buffer : isFloatingWider ? rect.bottom - buffer : rect.top], [rect.right, cursorLeaveFromRight ? isFloatingWider ? rect.bottom - buffer : rect.top : rect.bottom - buffer]];\n              return [cursorPointOne, cursorPointTwo, ...commonPoints];\n            }\n          case 'bottom':\n            {\n              const cursorPointOne = [isFloatingWider ? x + buffer / 2 : cursorLeaveFromRight ? x + buffer * 4 : x - buffer * 4, y - buffer];\n              const cursorPointTwo = [isFloatingWider ? x - buffer / 2 : cursorLeaveFromRight ? x + buffer * 4 : x - buffer * 4, y - buffer];\n              const commonPoints = [[rect.left, cursorLeaveFromRight ? rect.top + buffer : isFloatingWider ? rect.top + buffer : rect.bottom], [rect.right, cursorLeaveFromRight ? isFloatingWider ? rect.top + buffer : rect.bottom : rect.top + buffer]];\n              return [cursorPointOne, cursorPointTwo, ...commonPoints];\n            }\n          case 'left':\n            {\n              const cursorPointOne = [x + buffer + 1, isFloatingTaller ? y + buffer / 2 : cursorLeaveFromBottom ? y + buffer * 4 : y - buffer * 4];\n              const cursorPointTwo = [x + buffer + 1, isFloatingTaller ? y - buffer / 2 : cursorLeaveFromBottom ? y + buffer * 4 : y - buffer * 4];\n              const commonPoints = [[cursorLeaveFromBottom ? rect.right - buffer : isFloatingTaller ? rect.right - buffer : rect.left, rect.top], [cursorLeaveFromBottom ? isFloatingTaller ? rect.right - buffer : rect.left : rect.right - buffer, rect.bottom]];\n              return [...commonPoints, cursorPointOne, cursorPointTwo];\n            }\n          case 'right':\n            {\n              const cursorPointOne = [x - buffer, isFloatingTaller ? y + buffer / 2 : cursorLeaveFromBottom ? y + buffer * 4 : y - buffer * 4];\n              const cursorPointTwo = [x - buffer, isFloatingTaller ? y - buffer / 2 : cursorLeaveFromBottom ? y + buffer * 4 : y - buffer * 4];\n              const commonPoints = [[cursorLeaveFromBottom ? rect.left + buffer : isFloatingTaller ? rect.left + buffer : rect.right, rect.top], [cursorLeaveFromBottom ? isFloatingTaller ? rect.left + buffer : rect.right : rect.left + buffer, rect.bottom]];\n              return [cursorPointOne, cursorPointTwo, ...commonPoints];\n            }\n        }\n      }\n      if (isPointInPolygon([clientX, clientY], rectPoly)) {\n        return;\n      }\n      if (hasLanded && !isOverReferenceRect) {\n        return close();\n      }\n      if (!isLeave && requireIntent) {\n        const cursorSpeed = getCursorSpeed(event.clientX, event.clientY);\n        const cursorSpeedThreshold = 0.1;\n        if (cursorSpeed !== null && cursorSpeed < cursorSpeedThreshold) {\n          return close();\n        }\n      }\n      if (!isPointInPolygon([clientX, clientY], getPolygon([x, y]))) {\n        close();\n      } else if (!hasLanded && requireIntent) {\n        timeoutId = window.setTimeout(close, 40);\n      }\n    };\n  };\n  fn.__options = {\n    blockPointerEvents\n  };\n  return fn;\n}\n\nexport { Composite, CompositeItem, FloatingArrow, FloatingDelayGroup, FloatingFocusManager, FloatingList, FloatingNode, FloatingOverlay, FloatingPortal, FloatingTree, inner, safePolygon, useClick, useClientPoint, useDelayGroup, useDelayGroupContext, useDismiss, useFloating, useFloatingNodeId, useFloatingParentNodeId, useFloatingPortalNode, useFloatingRootContext, useFloatingTree, useFocus, useHover, useId, useInnerOffset, useInteractions, useListItem, useListNavigation, useMergeRefs, useRole, useTransitionStatus, useTransitionStyles, useTypeahead };\n","function hasWindow() {\n  return typeof window !== 'undefined';\n}\nfunction getNodeName(node) {\n  if (isNode(node)) {\n    return (node.nodeName || '').toLowerCase();\n  }\n  // Mocked nodes in testing environments may not be instances of Node. By\n  // returning `#document` an infinite loop won't occur.\n  // https://github.com/floating-ui/floating-ui/issues/2317\n  return '#document';\n}\nfunction getWindow(node) {\n  var _node$ownerDocument;\n  return (node == null || (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;\n}\nfunction getDocumentElement(node) {\n  var _ref;\n  return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;\n}\nfunction isNode(value) {\n  if (!hasWindow()) {\n    return false;\n  }\n  return value instanceof Node || value instanceof getWindow(value).Node;\n}\nfunction isElement(value) {\n  if (!hasWindow()) {\n    return false;\n  }\n  return value instanceof Element || value instanceof getWindow(value).Element;\n}\nfunction isHTMLElement(value) {\n  if (!hasWindow()) {\n    return false;\n  }\n  return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;\n}\nfunction isShadowRoot(value) {\n  if (!hasWindow() || typeof ShadowRoot === 'undefined') {\n    return false;\n  }\n  return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;\n}\nfunction isOverflowElement(element) {\n  const {\n    overflow,\n    overflowX,\n    overflowY,\n    display\n  } = getComputedStyle(element);\n  return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && !['inline', 'contents'].includes(display);\n}\nfunction isTableElement(element) {\n  return ['table', 'td', 'th'].includes(getNodeName(element));\n}\nfunction isTopLayer(element) {\n  return [':popover-open', ':modal'].some(selector => {\n    try {\n      return element.matches(selector);\n    } catch (e) {\n      return false;\n    }\n  });\n}\nfunction isContainingBlock(elementOrCss) {\n  const webkit = isWebKit();\n  const css = isElement(elementOrCss) ? getComputedStyle(elementOrCss) : elementOrCss;\n\n  // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block\n  return css.transform !== 'none' || css.perspective !== 'none' || (css.containerType ? css.containerType !== 'normal' : false) || !webkit && (css.backdropFilter ? css.backdropFilter !== 'none' : false) || !webkit && (css.filter ? css.filter !== 'none' : false) || ['transform', 'perspective', 'filter'].some(value => (css.willChange || '').includes(value)) || ['paint', 'layout', 'strict', 'content'].some(value => (css.contain || '').includes(value));\n}\nfunction getContainingBlock(element) {\n  let currentNode = getParentNode(element);\n  while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {\n    if (isContainingBlock(currentNode)) {\n      return currentNode;\n    } else if (isTopLayer(currentNode)) {\n      return null;\n    }\n    currentNode = getParentNode(currentNode);\n  }\n  return null;\n}\nfunction isWebKit() {\n  if (typeof CSS === 'undefined' || !CSS.supports) return false;\n  return CSS.supports('-webkit-backdrop-filter', 'none');\n}\nfunction isLastTraversableNode(node) {\n  return ['html', 'body', '#document'].includes(getNodeName(node));\n}\nfunction getComputedStyle(element) {\n  return getWindow(element).getComputedStyle(element);\n}\nfunction getNodeScroll(element) {\n  if (isElement(element)) {\n    return {\n      scrollLeft: element.scrollLeft,\n      scrollTop: element.scrollTop\n    };\n  }\n  return {\n    scrollLeft: element.scrollX,\n    scrollTop: element.scrollY\n  };\n}\nfunction getParentNode(node) {\n  if (getNodeName(node) === 'html') {\n    return node;\n  }\n  const result =\n  // Step into the shadow DOM of the parent of a slotted node.\n  node.assignedSlot ||\n  // DOM Element detected.\n  node.parentNode ||\n  // ShadowRoot detected.\n  isShadowRoot(node) && node.host ||\n  // Fallback.\n  getDocumentElement(node);\n  return isShadowRoot(result) ? result.host : result;\n}\nfunction getNearestOverflowAncestor(node) {\n  const parentNode = getParentNode(node);\n  if (isLastTraversableNode(parentNode)) {\n    return node.ownerDocument ? node.ownerDocument.body : node.body;\n  }\n  if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) {\n    return parentNode;\n  }\n  return getNearestOverflowAncestor(parentNode);\n}\nfunction getOverflowAncestors(node, list, traverseIframes) {\n  var _node$ownerDocument2;\n  if (list === void 0) {\n    list = [];\n  }\n  if (traverseIframes === void 0) {\n    traverseIframes = true;\n  }\n  const scrollableAncestor = getNearestOverflowAncestor(node);\n  const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);\n  const win = getWindow(scrollableAncestor);\n  if (isBody) {\n    const frameElement = getFrameElement(win);\n    return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], frameElement && traverseIframes ? getOverflowAncestors(frameElement) : []);\n  }\n  return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));\n}\nfunction getFrameElement(win) {\n  return win.parent && Object.getPrototypeOf(win.parent) ? win.frameElement : null;\n}\n\nexport { getComputedStyle, getContainingBlock, getDocumentElement, getFrameElement, getNearestOverflowAncestor, getNodeName, getNodeScroll, getOverflowAncestors, getParentNode, getWindow, isContainingBlock, isElement, isHTMLElement, isLastTraversableNode, isNode, isOverflowElement, isShadowRoot, isTableElement, isTopLayer, isWebKit };\n","\"use strict\";\n/*\nCopyright 2019-2024 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.EMOJI = exports.DATA_BY_CATEGORY = exports.getEmojiFromUnicode = exports.EMOTICON_TO_EMOJI = void 0;\nconst compact_json_1 = __importDefault(require(\"emojibase-data/en/compact.json\"));\nconst iamcal_json_1 = __importDefault(require(\"emojibase-data/en/shortcodes/iamcal.json\"));\nconst emoji_json_1 = __importDefault(require(\"emojibase-data/versions/emoji.json\"));\nconst emojibase_1 = require(\"emojibase\");\nconst MAX_EMOJI_VERSION_WEB = 15.1;\n// The unicode is stored without the variant selector\nconst UNICODE_TO_EMOJI = new Map(); // not exported as gets for it are handled by getEmojiFromUnicode\nexports.EMOTICON_TO_EMOJI = new Map();\nconst getEmojiFromUnicode = (unicode) => UNICODE_TO_EMOJI.get(stripVariation(unicode));\nexports.getEmojiFromUnicode = getEmojiFromUnicode;\nconst isRegionalIndicator = (x) => {\n    // First verify that the string is a single character. We use Array.from\n    // to make sure we count by characters, not UTF-8 code units.\n    return (Array.from(x).length === 1 &&\n        // Next verify that the character is within the code point range for\n        // regional indicators.\n        // http://unicode.org/charts/PDF/Unicode-6.0/U60-1F100.pdf\n        x >= \"\\u{1f1e6}\" &&\n        x <= \"\\u{1f1ff}\");\n};\nconst EMOJIBASE_GROUP_ID_TO_CATEGORY = [\n    \"people\",\n    \"people\",\n    \"control\",\n    \"nature\",\n    \"foods\",\n    \"places\",\n    \"activity\",\n    \"objects\",\n    \"symbols\",\n    \"flags\",\n];\nexports.DATA_BY_CATEGORY = {\n    people: [],\n    nature: [],\n    foods: [],\n    places: [],\n    activity: [],\n    objects: [],\n    symbols: [],\n    flags: [],\n};\n// The MAX emoji version to be included in exported data.\n// This can be present as an env variable when it is being run for the mobile context.\n// We support setting a max emoji version so that we can upgrade emojibase for its library\n// features but not force a version on all platforms. Web for example needs to be upgraded\n// in unison with twemoji.\nconst MAX_EMOJI_VERSION = parseFloat(process.env.MAX_EMOJI_VERSION) || MAX_EMOJI_VERSION_WEB;\n// The compact version of emojibase does not have version stored on the emoji object\n// but there does existing a map of version to emoji.\n// Create a map of emoji to version so that we can lookup an emoji version and filter.\nconst EMOJI_TO_VERSION = new Map();\nfor (const [versionString, emojis] of Object.entries(emoji_json_1.default)) {\n    const version = parseFloat(versionString);\n    emojis.forEach((emoji) => EMOJI_TO_VERSION.set(emoji, version));\n}\n// Store various mappings from unicode/emoticon/shortcode to the Emoji objects\nexports.EMOJI = compact_json_1.default.filter((emojiData) => {\n    // filter emojis that are less than or equal to MAX_EMOJI_VERSION\n    const version = EMOJI_TO_VERSION.get(emojiData.hexcode);\n    return version !== undefined && version <= MAX_EMOJI_VERSION;\n}).map((emojiData) => {\n    // If there's ever a gap in shortcode coverage, we fudge it by\n    // filling it in with the emoji's CLDR annotation\n    const shortcodeData = iamcal_json_1.default[emojiData.hexcode] ?? [\n        emojiData.label.toLowerCase().replace(/\\W+/g, \"_\"),\n    ];\n    const emoji = {\n        ...emojiData,\n        // Homogenize shortcodes by ensuring that everything is an array\n        shortcodes: typeof shortcodeData === \"string\" ? [shortcodeData] : shortcodeData,\n    };\n    return emoji;\n});\nexports.EMOJI.forEach((emoji) => {\n    // We manually include regional indicators in the symbols group, since\n    // Emojibase intentionally leaves them uncategorized\n    const categoryId = EMOJIBASE_GROUP_ID_TO_CATEGORY[emoji.group] ??\n        (isRegionalIndicator(emoji.unicode) ? \"symbols\" : null);\n    if (exports.DATA_BY_CATEGORY.hasOwnProperty(categoryId)) {\n        exports.DATA_BY_CATEGORY[categoryId].push(emoji);\n    }\n    // Add mapping from unicode to Emoji object\n    // The 'unicode' field that we use in emojibase has either\n    // VS15 or VS16 appended to any characters that can take\n    // variation selectors. Which one it appends depends\n    // on whether emojibase considers their type to be 'text' or\n    // 'emoji'. We therefore strip any variation chars from strings\n    // both when building the map and when looking up.\n    UNICODE_TO_EMOJI.set(stripVariation(emoji.unicode), emoji);\n    if (emoji.emoticon) {\n        // Add mapping from emoticon to Emoji object\n        const emoticons = [emoji.emoticon]\n            //flatten, in case `emoji.emoticon` is an array\n            .flat()\n            .flatMap((x) => (0, emojibase_1.generateEmoticonPermutations)(x));\n        emoticons.forEach((x) => exports.EMOTICON_TO_EMOJI.set(x, emoji));\n    }\n});\n/**\n * Strips variation selectors from the end of given string\n * NB. Skin tone modifiers are not variation selectors:\n * this function does not touch them. (Should it?)\n *\n * @param {string} str string to strip\n * @returns {string} stripped string\n */\nfunction stripVariation(str) {\n    return str.replace(/[\\uFE00-\\uFE0F]$/, \"\");\n}\n","\"use strict\";\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nvar _typeof = require(\"@babel/runtime/helpers/typeof\");\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.Spinner = void 0;\n\nvar _classCallCheck2 = _interopRequireDefault(require(\"@babel/runtime/helpers/classCallCheck\"));\n\nvar _createClass2 = _interopRequireDefault(require(\"@babel/runtime/helpers/createClass\"));\n\nvar _inherits2 = _interopRequireDefault(require(\"@babel/runtime/helpers/inherits\"));\n\nvar _possibleConstructorReturn2 = _interopRequireDefault(require(\"@babel/runtime/helpers/possibleConstructorReturn\"));\n\nvar _getPrototypeOf2 = _interopRequireDefault(require(\"@babel/runtime/helpers/getPrototypeOf\"));\n\nvar _defineProperty2 = _interopRequireDefault(require(\"@babel/runtime/helpers/defineProperty\"));\n\nvar React = _interopRequireWildcard(require(\"react\"));\n\nfunction _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== \"function\") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }\n\nfunction _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== \"object\" && typeof obj !== \"function\") { return { \"default\": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== \"default\" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj[\"default\"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }\n\nfunction _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2[\"default\"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2[\"default\"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2[\"default\"])(this, result); }; }\n\nfunction _isNativeReflectConstruct() { if (typeof Reflect === \"undefined\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \"function\") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } /*\n                                                                                                                                                                                                                                                                                                                                          Copyright 2022 The Matrix.org Foundation C.I.C.\n                                                                                                                                                                                                                                                                                                                                          \n                                                                                                                                                                                                                                                                                                                                          Licensed under the Apache License, Version 2.0 (the \"License\");\n                                                                                                                                                                                                                                                                                                                                          you may not use this file except in compliance with the License.\n                                                                                                                                                                                                                                                                                                                                          You may obtain a copy of the License at\n                                                                                                                                                                                                                                                                                                                                          \n                                                                                                                                                                                                                                                                                                                                              http://www.apache.org/licenses/LICENSE-2.0\n                                                                                                                                                                                                                                                                                                                                          \n                                                                                                                                                                                                                                                                                                                                          Unless required by applicable law or agreed to in writing, software\n                                                                                                                                                                                                                                                                                                                                          distributed under the License is distributed on an \"AS IS\" BASIS,\n                                                                                                                                                                                                                                                                                                                                          WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n                                                                                                                                                                                                                                                                                                                                          See the License for the specific language governing permissions and\n                                                                                                                                                                                                                                                                                                                                          limitations under the License.\n                                                                                                                                                                                                                                                                                                                                          */\n\nvar Spinner = /*#__PURE__*/function (_React$PureComponent) {\n  (0, _inherits2[\"default\"])(Spinner, _React$PureComponent);\n\n  var _super = _createSuper(Spinner);\n\n  function Spinner() {\n    (0, _classCallCheck2[\"default\"])(this, Spinner);\n    return _super.apply(this, arguments);\n  }\n\n  (0, _createClass2[\"default\"])(Spinner, [{\n    key: \"render\",\n    value:\n    /**\n     * The factory this component uses to render itself. Set to a different value to override.\n     * @returns The component, rendered.\n     */\n    function render() {\n      return Spinner.renderFactory();\n    }\n  }]);\n  return Spinner;\n}(React.PureComponent);\n\nexports.Spinner = Spinner;\n(0, _defineProperty2[\"default\"])(Spinner, \"renderFactory\", function () {\n  return null;\n});","\"use strict\";\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nvar _typeof = require(\"@babel/runtime/helpers/typeof\");\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.TextInputField = void 0;\n\nvar _classCallCheck2 = _interopRequireDefault(require(\"@babel/runtime/helpers/classCallCheck\"));\n\nvar _createClass2 = _interopRequireDefault(require(\"@babel/runtime/helpers/createClass\"));\n\nvar _inherits2 = _interopRequireDefault(require(\"@babel/runtime/helpers/inherits\"));\n\nvar _possibleConstructorReturn2 = _interopRequireDefault(require(\"@babel/runtime/helpers/possibleConstructorReturn\"));\n\nvar _getPrototypeOf2 = _interopRequireDefault(require(\"@babel/runtime/helpers/getPrototypeOf\"));\n\nvar _defineProperty2 = _interopRequireDefault(require(\"@babel/runtime/helpers/defineProperty\"));\n\nvar React = _interopRequireWildcard(require(\"react\"));\n\nfunction _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== \"function\") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }\n\nfunction _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== \"object\" && typeof obj !== \"function\") { return { \"default\": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== \"default\" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj[\"default\"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }\n\nfunction _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2[\"default\"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2[\"default\"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2[\"default\"])(this, result); }; }\n\nfunction _isNativeReflectConstruct() { if (typeof Reflect === \"undefined\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \"function\") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } /*\n                                                                                                                                                                                                                                                                                                                                          Copyright 2022 The Matrix.org Foundation C.I.C.\n                                                                                                                                                                                                                                                                                                                                          \n                                                                                                                                                                                                                                                                                                                                          Licensed under the Apache License, Version 2.0 (the \"License\");\n                                                                                                                                                                                                                                                                                                                                          you may not use this file except in compliance with the License.\n                                                                                                                                                                                                                                                                                                                                          You may obtain a copy of the License at\n                                                                                                                                                                                                                                                                                                                                          \n                                                                                                                                                                                                                                                                                                                                              http://www.apache.org/licenses/LICENSE-2.0\n                                                                                                                                                                                                                                                                                                                                          \n                                                                                                                                                                                                                                                                                                                                          Unless required by applicable law or agreed to in writing, software\n                                                                                                                                                                                                                                                                                                                                          distributed under the License is distributed on an \"AS IS\" BASIS,\n                                                                                                                                                                                                                                                                                                                                          WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n                                                                                                                                                                                                                                                                                                                                          See the License for the specific language governing permissions and\n                                                                                                                                                                                                                                                                                                                                          limitations under the License.\n                                                                                                                                                                                                                                                                                                                                          */\n\nvar TextInputField = /*#__PURE__*/function (_React$PureComponent) {\n  (0, _inherits2[\"default\"])(TextInputField, _React$PureComponent);\n\n  var _super = _createSuper(TextInputField);\n\n  function TextInputField() {\n    (0, _classCallCheck2[\"default\"])(this, TextInputField);\n    return _super.apply(this, arguments);\n  }\n\n  (0, _createClass2[\"default\"])(TextInputField, [{\n    key: \"render\",\n    value:\n    /**\n     * The factory this component uses to render itself. Set to a different value to override.\n     * @param props The component properties\n     * @returns The component, rendered.\n     */\n    function render() {\n      return TextInputField.renderFactory(this.props);\n    }\n  }]);\n  return TextInputField;\n}(React.PureComponent);\n\nexports.TextInputField = TextInputField;\n(0, _defineProperty2[\"default\"])(TextInputField, \"renderFactory\", function (props) {\n  return /*#__PURE__*/React.createElement(\"label\", null, props.label, /*#__PURE__*/React.createElement(\"input\", {\n    type: \"text\",\n    onChange: function onChange(e) {\n      return props.onChange(e.target.value);\n    },\n    value: props.value\n  }));\n});","\"use strict\";\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.SetupEncryptionKind = exports.DefaultCryptoSetupExtensions = exports.CryptoSetupExtensionsBase = void 0;\n\nvar _assertThisInitialized2 = _interopRequireDefault(require(\"@babel/runtime/helpers/assertThisInitialized\"));\n\nvar _inherits2 = _interopRequireDefault(require(\"@babel/runtime/helpers/inherits\"));\n\nvar _possibleConstructorReturn2 = _interopRequireDefault(require(\"@babel/runtime/helpers/possibleConstructorReturn\"));\n\nvar _getPrototypeOf2 = _interopRequireDefault(require(\"@babel/runtime/helpers/getPrototypeOf\"));\n\nvar _classCallCheck2 = _interopRequireDefault(require(\"@babel/runtime/helpers/classCallCheck\"));\n\nvar _createClass2 = _interopRequireDefault(require(\"@babel/runtime/helpers/createClass\"));\n\nvar _defineProperty2 = _interopRequireDefault(require(\"@babel/runtime/helpers/defineProperty\"));\n\nfunction _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2[\"default\"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2[\"default\"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2[\"default\"])(this, result); }; }\n\nfunction _isNativeReflectConstruct() { if (typeof Reflect === \"undefined\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \"function\") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }\n\n/*\nCopyright 2023 Verji Tech AS\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\n/*\n * Types copied (and renamed) from matrix-js-sdk\n */\n\n/**\n * Copied from https://github.com/matrix-org/matrix-js-sdk/blob/2337d5a7af6265bbcabbd42c1594cd8b1829b00b/src/secret-storage.ts#L39-L50\n */\n\n/**\n * Copied from https://github.com/matrix-org/matrix-js-sdk/blob/2337d5a7af6265bbcabbd42c1594cd8b1829b00b/src/secret-storage.ts#L59-L71\n */\n\n/**\n * Copied from https://github.com/matrix-org/matrix-js-sdk/blob/2337d5a7af6265bbcabbd42c1594cd8b1829b00b/src/secret-storage.ts#L78\n */\n\n/**\n * Copied from https://github.com/matrix-org/matrix-js-sdk/blob/2337d5a7af6265bbcabbd42c1594cd8b1829b00b/src/secret-storage.ts#L85-L97\n */\n\n/*\n * Copied from https://github.com/matrix-org/matrix-react-sdk/blob/11096b207a1510569f5c54182e328f6148a6475c/src/MatrixClientPeg.ts#L57-L67\n */\n\n/**\n * Copied from https://github.com/matrix-org/matrix-react-sdk/blob/11096b207a1510569f5c54182e328f6148a6475c/src/toasts/SetupEncryptionToast.ts#L71-L75\n */\nvar SetupEncryptionKind;\nexports.SetupEncryptionKind = SetupEncryptionKind;\n\n(function (SetupEncryptionKind) {\n  SetupEncryptionKind[\"SetUpEncryption\"] = \"set_up_encryption\";\n  SetupEncryptionKind[\"UpgradeEncryption\"] = \"upgrade_encryption\";\n  SetupEncryptionKind[\"VerifyThisSessions\"] = \"verify_this_session\";\n})(SetupEncryptionKind || (exports.SetupEncryptionKind = SetupEncryptionKind = {}));\n\nvar CryptoSetupExtensionsBase = /*#__PURE__*/function () {\n  function CryptoSetupExtensionsBase() {\n    (0, _classCallCheck2[\"default\"])(this, CryptoSetupExtensionsBase);\n    (0, _defineProperty2[\"default\"])(this, \"SHOW_ENCRYPTION_SETUP_UI\", void 0);\n  }\n\n  (0, _createClass2[\"default\"])(CryptoSetupExtensionsBase, [{\n    key: \"getDehydrationKeyCallback\",\n    value:\n    /** `getDehydrationKeyCallback` is no longer used; we provide an empty impl for type compatibility. */\n    function getDehydrationKeyCallback() {\n      return null;\n    }\n  }]);\n  return CryptoSetupExtensionsBase;\n}();\n/* Define an interface for setupEncryptionNeeded to help enforce mandatory arguments */\n\n\nexports.CryptoSetupExtensionsBase = CryptoSetupExtensionsBase;\n\n/**\n *\n * The default/empty crypto-extensions\n * Can (and will) be used if none of the modules has an implementation of {@link ProvideCryptoSetupExtensions}.\n */\nvar DefaultCryptoSetupExtensions = /*#__PURE__*/function (_CryptoSetupExtension) {\n  (0, _inherits2[\"default\"])(DefaultCryptoSetupExtensions, _CryptoSetupExtension);\n\n  var _super = _createSuper(DefaultCryptoSetupExtensions);\n\n  function DefaultCryptoSetupExtensions() {\n    var _this;\n\n    (0, _classCallCheck2[\"default\"])(this, DefaultCryptoSetupExtensions);\n\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    _this = _super.call.apply(_super, [this].concat(args));\n    (0, _defineProperty2[\"default\"])((0, _assertThisInitialized2[\"default\"])(_this), \"SHOW_ENCRYPTION_SETUP_UI\", true);\n    return _this;\n  }\n\n  (0, _createClass2[\"default\"])(DefaultCryptoSetupExtensions, [{\n    key: \"examineLoginResponse\",\n    value: function examineLoginResponse(response, credentials) {\n      console.log(\"Default empty examineLoginResponse() => void\");\n    }\n  }, {\n    key: \"persistCredentials\",\n    value: function persistCredentials(credentials) {\n      console.log(\"Default empty persistCredentials() => void\");\n    }\n  }, {\n    key: \"getSecretStorageKey\",\n    value: function getSecretStorageKey() {\n      console.log(\"Default empty getSecretStorageKey() => null\");\n      return null;\n    }\n  }, {\n    key: \"createSecretStorageKey\",\n    value: function createSecretStorageKey() {\n      console.log(\"Default empty createSecretStorageKey() => null\");\n      return null;\n    }\n  }, {\n    key: \"catchAccessSecretStorageError\",\n    value: function catchAccessSecretStorageError(e) {\n      console.log(\"Default catchAccessSecretStorageError() => void\");\n    }\n  }, {\n    key: \"setupEncryptionNeeded\",\n    value: function setupEncryptionNeeded(args) {\n      console.log(\"Default setupEncryptionNeeded() => false\");\n      return false;\n    }\n  }, {\n    key: \"getDehydrationKeyCallback\",\n    value: function getDehydrationKeyCallback() {\n      return null;\n    }\n  }]);\n  return DefaultCryptoSetupExtensions;\n}(CryptoSetupExtensionsBase);\n\nexports.DefaultCryptoSetupExtensions = DefaultCryptoSetupExtensions;","\"use strict\";\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.ExperimentalExtensionsBase = exports.DefaultExperimentalExtensions = void 0;\n\nvar _inherits2 = _interopRequireDefault(require(\"@babel/runtime/helpers/inherits\"));\n\nvar _possibleConstructorReturn2 = _interopRequireDefault(require(\"@babel/runtime/helpers/possibleConstructorReturn\"));\n\nvar _getPrototypeOf2 = _interopRequireDefault(require(\"@babel/runtime/helpers/getPrototypeOf\"));\n\nvar _createClass2 = _interopRequireDefault(require(\"@babel/runtime/helpers/createClass\"));\n\nvar _classCallCheck2 = _interopRequireDefault(require(\"@babel/runtime/helpers/classCallCheck\"));\n\nfunction _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2[\"default\"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2[\"default\"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2[\"default\"])(this, result); }; }\n\nfunction _isNativeReflectConstruct() { if (typeof Reflect === \"undefined\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \"function\") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }\n\n/*\nCopyright 2023 Verji Tech AS\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\n/**\n * Mostly for test. To ensure we handle more than one module having extensions\n * Can possibly also be useful for PoC development\n */\nvar ExperimentalExtensionsBase = /*#__PURE__*/(0, _createClass2[\"default\"])(function ExperimentalExtensionsBase() {\n  (0, _classCallCheck2[\"default\"])(this, ExperimentalExtensionsBase);\n});\nexports.ExperimentalExtensionsBase = ExperimentalExtensionsBase;\n\nvar DefaultExperimentalExtensions = /*#__PURE__*/function (_ExperimentalExtensio) {\n  (0, _inherits2[\"default\"])(DefaultExperimentalExtensions, _ExperimentalExtensio);\n\n  var _super = _createSuper(DefaultExperimentalExtensions);\n\n  function DefaultExperimentalExtensions() {\n    (0, _classCallCheck2[\"default\"])(this, DefaultExperimentalExtensions);\n    return _super.apply(this, arguments);\n  }\n\n  (0, _createClass2[\"default\"])(DefaultExperimentalExtensions, [{\n    key: \"experimentalMethod\",\n    value: function experimentalMethod(args) {\n      return null;\n    }\n  }]);\n  return DefaultExperimentalExtensions;\n}(ExperimentalExtensionsBase);\n\nexports.DefaultExperimentalExtensions = DefaultExperimentalExtensions;","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.RoomViewLifecycle = void 0;\n\n/*\nCopyright 2022 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\nvar RoomViewLifecycle;\nexports.RoomViewLifecycle = RoomViewLifecycle;\n\n(function (RoomViewLifecycle) {\n  RoomViewLifecycle[\"PreviewRoomNotLoggedIn\"] = \"preview_not_logged_in\";\n  RoomViewLifecycle[\"JoinFromRoomPreview\"] = \"try_join_not_logged_in\";\n  RoomViewLifecycle[\"ViewRoom\"] = \"view_room\";\n})(RoomViewLifecycle || (exports.RoomViewLifecycle = RoomViewLifecycle = {}));","// packages/core/primitive/src/primitive.tsx\nfunction composeEventHandlers(originalEventHandler, ourEventHandler, { checkForDefaultPrevented = true } = {}) {\n  return function handleEvent(event) {\n    originalEventHandler?.(event);\n    if (checkForDefaultPrevented === false || !event.defaultPrevented) {\n      return ourEventHandler?.(event);\n    }\n  };\n}\nexport {\n  composeEventHandlers\n};\n//# sourceMappingURL=index.mjs.map\n","// packages/react/compose-refs/src/composeRefs.tsx\nimport * as React from \"react\";\nfunction setRef(ref, value) {\n  if (typeof ref === \"function\") {\n    ref(value);\n  } else if (ref !== null && ref !== void 0) {\n    ref.current = value;\n  }\n}\nfunction composeRefs(...refs) {\n  return (node) => refs.forEach((ref) => setRef(ref, node));\n}\nfunction useComposedRefs(...refs) {\n  return React.useCallback(composeRefs(...refs), refs);\n}\nexport {\n  composeRefs,\n  useComposedRefs\n};\n//# sourceMappingURL=index.mjs.map\n","// packages/react/context/src/createContext.tsx\nimport * as React from \"react\";\nimport { jsx } from \"react/jsx-runtime\";\nfunction createContext2(rootComponentName, defaultContext) {\n  const Context = React.createContext(defaultContext);\n  function Provider(props) {\n    const { children, ...context } = props;\n    const value = React.useMemo(() => context, Object.values(context));\n    return /* @__PURE__ */ jsx(Context.Provider, { value, children });\n  }\n  function useContext2(consumerName) {\n    const context = React.useContext(Context);\n    if (context) return context;\n    if (defaultContext !== void 0) return defaultContext;\n    throw new Error(`\\`${consumerName}\\` must be used within \\`${rootComponentName}\\``);\n  }\n  Provider.displayName = rootComponentName + \"Provider\";\n  return [Provider, useContext2];\n}\nfunction createContextScope(scopeName, createContextScopeDeps = []) {\n  let defaultContexts = [];\n  function createContext3(rootComponentName, defaultContext) {\n    const BaseContext = React.createContext(defaultContext);\n    const index = defaultContexts.length;\n    defaultContexts = [...defaultContexts, defaultContext];\n    function Provider(props) {\n      const { scope, children, ...context } = props;\n      const Context = scope?.[scopeName][index] || BaseContext;\n      const value = React.useMemo(() => context, Object.values(context));\n      return /* @__PURE__ */ jsx(Context.Provider, { value, children });\n    }\n    function useContext2(consumerName, scope) {\n      const Context = scope?.[scopeName][index] || BaseContext;\n      const context = React.useContext(Context);\n      if (context) return context;\n      if (defaultContext !== void 0) return defaultContext;\n      throw new Error(`\\`${consumerName}\\` must be used within \\`${rootComponentName}\\``);\n    }\n    Provider.displayName = rootComponentName + \"Provider\";\n    return [Provider, useContext2];\n  }\n  const createScope = () => {\n    const scopeContexts = defaultContexts.map((defaultContext) => {\n      return React.createContext(defaultContext);\n    });\n    return function useScope(scope) {\n      const contexts = scope?.[scopeName] || scopeContexts;\n      return React.useMemo(\n        () => ({ [`__scope${scopeName}`]: { ...scope, [scopeName]: contexts } }),\n        [scope, contexts]\n      );\n    };\n  };\n  createScope.scopeName = scopeName;\n  return [createContext3, composeContextScopes(createScope, ...createContextScopeDeps)];\n}\nfunction composeContextScopes(...scopes) {\n  const baseScope = scopes[0];\n  if (scopes.length === 1) return baseScope;\n  const createScope = () => {\n    const scopeHooks = scopes.map((createScope2) => ({\n      useScope: createScope2(),\n      scopeName: createScope2.scopeName\n    }));\n    return function useComposedScopes(overrideScopes) {\n      const nextScopes = scopeHooks.reduce((nextScopes2, { useScope, scopeName }) => {\n        const scopeProps = useScope(overrideScopes);\n        const currentScope = scopeProps[`__scope${scopeName}`];\n        return { ...nextScopes2, ...currentScope };\n      }, {});\n      return React.useMemo(() => ({ [`__scope${baseScope.scopeName}`]: nextScopes }), [nextScopes]);\n    };\n  };\n  createScope.scopeName = baseScope.scopeName;\n  return createScope;\n}\nexport {\n  createContext2 as createContext,\n  createContextScope\n};\n//# sourceMappingURL=index.mjs.map\n","// packages/react/id/src/id.tsx\nimport * as React from \"react\";\nimport { useLayoutEffect } from \"@radix-ui/react-use-layout-effect\";\nvar useReactId = React[\"useId\".toString()] || (() => void 0);\nvar count = 0;\nfunction useId(deterministicId) {\n  const [id, setId] = React.useState(useReactId());\n  useLayoutEffect(() => {\n    if (!deterministicId) setId((reactId) => reactId ?? String(count++));\n  }, [deterministicId]);\n  return deterministicId || (id ? `radix-${id}` : \"\");\n}\nexport {\n  useId\n};\n//# sourceMappingURL=index.mjs.map\n","// packages/react/primitive/src/Primitive.tsx\nimport * as React from \"react\";\nimport * as ReactDOM from \"react-dom\";\nimport { Slot } from \"@radix-ui/react-slot\";\nimport { jsx } from \"react/jsx-runtime\";\nvar NODES = [\n  \"a\",\n  \"button\",\n  \"div\",\n  \"form\",\n  \"h2\",\n  \"h3\",\n  \"img\",\n  \"input\",\n  \"label\",\n  \"li\",\n  \"nav\",\n  \"ol\",\n  \"p\",\n  \"span\",\n  \"svg\",\n  \"ul\"\n];\nvar Primitive = NODES.reduce((primitive, node) => {\n  const Node = React.forwardRef((props, forwardedRef) => {\n    const { asChild, ...primitiveProps } = props;\n    const Comp = asChild ? Slot : node;\n    if (typeof window !== \"undefined\") {\n      window[Symbol.for(\"radix-ui\")] = true;\n    }\n    return /* @__PURE__ */ jsx(Comp, { ...primitiveProps, ref: forwardedRef });\n  });\n  Node.displayName = `Primitive.${node}`;\n  return { ...primitive, [node]: Node };\n}, {});\nfunction dispatchDiscreteCustomEvent(target, event) {\n  if (target) ReactDOM.flushSync(() => target.dispatchEvent(event));\n}\nvar Root = Primitive;\nexport {\n  Primitive,\n  Root,\n  dispatchDiscreteCustomEvent\n};\n//# sourceMappingURL=index.mjs.map\n","// packages/react/slot/src/Slot.tsx\nimport * as React from \"react\";\nimport { composeRefs } from \"@radix-ui/react-compose-refs\";\nimport { Fragment, jsx } from \"react/jsx-runtime\";\nvar Slot = React.forwardRef((props, forwardedRef) => {\n  const { children, ...slotProps } = props;\n  const childrenArray = React.Children.toArray(children);\n  const slottable = childrenArray.find(isSlottable);\n  if (slottable) {\n    const newElement = slottable.props.children;\n    const newChildren = childrenArray.map((child) => {\n      if (child === slottable) {\n        if (React.Children.count(newElement) > 1) return React.Children.only(null);\n        return React.isValidElement(newElement) ? newElement.props.children : null;\n      } else {\n        return child;\n      }\n    });\n    return /* @__PURE__ */ jsx(SlotClone, { ...slotProps, ref: forwardedRef, children: React.isValidElement(newElement) ? React.cloneElement(newElement, void 0, newChildren) : null });\n  }\n  return /* @__PURE__ */ jsx(SlotClone, { ...slotProps, ref: forwardedRef, children });\n});\nSlot.displayName = \"Slot\";\nvar SlotClone = React.forwardRef((props, forwardedRef) => {\n  const { children, ...slotProps } = props;\n  if (React.isValidElement(children)) {\n    const childrenRef = getElementRef(children);\n    return React.cloneElement(children, {\n      ...mergeProps(slotProps, children.props),\n      // @ts-ignore\n      ref: forwardedRef ? composeRefs(forwardedRef, childrenRef) : childrenRef\n    });\n  }\n  return React.Children.count(children) > 1 ? React.Children.only(null) : null;\n});\nSlotClone.displayName = \"SlotClone\";\nvar Slottable = ({ children }) => {\n  return /* @__PURE__ */ jsx(Fragment, { children });\n};\nfunction isSlottable(child) {\n  return React.isValidElement(child) && child.type === Slottable;\n}\nfunction mergeProps(slotProps, childProps) {\n  const overrideProps = { ...childProps };\n  for (const propName in childProps) {\n    const slotPropValue = slotProps[propName];\n    const childPropValue = childProps[propName];\n    const isHandler = /^on[A-Z]/.test(propName);\n    if (isHandler) {\n      if (slotPropValue && childPropValue) {\n        overrideProps[propName] = (...args) => {\n          childPropValue(...args);\n          slotPropValue(...args);\n        };\n      } else if (slotPropValue) {\n        overrideProps[propName] = slotPropValue;\n      }\n    } else if (propName === \"style\") {\n      overrideProps[propName] = { ...slotPropValue, ...childPropValue };\n    } else if (propName === \"className\") {\n      overrideProps[propName] = [slotPropValue, childPropValue].filter(Boolean).join(\" \");\n    }\n  }\n  return { ...slotProps, ...overrideProps };\n}\nfunction getElementRef(element) {\n  let getter = Object.getOwnPropertyDescriptor(element.props, \"ref\")?.get;\n  let mayWarn = getter && \"isReactWarning\" in getter && getter.isReactWarning;\n  if (mayWarn) {\n    return element.ref;\n  }\n  getter = Object.getOwnPropertyDescriptor(element, \"ref\")?.get;\n  mayWarn = getter && \"isReactWarning\" in getter && getter.isReactWarning;\n  if (mayWarn) {\n    return element.props.ref;\n  }\n  return element.props.ref || element.ref;\n}\nvar Root = Slot;\nexport {\n  Root,\n  Slot,\n  Slottable\n};\n//# sourceMappingURL=index.mjs.map\n","// packages/react/use-layout-effect/src/useLayoutEffect.tsx\nimport * as React from \"react\";\nvar useLayoutEffect2 = Boolean(globalThis?.document) ? React.useLayoutEffect : () => {\n};\nexport {\n  useLayoutEffect2 as useLayoutEffect\n};\n//# sourceMappingURL=index.mjs.map\n","import type { HandlerDataHistory } from '@sentry/core';\nimport { addHandler, fill, maybeInstrument, supportsHistory, triggerHandlers } from '@sentry/core';\nimport { WINDOW } from '../types';\n\nlet lastHref: string | undefined;\n\n/**\n * Add an instrumentation handler for when a fetch request happens.\n * The handler function is called once when the request starts and once when it ends,\n * which can be identified by checking if it has an `endTimestamp`.\n *\n * Use at your own risk, this might break without changelog notice, only used internally.\n * @hidden\n */\nexport function addHistoryInstrumentationHandler(handler: (data: HandlerDataHistory) => void): void {\n  const type = 'history';\n  addHandler(type, handler);\n  maybeInstrument(type, instrumentHistory);\n}\n\nfunction instrumentHistory(): void {\n  // The `popstate` event may also be triggered on `pushState`, but it may not always reliably be emitted by the browser\n  // Which is why we also monkey-patch methods below, in addition to this\n  WINDOW.addEventListener('popstate', () => {\n    const to = WINDOW.location.href;\n    // keep track of the current URL state, as we always receive only the updated state\n    const from = lastHref;\n    lastHref = to;\n\n    if (from === to) {\n      return;\n    }\n\n    const handlerData = { from, to } satisfies HandlerDataHistory;\n    triggerHandlers('history', handlerData);\n  });\n\n  // Just guard against this not being available, in weird environments\n  if (!supportsHistory()) {\n    return;\n  }\n\n  function historyReplacementFunction(originalHistoryFunction: () => void): () => void {\n    return function (this: History, ...args: unknown[]): void {\n      const url = args.length > 2 ? args[2] : undefined;\n      if (url) {\n        // coerce to string (this is what pushState does)\n        const from = lastHref;\n        const to = String(url);\n        // keep track of the current URL state, as we always receive only the updated state\n        lastHref = to;\n\n        if (from === to) {\n          return;\n        }\n\n        const handlerData = { from, to } satisfies HandlerDataHistory;\n        triggerHandlers('history', handlerData);\n      }\n      return originalHistoryFunction.apply(this, args);\n    };\n  }\n\n  fill(WINDOW.history, 'pushState', historyReplacementFunction);\n  fill(WINDOW.history, 'replaceState', historyReplacementFunction);\n}\n","import type {\n  FetchBreadcrumbHint,\n  HandlerDataFetch,\n  SentryWrappedXMLHttpRequest,\n  XhrBreadcrumbHint,\n} from '@sentry/core';\nimport { GLOBAL_OBJ } from '@sentry/core';\n\nexport const WINDOW = GLOBAL_OBJ as typeof GLOBAL_OBJ &\n  // document is not available in all browser environments (webworkers). We make it optional so you have to explicitly check for it\n  Omit<Window, 'document'> &\n  Partial<Pick<Window, 'document'>>;\n\nexport type NetworkMetaWarning =\n  | 'MAYBE_JSON_TRUNCATED'\n  | 'TEXT_TRUNCATED'\n  | 'URL_SKIPPED'\n  | 'BODY_PARSE_ERROR'\n  | 'BODY_PARSE_TIMEOUT'\n  | 'UNPARSEABLE_BODY_TYPE';\n\ntype RequestBody = null | Blob | BufferSource | FormData | URLSearchParams | string;\n\nexport type XhrHint = XhrBreadcrumbHint & {\n  xhr: XMLHttpRequest & SentryWrappedXMLHttpRequest;\n  input?: RequestBody;\n};\nexport type FetchHint = FetchBreadcrumbHint & {\n  input: HandlerDataFetch['args'];\n  response: Response;\n};\n","declare const __DEBUG_BUILD__: boolean;\n\n/**\n * This serves as a build time flag that will be true by default, but false in non-debug builds or if users replace `__SENTRY_DEBUG__` in their generated code.\n *\n * ATTENTION: This constant must never cross package boundaries (i.e. be exported) to guarantee that it can be used for tree shaking.\n */\nexport const DEBUG_BUILD = __DEBUG_BUILD__;\n","import type {\n  Event,\n  EventHint,\n  Exception,\n  ParameterizedString,\n  SeverityLevel,\n  StackFrame,\n  StackParser,\n} from '@sentry/core';\nimport {\n  addExceptionMechanism,\n  addExceptionTypeValue,\n  extractExceptionKeysForMessage,\n  getClient,\n  isDOMError,\n  isDOMException,\n  isError,\n  isErrorEvent,\n  isEvent,\n  isParameterizedString,\n  isPlainObject,\n  normalizeToSize,\n  resolvedSyncPromise,\n} from '@sentry/core';\n\ntype Prototype = { constructor: (...args: unknown[]) => unknown };\n\n/**\n * This function creates an exception from a JavaScript Error\n */\nexport function exceptionFromError(stackParser: StackParser, ex: Error): Exception {\n  // Get the frames first since Opera can lose the stack if we touch anything else first\n  const frames = parseStackFrames(stackParser, ex);\n\n  const exception: Exception = {\n    type: extractType(ex),\n    value: extractMessage(ex),\n  };\n\n  if (frames.length) {\n    exception.stacktrace = { frames };\n  }\n\n  if (exception.type === undefined && exception.value === '') {\n    exception.value = 'Unrecoverable error caught';\n  }\n\n  return exception;\n}\n\nfunction eventFromPlainObject(\n  stackParser: StackParser,\n  exception: Record<string, unknown>,\n  syntheticException?: Error,\n  isUnhandledRejection?: boolean,\n): Event {\n  const client = getClient();\n  const normalizeDepth = client?.getOptions().normalizeDepth;\n\n  // If we can, we extract an exception from the object properties\n  const errorFromProp = getErrorPropertyFromObject(exception);\n\n  const extra = {\n    __serialized__: normalizeToSize(exception, normalizeDepth),\n  };\n\n  if (errorFromProp) {\n    return {\n      exception: {\n        values: [exceptionFromError(stackParser, errorFromProp)],\n      },\n      extra,\n    };\n  }\n\n  const event = {\n    exception: {\n      values: [\n        {\n          type: isEvent(exception) ? exception.constructor.name : isUnhandledRejection ? 'UnhandledRejection' : 'Error',\n          value: getNonErrorObjectExceptionValue(exception, { isUnhandledRejection }),\n        } as Exception,\n      ],\n    },\n    extra,\n  } satisfies Event;\n\n  if (syntheticException) {\n    const frames = parseStackFrames(stackParser, syntheticException);\n    if (frames.length) {\n      // event.exception.values[0] has been set above\n      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      event.exception.values[0]!.stacktrace = { frames };\n    }\n  }\n\n  return event;\n}\n\nfunction eventFromError(stackParser: StackParser, ex: Error): Event {\n  return {\n    exception: {\n      values: [exceptionFromError(stackParser, ex)],\n    },\n  };\n}\n\n/** Parses stack frames from an error */\nfunction parseStackFrames(\n  stackParser: StackParser,\n  ex: Error & { framesToPop?: number; stacktrace?: string },\n): StackFrame[] {\n  // Access and store the stacktrace property before doing ANYTHING\n  // else to it because Opera is not very good at providing it\n  // reliably in other circumstances.\n  const stacktrace = ex.stacktrace || ex.stack || '';\n\n  const skipLines = getSkipFirstStackStringLines(ex);\n  const framesToPop = getPopFirstTopFrames(ex);\n\n  try {\n    return stackParser(stacktrace, skipLines, framesToPop);\n  } catch (e) {\n    // no-empty\n  }\n\n  return [];\n}\n\n// Based on our own mapping pattern - https://github.com/getsentry/sentry/blob/9f08305e09866c8bd6d0c24f5b0aabdd7dd6c59c/src/sentry/lang/javascript/errormapping.py#L83-L108\nconst reactMinifiedRegexp = /Minified React error #\\d+;/i;\n\n/**\n * Certain known React errors contain links that would be falsely\n * parsed as frames. This function check for these errors and\n * returns number of the stack string lines to skip.\n */\nfunction getSkipFirstStackStringLines(ex: Error): number {\n  if (ex && reactMinifiedRegexp.test(ex.message)) {\n    return 1;\n  }\n\n  return 0;\n}\n\n/**\n * If error has `framesToPop` property, it means that the\n * creator tells us the first x frames will be useless\n * and should be discarded. Typically error from wrapper function\n * which don't point to the actual location in the developer's code.\n *\n * Example: https://github.com/zertosh/invariant/blob/master/invariant.js#L46\n */\nfunction getPopFirstTopFrames(ex: Error & { framesToPop?: unknown }): number {\n  if (typeof ex.framesToPop === 'number') {\n    return ex.framesToPop;\n  }\n\n  return 0;\n}\n\n// https://developer.mozilla.org/en-US/docs/WebAssembly/JavaScript_interface/Exception\n// @ts-expect-error - WebAssembly.Exception is a valid class\nfunction isWebAssemblyException(exception: unknown): exception is WebAssembly.Exception {\n  // Check for support\n  // @ts-expect-error - WebAssembly.Exception is a valid class\n  if (typeof WebAssembly !== 'undefined' && typeof WebAssembly.Exception !== 'undefined') {\n    // @ts-expect-error - WebAssembly.Exception is a valid class\n    return exception instanceof WebAssembly.Exception;\n  } else {\n    return false;\n  }\n}\n\n/**\n * Extracts from errors what we use as the exception `type` in error events.\n *\n * Usually, this is the `name` property on Error objects but WASM errors need to be treated differently.\n */\nexport function extractType(ex: Error & { message: { error?: Error } }): string | undefined {\n  const name = ex?.name;\n\n  // The name for WebAssembly.Exception Errors needs to be extracted differently.\n  // Context: https://github.com/getsentry/sentry-javascript/issues/13787\n  if (!name && isWebAssemblyException(ex)) {\n    // Emscripten sets array[type, message] to the \"message\" property on the WebAssembly.Exception object\n    const hasTypeInMessage = ex.message && Array.isArray(ex.message) && ex.message.length == 2;\n    return hasTypeInMessage ? ex.message[0] : 'WebAssembly.Exception';\n  }\n\n  return name;\n}\n\n/**\n * There are cases where stacktrace.message is an Event object\n * https://github.com/getsentry/sentry-javascript/issues/1949\n * In this specific case we try to extract stacktrace.message.error.message\n */\nexport function extractMessage(ex: Error & { message: { error?: Error } }): string {\n  const message = ex?.message;\n\n  if (isWebAssemblyException(ex)) {\n    // For Node 18, Emscripten sets array[type, message] to the \"message\" property on the WebAssembly.Exception object\n    if (Array.isArray(ex.message) && ex.message.length == 2) {\n      return ex.message[1];\n    }\n    return 'wasm exception';\n  }\n\n  if (!message) {\n    return 'No error message';\n  }\n\n  if (message.error && typeof message.error.message === 'string') {\n    return message.error.message;\n  }\n\n  return message;\n}\n\n/**\n * Creates an {@link Event} from all inputs to `captureException` and non-primitive inputs to `captureMessage`.\n * @hidden\n */\nexport function eventFromException(\n  stackParser: StackParser,\n  exception: unknown,\n  hint?: EventHint,\n  attachStacktrace?: boolean,\n): PromiseLike<Event> {\n  const syntheticException = hint?.syntheticException || undefined;\n  const event = eventFromUnknownInput(stackParser, exception, syntheticException, attachStacktrace);\n  addExceptionMechanism(event); // defaults to { type: 'generic', handled: true }\n  event.level = 'error';\n  if (hint?.event_id) {\n    event.event_id = hint.event_id;\n  }\n  return resolvedSyncPromise(event);\n}\n\n/**\n * Builds and Event from a Message\n * @hidden\n */\nexport function eventFromMessage(\n  stackParser: StackParser,\n  message: ParameterizedString,\n  level: SeverityLevel = 'info',\n  hint?: EventHint,\n  attachStacktrace?: boolean,\n): PromiseLike<Event> {\n  const syntheticException = hint?.syntheticException || undefined;\n  const event = eventFromString(stackParser, message, syntheticException, attachStacktrace);\n  event.level = level;\n  if (hint?.event_id) {\n    event.event_id = hint.event_id;\n  }\n  return resolvedSyncPromise(event);\n}\n\n/**\n * @hidden\n */\nexport function eventFromUnknownInput(\n  stackParser: StackParser,\n  exception: unknown,\n  syntheticException?: Error,\n  attachStacktrace?: boolean,\n  isUnhandledRejection?: boolean,\n): Event {\n  let event: Event;\n\n  if (isErrorEvent(exception as ErrorEvent) && (exception as ErrorEvent).error) {\n    // If it is an ErrorEvent with `error` property, extract it to get actual Error\n    const errorEvent = exception as ErrorEvent;\n    return eventFromError(stackParser, errorEvent.error as Error);\n  }\n\n  // If it is a `DOMError` (which is a legacy API, but still supported in some browsers) then we just extract the name\n  // and message, as it doesn't provide anything else. According to the spec, all `DOMExceptions` should also be\n  // `Error`s, but that's not the case in IE11, so in that case we treat it the same as we do a `DOMError`.\n  //\n  // https://developer.mozilla.org/en-US/docs/Web/API/DOMError\n  // https://developer.mozilla.org/en-US/docs/Web/API/DOMException\n  // https://webidl.spec.whatwg.org/#es-DOMException-specialness\n  if (isDOMError(exception) || isDOMException(exception as DOMException)) {\n    const domException = exception as DOMException;\n\n    if ('stack' in (exception as Error)) {\n      event = eventFromError(stackParser, exception as Error);\n    } else {\n      const name = domException.name || (isDOMError(domException) ? 'DOMError' : 'DOMException');\n      const message = domException.message ? `${name}: ${domException.message}` : name;\n      event = eventFromString(stackParser, message, syntheticException, attachStacktrace);\n      addExceptionTypeValue(event, message);\n    }\n    if ('code' in domException) {\n      // eslint-disable-next-line deprecation/deprecation\n      event.tags = { ...event.tags, 'DOMException.code': `${domException.code}` };\n    }\n\n    return event;\n  }\n  if (isError(exception)) {\n    // we have a real Error object, do nothing\n    return eventFromError(stackParser, exception);\n  }\n  if (isPlainObject(exception) || isEvent(exception)) {\n    // If it's a plain object or an instance of `Event` (the built-in JS kind, not this SDK's `Event` type), serialize\n    // it manually. This will allow us to group events based on top-level keys which is much better than creating a new\n    // group on any key/value change.\n    const objectException = exception as Record<string, unknown>;\n    event = eventFromPlainObject(stackParser, objectException, syntheticException, isUnhandledRejection);\n    addExceptionMechanism(event, {\n      synthetic: true,\n    });\n    return event;\n  }\n\n  // If none of previous checks were valid, then it means that it's not:\n  // - an instance of DOMError\n  // - an instance of DOMException\n  // - an instance of Event\n  // - an instance of Error\n  // - a valid ErrorEvent (one with an error property)\n  // - a plain Object\n  //\n  // So bail out and capture it as a simple message:\n  event = eventFromString(stackParser, exception as string, syntheticException, attachStacktrace);\n  addExceptionTypeValue(event, `${exception}`, undefined);\n  addExceptionMechanism(event, {\n    synthetic: true,\n  });\n\n  return event;\n}\n\nfunction eventFromString(\n  stackParser: StackParser,\n  message: ParameterizedString,\n  syntheticException?: Error,\n  attachStacktrace?: boolean,\n): Event {\n  const event: Event = {};\n\n  if (attachStacktrace && syntheticException) {\n    const frames = parseStackFrames(stackParser, syntheticException);\n    if (frames.length) {\n      event.exception = {\n        values: [{ value: message, stacktrace: { frames } }],\n      };\n    }\n    addExceptionMechanism(event, { synthetic: true });\n  }\n\n  if (isParameterizedString(message)) {\n    const { __sentry_template_string__, __sentry_template_values__ } = message;\n\n    event.logentry = {\n      message: __sentry_template_string__,\n      params: __sentry_template_values__,\n    };\n    return event;\n  }\n\n  event.message = message;\n  return event;\n}\n\nfunction getNonErrorObjectExceptionValue(\n  exception: Record<string, unknown>,\n  { isUnhandledRejection }: { isUnhandledRejection?: boolean },\n): string {\n  const keys = extractExceptionKeysForMessage(exception);\n  const captureType = isUnhandledRejection ? 'promise rejection' : 'exception';\n\n  // Some ErrorEvent instances do not have an `error` property, which is why they are not handled before\n  // We still want to try to get a decent message for these cases\n  if (isErrorEvent(exception)) {\n    return `Event \\`ErrorEvent\\` captured as ${captureType} with message \\`${exception.message}\\``;\n  }\n\n  if (isEvent(exception)) {\n    const className = getObjectClassName(exception);\n    return `Event \\`${className}\\` (type=${exception.type}) captured as ${captureType}`;\n  }\n\n  return `Object captured as ${captureType} with keys: ${keys}`;\n}\n\nfunction getObjectClassName(obj: unknown): string | undefined | void {\n  try {\n    const prototype: Prototype | null = Object.getPrototypeOf(obj);\n    return prototype ? prototype.constructor.name : undefined;\n  } catch (e) {\n    // ignore errors here\n  }\n}\n\n/** If a plain object has a property that is an `Error`, return this error. */\nfunction getErrorPropertyFromObject(obj: Record<string, unknown>): Error | undefined {\n  for (const prop in obj) {\n    if (Object.prototype.hasOwnProperty.call(obj, prop)) {\n      const value = obj[prop];\n      if (value instanceof Error) {\n        return value;\n      }\n    }\n  }\n\n  return undefined;\n}\n","import type { Mechanism, WrappedFunction } from '@sentry/core';\nimport {\n  GLOBAL_OBJ,\n  addExceptionMechanism,\n  addExceptionTypeValue,\n  addNonEnumerableProperty,\n  captureException,\n  getOriginalFunction,\n  markFunctionWrapped,\n  withScope,\n} from '@sentry/core';\n\nexport const WINDOW = GLOBAL_OBJ as typeof GLOBAL_OBJ & Window;\n\nlet ignoreOnError: number = 0;\n\n/**\n * @hidden\n */\nexport function shouldIgnoreOnError(): boolean {\n  return ignoreOnError > 0;\n}\n\n/**\n * @hidden\n */\nexport function ignoreNextOnError(): void {\n  // onerror should trigger before setTimeout\n  ignoreOnError++;\n  setTimeout(() => {\n    ignoreOnError--;\n  });\n}\n\n// eslint-disable-next-line @typescript-eslint/ban-types\ntype WrappableFunction = Function;\n\nexport function wrap<T extends WrappableFunction>(\n  fn: T,\n  options?: {\n    mechanism?: Mechanism;\n  },\n): WrappedFunction<T>;\nexport function wrap<NonFunction>(\n  fn: NonFunction,\n  options?: {\n    mechanism?: Mechanism;\n  },\n): NonFunction;\n/**\n * Instruments the given function and sends an event to Sentry every time the\n * function throws an exception.\n *\n * @param fn A function to wrap. It is generally safe to pass an unbound function, because the returned wrapper always\n * has a correct `this` context.\n * @returns The wrapped function.\n * @hidden\n */\nexport function wrap<T extends WrappableFunction, NonFunction>(\n  fn: T | NonFunction,\n  options: {\n    mechanism?: Mechanism;\n  } = {},\n): NonFunction | WrappedFunction<T> {\n  // for future readers what this does is wrap a function and then create\n  // a bi-directional wrapping between them.\n  //\n  // example: wrapped = wrap(original);\n  //  original.__sentry_wrapped__ -> wrapped\n  //  wrapped.__sentry_original__ -> original\n\n  function isFunction(fn: T | NonFunction): fn is T {\n    return typeof fn === 'function';\n  }\n\n  if (!isFunction(fn)) {\n    return fn;\n  }\n\n  try {\n    // if we're dealing with a function that was previously wrapped, return\n    // the original wrapper.\n    const wrapper = (fn as WrappedFunction<T>).__sentry_wrapped__;\n    if (wrapper) {\n      if (typeof wrapper === 'function') {\n        return wrapper;\n      } else {\n        // If we find that the `__sentry_wrapped__` function is not a function at the time of accessing it, it means\n        // that something messed with it. In that case we want to return the originally passed function.\n        return fn;\n      }\n    }\n\n    // We don't wanna wrap it twice\n    if (getOriginalFunction(fn)) {\n      return fn;\n    }\n  } catch (e) {\n    // Just accessing custom props in some Selenium environments\n    // can cause a \"Permission denied\" exception (see raven-js#495).\n    // Bail on wrapping and return the function as-is (defers to window.onerror).\n    return fn;\n  }\n\n  // Wrap the function itself\n  // It is important that `sentryWrapped` is not an arrow function to preserve the context of `this`\n  const sentryWrapped = function (this: unknown, ...args: unknown[]): unknown {\n    try {\n      // Also wrap arguments that are themselves functions\n      const wrappedArguments = args.map(arg => wrap(arg, options));\n\n      // Attempt to invoke user-land function\n      // NOTE: If you are a Sentry user, and you are seeing this stack frame, it\n      //       means the sentry.javascript SDK caught an error invoking your application code. This\n      //       is expected behavior and NOT indicative of a bug with sentry.javascript.\n      return fn.apply(this, wrappedArguments);\n    } catch (ex) {\n      ignoreNextOnError();\n\n      withScope(scope => {\n        scope.addEventProcessor(event => {\n          if (options.mechanism) {\n            addExceptionTypeValue(event, undefined, undefined);\n            addExceptionMechanism(event, options.mechanism);\n          }\n\n          event.extra = {\n            ...event.extra,\n            arguments: args,\n          };\n\n          return event;\n        });\n\n        captureException(ex);\n      });\n\n      throw ex;\n    }\n  } as unknown as WrappedFunction<T>;\n\n  // Wrap the wrapped function in a proxy, to ensure any other properties of the original function remain available\n  try {\n    for (const property in fn) {\n      if (Object.prototype.hasOwnProperty.call(fn, property)) {\n        sentryWrapped[property as keyof T] = fn[property as keyof T];\n      }\n    }\n  } catch {\n    // Accessing some objects may throw\n    // ref: https://github.com/getsentry/sentry-javascript/issues/1168\n  }\n\n  // Signal that this function has been wrapped/filled already\n  // for both debugging and to prevent it to being wrapped/filled twice\n  markFunctionWrapped(sentryWrapped, fn);\n\n  addNonEnumerableProperty(fn, '__sentry_wrapped__', sentryWrapped);\n\n  // Restore original function name (not all browsers allow that)\n  try {\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    const descriptor = Object.getOwnPropertyDescriptor(sentryWrapped, 'name')!;\n    if (descriptor.configurable) {\n      Object.defineProperty(sentryWrapped, 'name', {\n        get(): string {\n          return fn.name;\n        },\n      });\n    }\n  } catch {\n    // This may throw if e.g. the descriptor does not exist, or a browser does not allow redefining `name`.\n    // to save some bytes we simply try-catch this\n  }\n\n  return sentryWrapped;\n}\n","import type { HandlerDataDom } from '@sentry/core';\nimport { addHandler, addNonEnumerableProperty, fill, maybeInstrument, triggerHandlers, uuid4 } from '@sentry/core';\nimport { WINDOW } from '../types';\n\ntype SentryWrappedTarget = HTMLElement & { _sentryId?: string };\n\ntype AddEventListener = (\n  type: string,\n  listener: EventListenerOrEventListenerObject,\n  options?: boolean | AddEventListenerOptions,\n) => void;\ntype RemoveEventListener = (\n  type: string,\n  listener: EventListenerOrEventListenerObject,\n  options?: boolean | EventListenerOptions,\n) => void;\n\ntype InstrumentedElement = Element & {\n  __sentry_instrumentation_handlers__?: {\n    [key in 'click' | 'keypress']?: {\n      handler?: unknown;\n      /** The number of custom listeners attached to this element */\n      refCount: number;\n    };\n  };\n};\n\nconst DEBOUNCE_DURATION = 1000;\n\nlet debounceTimerID: number | undefined;\nlet lastCapturedEventType: string | undefined;\nlet lastCapturedEventTargetId: string | undefined;\n\n/**\n * Add an instrumentation handler for when a click or a keypress happens.\n *\n * Use at your own risk, this might break without changelog notice, only used internally.\n * @hidden\n */\nexport function addClickKeypressInstrumentationHandler(handler: (data: HandlerDataDom) => void): void {\n  const type = 'dom';\n  addHandler(type, handler);\n  maybeInstrument(type, instrumentDOM);\n}\n\n/** Exported for tests only. */\nexport function instrumentDOM(): void {\n  if (!WINDOW.document) {\n    return;\n  }\n\n  // Make it so that any click or keypress that is unhandled / bubbled up all the way to the document triggers our dom\n  // handlers. (Normally we have only one, which captures a breadcrumb for each click or keypress.) Do this before\n  // we instrument `addEventListener` so that we don't end up attaching this handler twice.\n  const triggerDOMHandler = triggerHandlers.bind(null, 'dom');\n  const globalDOMEventHandler = makeDOMEventHandler(triggerDOMHandler, true);\n  WINDOW.document.addEventListener('click', globalDOMEventHandler, false);\n  WINDOW.document.addEventListener('keypress', globalDOMEventHandler, false);\n\n  // After hooking into click and keypress events bubbled up to `document`, we also hook into user-handled\n  // clicks & keypresses, by adding an event listener of our own to any element to which they add a listener. That\n  // way, whenever one of their handlers is triggered, ours will be, too. (This is needed because their handler\n  // could potentially prevent the event from bubbling up to our global listeners. This way, our handler are still\n  // guaranteed to fire at least once.)\n  ['EventTarget', 'Node'].forEach((target: string) => {\n    const globalObject = WINDOW as unknown as Record<string, { prototype?: object }>;\n    const proto = globalObject[target]?.prototype;\n\n    // eslint-disable-next-line no-prototype-builtins\n    if (!proto?.hasOwnProperty?.('addEventListener')) {\n      return;\n    }\n\n    fill(proto, 'addEventListener', function (originalAddEventListener: AddEventListener): AddEventListener {\n      return function (this: InstrumentedElement, type, listener, options): AddEventListener {\n        if (type === 'click' || type == 'keypress') {\n          try {\n            const handlers = (this.__sentry_instrumentation_handlers__ =\n              this.__sentry_instrumentation_handlers__ || {});\n            const handlerForType = (handlers[type] = handlers[type] || { refCount: 0 });\n\n            if (!handlerForType.handler) {\n              const handler = makeDOMEventHandler(triggerDOMHandler);\n              handlerForType.handler = handler;\n              originalAddEventListener.call(this, type, handler, options);\n            }\n\n            handlerForType.refCount++;\n          } catch (e) {\n            // Accessing dom properties is always fragile.\n            // Also allows us to skip `addEventListeners` calls with no proper `this` context.\n          }\n        }\n\n        return originalAddEventListener.call(this, type, listener, options);\n      };\n    });\n\n    fill(\n      proto,\n      'removeEventListener',\n      function (originalRemoveEventListener: RemoveEventListener): RemoveEventListener {\n        return function (this: InstrumentedElement, type, listener, options): () => void {\n          if (type === 'click' || type == 'keypress') {\n            try {\n              const handlers = this.__sentry_instrumentation_handlers__ || {};\n              const handlerForType = handlers[type];\n\n              if (handlerForType) {\n                handlerForType.refCount--;\n                // If there are no longer any custom handlers of the current type on this element, we can remove ours, too.\n                if (handlerForType.refCount <= 0) {\n                  originalRemoveEventListener.call(this, type, handlerForType.handler, options);\n                  handlerForType.handler = undefined;\n                  delete handlers[type]; // eslint-disable-line @typescript-eslint/no-dynamic-delete\n                }\n\n                // If there are no longer any custom handlers of any type on this element, cleanup everything.\n                if (Object.keys(handlers).length === 0) {\n                  delete this.__sentry_instrumentation_handlers__;\n                }\n              }\n            } catch (e) {\n              // Accessing dom properties is always fragile.\n              // Also allows us to skip `addEventListeners` calls with no proper `this` context.\n            }\n          }\n\n          return originalRemoveEventListener.call(this, type, listener, options);\n        };\n      },\n    );\n  });\n}\n\n/**\n * Check whether the event is similar to the last captured one. For example, two click events on the same button.\n */\nfunction isSimilarToLastCapturedEvent(event: Event): boolean {\n  // If both events have different type, then user definitely performed two separate actions. e.g. click + keypress.\n  if (event.type !== lastCapturedEventType) {\n    return false;\n  }\n\n  try {\n    // If both events have the same type, it's still possible that actions were performed on different targets.\n    // e.g. 2 clicks on different buttons.\n    if (!event.target || (event.target as SentryWrappedTarget)._sentryId !== lastCapturedEventTargetId) {\n      return false;\n    }\n  } catch (e) {\n    // just accessing `target` property can throw an exception in some rare circumstances\n    // see: https://github.com/getsentry/sentry-javascript/issues/838\n  }\n\n  // If both events have the same type _and_ same `target` (an element which triggered an event, _not necessarily_\n  // to which an event listener was attached), we treat them as the same action, as we want to capture\n  // only one breadcrumb. e.g. multiple clicks on the same button, or typing inside a user input box.\n  return true;\n}\n\n/**\n * Decide whether an event should be captured.\n * @param event event to be captured\n */\nfunction shouldSkipDOMEvent(eventType: string, target: SentryWrappedTarget | null): boolean {\n  // We are only interested in filtering `keypress` events for now.\n  if (eventType !== 'keypress') {\n    return false;\n  }\n\n  if (!target?.tagName) {\n    return true;\n  }\n\n  // Only consider keypress events on actual input elements. This will disregard keypresses targeting body\n  // e.g.tabbing through elements, hotkeys, etc.\n  if (target.tagName === 'INPUT' || target.tagName === 'TEXTAREA' || target.isContentEditable) {\n    return false;\n  }\n\n  return true;\n}\n\n/**\n * Wraps addEventListener to capture UI breadcrumbs\n */\nfunction makeDOMEventHandler(\n  handler: (data: HandlerDataDom) => void,\n  globalListener: boolean = false,\n): (event: Event) => void {\n  return (event: Event & { _sentryCaptured?: true }): void => {\n    // It's possible this handler might trigger multiple times for the same\n    // event (e.g. event propagation through node ancestors).\n    // Ignore if we've already captured that event.\n    if (!event || event['_sentryCaptured']) {\n      return;\n    }\n\n    const target = getEventTarget(event);\n\n    // We always want to skip _some_ events.\n    if (shouldSkipDOMEvent(event.type, target)) {\n      return;\n    }\n\n    // Mark event as \"seen\"\n    addNonEnumerableProperty(event, '_sentryCaptured', true);\n\n    if (target && !target._sentryId) {\n      // Add UUID to event target so we can identify if\n      addNonEnumerableProperty(target, '_sentryId', uuid4());\n    }\n\n    const name = event.type === 'keypress' ? 'input' : event.type;\n\n    // If there is no last captured event, it means that we can safely capture the new event and store it for future comparisons.\n    // If there is a last captured event, see if the new event is different enough to treat it as a unique one.\n    // If that's the case, emit the previous event and store locally the newly-captured DOM event.\n    if (!isSimilarToLastCapturedEvent(event)) {\n      const handlerData: HandlerDataDom = { event, name, global: globalListener };\n      handler(handlerData);\n      lastCapturedEventType = event.type;\n      lastCapturedEventTargetId = target ? target._sentryId : undefined;\n    }\n\n    // Start a new debounce timer that will prevent us from capturing multiple events that should be grouped together.\n    clearTimeout(debounceTimerID);\n    debounceTimerID = WINDOW.setTimeout(() => {\n      lastCapturedEventTargetId = undefined;\n      lastCapturedEventType = undefined;\n    }, DEBOUNCE_DURATION);\n  };\n}\n\nfunction getEventTarget(event: Event): SentryWrappedTarget | null {\n  try {\n    return event.target as SentryWrappedTarget | null;\n  } catch (e) {\n    // just accessing `target` property can throw an exception in some rare circumstances\n    // see: https://github.com/getsentry/sentry-javascript/issues/838\n    return null;\n  }\n}\n","import type { HandlerDataXhr, SentryWrappedXMLHttpRequest } from '@sentry/core';\nimport { addHandler, isString, maybeInstrument, timestampInSeconds, triggerHandlers } from '@sentry/core';\nimport { WINDOW } from '../types';\n\nexport const SENTRY_XHR_DATA_KEY = '__sentry_xhr_v3__';\n\ntype WindowWithXhr = Window & { XMLHttpRequest?: typeof XMLHttpRequest };\n\n/**\n * Add an instrumentation handler for when an XHR request happens.\n * The handler function is called once when the request starts and once when it ends,\n * which can be identified by checking if it has an `endTimestamp`.\n *\n * Use at your own risk, this might break without changelog notice, only used internally.\n * @hidden\n */\nexport function addXhrInstrumentationHandler(handler: (data: HandlerDataXhr) => void): void {\n  const type = 'xhr';\n  addHandler(type, handler);\n  maybeInstrument(type, instrumentXHR);\n}\n\n/** Exported only for tests. */\nexport function instrumentXHR(): void {\n  if (!(WINDOW as WindowWithXhr).XMLHttpRequest) {\n    return;\n  }\n\n  const xhrproto = XMLHttpRequest.prototype;\n\n  // eslint-disable-next-line @typescript-eslint/unbound-method\n  xhrproto.open = new Proxy(xhrproto.open, {\n    apply(originalOpen, xhrOpenThisArg: XMLHttpRequest & SentryWrappedXMLHttpRequest, xhrOpenArgArray) {\n      // NOTE: If you are a Sentry user, and you are seeing this stack frame,\n      //       it means the error, that was caused by your XHR call did not\n      //       have a stack trace. If you are using HttpClient integration,\n      //       this is the expected behavior, as we are using this virtual error to capture\n      //       the location of your XHR call, and group your HttpClient events accordingly.\n      const virtualError = new Error();\n\n      const startTimestamp = timestampInSeconds() * 1000;\n\n      // open() should always be called with two or more arguments\n      // But to be on the safe side, we actually validate this and bail out if we don't have a method & url\n      const method = isString(xhrOpenArgArray[0]) ? xhrOpenArgArray[0].toUpperCase() : undefined;\n      const url = parseUrl(xhrOpenArgArray[1]);\n\n      if (!method || !url) {\n        return originalOpen.apply(xhrOpenThisArg, xhrOpenArgArray);\n      }\n\n      xhrOpenThisArg[SENTRY_XHR_DATA_KEY] = {\n        method,\n        url,\n        request_headers: {},\n      };\n\n      // if Sentry key appears in URL, don't capture it as a request\n      if (method === 'POST' && url.match(/sentry_key/)) {\n        xhrOpenThisArg.__sentry_own_request__ = true;\n      }\n\n      const onreadystatechangeHandler: () => void = () => {\n        // For whatever reason, this is not the same instance here as from the outer method\n        const xhrInfo = xhrOpenThisArg[SENTRY_XHR_DATA_KEY];\n\n        if (!xhrInfo) {\n          return;\n        }\n\n        if (xhrOpenThisArg.readyState === 4) {\n          try {\n            // touching statusCode in some platforms throws\n            // an exception\n            xhrInfo.status_code = xhrOpenThisArg.status;\n          } catch (e) {\n            /* do nothing */\n          }\n\n          const handlerData: HandlerDataXhr = {\n            endTimestamp: timestampInSeconds() * 1000,\n            startTimestamp,\n            xhr: xhrOpenThisArg,\n            virtualError,\n          };\n          triggerHandlers('xhr', handlerData);\n        }\n      };\n\n      if ('onreadystatechange' in xhrOpenThisArg && typeof xhrOpenThisArg.onreadystatechange === 'function') {\n        xhrOpenThisArg.onreadystatechange = new Proxy(xhrOpenThisArg.onreadystatechange, {\n          apply(originalOnreadystatechange, onreadystatechangeThisArg, onreadystatechangeArgArray: unknown[]) {\n            onreadystatechangeHandler();\n            return originalOnreadystatechange.apply(onreadystatechangeThisArg, onreadystatechangeArgArray);\n          },\n        });\n      } else {\n        xhrOpenThisArg.addEventListener('readystatechange', onreadystatechangeHandler);\n      }\n\n      // Intercepting `setRequestHeader` to access the request headers of XHR instance.\n      // This will only work for user/library defined headers, not for the default/browser-assigned headers.\n      // Request cookies are also unavailable for XHR, as `Cookie` header can't be defined by `setRequestHeader`.\n      xhrOpenThisArg.setRequestHeader = new Proxy(xhrOpenThisArg.setRequestHeader, {\n        apply(\n          originalSetRequestHeader,\n          setRequestHeaderThisArg: SentryWrappedXMLHttpRequest,\n          setRequestHeaderArgArray: unknown[],\n        ) {\n          const [header, value] = setRequestHeaderArgArray;\n\n          const xhrInfo = setRequestHeaderThisArg[SENTRY_XHR_DATA_KEY];\n\n          if (xhrInfo && isString(header) && isString(value)) {\n            xhrInfo.request_headers[header.toLowerCase()] = value;\n          }\n\n          return originalSetRequestHeader.apply(setRequestHeaderThisArg, setRequestHeaderArgArray);\n        },\n      });\n\n      return originalOpen.apply(xhrOpenThisArg, xhrOpenArgArray);\n    },\n  });\n\n  // eslint-disable-next-line @typescript-eslint/unbound-method\n  xhrproto.send = new Proxy(xhrproto.send, {\n    apply(originalSend, sendThisArg: XMLHttpRequest & SentryWrappedXMLHttpRequest, sendArgArray: unknown[]) {\n      const sentryXhrData = sendThisArg[SENTRY_XHR_DATA_KEY];\n\n      if (!sentryXhrData) {\n        return originalSend.apply(sendThisArg, sendArgArray);\n      }\n\n      if (sendArgArray[0] !== undefined) {\n        sentryXhrData.body = sendArgArray[0];\n      }\n\n      const handlerData: HandlerDataXhr = {\n        startTimestamp: timestampInSeconds() * 1000,\n        xhr: sendThisArg,\n      };\n      triggerHandlers('xhr', handlerData);\n\n      return originalSend.apply(sendThisArg, sendArgArray);\n    },\n  });\n}\n\nfunction parseUrl(url: string | unknown): string | undefined {\n  if (isString(url)) {\n    return url;\n  }\n\n  try {\n    // url can be a string or URL\n    // but since URL is not available in IE11, we do not check for it,\n    // but simply assume it is an URL and return `toString()` from it (which returns the full URL)\n    // If that fails, we just return undefined\n    return (url as URL).toString();\n  } catch {} // eslint-disable-line no-empty\n\n  return undefined;\n}\n","/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable @typescript-eslint/ban-types */\nimport type { ConsoleLevel, HandlerDataConsole } from '../../types-hoist';\n\nimport { CONSOLE_LEVELS, originalConsoleMethods } from '../logger';\nimport { fill } from '../object';\nimport { GLOBAL_OBJ } from '../worldwide';\nimport { addHandler, maybeInstrument, triggerHandlers } from './handlers';\n\n/**\n * Add an instrumentation handler for when a console.xxx method is called.\n *\n * Use at your own risk, this might break without changelog notice, only used internally.\n * @hidden\n */\nexport function addConsoleInstrumentationHandler(handler: (data: HandlerDataConsole) => void): void {\n  const type = 'console';\n  addHandler(type, handler);\n  maybeInstrument(type, instrumentConsole);\n}\n\nfunction instrumentConsole(): void {\n  if (!('console' in GLOBAL_OBJ)) {\n    return;\n  }\n\n  CONSOLE_LEVELS.forEach(function (level: ConsoleLevel): void {\n    if (!(level in GLOBAL_OBJ.console)) {\n      return;\n    }\n\n    fill(GLOBAL_OBJ.console, level, function (originalConsoleMethod: () => any): Function {\n      originalConsoleMethods[level] = originalConsoleMethod;\n\n      return function (...args: any[]): void {\n        const handlerData: HandlerDataConsole = { args, level };\n        triggerHandlers('console', handlerData);\n\n        const log = originalConsoleMethods[level];\n        log?.apply(GLOBAL_OBJ.console, args);\n      };\n    });\n  });\n}\n","/* eslint-disable @typescript-eslint/no-explicit-any */\nimport type { HandlerDataFetch } from '../../types-hoist';\n\nimport { isError } from '../is';\nimport { addNonEnumerableProperty, fill } from '../object';\nimport { supportsNativeFetch } from '../supports';\nimport { timestampInSeconds } from '../time';\nimport { GLOBAL_OBJ } from '../worldwide';\nimport { addHandler, maybeInstrument, triggerHandlers } from './handlers';\n\ntype FetchResource = string | { toString(): string } | { url: string };\n\n/**\n * Add an instrumentation handler for when a fetch request happens.\n * The handler function is called once when the request starts and once when it ends,\n * which can be identified by checking if it has an `endTimestamp`.\n *\n * Use at your own risk, this might break without changelog notice, only used internally.\n * @hidden\n */\nexport function addFetchInstrumentationHandler(\n  handler: (data: HandlerDataFetch) => void,\n  skipNativeFetchCheck?: boolean,\n): void {\n  const type = 'fetch';\n  addHandler(type, handler);\n  maybeInstrument(type, () => instrumentFetch(undefined, skipNativeFetchCheck));\n}\n\n/**\n * Add an instrumentation handler for long-lived fetch requests, like consuming server-sent events (SSE) via fetch.\n * The handler will resolve the request body and emit the actual `endTimestamp`, so that the\n * span can be updated accordingly.\n *\n * Only used internally\n * @hidden\n */\nexport function addFetchEndInstrumentationHandler(handler: (data: HandlerDataFetch) => void): void {\n  const type = 'fetch-body-resolved';\n  addHandler(type, handler);\n  maybeInstrument(type, () => instrumentFetch(streamHandler));\n}\n\nfunction instrumentFetch(onFetchResolved?: (response: Response) => void, skipNativeFetchCheck: boolean = false): void {\n  if (skipNativeFetchCheck && !supportsNativeFetch()) {\n    return;\n  }\n\n  fill(GLOBAL_OBJ, 'fetch', function (originalFetch: () => void): () => void {\n    return function (...args: any[]): void {\n      // We capture the error right here and not in the Promise error callback because Safari (and probably other\n      // browsers too) will wipe the stack trace up to this point, only leaving us with this file which is useless.\n\n      // NOTE: If you are a Sentry user, and you are seeing this stack frame,\n      //       it means the error, that was caused by your fetch call did not\n      //       have a stack trace, so the SDK backfilled the stack trace so\n      //       you can see which fetch call failed.\n      const virtualError = new Error();\n\n      const { method, url } = parseFetchArgs(args);\n      const handlerData: HandlerDataFetch = {\n        args,\n        fetchData: {\n          method,\n          url,\n        },\n        startTimestamp: timestampInSeconds() * 1000,\n        // // Adding the error to be able to fingerprint the failed fetch event in HttpClient instrumentation\n        virtualError,\n      };\n\n      // if there is no callback, fetch is instrumented directly\n      if (!onFetchResolved) {\n        triggerHandlers('fetch', {\n          ...handlerData,\n        });\n      }\n\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n      return originalFetch.apply(GLOBAL_OBJ, args).then(\n        async (response: Response) => {\n          if (onFetchResolved) {\n            onFetchResolved(response);\n          } else {\n            triggerHandlers('fetch', {\n              ...handlerData,\n              endTimestamp: timestampInSeconds() * 1000,\n              response,\n            });\n          }\n\n          return response;\n        },\n        (error: Error) => {\n          triggerHandlers('fetch', {\n            ...handlerData,\n            endTimestamp: timestampInSeconds() * 1000,\n            error,\n          });\n\n          if (isError(error) && error.stack === undefined) {\n            // NOTE: If you are a Sentry user, and you are seeing this stack frame,\n            //       it means the error, that was caused by your fetch call did not\n            //       have a stack trace, so the SDK backfilled the stack trace so\n            //       you can see which fetch call failed.\n            error.stack = virtualError.stack;\n            addNonEnumerableProperty(error, 'framesToPop', 1);\n          }\n\n          // NOTE: If you are a Sentry user, and you are seeing this stack frame,\n          //       it means the sentry.javascript SDK caught an error invoking your application code.\n          //       This is expected behavior and NOT indicative of a bug with sentry.javascript.\n          throw error;\n        },\n      );\n    };\n  });\n}\n\nasync function resolveResponse(res: Response | undefined, onFinishedResolving: () => void): Promise<void> {\n  if (res?.body) {\n    const body = res.body;\n    const responseReader = body.getReader();\n\n    // Define a maximum duration after which we just cancel\n    const maxFetchDurationTimeout = setTimeout(\n      () => {\n        body.cancel().then(null, () => {\n          // noop\n        });\n      },\n      90 * 1000, // 90s\n    );\n\n    let readingActive = true;\n    while (readingActive) {\n      let chunkTimeout;\n      try {\n        // abort reading if read op takes more than 5s\n        chunkTimeout = setTimeout(() => {\n          body.cancel().then(null, () => {\n            // noop on error\n          });\n        }, 5000);\n\n        // This .read() call will reject/throw when we abort due to timeouts through `body.cancel()`\n        const { done } = await responseReader.read();\n\n        clearTimeout(chunkTimeout);\n\n        if (done) {\n          onFinishedResolving();\n          readingActive = false;\n        }\n      } catch (error) {\n        readingActive = false;\n      } finally {\n        clearTimeout(chunkTimeout);\n      }\n    }\n\n    clearTimeout(maxFetchDurationTimeout);\n\n    responseReader.releaseLock();\n    body.cancel().then(null, () => {\n      // noop on error\n    });\n  }\n}\n\nfunction streamHandler(response: Response): void {\n  // clone response for awaiting stream\n  let clonedResponseForResolving: Response;\n  try {\n    clonedResponseForResolving = response.clone();\n  } catch {\n    return;\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-floating-promises\n  resolveResponse(clonedResponseForResolving, () => {\n    triggerHandlers('fetch-body-resolved', {\n      endTimestamp: timestampInSeconds() * 1000,\n      response,\n    });\n  });\n}\n\nfunction hasProp<T extends string>(obj: unknown, prop: T): obj is Record<string, string> {\n  return !!obj && typeof obj === 'object' && !!(obj as Record<string, string>)[prop];\n}\n\nfunction getUrlFromResource(resource: FetchResource): string {\n  if (typeof resource === 'string') {\n    return resource;\n  }\n\n  if (!resource) {\n    return '';\n  }\n\n  if (hasProp(resource, 'url')) {\n    return resource.url;\n  }\n\n  if (resource.toString) {\n    return resource.toString();\n  }\n\n  return '';\n}\n\n/**\n * Parses the fetch arguments to find the used Http method and the url of the request.\n * Exported for tests only.\n */\nexport function parseFetchArgs(fetchArgs: unknown[]): { method: string; url: string } {\n  if (fetchArgs.length === 0) {\n    return { method: 'GET', url: '' };\n  }\n\n  if (fetchArgs.length === 2) {\n    const [url, options] = fetchArgs as [FetchResource, object];\n\n    return {\n      url: getUrlFromResource(url),\n      method: hasProp(options, 'method') ? String(options.method).toUpperCase() : 'GET',\n    };\n  }\n\n  const arg = fetchArgs[0];\n  return {\n    url: getUrlFromResource(arg as FetchResource),\n    method: hasProp(arg, 'method') ? String(arg.method).toUpperCase() : 'GET',\n  };\n}\n","import { getClient, getIsolationScope } from './currentScopes';\nimport type { Breadcrumb, BreadcrumbHint } from './types-hoist';\nimport { consoleSandbox } from './utils-hoist/logger';\nimport { dateTimestampInSeconds } from './utils-hoist/time';\n\n/**\n * Default maximum number of breadcrumbs added to an event. Can be overwritten\n * with {@link Options.maxBreadcrumbs}.\n */\nconst DEFAULT_BREADCRUMBS = 100;\n\n/**\n * Records a new breadcrumb which will be attached to future events.\n *\n * Breadcrumbs will be added to subsequent events to provide more context on\n * user's actions prior to an error or crash.\n */\nexport function addBreadcrumb(breadcrumb: Breadcrumb, hint?: BreadcrumbHint): void {\n  const client = getClient();\n  const isolationScope = getIsolationScope();\n\n  if (!client) return;\n\n  const { beforeBreadcrumb = null, maxBreadcrumbs = DEFAULT_BREADCRUMBS } = client.getOptions();\n\n  if (maxBreadcrumbs <= 0) return;\n\n  const timestamp = dateTimestampInSeconds();\n  const mergedBreadcrumb = { timestamp, ...breadcrumb };\n  const finalBreadcrumb = beforeBreadcrumb\n    ? (consoleSandbox(() => beforeBreadcrumb(mergedBreadcrumb, hint)) as Breadcrumb | null)\n    : mergedBreadcrumb;\n\n  if (finalBreadcrumb === null) return;\n\n  if (client.emit) {\n    client.emit('beforeAddBreadcrumb', finalBreadcrumb, hint);\n  }\n\n  isolationScope.addBreadcrumb(finalBreadcrumb, maxBreadcrumbs);\n}\n","import type { SeverityLevel } from '../types-hoist';\n\n/**\n * Converts a string-based level into a `SeverityLevel`, normalizing it along the way.\n *\n * @param level String representation of desired `SeverityLevel`.\n * @returns The `SeverityLevel` corresponding to the given string, or 'log' if the string isn't a valid level.\n */\nexport function severityLevelFromString(level: SeverityLevel | string): SeverityLevel {\n  return (\n    level === 'warn' ? 'warning' : ['fatal', 'error', 'warning', 'log', 'info', 'debug'].includes(level) ? level : 'log'\n  ) as SeverityLevel;\n}\n","import type { SeverityLevel } from '../types-hoist';\n\n/**\n * Determine a breadcrumb's log level (only `warning` or `error`) based on an HTTP status code.\n */\nexport function getBreadcrumbLogLevelFromHttpStatusCode(statusCode: number | undefined): SeverityLevel | undefined {\n  // NOTE: undefined defaults to 'info' in Sentry\n  if (statusCode === undefined) {\n    return undefined;\n  } else if (statusCode >= 400 && statusCode < 500) {\n    return 'warning';\n  } else if (statusCode >= 500) {\n    return 'error';\n  } else {\n    return undefined;\n  }\n}\n","type PartialURL = {\n  host?: string;\n  path?: string;\n  protocol?: string;\n  relative?: string;\n  search?: string;\n  hash?: string;\n};\n\n/**\n * Parses string form of URL into an object\n * // borrowed from https://tools.ietf.org/html/rfc3986#appendix-B\n * // intentionally using regex and not <a/> href parsing trick because React Native and other\n * // environments where DOM might not be available\n * @returns parsed URL object\n */\nexport function parseUrl(url: string): PartialURL {\n  if (!url) {\n    return {};\n  }\n\n  const match = url.match(/^(([^:/?#]+):)?(\\/\\/([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?$/);\n\n  if (!match) {\n    return {};\n  }\n\n  // coerce to undefined values to empty string so we don't get 'undefined'\n  const query = match[6] || '';\n  const fragment = match[8] || '';\n  return {\n    host: match[4],\n    path: match[5],\n    protocol: match[2],\n    search: query,\n    hash: fragment,\n    relative: match[5] + query + fragment, // everything minus origin\n  };\n}\n\n/**\n * Strip the query string and fragment off of a given URL or path (if present)\n *\n * @param urlPath Full URL or path, including possible query string and/or fragment\n * @returns URL or path without query string or fragment\n */\nexport function stripUrlQueryAndFragment(urlPath: string): string {\n  return (urlPath.split(/[?#]/, 1) as [string, ...string[]])[0];\n}\n\n/**\n * Takes a URL object and returns a sanitized string which is safe to use as span name\n * see: https://develop.sentry.dev/sdk/data-handling/#structuring-data\n */\nexport function getSanitizedUrlString(url: PartialURL): string {\n  const { protocol, host, path } = url;\n\n  const filteredHost =\n    host\n      // Always filter out authority\n      ?.replace(/^.*@/, '[filtered]:[filtered]@')\n      // Don't show standard :80 (http) and :443 (https) ports to reduce the noise\n      // TODO: Use new URL global if it exists\n      .replace(/(:80)$/, '')\n      .replace(/(:443)$/, '') || '';\n\n  return `${protocol ? `${protocol}://` : ''}${filteredHost}${path}`;\n}\n","/* eslint-disable max-lines */\n\nimport {\n  SENTRY_XHR_DATA_KEY,\n  addClickKeypressInstrumentationHandler,\n  addHistoryInstrumentationHandler,\n  addXhrInstrumentationHandler,\n} from '@sentry-internal/browser-utils';\nimport type { FetchHint, XhrHint } from '@sentry-internal/browser-utils';\nimport type {\n  Breadcrumb,\n  Client,\n  Event as SentryEvent,\n  FetchBreadcrumbData,\n  FetchBreadcrumbHint,\n  HandlerDataConsole,\n  HandlerDataDom,\n  HandlerDataFetch,\n  HandlerDataHistory,\n  HandlerDataXhr,\n  IntegrationFn,\n  XhrBreadcrumbData,\n  XhrBreadcrumbHint,\n} from '@sentry/core';\nimport {\n  addBreadcrumb,\n  addConsoleInstrumentationHandler,\n  addFetchInstrumentationHandler,\n  defineIntegration,\n  getBreadcrumbLogLevelFromHttpStatusCode,\n  getClient,\n  getComponentName,\n  getEventDescription,\n  htmlTreeAsString,\n  logger,\n  parseUrl,\n  safeJoin,\n  severityLevelFromString,\n} from '@sentry/core';\n\nimport { DEBUG_BUILD } from '../debug-build';\nimport { WINDOW } from '../helpers';\n\ninterface BreadcrumbsOptions {\n  console: boolean;\n  dom:\n    | boolean\n    | {\n        serializeAttribute?: string | string[];\n        maxStringLength?: number;\n      };\n  fetch: boolean;\n  history: boolean;\n  sentry: boolean;\n  xhr: boolean;\n}\n\n/** maxStringLength gets capped to prevent 100 breadcrumbs exceeding 1MB event payload size */\nconst MAX_ALLOWED_STRING_LENGTH = 1024;\n\nconst INTEGRATION_NAME = 'Breadcrumbs';\n\nconst _breadcrumbsIntegration = ((options: Partial<BreadcrumbsOptions> = {}) => {\n  const _options = {\n    console: true,\n    dom: true,\n    fetch: true,\n    history: true,\n    sentry: true,\n    xhr: true,\n    ...options,\n  };\n\n  return {\n    name: INTEGRATION_NAME,\n    setup(client) {\n      if (_options.console) {\n        addConsoleInstrumentationHandler(_getConsoleBreadcrumbHandler(client));\n      }\n      if (_options.dom) {\n        addClickKeypressInstrumentationHandler(_getDomBreadcrumbHandler(client, _options.dom));\n      }\n      if (_options.xhr) {\n        addXhrInstrumentationHandler(_getXhrBreadcrumbHandler(client));\n      }\n      if (_options.fetch) {\n        addFetchInstrumentationHandler(_getFetchBreadcrumbHandler(client));\n      }\n      if (_options.history) {\n        addHistoryInstrumentationHandler(_getHistoryBreadcrumbHandler(client));\n      }\n      if (_options.sentry) {\n        client.on('beforeSendEvent', _getSentryBreadcrumbHandler(client));\n      }\n    },\n  };\n}) satisfies IntegrationFn;\n\nexport const breadcrumbsIntegration = defineIntegration(_breadcrumbsIntegration);\n\n/**\n * Adds a breadcrumb for Sentry events or transactions if this option is enabled.\n */\nfunction _getSentryBreadcrumbHandler(client: Client): (event: SentryEvent) => void {\n  return function addSentryBreadcrumb(event: SentryEvent): void {\n    if (getClient() !== client) {\n      return;\n    }\n\n    addBreadcrumb(\n      {\n        category: `sentry.${event.type === 'transaction' ? 'transaction' : 'event'}`,\n        event_id: event.event_id,\n        level: event.level,\n        message: getEventDescription(event),\n      },\n      {\n        event,\n      },\n    );\n  };\n}\n\n/**\n * A HOC that creates a function that creates breadcrumbs from DOM API calls.\n * This is a HOC so that we get access to dom options in the closure.\n */\nfunction _getDomBreadcrumbHandler(\n  client: Client,\n  dom: BreadcrumbsOptions['dom'],\n): (handlerData: HandlerDataDom) => void {\n  return function _innerDomBreadcrumb(handlerData: HandlerDataDom): void {\n    if (getClient() !== client) {\n      return;\n    }\n\n    let target;\n    let componentName;\n    let keyAttrs = typeof dom === 'object' ? dom.serializeAttribute : undefined;\n\n    let maxStringLength =\n      typeof dom === 'object' && typeof dom.maxStringLength === 'number' ? dom.maxStringLength : undefined;\n    if (maxStringLength && maxStringLength > MAX_ALLOWED_STRING_LENGTH) {\n      DEBUG_BUILD &&\n        logger.warn(\n          `\\`dom.maxStringLength\\` cannot exceed ${MAX_ALLOWED_STRING_LENGTH}, but a value of ${maxStringLength} was configured. Sentry will use ${MAX_ALLOWED_STRING_LENGTH} instead.`,\n        );\n      maxStringLength = MAX_ALLOWED_STRING_LENGTH;\n    }\n\n    if (typeof keyAttrs === 'string') {\n      keyAttrs = [keyAttrs];\n    }\n\n    // Accessing event.target can throw (see getsentry/raven-js#838, #768)\n    try {\n      const event = handlerData.event as Event | Node;\n      const element = _isEvent(event) ? event.target : event;\n\n      target = htmlTreeAsString(element, { keyAttrs, maxStringLength });\n      componentName = getComponentName(element);\n    } catch (e) {\n      target = '<unknown>';\n    }\n\n    if (target.length === 0) {\n      return;\n    }\n\n    const breadcrumb: Breadcrumb = {\n      category: `ui.${handlerData.name}`,\n      message: target,\n    };\n\n    if (componentName) {\n      breadcrumb.data = { 'ui.component_name': componentName };\n    }\n\n    addBreadcrumb(breadcrumb, {\n      event: handlerData.event,\n      name: handlerData.name,\n      global: handlerData.global,\n    });\n  };\n}\n\n/**\n * Creates breadcrumbs from console API calls\n */\nfunction _getConsoleBreadcrumbHandler(client: Client): (handlerData: HandlerDataConsole) => void {\n  return function _consoleBreadcrumb(handlerData: HandlerDataConsole): void {\n    if (getClient() !== client) {\n      return;\n    }\n\n    const breadcrumb = {\n      category: 'console',\n      data: {\n        arguments: handlerData.args,\n        logger: 'console',\n      },\n      level: severityLevelFromString(handlerData.level),\n      message: safeJoin(handlerData.args, ' '),\n    };\n\n    if (handlerData.level === 'assert') {\n      if (handlerData.args[0] === false) {\n        breadcrumb.message = `Assertion failed: ${safeJoin(handlerData.args.slice(1), ' ') || 'console.assert'}`;\n        breadcrumb.data.arguments = handlerData.args.slice(1);\n      } else {\n        // Don't capture a breadcrumb for passed assertions\n        return;\n      }\n    }\n\n    addBreadcrumb(breadcrumb, {\n      input: handlerData.args,\n      level: handlerData.level,\n    });\n  };\n}\n\n/**\n * Creates breadcrumbs from XHR API calls\n */\nfunction _getXhrBreadcrumbHandler(client: Client): (handlerData: HandlerDataXhr) => void {\n  return function _xhrBreadcrumb(handlerData: HandlerDataXhr): void {\n    if (getClient() !== client) {\n      return;\n    }\n\n    const { startTimestamp, endTimestamp } = handlerData;\n\n    const sentryXhrData = handlerData.xhr[SENTRY_XHR_DATA_KEY];\n\n    // We only capture complete, non-sentry requests\n    if (!startTimestamp || !endTimestamp || !sentryXhrData) {\n      return;\n    }\n\n    const { method, url, status_code, body } = sentryXhrData;\n\n    const data: XhrBreadcrumbData = {\n      method,\n      url,\n      status_code,\n    };\n\n    const hint: XhrBreadcrumbHint = {\n      xhr: handlerData.xhr,\n      input: body,\n      startTimestamp,\n      endTimestamp,\n    };\n\n    const breadcrumb = {\n      category: 'xhr',\n      data,\n      type: 'http',\n      level: getBreadcrumbLogLevelFromHttpStatusCode(status_code),\n    };\n\n    client.emit('beforeOutgoingRequestBreadcrumb', breadcrumb, hint as XhrHint);\n\n    addBreadcrumb(breadcrumb, hint);\n  };\n}\n\n/**\n * Creates breadcrumbs from fetch API calls\n */\nfunction _getFetchBreadcrumbHandler(client: Client): (handlerData: HandlerDataFetch) => void {\n  return function _fetchBreadcrumb(handlerData: HandlerDataFetch): void {\n    if (getClient() !== client) {\n      return;\n    }\n\n    const { startTimestamp, endTimestamp } = handlerData;\n\n    // We only capture complete fetch requests\n    if (!endTimestamp) {\n      return;\n    }\n\n    if (handlerData.fetchData.url.match(/sentry_key/) && handlerData.fetchData.method === 'POST') {\n      // We will not create breadcrumbs for fetch requests that contain `sentry_key` (internal sentry requests)\n      return;\n    }\n\n    const breadcrumbData: FetchBreadcrumbData = {\n      method: handlerData.fetchData.method,\n      url: handlerData.fetchData.url,\n    };\n\n    if (handlerData.error) {\n      const data: FetchBreadcrumbData = handlerData.fetchData;\n      const hint: FetchBreadcrumbHint = {\n        data: handlerData.error,\n        input: handlerData.args,\n        startTimestamp,\n        endTimestamp,\n      };\n\n      const breadcrumb = {\n        category: 'fetch',\n        data,\n        level: 'error',\n        type: 'http',\n      } satisfies Breadcrumb;\n\n      client.emit('beforeOutgoingRequestBreadcrumb', breadcrumb, hint as FetchHint);\n\n      addBreadcrumb(breadcrumb, hint);\n    } else {\n      const response = handlerData.response as Response | undefined;\n      const data: FetchBreadcrumbData = {\n        ...handlerData.fetchData,\n        status_code: response?.status,\n      };\n\n      breadcrumbData.request_body_size = handlerData.fetchData.request_body_size;\n      breadcrumbData.response_body_size = handlerData.fetchData.response_body_size;\n      breadcrumbData.status_code = response?.status;\n\n      const hint: FetchBreadcrumbHint = {\n        input: handlerData.args,\n        response,\n        startTimestamp,\n        endTimestamp,\n      };\n\n      const breadcrumb = {\n        category: 'fetch',\n        data,\n        type: 'http',\n        level: getBreadcrumbLogLevelFromHttpStatusCode(data.status_code),\n      };\n\n      client.emit('beforeOutgoingRequestBreadcrumb', breadcrumb, hint as FetchHint);\n\n      addBreadcrumb(breadcrumb, hint);\n    }\n  };\n}\n\n/**\n * Creates breadcrumbs from history API calls\n */\nfunction _getHistoryBreadcrumbHandler(client: Client): (handlerData: HandlerDataHistory) => void {\n  return function _historyBreadcrumb(handlerData: HandlerDataHistory): void {\n    if (getClient() !== client) {\n      return;\n    }\n\n    let from: string | undefined = handlerData.from;\n    let to: string | undefined = handlerData.to;\n    const parsedLoc = parseUrl(WINDOW.location.href);\n    let parsedFrom = from ? parseUrl(from) : undefined;\n    const parsedTo = parseUrl(to);\n\n    // Initial pushState doesn't provide `from` information\n    if (!parsedFrom?.path) {\n      parsedFrom = parsedLoc;\n    }\n\n    // Use only the path component of the URL if the URL matches the current\n    // document (almost all the time when using pushState)\n    if (parsedLoc.protocol === parsedTo.protocol && parsedLoc.host === parsedTo.host) {\n      to = parsedTo.relative;\n    }\n    if (parsedLoc.protocol === parsedFrom.protocol && parsedLoc.host === parsedFrom.host) {\n      from = parsedFrom.relative;\n    }\n\n    addBreadcrumb({\n      category: 'navigation',\n      data: {\n        from,\n        to,\n      },\n    });\n  };\n}\n\nfunction _isEvent(event: unknown): event is Event {\n  return !!event && !!(event as Record<string, unknown>).target;\n}\n","import type { IntegrationFn, WrappedFunction } from '@sentry/core';\nimport { defineIntegration, fill, getFunctionName, getOriginalFunction } from '@sentry/core';\n\nimport { WINDOW, wrap } from '../helpers';\n\nconst DEFAULT_EVENT_TARGET = [\n  'EventTarget',\n  'Window',\n  'Node',\n  'ApplicationCache',\n  'AudioTrackList',\n  'BroadcastChannel',\n  'ChannelMergerNode',\n  'CryptoOperation',\n  'EventSource',\n  'FileReader',\n  'HTMLUnknownElement',\n  'IDBDatabase',\n  'IDBRequest',\n  'IDBTransaction',\n  'KeyOperation',\n  'MediaController',\n  'MessagePort',\n  'ModalWindow',\n  'Notification',\n  'SVGElementInstance',\n  'Screen',\n  'SharedWorker',\n  'TextTrack',\n  'TextTrackCue',\n  'TextTrackList',\n  'WebSocket',\n  'WebSocketWorker',\n  'Worker',\n  'XMLHttpRequest',\n  'XMLHttpRequestEventTarget',\n  'XMLHttpRequestUpload',\n];\n\nconst INTEGRATION_NAME = 'BrowserApiErrors';\n\ntype XMLHttpRequestProp = 'onload' | 'onerror' | 'onprogress' | 'onreadystatechange';\n\ninterface BrowserApiErrorsOptions {\n  setTimeout: boolean;\n  setInterval: boolean;\n  requestAnimationFrame: boolean;\n  XMLHttpRequest: boolean;\n  eventTarget: boolean | string[];\n}\n\nconst _browserApiErrorsIntegration = ((options: Partial<BrowserApiErrorsOptions> = {}) => {\n  const _options = {\n    XMLHttpRequest: true,\n    eventTarget: true,\n    requestAnimationFrame: true,\n    setInterval: true,\n    setTimeout: true,\n    ...options,\n  };\n\n  return {\n    name: INTEGRATION_NAME,\n    // TODO: This currently only works for the first client this is setup\n    // We may want to adjust this to check for client etc.\n    setupOnce() {\n      if (_options.setTimeout) {\n        fill(WINDOW, 'setTimeout', _wrapTimeFunction);\n      }\n\n      if (_options.setInterval) {\n        fill(WINDOW, 'setInterval', _wrapTimeFunction);\n      }\n\n      if (_options.requestAnimationFrame) {\n        fill(WINDOW, 'requestAnimationFrame', _wrapRAF);\n      }\n\n      if (_options.XMLHttpRequest && 'XMLHttpRequest' in WINDOW) {\n        fill(XMLHttpRequest.prototype, 'send', _wrapXHR);\n      }\n\n      const eventTargetOption = _options.eventTarget;\n      if (eventTargetOption) {\n        const eventTarget = Array.isArray(eventTargetOption) ? eventTargetOption : DEFAULT_EVENT_TARGET;\n        eventTarget.forEach(_wrapEventTarget);\n      }\n    },\n  };\n}) satisfies IntegrationFn;\n\n/**\n * Wrap timer functions and event targets to catch errors and provide better meta data.\n */\nexport const browserApiErrorsIntegration = defineIntegration(_browserApiErrorsIntegration);\n\nfunction _wrapTimeFunction(original: () => void): () => number {\n  return function (this: unknown, ...args: unknown[]): number {\n    const originalCallback = args[0];\n    args[0] = wrap(originalCallback, {\n      mechanism: {\n        data: { function: getFunctionName(original) },\n        handled: false,\n        type: 'instrument',\n      },\n    });\n    return original.apply(this, args);\n  };\n}\n\nfunction _wrapRAF(original: () => void): (callback: () => void) => unknown {\n  return function (this: unknown, callback: () => void): () => void {\n    return original.apply(this, [\n      wrap(callback, {\n        mechanism: {\n          data: {\n            function: 'requestAnimationFrame',\n            handler: getFunctionName(original),\n          },\n          handled: false,\n          type: 'instrument',\n        },\n      }),\n    ]);\n  };\n}\n\nfunction _wrapXHR(originalSend: () => void): () => void {\n  return function (this: XMLHttpRequest, ...args: unknown[]): void {\n    // eslint-disable-next-line @typescript-eslint/no-this-alias\n    const xhr = this;\n    const xmlHttpRequestProps: XMLHttpRequestProp[] = ['onload', 'onerror', 'onprogress', 'onreadystatechange'];\n\n    xmlHttpRequestProps.forEach(prop => {\n      if (prop in xhr && typeof xhr[prop] === 'function') {\n        fill(xhr, prop, function (original) {\n          const wrapOptions = {\n            mechanism: {\n              data: {\n                function: prop,\n                handler: getFunctionName(original),\n              },\n              handled: false,\n              type: 'instrument',\n            },\n          };\n\n          // If Instrument integration has been called before BrowserApiErrors, get the name of original function\n          const originalFunction = getOriginalFunction(original);\n          if (originalFunction) {\n            wrapOptions.mechanism.data.handler = getFunctionName(originalFunction);\n          }\n\n          // Otherwise wrap directly\n          return wrap(original, wrapOptions);\n        });\n      }\n    });\n\n    return originalSend.apply(this, args);\n  };\n}\n\nfunction _wrapEventTarget(target: string): void {\n  const globalObject = WINDOW as unknown as Record<string, { prototype?: object }>;\n  const proto = globalObject[target]?.prototype;\n\n  // eslint-disable-next-line no-prototype-builtins\n  if (!proto?.hasOwnProperty?.('addEventListener')) {\n    return;\n  }\n\n  fill(proto, 'addEventListener', function (original: VoidFunction): (\n    ...args: Parameters<typeof WINDOW.addEventListener>\n  ) => ReturnType<typeof WINDOW.addEventListener> {\n    return function (this: unknown, eventName, fn, options): VoidFunction {\n      try {\n        if (isEventListenerObject(fn)) {\n          // ESlint disable explanation:\n          //  First, it is generally safe to call `wrap` with an unbound function. Furthermore, using `.bind()` would\n          //  introduce a bug here, because bind returns a new function that doesn't have our\n          //  flags(like __sentry_original__) attached. `wrap` checks for those flags to avoid unnecessary wrapping.\n          //  Without those flags, every call to addEventListener wraps the function again, causing a memory leak.\n          // eslint-disable-next-line @typescript-eslint/unbound-method\n          fn.handleEvent = wrap(fn.handleEvent, {\n            mechanism: {\n              data: {\n                function: 'handleEvent',\n                handler: getFunctionName(fn),\n                target,\n              },\n              handled: false,\n              type: 'instrument',\n            },\n          });\n        }\n      } catch {\n        // can sometimes get 'Permission denied to access property \"handle Event'\n      }\n\n      return original.apply(this, [\n        eventName,\n        wrap(fn, {\n          mechanism: {\n            data: {\n              function: 'addEventListener',\n              handler: getFunctionName(fn),\n              target,\n            },\n            handled: false,\n            type: 'instrument',\n          },\n        }),\n        options,\n      ]);\n    };\n  });\n\n  fill(proto, 'removeEventListener', function (originalRemoveEventListener: VoidFunction): (\n    this: unknown,\n    ...args: Parameters<typeof WINDOW.removeEventListener>\n  ) => ReturnType<typeof WINDOW.removeEventListener> {\n    return function (this: unknown, eventName, fn, options): VoidFunction {\n      /**\n       * There are 2 possible scenarios here:\n       *\n       * 1. Someone passes a callback, which was attached prior to Sentry initialization, or by using unmodified\n       * method, eg. `document.addEventListener.call(el, name, handler). In this case, we treat this function\n       * as a pass-through, and call original `removeEventListener` with it.\n       *\n       * 2. Someone passes a callback, which was attached after Sentry was initialized, which means that it was using\n       * our wrapped version of `addEventListener`, which internally calls `wrap` helper.\n       * This helper \"wraps\" whole callback inside a try/catch statement, and attached appropriate metadata to it,\n       * in order for us to make a distinction between wrapped/non-wrapped functions possible.\n       * If a function was wrapped, it has additional property of `__sentry_wrapped__`, holding the handler.\n       *\n       * When someone adds a handler prior to initialization, and then do it again, but after,\n       * then we have to detach both of them. Otherwise, if we'd detach only wrapped one, it'd be impossible\n       * to get rid of the initial handler and it'd stick there forever.\n       */\n      try {\n        const originalEventHandler = (fn as WrappedFunction).__sentry_wrapped__;\n        if (originalEventHandler) {\n          originalRemoveEventListener.call(this, eventName, originalEventHandler, options);\n        }\n      } catch (e) {\n        // ignore, accessing __sentry_wrapped__ will throw in some Selenium environments\n      }\n      return originalRemoveEventListener.call(this, eventName, fn, options);\n    };\n  });\n}\n\nfunction isEventListenerObject(obj: unknown): obj is EventListenerObject {\n  return typeof (obj as EventListenerObject).handleEvent === 'function';\n}\n","import type { HandlerDataError } from '../../types-hoist';\n\nimport { GLOBAL_OBJ } from '../worldwide';\nimport { addHandler, maybeInstrument, triggerHandlers } from './handlers';\n\nlet _oldOnErrorHandler: (typeof GLOBAL_OBJ)['onerror'] | null = null;\n\n/**\n * Add an instrumentation handler for when an error is captured by the global error handler.\n *\n * Use at your own risk, this might break without changelog notice, only used internally.\n * @hidden\n */\nexport function addGlobalErrorInstrumentationHandler(handler: (data: HandlerDataError) => void): void {\n  const type = 'error';\n  addHandler(type, handler);\n  maybeInstrument(type, instrumentError);\n}\n\nfunction instrumentError(): void {\n  _oldOnErrorHandler = GLOBAL_OBJ.onerror;\n\n  // Note: The reason we are doing window.onerror instead of window.addEventListener('error')\n  // is that we are using this handler in the Loader Script, to handle buffered errors consistently\n  GLOBAL_OBJ.onerror = function (\n    msg: string | object,\n    url?: string,\n    line?: number,\n    column?: number,\n    error?: Error,\n  ): boolean {\n    const handlerData: HandlerDataError = {\n      column,\n      error,\n      line,\n      msg,\n      url,\n    };\n    triggerHandlers('error', handlerData);\n\n    if (_oldOnErrorHandler) {\n      // eslint-disable-next-line prefer-rest-params\n      return _oldOnErrorHandler.apply(this, arguments);\n    }\n\n    return false;\n  };\n\n  GLOBAL_OBJ.onerror.__SENTRY_INSTRUMENTED__ = true;\n}\n","import type { HandlerDataUnhandledRejection } from '../../types-hoist';\nimport { GLOBAL_OBJ } from '../worldwide';\nimport { addHandler, maybeInstrument, triggerHandlers } from './handlers';\n\nlet _oldOnUnhandledRejectionHandler: (typeof GLOBAL_OBJ)['onunhandledrejection'] | null = null;\n\n/**\n * Add an instrumentation handler for when an unhandled promise rejection is captured.\n *\n * Use at your own risk, this might break without changelog notice, only used internally.\n * @hidden\n */\nexport function addGlobalUnhandledRejectionInstrumentationHandler(\n  handler: (data: HandlerDataUnhandledRejection) => void,\n): void {\n  const type = 'unhandledrejection';\n  addHandler(type, handler);\n  maybeInstrument(type, instrumentUnhandledRejection);\n}\n\nfunction instrumentUnhandledRejection(): void {\n  _oldOnUnhandledRejectionHandler = GLOBAL_OBJ.onunhandledrejection;\n\n  // Note: The reason we are doing window.onunhandledrejection instead of window.addEventListener('unhandledrejection')\n  // is that we are using this handler in the Loader Script, to handle buffered rejections consistently\n  GLOBAL_OBJ.onunhandledrejection = function (e: unknown): boolean {\n    const handlerData: HandlerDataUnhandledRejection = e;\n    triggerHandlers('unhandledrejection', handlerData);\n\n    if (_oldOnUnhandledRejectionHandler) {\n      // eslint-disable-next-line prefer-rest-params\n      return _oldOnUnhandledRejectionHandler.apply(this, arguments);\n    }\n\n    return true;\n  };\n\n  GLOBAL_OBJ.onunhandledrejection.__SENTRY_INSTRUMENTED__ = true;\n}\n","import type { Client, Event, IntegrationFn, Primitive, StackParser } from '@sentry/core';\nimport {\n  UNKNOWN_FUNCTION,\n  addGlobalErrorInstrumentationHandler,\n  addGlobalUnhandledRejectionInstrumentationHandler,\n  captureEvent,\n  defineIntegration,\n  getClient,\n  getLocationHref,\n  isPrimitive,\n  isString,\n  logger,\n} from '@sentry/core';\n\nimport type { BrowserClient } from '../client';\nimport { DEBUG_BUILD } from '../debug-build';\nimport { eventFromUnknownInput } from '../eventbuilder';\nimport { shouldIgnoreOnError } from '../helpers';\n\ntype GlobalHandlersIntegrationsOptionKeys = 'onerror' | 'onunhandledrejection';\n\ntype GlobalHandlersIntegrations = Record<GlobalHandlersIntegrationsOptionKeys, boolean>;\n\nconst INTEGRATION_NAME = 'GlobalHandlers';\n\nconst _globalHandlersIntegration = ((options: Partial<GlobalHandlersIntegrations> = {}) => {\n  const _options = {\n    onerror: true,\n    onunhandledrejection: true,\n    ...options,\n  };\n\n  return {\n    name: INTEGRATION_NAME,\n    setupOnce() {\n      Error.stackTraceLimit = 50;\n    },\n    setup(client) {\n      if (_options.onerror) {\n        _installGlobalOnErrorHandler(client);\n        globalHandlerLog('onerror');\n      }\n      if (_options.onunhandledrejection) {\n        _installGlobalOnUnhandledRejectionHandler(client);\n        globalHandlerLog('onunhandledrejection');\n      }\n    },\n  };\n}) satisfies IntegrationFn;\n\nexport const globalHandlersIntegration = defineIntegration(_globalHandlersIntegration);\n\nfunction _installGlobalOnErrorHandler(client: Client): void {\n  addGlobalErrorInstrumentationHandler(data => {\n    const { stackParser, attachStacktrace } = getOptions();\n\n    if (getClient() !== client || shouldIgnoreOnError()) {\n      return;\n    }\n\n    const { msg, url, line, column, error } = data;\n\n    const event = _enhanceEventWithInitialFrame(\n      eventFromUnknownInput(stackParser, error || msg, undefined, attachStacktrace, false),\n      url,\n      line,\n      column,\n    );\n\n    event.level = 'error';\n\n    captureEvent(event, {\n      originalException: error,\n      mechanism: {\n        handled: false,\n        type: 'onerror',\n      },\n    });\n  });\n}\n\nfunction _installGlobalOnUnhandledRejectionHandler(client: Client): void {\n  addGlobalUnhandledRejectionInstrumentationHandler(e => {\n    const { stackParser, attachStacktrace } = getOptions();\n\n    if (getClient() !== client || shouldIgnoreOnError()) {\n      return;\n    }\n\n    const error = _getUnhandledRejectionError(e as unknown);\n\n    const event = isPrimitive(error)\n      ? _eventFromRejectionWithPrimitive(error)\n      : eventFromUnknownInput(stackParser, error, undefined, attachStacktrace, true);\n\n    event.level = 'error';\n\n    captureEvent(event, {\n      originalException: error,\n      mechanism: {\n        handled: false,\n        type: 'onunhandledrejection',\n      },\n    });\n  });\n}\n\nfunction _getUnhandledRejectionError(error: unknown): unknown {\n  if (isPrimitive(error)) {\n    return error;\n  }\n\n  // dig the object of the rejection out of known event types\n  try {\n    type ErrorWithReason = { reason: unknown };\n    // PromiseRejectionEvents store the object of the rejection under 'reason'\n    // see https://developer.mozilla.org/en-US/docs/Web/API/PromiseRejectionEvent\n    if ('reason' in (error as ErrorWithReason)) {\n      return (error as ErrorWithReason).reason;\n    }\n\n    type CustomEventWithDetail = { detail: { reason: unknown } };\n    // something, somewhere, (likely a browser extension) effectively casts PromiseRejectionEvents\n    // to CustomEvents, moving the `promise` and `reason` attributes of the PRE into\n    // the CustomEvent's `detail` attribute, since they're not part of CustomEvent's spec\n    // see https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent and\n    // https://github.com/getsentry/sentry-javascript/issues/2380\n    if ('detail' in (error as CustomEventWithDetail) && 'reason' in (error as CustomEventWithDetail).detail) {\n      return (error as CustomEventWithDetail).detail.reason;\n    }\n  } catch {} // eslint-disable-line no-empty\n\n  return error;\n}\n\n/**\n * Create an event from a promise rejection where the `reason` is a primitive.\n *\n * @param reason: The `reason` property of the promise rejection\n * @returns An Event object with an appropriate `exception` value\n */\nfunction _eventFromRejectionWithPrimitive(reason: Primitive): Event {\n  return {\n    exception: {\n      values: [\n        {\n          type: 'UnhandledRejection',\n          // String() is needed because the Primitive type includes symbols (which can't be automatically stringified)\n          value: `Non-Error promise rejection captured with value: ${String(reason)}`,\n        },\n      ],\n    },\n  };\n}\n\nfunction _enhanceEventWithInitialFrame(\n  event: Event,\n  url: string | undefined,\n  line: number | undefined,\n  column: number | undefined,\n): Event {\n  // event.exception\n  const e = (event.exception = event.exception || {});\n  // event.exception.values\n  const ev = (e.values = e.values || []);\n  // event.exception.values[0]\n  const ev0 = (ev[0] = ev[0] || {});\n  // event.exception.values[0].stacktrace\n  const ev0s = (ev0.stacktrace = ev0.stacktrace || {});\n  // event.exception.values[0].stacktrace.frames\n  const ev0sf = (ev0s.frames = ev0s.frames || []);\n\n  const colno = column;\n  const lineno = line;\n  const filename = isString(url) && url.length > 0 ? url : getLocationHref();\n\n  // event.exception.values[0].stacktrace.frames\n  if (ev0sf.length === 0) {\n    ev0sf.push({\n      colno,\n      filename,\n      function: UNKNOWN_FUNCTION,\n      in_app: true,\n      lineno,\n    });\n  }\n\n  return event;\n}\n\nfunction globalHandlerLog(type: string): void {\n  DEBUG_BUILD && logger.log(`Global Handler attached: ${type}`);\n}\n\nfunction getOptions(): { stackParser: StackParser; attachStacktrace?: boolean } {\n  const client = getClient<BrowserClient>();\n  const options = client?.getOptions() || {\n    stackParser: () => [],\n    attachStacktrace: false,\n  };\n  return options;\n}\n","import { defineIntegration, getLocationHref } from '@sentry/core';\nimport { WINDOW } from '../helpers';\n\n/**\n * Collects information about HTTP request headers and\n * attaches them to the event.\n */\nexport const httpContextIntegration = defineIntegration(() => {\n  return {\n    name: 'HttpContext',\n    preprocessEvent(event) {\n      // if none of the information we want exists, don't bother\n      if (!WINDOW.navigator && !WINDOW.location && !WINDOW.document) {\n        return;\n      }\n\n      // grab as much info as exists and add it to the event\n      const url = event.request?.url || getLocationHref();\n      const { referrer } = WINDOW.document || {};\n      const { userAgent } = WINDOW.navigator || {};\n\n      const headers = {\n        ...event.request?.headers,\n        ...(referrer && { Referer: referrer }),\n        ...(userAgent && { 'User-Agent': userAgent }),\n      };\n      const request = {\n        ...event.request,\n        ...(url && { url }),\n        headers,\n      };\n\n      event.request = request;\n    },\n  };\n});\n","import type { Client } from './client';\nimport { getCurrentScope } from './currentScopes';\nimport { DEBUG_BUILD } from './debug-build';\nimport type { ClientOptions } from './types-hoist';\nimport { consoleSandbox, logger } from './utils-hoist/logger';\n\n/** A class object that can instantiate Client objects. */\nexport type ClientClass<F extends Client, O extends ClientOptions> = new (options: O) => F;\n\n/**\n * Internal function to create a new SDK client instance. The client is\n * installed and then bound to the current scope.\n *\n * @param clientClass The client class to instantiate.\n * @param options Options to pass to the client.\n */\nexport function initAndBind<F extends Client, O extends ClientOptions>(\n  clientClass: ClientClass<F, O>,\n  options: O,\n): Client {\n  if (options.debug === true) {\n    if (DEBUG_BUILD) {\n      logger.enable();\n    } else {\n      // use `console.warn` rather than `logger.warn` since by non-debug bundles have all `logger.x` statements stripped\n      consoleSandbox(() => {\n        // eslint-disable-next-line no-console\n        console.warn('[Sentry] Cannot initialize SDK with `debug` option using a non-debug bundle.');\n      });\n    }\n  }\n  const scope = getCurrentScope();\n  scope.update(options.initialScope);\n\n  const client = new clientClass(options);\n  setCurrentClient(client);\n  client.init();\n  return client;\n}\n\n/**\n * Make the given client the current client.\n */\nexport function setCurrentClient(client: Client): void {\n  getCurrentScope().setClient(client);\n}\n","import type { ReportDialogOptions } from './report-dialog';\nimport type { DsnComponents, DsnLike, SdkInfo } from './types-hoist';\nimport { dsnToString, makeDsn } from './utils-hoist/dsn';\n\nconst SENTRY_API_VERSION = '7';\n\n/** Returns the prefix to construct Sentry ingestion API endpoints. */\nfunction getBaseApiEndpoint(dsn: DsnComponents): string {\n  const protocol = dsn.protocol ? `${dsn.protocol}:` : '';\n  const port = dsn.port ? `:${dsn.port}` : '';\n  return `${protocol}//${dsn.host}${port}${dsn.path ? `/${dsn.path}` : ''}/api/`;\n}\n\n/** Returns the ingest API endpoint for target. */\nfunction _getIngestEndpoint(dsn: DsnComponents): string {\n  return `${getBaseApiEndpoint(dsn)}${dsn.projectId}/envelope/`;\n}\n\n/** Returns a URL-encoded string with auth config suitable for a query string. */\nfunction _encodedAuth(dsn: DsnComponents, sdkInfo: SdkInfo | undefined): string {\n  const params: Record<string, string> = {\n    sentry_version: SENTRY_API_VERSION,\n  };\n\n  if (dsn.publicKey) {\n    // We send only the minimum set of required information. See\n    // https://github.com/getsentry/sentry-javascript/issues/2572.\n    params.sentry_key = dsn.publicKey;\n  }\n\n  if (sdkInfo) {\n    params.sentry_client = `${sdkInfo.name}/${sdkInfo.version}`;\n  }\n\n  return new URLSearchParams(params).toString();\n}\n\n/**\n * Returns the envelope endpoint URL with auth in the query string.\n *\n * Sending auth as part of the query string and not as custom HTTP headers avoids CORS preflight requests.\n */\nexport function getEnvelopeEndpointWithUrlEncodedAuth(dsn: DsnComponents, tunnel?: string, sdkInfo?: SdkInfo): string {\n  return tunnel ? tunnel : `${_getIngestEndpoint(dsn)}?${_encodedAuth(dsn, sdkInfo)}`;\n}\n\n/** Returns the url to the report dialog endpoint. */\nexport function getReportDialogEndpoint(dsnLike: DsnLike, dialogOptions: ReportDialogOptions): string {\n  const dsn = makeDsn(dsnLike);\n  if (!dsn) {\n    return '';\n  }\n\n  const endpoint = `${getBaseApiEndpoint(dsn)}embed/error-page/`;\n\n  let encodedOptions = `dsn=${dsnToString(dsn)}`;\n  for (const key in dialogOptions) {\n    if (key === 'dsn') {\n      continue;\n    }\n\n    if (key === 'onClose') {\n      continue;\n    }\n\n    if (key === 'user') {\n      const user = dialogOptions.user;\n      if (!user) {\n        continue;\n      }\n      if (user.name) {\n        encodedOptions += `&name=${encodeURIComponent(user.name)}`;\n      }\n      if (user.email) {\n        encodedOptions += `&email=${encodeURIComponent(user.email)}`;\n      }\n    } else {\n      encodedOptions += `&${encodeURIComponent(key)}=${encodeURIComponent(dialogOptions[key] as string)}`;\n    }\n  }\n\n  return `${endpoint}?${encodedOptions}`;\n}\n","import type { DsnComponents, DsnLike, DsnProtocol } from '../types-hoist';\n\nimport { DEBUG_BUILD } from './debug-build';\nimport { consoleSandbox, logger } from './logger';\n\n/** Regular expression used to parse a Dsn. */\nconst DSN_REGEX = /^(?:(\\w+):)\\/\\/(?:(\\w+)(?::(\\w+)?)?@)([\\w.-]+)(?::(\\d+))?\\/(.+)/;\n\nfunction isValidProtocol(protocol?: string): protocol is DsnProtocol {\n  return protocol === 'http' || protocol === 'https';\n}\n\n/**\n * Renders the string representation of this Dsn.\n *\n * By default, this will render the public representation without the password\n * component. To get the deprecated private representation, set `withPassword`\n * to true.\n *\n * @param withPassword When set to true, the password will be included.\n */\nexport function dsnToString(dsn: DsnComponents, withPassword: boolean = false): string {\n  const { host, path, pass, port, projectId, protocol, publicKey } = dsn;\n  return (\n    `${protocol}://${publicKey}${withPassword && pass ? `:${pass}` : ''}` +\n    `@${host}${port ? `:${port}` : ''}/${path ? `${path}/` : path}${projectId}`\n  );\n}\n\n/**\n * Parses a Dsn from a given string.\n *\n * @param str A Dsn as string\n * @returns Dsn as DsnComponents or undefined if @param str is not a valid DSN string\n */\nexport function dsnFromString(str: string): DsnComponents | undefined {\n  const match = DSN_REGEX.exec(str);\n\n  if (!match) {\n    // This should be logged to the console\n    consoleSandbox(() => {\n      // eslint-disable-next-line no-console\n      console.error(`Invalid Sentry Dsn: ${str}`);\n    });\n    return undefined;\n  }\n\n  const [protocol, publicKey, pass = '', host = '', port = '', lastPath = ''] = match.slice(1);\n  let path = '';\n  let projectId = lastPath;\n\n  const split = projectId.split('/');\n  if (split.length > 1) {\n    path = split.slice(0, -1).join('/');\n    projectId = split.pop() as string;\n  }\n\n  if (projectId) {\n    const projectMatch = projectId.match(/^\\d+/);\n    if (projectMatch) {\n      projectId = projectMatch[0];\n    }\n  }\n\n  return dsnFromComponents({ host, pass, path, projectId, port, protocol: protocol as DsnProtocol, publicKey });\n}\n\nfunction dsnFromComponents(components: DsnComponents): DsnComponents {\n  return {\n    protocol: components.protocol,\n    publicKey: components.publicKey || '',\n    pass: components.pass || '',\n    host: components.host,\n    port: components.port || '',\n    path: components.path || '',\n    projectId: components.projectId,\n  };\n}\n\nfunction validateDsn(dsn: DsnComponents): boolean {\n  if (!DEBUG_BUILD) {\n    return true;\n  }\n\n  const { port, projectId, protocol } = dsn;\n\n  const requiredComponents: ReadonlyArray<keyof DsnComponents> = ['protocol', 'publicKey', 'host', 'projectId'];\n  const hasMissingRequiredComponent = requiredComponents.find(component => {\n    if (!dsn[component]) {\n      logger.error(`Invalid Sentry Dsn: ${component} missing`);\n      return true;\n    }\n    return false;\n  });\n\n  if (hasMissingRequiredComponent) {\n    return false;\n  }\n\n  if (!projectId.match(/^\\d+$/)) {\n    logger.error(`Invalid Sentry Dsn: Invalid projectId ${projectId}`);\n    return false;\n  }\n\n  if (!isValidProtocol(protocol)) {\n    logger.error(`Invalid Sentry Dsn: Invalid protocol ${protocol}`);\n    return false;\n  }\n\n  if (port && isNaN(parseInt(port, 10))) {\n    logger.error(`Invalid Sentry Dsn: Invalid port ${port}`);\n    return false;\n  }\n\n  return true;\n}\n\n/**\n * Creates a valid Sentry Dsn object, identifying a Sentry instance and project.\n * @returns a valid DsnComponents object or `undefined` if @param from is an invalid DSN source\n */\nexport function makeDsn(from: DsnLike): DsnComponents | undefined {\n  const components = typeof from === 'string' ? dsnFromString(from) : dsnFromComponents(from);\n  if (!components || !validateDsn(components)) {\n    return undefined;\n  }\n  return components;\n}\n","import { getSentryCarrier } from '../carrier';\nimport type {\n  Attachment,\n  AttachmentItem,\n  BaseEnvelopeHeaders,\n  BaseEnvelopeItemHeaders,\n  DataCategory,\n  DsnComponents,\n  Envelope,\n  EnvelopeItemType,\n  Event,\n  EventEnvelopeHeaders,\n  SdkInfo,\n  SdkMetadata,\n  SpanItem,\n  SpanJSON,\n} from '../types-hoist';\n\nimport { dsnToString } from './dsn';\nimport { normalize } from './normalize';\nimport { dropUndefinedKeys } from './object';\nimport { GLOBAL_OBJ } from './worldwide';\n\n/**\n * Creates an envelope.\n * Make sure to always explicitly provide the generic to this function\n * so that the envelope types resolve correctly.\n */\nexport function createEnvelope<E extends Envelope>(headers: E[0], items: E[1] = []): E {\n  return [headers, items] as E;\n}\n\n/**\n * Add an item to an envelope.\n * Make sure to always explicitly provide the generic to this function\n * so that the envelope types resolve correctly.\n */\nexport function addItemToEnvelope<E extends Envelope>(envelope: E, newItem: E[1][number]): E {\n  const [headers, items] = envelope;\n  return [headers, [...items, newItem]] as unknown as E;\n}\n\n/**\n * Convenience function to loop through the items and item types of an envelope.\n * (This function was mostly created because working with envelope types is painful at the moment)\n *\n * If the callback returns true, the rest of the items will be skipped.\n */\nexport function forEachEnvelopeItem<E extends Envelope>(\n  envelope: Envelope,\n  callback: (envelopeItem: E[1][number], envelopeItemType: E[1][number][0]['type']) => boolean | void,\n): boolean {\n  const envelopeItems = envelope[1];\n\n  for (const envelopeItem of envelopeItems) {\n    const envelopeItemType = envelopeItem[0].type;\n    const result = callback(envelopeItem, envelopeItemType);\n\n    if (result) {\n      return true;\n    }\n  }\n\n  return false;\n}\n\n/**\n * Returns true if the envelope contains any of the given envelope item types\n */\nexport function envelopeContainsItemType(envelope: Envelope, types: EnvelopeItemType[]): boolean {\n  return forEachEnvelopeItem(envelope, (_, type) => types.includes(type));\n}\n\n/**\n * Encode a string to UTF8 array.\n */\nfunction encodeUTF8(input: string): Uint8Array {\n  const carrier = getSentryCarrier(GLOBAL_OBJ);\n  return carrier.encodePolyfill ? carrier.encodePolyfill(input) : new TextEncoder().encode(input);\n}\n\n/**\n * Decode a UTF8 array to string.\n */\nfunction decodeUTF8(input: Uint8Array): string {\n  const carrier = getSentryCarrier(GLOBAL_OBJ);\n  return carrier.decodePolyfill ? carrier.decodePolyfill(input) : new TextDecoder().decode(input);\n}\n\n/**\n * Serializes an envelope.\n */\nexport function serializeEnvelope(envelope: Envelope): string | Uint8Array {\n  const [envHeaders, items] = envelope;\n\n  // Initially we construct our envelope as a string and only convert to binary chunks if we encounter binary data\n  let parts: string | Uint8Array[] = JSON.stringify(envHeaders);\n\n  function append(next: string | Uint8Array): void {\n    if (typeof parts === 'string') {\n      parts = typeof next === 'string' ? parts + next : [encodeUTF8(parts), next];\n    } else {\n      parts.push(typeof next === 'string' ? encodeUTF8(next) : next);\n    }\n  }\n\n  for (const item of items) {\n    const [itemHeaders, payload] = item;\n\n    append(`\\n${JSON.stringify(itemHeaders)}\\n`);\n\n    if (typeof payload === 'string' || payload instanceof Uint8Array) {\n      append(payload);\n    } else {\n      let stringifiedPayload: string;\n      try {\n        stringifiedPayload = JSON.stringify(payload);\n      } catch (e) {\n        // In case, despite all our efforts to keep `payload` circular-dependency-free, `JSON.stringify()` still\n        // fails, we try again after normalizing it again with infinite normalization depth. This of course has a\n        // performance impact but in this case a performance hit is better than throwing.\n        stringifiedPayload = JSON.stringify(normalize(payload));\n      }\n      append(stringifiedPayload);\n    }\n  }\n\n  return typeof parts === 'string' ? parts : concatBuffers(parts);\n}\n\nfunction concatBuffers(buffers: Uint8Array[]): Uint8Array {\n  const totalLength = buffers.reduce((acc, buf) => acc + buf.length, 0);\n\n  const merged = new Uint8Array(totalLength);\n  let offset = 0;\n  for (const buffer of buffers) {\n    merged.set(buffer, offset);\n    offset += buffer.length;\n  }\n\n  return merged;\n}\n\n/**\n * Parses an envelope\n */\nexport function parseEnvelope(env: string | Uint8Array): Envelope {\n  let buffer = typeof env === 'string' ? encodeUTF8(env) : env;\n\n  function readBinary(length: number): Uint8Array {\n    const bin = buffer.subarray(0, length);\n    // Replace the buffer with the remaining data excluding trailing newline\n    buffer = buffer.subarray(length + 1);\n    return bin;\n  }\n\n  function readJson<T>(): T {\n    let i = buffer.indexOf(0xa);\n    // If we couldn't find a newline, we must have found the end of the buffer\n    if (i < 0) {\n      i = buffer.length;\n    }\n\n    return JSON.parse(decodeUTF8(readBinary(i))) as T;\n  }\n\n  const envelopeHeader = readJson<BaseEnvelopeHeaders>();\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const items: [any, any][] = [];\n\n  while (buffer.length) {\n    const itemHeader = readJson<BaseEnvelopeItemHeaders>();\n    const binaryLength = typeof itemHeader.length === 'number' ? itemHeader.length : undefined;\n\n    items.push([itemHeader, binaryLength ? readBinary(binaryLength) : readJson()]);\n  }\n\n  return [envelopeHeader, items];\n}\n\n/**\n * Creates envelope item for a single span\n */\nexport function createSpanEnvelopeItem(spanJson: Partial<SpanJSON>): SpanItem {\n  const spanHeaders: SpanItem[0] = {\n    type: 'span',\n  };\n\n  return [spanHeaders, spanJson];\n}\n\n/**\n * Creates attachment envelope items\n */\nexport function createAttachmentEnvelopeItem(attachment: Attachment): AttachmentItem {\n  const buffer = typeof attachment.data === 'string' ? encodeUTF8(attachment.data) : attachment.data;\n\n  return [\n    dropUndefinedKeys({\n      type: 'attachment',\n      length: buffer.length,\n      filename: attachment.filename,\n      content_type: attachment.contentType,\n      attachment_type: attachment.attachmentType,\n    }),\n    buffer,\n  ];\n}\n\nconst ITEM_TYPE_TO_DATA_CATEGORY_MAP: Record<EnvelopeItemType, DataCategory> = {\n  session: 'session',\n  sessions: 'session',\n  attachment: 'attachment',\n  transaction: 'transaction',\n  event: 'error',\n  client_report: 'internal',\n  user_report: 'default',\n  profile: 'profile',\n  profile_chunk: 'profile',\n  replay_event: 'replay',\n  replay_recording: 'replay',\n  check_in: 'monitor',\n  feedback: 'feedback',\n  span: 'span',\n  raw_security: 'security',\n};\n\n/**\n * Maps the type of an envelope item to a data category.\n */\nexport function envelopeItemTypeToDataCategory(type: EnvelopeItemType): DataCategory {\n  return ITEM_TYPE_TO_DATA_CATEGORY_MAP[type];\n}\n\n/** Extracts the minimal SDK info from the metadata or an events */\nexport function getSdkMetadataForEnvelopeHeader(metadataOrEvent?: SdkMetadata | Event): SdkInfo | undefined {\n  if (!metadataOrEvent?.sdk) {\n    return;\n  }\n  const { name, version } = metadataOrEvent.sdk;\n  return { name, version };\n}\n\n/**\n * Creates event envelope headers, based on event, sdk info and tunnel\n * Note: This function was extracted from the core package to make it available in Replay\n */\nexport function createEventEnvelopeHeaders(\n  event: Event,\n  sdkInfo: SdkInfo | undefined,\n  tunnel: string | undefined,\n  dsn?: DsnComponents,\n): EventEnvelopeHeaders {\n  const dynamicSamplingContext = event.sdkProcessingMetadata?.dynamicSamplingContext;\n  return {\n    event_id: event.event_id as string,\n    sent_at: new Date().toISOString(),\n    ...(sdkInfo && { sdk: sdkInfo }),\n    ...(!!tunnel && dsn && { dsn: dsnToString(dsn) }),\n    ...(dynamicSamplingContext && {\n      trace: dropUndefinedKeys({ ...dynamicSamplingContext }),\n    }),\n  };\n}\n","import type { Client } from './client';\nimport { getDynamicSamplingContextFromSpan } from './tracing/dynamicSamplingContext';\nimport type { SentrySpan } from './tracing/sentrySpan';\nimport type {\n  DsnComponents,\n  DynamicSamplingContext,\n  Event,\n  EventEnvelope,\n  EventItem,\n  LegacyCSPReport,\n  RawSecurityEnvelope,\n  RawSecurityItem,\n  SdkInfo,\n  SdkMetadata,\n  Session,\n  SessionAggregates,\n  SessionEnvelope,\n  SessionItem,\n  SpanEnvelope,\n  SpanItem,\n} from './types-hoist';\nimport { dsnToString } from './utils-hoist/dsn';\nimport {\n  createEnvelope,\n  createEventEnvelopeHeaders,\n  createSpanEnvelopeItem,\n  getSdkMetadataForEnvelopeHeader,\n} from './utils-hoist/envelope';\nimport { uuid4 } from './utils-hoist/misc';\nimport { showSpanDropWarning, spanToJSON } from './utils/spanUtils';\n\n/**\n * Apply SdkInfo (name, version, packages, integrations) to the corresponding event key.\n * Merge with existing data if any.\n **/\nfunction enhanceEventWithSdkInfo(event: Event, sdkInfo?: SdkInfo): Event {\n  if (!sdkInfo) {\n    return event;\n  }\n  event.sdk = event.sdk || {};\n  event.sdk.name = event.sdk.name || sdkInfo.name;\n  event.sdk.version = event.sdk.version || sdkInfo.version;\n  event.sdk.integrations = [...(event.sdk.integrations || []), ...(sdkInfo.integrations || [])];\n  event.sdk.packages = [...(event.sdk.packages || []), ...(sdkInfo.packages || [])];\n  return event;\n}\n\n/** Creates an envelope from a Session */\nexport function createSessionEnvelope(\n  session: Session | SessionAggregates,\n  dsn?: DsnComponents,\n  metadata?: SdkMetadata,\n  tunnel?: string,\n): SessionEnvelope {\n  const sdkInfo = getSdkMetadataForEnvelopeHeader(metadata);\n  const envelopeHeaders = {\n    sent_at: new Date().toISOString(),\n    ...(sdkInfo && { sdk: sdkInfo }),\n    ...(!!tunnel && dsn && { dsn: dsnToString(dsn) }),\n  };\n\n  const envelopeItem: SessionItem =\n    'aggregates' in session ? [{ type: 'sessions' }, session] : [{ type: 'session' }, session.toJSON()];\n\n  return createEnvelope<SessionEnvelope>(envelopeHeaders, [envelopeItem]);\n}\n\n/**\n * Create an Envelope from an event.\n */\nexport function createEventEnvelope(\n  event: Event,\n  dsn?: DsnComponents,\n  metadata?: SdkMetadata,\n  tunnel?: string,\n): EventEnvelope {\n  const sdkInfo = getSdkMetadataForEnvelopeHeader(metadata);\n\n  /*\n    Note: Due to TS, event.type may be `replay_event`, theoretically.\n    In practice, we never call `createEventEnvelope` with `replay_event` type,\n    and we'd have to adjust a looot of types to make this work properly.\n    We want to avoid casting this around, as that could lead to bugs (e.g. when we add another type)\n    So the safe choice is to really guard against the replay_event type here.\n  */\n  const eventType = event.type && event.type !== 'replay_event' ? event.type : 'event';\n\n  enhanceEventWithSdkInfo(event, metadata?.sdk);\n\n  const envelopeHeaders = createEventEnvelopeHeaders(event, sdkInfo, tunnel, dsn);\n\n  // Prevent this data (which, if it exists, was used in earlier steps in the processing pipeline) from being sent to\n  // sentry. (Note: Our use of this property comes and goes with whatever we might be debugging, whatever hacks we may\n  // have temporarily added, etc. Even if we don't happen to be using it at some point in the future, let's not get rid\n  // of this `delete`, lest we miss putting it back in the next time the property is in use.)\n  delete event.sdkProcessingMetadata;\n\n  const eventItem: EventItem = [{ type: eventType }, event];\n  return createEnvelope<EventEnvelope>(envelopeHeaders, [eventItem]);\n}\n\n/**\n * Create envelope from Span item.\n *\n * Takes an optional client and runs spans through `beforeSendSpan` if available.\n */\nexport function createSpanEnvelope(spans: [SentrySpan, ...SentrySpan[]], client?: Client): SpanEnvelope {\n  function dscHasRequiredProps(dsc: Partial<DynamicSamplingContext>): dsc is DynamicSamplingContext {\n    return !!dsc.trace_id && !!dsc.public_key;\n  }\n\n  // For the moment we'll obtain the DSC from the first span in the array\n  // This might need to be changed if we permit sending multiple spans from\n  // different segments in one envelope\n  const dsc = getDynamicSamplingContextFromSpan(spans[0]);\n\n  const dsn = client?.getDsn();\n  const tunnel = client?.getOptions().tunnel;\n\n  const headers: SpanEnvelope[0] = {\n    sent_at: new Date().toISOString(),\n    ...(dscHasRequiredProps(dsc) && { trace: dsc }),\n    ...(!!tunnel && dsn && { dsn: dsnToString(dsn) }),\n  };\n\n  const beforeSendSpan = client?.getOptions().beforeSendSpan;\n  const convertToSpanJSON = beforeSendSpan\n    ? (span: SentrySpan) => {\n        const spanJson = spanToJSON(span);\n        const processedSpan = beforeSendSpan(spanJson);\n\n        if (!processedSpan) {\n          showSpanDropWarning();\n          return spanJson;\n        }\n\n        return processedSpan;\n      }\n    : spanToJSON;\n\n  const items: SpanItem[] = [];\n  for (const span of spans) {\n    const spanJson = convertToSpanJSON(span);\n    if (spanJson) {\n      items.push(createSpanEnvelopeItem(spanJson));\n    }\n  }\n\n  return createEnvelope<SpanEnvelope>(headers, items);\n}\n\n/**\n * Create an Envelope from a CSP report.\n */\nexport function createRawSecurityEnvelope(\n  report: LegacyCSPReport,\n  dsn: DsnComponents,\n  tunnel?: string,\n  release?: string,\n  environment?: string,\n): RawSecurityEnvelope {\n  const envelopeHeaders = {\n    event_id: uuid4(),\n    ...(!!tunnel && dsn && { dsn: dsnToString(dsn) }),\n  };\n\n  const eventItem: RawSecurityItem = [\n    { type: 'raw_security', sentry_release: release, sentry_environment: environment },\n    report,\n  ];\n\n  return createEnvelope<RawSecurityEnvelope>(envelopeHeaders, [eventItem]);\n}\n","import type { ConsoleLevel } from '../types-hoist';\n\n/** An error emitted by Sentry SDKs and related utilities. */\nexport class SentryError extends Error {\n  public logLevel: ConsoleLevel;\n\n  public constructor(\n    public message: string,\n    logLevel: ConsoleLevel = 'warn',\n  ) {\n    super(message);\n\n    this.logLevel = logLevel;\n  }\n}\n","/* eslint-disable max-lines */\nimport type {\n  Breadcrumb,\n  BreadcrumbHint,\n  CheckIn,\n  ClientOptions,\n  DataCategory,\n  DsnComponents,\n  DynamicSamplingContext,\n  Envelope,\n  ErrorEvent,\n  Event,\n  EventDropReason,\n  EventHint,\n  EventProcessor,\n  FeedbackEvent,\n  FetchBreadcrumbHint,\n  Integration,\n  MonitorConfig,\n  Outcome,\n  ParameterizedString,\n  SdkMetadata,\n  Session,\n  SessionAggregates,\n  SeverityLevel,\n  Span,\n  SpanAttributes,\n  SpanContextData,\n  SpanJSON,\n  StartSpanOptions,\n  TransactionEvent,\n  Transport,\n  TransportMakeRequestResponse,\n  XhrBreadcrumbHint,\n} from './types-hoist';\n\nimport { getEnvelopeEndpointWithUrlEncodedAuth } from './api';\nimport { DEFAULT_ENVIRONMENT } from './constants';\nimport { getCurrentScope, getIsolationScope, getTraceContextFromScope } from './currentScopes';\nimport { DEBUG_BUILD } from './debug-build';\nimport { createEventEnvelope, createSessionEnvelope } from './envelope';\nimport type { IntegrationIndex } from './integration';\nimport { afterSetupIntegrations } from './integration';\nimport { setupIntegration, setupIntegrations } from './integration';\nimport type { Scope } from './scope';\nimport { updateSession } from './session';\nimport { getDynamicSamplingContextFromScope } from './tracing/dynamicSamplingContext';\nimport { createClientReportEnvelope } from './utils-hoist/clientreport';\nimport { dsnToString, makeDsn } from './utils-hoist/dsn';\nimport { addItemToEnvelope, createAttachmentEnvelopeItem } from './utils-hoist/envelope';\nimport { SentryError } from './utils-hoist/error';\nimport { isParameterizedString, isPlainObject, isPrimitive, isThenable } from './utils-hoist/is';\nimport { logger } from './utils-hoist/logger';\nimport { checkOrSetAlreadyCaught, uuid4 } from './utils-hoist/misc';\nimport { SyncPromise, rejectedSyncPromise, resolvedSyncPromise } from './utils-hoist/syncpromise';\nimport { getPossibleEventMessages } from './utils/eventUtils';\nimport { merge } from './utils/merge';\nimport { parseSampleRate } from './utils/parseSampleRate';\nimport { prepareEvent } from './utils/prepareEvent';\nimport { showSpanDropWarning } from './utils/spanUtils';\nimport { convertSpanJsonToTransactionEvent, convertTransactionEventToSpanJson } from './utils/transactionEvent';\n\nconst ALREADY_SEEN_ERROR = \"Not capturing exception because it's already been captured.\";\nconst MISSING_RELEASE_FOR_SESSION_ERROR = 'Discarded session because of missing or non-string release';\n\n/**\n * Base implementation for all JavaScript SDK clients.\n *\n * Call the constructor with the corresponding options\n * specific to the client subclass. To access these options later, use\n * {@link Client.getOptions}.\n *\n * If a Dsn is specified in the options, it will be parsed and stored. Use\n * {@link Client.getDsn} to retrieve the Dsn at any moment. In case the Dsn is\n * invalid, the constructor will throw a {@link SentryException}. Note that\n * without a valid Dsn, the SDK will not send any events to Sentry.\n *\n * Before sending an event, it is passed through\n * {@link Client._prepareEvent} to add SDK information and scope data\n * (breadcrumbs and context). To add more custom information, override this\n * method and extend the resulting prepared event.\n *\n * To issue automatically created events (e.g. via instrumentation), use\n * {@link Client.captureEvent}. It will prepare the event and pass it through\n * the callback lifecycle. To issue auto-breadcrumbs, use\n * {@link Client.addBreadcrumb}.\n *\n * @example\n * class NodeClient extends Client<NodeOptions> {\n *   public constructor(options: NodeOptions) {\n *     super(options);\n *   }\n *\n *   // ...\n * }\n */\nexport abstract class Client<O extends ClientOptions = ClientOptions> {\n  /** Options passed to the SDK. */\n  protected readonly _options: O;\n\n  /** The client Dsn, if specified in options. Without this Dsn, the SDK will be disabled. */\n  protected readonly _dsn?: DsnComponents;\n\n  protected readonly _transport?: Transport;\n\n  /** Array of set up integrations. */\n  protected _integrations: IntegrationIndex;\n\n  /** Number of calls being processed */\n  protected _numProcessing: number;\n\n  protected _eventProcessors: EventProcessor[];\n\n  /** Holds flushable  */\n  private _outcomes: { [key: string]: number };\n\n  // eslint-disable-next-line @typescript-eslint/ban-types\n  private _hooks: Record<string, Function[]>;\n\n  /**\n   * Initializes this client instance.\n   *\n   * @param options Options for the client.\n   */\n  protected constructor(options: O) {\n    this._options = options;\n    this._integrations = {};\n    this._numProcessing = 0;\n    this._outcomes = {};\n    this._hooks = {};\n    this._eventProcessors = [];\n\n    if (options.dsn) {\n      this._dsn = makeDsn(options.dsn);\n    } else {\n      DEBUG_BUILD && logger.warn('No DSN provided, client will not send events.');\n    }\n\n    if (this._dsn) {\n      const url = getEnvelopeEndpointWithUrlEncodedAuth(\n        this._dsn,\n        options.tunnel,\n        options._metadata ? options._metadata.sdk : undefined,\n      );\n      this._transport = options.transport({\n        tunnel: this._options.tunnel,\n        recordDroppedEvent: this.recordDroppedEvent.bind(this),\n        ...options.transportOptions,\n        url,\n      });\n    }\n  }\n\n  /**\n   * Captures an exception event and sends it to Sentry.\n   *\n   * Unlike `captureException` exported from every SDK, this method requires that you pass it the current scope.\n   */\n  public captureException(exception: unknown, hint?: EventHint, scope?: Scope): string {\n    const eventId = uuid4();\n\n    // ensure we haven't captured this very object before\n    if (checkOrSetAlreadyCaught(exception)) {\n      DEBUG_BUILD && logger.log(ALREADY_SEEN_ERROR);\n      return eventId;\n    }\n\n    const hintWithEventId = {\n      event_id: eventId,\n      ...hint,\n    };\n\n    this._process(\n      this.eventFromException(exception, hintWithEventId).then(event =>\n        this._captureEvent(event, hintWithEventId, scope),\n      ),\n    );\n\n    return hintWithEventId.event_id;\n  }\n\n  /**\n   * Captures a message event and sends it to Sentry.\n   *\n   * Unlike `captureMessage` exported from every SDK, this method requires that you pass it the current scope.\n   */\n  public captureMessage(\n    message: ParameterizedString,\n    level?: SeverityLevel,\n    hint?: EventHint,\n    currentScope?: Scope,\n  ): string {\n    const hintWithEventId = {\n      event_id: uuid4(),\n      ...hint,\n    };\n\n    const eventMessage = isParameterizedString(message) ? message : String(message);\n\n    const promisedEvent = isPrimitive(message)\n      ? this.eventFromMessage(eventMessage, level, hintWithEventId)\n      : this.eventFromException(message, hintWithEventId);\n\n    this._process(promisedEvent.then(event => this._captureEvent(event, hintWithEventId, currentScope)));\n\n    return hintWithEventId.event_id;\n  }\n\n  /**\n   * Captures a manually created event and sends it to Sentry.\n   *\n   * Unlike `captureEvent` exported from every SDK, this method requires that you pass it the current scope.\n   */\n  public captureEvent(event: Event, hint?: EventHint, currentScope?: Scope): string {\n    const eventId = uuid4();\n\n    // ensure we haven't captured this very object before\n    if (hint?.originalException && checkOrSetAlreadyCaught(hint.originalException)) {\n      DEBUG_BUILD && logger.log(ALREADY_SEEN_ERROR);\n      return eventId;\n    }\n\n    const hintWithEventId = {\n      event_id: eventId,\n      ...hint,\n    };\n\n    const sdkProcessingMetadata = event.sdkProcessingMetadata || {};\n    const capturedSpanScope: Scope | undefined = sdkProcessingMetadata.capturedSpanScope;\n    const capturedSpanIsolationScope: Scope | undefined = sdkProcessingMetadata.capturedSpanIsolationScope;\n\n    this._process(\n      this._captureEvent(event, hintWithEventId, capturedSpanScope || currentScope, capturedSpanIsolationScope),\n    );\n\n    return hintWithEventId.event_id;\n  }\n\n  /**\n   * Captures a session.\n   */\n  public captureSession(session: Session): void {\n    this.sendSession(session);\n    // After sending, we set init false to indicate it's not the first occurrence\n    updateSession(session, { init: false });\n  }\n\n  /**\n   * Create a cron monitor check in and send it to Sentry. This method is not available on all clients.\n   *\n   * @param checkIn An object that describes a check in.\n   * @param upsertMonitorConfig An optional object that describes a monitor config. Use this if you want\n   * to create a monitor automatically when sending a check in.\n   * @param scope An optional scope containing event metadata.\n   * @returns A string representing the id of the check in.\n   */\n  public captureCheckIn?(checkIn: CheckIn, monitorConfig?: MonitorConfig, scope?: Scope): string;\n\n  /**\n   * Get the current Dsn.\n   */\n  public getDsn(): DsnComponents | undefined {\n    return this._dsn;\n  }\n\n  /**\n   * Get the current options.\n   */\n  public getOptions(): O {\n    return this._options;\n  }\n\n  /**\n   * Get the SDK metadata.\n   * @see SdkMetadata\n   */\n  public getSdkMetadata(): SdkMetadata | undefined {\n    return this._options._metadata;\n  }\n\n  /**\n   * Returns the transport that is used by the client.\n   * Please note that the transport gets lazy initialized so it will only be there once the first event has been sent.\n   */\n  public getTransport(): Transport | undefined {\n    return this._transport;\n  }\n\n  /**\n   * Wait for all events to be sent or the timeout to expire, whichever comes first.\n   *\n   * @param timeout Maximum time in ms the client should wait for events to be flushed. Omitting this parameter will\n   *   cause the client to wait until all events are sent before resolving the promise.\n   * @returns A promise that will resolve with `true` if all events are sent before the timeout, or `false` if there are\n   * still events in the queue when the timeout is reached.\n   */\n  public flush(timeout?: number): PromiseLike<boolean> {\n    const transport = this._transport;\n    if (transport) {\n      this.emit('flush');\n      return this._isClientDoneProcessing(timeout).then(clientFinished => {\n        return transport.flush(timeout).then(transportFlushed => clientFinished && transportFlushed);\n      });\n    } else {\n      return resolvedSyncPromise(true);\n    }\n  }\n\n  /**\n   * Flush the event queue and set the client to `enabled = false`. See {@link Client.flush}.\n   *\n   * @param {number} timeout Maximum time in ms the client should wait before shutting down. Omitting this parameter will cause\n   *   the client to wait until all events are sent before disabling itself.\n   * @returns {Promise<boolean>} A promise which resolves to `true` if the flush completes successfully before the timeout, or `false` if\n   * it doesn't.\n   */\n  public close(timeout?: number): PromiseLike<boolean> {\n    return this.flush(timeout).then(result => {\n      this.getOptions().enabled = false;\n      this.emit('close');\n      return result;\n    });\n  }\n\n  /**\n   * Get all installed event processors.\n   */\n  public getEventProcessors(): EventProcessor[] {\n    return this._eventProcessors;\n  }\n\n  /**\n   * Adds an event processor that applies to any event processed by this client.\n   */\n  public addEventProcessor(eventProcessor: EventProcessor): void {\n    this._eventProcessors.push(eventProcessor);\n  }\n\n  /**\n   * Initialize this client.\n   * Call this after the client was set on a scope.\n   */\n  public init(): void {\n    if (\n      this._isEnabled() ||\n      // Force integrations to be setup even if no DSN was set when we have\n      // Spotlight enabled. This is particularly important for browser as we\n      // don't support the `spotlight` option there and rely on the users\n      // adding the `spotlightBrowserIntegration()` to their integrations which\n      // wouldn't get initialized with the check below when there's no DSN set.\n      this._options.integrations.some(({ name }) => name.startsWith('Spotlight'))\n    ) {\n      this._setupIntegrations();\n    }\n  }\n\n  /**\n   * Gets an installed integration by its name.\n   *\n   * @returns {Integration|undefined} The installed integration or `undefined` if no integration with that `name` was installed.\n   */\n  public getIntegrationByName<T extends Integration = Integration>(integrationName: string): T | undefined {\n    return this._integrations[integrationName] as T | undefined;\n  }\n\n  /**\n   * Add an integration to the client.\n   * This can be used to e.g. lazy load integrations.\n   * In most cases, this should not be necessary,\n   * and you're better off just passing the integrations via `integrations: []` at initialization time.\n   * However, if you find the need to conditionally load & add an integration, you can use `addIntegration` to do so.\n   */\n  public addIntegration(integration: Integration): void {\n    const isAlreadyInstalled = this._integrations[integration.name];\n\n    // This hook takes care of only installing if not already installed\n    setupIntegration(this, integration, this._integrations);\n    // Here we need to check manually to make sure to not run this multiple times\n    if (!isAlreadyInstalled) {\n      afterSetupIntegrations(this, [integration]);\n    }\n  }\n\n  /**\n   * Send a fully prepared event to Sentry.\n   */\n  public sendEvent(event: Event, hint: EventHint = {}): void {\n    this.emit('beforeSendEvent', event, hint);\n\n    let env = createEventEnvelope(event, this._dsn, this._options._metadata, this._options.tunnel);\n\n    for (const attachment of hint.attachments || []) {\n      env = addItemToEnvelope(env, createAttachmentEnvelopeItem(attachment));\n    }\n\n    const promise = this.sendEnvelope(env);\n    if (promise) {\n      promise.then(sendResponse => this.emit('afterSendEvent', event, sendResponse), null);\n    }\n  }\n\n  /**\n   * Send a session or session aggregrates to Sentry.\n   */\n  public sendSession(session: Session | SessionAggregates): void {\n    // Backfill release and environment on session\n    const { release: clientReleaseOption, environment: clientEnvironmentOption = DEFAULT_ENVIRONMENT } = this._options;\n    if ('aggregates' in session) {\n      const sessionAttrs = session.attrs || {};\n      if (!sessionAttrs.release && !clientReleaseOption) {\n        DEBUG_BUILD && logger.warn(MISSING_RELEASE_FOR_SESSION_ERROR);\n        return;\n      }\n      sessionAttrs.release = sessionAttrs.release || clientReleaseOption;\n      sessionAttrs.environment = sessionAttrs.environment || clientEnvironmentOption;\n      session.attrs = sessionAttrs;\n    } else {\n      if (!session.release && !clientReleaseOption) {\n        DEBUG_BUILD && logger.warn(MISSING_RELEASE_FOR_SESSION_ERROR);\n        return;\n      }\n      session.release = session.release || clientReleaseOption;\n      session.environment = session.environment || clientEnvironmentOption;\n    }\n\n    this.emit('beforeSendSession', session);\n\n    const env = createSessionEnvelope(session, this._dsn, this._options._metadata, this._options.tunnel);\n\n    // sendEnvelope should not throw\n    // eslint-disable-next-line @typescript-eslint/no-floating-promises\n    this.sendEnvelope(env);\n  }\n\n  /**\n   * Record on the client that an event got dropped (ie, an event that will not be sent to Sentry).\n   */\n  public recordDroppedEvent(reason: EventDropReason, category: DataCategory, count: number = 1): void {\n    if (this._options.sendClientReports) {\n      // We want to track each category (error, transaction, session, replay_event) separately\n      // but still keep the distinction between different type of outcomes.\n      // We could use nested maps, but it's much easier to read and type this way.\n      // A correct type for map-based implementation if we want to go that route\n      // would be `Partial<Record<SentryRequestType, Partial<Record<Outcome, number>>>>`\n      // With typescript 4.1 we could even use template literal types\n      const key = `${reason}:${category}`;\n      DEBUG_BUILD && logger.log(`Recording outcome: \"${key}\"${count > 1 ? ` (${count} times)` : ''}`);\n      this._outcomes[key] = (this._outcomes[key] || 0) + count;\n    }\n  }\n\n  /* eslint-disable @typescript-eslint/unified-signatures */\n  /**\n   * Register a callback for whenever a span is started.\n   * Receives the span as argument.\n   * @returns {() => void} A function that, when executed, removes the registered callback.\n   */\n  public on(hook: 'spanStart', callback: (span: Span) => void): () => void;\n\n  /**\n   * Register a callback before span sampling runs. Receives a `samplingDecision` object argument with a `decision`\n   * property that can be used to make a sampling decision that will be enforced, before any span sampling runs.\n   * @returns {() => void} A function that, when executed, removes the registered callback.\n   */\n  public on(\n    hook: 'beforeSampling',\n    callback: (\n      samplingData: {\n        spanAttributes: SpanAttributes;\n        spanName: string;\n        parentSampled?: boolean;\n        parentContext?: SpanContextData;\n      },\n      samplingDecision: { decision: boolean },\n    ) => void,\n  ): void;\n\n  /**\n   * Register a callback for whenever a span is ended.\n   * Receives the span as argument.\n   * @returns {() => void} A function that, when executed, removes the registered callback.\n   */\n  public on(hook: 'spanEnd', callback: (span: Span) => void): () => void;\n\n  /**\n   * Register a callback for when an idle span is allowed to auto-finish.\n   * @returns {() => void} A function that, when executed, removes the registered callback.\n   */\n  public on(hook: 'idleSpanEnableAutoFinish', callback: (span: Span) => void): () => void;\n\n  /**\n   * Register a callback for transaction start and finish.\n   * @returns {() => void} A function that, when executed, removes the registered callback.\n   */\n  public on(hook: 'beforeEnvelope', callback: (envelope: Envelope) => void): () => void;\n\n  /**\n   * Register a callback that runs when stack frame metadata should be applied to an event.\n   * @returns {() => void} A function that, when executed, removes the registered callback.\n   */\n  public on(hook: 'applyFrameMetadata', callback: (event: Event) => void): () => void;\n\n  /**\n   * Register a callback for before sending an event.\n   * This is called right before an event is sent and should not be used to mutate the event.\n   * Receives an Event & EventHint as arguments.\n   * @returns {() => void} A function that, when executed, removes the registered callback.\n   */\n  public on(hook: 'beforeSendEvent', callback: (event: Event, hint?: EventHint | undefined) => void): () => void;\n\n  /**\n   * Register a callback for before sending a session or session aggregrates..\n   * Receives the session/aggregate as second argument.\n   * @returns {() => void} A function that, when executed, removes the registered callback.\n   */\n  public on(hook: 'beforeSendSession', callback: (session: Session | SessionAggregates) => void): () => void;\n\n  /**\n   * Register a callback for preprocessing an event,\n   * before it is passed to (global) event processors.\n   * Receives an Event & EventHint as arguments.\n   * @returns {() => void} A function that, when executed, removes the registered callback.\n   */\n  public on(hook: 'preprocessEvent', callback: (event: Event, hint?: EventHint | undefined) => void): () => void;\n\n  /**\n   * Register a callback for postprocessing an event,\n   * after it was passed to (global) event processors, before it is being sent.\n   * Receives an Event & EventHint as arguments.\n   * @returns {() => void} A function that, when executed, removes the registered callback.\n   */\n  public on(hook: 'postprocessEvent', callback: (event: Event, hint?: EventHint | undefined) => void): () => void;\n\n  /**\n   * Register a callback for when an event has been sent.\n   * @returns {() => void} A function that, when executed, removes the registered callback.\n   */\n  public on(\n    hook: 'afterSendEvent',\n    callback: (event: Event, sendResponse: TransportMakeRequestResponse) => void,\n  ): () => void;\n\n  /**\n   * Register a callback before a breadcrumb is added.\n   * @returns {() => void} A function that, when executed, removes the registered callback.\n   */\n  public on(hook: 'beforeAddBreadcrumb', callback: (breadcrumb: Breadcrumb, hint?: BreadcrumbHint) => void): () => void;\n\n  /**\n   * Register a callback when a DSC (Dynamic Sampling Context) is created.\n   * @returns {() => void} A function that, when executed, removes the registered callback.\n   */\n  public on(hook: 'createDsc', callback: (dsc: DynamicSamplingContext, rootSpan?: Span) => void): () => void;\n\n  /**\n   * Register a callback when a Feedback event has been prepared.\n   * This should be used to mutate the event. The options argument can hint\n   * about what kind of mutation it expects.\n   * @returns {() => void} A function that, when executed, removes the registered callback.\n   */\n  public on(\n    hook: 'beforeSendFeedback',\n    callback: (feedback: FeedbackEvent, options?: { includeReplay?: boolean }) => void,\n  ): () => void;\n\n  /**\n   * Register a callback when the feedback widget is opened in a user's browser\n   */\n  public on(hook: 'openFeedbackWidget', callback: () => void): () => void;\n\n  /**\n   * A hook for the browser tracing integrations to trigger a span start for a page load.\n   * @returns {() => void} A function that, when executed, removes the registered callback.\n   */\n  public on(\n    hook: 'startPageLoadSpan',\n    callback: (\n      options: StartSpanOptions,\n      traceOptions?: { sentryTrace?: string | undefined; baggage?: string | undefined },\n    ) => void,\n  ): () => void;\n\n  /**\n   * A hook for browser tracing integrations to trigger a span for a navigation.\n   * @returns {() => void} A function that, when executed, removes the registered callback.\n   */\n  public on(hook: 'startNavigationSpan', callback: (options: StartSpanOptions) => void): () => void;\n\n  /**\n   * A hook for GraphQL client integration to enhance a span with request data.\n   * @returns A function that, when executed, removes the registered callback.\n   */\n  public on(\n    hook: 'beforeOutgoingRequestSpan',\n    callback: (span: Span, hint: XhrBreadcrumbHint | FetchBreadcrumbHint) => void,\n  ): () => void;\n\n  /**\n   * A hook for GraphQL client integration to enhance a breadcrumb with request data.\n   * @returns A function that, when executed, removes the registered callback.\n   */\n  public on(\n    hook: 'beforeOutgoingRequestBreadcrumb',\n    callback: (breadcrumb: Breadcrumb, hint: XhrBreadcrumbHint | FetchBreadcrumbHint) => void,\n  ): () => void;\n\n  /**\n   * A hook that is called when the client is flushing\n   * @returns {() => void} A function that, when executed, removes the registered callback.\n   */\n  public on(hook: 'flush', callback: () => void): () => void;\n\n  /**\n   * A hook that is called when the client is closing\n   * @returns {() => void} A function that, when executed, removes the registered callback.\n   */\n  public on(hook: 'close', callback: () => void): () => void;\n\n  /**\n   * Register a hook oin this client.\n   */\n  public on(hook: string, callback: unknown): () => void {\n    const hooks = (this._hooks[hook] = this._hooks[hook] || []);\n\n    // @ts-expect-error We assume the types are correct\n    hooks.push(callback);\n\n    // This function returns a callback execution handler that, when invoked,\n    // deregisters a callback. This is crucial for managing instances where callbacks\n    // need to be unregistered to prevent self-referencing in callback closures,\n    // ensuring proper garbage collection.\n    return () => {\n      // @ts-expect-error We assume the types are correct\n      const cbIndex = hooks.indexOf(callback);\n      if (cbIndex > -1) {\n        hooks.splice(cbIndex, 1);\n      }\n    };\n  }\n\n  /** Fire a hook whenever a span starts. */\n  public emit(hook: 'spanStart', span: Span): void;\n\n  /** A hook that is called every time before a span is sampled. */\n  public emit(\n    hook: 'beforeSampling',\n    samplingData: {\n      spanAttributes: SpanAttributes;\n      spanName: string;\n      parentSampled?: boolean;\n      parentContext?: SpanContextData;\n    },\n    samplingDecision: { decision: boolean },\n  ): void;\n\n  /** Fire a hook whenever a span ends. */\n  public emit(hook: 'spanEnd', span: Span): void;\n\n  /**\n   * Fire a hook indicating that an idle span is allowed to auto finish.\n   */\n  public emit(hook: 'idleSpanEnableAutoFinish', span: Span): void;\n\n  /*\n   * Fire a hook event for envelope creation and sending. Expects to be given an envelope as the\n   * second argument.\n   */\n  public emit(hook: 'beforeEnvelope', envelope: Envelope): void;\n\n  /*\n   * Fire a hook indicating that stack frame metadata should be applied to the event passed to the hook.\n   */\n  public emit(hook: 'applyFrameMetadata', event: Event): void;\n\n  /**\n   * Fire a hook event before sending an event.\n   * This is called right before an event is sent and should not be used to mutate the event.\n   * Expects to be given an Event & EventHint as the second/third argument.\n   */\n  public emit(hook: 'beforeSendEvent', event: Event, hint?: EventHint): void;\n\n  /**\n   * Fire a hook event before sending a session/aggregates.\n   * Expects to be given the prepared session/aggregates as second argument.\n   */\n  public emit(hook: 'beforeSendSession', session: Session | SessionAggregates): void;\n\n  /**\n   * Fire a hook event to process events before they are passed to (global) event processors.\n   * Expects to be given an Event & EventHint as the second/third argument.\n   */\n  public emit(hook: 'preprocessEvent', event: Event, hint?: EventHint): void;\n\n  /**\n   * Fire a hook event to process a user on an event before it is sent to Sentry, after all other processors have run.\n   * Expects to be given an Event & EventHint as the second/third argument.\n   */\n  public emit(hook: 'postprocessEvent', event: Event, hint?: EventHint): void;\n\n  /*\n   * Fire a hook event after sending an event. Expects to be given an Event as the\n   * second argument.\n   */\n  public emit(hook: 'afterSendEvent', event: Event, sendResponse: TransportMakeRequestResponse): void;\n\n  /**\n   * Fire a hook for when a breadcrumb is added. Expects the breadcrumb as second argument.\n   */\n  public emit(hook: 'beforeAddBreadcrumb', breadcrumb: Breadcrumb, hint?: BreadcrumbHint): void;\n\n  /**\n   * Fire a hook for when a DSC (Dynamic Sampling Context) is created. Expects the DSC as second argument.\n   */\n  public emit(hook: 'createDsc', dsc: DynamicSamplingContext, rootSpan?: Span): void;\n\n  /**\n   * Fire a hook event for after preparing a feedback event. Events to be given\n   * a feedback event as the second argument, and an optional options object as\n   * third argument.\n   */\n  public emit(hook: 'beforeSendFeedback', feedback: FeedbackEvent, options?: { includeReplay?: boolean }): void;\n\n  /**\n   * Fire a hook event for when the feedback widget is opened in a user's browser\n   */\n  public emit(hook: 'openFeedbackWidget'): void;\n\n  /**\n   * Emit a hook event for browser tracing integrations to trigger a span start for a page load.\n   */\n  public emit(\n    hook: 'startPageLoadSpan',\n    options: StartSpanOptions,\n    traceOptions?: { sentryTrace?: string | undefined; baggage?: string | undefined },\n  ): void;\n\n  /**\n   * Emit a hook event for browser tracing integrations to trigger a span for a navigation.\n   */\n  public emit(hook: 'startNavigationSpan', options: StartSpanOptions): void;\n\n  /**\n   * Emit a hook event for GraphQL client integration to enhance a span with request data.\n   */\n  public emit(hook: 'beforeOutgoingRequestSpan', span: Span, hint: XhrBreadcrumbHint | FetchBreadcrumbHint): void;\n\n  /**\n   * Emit a hook event for GraphQL client integration to enhance a breadcrumb with request data.\n   */\n  public emit(\n    hook: 'beforeOutgoingRequestBreadcrumb',\n    breadcrumb: Breadcrumb,\n    hint: XhrBreadcrumbHint | FetchBreadcrumbHint,\n  ): void;\n\n  /**\n   * Emit a hook event for client flush\n   */\n  public emit(hook: 'flush'): void;\n\n  /**\n   * Emit a hook event for client close\n   */\n  public emit(hook: 'close'): void;\n\n  /**\n   * Emit a hook that was previously registered via `on()`.\n   */\n  public emit(hook: string, ...rest: unknown[]): void {\n    const callbacks = this._hooks[hook];\n    if (callbacks) {\n      callbacks.forEach(callback => callback(...rest));\n    }\n  }\n\n  /**\n   * Send an envelope to Sentry.\n   */\n  public sendEnvelope(envelope: Envelope): PromiseLike<TransportMakeRequestResponse> {\n    this.emit('beforeEnvelope', envelope);\n\n    if (this._isEnabled() && this._transport) {\n      return this._transport.send(envelope).then(null, reason => {\n        DEBUG_BUILD && logger.error('Error while sending envelope:', reason);\n        return reason;\n      });\n    }\n\n    DEBUG_BUILD && logger.error('Transport disabled');\n\n    return resolvedSyncPromise({});\n  }\n\n  /* eslint-enable @typescript-eslint/unified-signatures */\n\n  /** Setup integrations for this client. */\n  protected _setupIntegrations(): void {\n    const { integrations } = this._options;\n    this._integrations = setupIntegrations(this, integrations);\n    afterSetupIntegrations(this, integrations);\n  }\n\n  /** Updates existing session based on the provided event */\n  protected _updateSessionFromEvent(session: Session, event: Event): void {\n    let crashed = event.level === 'fatal';\n    let errored = false;\n    const exceptions = event.exception?.values;\n\n    if (exceptions) {\n      errored = true;\n\n      for (const ex of exceptions) {\n        const mechanism = ex.mechanism;\n        if (mechanism?.handled === false) {\n          crashed = true;\n          break;\n        }\n      }\n    }\n\n    // A session is updated and that session update is sent in only one of the two following scenarios:\n    // 1. Session with non terminal status and 0 errors + an error occurred -> Will set error count to 1 and send update\n    // 2. Session with non terminal status and 1 error + a crash occurred -> Will set status crashed and send update\n    const sessionNonTerminal = session.status === 'ok';\n    const shouldUpdateAndSend = (sessionNonTerminal && session.errors === 0) || (sessionNonTerminal && crashed);\n\n    if (shouldUpdateAndSend) {\n      updateSession(session, {\n        ...(crashed && { status: 'crashed' }),\n        errors: session.errors || Number(errored || crashed),\n      });\n      this.captureSession(session);\n    }\n  }\n\n  /**\n   * Determine if the client is finished processing. Returns a promise because it will wait `timeout` ms before saying\n   * \"no\" (resolving to `false`) in order to give the client a chance to potentially finish first.\n   *\n   * @param timeout The time, in ms, after which to resolve to `false` if the client is still busy. Passing `0` (or not\n   * passing anything) will make the promise wait as long as it takes for processing to finish before resolving to\n   * `true`.\n   * @returns A promise which will resolve to `true` if processing is already done or finishes before the timeout, and\n   * `false` otherwise\n   */\n  protected _isClientDoneProcessing(timeout?: number): PromiseLike<boolean> {\n    return new SyncPromise(resolve => {\n      let ticked: number = 0;\n      const tick: number = 1;\n\n      const interval = setInterval(() => {\n        if (this._numProcessing == 0) {\n          clearInterval(interval);\n          resolve(true);\n        } else {\n          ticked += tick;\n          if (timeout && ticked >= timeout) {\n            clearInterval(interval);\n            resolve(false);\n          }\n        }\n      }, tick);\n    });\n  }\n\n  /** Determines whether this SDK is enabled and a transport is present. */\n  protected _isEnabled(): boolean {\n    return this.getOptions().enabled !== false && this._transport !== undefined;\n  }\n\n  /**\n   * Adds common information to events.\n   *\n   * The information includes release and environment from `options`,\n   * breadcrumbs and context (extra, tags and user) from the scope.\n   *\n   * Information that is already present in the event is never overwritten. For\n   * nested objects, such as the context, keys are merged.\n   *\n   * @param event The original event.\n   * @param hint May contain additional information about the original exception.\n   * @param currentScope A scope containing event metadata.\n   * @returns A new event with more information.\n   */\n  protected _prepareEvent(\n    event: Event,\n    hint: EventHint,\n    currentScope: Scope,\n    isolationScope: Scope,\n  ): PromiseLike<Event | null> {\n    const options = this.getOptions();\n    const integrations = Object.keys(this._integrations);\n    if (!hint.integrations && integrations?.length) {\n      hint.integrations = integrations;\n    }\n\n    this.emit('preprocessEvent', event, hint);\n\n    if (!event.type) {\n      isolationScope.setLastEventId(event.event_id || hint.event_id);\n    }\n\n    return prepareEvent(options, event, hint, currentScope, this, isolationScope).then(evt => {\n      if (evt === null) {\n        return evt;\n      }\n\n      this.emit('postprocessEvent', evt, hint);\n\n      evt.contexts = {\n        trace: getTraceContextFromScope(currentScope),\n        ...evt.contexts,\n      };\n\n      const dynamicSamplingContext = getDynamicSamplingContextFromScope(this, currentScope);\n\n      evt.sdkProcessingMetadata = {\n        dynamicSamplingContext,\n        ...evt.sdkProcessingMetadata,\n      };\n\n      return evt;\n    });\n  }\n\n  /**\n   * Processes the event and logs an error in case of rejection\n   * @param event\n   * @param hint\n   * @param scope\n   */\n  protected _captureEvent(\n    event: Event,\n    hint: EventHint = {},\n    currentScope = getCurrentScope(),\n    isolationScope = getIsolationScope(),\n  ): PromiseLike<string | undefined> {\n    if (DEBUG_BUILD && isErrorEvent(event)) {\n      logger.log(`Captured error event \\`${getPossibleEventMessages(event)[0] || '<unknown>'}\\``);\n    }\n\n    return this._processEvent(event, hint, currentScope, isolationScope).then(\n      finalEvent => {\n        return finalEvent.event_id;\n      },\n      reason => {\n        if (DEBUG_BUILD) {\n          // If something's gone wrong, log the error as a warning. If it's just us having used a `SentryError` for\n          // control flow, log just the message (no stack) as a log-level log.\n          if (reason instanceof SentryError && reason.logLevel === 'log') {\n            logger.log(reason.message);\n          } else {\n            logger.warn(reason);\n          }\n        }\n        return undefined;\n      },\n    );\n  }\n\n  /**\n   * Processes an event (either error or message) and sends it to Sentry.\n   *\n   * This also adds breadcrumbs and context information to the event. However,\n   * platform specific meta data (such as the User's IP address) must be added\n   * by the SDK implementor.\n   *\n   *\n   * @param event The event to send to Sentry.\n   * @param hint May contain additional information about the original exception.\n   * @param currentScope A scope containing event metadata.\n   * @returns A SyncPromise that resolves with the event or rejects in case event was/will not be send.\n   */\n  protected _processEvent(\n    event: Event,\n    hint: EventHint,\n    currentScope: Scope,\n    isolationScope: Scope,\n  ): PromiseLike<Event> {\n    const options = this.getOptions();\n    const { sampleRate } = options;\n\n    const isTransaction = isTransactionEvent(event);\n    const isError = isErrorEvent(event);\n    const eventType = event.type || 'error';\n    const beforeSendLabel = `before send for type \\`${eventType}\\``;\n\n    // 1.0 === 100% events are sent\n    // 0.0 === 0% events are sent\n    // Sampling for transaction happens somewhere else\n    const parsedSampleRate = typeof sampleRate === 'undefined' ? undefined : parseSampleRate(sampleRate);\n    if (isError && typeof parsedSampleRate === 'number' && Math.random() > parsedSampleRate) {\n      this.recordDroppedEvent('sample_rate', 'error');\n      return rejectedSyncPromise(\n        new SentryError(\n          `Discarding event because it's not included in the random sample (sampling rate = ${sampleRate})`,\n          'log',\n        ),\n      );\n    }\n\n    const dataCategory = (eventType === 'replay_event' ? 'replay' : eventType) satisfies DataCategory;\n\n    return this._prepareEvent(event, hint, currentScope, isolationScope)\n      .then(prepared => {\n        if (prepared === null) {\n          this.recordDroppedEvent('event_processor', dataCategory);\n          throw new SentryError('An event processor returned `null`, will not send event.', 'log');\n        }\n\n        const isInternalException = hint.data && (hint.data as { __sentry__: boolean }).__sentry__ === true;\n        if (isInternalException) {\n          return prepared;\n        }\n\n        const result = processBeforeSend(this, options, prepared, hint);\n        return _validateBeforeSendResult(result, beforeSendLabel);\n      })\n      .then(processedEvent => {\n        if (processedEvent === null) {\n          this.recordDroppedEvent('before_send', dataCategory);\n          if (isTransaction) {\n            const spans = event.spans || [];\n            // the transaction itself counts as one span, plus all the child spans that are added\n            const spanCount = 1 + spans.length;\n            this.recordDroppedEvent('before_send', 'span', spanCount);\n          }\n          throw new SentryError(`${beforeSendLabel} returned \\`null\\`, will not send event.`, 'log');\n        }\n\n        const session = currentScope.getSession() || isolationScope.getSession();\n        if (isError && session) {\n          this._updateSessionFromEvent(session, processedEvent);\n        }\n\n        if (isTransaction) {\n          const spanCountBefore = processedEvent.sdkProcessingMetadata?.spanCountBeforeProcessing || 0;\n          const spanCountAfter = processedEvent.spans ? processedEvent.spans.length : 0;\n\n          const droppedSpanCount = spanCountBefore - spanCountAfter;\n          if (droppedSpanCount > 0) {\n            this.recordDroppedEvent('before_send', 'span', droppedSpanCount);\n          }\n        }\n\n        // None of the Sentry built event processor will update transaction name,\n        // so if the transaction name has been changed by an event processor, we know\n        // it has to come from custom event processor added by a user\n        const transactionInfo = processedEvent.transaction_info;\n        if (isTransaction && transactionInfo && processedEvent.transaction !== event.transaction) {\n          const source = 'custom';\n          processedEvent.transaction_info = {\n            ...transactionInfo,\n            source,\n          };\n        }\n\n        this.sendEvent(processedEvent, hint);\n        return processedEvent;\n      })\n      .then(null, reason => {\n        if (reason instanceof SentryError) {\n          throw reason;\n        }\n\n        this.captureException(reason, {\n          data: {\n            __sentry__: true,\n          },\n          originalException: reason,\n        });\n        throw new SentryError(\n          `Event processing pipeline threw an error, original event will not be sent. Details have been sent as a new event.\\nReason: ${reason}`,\n        );\n      });\n  }\n\n  /**\n   * Occupies the client with processing and event\n   */\n  protected _process<T>(promise: PromiseLike<T>): void {\n    this._numProcessing++;\n    void promise.then(\n      value => {\n        this._numProcessing--;\n        return value;\n      },\n      reason => {\n        this._numProcessing--;\n        return reason;\n      },\n    );\n  }\n\n  /**\n   * Clears outcomes on this client and returns them.\n   */\n  protected _clearOutcomes(): Outcome[] {\n    const outcomes = this._outcomes;\n    this._outcomes = {};\n    return Object.entries(outcomes).map(([key, quantity]) => {\n      const [reason, category] = key.split(':') as [EventDropReason, DataCategory];\n      return {\n        reason,\n        category,\n        quantity,\n      };\n    });\n  }\n\n  /**\n   * Sends client reports as an envelope.\n   */\n  protected _flushOutcomes(): void {\n    DEBUG_BUILD && logger.log('Flushing outcomes...');\n\n    const outcomes = this._clearOutcomes();\n\n    if (outcomes.length === 0) {\n      DEBUG_BUILD && logger.log('No outcomes to send');\n      return;\n    }\n\n    // This is really the only place where we want to check for a DSN and only send outcomes then\n    if (!this._dsn) {\n      DEBUG_BUILD && logger.log('No dsn provided, will not send outcomes');\n      return;\n    }\n\n    DEBUG_BUILD && logger.log('Sending outcomes:', outcomes);\n\n    const envelope = createClientReportEnvelope(outcomes, this._options.tunnel && dsnToString(this._dsn));\n\n    // sendEnvelope should not throw\n    // eslint-disable-next-line @typescript-eslint/no-floating-promises\n    this.sendEnvelope(envelope);\n  }\n\n  /**\n   * Creates an {@link Event} from all inputs to `captureException` and non-primitive inputs to `captureMessage`.\n   */\n  public abstract eventFromException(_exception: unknown, _hint?: EventHint): PromiseLike<Event>;\n\n  /**\n   * Creates an {@link Event} from primitive inputs to `captureMessage`.\n   */\n  public abstract eventFromMessage(\n    _message: ParameterizedString,\n    _level?: SeverityLevel,\n    _hint?: EventHint,\n  ): PromiseLike<Event>;\n}\n\n/**\n * @deprecated Use `Client` instead. This alias may be removed in a future major version.\n */\n// TODO(v10): Remove\nexport type BaseClient = Client;\n\n/**\n * @deprecated Use `Client` instead. This alias may be removed in a future major version.\n */\n// TODO(v10): Remove\nexport const BaseClient = Client;\n\n/**\n * Verifies that return value of configured `beforeSend` or `beforeSendTransaction` is of expected type, and returns the value if so.\n */\nfunction _validateBeforeSendResult(\n  beforeSendResult: PromiseLike<Event | null> | Event | null,\n  beforeSendLabel: string,\n): PromiseLike<Event | null> | Event | null {\n  const invalidValueError = `${beforeSendLabel} must return \\`null\\` or a valid event.`;\n  if (isThenable(beforeSendResult)) {\n    return beforeSendResult.then(\n      event => {\n        if (!isPlainObject(event) && event !== null) {\n          throw new SentryError(invalidValueError);\n        }\n        return event;\n      },\n      e => {\n        throw new SentryError(`${beforeSendLabel} rejected with ${e}`);\n      },\n    );\n  } else if (!isPlainObject(beforeSendResult) && beforeSendResult !== null) {\n    throw new SentryError(invalidValueError);\n  }\n  return beforeSendResult;\n}\n\n/**\n * Process the matching `beforeSendXXX` callback.\n */\nfunction processBeforeSend(\n  client: Client,\n  options: ClientOptions,\n  event: Event,\n  hint: EventHint,\n): PromiseLike<Event | null> | Event | null {\n  const { beforeSend, beforeSendTransaction, beforeSendSpan } = options;\n  let processedEvent = event;\n\n  if (isErrorEvent(processedEvent) && beforeSend) {\n    return beforeSend(processedEvent, hint);\n  }\n\n  if (isTransactionEvent(processedEvent)) {\n    if (beforeSendSpan) {\n      // process root span\n      const processedRootSpanJson = beforeSendSpan(convertTransactionEventToSpanJson(processedEvent));\n      if (!processedRootSpanJson) {\n        showSpanDropWarning();\n      } else {\n        // update event with processed root span values\n        processedEvent = merge(event, convertSpanJsonToTransactionEvent(processedRootSpanJson));\n      }\n\n      // process child spans\n      if (processedEvent.spans) {\n        const processedSpans: SpanJSON[] = [];\n        for (const span of processedEvent.spans) {\n          const processedSpan = beforeSendSpan(span);\n          if (!processedSpan) {\n            showSpanDropWarning();\n            processedSpans.push(span);\n          } else {\n            processedSpans.push(processedSpan);\n          }\n        }\n        processedEvent.spans = processedSpans;\n      }\n    }\n\n    if (beforeSendTransaction) {\n      if (processedEvent.spans) {\n        // We store the # of spans before processing in SDK metadata,\n        // so we can compare it afterwards to determine how many spans were dropped\n        const spanCountBefore = processedEvent.spans.length;\n        processedEvent.sdkProcessingMetadata = {\n          ...event.sdkProcessingMetadata,\n          spanCountBeforeProcessing: spanCountBefore,\n        };\n      }\n      return beforeSendTransaction(processedEvent as TransactionEvent, hint);\n    }\n  }\n\n  return processedEvent;\n}\n\nfunction isErrorEvent(event: Event): event is ErrorEvent {\n  return event.type === undefined;\n}\n\nfunction isTransactionEvent(event: Event): event is TransactionEvent {\n  return event.type === 'transaction';\n}\n","/**\n * Parse a sample rate from a given value.\n * This will either return a boolean or number sample rate, if the sample rate is valid (between 0 and 1).\n * If a string is passed, we try to convert it to a number.\n *\n * Any invalid sample rate will return `undefined`.\n */\nexport function parseSampleRate(sampleRate: unknown): number | undefined {\n  if (typeof sampleRate === 'boolean') {\n    return Number(sampleRate);\n  }\n\n  const rate = typeof sampleRate === 'string' ? parseFloat(sampleRate) : sampleRate;\n  if (typeof rate !== 'number' || isNaN(rate) || rate < 0 || rate > 1) {\n    return undefined;\n  }\n\n  return rate;\n}\n","import { SEMANTIC_ATTRIBUTE_EXCLUSIVE_TIME, SEMANTIC_ATTRIBUTE_PROFILE_ID } from '../semanticAttributes';\nimport type { SpanJSON, TransactionEvent } from '../types-hoist';\nimport { dropUndefinedKeys } from '../utils-hoist';\n\n/**\n * Converts a transaction event to a span JSON object.\n */\nexport function convertTransactionEventToSpanJson(event: TransactionEvent): SpanJSON {\n  const { trace_id, parent_span_id, span_id, status, origin, data, op } = event.contexts?.trace ?? {};\n\n  return dropUndefinedKeys({\n    data: data ?? {},\n    description: event.transaction,\n    op,\n    parent_span_id,\n    span_id: span_id ?? '',\n    start_timestamp: event.start_timestamp ?? 0,\n    status,\n    timestamp: event.timestamp,\n    trace_id: trace_id ?? '',\n    origin,\n    profile_id: data?.[SEMANTIC_ATTRIBUTE_PROFILE_ID] as string | undefined,\n    exclusive_time: data?.[SEMANTIC_ATTRIBUTE_EXCLUSIVE_TIME] as number | undefined,\n    measurements: event.measurements,\n    is_segment: true,\n  });\n}\n\n/**\n * Converts a span JSON object to a transaction event.\n */\nexport function convertSpanJsonToTransactionEvent(span: SpanJSON): TransactionEvent {\n  const event: TransactionEvent = {\n    type: 'transaction',\n    timestamp: span.timestamp,\n    start_timestamp: span.start_timestamp,\n    transaction: span.description,\n    contexts: {\n      trace: {\n        trace_id: span.trace_id,\n        span_id: span.span_id,\n        parent_span_id: span.parent_span_id,\n        op: span.op,\n        status: span.status,\n        origin: span.origin,\n        data: {\n          ...span.data,\n          ...(span.profile_id && { [SEMANTIC_ATTRIBUTE_PROFILE_ID]: span.profile_id }),\n          ...(span.exclusive_time && { [SEMANTIC_ATTRIBUTE_EXCLUSIVE_TIME]: span.exclusive_time }),\n        },\n      },\n    },\n    measurements: span.measurements,\n  };\n\n  return dropUndefinedKeys(event);\n}\n","import type { ClientReport, ClientReportEnvelope, ClientReportItem } from '../types-hoist';\n\nimport { createEnvelope } from './envelope';\nimport { dateTimestampInSeconds } from './time';\n\n/**\n * Creates client report envelope\n * @param discarded_events An array of discard events\n * @param dsn A DSN that can be set on the header. Optional.\n */\nexport function createClientReportEnvelope(\n  discarded_events: ClientReport['discarded_events'],\n  dsn?: string,\n  timestamp?: number,\n): ClientReportEnvelope {\n  const clientReportItem: ClientReportItem = [\n    { type: 'client_report' },\n    {\n      timestamp: timestamp || dateTimestampInSeconds(),\n      discarded_events,\n    },\n  ];\n  return createEnvelope<ClientReportEnvelope>(dsn ? { dsn } : {}, [clientReportItem]);\n}\n","import type { Session, SessionAggregates, User } from '../types-hoist';\n\n// By default, we want to infer the IP address, unless this is explicitly set to `null`\n// We do this after all other processing is done\n// If `ip_address` is explicitly set to `null` or a value, we leave it as is\n\n/**\n * @internal\n */\nexport function addAutoIpAddressToUser(objWithMaybeUser: { user?: User | null }): void {\n  if (objWithMaybeUser.user?.ip_address === undefined) {\n    objWithMaybeUser.user = {\n      ...objWithMaybeUser.user,\n      ip_address: '{{auto}}',\n    };\n  }\n}\n\n/**\n * @internal\n */\nexport function addAutoIpAddressToSession(session: Session | SessionAggregates): void {\n  if ('aggregates' in session) {\n    if (session.attrs?.['ip_address'] === undefined) {\n      session.attrs = {\n        ...session.attrs,\n        ip_address: '{{auto}}',\n      };\n    }\n  } else {\n    if (session.ipAddress === undefined) {\n      session.ipAddress = '{{auto}}';\n    }\n  }\n}\n","import type {\n  BrowserClientProfilingOptions,\n  BrowserClientReplayOptions,\n  ClientOptions,\n  Event,\n  EventHint,\n  Options,\n  ParameterizedString,\n  Scope,\n  SeverityLevel,\n} from '@sentry/core';\nimport {\n  Client,\n  addAutoIpAddressToSession,\n  addAutoIpAddressToUser,\n  applySdkMetadata,\n  getSDKSource,\n} from '@sentry/core';\nimport { eventFromException, eventFromMessage } from './eventbuilder';\nimport { WINDOW } from './helpers';\nimport type { BrowserTransportOptions } from './transports/types';\n\n/**\n * Configuration options for the Sentry Browser SDK.\n * @see @sentry/core Options for more information.\n */\nexport type BrowserOptions = Options<BrowserTransportOptions> &\n  BrowserClientReplayOptions &\n  BrowserClientProfilingOptions & {\n    /**\n     * Important: Only set this option if you know what you are doing!\n     *\n     * By default, the SDK will check if `Sentry.init` is called in a browser extension.\n     * In case it is, it will stop initialization and log a warning\n     * because browser extensions require a different Sentry initialization process:\n     * https://docs.sentry.io/platforms/javascript/best-practices/shared-environments/\n     *\n     * Setting up the SDK in a browser extension with global error monitoring is not recommended\n     * and will likely flood you with errors from other web sites or extensions. This can heavily\n     * impact your quota and cause interference with your and other Sentry SDKs in shared environments.\n     *\n     * If this check wrongfully flags your setup as a browser extension, you can set this\n     * option to `true` to skip the check.\n     *\n     * @default false\n     */\n    skipBrowserExtensionCheck?: boolean;\n  };\n\n/**\n * Configuration options for the Sentry Browser SDK Client class\n * @see BrowserClient for more information.\n */\nexport type BrowserClientOptions = ClientOptions<BrowserTransportOptions> &\n  BrowserClientReplayOptions &\n  BrowserClientProfilingOptions & {\n    /** If configured, this URL will be used as base URL for lazy loading integration. */\n    cdnBaseUrl?: string;\n  };\n\n/**\n * The Sentry Browser SDK Client.\n *\n * @see BrowserOptions for documentation on configuration options.\n * @see SentryClient for usage documentation.\n */\nexport class BrowserClient extends Client<BrowserClientOptions> {\n  /**\n   * Creates a new Browser SDK instance.\n   *\n   * @param options Configuration options for this SDK.\n   */\n  public constructor(options: BrowserClientOptions) {\n    const opts = {\n      // We default this to true, as it is the safer scenario\n      parentSpanIsAlwaysRootSpan: true,\n      ...options,\n    };\n    const sdkSource = WINDOW.SENTRY_SDK_SOURCE || getSDKSource();\n    applySdkMetadata(opts, 'browser', ['browser'], sdkSource);\n\n    super(opts);\n\n    if (opts.sendClientReports && WINDOW.document) {\n      WINDOW.document.addEventListener('visibilitychange', () => {\n        if (WINDOW.document.visibilityState === 'hidden') {\n          this._flushOutcomes();\n        }\n      });\n    }\n\n    if (this._options.sendDefaultPii) {\n      this.on('postprocessEvent', addAutoIpAddressToUser);\n      this.on('beforeSendSession', addAutoIpAddressToSession);\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public eventFromException(exception: unknown, hint?: EventHint): PromiseLike<Event> {\n    return eventFromException(this._options.stackParser, exception, hint, this._options.attachStacktrace);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public eventFromMessage(\n    message: ParameterizedString,\n    level: SeverityLevel = 'info',\n    hint?: EventHint,\n  ): PromiseLike<Event> {\n    return eventFromMessage(this._options.stackParser, message, level, hint, this._options.attachStacktrace);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  protected _prepareEvent(\n    event: Event,\n    hint: EventHint,\n    currentScope: Scope,\n    isolationScope: Scope,\n  ): PromiseLike<Event | null> {\n    event.platform = event.platform || 'javascript';\n\n    return super._prepareEvent(event, hint, currentScope, isolationScope);\n  }\n}\n","import type { Options } from '../types-hoist';\nimport { SDK_VERSION } from '../utils-hoist/version';\n\n/**\n * A builder for the SDK metadata in the options for the SDK initialization.\n *\n * Note: This function is identical to `buildMetadata` in Remix and NextJS and SvelteKit.\n * We don't extract it for bundle size reasons.\n * @see https://github.com/getsentry/sentry-javascript/pull/7404\n * @see https://github.com/getsentry/sentry-javascript/pull/4196\n *\n * If you make changes to this function consider updating the others as well.\n *\n * @param options SDK options object that gets mutated\n * @param names list of package names\n */\nexport function applySdkMetadata(options: Options, name: string, names = [name], source = 'npm'): void {\n  const metadata = options._metadata || {};\n\n  if (!metadata.sdk) {\n    metadata.sdk = {\n      name: `sentry.javascript.${name}`,\n      packages: names.map(name => ({\n        name: `${source}:@sentry/${name}`,\n        version: SDK_VERSION,\n      })),\n      version: SDK_VERSION,\n    };\n  }\n\n  options._metadata = metadata;\n}\n","/*\n * This module exists for optimizations in the build process through rollup and terser.  We define some global\n * constants, which can be overridden during build. By guarding certain pieces of code with functions that return these\n * constants, we can control whether or not they appear in the final bundle. (Any code guarded by a false condition will\n * never run, and will hence be dropped during treeshaking.) The two primary uses for this are stripping out calls to\n * `logger` and preventing node-related code from appearing in browser bundles.\n *\n * Attention:\n * This file should not be used to define constants/flags that are intended to be used for tree-shaking conducted by\n * users. These flags should live in their respective packages, as we identified user tooling (specifically webpack)\n * having issues tree-shaking these constants across package boundaries.\n * An example for this is the __SENTRY_DEBUG__ constant. It is declared in each package individually because we want\n * users to be able to shake away expressions that it guards.\n */\n\ndeclare const __SENTRY_BROWSER_BUNDLE__: boolean | undefined;\n\nexport type SdkSource = 'npm' | 'cdn' | 'loader';\n\n/**\n * Figures out if we're building a browser bundle.\n *\n * @returns true if this is a browser bundle build.\n */\nexport function isBrowserBundle(): boolean {\n  return typeof __SENTRY_BROWSER_BUNDLE__ !== 'undefined' && !!__SENTRY_BROWSER_BUNDLE__;\n}\n\n/**\n * Get source of SDK.\n */\nexport function getSDKSource(): SdkSource {\n  // This comment is used to identify this line in the CDN bundle build step and replace this with \"return 'cdn';\"\n  /* __SENTRY_SDK_SOURCE__ */ return 'npm';\n}\n","import { addHistoryInstrumentationHandler } from '@sentry-internal/browser-utils';\nimport { captureSession, defineIntegration, logger, startSession } from '@sentry/core';\nimport { DEBUG_BUILD } from '../debug-build';\nimport { WINDOW } from '../helpers';\n\n/**\n * When added, automatically creates sessions which allow you to track adoption and crashes (crash free rate) in your Releases in Sentry.\n * More information: https://docs.sentry.io/product/releases/health/\n *\n * Note: In order for session tracking to work, you need to set up Releases: https://docs.sentry.io/product/releases/\n */\nexport const browserSessionIntegration = defineIntegration(() => {\n  return {\n    name: 'BrowserSession',\n    setupOnce() {\n      if (typeof WINDOW.document === 'undefined') {\n        DEBUG_BUILD &&\n          logger.warn('Using the `browserSessionIntegration` in non-browser environments is not supported.');\n        return;\n      }\n\n      // The session duration for browser sessions does not track a meaningful\n      // concept that can be used as a metric.\n      // Automatically captured sessions are akin to page views, and thus we\n      // discard their duration.\n      startSession({ ignoreDuration: true });\n      captureSession();\n\n      // We want to create a session for every navigation as well\n      addHistoryInstrumentationHandler(({ from, to }) => {\n        // Don't create an additional session for the initial route or if the location did not change\n        if (from !== undefined && from !== to) {\n          startSession({ ignoreDuration: true });\n          captureSession();\n        }\n      });\n    },\n  };\n});\n","import type { Event, EventHint, Exception, ExtendedError, StackParser } from '../types-hoist';\n\nimport { isInstanceOf } from './is';\nimport { truncate } from './string';\n\n/**\n * Creates exceptions inside `event.exception.values` for errors that are nested on properties based on the `key` parameter.\n */\nexport function applyAggregateErrorsToEvent(\n  exceptionFromErrorImplementation: (stackParser: StackParser, ex: Error) => Exception,\n  parser: StackParser,\n  maxValueLimit: number = 250,\n  key: string,\n  limit: number,\n  event: Event,\n  hint?: EventHint,\n): void {\n  if (!event.exception?.values || !hint || !isInstanceOf(hint.originalException, Error)) {\n    return;\n  }\n\n  // Generally speaking the last item in `event.exception.values` is the exception originating from the original Error\n  const originalException: Exception | undefined =\n    event.exception.values.length > 0 ? event.exception.values[event.exception.values.length - 1] : undefined;\n\n  // We only create exception grouping if there is an exception in the event.\n  if (originalException) {\n    event.exception.values = truncateAggregateExceptions(\n      aggregateExceptionsFromError(\n        exceptionFromErrorImplementation,\n        parser,\n        limit,\n        hint.originalException as ExtendedError,\n        key,\n        event.exception.values,\n        originalException,\n        0,\n      ),\n      maxValueLimit,\n    );\n  }\n}\n\nfunction aggregateExceptionsFromError(\n  exceptionFromErrorImplementation: (stackParser: StackParser, ex: Error) => Exception,\n  parser: StackParser,\n  limit: number,\n  error: ExtendedError,\n  key: string,\n  prevExceptions: Exception[],\n  exception: Exception,\n  exceptionId: number,\n): Exception[] {\n  if (prevExceptions.length >= limit + 1) {\n    return prevExceptions;\n  }\n\n  let newExceptions = [...prevExceptions];\n\n  // Recursively call this function in order to walk down a chain of errors\n  if (isInstanceOf(error[key], Error)) {\n    applyExceptionGroupFieldsForParentException(exception, exceptionId);\n    const newException = exceptionFromErrorImplementation(parser, error[key]);\n    const newExceptionId = newExceptions.length;\n    applyExceptionGroupFieldsForChildException(newException, key, newExceptionId, exceptionId);\n    newExceptions = aggregateExceptionsFromError(\n      exceptionFromErrorImplementation,\n      parser,\n      limit,\n      error[key],\n      key,\n      [newException, ...newExceptions],\n      newException,\n      newExceptionId,\n    );\n  }\n\n  // This will create exception grouping for AggregateErrors\n  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/AggregateError\n  if (Array.isArray(error.errors)) {\n    error.errors.forEach((childError, i) => {\n      if (isInstanceOf(childError, Error)) {\n        applyExceptionGroupFieldsForParentException(exception, exceptionId);\n        const newException = exceptionFromErrorImplementation(parser, childError);\n        const newExceptionId = newExceptions.length;\n        applyExceptionGroupFieldsForChildException(newException, `errors[${i}]`, newExceptionId, exceptionId);\n        newExceptions = aggregateExceptionsFromError(\n          exceptionFromErrorImplementation,\n          parser,\n          limit,\n          childError,\n          key,\n          [newException, ...newExceptions],\n          newException,\n          newExceptionId,\n        );\n      }\n    });\n  }\n\n  return newExceptions;\n}\n\nfunction applyExceptionGroupFieldsForParentException(exception: Exception, exceptionId: number): void {\n  // Don't know if this default makes sense. The protocol requires us to set these values so we pick *some* default.\n  exception.mechanism = exception.mechanism || { type: 'generic', handled: true };\n\n  exception.mechanism = {\n    ...exception.mechanism,\n    ...(exception.type === 'AggregateError' && { is_exception_group: true }),\n    exception_id: exceptionId,\n  };\n}\n\nfunction applyExceptionGroupFieldsForChildException(\n  exception: Exception,\n  source: string,\n  exceptionId: number,\n  parentId: number | undefined,\n): void {\n  // Don't know if this default makes sense. The protocol requires us to set these values so we pick *some* default.\n  exception.mechanism = exception.mechanism || { type: 'generic', handled: true };\n\n  exception.mechanism = {\n    ...exception.mechanism,\n    type: 'chained',\n    source,\n    exception_id: exceptionId,\n    parent_id: parentId,\n  };\n}\n\n/**\n * Truncate the message (exception.value) of all exceptions in the event.\n * Because this event processor is ran after `applyClientOptions`,\n * we need to truncate the message of the added exceptions here.\n */\nfunction truncateAggregateExceptions(exceptions: Exception[], maxValueLength: number): Exception[] {\n  return exceptions.map(exception => {\n    if (exception.value) {\n      exception.value = truncate(exception.value, maxValueLength);\n    }\n    return exception;\n  });\n}\n","import type { IntegrationFn } from '@sentry/core';\nimport { applyAggregateErrorsToEvent, defineIntegration } from '@sentry/core';\nimport { exceptionFromError } from '../eventbuilder';\n\ninterface LinkedErrorsOptions {\n  key?: string;\n  limit?: number;\n}\n\nconst DEFAULT_KEY = 'cause';\nconst DEFAULT_LIMIT = 5;\n\nconst INTEGRATION_NAME = 'LinkedErrors';\n\nconst _linkedErrorsIntegration = ((options: LinkedErrorsOptions = {}) => {\n  const limit = options.limit || DEFAULT_LIMIT;\n  const key = options.key || DEFAULT_KEY;\n\n  return {\n    name: INTEGRATION_NAME,\n    preprocessEvent(event, hint, client) {\n      const options = client.getOptions();\n\n      applyAggregateErrorsToEvent(\n        // This differs from the LinkedErrors integration in core by using a different exceptionFromError function\n        exceptionFromError,\n        options.stackParser,\n        options.maxValueLength,\n        key,\n        limit,\n        event,\n        hint,\n      );\n    },\n  };\n}) satisfies IntegrationFn;\n\n/**\n * Aggregrate linked errors in an event.\n */\nexport const linkedErrorsIntegration = defineIntegration(_linkedErrorsIntegration);\n","// This was originally forked from https://github.com/csnover/TraceKit, and was largely\n// re - written as part of raven - js.\n//\n// This code was later copied to the JavaScript mono - repo and further modified and\n// refactored over the years.\n\n// Copyright (c) 2013 Onur Can Cakmak onur.cakmak@gmail.com and all TraceKit contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy of this\n// software and associated documentation files(the 'Software'), to deal in the Software\n// without restriction, including without limitation the rights to use, copy, modify,\n// merge, publish, distribute, sublicense, and / or sell copies of the Software, and to\n// permit persons to whom the Software is furnished to do so, subject to the following\n// conditions:\n//\n// The above copyright notice and this permission notice shall be included in all copies\n// or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,\n// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A\n// PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT\n// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF\n// CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE\n// OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nimport { UNKNOWN_FUNCTION, createStackParser } from '@sentry/core';\nimport type { StackFrame, StackLineParser, StackLineParserFn } from '@sentry/core';\n\nconst OPERA10_PRIORITY = 10;\nconst OPERA11_PRIORITY = 20;\nconst CHROME_PRIORITY = 30;\nconst WINJS_PRIORITY = 40;\nconst GECKO_PRIORITY = 50;\n\nfunction createFrame(filename: string, func: string, lineno?: number, colno?: number): StackFrame {\n  const frame: StackFrame = {\n    filename,\n    function: func === '<anonymous>' ? UNKNOWN_FUNCTION : func,\n    in_app: true, // All browser frames are considered in_app\n  };\n\n  if (lineno !== undefined) {\n    frame.lineno = lineno;\n  }\n\n  if (colno !== undefined) {\n    frame.colno = colno;\n  }\n\n  return frame;\n}\n\n// This regex matches frames that have no function name (ie. are at the top level of a module).\n// For example \"at http://localhost:5000//script.js:1:126\"\n// Frames _with_ function names usually look as follows: \"at commitLayoutEffects (react-dom.development.js:23426:1)\"\nconst chromeRegexNoFnName = /^\\s*at (\\S+?)(?::(\\d+))(?::(\\d+))\\s*$/i;\n\n// This regex matches all the frames that have a function name.\nconst chromeRegex =\n  /^\\s*at (?:(.+?\\)(?: \\[.+\\])?|.*?) ?\\((?:address at )?)?(?:async )?((?:<anonymous>|[-a-z]+:|.*bundle|\\/)?.*?)(?::(\\d+))?(?::(\\d+))?\\)?\\s*$/i;\n\nconst chromeEvalRegex = /\\((\\S*)(?::(\\d+))(?::(\\d+))\\)/;\n\n// Chromium based browsers: Chrome, Brave, new Opera, new Edge\n// We cannot call this variable `chrome` because it can conflict with global `chrome` variable in certain environments\n// See: https://github.com/getsentry/sentry-javascript/issues/6880\nconst chromeStackParserFn: StackLineParserFn = line => {\n  // If the stack line has no function name, we need to parse it differently\n  const noFnParts = chromeRegexNoFnName.exec(line) as null | [string, string, string, string];\n\n  if (noFnParts) {\n    const [, filename, line, col] = noFnParts;\n    return createFrame(filename, UNKNOWN_FUNCTION, +line, +col);\n  }\n\n  const parts = chromeRegex.exec(line) as null | [string, string, string, string, string];\n\n  if (parts) {\n    const isEval = parts[2] && parts[2].indexOf('eval') === 0; // start of line\n\n    if (isEval) {\n      const subMatch = chromeEvalRegex.exec(parts[2]) as null | [string, string, string, string];\n\n      if (subMatch) {\n        // throw out eval line/column and use top-most line/column number\n        parts[2] = subMatch[1]; // url\n        parts[3] = subMatch[2]; // line\n        parts[4] = subMatch[3]; // column\n      }\n    }\n\n    // Kamil: One more hack won't hurt us right? Understanding and adding more rules on top of these regexps right now\n    // would be way too time consuming. (TODO: Rewrite whole RegExp to be more readable)\n    const [func, filename] = extractSafariExtensionDetails(parts[1] || UNKNOWN_FUNCTION, parts[2]);\n\n    return createFrame(filename, func, parts[3] ? +parts[3] : undefined, parts[4] ? +parts[4] : undefined);\n  }\n\n  return;\n};\n\nexport const chromeStackLineParser: StackLineParser = [CHROME_PRIORITY, chromeStackParserFn];\n\n// gecko regex: `(?:bundle|\\d+\\.js)`: `bundle` is for react native, `\\d+\\.js` also but specifically for ram bundles because it\n// generates filenames without a prefix like `file://` the filenames in the stacktrace are just 42.js\n// We need this specific case for now because we want no other regex to match.\nconst geckoREgex =\n  /^\\s*(.*?)(?:\\((.*?)\\))?(?:^|@)?((?:[-a-z]+)?:\\/.*?|\\[native code\\]|[^@]*(?:bundle|\\d+\\.js)|\\/[\\w\\-. /=]+)(?::(\\d+))?(?::(\\d+))?\\s*$/i;\nconst geckoEvalRegex = /(\\S+) line (\\d+)(?: > eval line \\d+)* > eval/i;\n\nconst gecko: StackLineParserFn = line => {\n  const parts = geckoREgex.exec(line) as null | [string, string, string, string, string, string];\n\n  if (parts) {\n    const isEval = parts[3] && parts[3].indexOf(' > eval') > -1;\n    if (isEval) {\n      const subMatch = geckoEvalRegex.exec(parts[3]) as null | [string, string, string];\n\n      if (subMatch) {\n        // throw out eval line/column and use top-most line number\n        parts[1] = parts[1] || 'eval';\n        parts[3] = subMatch[1];\n        parts[4] = subMatch[2];\n        parts[5] = ''; // no column when eval\n      }\n    }\n\n    let filename = parts[3];\n    let func = parts[1] || UNKNOWN_FUNCTION;\n    [func, filename] = extractSafariExtensionDetails(func, filename);\n\n    return createFrame(filename, func, parts[4] ? +parts[4] : undefined, parts[5] ? +parts[5] : undefined);\n  }\n\n  return;\n};\n\nexport const geckoStackLineParser: StackLineParser = [GECKO_PRIORITY, gecko];\n\nconst winjsRegex = /^\\s*at (?:((?:\\[object object\\])?.+) )?\\(?((?:[-a-z]+):.*?):(\\d+)(?::(\\d+))?\\)?\\s*$/i;\n\nconst winjs: StackLineParserFn = line => {\n  const parts = winjsRegex.exec(line) as null | [string, string, string, string, string];\n\n  return parts\n    ? createFrame(parts[2], parts[1] || UNKNOWN_FUNCTION, +parts[3], parts[4] ? +parts[4] : undefined)\n    : undefined;\n};\n\nexport const winjsStackLineParser: StackLineParser = [WINJS_PRIORITY, winjs];\n\nconst opera10Regex = / line (\\d+).*script (?:in )?(\\S+)(?:: in function (\\S+))?$/i;\n\nconst opera10: StackLineParserFn = line => {\n  const parts = opera10Regex.exec(line) as null | [string, string, string, string];\n  return parts ? createFrame(parts[2], parts[3] || UNKNOWN_FUNCTION, +parts[1]) : undefined;\n};\n\nexport const opera10StackLineParser: StackLineParser = [OPERA10_PRIORITY, opera10];\n\nconst opera11Regex =\n  / line (\\d+), column (\\d+)\\s*(?:in (?:<anonymous function: ([^>]+)>|([^)]+))\\(.*\\))? in (.*):\\s*$/i;\n\nconst opera11: StackLineParserFn = line => {\n  const parts = opera11Regex.exec(line) as null | [string, string, string, string, string, string];\n  return parts ? createFrame(parts[5], parts[3] || parts[4] || UNKNOWN_FUNCTION, +parts[1], +parts[2]) : undefined;\n};\n\nexport const opera11StackLineParser: StackLineParser = [OPERA11_PRIORITY, opera11];\n\nexport const defaultStackLineParsers = [chromeStackLineParser, geckoStackLineParser];\n\nexport const defaultStackParser = createStackParser(...defaultStackLineParsers);\n\n/**\n * Safari web extensions, starting version unknown, can produce \"frames-only\" stacktraces.\n * What it means, is that instead of format like:\n *\n * Error: wat\n *   at function@url:row:col\n *   at function@url:row:col\n *   at function@url:row:col\n *\n * it produces something like:\n *\n *   function@url:row:col\n *   function@url:row:col\n *   function@url:row:col\n *\n * Because of that, it won't be captured by `chrome` RegExp and will fall into `Gecko` branch.\n * This function is extracted so that we can use it in both places without duplicating the logic.\n * Unfortunately \"just\" changing RegExp is too complicated now and making it pass all tests\n * and fix this case seems like an impossible, or at least way too time-consuming task.\n */\nconst extractSafariExtensionDetails = (func: string, filename: string): [string, string] => {\n  const isSafariExtension = func.indexOf('safari-extension') !== -1;\n  const isSafariWebExtension = func.indexOf('safari-web-extension') !== -1;\n\n  return isSafariExtension || isSafariWebExtension\n    ? [\n        func.indexOf('@') !== -1 ? (func.split('@')[0] as string) : UNKNOWN_FUNCTION,\n        isSafariExtension ? `safari-extension:${filename}` : `safari-web-extension:${filename}`,\n      ]\n    : [func, filename];\n};\n","declare const __DEBUG_BUILD__: boolean;\n\n/**\n * This serves as a build time flag that will be true by default, but false in non-debug builds or if users replace `__SENTRY_DEBUG__` in their generated code.\n *\n * ATTENTION: This constant must never cross package boundaries (i.e. be exported) to guarantee that it can be used for tree shaking.\n */\nexport const DEBUG_BUILD = __DEBUG_BUILD__;\n","import { isNativeFunction, logger } from '@sentry/core';\nimport { DEBUG_BUILD } from './debug-build';\nimport { WINDOW } from './types';\n\n/**\n * We generally want to use window.fetch / window.setTimeout.\n * However, in some cases this may be wrapped (e.g. by Zone.js for Angular),\n * so we try to get an unpatched version of this from a sandboxed iframe.\n */\n\ninterface CacheableImplementations {\n  setTimeout: typeof WINDOW.setTimeout;\n  fetch: typeof WINDOW.fetch;\n}\n\nconst cachedImplementations: Partial<CacheableImplementations> = {};\n\n/**\n * Get the native implementation of a browser function.\n *\n * This can be used to ensure we get an unwrapped version of a function, in cases where a wrapped function can lead to problems.\n *\n * The following methods can be retrieved:\n * - `setTimeout`: This can be wrapped by e.g. Angular, causing change detection to be triggered.\n * - `fetch`: This can be wrapped by e.g. ad-blockers, causing an infinite loop when a request is blocked.\n */\nexport function getNativeImplementation<T extends keyof CacheableImplementations>(\n  name: T,\n): CacheableImplementations[T] {\n  const cached = cachedImplementations[name];\n  if (cached) {\n    return cached;\n  }\n\n  let impl = WINDOW[name] as CacheableImplementations[T];\n\n  // Fast path to avoid DOM I/O\n  if (isNativeFunction(impl)) {\n    return (cachedImplementations[name] = impl.bind(WINDOW) as CacheableImplementations[T]);\n  }\n\n  const document = WINDOW.document;\n  // eslint-disable-next-line deprecation/deprecation\n  if (document && typeof document.createElement === 'function') {\n    try {\n      const sandbox = document.createElement('iframe');\n      sandbox.hidden = true;\n      document.head.appendChild(sandbox);\n      const contentWindow = sandbox.contentWindow;\n      if (contentWindow?.[name]) {\n        impl = contentWindow[name] as CacheableImplementations[T];\n      }\n      document.head.removeChild(sandbox);\n    } catch (e) {\n      // Could not create sandbox iframe, just use window.xxx\n      DEBUG_BUILD && logger.warn(`Could not create sandbox iframe for ${name} check, bailing to window.${name}: `, e);\n    }\n  }\n\n  // Sanity check: This _should_ not happen, but if it does, we just skip caching...\n  // This can happen e.g. in tests where fetch may not be available in the env, or similar.\n  if (!impl) {\n    return impl;\n  }\n\n  return (cachedImplementations[name] = impl.bind(WINDOW) as CacheableImplementations[T]);\n}\n\n/** Clear a cached implementation. */\nexport function clearCachedImplementation(name: keyof CacheableImplementations): void {\n  cachedImplementations[name] = undefined;\n}\n\n/**\n * A special usecase for incorrectly wrapped Fetch APIs in conjunction with ad-blockers.\n * Whenever someone wraps the Fetch API and returns the wrong promise chain,\n * this chain becomes orphaned and there is no possible way to capture it's rejections\n * other than allowing it bubble up to this very handler. eg.\n *\n * const f = window.fetch;\n * window.fetch = function () {\n *   const p = f.apply(this, arguments);\n *\n *   p.then(function() {\n *     console.log('hi.');\n *   });\n *\n *   return p;\n * }\n *\n * `p.then(function () { ... })` is producing a completely separate promise chain,\n * however, what's returned is `p` - the result of original `fetch` call.\n *\n * This mean, that whenever we use the Fetch API to send our own requests, _and_\n * some ad-blocker blocks it, this orphaned chain will _always_ reject,\n * effectively causing another event to be captured.\n * This makes a whole process become an infinite loop, which we need to somehow\n * deal with, and break it in one way or another.\n *\n * To deal with this issue, we are making sure that we _always_ use the real\n * browser Fetch API, instead of relying on what `window.fetch` exposes.\n * The only downside to this would be missing our own requests as breadcrumbs,\n * but because we are already not doing this, it should be just fine.\n *\n * Possible failed fetch error messages per-browser:\n *\n * Chrome:  Failed to fetch\n * Edge:    Failed to Fetch\n * Firefox: NetworkError when attempting to fetch resource\n * Safari:  resource blocked by content blocker\n */\nexport function fetch(...rest: Parameters<typeof WINDOW.fetch>): ReturnType<typeof WINDOW.fetch> {\n  return getNativeImplementation('fetch')(...rest);\n}\n\n/**\n * Get an unwrapped `setTimeout` method.\n * This ensures that even if e.g. Angular wraps `setTimeout`, we get the native implementation,\n * avoiding triggering change detection.\n */\nexport function setTimeout(...rest: Parameters<typeof WINDOW.setTimeout>): ReturnType<typeof WINDOW.setTimeout> {\n  return getNativeImplementation('setTimeout')(...rest);\n}\n","import { SentryError } from './error';\nimport { SyncPromise, rejectedSyncPromise, resolvedSyncPromise } from './syncpromise';\n\nexport interface PromiseBuffer<T> {\n  // exposes the internal array so tests can assert on the state of it.\n  // XXX: this really should not be public api.\n  $: Array<PromiseLike<T>>;\n  add(taskProducer: () => PromiseLike<T>): PromiseLike<T>;\n  drain(timeout?: number): PromiseLike<boolean>;\n}\n\n/**\n * Creates an new PromiseBuffer object with the specified limit\n * @param limit max number of promises that can be stored in the buffer\n */\nexport function makePromiseBuffer<T>(limit?: number): PromiseBuffer<T> {\n  const buffer: Array<PromiseLike<T>> = [];\n\n  function isReady(): boolean {\n    return limit === undefined || buffer.length < limit;\n  }\n\n  /**\n   * Remove a promise from the queue.\n   *\n   * @param task Can be any PromiseLike<T>\n   * @returns Removed promise.\n   */\n  function remove(task: PromiseLike<T>): PromiseLike<T | void> {\n    return buffer.splice(buffer.indexOf(task), 1)[0] || Promise.resolve(undefined);\n  }\n\n  /**\n   * Add a promise (representing an in-flight action) to the queue, and set it to remove itself on fulfillment.\n   *\n   * @param taskProducer A function producing any PromiseLike<T>; In previous versions this used to be `task:\n   *        PromiseLike<T>`, but under that model, Promises were instantly created on the call-site and their executor\n   *        functions therefore ran immediately. Thus, even if the buffer was full, the action still happened. By\n   *        requiring the promise to be wrapped in a function, we can defer promise creation until after the buffer\n   *        limit check.\n   * @returns The original promise.\n   */\n  function add(taskProducer: () => PromiseLike<T>): PromiseLike<T> {\n    if (!isReady()) {\n      return rejectedSyncPromise(new SentryError('Not adding Promise because buffer limit was reached.'));\n    }\n\n    // start the task and add its promise to the queue\n    const task = taskProducer();\n    if (buffer.indexOf(task) === -1) {\n      buffer.push(task);\n    }\n    void task\n      .then(() => remove(task))\n      // Use `then(null, rejectionHandler)` rather than `catch(rejectionHandler)` so that we can use `PromiseLike`\n      // rather than `Promise`. `PromiseLike` doesn't have a `.catch` method, making its polyfill smaller. (ES5 didn't\n      // have promises, so TS has to polyfill when down-compiling.)\n      .then(null, () =>\n        remove(task).then(null, () => {\n          // We have to add another catch here because `remove()` starts a new promise chain.\n        }),\n      );\n    return task;\n  }\n\n  /**\n   * Wait for all promises in the queue to resolve or for timeout to expire, whichever comes first.\n   *\n   * @param timeout The time, in ms, after which to resolve to `false` if the queue is still non-empty. Passing `0` (or\n   * not passing anything) will make the promise wait as long as it takes for the queue to drain before resolving to\n   * `true`.\n   * @returns A promise which will resolve to `true` if the queue is already empty or drains before the timeout, and\n   * `false` otherwise\n   */\n  function drain(timeout?: number): PromiseLike<boolean> {\n    return new SyncPromise<boolean>((resolve, reject) => {\n      let counter = buffer.length;\n\n      if (!counter) {\n        return resolve(true);\n      }\n\n      // wait for `timeout` ms and then resolve to `false` (if not cancelled first)\n      const capturedSetTimeout = setTimeout(() => {\n        if (timeout && timeout > 0) {\n          resolve(false);\n        }\n      }, timeout);\n\n      // if all promises resolve in time, cancel the timer and resolve to `true`\n      buffer.forEach(item => {\n        void resolvedSyncPromise(item).then(() => {\n          if (!--counter) {\n            clearTimeout(capturedSetTimeout);\n            resolve(true);\n          }\n        }, reject);\n      });\n    });\n  }\n\n  return {\n    $: buffer,\n    add,\n    drain,\n  };\n}\n","import type { DataCategory, TransportMakeRequestResponse } from '../types-hoist';\n\n// Intentionally keeping the key broad, as we don't know for sure what rate limit headers get returned from backend\nexport type RateLimits = Record<string, number>;\n\nexport const DEFAULT_RETRY_AFTER = 60 * 1000; // 60 seconds\n\n/**\n * Extracts Retry-After value from the request header or returns default value\n * @param header string representation of 'Retry-After' header\n * @param now current unix timestamp\n *\n */\nexport function parseRetryAfterHeader(header: string, now: number = Date.now()): number {\n  const headerDelay = parseInt(`${header}`, 10);\n  if (!isNaN(headerDelay)) {\n    return headerDelay * 1000;\n  }\n\n  const headerDate = Date.parse(`${header}`);\n  if (!isNaN(headerDate)) {\n    return headerDate - now;\n  }\n\n  return DEFAULT_RETRY_AFTER;\n}\n\n/**\n * Gets the time that the given category is disabled until for rate limiting.\n * In case no category-specific limit is set but a general rate limit across all categories is active,\n * that time is returned.\n *\n * @return the time in ms that the category is disabled until or 0 if there's no active rate limit.\n */\nexport function disabledUntil(limits: RateLimits, dataCategory: DataCategory): number {\n  return limits[dataCategory] || limits.all || 0;\n}\n\n/**\n * Checks if a category is rate limited\n */\nexport function isRateLimited(limits: RateLimits, dataCategory: DataCategory, now: number = Date.now()): boolean {\n  return disabledUntil(limits, dataCategory) > now;\n}\n\n/**\n * Update ratelimits from incoming headers.\n *\n * @return the updated RateLimits object.\n */\nexport function updateRateLimits(\n  limits: RateLimits,\n  { statusCode, headers }: TransportMakeRequestResponse,\n  now: number = Date.now(),\n): RateLimits {\n  const updatedRateLimits: RateLimits = {\n    ...limits,\n  };\n\n  // \"The name is case-insensitive.\"\n  // https://developer.mozilla.org/en-US/docs/Web/API/Headers/get\n  const rateLimitHeader = headers?.['x-sentry-rate-limits'];\n  const retryAfterHeader = headers?.['retry-after'];\n\n  if (rateLimitHeader) {\n    /**\n     * rate limit headers are of the form\n     *     <header>,<header>,..\n     * where each <header> is of the form\n     *     <retry_after>: <categories>: <scope>: <reason_code>: <namespaces>\n     * where\n     *     <retry_after> is a delay in seconds\n     *     <categories> is the event type(s) (error, transaction, etc) being rate limited and is of the form\n     *         <category>;<category>;...\n     *     <scope> is what's being limited (org, project, or key) - ignored by SDK\n     *     <reason_code> is an arbitrary string like \"org_quota\" - ignored by SDK\n     *     <namespaces> Semicolon-separated list of metric namespace identifiers. Defines which namespace(s) will be affected.\n     *         Only present if rate limit applies to the metric_bucket data category.\n     */\n    for (const limit of rateLimitHeader.trim().split(',')) {\n      const [retryAfter, categories, , , namespaces] = limit.split(':', 5) as [string, ...string[]];\n      const headerDelay = parseInt(retryAfter, 10);\n      const delay = (!isNaN(headerDelay) ? headerDelay : 60) * 1000; // 60sec default\n      if (!categories) {\n        updatedRateLimits.all = now + delay;\n      } else {\n        for (const category of categories.split(';')) {\n          if (category === 'metric_bucket') {\n            // namespaces will be present when category === 'metric_bucket'\n            if (!namespaces || namespaces.split(';').includes('custom')) {\n              updatedRateLimits[category] = now + delay;\n            }\n          } else {\n            updatedRateLimits[category] = now + delay;\n          }\n        }\n      }\n    }\n  } else if (retryAfterHeader) {\n    updatedRateLimits.all = now + parseRetryAfterHeader(retryAfterHeader, now);\n  } else if (statusCode === 429) {\n    updatedRateLimits.all = now + 60 * 1000;\n  }\n\n  return updatedRateLimits;\n}\n","import { DEBUG_BUILD } from '../debug-build';\nimport type {\n  Envelope,\n  EnvelopeItem,\n  EventDropReason,\n  InternalBaseTransportOptions,\n  Transport,\n  TransportMakeRequestResponse,\n  TransportRequestExecutor,\n} from '../types-hoist';\nimport {\n  createEnvelope,\n  envelopeItemTypeToDataCategory,\n  forEachEnvelopeItem,\n  serializeEnvelope,\n} from '../utils-hoist/envelope';\nimport { SentryError } from '../utils-hoist/error';\nimport { logger } from '../utils-hoist/logger';\nimport { type PromiseBuffer, makePromiseBuffer } from '../utils-hoist/promisebuffer';\nimport { type RateLimits, isRateLimited, updateRateLimits } from '../utils-hoist/ratelimit';\nimport { resolvedSyncPromise } from '../utils-hoist/syncpromise';\n\nexport const DEFAULT_TRANSPORT_BUFFER_SIZE = 64;\n\n/**\n * Creates an instance of a Sentry `Transport`\n *\n * @param options\n * @param makeRequest\n */\nexport function createTransport(\n  options: InternalBaseTransportOptions,\n  makeRequest: TransportRequestExecutor,\n  buffer: PromiseBuffer<TransportMakeRequestResponse> = makePromiseBuffer(\n    options.bufferSize || DEFAULT_TRANSPORT_BUFFER_SIZE,\n  ),\n): Transport {\n  let rateLimits: RateLimits = {};\n  const flush = (timeout?: number): PromiseLike<boolean> => buffer.drain(timeout);\n\n  function send(envelope: Envelope): PromiseLike<TransportMakeRequestResponse> {\n    const filteredEnvelopeItems: EnvelopeItem[] = [];\n\n    // Drop rate limited items from envelope\n    forEachEnvelopeItem(envelope, (item, type) => {\n      const dataCategory = envelopeItemTypeToDataCategory(type);\n      if (isRateLimited(rateLimits, dataCategory)) {\n        options.recordDroppedEvent('ratelimit_backoff', dataCategory);\n      } else {\n        filteredEnvelopeItems.push(item);\n      }\n    });\n\n    // Skip sending if envelope is empty after filtering out rate limited events\n    if (filteredEnvelopeItems.length === 0) {\n      return resolvedSyncPromise({});\n    }\n\n    const filteredEnvelope: Envelope = createEnvelope(envelope[0], filteredEnvelopeItems as (typeof envelope)[1]);\n\n    // Creates client report for each item in an envelope\n    const recordEnvelopeLoss = (reason: EventDropReason): void => {\n      forEachEnvelopeItem(filteredEnvelope, (item, type) => {\n        options.recordDroppedEvent(reason, envelopeItemTypeToDataCategory(type));\n      });\n    };\n\n    const requestTask = (): PromiseLike<TransportMakeRequestResponse> =>\n      makeRequest({ body: serializeEnvelope(filteredEnvelope) }).then(\n        response => {\n          // We don't want to throw on NOK responses, but we want to at least log them\n          if (response.statusCode !== undefined && (response.statusCode < 200 || response.statusCode >= 300)) {\n            DEBUG_BUILD && logger.warn(`Sentry responded with status code ${response.statusCode} to sent event.`);\n          }\n\n          rateLimits = updateRateLimits(rateLimits, response);\n          return response;\n        },\n        error => {\n          recordEnvelopeLoss('network_error');\n          throw error;\n        },\n      );\n\n    return buffer.add(requestTask).then(\n      result => result,\n      error => {\n        if (error instanceof SentryError) {\n          DEBUG_BUILD && logger.error('Skipped sending event because buffer is full.');\n          recordEnvelopeLoss('queue_overflow');\n          return resolvedSyncPromise({});\n        } else {\n          throw error;\n        }\n      },\n    );\n  }\n\n  return {\n    send,\n    flush,\n  };\n}\n","import { clearCachedImplementation, getNativeImplementation } from '@sentry-internal/browser-utils';\nimport type { Transport, TransportMakeRequestResponse, TransportRequest } from '@sentry/core';\nimport { createTransport, rejectedSyncPromise } from '@sentry/core';\nimport type { WINDOW } from '../helpers';\nimport type { BrowserTransportOptions } from './types';\n\n/**\n * Creates a Transport that uses the Fetch API to send events to Sentry.\n */\nexport function makeFetchTransport(\n  options: BrowserTransportOptions,\n  nativeFetch: typeof WINDOW.fetch | undefined = getNativeImplementation('fetch'),\n): Transport {\n  let pendingBodySize = 0;\n  let pendingCount = 0;\n\n  function makeRequest(request: TransportRequest): PromiseLike<TransportMakeRequestResponse> {\n    const requestSize = request.body.length;\n    pendingBodySize += requestSize;\n    pendingCount++;\n\n    const requestOptions: RequestInit = {\n      body: request.body,\n      method: 'POST',\n      referrerPolicy: 'strict-origin',\n      headers: options.headers,\n      // Outgoing requests are usually cancelled when navigating to a different page, causing a \"TypeError: Failed to\n      // fetch\" error and sending a \"network_error\" client-outcome - in Chrome, the request status shows \"(cancelled)\".\n      // The `keepalive` flag keeps outgoing requests alive, even when switching pages. We want this since we're\n      // frequently sending events right before the user is switching pages (eg. when finishing navigation transactions).\n      // Gotchas:\n      // - `keepalive` isn't supported by Firefox\n      // - As per spec (https://fetch.spec.whatwg.org/#http-network-or-cache-fetch):\n      //   If the sum of contentLength and inflightKeepaliveBytes is greater than 64 kibibytes, then return a network error.\n      //   We will therefore only activate the flag when we're below that limit.\n      // There is also a limit of requests that can be open at the same time, so we also limit this to 15\n      // See https://github.com/getsentry/sentry-javascript/pull/7553 for details\n      keepalive: pendingBodySize <= 60_000 && pendingCount < 15,\n      ...options.fetchOptions,\n    };\n\n    if (!nativeFetch) {\n      clearCachedImplementation('fetch');\n      return rejectedSyncPromise('No fetch implementation available');\n    }\n\n    try {\n      // TODO: This may need a `suppressTracing` call in the future when we switch the browser SDK to OTEL\n      return nativeFetch(options.url, requestOptions).then(response => {\n        pendingBodySize -= requestSize;\n        pendingCount--;\n        return {\n          statusCode: response.status,\n          headers: {\n            'x-sentry-rate-limits': response.headers.get('X-Sentry-Rate-Limits'),\n            'retry-after': response.headers.get('Retry-After'),\n          },\n        };\n      });\n    } catch (e) {\n      clearCachedImplementation('fetch');\n      pendingBodySize -= requestSize;\n      pendingCount--;\n      return rejectedSyncPromise(e);\n    }\n  }\n\n  return createTransport(options, makeRequest);\n}\n","import type { Client, Integration, Options, ReportDialogOptions } from '@sentry/core';\nimport {\n  consoleSandbox,\n  dedupeIntegration,\n  functionToStringIntegration,\n  getCurrentScope,\n  getIntegrationsToSetup,\n  getLocationHref,\n  getReportDialogEndpoint,\n  inboundFiltersIntegration,\n  initAndBind,\n  lastEventId,\n  logger,\n  stackParserFromStackParserOptions,\n  supportsFetch,\n} from '@sentry/core';\nimport type { BrowserClientOptions, BrowserOptions } from './client';\nimport { BrowserClient } from './client';\nimport { DEBUG_BUILD } from './debug-build';\nimport { WINDOW } from './helpers';\nimport { breadcrumbsIntegration } from './integrations/breadcrumbs';\nimport { browserApiErrorsIntegration } from './integrations/browserapierrors';\nimport { browserSessionIntegration } from './integrations/browsersession';\nimport { globalHandlersIntegration } from './integrations/globalhandlers';\nimport { httpContextIntegration } from './integrations/httpcontext';\nimport { linkedErrorsIntegration } from './integrations/linkederrors';\nimport { defaultStackParser } from './stack-parsers';\nimport { makeFetchTransport } from './transports/fetch';\n\n/** Get the default integrations for the browser SDK. */\nexport function getDefaultIntegrations(_options: Options): Integration[] {\n  /**\n   * Note: Please make sure this stays in sync with Angular SDK, which re-exports\n   * `getDefaultIntegrations` but with an adjusted set of integrations.\n   */\n  return [\n    // TODO(v10): Replace with `eventFiltersIntegration` once we remove the deprecated `inboundFiltersIntegration`\n    // eslint-disable-next-line deprecation/deprecation\n    inboundFiltersIntegration(),\n    functionToStringIntegration(),\n    browserApiErrorsIntegration(),\n    breadcrumbsIntegration(),\n    globalHandlersIntegration(),\n    linkedErrorsIntegration(),\n    dedupeIntegration(),\n    httpContextIntegration(),\n    browserSessionIntegration(),\n  ];\n}\n\n/** Exported only for tests. */\nexport function applyDefaultOptions(optionsArg: BrowserOptions = {}): BrowserOptions {\n  const defaultOptions: BrowserOptions = {\n    defaultIntegrations: getDefaultIntegrations(optionsArg),\n    release:\n      typeof __SENTRY_RELEASE__ === 'string' // This allows build tooling to find-and-replace __SENTRY_RELEASE__ to inject a release value\n        ? __SENTRY_RELEASE__\n        : WINDOW.SENTRY_RELEASE?.id, // This supports the variable that sentry-webpack-plugin injects\n    sendClientReports: true,\n  };\n\n  return {\n    ...defaultOptions,\n    ...dropTopLevelUndefinedKeys(optionsArg),\n  };\n}\n\n/**\n * In contrast to the regular `dropUndefinedKeys` method,\n * this one does not deep-drop keys, but only on the top level.\n */\nfunction dropTopLevelUndefinedKeys<T extends object>(obj: T): Partial<T> {\n  const mutatetedObj: Partial<T> = {};\n\n  for (const k of Object.getOwnPropertyNames(obj)) {\n    const key = k as keyof T;\n    if (obj[key] !== undefined) {\n      mutatetedObj[key] = obj[key];\n    }\n  }\n\n  return mutatetedObj;\n}\n\ntype ExtensionProperties = {\n  chrome?: Runtime;\n  browser?: Runtime;\n  nw?: unknown;\n};\ntype Runtime = {\n  runtime?: {\n    id?: string;\n  };\n};\n\nfunction shouldShowBrowserExtensionError(): boolean {\n  const windowWithMaybeExtension =\n    typeof WINDOW.window !== 'undefined' && (WINDOW as typeof WINDOW & ExtensionProperties);\n  if (!windowWithMaybeExtension) {\n    // No need to show the error if we're not in a browser window environment (e.g. service workers)\n    return false;\n  }\n\n  const extensionKey = windowWithMaybeExtension.chrome ? 'chrome' : 'browser';\n  const extensionObject = windowWithMaybeExtension[extensionKey];\n\n  const runtimeId = extensionObject?.runtime?.id;\n  const href = getLocationHref() || '';\n\n  const extensionProtocols = ['chrome-extension:', 'moz-extension:', 'ms-browser-extension:', 'safari-web-extension:'];\n\n  // Running the SDK in a dedicated extension page and calling Sentry.init is fine; no risk of data leakage\n  const isDedicatedExtensionPage =\n    !!runtimeId && WINDOW === WINDOW.top && extensionProtocols.some(protocol => href.startsWith(`${protocol}//`));\n\n  // Running the SDK in NW.js, which appears like a browser extension but isn't, is also fine\n  // see: https://github.com/getsentry/sentry-javascript/issues/12668\n  const isNWjs = typeof windowWithMaybeExtension.nw !== 'undefined';\n\n  return !!runtimeId && !isDedicatedExtensionPage && !isNWjs;\n}\n\n/**\n * A magic string that build tooling can leverage in order to inject a release value into the SDK.\n */\ndeclare const __SENTRY_RELEASE__: string | undefined;\n\n/**\n * The Sentry Browser SDK Client.\n *\n * To use this SDK, call the {@link init} function as early as possible when\n * loading the web page. To set context information or send manual events, use\n * the provided methods.\n *\n * @example\n *\n * ```\n *\n * import { init } from '@sentry/browser';\n *\n * init({\n *   dsn: '__DSN__',\n *   // ...\n * });\n * ```\n *\n * @example\n * ```\n *\n * import { addBreadcrumb } from '@sentry/browser';\n * addBreadcrumb({\n *   message: 'My Breadcrumb',\n *   // ...\n * });\n * ```\n *\n * @example\n *\n * ```\n *\n * import * as Sentry from '@sentry/browser';\n * Sentry.captureMessage('Hello, world!');\n * Sentry.captureException(new Error('Good bye'));\n * Sentry.captureEvent({\n *   message: 'Manual',\n *   stacktrace: [\n *     // ...\n *   ],\n * });\n * ```\n *\n * @see {@link BrowserOptions} for documentation on configuration options.\n */\nexport function init(browserOptions: BrowserOptions = {}): Client | undefined {\n  const options = applyDefaultOptions(browserOptions);\n\n  if (!options.skipBrowserExtensionCheck && shouldShowBrowserExtensionError()) {\n    if (DEBUG_BUILD) {\n      consoleSandbox(() => {\n        // eslint-disable-next-line no-console\n        console.error(\n          '[Sentry] You cannot run Sentry this way in a browser extension, check: https://docs.sentry.io/platforms/javascript/best-practices/browser-extensions/',\n        );\n      });\n    }\n    return;\n  }\n\n  if (DEBUG_BUILD && !supportsFetch()) {\n    logger.warn(\n      'No Fetch API detected. The Sentry SDK requires a Fetch API compatible environment to send events. Please add a Fetch API polyfill.',\n    );\n  }\n  const clientOptions: BrowserClientOptions = {\n    ...options,\n    stackParser: stackParserFromStackParserOptions(options.stackParser || defaultStackParser),\n    integrations: getIntegrationsToSetup(options),\n    transport: options.transport || makeFetchTransport,\n  };\n\n  return initAndBind(BrowserClient, clientOptions);\n}\n\n/**\n * Present the user with a report dialog.\n *\n * @param options Everything is optional, we try to fetch all info need from the global scope.\n */\nexport function showReportDialog(options: ReportDialogOptions = {}): void {\n  // doesn't work without a document (React Native)\n  if (!WINDOW.document) {\n    DEBUG_BUILD && logger.error('Global document not defined in showReportDialog call');\n    return;\n  }\n\n  const scope = getCurrentScope();\n  const client = scope.getClient();\n  const dsn = client?.getDsn();\n\n  if (!dsn) {\n    DEBUG_BUILD && logger.error('DSN not configured for showReportDialog call');\n    return;\n  }\n\n  if (scope) {\n    options.user = {\n      ...scope.getUser(),\n      ...options.user,\n    };\n  }\n\n  if (!options.eventId) {\n    const eventId = lastEventId();\n    if (eventId) {\n      options.eventId = eventId;\n    }\n  }\n\n  const script = WINDOW.document.createElement('script');\n  script.async = true;\n  script.crossOrigin = 'anonymous';\n  script.src = getReportDialogEndpoint(dsn, options);\n\n  if (options.onLoad) {\n    script.onload = options.onLoad;\n  }\n\n  const { onClose } = options;\n  if (onClose) {\n    const reportDialogClosedMessageHandler = (event: MessageEvent): void => {\n      if (event.data === '__sentry_reportdialog_closed__') {\n        try {\n          onClose();\n        } finally {\n          WINDOW.removeEventListener('message', reportDialogClosedMessageHandler);\n        }\n      }\n    };\n    WINDOW.addEventListener('message', reportDialogClosedMessageHandler);\n  }\n\n  const injectionPoint = WINDOW.document.head || WINDOW.document.body;\n  if (injectionPoint) {\n    injectionPoint.appendChild(script);\n  } else {\n    DEBUG_BUILD && logger.error('Not injecting report dialog. No injection point found in HTML');\n  }\n}\n\n/**\n * This function is here to be API compatible with the loader.\n * @hidden\n */\nexport function forceLoad(): void {\n  // Noop\n}\n\n/**\n * This function is here to be API compatible with the loader.\n * @hidden\n */\nexport function onLoad(callback: () => void): void {\n  callback();\n}\n","import type { AsyncContextStack } from './asyncContext/stackStrategy';\nimport type { AsyncContextStrategy } from './asyncContext/types';\nimport type { Scope } from './scope';\nimport type { Logger } from './utils-hoist/logger';\nimport { SDK_VERSION } from './utils-hoist/version';\nimport { GLOBAL_OBJ } from './utils-hoist/worldwide';\n\n/**\n * An object that contains globally accessible properties and maintains a scope stack.\n * @hidden\n */\nexport interface Carrier {\n  __SENTRY__?: VersionedCarrier;\n}\n\ntype VersionedCarrier = {\n  version?: string;\n} & Record<Exclude<string, 'version'>, SentryCarrier>;\n\nexport interface SentryCarrier {\n  acs?: AsyncContextStrategy;\n  stack?: AsyncContextStack;\n\n  globalScope?: Scope;\n  defaultIsolationScope?: Scope;\n  defaultCurrentScope?: Scope;\n  logger?: Logger;\n\n  /** Overwrites TextEncoder used in `@sentry/core`, need for `react-native@0.73` and older */\n  encodePolyfill?: (input: string) => Uint8Array;\n  /** Overwrites TextDecoder used in `@sentry/core`, need for `react-native@0.73` and older */\n  decodePolyfill?: (input: Uint8Array) => string;\n}\n\n/**\n * Returns the global shim registry.\n *\n * FIXME: This function is problematic, because despite always returning a valid Carrier,\n * it has an optional `__SENTRY__` property, which then in turn requires us to always perform an unnecessary check\n * at the call-site. We always access the carrier through this function, so we can guarantee that `__SENTRY__` is there.\n **/\nexport function getMainCarrier(): Carrier {\n  // This ensures a Sentry carrier exists\n  getSentryCarrier(GLOBAL_OBJ);\n  return GLOBAL_OBJ;\n}\n\n/** Will either get the existing sentry carrier, or create a new one. */\nexport function getSentryCarrier(carrier: Carrier): SentryCarrier {\n  const __SENTRY__ = (carrier.__SENTRY__ = carrier.__SENTRY__ || {});\n\n  // For now: First SDK that sets the .version property wins\n  __SENTRY__.version = __SENTRY__.version || SDK_VERSION;\n\n  // Intentionally populating and returning the version of \"this\" SDK instance\n  // rather than what's set in .version so that \"this\" SDK always gets its carrier\n  return (__SENTRY__[SDK_VERSION] = __SENTRY__[SDK_VERSION] || {});\n}\n\n/**\n * Returns a global singleton contained in the global `__SENTRY__[]` object.\n *\n * If the singleton doesn't already exist in `__SENTRY__`, it will be created using the given factory\n * function and added to the `__SENTRY__` object.\n *\n * @param name name of the global singleton on __SENTRY__\n * @param creator creator Factory function to create the singleton if it doesn't already exist on `__SENTRY__`\n * @param obj (Optional) The global object on which to look for `__SENTRY__`, if not `GLOBAL_OBJ`'s return value\n * @returns the singleton\n */\nexport function getGlobalSingleton<Prop extends keyof SentryCarrier>(\n  name: Prop,\n  creator: () => NonNullable<SentryCarrier[Prop]>,\n  obj = GLOBAL_OBJ,\n): NonNullable<SentryCarrier[Prop]> {\n  const __SENTRY__ = (obj.__SENTRY__ = obj.__SENTRY__ || {});\n  const carrier = (__SENTRY__[SDK_VERSION] = __SENTRY__[SDK_VERSION] || {});\n  // Note: We do not want to set `carrier.version` here, as this may be called before any `init` is called, e.g. for the default scopes\n  return carrier[name] || (carrier[name] = creator());\n}\n","export const DEFAULT_ENVIRONMENT = 'production';\n","import type { Client } from '../client';\nimport { getDefaultCurrentScope, getDefaultIsolationScope } from '../defaultScopes';\nimport { Scope } from '../scope';\nimport { isThenable } from '../utils-hoist/is';\nimport { getMainCarrier, getSentryCarrier } from './../carrier';\nimport type { AsyncContextStrategy } from './types';\n\ninterface Layer {\n  client?: Client;\n  scope: Scope;\n}\n\n/**\n * This is an object that holds a stack of scopes.\n */\nexport class AsyncContextStack {\n  private readonly _stack: [Layer, ...Layer[]];\n  private _isolationScope: Scope;\n\n  public constructor(scope?: Scope, isolationScope?: Scope) {\n    let assignedScope;\n    if (!scope) {\n      assignedScope = new Scope();\n    } else {\n      assignedScope = scope;\n    }\n\n    let assignedIsolationScope;\n    if (!isolationScope) {\n      assignedIsolationScope = new Scope();\n    } else {\n      assignedIsolationScope = isolationScope;\n    }\n\n    // scope stack for domains or the process\n    this._stack = [{ scope: assignedScope }];\n    this._isolationScope = assignedIsolationScope;\n  }\n\n  /**\n   * Fork a scope for the stack.\n   */\n  public withScope<T>(callback: (scope: Scope) => T): T {\n    const scope = this._pushScope();\n\n    let maybePromiseResult: T;\n    try {\n      maybePromiseResult = callback(scope);\n    } catch (e) {\n      this._popScope();\n      throw e;\n    }\n\n    if (isThenable(maybePromiseResult)) {\n      // @ts-expect-error - isThenable returns the wrong type\n      return maybePromiseResult.then(\n        res => {\n          this._popScope();\n          return res;\n        },\n        e => {\n          this._popScope();\n          throw e;\n        },\n      );\n    }\n\n    this._popScope();\n    return maybePromiseResult;\n  }\n\n  /**\n   * Get the client of the stack.\n   */\n  public getClient<C extends Client>(): C | undefined {\n    return this.getStackTop().client as C;\n  }\n\n  /**\n   * Returns the scope of the top stack.\n   */\n  public getScope(): Scope {\n    return this.getStackTop().scope;\n  }\n\n  /**\n   * Get the isolation scope for the stack.\n   */\n  public getIsolationScope(): Scope {\n    return this._isolationScope;\n  }\n\n  /**\n   * Returns the topmost scope layer in the order domain > local > process.\n   */\n  public getStackTop(): Layer {\n    return this._stack[this._stack.length - 1] as Layer;\n  }\n\n  /**\n   * Push a scope to the stack.\n   */\n  private _pushScope(): Scope {\n    // We want to clone the content of prev scope\n    const scope = this.getScope().clone();\n    this._stack.push({\n      client: this.getClient(),\n      scope,\n    });\n    return scope;\n  }\n\n  /**\n   * Pop a scope from the stack.\n   */\n  private _popScope(): boolean {\n    if (this._stack.length <= 1) return false;\n    return !!this._stack.pop();\n  }\n}\n\n/**\n * Get the global async context stack.\n * This will be removed during the v8 cycle and is only here to make migration easier.\n */\nfunction getAsyncContextStack(): AsyncContextStack {\n  const registry = getMainCarrier();\n  const sentry = getSentryCarrier(registry);\n\n  return (sentry.stack = sentry.stack || new AsyncContextStack(getDefaultCurrentScope(), getDefaultIsolationScope()));\n}\n\nfunction withScope<T>(callback: (scope: Scope) => T): T {\n  return getAsyncContextStack().withScope(callback);\n}\n\nfunction withSetScope<T>(scope: Scope, callback: (scope: Scope) => T): T {\n  const stack = getAsyncContextStack() as AsyncContextStack;\n  return stack.withScope(() => {\n    stack.getStackTop().scope = scope;\n    return callback(scope);\n  });\n}\n\nfunction withIsolationScope<T>(callback: (isolationScope: Scope) => T): T {\n  return getAsyncContextStack().withScope(() => {\n    return callback(getAsyncContextStack().getIsolationScope());\n  });\n}\n\n/**\n * Get the stack-based async context strategy.\n */\nexport function getStackAsyncContextStrategy(): AsyncContextStrategy {\n  return {\n    withIsolationScope,\n    withScope,\n    withSetScope,\n    withSetIsolationScope: <T>(_isolationScope: Scope, callback: (isolationScope: Scope) => T) => {\n      return withIsolationScope(callback);\n    },\n    getCurrentScope: () => getAsyncContextStack().getScope(),\n    getIsolationScope: () => getAsyncContextStack().getIsolationScope(),\n  };\n}\n","import { getGlobalSingleton } from './carrier';\nimport { Scope } from './scope';\n\n/** Get the default current scope. */\nexport function getDefaultCurrentScope(): Scope {\n  return getGlobalSingleton('defaultCurrentScope', () => new Scope());\n}\n\n/** Get the default isolation scope. */\nexport function getDefaultIsolationScope(): Scope {\n  return getGlobalSingleton('defaultIsolationScope', () => new Scope());\n}\n","import type { Carrier } from './../carrier';\nimport { getMainCarrier, getSentryCarrier } from './../carrier';\nimport { getStackAsyncContextStrategy } from './stackStrategy';\nimport type { AsyncContextStrategy } from './types';\n\n/**\n * @private Private API with no semver guarantees!\n *\n * Sets the global async context strategy\n */\nexport function setAsyncContextStrategy(strategy: AsyncContextStrategy | undefined): void {\n  // Get main carrier (global for every environment)\n  const registry = getMainCarrier();\n  const sentry = getSentryCarrier(registry);\n  sentry.acs = strategy;\n}\n\n/**\n * Get the current async context strategy.\n * If none has been setup, the default will be used.\n */\nexport function getAsyncContextStrategy(carrier: Carrier): AsyncContextStrategy {\n  const sentry = getSentryCarrier(carrier);\n\n  if (sentry.acs) {\n    return sentry.acs;\n  }\n\n  // Otherwise, use the default one (stack)\n  return getStackAsyncContextStrategy();\n}\n","import { getAsyncContextStrategy } from './asyncContext';\nimport { getGlobalSingleton, getMainCarrier } from './carrier';\nimport type { Client } from './client';\nimport { Scope } from './scope';\nimport type { TraceContext } from './types-hoist';\nimport { generateSpanId } from './utils-hoist';\nimport { dropUndefinedKeys } from './utils-hoist/object';\n\n/**\n * Get the currently active scope.\n */\nexport function getCurrentScope(): Scope {\n  const carrier = getMainCarrier();\n  const acs = getAsyncContextStrategy(carrier);\n  return acs.getCurrentScope();\n}\n\n/**\n * Get the currently active isolation scope.\n * The isolation scope is active for the current execution context.\n */\nexport function getIsolationScope(): Scope {\n  const carrier = getMainCarrier();\n  const acs = getAsyncContextStrategy(carrier);\n  return acs.getIsolationScope();\n}\n\n/**\n * Get the global scope.\n * This scope is applied to _all_ events.\n */\nexport function getGlobalScope(): Scope {\n  return getGlobalSingleton('globalScope', () => new Scope());\n}\n\n/**\n * Creates a new scope with and executes the given operation within.\n * The scope is automatically removed once the operation\n * finishes or throws.\n */\nexport function withScope<T>(callback: (scope: Scope) => T): T;\n/**\n * Set the given scope as the active scope in the callback.\n */\nexport function withScope<T>(scope: Scope | undefined, callback: (scope: Scope) => T): T;\n/**\n * Either creates a new active scope, or sets the given scope as active scope in the given callback.\n */\nexport function withScope<T>(\n  ...rest: [callback: (scope: Scope) => T] | [scope: Scope | undefined, callback: (scope: Scope) => T]\n): T {\n  const carrier = getMainCarrier();\n  const acs = getAsyncContextStrategy(carrier);\n\n  // If a scope is defined, we want to make this the active scope instead of the default one\n  if (rest.length === 2) {\n    const [scope, callback] = rest;\n\n    if (!scope) {\n      return acs.withScope(callback);\n    }\n\n    return acs.withSetScope(scope, callback);\n  }\n\n  return acs.withScope(rest[0]);\n}\n\n/**\n * Attempts to fork the current isolation scope and the current scope based on the current async context strategy. If no\n * async context strategy is set, the isolation scope and the current scope will not be forked (this is currently the\n * case, for example, in the browser).\n *\n * Usage of this function in environments without async context strategy is discouraged and may lead to unexpected behaviour.\n *\n * This function is intended for Sentry SDK and SDK integration development. It is not recommended to be used in \"normal\"\n * applications directly because it comes with pitfalls. Use at your own risk!\n */\nexport function withIsolationScope<T>(callback: (isolationScope: Scope) => T): T;\n/**\n * Set the provided isolation scope as active in the given callback. If no\n * async context strategy is set, the isolation scope and the current scope will not be forked (this is currently the\n * case, for example, in the browser).\n *\n * Usage of this function in environments without async context strategy is discouraged and may lead to unexpected behaviour.\n *\n * This function is intended for Sentry SDK and SDK integration development. It is not recommended to be used in \"normal\"\n * applications directly because it comes with pitfalls. Use at your own risk!\n *\n * If you pass in `undefined` as a scope, it will fork a new isolation scope, the same as if no scope is passed.\n */\nexport function withIsolationScope<T>(isolationScope: Scope | undefined, callback: (isolationScope: Scope) => T): T;\n/**\n * Either creates a new active isolation scope, or sets the given isolation scope as active scope in the given callback.\n */\nexport function withIsolationScope<T>(\n  ...rest:\n    | [callback: (isolationScope: Scope) => T]\n    | [isolationScope: Scope | undefined, callback: (isolationScope: Scope) => T]\n): T {\n  const carrier = getMainCarrier();\n  const acs = getAsyncContextStrategy(carrier);\n\n  // If a scope is defined, we want to make this the active scope instead of the default one\n  if (rest.length === 2) {\n    const [isolationScope, callback] = rest;\n\n    if (!isolationScope) {\n      return acs.withIsolationScope(callback);\n    }\n\n    return acs.withSetIsolationScope(isolationScope, callback);\n  }\n\n  return acs.withIsolationScope(rest[0]);\n}\n\n/**\n * Get the currently active client.\n */\nexport function getClient<C extends Client>(): C | undefined {\n  return getCurrentScope().getClient<C>();\n}\n\n/**\n * Get a trace context for the given scope.\n */\nexport function getTraceContextFromScope(scope: Scope): TraceContext {\n  const propagationContext = scope.getPropagationContext();\n\n  const { traceId, parentSpanId, propagationSpanId } = propagationContext;\n\n  const traceContext: TraceContext = dropUndefinedKeys({\n    trace_id: traceId,\n    span_id: propagationSpanId || generateSpanId(),\n    parent_span_id: parentSpanId,\n  });\n\n  return traceContext;\n}\n","declare const __DEBUG_BUILD__: boolean;\n\n/**\n * This serves as a build time flag that will be true by default, but false in non-debug builds or if users replace `__SENTRY_DEBUG__` in their generated code.\n *\n * ATTENTION: This constant must never cross package boundaries (i.e. be exported) to guarantee that it can be used for tree shaking.\n */\nexport const DEBUG_BUILD = __DEBUG_BUILD__;\n","import { getClient, getCurrentScope, getIsolationScope, withIsolationScope } from './currentScopes';\nimport { DEBUG_BUILD } from './debug-build';\nimport type { CaptureContext } from './scope';\nimport { closeSession, makeSession, updateSession } from './session';\nimport type {\n  CheckIn,\n  Event,\n  EventHint,\n  EventProcessor,\n  Extra,\n  Extras,\n  FinishedCheckIn,\n  MonitorConfig,\n  Primitive,\n  Session,\n  SessionContext,\n  SeverityLevel,\n  User,\n} from './types-hoist';\nimport { isThenable } from './utils-hoist/is';\nimport { logger } from './utils-hoist/logger';\nimport { uuid4 } from './utils-hoist/misc';\nimport { timestampInSeconds } from './utils-hoist/time';\nimport { GLOBAL_OBJ } from './utils-hoist/worldwide';\nimport type { ExclusiveEventHintOrCaptureContext } from './utils/prepareEvent';\nimport { parseEventHintOrCaptureContext } from './utils/prepareEvent';\n\n/**\n * Captures an exception event and sends it to Sentry.\n *\n * @param exception The exception to capture.\n * @param hint Optional additional data to attach to the Sentry event.\n * @returns the id of the captured Sentry event.\n */\nexport function captureException(exception: unknown, hint?: ExclusiveEventHintOrCaptureContext): string {\n  return getCurrentScope().captureException(exception, parseEventHintOrCaptureContext(hint));\n}\n\n/**\n * Captures a message event and sends it to Sentry.\n *\n * @param message The message to send to Sentry.\n * @param captureContext Define the level of the message or pass in additional data to attach to the message.\n * @returns the id of the captured message.\n */\nexport function captureMessage(message: string, captureContext?: CaptureContext | SeverityLevel): string {\n  // This is necessary to provide explicit scopes upgrade, without changing the original\n  // arity of the `captureMessage(message, level)` method.\n  const level = typeof captureContext === 'string' ? captureContext : undefined;\n  const context = typeof captureContext !== 'string' ? { captureContext } : undefined;\n  return getCurrentScope().captureMessage(message, level, context);\n}\n\n/**\n * Captures a manually created event and sends it to Sentry.\n *\n * @param event The event to send to Sentry.\n * @param hint Optional additional data to attach to the Sentry event.\n * @returns the id of the captured event.\n */\nexport function captureEvent(event: Event, hint?: EventHint): string {\n  return getCurrentScope().captureEvent(event, hint);\n}\n\n/**\n * Sets context data with the given name.\n * @param name of the context\n * @param context Any kind of data. This data will be normalized.\n */\nexport function setContext(name: string, context: { [key: string]: unknown } | null): void {\n  getIsolationScope().setContext(name, context);\n}\n\n/**\n * Set an object that will be merged sent as extra data with the event.\n * @param extras Extras object to merge into current context.\n */\nexport function setExtras(extras: Extras): void {\n  getIsolationScope().setExtras(extras);\n}\n\n/**\n * Set key:value that will be sent as extra data with the event.\n * @param key String of extra\n * @param extra Any kind of data. This data will be normalized.\n */\nexport function setExtra(key: string, extra: Extra): void {\n  getIsolationScope().setExtra(key, extra);\n}\n\n/**\n * Set an object that will be merged sent as tags data with the event.\n * @param tags Tags context object to merge into current context.\n */\nexport function setTags(tags: { [key: string]: Primitive }): void {\n  getIsolationScope().setTags(tags);\n}\n\n/**\n * Set key:value that will be sent as tags data with the event.\n *\n * Can also be used to unset a tag, by passing `undefined`.\n *\n * @param key String key of tag\n * @param value Value of tag\n */\nexport function setTag(key: string, value: Primitive): void {\n  getIsolationScope().setTag(key, value);\n}\n\n/**\n * Updates user context information for future events.\n *\n * @param user User context object to be set in the current context. Pass `null` to unset the user.\n */\nexport function setUser(user: User | null): void {\n  getIsolationScope().setUser(user);\n}\n\n/**\n * The last error event id of the isolation scope.\n *\n * Warning: This function really returns the last recorded error event id on the current\n * isolation scope. If you call this function after handling a certain error and another error\n * is captured in between, the last one is returned instead of the one you might expect.\n * Also, ids of events that were never sent to Sentry (for example because\n * they were dropped in `beforeSend`) could be returned.\n *\n * @returns The last event id of the isolation scope.\n */\nexport function lastEventId(): string | undefined {\n  return getIsolationScope().lastEventId();\n}\n\n/**\n * Create a cron monitor check in and send it to Sentry.\n *\n * @param checkIn An object that describes a check in.\n * @param upsertMonitorConfig An optional object that describes a monitor config. Use this if you want\n * to create a monitor automatically when sending a check in.\n */\nexport function captureCheckIn(checkIn: CheckIn, upsertMonitorConfig?: MonitorConfig): string {\n  const scope = getCurrentScope();\n  const client = getClient();\n  if (!client) {\n    DEBUG_BUILD && logger.warn('Cannot capture check-in. No client defined.');\n  } else if (!client.captureCheckIn) {\n    DEBUG_BUILD && logger.warn('Cannot capture check-in. Client does not support sending check-ins.');\n  } else {\n    return client.captureCheckIn(checkIn, upsertMonitorConfig, scope);\n  }\n\n  return uuid4();\n}\n\n/**\n * Wraps a callback with a cron monitor check in. The check in will be sent to Sentry when the callback finishes.\n *\n * @param monitorSlug The distinct slug of the monitor.\n * @param upsertMonitorConfig An optional object that describes a monitor config. Use this if you want\n * to create a monitor automatically when sending a check in.\n */\nexport function withMonitor<T>(\n  monitorSlug: CheckIn['monitorSlug'],\n  callback: () => T,\n  upsertMonitorConfig?: MonitorConfig,\n): T {\n  const checkInId = captureCheckIn({ monitorSlug, status: 'in_progress' }, upsertMonitorConfig);\n  const now = timestampInSeconds();\n\n  function finishCheckIn(status: FinishedCheckIn['status']): void {\n    captureCheckIn({ monitorSlug, status, checkInId, duration: timestampInSeconds() - now });\n  }\n\n  return withIsolationScope(() => {\n    let maybePromiseResult: T;\n    try {\n      maybePromiseResult = callback();\n    } catch (e) {\n      finishCheckIn('error');\n      throw e;\n    }\n\n    if (isThenable(maybePromiseResult)) {\n      Promise.resolve(maybePromiseResult).then(\n        () => {\n          finishCheckIn('ok');\n        },\n        e => {\n          finishCheckIn('error');\n          throw e;\n        },\n      );\n    } else {\n      finishCheckIn('ok');\n    }\n\n    return maybePromiseResult;\n  });\n}\n\n/**\n * Call `flush()` on the current client, if there is one. See {@link Client.flush}.\n *\n * @param timeout Maximum time in ms the client should wait to flush its event queue. Omitting this parameter will cause\n * the client to wait until all events are sent before resolving the promise.\n * @returns A promise which resolves to `true` if the queue successfully drains before the timeout, or `false` if it\n * doesn't (or if there's no client defined).\n */\nexport async function flush(timeout?: number): Promise<boolean> {\n  const client = getClient();\n  if (client) {\n    return client.flush(timeout);\n  }\n  DEBUG_BUILD && logger.warn('Cannot flush events. No client defined.');\n  return Promise.resolve(false);\n}\n\n/**\n * Call `close()` on the current client, if there is one. See {@link Client.close}.\n *\n * @param timeout Maximum time in ms the client should wait to flush its event queue before shutting down. Omitting this\n * parameter will cause the client to wait until all events are sent before disabling itself.\n * @returns A promise which resolves to `true` if the queue successfully drains before the timeout, or `false` if it\n * doesn't (or if there's no client defined).\n */\nexport async function close(timeout?: number): Promise<boolean> {\n  const client = getClient();\n  if (client) {\n    return client.close(timeout);\n  }\n  DEBUG_BUILD && logger.warn('Cannot flush events and disable SDK. No client defined.');\n  return Promise.resolve(false);\n}\n\n/**\n * Returns true if Sentry has been properly initialized.\n */\nexport function isInitialized(): boolean {\n  return !!getClient();\n}\n\n/** If the SDK is initialized & enabled. */\nexport function isEnabled(): boolean {\n  const client = getClient();\n  return client?.getOptions().enabled !== false && !!client?.getTransport();\n}\n\n/**\n * Add an event processor.\n * This will be added to the current isolation scope, ensuring any event that is processed in the current execution\n * context will have the processor applied.\n */\nexport function addEventProcessor(callback: EventProcessor): void {\n  getIsolationScope().addEventProcessor(callback);\n}\n\n/**\n * Start a session on the current isolation scope.\n *\n * @param context (optional) additional properties to be applied to the returned session object\n *\n * @returns the new active session\n */\nexport function startSession(context?: SessionContext): Session {\n  const isolationScope = getIsolationScope();\n  const currentScope = getCurrentScope();\n\n  // Will fetch userAgent if called from browser sdk\n  const { userAgent } = GLOBAL_OBJ.navigator || {};\n\n  const session = makeSession({\n    user: currentScope.getUser() || isolationScope.getUser(),\n    ...(userAgent && { userAgent }),\n    ...context,\n  });\n\n  // End existing session if there's one\n  const currentSession = isolationScope.getSession();\n  if (currentSession?.status === 'ok') {\n    updateSession(currentSession, { status: 'exited' });\n  }\n\n  endSession();\n\n  // Afterwards we set the new session on the scope\n  isolationScope.setSession(session);\n\n  return session;\n}\n\n/**\n * End the session on the current isolation scope.\n */\nexport function endSession(): void {\n  const isolationScope = getIsolationScope();\n  const currentScope = getCurrentScope();\n\n  const session = currentScope.getSession() || isolationScope.getSession();\n  if (session) {\n    closeSession(session);\n  }\n  _sendSessionUpdate();\n\n  // the session is over; take it off of the scope\n  isolationScope.setSession();\n}\n\n/**\n * Sends the current Session on the scope\n */\nfunction _sendSessionUpdate(): void {\n  const isolationScope = getIsolationScope();\n  const client = getClient();\n  const session = isolationScope.getSession();\n  if (session && client) {\n    client.captureSession(session);\n  }\n}\n\n/**\n * Sends the current session on the scope to Sentry\n *\n * @param end If set the session will be marked as exited and removed from the scope.\n *            Defaults to `false`.\n */\nexport function captureSession(end: boolean = false): void {\n  // both send the update and pull the session from the scope\n  if (end) {\n    endSession();\n    return;\n  }\n\n  // only send the update\n  _sendSessionUpdate();\n}\n","import type { Client } from './client';\nimport { getClient } from './currentScopes';\nimport { DEBUG_BUILD } from './debug-build';\nimport type { Event, EventHint, Integration, IntegrationFn, Options } from './types-hoist';\nimport { logger } from './utils-hoist/logger';\n\nexport const installedIntegrations: string[] = [];\n\n/** Map of integrations assigned to a client */\nexport type IntegrationIndex = {\n  [key: string]: Integration;\n};\n\ntype IntegrationWithDefaultInstance = Integration & { isDefaultInstance?: true };\n\n/**\n * Remove duplicates from the given array, preferring the last instance of any duplicate. Not guaranteed to\n * preserve the order of integrations in the array.\n *\n * @private\n */\nfunction filterDuplicates(integrations: Integration[]): Integration[] {\n  const integrationsByName: { [key: string]: Integration } = {};\n\n  integrations.forEach((currentInstance: IntegrationWithDefaultInstance) => {\n    const { name } = currentInstance;\n\n    const existingInstance: IntegrationWithDefaultInstance | undefined = integrationsByName[name];\n\n    // We want integrations later in the array to overwrite earlier ones of the same type, except that we never want a\n    // default instance to overwrite an existing user instance\n    if (existingInstance && !existingInstance.isDefaultInstance && currentInstance.isDefaultInstance) {\n      return;\n    }\n\n    integrationsByName[name] = currentInstance;\n  });\n\n  return Object.values(integrationsByName);\n}\n\n/** Gets integrations to install */\nexport function getIntegrationsToSetup(options: Pick<Options, 'defaultIntegrations' | 'integrations'>): Integration[] {\n  const defaultIntegrations = options.defaultIntegrations || [];\n  const userIntegrations = options.integrations;\n\n  // We flag default instances, so that later we can tell them apart from any user-created instances of the same class\n  defaultIntegrations.forEach((integration: IntegrationWithDefaultInstance) => {\n    integration.isDefaultInstance = true;\n  });\n\n  let integrations: Integration[];\n\n  if (Array.isArray(userIntegrations)) {\n    integrations = [...defaultIntegrations, ...userIntegrations];\n  } else if (typeof userIntegrations === 'function') {\n    const resolvedUserIntegrations = userIntegrations(defaultIntegrations);\n    integrations = Array.isArray(resolvedUserIntegrations) ? resolvedUserIntegrations : [resolvedUserIntegrations];\n  } else {\n    integrations = defaultIntegrations;\n  }\n\n  return filterDuplicates(integrations);\n}\n\n/**\n * Given a list of integration instances this installs them all. When `withDefaults` is set to `true` then all default\n * integrations are added unless they were already provided before.\n * @param integrations array of integration instances\n * @param withDefault should enable default integrations\n */\nexport function setupIntegrations(client: Client, integrations: Integration[]): IntegrationIndex {\n  const integrationIndex: IntegrationIndex = {};\n\n  integrations.forEach((integration: Integration | undefined) => {\n    // guard against empty provided integrations\n    if (integration) {\n      setupIntegration(client, integration, integrationIndex);\n    }\n  });\n\n  return integrationIndex;\n}\n\n/**\n * Execute the `afterAllSetup` hooks of the given integrations.\n */\nexport function afterSetupIntegrations(client: Client, integrations: Integration[]): void {\n  for (const integration of integrations) {\n    // guard against empty provided integrations\n    if (integration?.afterAllSetup) {\n      integration.afterAllSetup(client);\n    }\n  }\n}\n\n/** Setup a single integration.  */\nexport function setupIntegration(client: Client, integration: Integration, integrationIndex: IntegrationIndex): void {\n  if (integrationIndex[integration.name]) {\n    DEBUG_BUILD && logger.log(`Integration skipped because it was already installed: ${integration.name}`);\n    return;\n  }\n  integrationIndex[integration.name] = integration;\n\n  // `setupOnce` is only called the first time\n  if (installedIntegrations.indexOf(integration.name) === -1 && typeof integration.setupOnce === 'function') {\n    integration.setupOnce();\n    installedIntegrations.push(integration.name);\n  }\n\n  // `setup` is run for each client\n  if (integration.setup && typeof integration.setup === 'function') {\n    integration.setup(client);\n  }\n\n  if (typeof integration.preprocessEvent === 'function') {\n    const callback = integration.preprocessEvent.bind(integration) as typeof integration.preprocessEvent;\n    client.on('preprocessEvent', (event, hint) => callback(event, hint, client));\n  }\n\n  if (typeof integration.processEvent === 'function') {\n    const callback = integration.processEvent.bind(integration) as typeof integration.processEvent;\n\n    const processor = Object.assign((event: Event, hint: EventHint) => callback(event, hint, client), {\n      id: integration.name,\n    });\n\n    client.addEventProcessor(processor);\n  }\n\n  DEBUG_BUILD && logger.log(`Integration installed: ${integration.name}`);\n}\n\n/** Add an integration to the current scope's client. */\nexport function addIntegration(integration: Integration): void {\n  const client = getClient();\n\n  if (!client) {\n    DEBUG_BUILD && logger.warn(`Cannot add integration \"${integration.name}\" because no SDK Client is available.`);\n    return;\n  }\n\n  client.addIntegration(integration);\n}\n\n/**\n * Define an integration function that can be used to create an integration instance.\n * Note that this by design hides the implementation details of the integration, as they are considered internal.\n */\nexport function defineIntegration<Fn extends IntegrationFn>(fn: Fn): (...args: Parameters<Fn>) => Integration {\n  return fn;\n}\n","import { defineIntegration } from '../integration';\nimport type { Event, Exception, IntegrationFn, StackFrame } from '../types-hoist';\n\nimport { DEBUG_BUILD } from '../debug-build';\nimport { logger } from '../utils-hoist/logger';\nimport { getFramesFromEvent } from '../utils-hoist/stacktrace';\n\nconst INTEGRATION_NAME = 'Dedupe';\n\nconst _dedupeIntegration = (() => {\n  let previousEvent: Event | undefined;\n\n  return {\n    name: INTEGRATION_NAME,\n    processEvent(currentEvent) {\n      // We want to ignore any non-error type events, e.g. transactions or replays\n      // These should never be deduped, and also not be compared against as _previousEvent.\n      if (currentEvent.type) {\n        return currentEvent;\n      }\n\n      // Juuust in case something goes wrong\n      try {\n        if (_shouldDropEvent(currentEvent, previousEvent)) {\n          DEBUG_BUILD && logger.warn('Event dropped due to being a duplicate of previously captured event.');\n          return null;\n        }\n      } catch (_oO) {} // eslint-disable-line no-empty\n\n      return (previousEvent = currentEvent);\n    },\n  };\n}) satisfies IntegrationFn;\n\n/**\n * Deduplication filter.\n */\nexport const dedupeIntegration = defineIntegration(_dedupeIntegration);\n\n/** only exported for tests. */\nexport function _shouldDropEvent(currentEvent: Event, previousEvent?: Event): boolean {\n  if (!previousEvent) {\n    return false;\n  }\n\n  if (_isSameMessageEvent(currentEvent, previousEvent)) {\n    return true;\n  }\n\n  if (_isSameExceptionEvent(currentEvent, previousEvent)) {\n    return true;\n  }\n\n  return false;\n}\n\nfunction _isSameMessageEvent(currentEvent: Event, previousEvent: Event): boolean {\n  const currentMessage = currentEvent.message;\n  const previousMessage = previousEvent.message;\n\n  // If neither event has a message property, they were both exceptions, so bail out\n  if (!currentMessage && !previousMessage) {\n    return false;\n  }\n\n  // If only one event has a stacktrace, but not the other one, they are not the same\n  if ((currentMessage && !previousMessage) || (!currentMessage && previousMessage)) {\n    return false;\n  }\n\n  if (currentMessage !== previousMessage) {\n    return false;\n  }\n\n  if (!_isSameFingerprint(currentEvent, previousEvent)) {\n    return false;\n  }\n\n  if (!_isSameStacktrace(currentEvent, previousEvent)) {\n    return false;\n  }\n\n  return true;\n}\n\nfunction _isSameExceptionEvent(currentEvent: Event, previousEvent: Event): boolean {\n  const previousException = _getExceptionFromEvent(previousEvent);\n  const currentException = _getExceptionFromEvent(currentEvent);\n\n  if (!previousException || !currentException) {\n    return false;\n  }\n\n  if (previousException.type !== currentException.type || previousException.value !== currentException.value) {\n    return false;\n  }\n\n  if (!_isSameFingerprint(currentEvent, previousEvent)) {\n    return false;\n  }\n\n  if (!_isSameStacktrace(currentEvent, previousEvent)) {\n    return false;\n  }\n\n  return true;\n}\n\nfunction _isSameStacktrace(currentEvent: Event, previousEvent: Event): boolean {\n  let currentFrames = getFramesFromEvent(currentEvent);\n  let previousFrames = getFramesFromEvent(previousEvent);\n\n  // If neither event has a stacktrace, they are assumed to be the same\n  if (!currentFrames && !previousFrames) {\n    return true;\n  }\n\n  // If only one event has a stacktrace, but not the other one, they are not the same\n  if ((currentFrames && !previousFrames) || (!currentFrames && previousFrames)) {\n    return false;\n  }\n\n  currentFrames = currentFrames as StackFrame[];\n  previousFrames = previousFrames as StackFrame[];\n\n  // If number of frames differ, they are not the same\n  if (previousFrames.length !== currentFrames.length) {\n    return false;\n  }\n\n  // Otherwise, compare the two\n  for (let i = 0; i < previousFrames.length; i++) {\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    const frameA = previousFrames[i]!;\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    const frameB = currentFrames[i]!;\n\n    if (\n      frameA.filename !== frameB.filename ||\n      frameA.lineno !== frameB.lineno ||\n      frameA.colno !== frameB.colno ||\n      frameA.function !== frameB.function\n    ) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nfunction _isSameFingerprint(currentEvent: Event, previousEvent: Event): boolean {\n  let currentFingerprint = currentEvent.fingerprint;\n  let previousFingerprint = previousEvent.fingerprint;\n\n  // If neither event has a fingerprint, they are assumed to be the same\n  if (!currentFingerprint && !previousFingerprint) {\n    return true;\n  }\n\n  // If only one event has a fingerprint, but not the other one, they are not the same\n  if ((currentFingerprint && !previousFingerprint) || (!currentFingerprint && previousFingerprint)) {\n    return false;\n  }\n\n  currentFingerprint = currentFingerprint as string[];\n  previousFingerprint = previousFingerprint as string[];\n\n  // Otherwise, compare the two\n  try {\n    return !!(currentFingerprint.join('') === previousFingerprint.join(''));\n  } catch (_oO) {\n    return false;\n  }\n}\n\nfunction _getExceptionFromEvent(event: Event): Exception | undefined {\n  return event.exception?.values && event.exception.values[0];\n}\n","import type { Event, IntegrationFn, StackFrame } from '../types-hoist';\n\nimport { DEBUG_BUILD } from '../debug-build';\nimport { defineIntegration } from '../integration';\nimport { logger } from '../utils-hoist/logger';\nimport { getEventDescription } from '../utils-hoist/misc';\nimport { stringMatchesSomePattern } from '../utils-hoist/string';\nimport { getPossibleEventMessages } from '../utils/eventUtils';\n\n// \"Script error.\" is hard coded into browsers for errors that it can't read.\n// this is the result of a script being pulled in from an external domain and CORS.\nconst DEFAULT_IGNORE_ERRORS = [\n  /^Script error\\.?$/,\n  /^Javascript error: Script error\\.? on line 0$/,\n  /^ResizeObserver loop completed with undelivered notifications.$/, // The browser logs this when a ResizeObserver handler takes a bit longer. Usually this is not an actual issue though. It indicates slowness.\n  /^Cannot redefine property: googletag$/, // This is thrown when google tag manager is used in combination with an ad blocker\n  /^Can't find variable: gmo$/, // Error from Google Search App https://issuetracker.google.com/issues/396043331\n  /^undefined is not an object \\(evaluating 'a\\.[A-Z]'\\)$/, // Random error that happens but not actionable or noticeable to end-users.\n  'can\\'t redefine non-configurable property \"solana\"', // Probably a browser extension or custom browser (Brave) throwing this error\n  \"vv().getRestrictions is not a function. (In 'vv().getRestrictions(1,a)', 'vv().getRestrictions' is undefined)\", // Error thrown by GTM, seemingly not affecting end-users\n  \"Can't find variable: _AutofillCallbackHandler\", // Unactionable error in instagram webview https://developers.facebook.com/community/threads/320013549791141/\n  /^Non-Error promise rejection captured with value: Object Not Found Matching Id:\\d+, MethodName:simulateEvent, ParamCount:\\d+$/, // unactionable error from CEFSharp, a .NET library that embeds chromium in .NET apps\n  /^Java exception was raised during method invocation$/, // error from Facebook Mobile browser (https://github.com/getsentry/sentry-javascript/issues/15065)\n];\n\n/** Options for the EventFilters integration */\nexport interface EventFiltersOptions {\n  allowUrls: Array<string | RegExp>;\n  denyUrls: Array<string | RegExp>;\n  ignoreErrors: Array<string | RegExp>;\n  ignoreTransactions: Array<string | RegExp>;\n  ignoreInternal: boolean;\n  disableErrorDefaults: boolean;\n}\n\nconst INTEGRATION_NAME = 'EventFilters';\n\nconst _eventFiltersIntegration = ((options: Partial<EventFiltersOptions> = {}) => {\n  return {\n    name: INTEGRATION_NAME,\n    processEvent(event, _hint, client) {\n      const clientOptions = client.getOptions();\n      const mergedOptions = _mergeOptions(options, clientOptions);\n      return _shouldDropEvent(event, mergedOptions) ? null : event;\n    },\n  };\n}) satisfies IntegrationFn;\n\n/**\n * An integration that filters out events (errors and transactions) based on:\n *\n * - (Errors) A curated list of known low-value or irrelevant errors (see {@link DEFAULT_IGNORE_ERRORS})\n * - (Errors) A list of error messages or urls/filenames passed in via\n *   - Top level Sentry.init options (`ignoreErrors`, `denyUrls`, `allowUrls`)\n *   - The same options passed to the integration directly via @param options\n * - (Transactions/Spans) A list of root span (transaction) names passed in via\n *   - Top level Sentry.init option (`ignoreTransactions`)\n *   - The same option passed to the integration directly via @param options\n *\n * Events filtered by this integration will not be sent to Sentry.\n */\nexport const eventFiltersIntegration = defineIntegration(_eventFiltersIntegration);\n\n/**\n * An integration that filters out events (errors and transactions) based on:\n *\n * - (Errors) A curated list of known low-value or irrelevant errors (see {@link DEFAULT_IGNORE_ERRORS})\n * - (Errors) A list of error messages or urls/filenames passed in via\n *   - Top level Sentry.init options (`ignoreErrors`, `denyUrls`, `allowUrls`)\n *   - The same options passed to the integration directly via @param options\n * - (Transactions/Spans) A list of root span (transaction) names passed in via\n *   - Top level Sentry.init option (`ignoreTransactions`)\n *   - The same option passed to the integration directly via @param options\n *\n * Events filtered by this integration will not be sent to Sentry.\n *\n * @deprecated this integration was renamed and will be removed in a future major version.\n * Use `eventFiltersIntegration` instead.\n */\nexport const inboundFiltersIntegration = defineIntegration(((options: Partial<EventFiltersOptions> = {}) => {\n  return {\n    ...eventFiltersIntegration(options),\n    name: 'InboundFilters',\n  };\n}) satisfies IntegrationFn);\n\nfunction _mergeOptions(\n  internalOptions: Partial<EventFiltersOptions> = {},\n  clientOptions: Partial<EventFiltersOptions> = {},\n): Partial<EventFiltersOptions> {\n  return {\n    allowUrls: [...(internalOptions.allowUrls || []), ...(clientOptions.allowUrls || [])],\n    denyUrls: [...(internalOptions.denyUrls || []), ...(clientOptions.denyUrls || [])],\n    ignoreErrors: [\n      ...(internalOptions.ignoreErrors || []),\n      ...(clientOptions.ignoreErrors || []),\n      ...(internalOptions.disableErrorDefaults ? [] : DEFAULT_IGNORE_ERRORS),\n    ],\n    ignoreTransactions: [...(internalOptions.ignoreTransactions || []), ...(clientOptions.ignoreTransactions || [])],\n    ignoreInternal: internalOptions.ignoreInternal !== undefined ? internalOptions.ignoreInternal : true,\n  };\n}\n\nfunction _shouldDropEvent(event: Event, options: Partial<EventFiltersOptions>): boolean {\n  if (options.ignoreInternal && _isSentryError(event)) {\n    DEBUG_BUILD &&\n      logger.warn(`Event dropped due to being internal Sentry Error.\\nEvent: ${getEventDescription(event)}`);\n    return true;\n  }\n  if (_isIgnoredError(event, options.ignoreErrors)) {\n    DEBUG_BUILD &&\n      logger.warn(\n        `Event dropped due to being matched by \\`ignoreErrors\\` option.\\nEvent: ${getEventDescription(event)}`,\n      );\n    return true;\n  }\n  if (_isUselessError(event)) {\n    DEBUG_BUILD &&\n      logger.warn(\n        `Event dropped due to not having an error message, error type or stacktrace.\\nEvent: ${getEventDescription(\n          event,\n        )}`,\n      );\n    return true;\n  }\n  if (_isIgnoredTransaction(event, options.ignoreTransactions)) {\n    DEBUG_BUILD &&\n      logger.warn(\n        `Event dropped due to being matched by \\`ignoreTransactions\\` option.\\nEvent: ${getEventDescription(event)}`,\n      );\n    return true;\n  }\n  if (_isDeniedUrl(event, options.denyUrls)) {\n    DEBUG_BUILD &&\n      logger.warn(\n        `Event dropped due to being matched by \\`denyUrls\\` option.\\nEvent: ${getEventDescription(\n          event,\n        )}.\\nUrl: ${_getEventFilterUrl(event)}`,\n      );\n    return true;\n  }\n  if (!_isAllowedUrl(event, options.allowUrls)) {\n    DEBUG_BUILD &&\n      logger.warn(\n        `Event dropped due to not being matched by \\`allowUrls\\` option.\\nEvent: ${getEventDescription(\n          event,\n        )}.\\nUrl: ${_getEventFilterUrl(event)}`,\n      );\n    return true;\n  }\n  return false;\n}\n\nfunction _isIgnoredError(event: Event, ignoreErrors?: Array<string | RegExp>): boolean {\n  // If event.type, this is not an error\n  if (event.type || !ignoreErrors || !ignoreErrors.length) {\n    return false;\n  }\n\n  return getPossibleEventMessages(event).some(message => stringMatchesSomePattern(message, ignoreErrors));\n}\n\nfunction _isIgnoredTransaction(event: Event, ignoreTransactions?: Array<string | RegExp>): boolean {\n  if (event.type !== 'transaction' || !ignoreTransactions || !ignoreTransactions.length) {\n    return false;\n  }\n\n  const name = event.transaction;\n  return name ? stringMatchesSomePattern(name, ignoreTransactions) : false;\n}\n\nfunction _isDeniedUrl(event: Event, denyUrls?: Array<string | RegExp>): boolean {\n  if (!denyUrls?.length) {\n    return false;\n  }\n  const url = _getEventFilterUrl(event);\n  return !url ? false : stringMatchesSomePattern(url, denyUrls);\n}\n\nfunction _isAllowedUrl(event: Event, allowUrls?: Array<string | RegExp>): boolean {\n  if (!allowUrls?.length) {\n    return true;\n  }\n  const url = _getEventFilterUrl(event);\n  return !url ? true : stringMatchesSomePattern(url, allowUrls);\n}\n\nfunction _isSentryError(event: Event): boolean {\n  try {\n    // @ts-expect-error can't be a sentry error if undefined\n    return event.exception.values[0].type === 'SentryError';\n  } catch (e) {\n    // ignore\n  }\n  return false;\n}\n\nfunction _getLastValidUrl(frames: StackFrame[] = []): string | null {\n  for (let i = frames.length - 1; i >= 0; i--) {\n    const frame = frames[i];\n\n    if (frame && frame.filename !== '<anonymous>' && frame.filename !== '[native code]') {\n      return frame.filename || null;\n    }\n  }\n\n  return null;\n}\n\nfunction _getEventFilterUrl(event: Event): string | null {\n  try {\n    // If there are linked exceptions or exception aggregates we only want to match against the top frame of the \"root\" (the main exception)\n    // The root always comes last in linked exceptions\n    const rootException = [...(event.exception?.values ?? []).reverse()]?.find(\n      value => value.mechanism?.parent_id === undefined && value.stacktrace?.frames?.length,\n    );\n    const frames = rootException?.stacktrace?.frames;\n    return frames ? _getLastValidUrl(frames) : null;\n  } catch (oO) {\n    DEBUG_BUILD && logger.error(`Cannot extract url for event ${getEventDescription(event)}`);\n    return null;\n  }\n}\n\nfunction _isUselessError(event: Event): boolean {\n  if (event.type) {\n    // event is not an error\n    return false;\n  }\n\n  // We only want to consider events for dropping that actually have recorded exception values.\n  if (!event.exception?.values?.length) {\n    return false;\n  }\n\n  return (\n    // No top-level message\n    !event.message &&\n    // There are no exception values that have a stacktrace, a non-generic-Error type or value\n    !event.exception.values.some(value => value.stacktrace || (value.type && value.type !== 'Error') || value.value)\n  );\n}\n","import type { Client } from '../client';\nimport { getClient } from '../currentScopes';\nimport { defineIntegration } from '../integration';\nimport type { IntegrationFn, WrappedFunction } from '../types-hoist';\nimport { getOriginalFunction } from '../utils-hoist/object';\n\nlet originalFunctionToString: () => void;\n\nconst INTEGRATION_NAME = 'FunctionToString';\n\nconst SETUP_CLIENTS = new WeakMap<Client, boolean>();\n\nconst _functionToStringIntegration = (() => {\n  return {\n    name: INTEGRATION_NAME,\n    setupOnce() {\n      // eslint-disable-next-line @typescript-eslint/unbound-method\n      originalFunctionToString = Function.prototype.toString;\n\n      // intrinsics (like Function.prototype) might be immutable in some environments\n      // e.g. Node with --frozen-intrinsics, XS (an embedded JavaScript engine) or SES (a JavaScript proposal)\n      try {\n        Function.prototype.toString = function (this: WrappedFunction, ...args: unknown[]): string {\n          const originalFunction = getOriginalFunction(this);\n          const context =\n            SETUP_CLIENTS.has(getClient() as Client) && originalFunction !== undefined ? originalFunction : this;\n          return originalFunctionToString.apply(context, args);\n        };\n      } catch {\n        // ignore errors here, just don't patch this\n      }\n    },\n    setup(client) {\n      SETUP_CLIENTS.set(client, true);\n    },\n  };\n}) satisfies IntegrationFn;\n\n/**\n * Patch toString calls to return proper name for wrapped functions.\n *\n * ```js\n * Sentry.init({\n *   integrations: [\n *     functionToStringIntegration(),\n *   ],\n * });\n * ```\n */\nexport const functionToStringIntegration = defineIntegration(_functionToStringIntegration);\n","import type { Scope } from '../scope';\nimport type { Span } from '../types-hoist';\nimport { addNonEnumerableProperty } from '../utils-hoist/object';\n\nconst SCOPE_SPAN_FIELD = '_sentrySpan';\n\ntype ScopeWithMaybeSpan = Scope & {\n  [SCOPE_SPAN_FIELD]?: Span;\n};\n\n/**\n * Set the active span for a given scope.\n * NOTE: This should NOT be used directly, but is only used internally by the trace methods.\n */\nexport function _setSpanForScope(scope: Scope, span: Span | undefined): void {\n  if (span) {\n    addNonEnumerableProperty(scope as ScopeWithMaybeSpan, SCOPE_SPAN_FIELD, span);\n  } else {\n    // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n    delete (scope as ScopeWithMaybeSpan)[SCOPE_SPAN_FIELD];\n  }\n}\n\n/**\n * Get the active span for a given scope.\n * NOTE: This should NOT be used directly, but is only used internally by the trace methods.\n */\nexport function _getSpanForScope(scope: ScopeWithMaybeSpan): Span | undefined {\n  return scope[SCOPE_SPAN_FIELD];\n}\n","/* eslint-disable max-lines */\nimport type { Client } from './client';\nimport { updateSession } from './session';\nimport type {\n  Attachment,\n  Breadcrumb,\n  Context,\n  Contexts,\n  DynamicSamplingContext,\n  Event,\n  EventHint,\n  EventProcessor,\n  Extra,\n  Extras,\n  Primitive,\n  PropagationContext,\n  RequestEventData,\n  Session,\n  SeverityLevel,\n  Span,\n  User,\n} from './types-hoist';\nimport { isPlainObject } from './utils-hoist/is';\nimport { logger } from './utils-hoist/logger';\nimport { uuid4 } from './utils-hoist/misc';\nimport { generateTraceId } from './utils-hoist/propagationContext';\nimport { dateTimestampInSeconds } from './utils-hoist/time';\nimport { merge } from './utils/merge';\nimport { _getSpanForScope, _setSpanForScope } from './utils/spanOnScope';\n\n/**\n * Default value for maximum number of breadcrumbs added to an event.\n */\nconst DEFAULT_MAX_BREADCRUMBS = 100;\n\n/**\n * A context to be used for capturing an event.\n * This can either be a Scope, or a partial ScopeContext,\n * or a callback that receives the current scope and returns a new scope to use.\n */\nexport type CaptureContext = Scope | Partial<ScopeContext> | ((scope: Scope) => Scope);\n\n/**\n * Data that can be converted to a Scope.\n */\nexport interface ScopeContext {\n  user: User;\n  level: SeverityLevel;\n  extra: Extras;\n  contexts: Contexts;\n  tags: { [key: string]: Primitive };\n  fingerprint: string[];\n  propagationContext: PropagationContext;\n}\n\nexport interface SdkProcessingMetadata {\n  [key: string]: unknown;\n  requestSession?: {\n    status: 'ok' | 'errored' | 'crashed';\n  };\n  normalizedRequest?: RequestEventData;\n  dynamicSamplingContext?: Partial<DynamicSamplingContext>;\n  capturedSpanScope?: Scope;\n  capturedSpanIsolationScope?: Scope;\n  spanCountBeforeProcessing?: number;\n  ipAddress?: string;\n}\n\n/**\n * Normalized data of the Scope, ready to be used.\n */\nexport interface ScopeData {\n  eventProcessors: EventProcessor[];\n  breadcrumbs: Breadcrumb[];\n  user: User;\n  tags: { [key: string]: Primitive };\n  extra: Extras;\n  contexts: Contexts;\n  attachments: Attachment[];\n  propagationContext: PropagationContext;\n  sdkProcessingMetadata: SdkProcessingMetadata;\n  fingerprint: string[];\n  level?: SeverityLevel;\n  transactionName?: string;\n  span?: Span;\n}\n\n/**\n * Holds additional event information.\n */\nexport class Scope {\n  /** Flag if notifying is happening. */\n  protected _notifyingListeners: boolean;\n\n  /** Callback for client to receive scope changes. */\n  protected _scopeListeners: Array<(scope: Scope) => void>;\n\n  /** Callback list that will be called during event processing. */\n  protected _eventProcessors: EventProcessor[];\n\n  /** Array of breadcrumbs. */\n  protected _breadcrumbs: Breadcrumb[];\n\n  /** User */\n  protected _user: User;\n\n  /** Tags */\n  protected _tags: { [key: string]: Primitive };\n\n  /** Extra */\n  protected _extra: Extras;\n\n  /** Contexts */\n  protected _contexts: Contexts;\n\n  /** Attachments */\n  protected _attachments: Attachment[];\n\n  /** Propagation Context for distributed tracing */\n  protected _propagationContext: PropagationContext;\n\n  /**\n   * A place to stash data which is needed at some point in the SDK's event processing pipeline but which shouldn't get\n   * sent to Sentry\n   */\n  protected _sdkProcessingMetadata: SdkProcessingMetadata;\n\n  /** Fingerprint */\n  protected _fingerprint?: string[];\n\n  /** Severity */\n  protected _level?: SeverityLevel;\n\n  /**\n   * Transaction Name\n   *\n   * IMPORTANT: The transaction name on the scope has nothing to do with root spans/transaction objects.\n   * It's purpose is to assign a transaction to the scope that's added to non-transaction events.\n   */\n  protected _transactionName?: string;\n\n  /** Session */\n  protected _session?: Session;\n\n  /** The client on this scope */\n  protected _client?: Client;\n\n  /** Contains the last event id of a captured event.  */\n  protected _lastEventId?: string;\n\n  // NOTE: Any field which gets added here should get added not only to the constructor but also to the `clone` method.\n\n  public constructor() {\n    this._notifyingListeners = false;\n    this._scopeListeners = [];\n    this._eventProcessors = [];\n    this._breadcrumbs = [];\n    this._attachments = [];\n    this._user = {};\n    this._tags = {};\n    this._extra = {};\n    this._contexts = {};\n    this._sdkProcessingMetadata = {};\n    this._propagationContext = {\n      traceId: generateTraceId(),\n      sampleRand: Math.random(),\n    };\n  }\n\n  /**\n   * Clone all data from this scope into a new scope.\n   */\n  public clone(): Scope {\n    const newScope = new Scope();\n    newScope._breadcrumbs = [...this._breadcrumbs];\n    newScope._tags = { ...this._tags };\n    newScope._extra = { ...this._extra };\n    newScope._contexts = { ...this._contexts };\n    if (this._contexts.flags) {\n      // We need to copy the `values` array so insertions on a cloned scope\n      // won't affect the original array.\n      newScope._contexts.flags = {\n        values: [...this._contexts.flags.values],\n      };\n    }\n\n    newScope._user = this._user;\n    newScope._level = this._level;\n    newScope._session = this._session;\n    newScope._transactionName = this._transactionName;\n    newScope._fingerprint = this._fingerprint;\n    newScope._eventProcessors = [...this._eventProcessors];\n    newScope._attachments = [...this._attachments];\n    newScope._sdkProcessingMetadata = { ...this._sdkProcessingMetadata };\n    newScope._propagationContext = { ...this._propagationContext };\n    newScope._client = this._client;\n    newScope._lastEventId = this._lastEventId;\n\n    _setSpanForScope(newScope, _getSpanForScope(this));\n\n    return newScope;\n  }\n\n  /**\n   * Update the client assigned to this scope.\n   * Note that not every scope will have a client assigned - isolation scopes & the global scope will generally not have a client,\n   * as well as manually created scopes.\n   */\n  public setClient(client: Client | undefined): void {\n    this._client = client;\n  }\n\n  /**\n   * Set the ID of the last captured error event.\n   * This is generally only captured on the isolation scope.\n   */\n  public setLastEventId(lastEventId: string | undefined): void {\n    this._lastEventId = lastEventId;\n  }\n\n  /**\n   * Get the client assigned to this scope.\n   */\n  public getClient<C extends Client>(): C | undefined {\n    return this._client as C | undefined;\n  }\n\n  /**\n   * Get the ID of the last captured error event.\n   * This is generally only available on the isolation scope.\n   */\n  public lastEventId(): string | undefined {\n    return this._lastEventId;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public addScopeListener(callback: (scope: Scope) => void): void {\n    this._scopeListeners.push(callback);\n  }\n\n  /**\n   * Add an event processor that will be called before an event is sent.\n   */\n  public addEventProcessor(callback: EventProcessor): this {\n    this._eventProcessors.push(callback);\n    return this;\n  }\n\n  /**\n   * Set the user for this scope.\n   * Set to `null` to unset the user.\n   */\n  public setUser(user: User | null): this {\n    // If null is passed we want to unset everything, but still define keys,\n    // so that later down in the pipeline any existing values are cleared.\n    this._user = user || {\n      email: undefined,\n      id: undefined,\n      ip_address: undefined,\n      username: undefined,\n    };\n\n    if (this._session) {\n      updateSession(this._session, { user });\n    }\n\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * Get the user from this scope.\n   */\n  public getUser(): User | undefined {\n    return this._user;\n  }\n\n  /**\n   * Set an object that will be merged into existing tags on the scope,\n   * and will be sent as tags data with the event.\n   */\n  public setTags(tags: { [key: string]: Primitive }): this {\n    this._tags = {\n      ...this._tags,\n      ...tags,\n    };\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * Set a single tag that will be sent as tags data with the event.\n   */\n  public setTag(key: string, value: Primitive): this {\n    this._tags = { ...this._tags, [key]: value };\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * Set an object that will be merged into existing extra on the scope,\n   * and will be sent as extra data with the event.\n   */\n  public setExtras(extras: Extras): this {\n    this._extra = {\n      ...this._extra,\n      ...extras,\n    };\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * Set a single key:value extra entry that will be sent as extra data with the event.\n   */\n  public setExtra(key: string, extra: Extra): this {\n    this._extra = { ...this._extra, [key]: extra };\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * Sets the fingerprint on the scope to send with the events.\n   * @param {string[]} fingerprint Fingerprint to group events in Sentry.\n   */\n  public setFingerprint(fingerprint: string[]): this {\n    this._fingerprint = fingerprint;\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * Sets the level on the scope for future events.\n   */\n  public setLevel(level: SeverityLevel): this {\n    this._level = level;\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * Sets the transaction name on the scope so that the name of e.g. taken server route or\n   * the page location is attached to future events.\n   *\n   * IMPORTANT: Calling this function does NOT change the name of the currently active\n   * root span. If you want to change the name of the active root span, use\n   * `Sentry.updateSpanName(rootSpan, 'new name')` instead.\n   *\n   * By default, the SDK updates the scope's transaction name automatically on sensible\n   * occasions, such as a page navigation or when handling a new request on the server.\n   */\n  public setTransactionName(name?: string): this {\n    this._transactionName = name;\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * Sets context data with the given name.\n   * Data passed as context will be normalized. You can also pass `null` to unset the context.\n   * Note that context data will not be merged - calling `setContext` will overwrite an existing context with the same key.\n   */\n  public setContext(key: string, context: Context | null): this {\n    if (context === null) {\n      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n      delete this._contexts[key];\n    } else {\n      this._contexts[key] = context;\n    }\n\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * Set the session for the scope.\n   */\n  public setSession(session?: Session): this {\n    if (!session) {\n      delete this._session;\n    } else {\n      this._session = session;\n    }\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * Get the session from the scope.\n   */\n  public getSession(): Session | undefined {\n    return this._session;\n  }\n\n  /**\n   * Updates the scope with provided data. Can work in three variations:\n   * - plain object containing updatable attributes\n   * - Scope instance that'll extract the attributes from\n   * - callback function that'll receive the current scope as an argument and allow for modifications\n   */\n  public update(captureContext?: CaptureContext): this {\n    if (!captureContext) {\n      return this;\n    }\n\n    const scopeToMerge = typeof captureContext === 'function' ? captureContext(this) : captureContext;\n\n    const scopeInstance =\n      scopeToMerge instanceof Scope\n        ? scopeToMerge.getScopeData()\n        : isPlainObject(scopeToMerge)\n          ? (captureContext as ScopeContext)\n          : undefined;\n\n    const { tags, extra, user, contexts, level, fingerprint = [], propagationContext } = scopeInstance || {};\n\n    this._tags = { ...this._tags, ...tags };\n    this._extra = { ...this._extra, ...extra };\n    this._contexts = { ...this._contexts, ...contexts };\n\n    if (user && Object.keys(user).length) {\n      this._user = user;\n    }\n\n    if (level) {\n      this._level = level;\n    }\n\n    if (fingerprint.length) {\n      this._fingerprint = fingerprint;\n    }\n\n    if (propagationContext) {\n      this._propagationContext = propagationContext;\n    }\n\n    return this;\n  }\n\n  /**\n   * Clears the current scope and resets its properties.\n   * Note: The client will not be cleared.\n   */\n  public clear(): this {\n    // client is not cleared here on purpose!\n    this._breadcrumbs = [];\n    this._tags = {};\n    this._extra = {};\n    this._user = {};\n    this._contexts = {};\n    this._level = undefined;\n    this._transactionName = undefined;\n    this._fingerprint = undefined;\n    this._session = undefined;\n    _setSpanForScope(this, undefined);\n    this._attachments = [];\n    this.setPropagationContext({ traceId: generateTraceId(), sampleRand: Math.random() });\n\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * Adds a breadcrumb to the scope.\n   * By default, the last 100 breadcrumbs are kept.\n   */\n  public addBreadcrumb(breadcrumb: Breadcrumb, maxBreadcrumbs?: number): this {\n    const maxCrumbs = typeof maxBreadcrumbs === 'number' ? maxBreadcrumbs : DEFAULT_MAX_BREADCRUMBS;\n\n    // No data has been changed, so don't notify scope listeners\n    if (maxCrumbs <= 0) {\n      return this;\n    }\n\n    const mergedBreadcrumb = {\n      timestamp: dateTimestampInSeconds(),\n      ...breadcrumb,\n    };\n\n    this._breadcrumbs.push(mergedBreadcrumb);\n    if (this._breadcrumbs.length > maxCrumbs) {\n      this._breadcrumbs = this._breadcrumbs.slice(-maxCrumbs);\n      this._client?.recordDroppedEvent('buffer_overflow', 'log_item');\n    }\n\n    this._notifyScopeListeners();\n\n    return this;\n  }\n\n  /**\n   * Get the last breadcrumb of the scope.\n   */\n  public getLastBreadcrumb(): Breadcrumb | undefined {\n    return this._breadcrumbs[this._breadcrumbs.length - 1];\n  }\n\n  /**\n   * Clear all breadcrumbs from the scope.\n   */\n  public clearBreadcrumbs(): this {\n    this._breadcrumbs = [];\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * Add an attachment to the scope.\n   */\n  public addAttachment(attachment: Attachment): this {\n    this._attachments.push(attachment);\n    return this;\n  }\n\n  /**\n   * Clear all attachments from the scope.\n   */\n  public clearAttachments(): this {\n    this._attachments = [];\n    return this;\n  }\n\n  /**\n   * Get the data of this scope, which should be applied to an event during processing.\n   */\n  public getScopeData(): ScopeData {\n    return {\n      breadcrumbs: this._breadcrumbs,\n      attachments: this._attachments,\n      contexts: this._contexts,\n      tags: this._tags,\n      extra: this._extra,\n      user: this._user,\n      level: this._level,\n      fingerprint: this._fingerprint || [],\n      eventProcessors: this._eventProcessors,\n      propagationContext: this._propagationContext,\n      sdkProcessingMetadata: this._sdkProcessingMetadata,\n      transactionName: this._transactionName,\n      span: _getSpanForScope(this),\n    };\n  }\n\n  /**\n   * Add data which will be accessible during event processing but won't get sent to Sentry.\n   */\n  public setSDKProcessingMetadata(newData: SdkProcessingMetadata): this {\n    this._sdkProcessingMetadata = merge(this._sdkProcessingMetadata, newData, 2);\n    return this;\n  }\n\n  /**\n   * Add propagation context to the scope, used for distributed tracing\n   */\n  public setPropagationContext(context: PropagationContext): this {\n    this._propagationContext = context;\n    return this;\n  }\n\n  /**\n   * Get propagation context from the scope, used for distributed tracing\n   */\n  public getPropagationContext(): PropagationContext {\n    return this._propagationContext;\n  }\n\n  /**\n   * Capture an exception for this scope.\n   *\n   * @returns {string} The id of the captured Sentry event.\n   */\n  public captureException(exception: unknown, hint?: EventHint): string {\n    const eventId = hint?.event_id || uuid4();\n\n    if (!this._client) {\n      logger.warn('No client configured on scope - will not capture exception!');\n      return eventId;\n    }\n\n    const syntheticException = new Error('Sentry syntheticException');\n\n    this._client.captureException(\n      exception,\n      {\n        originalException: exception,\n        syntheticException,\n        ...hint,\n        event_id: eventId,\n      },\n      this,\n    );\n\n    return eventId;\n  }\n\n  /**\n   * Capture a message for this scope.\n   *\n   * @returns {string} The id of the captured message.\n   */\n  public captureMessage(message: string, level?: SeverityLevel, hint?: EventHint): string {\n    const eventId = hint?.event_id || uuid4();\n\n    if (!this._client) {\n      logger.warn('No client configured on scope - will not capture message!');\n      return eventId;\n    }\n\n    const syntheticException = new Error(message);\n\n    this._client.captureMessage(\n      message,\n      level,\n      {\n        originalException: message,\n        syntheticException,\n        ...hint,\n        event_id: eventId,\n      },\n      this,\n    );\n\n    return eventId;\n  }\n\n  /**\n   * Capture a Sentry event for this scope.\n   *\n   * @returns {string} The id of the captured event.\n   */\n  public captureEvent(event: Event, hint?: EventHint): string {\n    const eventId = hint?.event_id || uuid4();\n\n    if (!this._client) {\n      logger.warn('No client configured on scope - will not capture event!');\n      return eventId;\n    }\n\n    this._client.captureEvent(event, { ...hint, event_id: eventId }, this);\n\n    return eventId;\n  }\n\n  /**\n   * This will be called on every set call.\n   */\n  protected _notifyScopeListeners(): void {\n    // We need this check for this._notifyingListeners to be able to work on scope during updates\n    // If this check is not here we'll produce endless recursion when something is done with the scope\n    // during the callback.\n    if (!this._notifyingListeners) {\n      this._notifyingListeners = true;\n      this._scopeListeners.forEach(callback => {\n        callback(this);\n      });\n      this._notifyingListeners = false;\n    }\n  }\n}\n","/**\n * Use this attribute to represent the source of a span.\n * Should be one of: custom, url, route, view, component, task, unknown\n *\n */\nexport const SEMANTIC_ATTRIBUTE_SENTRY_SOURCE = 'sentry.source';\n\n/**\n * Attributes that holds the sample rate that was locally applied to a span.\n * If this attribute is not defined, it means that the span inherited a sampling decision.\n *\n * NOTE: Is only defined on root spans.\n */\nexport const SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE = 'sentry.sample_rate';\n\n/**\n * Use this attribute to represent the operation of a span.\n */\nexport const SEMANTIC_ATTRIBUTE_SENTRY_OP = 'sentry.op';\n\n/**\n * Use this attribute to represent the origin of a span.\n */\nexport const SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN = 'sentry.origin';\n\n/** The reason why an idle span finished. */\nexport const SEMANTIC_ATTRIBUTE_SENTRY_IDLE_SPAN_FINISH_REASON = 'sentry.idle_span_finish_reason';\n\n/** The unit of a measurement, which may be stored as a TimedEvent. */\nexport const SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_UNIT = 'sentry.measurement_unit';\n\n/** The value of a measurement, which may be stored as a TimedEvent. */\nexport const SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_VALUE = 'sentry.measurement_value';\n\n/**\n * A custom span name set by users guaranteed to be taken over any automatically\n * inferred name. This attribute is removed before the span is sent.\n *\n * @internal only meant for internal SDK usage\n * @hidden\n */\nexport const SEMANTIC_ATTRIBUTE_SENTRY_CUSTOM_SPAN_NAME = 'sentry.custom_span_name';\n\n/**\n * The id of the profile that this span occurred in.\n */\nexport const SEMANTIC_ATTRIBUTE_PROFILE_ID = 'sentry.profile_id';\n\nexport const SEMANTIC_ATTRIBUTE_EXCLUSIVE_TIME = 'sentry.exclusive_time';\n\nexport const SEMANTIC_ATTRIBUTE_CACHE_HIT = 'cache.hit';\n\nexport const SEMANTIC_ATTRIBUTE_CACHE_KEY = 'cache.key';\n\nexport const SEMANTIC_ATTRIBUTE_CACHE_ITEM_SIZE = 'cache.item_size';\n\n/** TODO: Remove these once we update to latest semantic conventions */\nexport const SEMANTIC_ATTRIBUTE_HTTP_REQUEST_METHOD = 'http.request.method';\nexport const SEMANTIC_ATTRIBUTE_URL_FULL = 'url.full';\n","import type { SerializedSession, Session, SessionContext, SessionStatus } from './types-hoist';\nimport { dropUndefinedKeys, timestampInSeconds, uuid4 } from './utils-hoist';\n\n/**\n * Creates a new `Session` object by setting certain default parameters. If optional @param context\n * is passed, the passed properties are applied to the session object.\n *\n * @param context (optional) additional properties to be applied to the returned session object\n *\n * @returns a new `Session` object\n */\nexport function makeSession(context?: Omit<SessionContext, 'started' | 'status'>): Session {\n  // Both timestamp and started are in seconds since the UNIX epoch.\n  const startingTime = timestampInSeconds();\n\n  const session: Session = {\n    sid: uuid4(),\n    init: true,\n    timestamp: startingTime,\n    started: startingTime,\n    duration: 0,\n    status: 'ok',\n    errors: 0,\n    ignoreDuration: false,\n    toJSON: () => sessionToJSON(session),\n  };\n\n  if (context) {\n    updateSession(session, context);\n  }\n\n  return session;\n}\n\n/**\n * Updates a session object with the properties passed in the context.\n *\n * Note that this function mutates the passed object and returns void.\n * (Had to do this instead of returning a new and updated session because closing and sending a session\n * makes an update to the session after it was passed to the sending logic.\n * @see Client.captureSession )\n *\n * @param session the `Session` to update\n * @param context the `SessionContext` holding the properties that should be updated in @param session\n */\n// eslint-disable-next-line complexity\nexport function updateSession(session: Session, context: SessionContext = {}): void {\n  if (context.user) {\n    if (!session.ipAddress && context.user.ip_address) {\n      session.ipAddress = context.user.ip_address;\n    }\n\n    if (!session.did && !context.did) {\n      session.did = context.user.id || context.user.email || context.user.username;\n    }\n  }\n\n  session.timestamp = context.timestamp || timestampInSeconds();\n\n  if (context.abnormal_mechanism) {\n    session.abnormal_mechanism = context.abnormal_mechanism;\n  }\n\n  if (context.ignoreDuration) {\n    session.ignoreDuration = context.ignoreDuration;\n  }\n  if (context.sid) {\n    // Good enough uuid validation. — Kamil\n    session.sid = context.sid.length === 32 ? context.sid : uuid4();\n  }\n  if (context.init !== undefined) {\n    session.init = context.init;\n  }\n  if (!session.did && context.did) {\n    session.did = `${context.did}`;\n  }\n  if (typeof context.started === 'number') {\n    session.started = context.started;\n  }\n  if (session.ignoreDuration) {\n    session.duration = undefined;\n  } else if (typeof context.duration === 'number') {\n    session.duration = context.duration;\n  } else {\n    const duration = session.timestamp - session.started;\n    session.duration = duration >= 0 ? duration : 0;\n  }\n  if (context.release) {\n    session.release = context.release;\n  }\n  if (context.environment) {\n    session.environment = context.environment;\n  }\n  if (!session.ipAddress && context.ipAddress) {\n    session.ipAddress = context.ipAddress;\n  }\n  if (!session.userAgent && context.userAgent) {\n    session.userAgent = context.userAgent;\n  }\n  if (typeof context.errors === 'number') {\n    session.errors = context.errors;\n  }\n  if (context.status) {\n    session.status = context.status;\n  }\n}\n\n/**\n * Closes a session by setting its status and updating the session object with it.\n * Internally calls `updateSession` to update the passed session object.\n *\n * Note that this function mutates the passed session (@see updateSession for explanation).\n *\n * @param session the `Session` object to be closed\n * @param status the `SessionStatus` with which the session was closed. If you don't pass a status,\n *               this function will keep the previously set status, unless it was `'ok'` in which case\n *               it is changed to `'exited'`.\n */\nexport function closeSession(session: Session, status?: Exclude<SessionStatus, 'ok'>): void {\n  let context = {};\n  if (status) {\n    context = { status };\n  } else if (session.status === 'ok') {\n    context = { status: 'exited' };\n  }\n\n  updateSession(session, context);\n}\n\n/**\n * Serializes a passed session object to a JSON object with a slightly different structure.\n * This is necessary because the Sentry backend requires a slightly different schema of a session\n * than the one the JS SDKs use internally.\n *\n * @param session the session to be converted\n *\n * @returns a JSON object of the passed session\n */\nfunction sessionToJSON(session: Session): SerializedSession {\n  return dropUndefinedKeys({\n    sid: `${session.sid}`,\n    init: session.init,\n    // Make sure that sec is converted to ms for date constructor\n    started: new Date(session.started * 1000).toISOString(),\n    timestamp: new Date(session.timestamp * 1000).toISOString(),\n    status: session.status,\n    errors: session.errors,\n    did: typeof session.did === 'number' || typeof session.did === 'string' ? `${session.did}` : undefined,\n    duration: session.duration,\n    abnormal_mechanism: session.abnormal_mechanism,\n    attrs: {\n      release: session.release,\n      environment: session.environment,\n      ip_address: session.ipAddress,\n      user_agent: session.userAgent,\n    },\n  });\n}\n","import type { DynamicSamplingContext } from '../types-hoist';\n\nimport { DEBUG_BUILD } from './debug-build';\nimport { isString } from './is';\nimport { logger } from './logger';\n\nexport const SENTRY_BAGGAGE_KEY_PREFIX = 'sentry-';\n\nexport const SENTRY_BAGGAGE_KEY_PREFIX_REGEX = /^sentry-/;\n\n/**\n * Max length of a serialized baggage string\n *\n * https://www.w3.org/TR/baggage/#limits\n */\nexport const MAX_BAGGAGE_STRING_LENGTH = 8192;\n\n/**\n * Takes a baggage header and turns it into Dynamic Sampling Context, by extracting all the \"sentry-\" prefixed values\n * from it.\n *\n * @param baggageHeader A very bread definition of a baggage header as it might appear in various frameworks.\n * @returns The Dynamic Sampling Context that was found on `baggageHeader`, if there was any, `undefined` otherwise.\n */\nexport function baggageHeaderToDynamicSamplingContext(\n  // Very liberal definition of what any incoming header might look like\n  baggageHeader: string | string[] | number | null | undefined | boolean,\n): Partial<DynamicSamplingContext> | undefined {\n  const baggageObject = parseBaggageHeader(baggageHeader);\n\n  if (!baggageObject) {\n    return undefined;\n  }\n\n  // Read all \"sentry-\" prefixed values out of the baggage object and put it onto a dynamic sampling context object.\n  const dynamicSamplingContext = Object.entries(baggageObject).reduce<Record<string, string>>((acc, [key, value]) => {\n    if (key.match(SENTRY_BAGGAGE_KEY_PREFIX_REGEX)) {\n      const nonPrefixedKey = key.slice(SENTRY_BAGGAGE_KEY_PREFIX.length);\n      acc[nonPrefixedKey] = value;\n    }\n    return acc;\n  }, {});\n\n  // Only return a dynamic sampling context object if there are keys in it.\n  // A keyless object means there were no sentry values on the header, which means that there is no DSC.\n  if (Object.keys(dynamicSamplingContext).length > 0) {\n    return dynamicSamplingContext as Partial<DynamicSamplingContext>;\n  } else {\n    return undefined;\n  }\n}\n\n/**\n * Turns a Dynamic Sampling Object into a baggage header by prefixing all the keys on the object with \"sentry-\".\n *\n * @param dynamicSamplingContext The Dynamic Sampling Context to turn into a header. For convenience and compatibility\n * with the `getDynamicSamplingContext` method on the Transaction class ,this argument can also be `undefined`. If it is\n * `undefined` the function will return `undefined`.\n * @returns a baggage header, created from `dynamicSamplingContext`, or `undefined` either if `dynamicSamplingContext`\n * was `undefined`, or if `dynamicSamplingContext` didn't contain any values.\n */\nexport function dynamicSamplingContextToSentryBaggageHeader(\n  // this also takes undefined for convenience and bundle size in other places\n  dynamicSamplingContext?: Partial<DynamicSamplingContext>,\n): string | undefined {\n  if (!dynamicSamplingContext) {\n    return undefined;\n  }\n\n  // Prefix all DSC keys with \"sentry-\" and put them into a new object\n  const sentryPrefixedDSC = Object.entries(dynamicSamplingContext).reduce<Record<string, string>>(\n    (acc, [dscKey, dscValue]) => {\n      if (dscValue) {\n        acc[`${SENTRY_BAGGAGE_KEY_PREFIX}${dscKey}`] = dscValue;\n      }\n      return acc;\n    },\n    {},\n  );\n\n  return objectToBaggageHeader(sentryPrefixedDSC);\n}\n\n/**\n * Take a baggage header and parse it into an object.\n */\nexport function parseBaggageHeader(\n  baggageHeader: string | string[] | number | null | undefined | boolean,\n): Record<string, string> | undefined {\n  if (!baggageHeader || (!isString(baggageHeader) && !Array.isArray(baggageHeader))) {\n    return undefined;\n  }\n\n  if (Array.isArray(baggageHeader)) {\n    // Combine all baggage headers into one object containing the baggage values so we can later read the Sentry-DSC-values from it\n    return baggageHeader.reduce<Record<string, string>>((acc, curr) => {\n      const currBaggageObject = baggageHeaderToObject(curr);\n      Object.entries(currBaggageObject).forEach(([key, value]) => {\n        acc[key] = value;\n      });\n      return acc;\n    }, {});\n  }\n\n  return baggageHeaderToObject(baggageHeader);\n}\n\n/**\n * Will parse a baggage header, which is a simple key-value map, into a flat object.\n *\n * @param baggageHeader The baggage header to parse.\n * @returns a flat object containing all the key-value pairs from `baggageHeader`.\n */\nfunction baggageHeaderToObject(baggageHeader: string): Record<string, string> {\n  return baggageHeader\n    .split(',')\n    .map(baggageEntry => baggageEntry.split('=').map(keyOrValue => decodeURIComponent(keyOrValue.trim())))\n    .reduce<Record<string, string>>((acc, [key, value]) => {\n      if (key && value) {\n        acc[key] = value;\n      }\n      return acc;\n    }, {});\n}\n\n/**\n * Turns a flat object (key-value pairs) into a baggage header, which is also just key-value pairs.\n *\n * @param object The object to turn into a baggage header.\n * @returns a baggage header string, or `undefined` if the object didn't have any values, since an empty baggage header\n * is not spec compliant.\n */\nexport function objectToBaggageHeader(object: Record<string, string>): string | undefined {\n  if (Object.keys(object).length === 0) {\n    // An empty baggage header is not spec compliant: We return undefined.\n    return undefined;\n  }\n\n  return Object.entries(object).reduce((baggageHeader, [objectKey, objectValue], currentIndex) => {\n    const baggageEntry = `${encodeURIComponent(objectKey)}=${encodeURIComponent(objectValue)}`;\n    const newBaggageHeader = currentIndex === 0 ? baggageEntry : `${baggageHeader},${baggageEntry}`;\n    if (newBaggageHeader.length > MAX_BAGGAGE_STRING_LENGTH) {\n      DEBUG_BUILD &&\n        logger.warn(\n          `Not adding key: ${objectKey} with val: ${objectValue} to baggage header due to exceeding baggage size limits.`,\n        );\n      return baggageHeader;\n    } else {\n      return newBaggageHeader;\n    }\n  }, '');\n}\n","import { getClient } from '../currentScopes';\nimport type { Options } from '../types-hoist';\n\n// Treeshakable guard to remove all code related to tracing\ndeclare const __SENTRY_TRACING__: boolean | undefined;\n\n/**\n * Determines if span recording is currently enabled.\n *\n * Spans are recorded when at least one of `tracesSampleRate` and `tracesSampler`\n * is defined in the SDK config. This function does not make any assumption about\n * sampling decisions, it only checks if the SDK is configured to record spans.\n *\n * Important: This function only determines if span recording is enabled. Trace\n * continuation and propagation is separately controlled and not covered by this function.\n * If this function returns `false`, traces can still be propagated (which is what\n * we refer to by \"Tracing without Performance\")\n * @see https://develop.sentry.dev/sdk/telemetry/traces/tracing-without-performance/\n *\n * @param maybeOptions An SDK options object to be passed to this function.\n * If this option is not provided, the function will use the current client's options.\n */\nexport function hasSpansEnabled(\n  maybeOptions?: Pick<Options, 'tracesSampleRate' | 'tracesSampler'> | undefined,\n): boolean {\n  if (typeof __SENTRY_TRACING__ === 'boolean' && !__SENTRY_TRACING__) {\n    return false;\n  }\n\n  const options = maybeOptions || getClient()?.getOptions();\n  return (\n    !!options &&\n    // Note: This check is `!= null`, meaning \"nullish\". `0` is not \"nullish\", `undefined` and `null` are. (This comment was brought to you by 15 minutes of questioning life)\n    (options.tracesSampleRate != null || !!options.tracesSampler)\n  );\n}\n\n/**\n * @see JSDoc of `hasSpansEnabled`\n * @deprecated Use `hasSpansEnabled` instead, which is a more accurately named version of this function.\n * This function will be removed in the next major version of the SDK.\n */\n// TODO(v10): Remove this export\nexport const hasTracingEnabled = hasSpansEnabled;\n","import type { Client } from '../client';\nimport { DEFAULT_ENVIRONMENT } from '../constants';\nimport { getClient } from '../currentScopes';\nimport type { Scope } from '../scope';\nimport { SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE } from '../semanticAttributes';\nimport type { DynamicSamplingContext, Span } from '../types-hoist';\nimport {\n  baggageHeaderToDynamicSamplingContext,\n  dynamicSamplingContextToSentryBaggageHeader,\n} from '../utils-hoist/baggage';\nimport { addNonEnumerableProperty, dropUndefinedKeys } from '../utils-hoist/object';\nimport { hasSpansEnabled } from '../utils/hasSpansEnabled';\nimport { getRootSpan, spanIsSampled, spanToJSON } from '../utils/spanUtils';\nimport { getCapturedScopesOnSpan } from './utils';\n\n/**\n * If you change this value, also update the terser plugin config to\n * avoid minification of the object property!\n */\nconst FROZEN_DSC_FIELD = '_frozenDsc';\n\ntype SpanWithMaybeDsc = Span & {\n  [FROZEN_DSC_FIELD]?: Partial<DynamicSamplingContext> | undefined;\n};\n\n/**\n * Freeze the given DSC on the given span.\n */\nexport function freezeDscOnSpan(span: Span, dsc: Partial<DynamicSamplingContext>): void {\n  const spanWithMaybeDsc = span as SpanWithMaybeDsc;\n  addNonEnumerableProperty(spanWithMaybeDsc, FROZEN_DSC_FIELD, dsc);\n}\n\n/**\n * Creates a dynamic sampling context from a client.\n *\n * Dispatches the `createDsc` lifecycle hook as a side effect.\n */\nexport function getDynamicSamplingContextFromClient(trace_id: string, client: Client): DynamicSamplingContext {\n  const options = client.getOptions();\n\n  const { publicKey: public_key } = client.getDsn() || {};\n\n  const dsc = dropUndefinedKeys({\n    environment: options.environment || DEFAULT_ENVIRONMENT,\n    release: options.release,\n    public_key,\n    trace_id,\n  }) as DynamicSamplingContext;\n\n  client.emit('createDsc', dsc);\n\n  return dsc;\n}\n\n/**\n * Get the dynamic sampling context for the currently active scopes.\n */\nexport function getDynamicSamplingContextFromScope(client: Client, scope: Scope): Partial<DynamicSamplingContext> {\n  const propagationContext = scope.getPropagationContext();\n  return propagationContext.dsc || getDynamicSamplingContextFromClient(propagationContext.traceId, client);\n}\n\n/**\n * Creates a dynamic sampling context from a span (and client and scope)\n *\n * @param span the span from which a few values like the root span name and sample rate are extracted.\n *\n * @returns a dynamic sampling context\n */\nexport function getDynamicSamplingContextFromSpan(span: Span): Readonly<Partial<DynamicSamplingContext>> {\n  const client = getClient();\n  if (!client) {\n    return {};\n  }\n\n  const rootSpan = getRootSpan(span);\n  const rootSpanJson = spanToJSON(rootSpan);\n  const rootSpanAttributes = rootSpanJson.data;\n  const traceState = rootSpan.spanContext().traceState;\n\n  // The span sample rate that was locally applied to the root span should also always be applied to the DSC, even if the DSC is frozen.\n  // This is so that the downstream traces/services can use parentSampleRate in their `tracesSampler` to make consistent sampling decisions across the entire trace.\n  const rootSpanSampleRate =\n    traceState?.get('sentry.sample_rate') ?? rootSpanAttributes[SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE];\n  function applyLocalSampleRateToDsc(dsc: Partial<DynamicSamplingContext>): Partial<DynamicSamplingContext> {\n    if (typeof rootSpanSampleRate === 'number' || typeof rootSpanSampleRate === 'string') {\n      dsc.sample_rate = `${rootSpanSampleRate}`;\n    }\n    return dsc;\n  }\n\n  // For core implementation, we freeze the DSC onto the span as a non-enumerable property\n  const frozenDsc = (rootSpan as SpanWithMaybeDsc)[FROZEN_DSC_FIELD];\n  if (frozenDsc) {\n    return applyLocalSampleRateToDsc(frozenDsc);\n  }\n\n  // For OpenTelemetry, we freeze the DSC on the trace state\n  const traceStateDsc = traceState?.get('sentry.dsc');\n\n  // If the span has a DSC, we want it to take precedence\n  const dscOnTraceState = traceStateDsc && baggageHeaderToDynamicSamplingContext(traceStateDsc);\n\n  if (dscOnTraceState) {\n    return applyLocalSampleRateToDsc(dscOnTraceState);\n  }\n\n  // Else, we generate it from the span\n  const dsc = getDynamicSamplingContextFromClient(span.spanContext().traceId, client);\n\n  // We don't want to have a transaction name in the DSC if the source is \"url\" because URLs might contain PII\n  const source = rootSpanAttributes[SEMANTIC_ATTRIBUTE_SENTRY_SOURCE];\n\n  // after JSON conversion, txn.name becomes jsonSpan.description\n  const name = rootSpanJson.description;\n  if (source !== 'url' && name) {\n    dsc.transaction = name;\n  }\n\n  // How can we even land here with hasSpansEnabled() returning false?\n  // Otel creates a Non-recording span in Tracing Without Performance mode when handling incoming requests\n  // So we end up with an active span that is not sampled (neither positively nor negatively)\n  if (hasSpansEnabled()) {\n    dsc.sampled = String(spanIsSampled(rootSpan));\n    dsc.sample_rand =\n      // In OTEL we store the sample rand on the trace state because we cannot access scopes for NonRecordingSpans\n      // The Sentry OTEL SpanSampler takes care of writing the sample rand on the root span\n      traceState?.get('sentry.sample_rand') ??\n      // On all other platforms we can actually get the scopes from a root span (we use this as a fallback)\n      getCapturedScopesOnSpan(rootSpan).scope?.getPropagationContext().sampleRand.toString();\n  }\n\n  applyLocalSampleRateToDsc(dsc);\n\n  client.emit('createDsc', dsc, rootSpan);\n\n  return dsc;\n}\n\n/**\n * Convert a Span to a baggage header.\n */\nexport function spanToBaggageHeader(span: Span): string | undefined {\n  const dsc = getDynamicSamplingContextFromSpan(span);\n  return dynamicSamplingContextToSentryBaggageHeader(dsc);\n}\n","import type { Scope } from '../scope';\nimport type { Span } from '../types-hoist';\nimport { addNonEnumerableProperty } from '../utils-hoist/object';\n\nconst SCOPE_ON_START_SPAN_FIELD = '_sentryScope';\nconst ISOLATION_SCOPE_ON_START_SPAN_FIELD = '_sentryIsolationScope';\n\ntype SpanWithScopes = Span & {\n  [SCOPE_ON_START_SPAN_FIELD]?: Scope;\n  [ISOLATION_SCOPE_ON_START_SPAN_FIELD]?: Scope;\n};\n\n/** Store the scope & isolation scope for a span, which can the be used when it is finished. */\nexport function setCapturedScopesOnSpan(span: Span | undefined, scope: Scope, isolationScope: Scope): void {\n  if (span) {\n    addNonEnumerableProperty(span, ISOLATION_SCOPE_ON_START_SPAN_FIELD, isolationScope);\n    addNonEnumerableProperty(span, SCOPE_ON_START_SPAN_FIELD, scope);\n  }\n}\n\n/**\n * Grabs the scope and isolation scope off a span that were active when the span was started.\n */\nexport function getCapturedScopesOnSpan(span: Span): { scope?: Scope; isolationScope?: Scope } {\n  return {\n    scope: (span as SpanWithScopes)[SCOPE_ON_START_SPAN_FIELD],\n    isolationScope: (span as SpanWithScopes)[ISOLATION_SCOPE_ON_START_SPAN_FIELD],\n  };\n}\n","import { isString } from './is';\nimport { GLOBAL_OBJ } from './worldwide';\n\nconst WINDOW = GLOBAL_OBJ as unknown as Window;\n\nconst DEFAULT_MAX_STRING_LENGTH = 80;\n\ntype SimpleNode = {\n  parentNode: SimpleNode;\n} | null;\n\n/**\n * Given a child DOM element, returns a query-selector statement describing that\n * and its ancestors\n * e.g. [HTMLElement] => body > div > input#foo.btn[name=baz]\n * @returns generated DOM path\n */\nexport function htmlTreeAsString(\n  elem: unknown,\n  options: string[] | { keyAttrs?: string[]; maxStringLength?: number } = {},\n): string {\n  if (!elem) {\n    return '<unknown>';\n  }\n\n  // try/catch both:\n  // - accessing event.target (see getsentry/raven-js#838, #768)\n  // - `htmlTreeAsString` because it's complex, and just accessing the DOM incorrectly\n  // - can throw an exception in some circumstances.\n  try {\n    let currentElem = elem as SimpleNode;\n    const MAX_TRAVERSE_HEIGHT = 5;\n    const out = [];\n    let height = 0;\n    let len = 0;\n    const separator = ' > ';\n    const sepLength = separator.length;\n    let nextStr;\n    const keyAttrs = Array.isArray(options) ? options : options.keyAttrs;\n    const maxStringLength = (!Array.isArray(options) && options.maxStringLength) || DEFAULT_MAX_STRING_LENGTH;\n\n    while (currentElem && height++ < MAX_TRAVERSE_HEIGHT) {\n      nextStr = _htmlElementAsString(currentElem, keyAttrs);\n      // bail out if\n      // - nextStr is the 'html' element\n      // - the length of the string that would be created exceeds maxStringLength\n      //   (ignore this limit if we are on the first iteration)\n      if (nextStr === 'html' || (height > 1 && len + out.length * sepLength + nextStr.length >= maxStringLength)) {\n        break;\n      }\n\n      out.push(nextStr);\n\n      len += nextStr.length;\n      currentElem = currentElem.parentNode;\n    }\n\n    return out.reverse().join(separator);\n  } catch (_oO) {\n    return '<unknown>';\n  }\n}\n\n/**\n * Returns a simple, query-selector representation of a DOM element\n * e.g. [HTMLElement] => input#foo.btn[name=baz]\n * @returns generated DOM path\n */\nfunction _htmlElementAsString(el: unknown, keyAttrs?: string[]): string {\n  const elem = el as {\n    tagName?: string;\n    id?: string;\n    className?: string;\n    getAttribute(key: string): string;\n  };\n\n  const out = [];\n\n  if (!elem?.tagName) {\n    return '';\n  }\n\n  // @ts-expect-error WINDOW has HTMLElement\n  if (WINDOW.HTMLElement) {\n    // If using the component name annotation plugin, this value may be available on the DOM node\n    if (elem instanceof HTMLElement && elem.dataset) {\n      if (elem.dataset['sentryComponent']) {\n        return elem.dataset['sentryComponent'];\n      }\n      if (elem.dataset['sentryElement']) {\n        return elem.dataset['sentryElement'];\n      }\n    }\n  }\n\n  out.push(elem.tagName.toLowerCase());\n\n  // Pairs of attribute keys defined in `serializeAttribute` and their values on element.\n  const keyAttrPairs = keyAttrs?.length\n    ? keyAttrs.filter(keyAttr => elem.getAttribute(keyAttr)).map(keyAttr => [keyAttr, elem.getAttribute(keyAttr)])\n    : null;\n\n  if (keyAttrPairs?.length) {\n    keyAttrPairs.forEach(keyAttrPair => {\n      out.push(`[${keyAttrPair[0]}=\"${keyAttrPair[1]}\"]`);\n    });\n  } else {\n    if (elem.id) {\n      out.push(`#${elem.id}`);\n    }\n\n    const className = elem.className;\n    if (className && isString(className)) {\n      const classes = className.split(/\\s+/);\n      for (const c of classes) {\n        out.push(`.${c}`);\n      }\n    }\n  }\n  const allowedAttrs = ['aria-label', 'type', 'name', 'title', 'alt'];\n  for (const k of allowedAttrs) {\n    const attr = elem.getAttribute(k);\n    if (attr) {\n      out.push(`[${k}=\"${attr}\"]`);\n    }\n  }\n\n  return out.join('');\n}\n\n/**\n * A safe form of location.href\n */\nexport function getLocationHref(): string {\n  try {\n    return WINDOW.document.location.href;\n  } catch (oO) {\n    return '';\n  }\n}\n\n/**\n * Given a DOM element, traverses up the tree until it finds the first ancestor node\n * that has the `data-sentry-component` or `data-sentry-element` attribute with `data-sentry-component` taking\n * precedence. This attribute is added at build-time by projects that have the component name annotation plugin installed.\n *\n * @returns a string representation of the component for the provided DOM element, or `null` if not found\n */\nexport function getComponentName(elem: unknown): string | null {\n  // @ts-expect-error WINDOW has HTMLElement\n  if (!WINDOW.HTMLElement) {\n    return null;\n  }\n\n  let currentElem = elem as SimpleNode;\n  const MAX_TRAVERSE_HEIGHT = 5;\n  for (let i = 0; i < MAX_TRAVERSE_HEIGHT; i++) {\n    if (!currentElem) {\n      return null;\n    }\n\n    if (currentElem instanceof HTMLElement) {\n      if (currentElem.dataset['sentryComponent']) {\n        return currentElem.dataset['sentryComponent'];\n      }\n      if (currentElem.dataset['sentryElement']) {\n        return currentElem.dataset['sentryElement'];\n      }\n    }\n\n    currentElem = currentElem.parentNode;\n  }\n\n  return null;\n}\n","declare const __DEBUG_BUILD__: boolean;\n\n/**\n * This serves as a build time flag that will be true by default, but false in non-debug builds or if users replace `__SENTRY_DEBUG__` in their generated code.\n *\n * ATTENTION: This constant must never cross package boundaries (i.e. be exported) to guarantee that it can be used for tree shaking.\n */\nexport const DEBUG_BUILD = __DEBUG_BUILD__;\n","import { DEBUG_BUILD } from '../debug-build';\nimport { logger } from '../logger';\nimport { getFunctionName } from '../stacktrace';\n\nexport type InstrumentHandlerType =\n  | 'console'\n  | 'dom'\n  | 'fetch'\n  | 'fetch-body-resolved'\n  | 'history'\n  | 'xhr'\n  | 'error'\n  | 'unhandledrejection';\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type InstrumentHandlerCallback = (data: any) => void;\n\n// We keep the handlers globally\nconst handlers: { [key in InstrumentHandlerType]?: InstrumentHandlerCallback[] } = {};\nconst instrumented: { [key in InstrumentHandlerType]?: boolean } = {};\n\n/** Add a handler function. */\nexport function addHandler(type: InstrumentHandlerType, handler: InstrumentHandlerCallback): void {\n  handlers[type] = handlers[type] || [];\n  (handlers[type] as InstrumentHandlerCallback[]).push(handler);\n}\n\n/**\n * Reset all instrumentation handlers.\n * This can be used by tests to ensure we have a clean slate of instrumentation handlers.\n */\nexport function resetInstrumentationHandlers(): void {\n  Object.keys(handlers).forEach(key => {\n    handlers[key as InstrumentHandlerType] = undefined;\n  });\n}\n\n/** Maybe run an instrumentation function, unless it was already called. */\nexport function maybeInstrument(type: InstrumentHandlerType, instrumentFn: () => void): void {\n  if (!instrumented[type]) {\n    instrumented[type] = true;\n    try {\n      instrumentFn();\n    } catch (e) {\n      DEBUG_BUILD && logger.error(`Error while instrumenting ${type}`, e);\n    }\n  }\n}\n\n/** Trigger handlers for a given instrumentation type. */\nexport function triggerHandlers(type: InstrumentHandlerType, data: unknown): void {\n  const typeHandlers = type && handlers[type];\n  if (!typeHandlers) {\n    return;\n  }\n\n  for (const handler of typeHandlers) {\n    try {\n      handler(data);\n    } catch (e) {\n      DEBUG_BUILD &&\n        logger.error(\n          `Error while triggering instrumentation handler.\\nType: ${type}\\nName: ${getFunctionName(handler)}\\nError:`,\n          e,\n        );\n    }\n  }\n}\n","/* eslint-disable @typescript-eslint/no-explicit-any */\n\nimport type { ParameterizedString, PolymorphicEvent, Primitive } from '../types-hoist';\n\n// eslint-disable-next-line @typescript-eslint/unbound-method\nconst objectToString = Object.prototype.toString;\n\n/**\n * Checks whether given value's type is one of a few Error or Error-like\n * {@link isError}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isError(wat: unknown): wat is Error {\n  switch (objectToString.call(wat)) {\n    case '[object Error]':\n    case '[object Exception]':\n    case '[object DOMException]':\n    case '[object WebAssembly.Exception]':\n      return true;\n    default:\n      return isInstanceOf(wat, Error);\n  }\n}\n/**\n * Checks whether given value is an instance of the given built-in class.\n *\n * @param wat The value to be checked\n * @param className\n * @returns A boolean representing the result.\n */\nfunction isBuiltin(wat: unknown, className: string): boolean {\n  return objectToString.call(wat) === `[object ${className}]`;\n}\n\n/**\n * Checks whether given value's type is ErrorEvent\n * {@link isErrorEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isErrorEvent(wat: unknown): boolean {\n  return isBuiltin(wat, 'ErrorEvent');\n}\n\n/**\n * Checks whether given value's type is DOMError\n * {@link isDOMError}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isDOMError(wat: unknown): boolean {\n  return isBuiltin(wat, 'DOMError');\n}\n\n/**\n * Checks whether given value's type is DOMException\n * {@link isDOMException}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isDOMException(wat: unknown): boolean {\n  return isBuiltin(wat, 'DOMException');\n}\n\n/**\n * Checks whether given value's type is a string\n * {@link isString}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isString(wat: unknown): wat is string {\n  return isBuiltin(wat, 'String');\n}\n\n/**\n * Checks whether given string is parameterized\n * {@link isParameterizedString}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isParameterizedString(wat: unknown): wat is ParameterizedString {\n  return (\n    typeof wat === 'object' &&\n    wat !== null &&\n    '__sentry_template_string__' in wat &&\n    '__sentry_template_values__' in wat\n  );\n}\n\n/**\n * Checks whether given value is a primitive (undefined, null, number, boolean, string, bigint, symbol)\n * {@link isPrimitive}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isPrimitive(wat: unknown): wat is Primitive {\n  return wat === null || isParameterizedString(wat) || (typeof wat !== 'object' && typeof wat !== 'function');\n}\n\n/**\n * Checks whether given value's type is an object literal, or a class instance.\n * {@link isPlainObject}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isPlainObject(wat: unknown): wat is Record<string, unknown> {\n  return isBuiltin(wat, 'Object');\n}\n\n/**\n * Checks whether given value's type is an Event instance\n * {@link isEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isEvent(wat: unknown): wat is PolymorphicEvent {\n  return typeof Event !== 'undefined' && isInstanceOf(wat, Event);\n}\n\n/**\n * Checks whether given value's type is an Element instance\n * {@link isElement}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isElement(wat: unknown): boolean {\n  return typeof Element !== 'undefined' && isInstanceOf(wat, Element);\n}\n\n/**\n * Checks whether given value's type is an regexp\n * {@link isRegExp}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isRegExp(wat: unknown): wat is RegExp {\n  return isBuiltin(wat, 'RegExp');\n}\n\n/**\n * Checks whether given value has a then function.\n * @param wat A value to be checked.\n */\nexport function isThenable(wat: any): wat is PromiseLike<any> {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n  return Boolean(wat?.then && typeof wat.then === 'function');\n}\n\n/**\n * Checks whether given value's type is a SyntheticEvent\n * {@link isSyntheticEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isSyntheticEvent(wat: unknown): boolean {\n  return isPlainObject(wat) && 'nativeEvent' in wat && 'preventDefault' in wat && 'stopPropagation' in wat;\n}\n\n/**\n * Checks whether given value's type is an instance of provided constructor.\n * {@link isInstanceOf}.\n *\n * @param wat A value to be checked.\n * @param base A constructor to be used in a check.\n * @returns A boolean representing the result.\n */\nexport function isInstanceOf(wat: any, base: any): boolean {\n  try {\n    return wat instanceof base;\n  } catch (_e) {\n    return false;\n  }\n}\n\ninterface VueViewModel {\n  // Vue3\n  __isVue?: boolean;\n  // Vue2\n  _isVue?: boolean;\n}\n/**\n * Checks whether given value's type is a Vue ViewModel.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isVueViewModel(wat: unknown): boolean {\n  // Not using Object.prototype.toString because in Vue 3 it would read the instance's Symbol(Symbol.toStringTag) property.\n  return !!(typeof wat === 'object' && wat !== null && ((wat as VueViewModel).__isVue || (wat as VueViewModel)._isVue));\n}\n","import { getGlobalSingleton } from '../carrier';\nimport type { ConsoleLevel } from '../types-hoist';\nimport { DEBUG_BUILD } from './debug-build';\nimport { GLOBAL_OBJ } from './worldwide';\n\n/** Prefix for logging strings */\nconst PREFIX = 'Sentry Logger ';\n\nexport const CONSOLE_LEVELS: readonly ConsoleLevel[] = [\n  'debug',\n  'info',\n  'warn',\n  'error',\n  'log',\n  'assert',\n  'trace',\n] as const;\n\ntype LoggerMethod = (...args: unknown[]) => void;\ntype LoggerConsoleMethods = Record<ConsoleLevel, LoggerMethod>;\n\n/** This may be mutated by the console instrumentation. */\nexport const originalConsoleMethods: {\n  [key in ConsoleLevel]?: (...args: unknown[]) => void;\n} = {};\n\n/** A Sentry Logger instance. */\nexport interface Logger extends LoggerConsoleMethods {\n  disable(): void;\n  enable(): void;\n  isEnabled(): boolean;\n}\n\n/**\n * Temporarily disable sentry console instrumentations.\n *\n * @param callback The function to run against the original `console` messages\n * @returns The results of the callback\n */\nexport function consoleSandbox<T>(callback: () => T): T {\n  if (!('console' in GLOBAL_OBJ)) {\n    return callback();\n  }\n\n  const console = GLOBAL_OBJ.console as Console;\n  const wrappedFuncs: Partial<LoggerConsoleMethods> = {};\n\n  const wrappedLevels = Object.keys(originalConsoleMethods) as ConsoleLevel[];\n\n  // Restore all wrapped console methods\n  wrappedLevels.forEach(level => {\n    const originalConsoleMethod = originalConsoleMethods[level] as LoggerMethod;\n    wrappedFuncs[level] = console[level] as LoggerMethod | undefined;\n    console[level] = originalConsoleMethod;\n  });\n\n  try {\n    return callback();\n  } finally {\n    // Revert restoration to wrapped state\n    wrappedLevels.forEach(level => {\n      console[level] = wrappedFuncs[level] as LoggerMethod;\n    });\n  }\n}\n\nfunction makeLogger(): Logger {\n  let enabled = false;\n  const logger: Partial<Logger> = {\n    enable: () => {\n      enabled = true;\n    },\n    disable: () => {\n      enabled = false;\n    },\n    isEnabled: () => enabled,\n  };\n\n  if (DEBUG_BUILD) {\n    CONSOLE_LEVELS.forEach(name => {\n      logger[name] = (...args: Parameters<(typeof GLOBAL_OBJ.console)[typeof name]>) => {\n        if (enabled) {\n          consoleSandbox(() => {\n            GLOBAL_OBJ.console[name](`${PREFIX}[${name}]:`, ...args);\n          });\n        }\n      };\n    });\n  } else {\n    CONSOLE_LEVELS.forEach(name => {\n      logger[name] = () => undefined;\n    });\n  }\n\n  return logger as Logger;\n}\n\n/**\n * This is a logger singleton which either logs things or no-ops if logging is not enabled.\n * The logger is a singleton on the carrier, to ensure that a consistent logger is used throughout the SDK.\n */\nexport const logger = getGlobalSingleton('logger', makeLogger);\n","import type { Event, Exception, Mechanism, StackFrame } from '../types-hoist';\n\nimport { addNonEnumerableProperty } from './object';\nimport { snipLine } from './string';\nimport { GLOBAL_OBJ } from './worldwide';\n\ninterface CryptoInternal {\n  getRandomValues(array: Uint8Array): Uint8Array;\n  randomUUID?(): string;\n}\n\n/** An interface for common properties on global */\ninterface CryptoGlobal {\n  msCrypto?: CryptoInternal;\n  crypto?: CryptoInternal;\n}\n\nfunction getCrypto(): CryptoInternal | undefined {\n  const gbl = GLOBAL_OBJ as typeof GLOBAL_OBJ & CryptoGlobal;\n  return gbl.crypto || gbl.msCrypto;\n}\n\n/**\n * UUID4 generator\n * @param crypto Object that provides the crypto API.\n * @returns string Generated UUID4.\n */\nexport function uuid4(crypto = getCrypto()): string {\n  let getRandomByte = (): number => Math.random() * 16;\n  try {\n    if (crypto?.randomUUID) {\n      return crypto.randomUUID().replace(/-/g, '');\n    }\n    if (crypto?.getRandomValues) {\n      getRandomByte = () => {\n        // crypto.getRandomValues might return undefined instead of the typed array\n        // in old Chromium versions (e.g. 23.0.1235.0 (151422))\n        // However, `typedArray` is still filled in-place.\n        // @see https://developer.mozilla.org/en-US/docs/Web/API/Crypto/getRandomValues#typedarray\n        const typedArray = new Uint8Array(1);\n        crypto.getRandomValues(typedArray);\n        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n        return typedArray[0]!;\n      };\n    }\n  } catch (_) {\n    // some runtimes can crash invoking crypto\n    // https://github.com/getsentry/sentry-javascript/issues/8935\n  }\n\n  // http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/2117523#2117523\n  // Concatenating the following numbers as strings results in '10000000100040008000100000000000'\n  return (([1e7] as unknown as string) + 1e3 + 4e3 + 8e3 + 1e11).replace(/[018]/g, c =>\n    // eslint-disable-next-line no-bitwise\n    ((c as unknown as number) ^ ((getRandomByte() & 15) >> ((c as unknown as number) / 4))).toString(16),\n  );\n}\n\nfunction getFirstException(event: Event): Exception | undefined {\n  return event.exception?.values?.[0];\n}\n\n/**\n * Extracts either message or type+value from an event that can be used for user-facing logs\n * @returns event's description\n */\nexport function getEventDescription(event: Event): string {\n  const { message, event_id: eventId } = event;\n  if (message) {\n    return message;\n  }\n\n  const firstException = getFirstException(event);\n  if (firstException) {\n    if (firstException.type && firstException.value) {\n      return `${firstException.type}: ${firstException.value}`;\n    }\n    return firstException.type || firstException.value || eventId || '<unknown>';\n  }\n  return eventId || '<unknown>';\n}\n\n/**\n * Adds exception values, type and value to an synthetic Exception.\n * @param event The event to modify.\n * @param value Value of the exception.\n * @param type Type of the exception.\n * @hidden\n */\nexport function addExceptionTypeValue(event: Event, value?: string, type?: string): void {\n  const exception = (event.exception = event.exception || {});\n  const values = (exception.values = exception.values || []);\n  const firstException = (values[0] = values[0] || {});\n  if (!firstException.value) {\n    firstException.value = value || '';\n  }\n  if (!firstException.type) {\n    firstException.type = type || 'Error';\n  }\n}\n\n/**\n * Adds exception mechanism data to a given event. Uses defaults if the second parameter is not passed.\n *\n * @param event The event to modify.\n * @param newMechanism Mechanism data to add to the event.\n * @hidden\n */\nexport function addExceptionMechanism(event: Event, newMechanism?: Partial<Mechanism>): void {\n  const firstException = getFirstException(event);\n  if (!firstException) {\n    return;\n  }\n\n  const defaultMechanism = { type: 'generic', handled: true };\n  const currentMechanism = firstException.mechanism;\n  firstException.mechanism = { ...defaultMechanism, ...currentMechanism, ...newMechanism };\n\n  if (newMechanism && 'data' in newMechanism) {\n    const mergedData = { ...currentMechanism?.data, ...newMechanism.data };\n    firstException.mechanism.data = mergedData;\n  }\n}\n\n// https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string\nconst SEMVER_REGEXP =\n  /^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)(?:-((?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\\+([0-9a-zA-Z-]+(?:\\.[0-9a-zA-Z-]+)*))?$/;\n\n/**\n * Represents Semantic Versioning object\n */\ninterface SemVer {\n  major?: number;\n  minor?: number;\n  patch?: number;\n  prerelease?: string;\n  buildmetadata?: string;\n}\n\nfunction _parseInt(input: string | undefined): number {\n  return parseInt(input || '', 10);\n}\n\n/**\n * Parses input into a SemVer interface\n * @param input string representation of a semver version\n */\nexport function parseSemver(input: string): SemVer {\n  const match = input.match(SEMVER_REGEXP) || [];\n  const major = _parseInt(match[1]);\n  const minor = _parseInt(match[2]);\n  const patch = _parseInt(match[3]);\n  return {\n    buildmetadata: match[5],\n    major: isNaN(major) ? undefined : major,\n    minor: isNaN(minor) ? undefined : minor,\n    patch: isNaN(patch) ? undefined : patch,\n    prerelease: match[4],\n  };\n}\n\n/**\n * This function adds context (pre/post/line) lines to the provided frame\n *\n * @param lines string[] containing all lines\n * @param frame StackFrame that will be mutated\n * @param linesOfContext number of context lines we want to add pre/post\n */\nexport function addContextToFrame(lines: string[], frame: StackFrame, linesOfContext: number = 5): void {\n  // When there is no line number in the frame, attaching context is nonsensical and will even break grouping\n  if (frame.lineno === undefined) {\n    return;\n  }\n\n  const maxLines = lines.length;\n  const sourceLine = Math.max(Math.min(maxLines - 1, frame.lineno - 1), 0);\n\n  frame.pre_context = lines\n    .slice(Math.max(0, sourceLine - linesOfContext), sourceLine)\n    .map((line: string) => snipLine(line, 0));\n\n  // We guard here to ensure this is not larger than the existing number of lines\n  const lineIndex = Math.min(maxLines - 1, sourceLine);\n\n  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n  frame.context_line = snipLine(lines[lineIndex]!, frame.colno || 0);\n\n  frame.post_context = lines\n    .slice(Math.min(sourceLine + 1, maxLines), sourceLine + 1 + linesOfContext)\n    .map((line: string) => snipLine(line, 0));\n}\n\n/**\n * Checks whether or not we've already captured the given exception (note: not an identical exception - the very object\n * in question), and marks it captured if not.\n *\n * This is useful because it's possible for an error to get captured by more than one mechanism. After we intercept and\n * record an error, we rethrow it (assuming we've intercepted it before it's reached the top-level global handlers), so\n * that we don't interfere with whatever effects the error might have had were the SDK not there. At that point, because\n * the error has been rethrown, it's possible for it to bubble up to some other code we've instrumented. If it's not\n * caught after that, it will bubble all the way up to the global handlers (which of course we also instrument). This\n * function helps us ensure that even if we encounter the same error more than once, we only record it the first time we\n * see it.\n *\n * Note: It will ignore primitives (always return `false` and not mark them as seen), as properties can't be set on\n * them. {@link: Object.objectify} can be used on exceptions to convert any that are primitives into their equivalent\n * object wrapper forms so that this check will always work. However, because we need to flag the exact object which\n * will get rethrown, and because that rethrowing happens outside of the event processing pipeline, the objectification\n * must be done before the exception captured.\n *\n * @param A thrown exception to check or flag as having been seen\n * @returns `true` if the exception has already been captured, `false` if not (with the side effect of marking it seen)\n */\nexport function checkOrSetAlreadyCaught(exception: unknown): boolean {\n  if (isAlreadyCaptured(exception)) {\n    return true;\n  }\n\n  try {\n    // set it this way rather than by assignment so that it's not ennumerable and therefore isn't recorded by the\n    // `ExtraErrorData` integration\n    addNonEnumerableProperty(exception as { [key: string]: unknown }, '__sentry_captured__', true);\n  } catch (err) {\n    // `exception` is a primitive, so we can't mark it seen\n  }\n\n  return false;\n}\n\nfunction isAlreadyCaptured(exception: unknown): boolean | void {\n  try {\n    return (exception as { __sentry_captured__?: boolean }).__sentry_captured__;\n  } catch {} // eslint-disable-line no-empty\n}\n","import type { Primitive } from '../types-hoist';\n\nimport { isSyntheticEvent, isVueViewModel } from './is';\nimport { convertToPlainObject } from './object';\nimport { getFunctionName } from './stacktrace';\n\ntype Prototype = { constructor: (...args: unknown[]) => unknown };\n// This is a hack to placate TS, relying on the fact that technically, arrays are objects with integer keys. Normally we\n// think of those keys as actual numbers, but `arr['0']` turns out to work just as well as `arr[0]`, and doing it this\n// way lets us use a single type in the places where behave as if we are only dealing with objects, even if some of them\n// might be arrays.\ntype ObjOrArray<T> = { [key: string]: T };\n\ntype MemoFunc = [\n  // memoize\n  (obj: object) => boolean,\n  // unmemoize\n  (obj: object) => void,\n];\n\n/**\n * Recursively normalizes the given object.\n *\n * - Creates a copy to prevent original input mutation\n * - Skips non-enumerable properties\n * - When stringifying, calls `toJSON` if implemented\n * - Removes circular references\n * - Translates non-serializable values (`undefined`/`NaN`/functions) to serializable format\n * - Translates known global objects/classes to a string representations\n * - Takes care of `Error` object serialization\n * - Optionally limits depth of final output\n * - Optionally limits number of properties/elements included in any single object/array\n *\n * @param input The object to be normalized.\n * @param depth The max depth to which to normalize the object. (Anything deeper stringified whole.)\n * @param maxProperties The max number of elements or properties to be included in any single array or\n * object in the normalized output.\n * @returns A normalized version of the object, or `\"**non-serializable**\"` if any errors are thrown during normalization.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function normalize(input: unknown, depth: number = 100, maxProperties: number = +Infinity): any {\n  try {\n    // since we're at the outermost level, we don't provide a key\n    return visit('', input, depth, maxProperties);\n  } catch (err) {\n    return { ERROR: `**non-serializable** (${err})` };\n  }\n}\n\n/** JSDoc */\nexport function normalizeToSize<T>(\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  object: { [key: string]: any },\n  // Default Node.js REPL depth\n  depth: number = 3,\n  // 100kB, as 200kB is max payload size, so half sounds reasonable\n  maxSize: number = 100 * 1024,\n): T {\n  const normalized = normalize(object, depth);\n\n  if (jsonSize(normalized) > maxSize) {\n    return normalizeToSize(object, depth - 1, maxSize);\n  }\n\n  return normalized as T;\n}\n\n/**\n * Visits a node to perform normalization on it\n *\n * @param key The key corresponding to the given node\n * @param value The node to be visited\n * @param depth Optional number indicating the maximum recursion depth\n * @param maxProperties Optional maximum number of properties/elements included in any single object/array\n * @param memo Optional Memo class handling decycling\n */\nfunction visit(\n  key: string,\n  value: unknown,\n  depth: number = +Infinity,\n  maxProperties: number = +Infinity,\n  memo = memoBuilder(),\n): Primitive | ObjOrArray<unknown> {\n  const [memoize, unmemoize] = memo;\n\n  // Get the simple cases out of the way first\n  if (\n    value == null || // this matches null and undefined -> eqeq not eqeqeq\n    ['boolean', 'string'].includes(typeof value) ||\n    (typeof value === 'number' && Number.isFinite(value))\n  ) {\n    return value as Primitive;\n  }\n\n  const stringified = stringifyValue(key, value);\n\n  // Anything we could potentially dig into more (objects or arrays) will have come back as `\"[object XXXX]\"`.\n  // Everything else will have already been serialized, so if we don't see that pattern, we're done.\n  if (!stringified.startsWith('[object ')) {\n    return stringified;\n  }\n\n  // From here on, we can assert that `value` is either an object or an array.\n\n  // Do not normalize objects that we know have already been normalized. As a general rule, the\n  // \"__sentry_skip_normalization__\" property should only be used sparingly and only should only be set on objects that\n  // have already been normalized.\n  if ((value as ObjOrArray<unknown>)['__sentry_skip_normalization__']) {\n    return value as ObjOrArray<unknown>;\n  }\n\n  // We can set `__sentry_override_normalization_depth__` on an object to ensure that from there\n  // We keep a certain amount of depth.\n  // This should be used sparingly, e.g. we use it for the redux integration to ensure we get a certain amount of state.\n  const remainingDepth =\n    typeof (value as ObjOrArray<unknown>)['__sentry_override_normalization_depth__'] === 'number'\n      ? ((value as ObjOrArray<unknown>)['__sentry_override_normalization_depth__'] as number)\n      : depth;\n\n  // We're also done if we've reached the max depth\n  if (remainingDepth === 0) {\n    // At this point we know `serialized` is a string of the form `\"[object XXXX]\"`. Clean it up so it's just `\"[XXXX]\"`.\n    return stringified.replace('object ', '');\n  }\n\n  // If we've already visited this branch, bail out, as it's circular reference. If not, note that we're seeing it now.\n  if (memoize(value)) {\n    return '[Circular ~]';\n  }\n\n  // If the value has a `toJSON` method, we call it to extract more information\n  const valueWithToJSON = value as unknown & { toJSON?: () => unknown };\n  if (valueWithToJSON && typeof valueWithToJSON.toJSON === 'function') {\n    try {\n      const jsonValue = valueWithToJSON.toJSON();\n      // We need to normalize the return value of `.toJSON()` in case it has circular references\n      return visit('', jsonValue, remainingDepth - 1, maxProperties, memo);\n    } catch (err) {\n      // pass (The built-in `toJSON` failed, but we can still try to do it ourselves)\n    }\n  }\n\n  // At this point we know we either have an object or an array, we haven't seen it before, and we're going to recurse\n  // because we haven't yet reached the max depth. Create an accumulator to hold the results of visiting each\n  // property/entry, and keep track of the number of items we add to it.\n  const normalized = (Array.isArray(value) ? [] : {}) as ObjOrArray<unknown>;\n  let numAdded = 0;\n\n  // Before we begin, convert`Error` and`Event` instances into plain objects, since some of each of their relevant\n  // properties are non-enumerable and otherwise would get missed.\n  const visitable = convertToPlainObject(value as ObjOrArray<unknown>);\n\n  for (const visitKey in visitable) {\n    // Avoid iterating over fields in the prototype if they've somehow been exposed to enumeration.\n    if (!Object.prototype.hasOwnProperty.call(visitable, visitKey)) {\n      continue;\n    }\n\n    if (numAdded >= maxProperties) {\n      normalized[visitKey] = '[MaxProperties ~]';\n      break;\n    }\n\n    // Recursively visit all the child nodes\n    const visitValue = visitable[visitKey];\n    normalized[visitKey] = visit(visitKey, visitValue, remainingDepth - 1, maxProperties, memo);\n\n    numAdded++;\n  }\n\n  // Once we've visited all the branches, remove the parent from memo storage\n  unmemoize(value);\n\n  // Return accumulated values\n  return normalized;\n}\n\n/* eslint-disable complexity */\n/**\n * Stringify the given value. Handles various known special values and types.\n *\n * Not meant to be used on simple primitives which already have a string representation, as it will, for example, turn\n * the number 1231 into \"[Object Number]\", nor on `null`, as it will throw.\n *\n * @param value The value to stringify\n * @returns A stringified representation of the given value\n */\nfunction stringifyValue(\n  key: unknown,\n  // this type is a tiny bit of a cheat, since this function does handle NaN (which is technically a number), but for\n  // our internal use, it'll do\n  value: Exclude<unknown, string | number | boolean | null>,\n): string {\n  try {\n    if (key === 'domain' && value && typeof value === 'object' && (value as { _events: unknown })._events) {\n      return '[Domain]';\n    }\n\n    if (key === 'domainEmitter') {\n      return '[DomainEmitter]';\n    }\n\n    // It's safe to use `global`, `window`, and `document` here in this manner, as we are asserting using `typeof` first\n    // which won't throw if they are not present.\n\n    if (typeof global !== 'undefined' && value === global) {\n      return '[Global]';\n    }\n\n    // eslint-disable-next-line no-restricted-globals\n    if (typeof window !== 'undefined' && value === window) {\n      return '[Window]';\n    }\n\n    // eslint-disable-next-line no-restricted-globals\n    if (typeof document !== 'undefined' && value === document) {\n      return '[Document]';\n    }\n\n    if (isVueViewModel(value)) {\n      return '[VueViewModel]';\n    }\n\n    // React's SyntheticEvent thingy\n    if (isSyntheticEvent(value)) {\n      return '[SyntheticEvent]';\n    }\n\n    if (typeof value === 'number' && !Number.isFinite(value)) {\n      return `[${value}]`;\n    }\n\n    if (typeof value === 'function') {\n      return `[Function: ${getFunctionName(value)}]`;\n    }\n\n    if (typeof value === 'symbol') {\n      return `[${String(value)}]`;\n    }\n\n    // stringified BigInts are indistinguishable from regular numbers, so we need to label them to avoid confusion\n    if (typeof value === 'bigint') {\n      return `[BigInt: ${String(value)}]`;\n    }\n\n    // Now that we've knocked out all the special cases and the primitives, all we have left are objects. Simply casting\n    // them to strings means that instances of classes which haven't defined their `toStringTag` will just come out as\n    // `\"[object Object]\"`. If we instead look at the constructor's name (which is the same as the name of the class),\n    // we can make sure that only plain objects come out that way.\n    const objName = getConstructorName(value);\n\n    // Handle HTML Elements\n    if (/^HTML(\\w*)Element$/.test(objName)) {\n      return `[HTMLElement: ${objName}]`;\n    }\n\n    return `[object ${objName}]`;\n  } catch (err) {\n    return `**non-serializable** (${err})`;\n  }\n}\n/* eslint-enable complexity */\n\nfunction getConstructorName(value: unknown): string {\n  const prototype: Prototype | null = Object.getPrototypeOf(value);\n\n  return prototype ? prototype.constructor.name : 'null prototype';\n}\n\n/** Calculates bytes size of input string */\nfunction utf8Length(value: string): number {\n  // eslint-disable-next-line no-bitwise\n  return ~-encodeURI(value).split(/%..|./).length;\n}\n\n/** Calculates bytes size of input object */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction jsonSize(value: any): number {\n  return utf8Length(JSON.stringify(value));\n}\n\n/**\n * Normalizes URLs in exceptions and stacktraces to a base path so Sentry can fingerprint\n * across platforms and working directory.\n *\n * @param url The URL to be normalized.\n * @param basePath The application base path.\n * @returns The normalized URL.\n */\nexport function normalizeUrlToBase(url: string, basePath: string): string {\n  const escapedBase = basePath\n    // Backslash to forward\n    .replace(/\\\\/g, '/')\n    // Escape RegExp special characters\n    .replace(/[|\\\\{}()[\\]^$+*?.]/g, '\\\\$&');\n\n  let newUrl = url;\n  try {\n    newUrl = decodeURI(url);\n  } catch (_Oo) {\n    // Sometime this breaks\n  }\n  return (\n    newUrl\n      .replace(/\\\\/g, '/')\n      .replace(/webpack:\\/?/g, '') // Remove intermediate base path\n      // eslint-disable-next-line @sentry-internal/sdk/no-regexp-constructor\n      .replace(new RegExp(`(file://)?/*${escapedBase}/*`, 'ig'), 'app:///')\n  );\n}\n\n/**\n * Helper to decycle json objects\n */\nfunction memoBuilder(): MemoFunc {\n  const inner = new WeakSet<object>();\n  function memoize(obj: object): boolean {\n    if (inner.has(obj)) {\n      return true;\n    }\n    inner.add(obj);\n    return false;\n  }\n\n  function unmemoize(obj: object): void {\n    inner.delete(obj);\n  }\n  return [memoize, unmemoize];\n}\n","/* eslint-disable @typescript-eslint/no-explicit-any */\nimport type { WrappedFunction } from '../types-hoist';\n\nimport { htmlTreeAsString } from './browser';\nimport { DEBUG_BUILD } from './debug-build';\nimport { isElement, isError, isEvent, isInstanceOf, isPlainObject, isPrimitive } from './is';\nimport { logger } from './logger';\nimport { truncate } from './string';\n\n/**\n * Replace a method in an object with a wrapped version of itself.\n *\n * @param source An object that contains a method to be wrapped.\n * @param name The name of the method to be wrapped.\n * @param replacementFactory A higher-order function that takes the original version of the given method and returns a\n * wrapped version. Note: The function returned by `replacementFactory` needs to be a non-arrow function, in order to\n * preserve the correct value of `this`, and the original method must be called using `origMethod.call(this, <other\n * args>)` or `origMethod.apply(this, [<other args>])` (rather than being called directly), again to preserve `this`.\n * @returns void\n */\nexport function fill(source: { [key: string]: any }, name: string, replacementFactory: (...args: any[]) => any): void {\n  if (!(name in source)) {\n    return;\n  }\n\n  const original = source[name] as () => any;\n  const wrapped = replacementFactory(original) as WrappedFunction;\n\n  // Make sure it's a function first, as we need to attach an empty prototype for `defineProperties` to work\n  // otherwise it'll throw \"TypeError: Object.defineProperties called on non-object\"\n  if (typeof wrapped === 'function') {\n    markFunctionWrapped(wrapped, original);\n  }\n\n  try {\n    source[name] = wrapped;\n  } catch {\n    DEBUG_BUILD && logger.log(`Failed to replace method \"${name}\" in object`, source);\n  }\n}\n\n/**\n * Defines a non-enumerable property on the given object.\n *\n * @param obj The object on which to set the property\n * @param name The name of the property to be set\n * @param value The value to which to set the property\n */\nexport function addNonEnumerableProperty(obj: object, name: string, value: unknown): void {\n  try {\n    Object.defineProperty(obj, name, {\n      // enumerable: false, // the default, so we can save on bundle size by not explicitly setting it\n      value: value,\n      writable: true,\n      configurable: true,\n    });\n  } catch (o_O) {\n    DEBUG_BUILD && logger.log(`Failed to add non-enumerable property \"${name}\" to object`, obj);\n  }\n}\n\n/**\n * Remembers the original function on the wrapped function and\n * patches up the prototype.\n *\n * @param wrapped the wrapper function\n * @param original the original function that gets wrapped\n */\nexport function markFunctionWrapped(wrapped: WrappedFunction, original: WrappedFunction): void {\n  try {\n    const proto = original.prototype || {};\n    wrapped.prototype = original.prototype = proto;\n    addNonEnumerableProperty(wrapped, '__sentry_original__', original);\n  } catch (o_O) {} // eslint-disable-line no-empty\n}\n\n/**\n * This extracts the original function if available.  See\n * `markFunctionWrapped` for more information.\n *\n * @param func the function to unwrap\n * @returns the unwrapped version of the function if available.\n */\n// eslint-disable-next-line @typescript-eslint/ban-types\nexport function getOriginalFunction<T extends Function>(func: WrappedFunction<T>): T | undefined {\n  return func.__sentry_original__;\n}\n\n/**\n * Transforms any `Error` or `Event` into a plain object with all of their enumerable properties, and some of their\n * non-enumerable properties attached.\n *\n * @param value Initial source that we have to transform in order for it to be usable by the serializer\n * @returns An Event or Error turned into an object - or the value argument itself, when value is neither an Event nor\n *  an Error.\n */\nexport function convertToPlainObject<V>(value: V):\n  | {\n      [ownProps: string]: unknown;\n      type: string;\n      target: string;\n      currentTarget: string;\n      detail?: unknown;\n    }\n  | {\n      [ownProps: string]: unknown;\n      message: string;\n      name: string;\n      stack?: string;\n    }\n  | V {\n  if (isError(value)) {\n    return {\n      message: value.message,\n      name: value.name,\n      stack: value.stack,\n      ...getOwnProperties(value),\n    };\n  } else if (isEvent(value)) {\n    const newObj: {\n      [ownProps: string]: unknown;\n      type: string;\n      target: string;\n      currentTarget: string;\n      detail?: unknown;\n    } = {\n      type: value.type,\n      target: serializeEventTarget(value.target),\n      currentTarget: serializeEventTarget(value.currentTarget),\n      ...getOwnProperties(value),\n    };\n\n    if (typeof CustomEvent !== 'undefined' && isInstanceOf(value, CustomEvent)) {\n      newObj.detail = value.detail;\n    }\n\n    return newObj;\n  } else {\n    return value;\n  }\n}\n\n/** Creates a string representation of the target of an `Event` object */\nfunction serializeEventTarget(target: unknown): string {\n  try {\n    return isElement(target) ? htmlTreeAsString(target) : Object.prototype.toString.call(target);\n  } catch (_oO) {\n    return '<unknown>';\n  }\n}\n\n/** Filters out all but an object's own properties */\nfunction getOwnProperties(obj: unknown): { [key: string]: unknown } {\n  if (typeof obj === 'object' && obj !== null) {\n    const extractedProps: { [key: string]: unknown } = {};\n    for (const property in obj) {\n      if (Object.prototype.hasOwnProperty.call(obj, property)) {\n        extractedProps[property] = (obj as Record<string, unknown>)[property];\n      }\n    }\n    return extractedProps;\n  } else {\n    return {};\n  }\n}\n\n/**\n * Given any captured exception, extract its keys and create a sorted\n * and truncated list that will be used inside the event message.\n * eg. `Non-error exception captured with keys: foo, bar, baz`\n */\nexport function extractExceptionKeysForMessage(exception: Record<string, unknown>, maxLength: number = 40): string {\n  const keys = Object.keys(convertToPlainObject(exception));\n  keys.sort();\n\n  const firstKey = keys[0];\n\n  if (!firstKey) {\n    return '[object has no keys]';\n  }\n\n  if (firstKey.length >= maxLength) {\n    return truncate(firstKey, maxLength);\n  }\n\n  for (let includedKeys = keys.length; includedKeys > 0; includedKeys--) {\n    const serialized = keys.slice(0, includedKeys).join(', ');\n    if (serialized.length > maxLength) {\n      continue;\n    }\n    if (includedKeys === keys.length) {\n      return serialized;\n    }\n    return truncate(serialized, maxLength);\n  }\n\n  return '';\n}\n\n/**\n * Given any object, return a new object having removed all fields whose value was `undefined`.\n * Works recursively on objects and arrays.\n *\n * Attention: This function keeps circular references in the returned object.\n */\nexport function dropUndefinedKeys<T>(inputValue: T): T {\n  // This map keeps track of what already visited nodes map to.\n  // Our Set - based memoBuilder doesn't work here because we want to the output object to have the same circular\n  // references as the input object.\n  const memoizationMap = new Map<unknown, unknown>();\n\n  // This function just proxies `_dropUndefinedKeys` to keep the `memoBuilder` out of this function's API\n  return _dropUndefinedKeys(inputValue, memoizationMap);\n}\n\nfunction _dropUndefinedKeys<T>(inputValue: T, memoizationMap: Map<unknown, unknown>): T {\n  if (isPojo(inputValue)) {\n    // If this node has already been visited due to a circular reference, return the object it was mapped to in the new object\n    const memoVal = memoizationMap.get(inputValue);\n    if (memoVal !== undefined) {\n      return memoVal as T;\n    }\n\n    const returnValue: { [key: string]: unknown } = {};\n    // Store the mapping of this value in case we visit it again, in case of circular data\n    memoizationMap.set(inputValue, returnValue);\n\n    for (const key of Object.getOwnPropertyNames(inputValue)) {\n      if (typeof inputValue[key] !== 'undefined') {\n        returnValue[key] = _dropUndefinedKeys(inputValue[key], memoizationMap);\n      }\n    }\n\n    return returnValue as T;\n  }\n\n  if (Array.isArray(inputValue)) {\n    // If this node has already been visited due to a circular reference, return the array it was mapped to in the new object\n    const memoVal = memoizationMap.get(inputValue);\n    if (memoVal !== undefined) {\n      return memoVal as T;\n    }\n\n    const returnValue: unknown[] = [];\n    // Store the mapping of this value in case we visit it again, in case of circular data\n    memoizationMap.set(inputValue, returnValue);\n\n    inputValue.forEach((item: unknown) => {\n      returnValue.push(_dropUndefinedKeys(item, memoizationMap));\n    });\n\n    return returnValue as unknown as T;\n  }\n\n  return inputValue;\n}\n\nfunction isPojo(input: unknown): input is Record<string, unknown> {\n  if (!isPlainObject(input)) {\n    return false;\n  }\n\n  try {\n    const name = (Object.getPrototypeOf(input) as { constructor: { name: string } }).constructor.name;\n    return !name || name === 'Object';\n  } catch {\n    return true;\n  }\n}\n\n/**\n * Ensure that something is an object.\n *\n * Turns `undefined` and `null` into `String`s and all other primitives into instances of their respective wrapper\n * classes (String, Boolean, Number, etc.). Acts as the identity function on non-primitives.\n *\n * @param wat The subject of the objectification\n * @returns A version of `wat` which can safely be used with `Object` class methods\n */\nexport function objectify(wat: unknown): typeof Object {\n  let objectified;\n  switch (true) {\n    // this will catch both undefined and null\n    case wat == undefined:\n      objectified = new String(wat);\n      break;\n\n    // Though symbols and bigints do have wrapper classes (`Symbol` and `BigInt`, respectively), for whatever reason\n    // those classes don't have constructors which can be used with the `new` keyword. We therefore need to cast each as\n    // an object in order to wrap it.\n    case typeof wat === 'symbol' || typeof wat === 'bigint':\n      objectified = Object(wat);\n      break;\n\n    // this will catch the remaining primitives: `String`, `Number`, and `Boolean`\n    case isPrimitive(wat):\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n      objectified = new (wat as any).constructor(wat);\n      break;\n\n    // by process of elimination, at this point we know that `wat` must already be an object\n    default:\n      objectified = wat;\n      break;\n  }\n  return objectified;\n}\n","import { uuid4 } from './misc';\n\n/**\n * Generate a random, valid trace ID.\n */\nexport function generateTraceId(): string {\n  return uuid4();\n}\n\n/**\n * Generate a random, valid span ID.\n */\nexport function generateSpanId(): string {\n  return uuid4().substring(16);\n}\n","import type { Event, StackFrame, StackLineParser, StackParser } from '../types-hoist';\n\nconst STACKTRACE_FRAME_LIMIT = 50;\nexport const UNKNOWN_FUNCTION = '?';\n// Used to sanitize webpack (error: *) wrapped stack errors\nconst WEBPACK_ERROR_REGEXP = /\\(error: (.*)\\)/;\nconst STRIP_FRAME_REGEXP = /captureMessage|captureException/;\n\n/**\n * Creates a stack parser with the supplied line parsers\n *\n * StackFrames are returned in the correct order for Sentry Exception\n * frames and with Sentry SDK internal frames removed from the top and bottom\n *\n */\nexport function createStackParser(...parsers: StackLineParser[]): StackParser {\n  const sortedParsers = parsers.sort((a, b) => a[0] - b[0]).map(p => p[1]);\n\n  return (stack: string, skipFirstLines: number = 0, framesToPop: number = 0): StackFrame[] => {\n    const frames: StackFrame[] = [];\n    const lines = stack.split('\\n');\n\n    for (let i = skipFirstLines; i < lines.length; i++) {\n      const line = lines[i] as string;\n      // Ignore lines over 1kb as they are unlikely to be stack frames.\n      // Many of the regular expressions use backtracking which results in run time that increases exponentially with\n      // input size. Huge strings can result in hangs/Denial of Service:\n      // https://github.com/getsentry/sentry-javascript/issues/2286\n      if (line.length > 1024) {\n        continue;\n      }\n\n      // https://github.com/getsentry/sentry-javascript/issues/5459\n      // Remove webpack (error: *) wrappers\n      const cleanedLine = WEBPACK_ERROR_REGEXP.test(line) ? line.replace(WEBPACK_ERROR_REGEXP, '$1') : line;\n\n      // https://github.com/getsentry/sentry-javascript/issues/7813\n      // Skip Error: lines\n      if (cleanedLine.match(/\\S*Error: /)) {\n        continue;\n      }\n\n      for (const parser of sortedParsers) {\n        const frame = parser(cleanedLine);\n\n        if (frame) {\n          frames.push(frame);\n          break;\n        }\n      }\n\n      if (frames.length >= STACKTRACE_FRAME_LIMIT + framesToPop) {\n        break;\n      }\n    }\n\n    return stripSentryFramesAndReverse(frames.slice(framesToPop));\n  };\n}\n\n/**\n * Gets a stack parser implementation from Options.stackParser\n * @see Options\n *\n * If options contains an array of line parsers, it is converted into a parser\n */\nexport function stackParserFromStackParserOptions(stackParser: StackParser | StackLineParser[]): StackParser {\n  if (Array.isArray(stackParser)) {\n    return createStackParser(...stackParser);\n  }\n  return stackParser;\n}\n\n/**\n * Removes Sentry frames from the top and bottom of the stack if present and enforces a limit of max number of frames.\n * Assumes stack input is ordered from top to bottom and returns the reverse representation so call site of the\n * function that caused the crash is the last frame in the array.\n * @hidden\n */\nexport function stripSentryFramesAndReverse(stack: ReadonlyArray<StackFrame>): StackFrame[] {\n  if (!stack.length) {\n    return [];\n  }\n\n  const localStack = Array.from(stack);\n\n  // If stack starts with one of our API calls, remove it (starts, meaning it's the top of the stack - aka last call)\n  if (/sentryWrapped/.test(getLastStackFrame(localStack).function || '')) {\n    localStack.pop();\n  }\n\n  // Reversing in the middle of the procedure allows us to just pop the values off the stack\n  localStack.reverse();\n\n  // If stack ends with one of our internal API calls, remove it (ends, meaning it's the bottom of the stack - aka top-most call)\n  if (STRIP_FRAME_REGEXP.test(getLastStackFrame(localStack).function || '')) {\n    localStack.pop();\n\n    // When using synthetic events, we will have a 2 levels deep stack, as `new Error('Sentry syntheticException')`\n    // is produced within the scope itself, making it:\n    //\n    //   Sentry.captureException()\n    //   scope.captureException()\n    //\n    // instead of just the top `Sentry` call itself.\n    // This forces us to possibly strip an additional frame in the exact same was as above.\n    if (STRIP_FRAME_REGEXP.test(getLastStackFrame(localStack).function || '')) {\n      localStack.pop();\n    }\n  }\n\n  return localStack.slice(0, STACKTRACE_FRAME_LIMIT).map(frame => ({\n    ...frame,\n    filename: frame.filename || getLastStackFrame(localStack).filename,\n    function: frame.function || UNKNOWN_FUNCTION,\n  }));\n}\n\nfunction getLastStackFrame(arr: StackFrame[]): StackFrame {\n  return arr[arr.length - 1] || {};\n}\n\nconst defaultFunctionName = '<anonymous>';\n\n/**\n * Safely extract function name from itself\n */\nexport function getFunctionName(fn: unknown): string {\n  try {\n    if (!fn || typeof fn !== 'function') {\n      return defaultFunctionName;\n    }\n    return fn.name || defaultFunctionName;\n  } catch (e) {\n    // Just accessing custom props in some Selenium environments\n    // can cause a \"Permission denied\" exception (see raven-js#495).\n    return defaultFunctionName;\n  }\n}\n\n/**\n * Get's stack frames from an event without needing to check for undefined properties.\n */\nexport function getFramesFromEvent(event: Event): StackFrame[] | undefined {\n  const exception = event.exception;\n\n  if (exception) {\n    const frames: StackFrame[] = [];\n    try {\n      // @ts-expect-error Object could be undefined\n      exception.values.forEach(value => {\n        // @ts-expect-error Value could be undefined\n        if (value.stacktrace.frames) {\n          // @ts-expect-error Value could be undefined\n          frames.push(...value.stacktrace.frames);\n        }\n      });\n      return frames;\n    } catch (_oO) {\n      return undefined;\n    }\n  }\n  return undefined;\n}\n","import { isRegExp, isString, isVueViewModel } from './is';\n\nexport { escapeStringForRegex } from './vendor/escapeStringForRegex';\n\n/**\n * Truncates given string to the maximum characters count\n *\n * @param str An object that contains serializable values\n * @param max Maximum number of characters in truncated string (0 = unlimited)\n * @returns string Encoded\n */\nexport function truncate(str: string, max: number = 0): string {\n  if (typeof str !== 'string' || max === 0) {\n    return str;\n  }\n  return str.length <= max ? str : `${str.slice(0, max)}...`;\n}\n\n/**\n * This is basically just `trim_line` from\n * https://github.com/getsentry/sentry/blob/master/src/sentry/lang/javascript/processor.py#L67\n *\n * @param str An object that contains serializable values\n * @param max Maximum number of characters in truncated string\n * @returns string Encoded\n */\nexport function snipLine(line: string, colno: number): string {\n  let newLine = line;\n  const lineLength = newLine.length;\n  if (lineLength <= 150) {\n    return newLine;\n  }\n  if (colno > lineLength) {\n    // eslint-disable-next-line no-param-reassign\n    colno = lineLength;\n  }\n\n  let start = Math.max(colno - 60, 0);\n  if (start < 5) {\n    start = 0;\n  }\n\n  let end = Math.min(start + 140, lineLength);\n  if (end > lineLength - 5) {\n    end = lineLength;\n  }\n  if (end === lineLength) {\n    start = Math.max(end - 140, 0);\n  }\n\n  newLine = newLine.slice(start, end);\n  if (start > 0) {\n    newLine = `'{snip} ${newLine}`;\n  }\n  if (end < lineLength) {\n    newLine += ' {snip}';\n  }\n\n  return newLine;\n}\n\n/**\n * Join values in array\n * @param input array of values to be joined together\n * @param delimiter string to be placed in-between values\n * @returns Joined values\n */\nexport function safeJoin(input: unknown[], delimiter?: string): string {\n  if (!Array.isArray(input)) {\n    return '';\n  }\n\n  const output = [];\n  // eslint-disable-next-line @typescript-eslint/prefer-for-of\n  for (let i = 0; i < input.length; i++) {\n    const value = input[i];\n    try {\n      // This is a hack to fix a Vue3-specific bug that causes an infinite loop of\n      // console warnings. This happens when a Vue template is rendered with\n      // an undeclared variable, which we try to stringify, ultimately causing\n      // Vue to issue another warning which repeats indefinitely.\n      // see: https://github.com/getsentry/sentry-javascript/pull/8981\n      if (isVueViewModel(value)) {\n        output.push('[VueViewModel]');\n      } else {\n        output.push(String(value));\n      }\n    } catch (e) {\n      output.push('[value cannot be serialized]');\n    }\n  }\n\n  return output.join(delimiter);\n}\n\n/**\n * Checks if the given value matches a regex or string\n *\n * @param value The string to test\n * @param pattern Either a regex or a string against which `value` will be matched\n * @param requireExactStringMatch If true, `value` must match `pattern` exactly. If false, `value` will match\n * `pattern` if it contains `pattern`. Only applies to string-type patterns.\n */\nexport function isMatchingPattern(\n  value: string,\n  pattern: RegExp | string,\n  requireExactStringMatch: boolean = false,\n): boolean {\n  if (!isString(value)) {\n    return false;\n  }\n\n  if (isRegExp(pattern)) {\n    return pattern.test(value);\n  }\n  if (isString(pattern)) {\n    return requireExactStringMatch ? value === pattern : value.includes(pattern);\n  }\n\n  return false;\n}\n\n/**\n * Test the given string against an array of strings and regexes. By default, string matching is done on a\n * substring-inclusion basis rather than a strict equality basis\n *\n * @param testString The string to test\n * @param patterns The patterns against which to test the string\n * @param requireExactStringMatch If true, `testString` must match one of the given string patterns exactly in order to\n * count. If false, `testString` will match a string pattern if it contains that pattern.\n * @returns\n */\nexport function stringMatchesSomePattern(\n  testString: string,\n  patterns: Array<string | RegExp> = [],\n  requireExactStringMatch: boolean = false,\n): boolean {\n  return patterns.some(pattern => isMatchingPattern(testString, pattern, requireExactStringMatch));\n}\n","import { DEBUG_BUILD } from './debug-build';\nimport { logger } from './logger';\nimport { GLOBAL_OBJ } from './worldwide';\n\nconst WINDOW = GLOBAL_OBJ as unknown as Window;\n\ndeclare const EdgeRuntime: string | undefined;\n\n/**\n * Tells whether current environment supports ErrorEvent objects\n * {@link supportsErrorEvent}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsErrorEvent(): boolean {\n  try {\n    new ErrorEvent('');\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * Tells whether current environment supports DOMError objects\n * {@link supportsDOMError}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsDOMError(): boolean {\n  try {\n    // Chrome: VM89:1 Uncaught TypeError: Failed to construct 'DOMError':\n    // 1 argument required, but only 0 present.\n    // @ts-expect-error It really needs 1 argument, not 0.\n    new DOMError('');\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * Tells whether current environment supports DOMException objects\n * {@link supportsDOMException}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsDOMException(): boolean {\n  try {\n    new DOMException('');\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * Tells whether current environment supports History API\n * {@link supportsHistory}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsHistory(): boolean {\n  return 'history' in WINDOW;\n}\n\n/**\n * Tells whether current environment supports Fetch API\n * {@link supportsFetch}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsFetch(): boolean {\n  if (!('fetch' in WINDOW)) {\n    return false;\n  }\n\n  try {\n    new Headers();\n    new Request('http://www.example.com');\n    new Response();\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * isNative checks if the given function is a native implementation\n */\n// eslint-disable-next-line @typescript-eslint/ban-types\nexport function isNativeFunction(func: Function): boolean {\n  return func && /^function\\s+\\w+\\(\\)\\s+\\{\\s+\\[native code\\]\\s+\\}$/.test(func.toString());\n}\n\n/**\n * Tells whether current environment supports Fetch API natively\n * {@link supportsNativeFetch}.\n *\n * @returns true if `window.fetch` is natively implemented, false otherwise\n */\nexport function supportsNativeFetch(): boolean {\n  if (typeof EdgeRuntime === 'string') {\n    return true;\n  }\n\n  if (!supportsFetch()) {\n    return false;\n  }\n\n  // Fast path to avoid DOM I/O\n  // eslint-disable-next-line @typescript-eslint/unbound-method\n  if (isNativeFunction(WINDOW.fetch)) {\n    return true;\n  }\n\n  // window.fetch is implemented, but is polyfilled or already wrapped (e.g: by a chrome extension)\n  // so create a \"pure\" iframe to see if that has native fetch\n  let result = false;\n  const doc = WINDOW.document;\n  // eslint-disable-next-line deprecation/deprecation\n  if (doc && typeof (doc.createElement as unknown) === 'function') {\n    try {\n      const sandbox = doc.createElement('iframe');\n      sandbox.hidden = true;\n      doc.head.appendChild(sandbox);\n      if (sandbox.contentWindow?.fetch) {\n        // eslint-disable-next-line @typescript-eslint/unbound-method\n        result = isNativeFunction(sandbox.contentWindow.fetch);\n      }\n      doc.head.removeChild(sandbox);\n    } catch (err) {\n      DEBUG_BUILD &&\n        logger.warn('Could not create sandbox iframe for pure fetch check, bailing to window.fetch: ', err);\n    }\n  }\n\n  return result;\n}\n\n/**\n * Tells whether current environment supports ReportingObserver API\n * {@link supportsReportingObserver}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsReportingObserver(): boolean {\n  return 'ReportingObserver' in WINDOW;\n}\n\n/**\n * Tells whether current environment supports Referrer Policy API\n * {@link supportsReferrerPolicy}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsReferrerPolicy(): boolean {\n  // Despite all stars in the sky saying that Edge supports old draft syntax, aka 'never', 'always', 'origin' and 'default'\n  // (see https://caniuse.com/#feat=referrer-policy),\n  // it doesn't. And it throws an exception instead of ignoring this parameter...\n  // REF: https://github.com/getsentry/raven-js/issues/1233\n\n  if (!supportsFetch()) {\n    return false;\n  }\n\n  try {\n    new Request('_', {\n      referrerPolicy: 'origin' as ReferrerPolicy,\n    });\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n","/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { isThenable } from './is';\n\n/** SyncPromise internal states */\nconst enum States {\n  /** Pending */\n  PENDING = 0,\n  /** Resolved / OK */\n  RESOLVED = 1,\n  /** Rejected / Error */\n  REJECTED = 2,\n}\n\n// Overloads so we can call resolvedSyncPromise without arguments and generic argument\nexport function resolvedSyncPromise(): PromiseLike<void>;\nexport function resolvedSyncPromise<T>(value: T | PromiseLike<T>): PromiseLike<T>;\n\n/**\n * Creates a resolved sync promise.\n *\n * @param value the value to resolve the promise with\n * @returns the resolved sync promise\n */\nexport function resolvedSyncPromise<T>(value?: T | PromiseLike<T>): PromiseLike<T> {\n  return new SyncPromise(resolve => {\n    resolve(value);\n  });\n}\n\n/**\n * Creates a rejected sync promise.\n *\n * @param value the value to reject the promise with\n * @returns the rejected sync promise\n */\nexport function rejectedSyncPromise<T = never>(reason?: any): PromiseLike<T> {\n  return new SyncPromise((_, reject) => {\n    reject(reason);\n  });\n}\n\ntype Executor<T> = (resolve: (value?: T | PromiseLike<T> | null) => void, reject: (reason?: any) => void) => void;\n\n/**\n * Thenable class that behaves like a Promise and follows it's interface\n * but is not async internally\n */\nexport class SyncPromise<T> implements PromiseLike<T> {\n  private _state: States;\n  private _handlers: Array<[boolean, (value: T) => void, (reason: any) => any]>;\n  private _value: any;\n\n  public constructor(executor: Executor<T>) {\n    this._state = States.PENDING;\n    this._handlers = [];\n\n    this._runExecutor(executor);\n  }\n\n  /** @inheritdoc */\n  public then<TResult1 = T, TResult2 = never>(\n    onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null,\n    onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null,\n  ): PromiseLike<TResult1 | TResult2> {\n    return new SyncPromise((resolve, reject) => {\n      this._handlers.push([\n        false,\n        result => {\n          if (!onfulfilled) {\n            // TODO: ¯\\_(ツ)_/¯\n            // TODO: FIXME\n            resolve(result as any);\n          } else {\n            try {\n              resolve(onfulfilled(result));\n            } catch (e) {\n              reject(e);\n            }\n          }\n        },\n        reason => {\n          if (!onrejected) {\n            reject(reason);\n          } else {\n            try {\n              resolve(onrejected(reason));\n            } catch (e) {\n              reject(e);\n            }\n          }\n        },\n      ]);\n      this._executeHandlers();\n    });\n  }\n\n  /** @inheritdoc */\n  public catch<TResult = never>(\n    onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null,\n  ): PromiseLike<T | TResult> {\n    return this.then(val => val, onrejected);\n  }\n\n  /** @inheritdoc */\n  public finally<TResult>(onfinally?: (() => void) | null): PromiseLike<TResult> {\n    return new SyncPromise<TResult>((resolve, reject) => {\n      let val: TResult | any;\n      let isRejected: boolean;\n\n      return this.then(\n        value => {\n          isRejected = false;\n          val = value;\n          if (onfinally) {\n            onfinally();\n          }\n        },\n        reason => {\n          isRejected = true;\n          val = reason;\n          if (onfinally) {\n            onfinally();\n          }\n        },\n      ).then(() => {\n        if (isRejected) {\n          reject(val);\n          return;\n        }\n\n        resolve(val as unknown as any);\n      });\n    });\n  }\n\n  /** Excute the resolve/reject handlers. */\n  private _executeHandlers(): void {\n    if (this._state === States.PENDING) {\n      return;\n    }\n\n    const cachedHandlers = this._handlers.slice();\n    this._handlers = [];\n\n    cachedHandlers.forEach(handler => {\n      if (handler[0]) {\n        return;\n      }\n\n      if (this._state === States.RESOLVED) {\n        handler[1](this._value as unknown as any);\n      }\n\n      if (this._state === States.REJECTED) {\n        handler[2](this._value);\n      }\n\n      handler[0] = true;\n    });\n  }\n\n  /** Run the executor for the SyncPromise. */\n  private _runExecutor(executor: Executor<T>): void {\n    const setResult = (state: States, value?: T | PromiseLike<T> | any): void => {\n      if (this._state !== States.PENDING) {\n        return;\n      }\n\n      if (isThenable(value)) {\n        void (value as PromiseLike<T>).then(resolve, reject);\n        return;\n      }\n\n      this._state = state;\n      this._value = value;\n\n      this._executeHandlers();\n    };\n\n    const resolve = (value: unknown): void => {\n      setResult(States.RESOLVED, value);\n    };\n\n    const reject = (reason: unknown): void => {\n      setResult(States.REJECTED, reason);\n    };\n\n    try {\n      executor(resolve, reject);\n    } catch (e) {\n      reject(e);\n    }\n  }\n}\n","import { GLOBAL_OBJ } from './worldwide';\n\nconst ONE_SECOND_IN_MS = 1000;\n\n/**\n * A partial definition of the [Performance Web API]{@link https://developer.mozilla.org/en-US/docs/Web/API/Performance}\n * for accessing a high-resolution monotonic clock.\n */\ninterface Performance {\n  /**\n   * The millisecond timestamp at which measurement began, measured in Unix time.\n   */\n  timeOrigin: number;\n  /**\n   * Returns the current millisecond timestamp, where 0 represents the start of measurement.\n   */\n  now(): number;\n}\n\n/**\n * Returns a timestamp in seconds since the UNIX epoch using the Date API.\n */\nexport function dateTimestampInSeconds(): number {\n  return Date.now() / ONE_SECOND_IN_MS;\n}\n\n/**\n * Returns a wrapper around the native Performance API browser implementation, or undefined for browsers that do not\n * support the API.\n *\n * Wrapping the native API works around differences in behavior from different browsers.\n */\nfunction createUnixTimestampInSecondsFunc(): () => number {\n  const { performance } = GLOBAL_OBJ as typeof GLOBAL_OBJ & { performance?: Performance };\n  if (!performance?.now) {\n    return dateTimestampInSeconds;\n  }\n\n  // Some browser and environments don't have a timeOrigin, so we fallback to\n  // using Date.now() to compute the starting time.\n  const approxStartingTimeOrigin = Date.now() - performance.now();\n  const timeOrigin = performance.timeOrigin == undefined ? approxStartingTimeOrigin : performance.timeOrigin;\n\n  // performance.now() is a monotonic clock, which means it starts at 0 when the process begins. To get the current\n  // wall clock time (actual UNIX timestamp), we need to add the starting time origin and the current time elapsed.\n  //\n  // TODO: This does not account for the case where the monotonic clock that powers performance.now() drifts from the\n  // wall clock time, which causes the returned timestamp to be inaccurate. We should investigate how to detect and\n  // correct for this.\n  // See: https://github.com/getsentry/sentry-javascript/issues/2590\n  // See: https://github.com/mdn/content/issues/4713\n  // See: https://dev.to/noamr/when-a-millisecond-is-not-a-millisecond-3h6\n  return () => {\n    return (timeOrigin + performance.now()) / ONE_SECOND_IN_MS;\n  };\n}\n\n/**\n * Returns a timestamp in seconds since the UNIX epoch using either the Performance or Date APIs, depending on the\n * availability of the Performance API.\n *\n * BUG: Note that because of how browsers implement the Performance API, the clock might stop when the computer is\n * asleep. This creates a skew between `dateTimestampInSeconds` and `timestampInSeconds`. The\n * skew can grow to arbitrary amounts like days, weeks or months.\n * See https://github.com/getsentry/sentry-javascript/issues/2590.\n */\nexport const timestampInSeconds = createUnixTimestampInSecondsFunc();\n\n/**\n * Cached result of getBrowserTimeOrigin.\n */\nlet cachedTimeOrigin: [number | undefined, string] | undefined;\n\n/**\n * Gets the time origin and the mode used to determine it.\n */\nfunction getBrowserTimeOrigin(): [number | undefined, string] {\n  // Unfortunately browsers may report an inaccurate time origin data, through either performance.timeOrigin or\n  // performance.timing.navigationStart, which results in poor results in performance data. We only treat time origin\n  // data as reliable if they are within a reasonable threshold of the current time.\n\n  const { performance } = GLOBAL_OBJ as typeof GLOBAL_OBJ & Window;\n  if (!performance?.now) {\n    return [undefined, 'none'];\n  }\n\n  const threshold = 3600 * 1000;\n  const performanceNow = performance.now();\n  const dateNow = Date.now();\n\n  // if timeOrigin isn't available set delta to threshold so it isn't used\n  const timeOriginDelta = performance.timeOrigin\n    ? Math.abs(performance.timeOrigin + performanceNow - dateNow)\n    : threshold;\n  const timeOriginIsReliable = timeOriginDelta < threshold;\n\n  // While performance.timing.navigationStart is deprecated in favor of performance.timeOrigin, performance.timeOrigin\n  // is not as widely supported. Namely, performance.timeOrigin is undefined in Safari as of writing.\n  // Also as of writing, performance.timing is not available in Web Workers in mainstream browsers, so it is not always\n  // a valid fallback. In the absence of an initial time provided by the browser, fallback to the current time from the\n  // Date API.\n  // eslint-disable-next-line deprecation/deprecation\n  const navigationStart = performance.timing?.navigationStart;\n  const hasNavigationStart = typeof navigationStart === 'number';\n  // if navigationStart isn't available set delta to threshold so it isn't used\n  const navigationStartDelta = hasNavigationStart ? Math.abs(navigationStart + performanceNow - dateNow) : threshold;\n  const navigationStartIsReliable = navigationStartDelta < threshold;\n\n  if (timeOriginIsReliable || navigationStartIsReliable) {\n    // Use the more reliable time origin\n    if (timeOriginDelta <= navigationStartDelta) {\n      return [performance.timeOrigin, 'timeOrigin'];\n    } else {\n      return [navigationStart, 'navigationStart'];\n    }\n  }\n\n  // Either both timeOrigin and navigationStart are skewed or neither is available, fallback to Date.\n  return [dateNow, 'dateNow'];\n}\n\n/**\n * The number of milliseconds since the UNIX epoch. This value is only usable in a browser, and only when the\n * performance API is available.\n */\nexport function browserPerformanceTimeOrigin(): number | undefined {\n  if (!cachedTimeOrigin) {\n    cachedTimeOrigin = getBrowserTimeOrigin();\n  }\n\n  return cachedTimeOrigin[0];\n}\n","// This is a magic string replaced by rollup\ndeclare const __SENTRY_SDK_VERSION__: string;\n\nexport const SDK_VERSION = typeof __SENTRY_SDK_VERSION__ === 'string' ? __SENTRY_SDK_VERSION__ : '0.0.0-unknown.0';\n","/**\n * NOTE: In order to avoid circular dependencies, if you add a function to this module and it needs to print something,\n * you must either a) use `console.log` rather than the logger, or b) put your function elsewhere.\n *\n * Note: This file was originally called `global.ts`, but was changed to unblock users which might be doing\n * string replaces with bundlers like Vite for `global` (would break imports that rely on importing from utils/src/global).\n *\n * Why worldwide?\n *\n * Why not?\n */\n\n/* eslint-disable @typescript-eslint/no-explicit-any */\n\nimport type { Carrier } from '../carrier';\nimport type { SdkSource } from './env';\n\n/** Internal global with common properties and Sentry extensions  */\nexport type InternalGlobal = {\n  navigator?: { userAgent?: string; maxTouchPoints?: number };\n  console: Console;\n  PerformanceObserver?: any;\n  Sentry?: any;\n  onerror?: {\n    (event: object | string, source?: string, lineno?: number, colno?: number, error?: Error): any;\n    __SENTRY_INSTRUMENTED__?: true;\n  };\n  onunhandledrejection?: {\n    (event: unknown): boolean;\n    __SENTRY_INSTRUMENTED__?: true;\n  };\n  SENTRY_ENVIRONMENT?: string;\n  SENTRY_DSN?: string;\n  SENTRY_RELEASE?: {\n    id?: string;\n  };\n  SENTRY_SDK_SOURCE?: SdkSource;\n  /**\n   * Debug IDs are indirectly injected by Sentry CLI or bundler plugins to directly reference a particular source map\n   * for resolving of a source file. The injected code will place an entry into the record for each loaded bundle/JS\n   * file.\n   */\n  _sentryDebugIds?: Record<string, string>;\n  /**\n   * Raw module metadata that is injected by bundler plugins.\n   *\n   * Keys are `error.stack` strings, values are the metadata.\n   */\n  _sentryModuleMetadata?: Record<string, any>;\n  _sentryEsmLoaderHookRegistered?: boolean;\n} & Carrier;\n\n/** Get's the global object for the current JavaScript runtime */\nexport const GLOBAL_OBJ = globalThis as unknown as InternalGlobal;\n","import type { Event } from '../types-hoist';\n\n/**\n * Get a list of possible event messages from a Sentry event.\n */\nexport function getPossibleEventMessages(event: Event): string[] {\n  const possibleMessages: string[] = [];\n\n  if (event.message) {\n    possibleMessages.push(event.message);\n  }\n\n  try {\n    // @ts-expect-error Try catching to save bundle size\n    const lastException = event.exception.values[event.exception.values.length - 1];\n    if (lastException?.value) {\n      possibleMessages.push(lastException.value);\n      if (lastException.type) {\n        possibleMessages.push(`${lastException.type}: ${lastException.value}`);\n      }\n    }\n  } catch (e) {\n    // ignore errors here\n  }\n\n  return possibleMessages;\n}\n","/**\n * Shallow merge two objects.\n * Does not mutate the passed in objects.\n * Undefined/empty values in the merge object will overwrite existing values.\n *\n * By default, this merges 2 levels deep.\n */\nexport function merge<T>(initialObj: T, mergeObj: T, levels = 2): T {\n  // If the merge value is not an object, or we have no merge levels left,\n  // we just set the value to the merge value\n  if (!mergeObj || typeof mergeObj !== 'object' || levels <= 0) {\n    return mergeObj;\n  }\n\n  // If the merge object is an empty object, and the initial object is not undefined, we return the initial object\n  if (initialObj && Object.keys(mergeObj).length === 0) {\n    return initialObj;\n  }\n\n  // Clone object\n  const output = { ...initialObj };\n\n  // Merge values into output, resursively\n  for (const key in mergeObj) {\n    if (Object.prototype.hasOwnProperty.call(mergeObj, key)) {\n      output[key] = merge(output[key], mergeObj[key], levels - 1);\n    }\n  }\n\n  return output;\n}\n","import { DEBUG_BUILD } from './debug-build';\nimport type { Event, EventHint, EventProcessor } from './types-hoist';\nimport { isThenable } from './utils-hoist/is';\nimport { logger } from './utils-hoist/logger';\nimport { SyncPromise } from './utils-hoist/syncpromise';\n\n/**\n * Process an array of event processors, returning the processed event (or `null` if the event was dropped).\n */\nexport function notifyEventProcessors(\n  processors: EventProcessor[],\n  event: Event | null,\n  hint: EventHint,\n  index: number = 0,\n): PromiseLike<Event | null> {\n  return new SyncPromise<Event | null>((resolve, reject) => {\n    const processor = processors[index];\n    if (event === null || typeof processor !== 'function') {\n      resolve(event);\n    } else {\n      const result = processor({ ...event }, hint) as Event | null;\n\n      DEBUG_BUILD && processor.id && result === null && logger.log(`Event processor \"${processor.id}\" dropped event`);\n\n      if (isThenable(result)) {\n        void result\n          .then(final => notifyEventProcessors(processors, final, hint, index + 1).then(resolve))\n          .then(null, reject);\n      } else {\n        void notifyEventProcessors(processors, result, hint, index + 1)\n          .then(resolve)\n          .then(null, reject);\n      }\n    }\n  });\n}\n","import type { DebugImage, StackParser } from '../types-hoist';\nimport { GLOBAL_OBJ } from './worldwide';\n\ntype StackString = string;\ntype CachedResult = [string, string];\n\nlet parsedStackResults: Record<StackString, CachedResult> | undefined;\nlet lastKeysCount: number | undefined;\nlet cachedFilenameDebugIds: Record<string, string> | undefined;\n\n/**\n * Returns a map of filenames to debug identifiers.\n */\nexport function getFilenameToDebugIdMap(stackParser: StackParser): Record<string, string> {\n  const debugIdMap = GLOBAL_OBJ._sentryDebugIds;\n  if (!debugIdMap) {\n    return {};\n  }\n\n  const debugIdKeys = Object.keys(debugIdMap);\n\n  // If the count of registered globals hasn't changed since the last call, we\n  // can just return the cached result.\n  if (cachedFilenameDebugIds && debugIdKeys.length === lastKeysCount) {\n    return cachedFilenameDebugIds;\n  }\n\n  lastKeysCount = debugIdKeys.length;\n\n  // Build a map of filename -> debug_id.\n  cachedFilenameDebugIds = debugIdKeys.reduce<Record<string, string>>((acc, stackKey) => {\n    if (!parsedStackResults) {\n      parsedStackResults = {};\n    }\n\n    const result = parsedStackResults[stackKey];\n\n    if (result) {\n      acc[result[0]] = result[1];\n    } else {\n      const parsedStack = stackParser(stackKey);\n\n      for (let i = parsedStack.length - 1; i >= 0; i--) {\n        const stackFrame = parsedStack[i];\n        const filename = stackFrame?.filename;\n        const debugId = debugIdMap[stackKey];\n\n        if (filename && debugId) {\n          acc[filename] = debugId;\n          parsedStackResults[stackKey] = [filename, debugId];\n          break;\n        }\n      }\n    }\n\n    return acc;\n  }, {});\n\n  return cachedFilenameDebugIds;\n}\n\n/**\n * Returns a list of debug images for the given resources.\n */\nexport function getDebugImagesForResources(\n  stackParser: StackParser,\n  resource_paths: ReadonlyArray<string>,\n): DebugImage[] {\n  const filenameDebugIdMap = getFilenameToDebugIdMap(stackParser);\n\n  if (!filenameDebugIdMap) {\n    return [];\n  }\n\n  const images: DebugImage[] = [];\n  for (const path of resource_paths) {\n    if (path && filenameDebugIdMap[path]) {\n      images.push({\n        type: 'sourcemap',\n        code_file: path,\n        debug_id: filenameDebugIdMap[path] as string,\n      });\n    }\n  }\n\n  return images;\n}\n","import type { ScopeData } from '../scope';\nimport { getDynamicSamplingContextFromSpan } from '../tracing/dynamicSamplingContext';\nimport type { Breadcrumb, Event, Span } from '../types-hoist';\nimport { dropUndefinedKeys } from '../utils-hoist/object';\nimport { merge } from './merge';\nimport { getRootSpan, spanToJSON, spanToTraceContext } from './spanUtils';\n\n/**\n * Applies data from the scope to the event and runs all event processors on it.\n */\nexport function applyScopeDataToEvent(event: Event, data: ScopeData): void {\n  const { fingerprint, span, breadcrumbs, sdkProcessingMetadata } = data;\n\n  // Apply general data\n  applyDataToEvent(event, data);\n\n  // We want to set the trace context for normal events only if there isn't already\n  // a trace context on the event. There is a product feature in place where we link\n  // errors with transaction and it relies on that.\n  if (span) {\n    applySpanToEvent(event, span);\n  }\n\n  applyFingerprintToEvent(event, fingerprint);\n  applyBreadcrumbsToEvent(event, breadcrumbs);\n  applySdkMetadataToEvent(event, sdkProcessingMetadata);\n}\n\n/** Merge data of two scopes together. */\nexport function mergeScopeData(data: ScopeData, mergeData: ScopeData): void {\n  const {\n    extra,\n    tags,\n    user,\n    contexts,\n    level,\n    sdkProcessingMetadata,\n    breadcrumbs,\n    fingerprint,\n    eventProcessors,\n    attachments,\n    propagationContext,\n    transactionName,\n    span,\n  } = mergeData;\n\n  mergeAndOverwriteScopeData(data, 'extra', extra);\n  mergeAndOverwriteScopeData(data, 'tags', tags);\n  mergeAndOverwriteScopeData(data, 'user', user);\n  mergeAndOverwriteScopeData(data, 'contexts', contexts);\n\n  data.sdkProcessingMetadata = merge(data.sdkProcessingMetadata, sdkProcessingMetadata, 2);\n\n  if (level) {\n    data.level = level;\n  }\n\n  if (transactionName) {\n    data.transactionName = transactionName;\n  }\n\n  if (span) {\n    data.span = span;\n  }\n\n  if (breadcrumbs.length) {\n    data.breadcrumbs = [...data.breadcrumbs, ...breadcrumbs];\n  }\n\n  if (fingerprint.length) {\n    data.fingerprint = [...data.fingerprint, ...fingerprint];\n  }\n\n  if (eventProcessors.length) {\n    data.eventProcessors = [...data.eventProcessors, ...eventProcessors];\n  }\n\n  if (attachments.length) {\n    data.attachments = [...data.attachments, ...attachments];\n  }\n\n  data.propagationContext = { ...data.propagationContext, ...propagationContext };\n}\n\n/**\n * Merges certain scope data. Undefined values will overwrite any existing values.\n * Exported only for tests.\n */\nexport function mergeAndOverwriteScopeData<\n  Prop extends 'extra' | 'tags' | 'user' | 'contexts' | 'sdkProcessingMetadata',\n  Data extends ScopeData,\n>(data: Data, prop: Prop, mergeVal: Data[Prop]): void {\n  data[prop] = merge(data[prop], mergeVal, 1);\n}\n\n/** Exported only for tests */\nexport function mergeArray<Prop extends 'breadcrumbs' | 'fingerprint'>(\n  event: Event,\n  prop: Prop,\n  mergeVal: ScopeData[Prop],\n): void {\n  const prevVal = event[prop];\n  // If we are not merging any new values,\n  // we only need to proceed if there was an empty array before (as we want to replace it with undefined)\n  if (!mergeVal.length && (!prevVal || prevVal.length)) {\n    return;\n  }\n\n  const merged = [...(prevVal || []), ...mergeVal] as ScopeData[Prop];\n  event[prop] = merged.length ? merged : undefined;\n}\n\nfunction applyDataToEvent(event: Event, data: ScopeData): void {\n  const { extra, tags, user, contexts, level, transactionName } = data;\n\n  const cleanedExtra = dropUndefinedKeys(extra);\n  if (Object.keys(cleanedExtra).length) {\n    event.extra = { ...cleanedExtra, ...event.extra };\n  }\n\n  const cleanedTags = dropUndefinedKeys(tags);\n  if (Object.keys(cleanedTags).length) {\n    event.tags = { ...cleanedTags, ...event.tags };\n  }\n\n  const cleanedUser = dropUndefinedKeys(user);\n  if (Object.keys(cleanedUser).length) {\n    event.user = { ...cleanedUser, ...event.user };\n  }\n\n  const cleanedContexts = dropUndefinedKeys(contexts);\n  if (Object.keys(cleanedContexts).length) {\n    event.contexts = { ...cleanedContexts, ...event.contexts };\n  }\n\n  if (level) {\n    event.level = level;\n  }\n\n  // transaction events get their `transaction` from the root span name\n  if (transactionName && event.type !== 'transaction') {\n    event.transaction = transactionName;\n  }\n}\n\nfunction applyBreadcrumbsToEvent(event: Event, breadcrumbs: Breadcrumb[]): void {\n  const mergedBreadcrumbs = [...(event.breadcrumbs || []), ...breadcrumbs];\n  event.breadcrumbs = mergedBreadcrumbs.length ? mergedBreadcrumbs : undefined;\n}\n\nfunction applySdkMetadataToEvent(event: Event, sdkProcessingMetadata: ScopeData['sdkProcessingMetadata']): void {\n  event.sdkProcessingMetadata = {\n    ...event.sdkProcessingMetadata,\n    ...sdkProcessingMetadata,\n  };\n}\n\nfunction applySpanToEvent(event: Event, span: Span): void {\n  event.contexts = {\n    trace: spanToTraceContext(span),\n    ...event.contexts,\n  };\n\n  event.sdkProcessingMetadata = {\n    dynamicSamplingContext: getDynamicSamplingContextFromSpan(span),\n    ...event.sdkProcessingMetadata,\n  };\n\n  const rootSpan = getRootSpan(span);\n  const transactionName = spanToJSON(rootSpan).description;\n  if (transactionName && !event.transaction && event.type === 'transaction') {\n    event.transaction = transactionName;\n  }\n}\n\n/**\n * Applies fingerprint from the scope to the event if there's one,\n * uses message if there's one instead or get rid of empty fingerprint\n */\nfunction applyFingerprintToEvent(event: Event, fingerprint: ScopeData['fingerprint'] | undefined): void {\n  // Make sure it's an array first and we actually have something in place\n  event.fingerprint = event.fingerprint\n    ? Array.isArray(event.fingerprint)\n      ? event.fingerprint\n      : [event.fingerprint]\n    : [];\n\n  // If we have something on the scope, then merge it with event\n  if (fingerprint) {\n    event.fingerprint = event.fingerprint.concat(fingerprint);\n  }\n\n  // If we have no data at all, remove empty array default\n  if (!event.fingerprint.length) {\n    delete event.fingerprint;\n  }\n}\n","import type { Client } from '../client';\nimport { DEFAULT_ENVIRONMENT } from '../constants';\nimport { getGlobalScope } from '../currentScopes';\nimport { notifyEventProcessors } from '../eventProcessors';\nimport type { CaptureContext, ScopeContext } from '../scope';\nimport { Scope } from '../scope';\nimport type { ClientOptions, Event, EventHint, StackParser } from '../types-hoist';\nimport { getFilenameToDebugIdMap } from '../utils-hoist/debug-ids';\nimport { addExceptionMechanism, uuid4 } from '../utils-hoist/misc';\nimport { normalize } from '../utils-hoist/normalize';\nimport { truncate } from '../utils-hoist/string';\nimport { dateTimestampInSeconds } from '../utils-hoist/time';\nimport { applyScopeDataToEvent, mergeScopeData } from './applyScopeDataToEvent';\n\n/**\n * This type makes sure that we get either a CaptureContext, OR an EventHint.\n * It does not allow mixing them, which could lead to unexpected outcomes, e.g. this is disallowed:\n * { user: { id: '123' }, mechanism: { handled: false } }\n */\nexport type ExclusiveEventHintOrCaptureContext =\n  | (CaptureContext & Partial<{ [key in keyof EventHint]: never }>)\n  | (EventHint & Partial<{ [key in keyof ScopeContext]: never }>);\n\n/**\n * Adds common information to events.\n *\n * The information includes release and environment from `options`,\n * breadcrumbs and context (extra, tags and user) from the scope.\n *\n * Information that is already present in the event is never overwritten. For\n * nested objects, such as the context, keys are merged.\n *\n * @param event The original event.\n * @param hint May contain additional information about the original exception.\n * @param scope A scope containing event metadata.\n * @returns A new event with more information.\n * @hidden\n */\nexport function prepareEvent(\n  options: ClientOptions,\n  event: Event,\n  hint: EventHint,\n  scope?: Scope,\n  client?: Client,\n  isolationScope?: Scope,\n): PromiseLike<Event | null> {\n  const { normalizeDepth = 3, normalizeMaxBreadth = 1_000 } = options;\n  const prepared: Event = {\n    ...event,\n    event_id: event.event_id || hint.event_id || uuid4(),\n    timestamp: event.timestamp || dateTimestampInSeconds(),\n  };\n  const integrations = hint.integrations || options.integrations.map(i => i.name);\n\n  applyClientOptions(prepared, options);\n  applyIntegrationsMetadata(prepared, integrations);\n\n  if (client) {\n    client.emit('applyFrameMetadata', event);\n  }\n\n  // Only put debug IDs onto frames for error events.\n  if (event.type === undefined) {\n    applyDebugIds(prepared, options.stackParser);\n  }\n\n  // If we have scope given to us, use it as the base for further modifications.\n  // This allows us to prevent unnecessary copying of data if `captureContext` is not provided.\n  const finalScope = getFinalScope(scope, hint.captureContext);\n\n  if (hint.mechanism) {\n    addExceptionMechanism(prepared, hint.mechanism);\n  }\n\n  const clientEventProcessors = client ? client.getEventProcessors() : [];\n\n  // This should be the last thing called, since we want that\n  // {@link Scope.addEventProcessor} gets the finished prepared event.\n  // Merge scope data together\n  const data = getGlobalScope().getScopeData();\n\n  if (isolationScope) {\n    const isolationData = isolationScope.getScopeData();\n    mergeScopeData(data, isolationData);\n  }\n\n  if (finalScope) {\n    const finalScopeData = finalScope.getScopeData();\n    mergeScopeData(data, finalScopeData);\n  }\n\n  const attachments = [...(hint.attachments || []), ...data.attachments];\n  if (attachments.length) {\n    hint.attachments = attachments;\n  }\n\n  applyScopeDataToEvent(prepared, data);\n\n  const eventProcessors = [\n    ...clientEventProcessors,\n    // Run scope event processors _after_ all other processors\n    ...data.eventProcessors,\n  ];\n\n  const result = notifyEventProcessors(eventProcessors, prepared, hint);\n\n  return result.then(evt => {\n    if (evt) {\n      // We apply the debug_meta field only after all event processors have ran, so that if any event processors modified\n      // file names (e.g.the RewriteFrames integration) the filename -> debug ID relationship isn't destroyed.\n      // This should not cause any PII issues, since we're only moving data that is already on the event and not adding\n      // any new data\n      applyDebugMeta(evt);\n    }\n\n    if (typeof normalizeDepth === 'number' && normalizeDepth > 0) {\n      return normalizeEvent(evt, normalizeDepth, normalizeMaxBreadth);\n    }\n    return evt;\n  });\n}\n\n/**\n * Enhances event using the client configuration.\n * It takes care of all \"static\" values like environment, release and `dist`,\n * as well as truncating overly long values.\n *\n * Only exported for tests.\n *\n * @param event event instance to be enhanced\n */\nexport function applyClientOptions(event: Event, options: ClientOptions): void {\n  const { environment, release, dist, maxValueLength = 250 } = options;\n\n  // empty strings do not make sense for environment, release, and dist\n  // so we handle them the same as if they were not provided\n  event.environment = event.environment || environment || DEFAULT_ENVIRONMENT;\n\n  if (!event.release && release) {\n    event.release = release;\n  }\n\n  if (!event.dist && dist) {\n    event.dist = dist;\n  }\n\n  if (event.message) {\n    event.message = truncate(event.message, maxValueLength);\n  }\n\n  const exception = event.exception?.values?.[0];\n  if (exception?.value) {\n    exception.value = truncate(exception.value, maxValueLength);\n  }\n\n  const request = event.request;\n  if (request?.url) {\n    request.url = truncate(request.url, maxValueLength);\n  }\n}\n\n/**\n * Puts debug IDs into the stack frames of an error event.\n */\nexport function applyDebugIds(event: Event, stackParser: StackParser): void {\n  // Build a map of filename -> debug_id\n  const filenameDebugIdMap = getFilenameToDebugIdMap(stackParser);\n\n  event.exception?.values?.forEach(exception => {\n    exception.stacktrace?.frames?.forEach(frame => {\n      if (frame.filename) {\n        frame.debug_id = filenameDebugIdMap[frame.filename];\n      }\n    });\n  });\n}\n\n/**\n * Moves debug IDs from the stack frames of an error event into the debug_meta field.\n */\nexport function applyDebugMeta(event: Event): void {\n  // Extract debug IDs and filenames from the stack frames on the event.\n  const filenameDebugIdMap: Record<string, string> = {};\n  event.exception?.values?.forEach(exception => {\n    exception.stacktrace?.frames?.forEach(frame => {\n      if (frame.debug_id) {\n        if (frame.abs_path) {\n          filenameDebugIdMap[frame.abs_path] = frame.debug_id;\n        } else if (frame.filename) {\n          filenameDebugIdMap[frame.filename] = frame.debug_id;\n        }\n        delete frame.debug_id;\n      }\n    });\n  });\n\n  if (Object.keys(filenameDebugIdMap).length === 0) {\n    return;\n  }\n\n  // Fill debug_meta information\n  event.debug_meta = event.debug_meta || {};\n  event.debug_meta.images = event.debug_meta.images || [];\n  const images = event.debug_meta.images;\n  Object.entries(filenameDebugIdMap).forEach(([filename, debug_id]) => {\n    images.push({\n      type: 'sourcemap',\n      code_file: filename,\n      debug_id,\n    });\n  });\n}\n\n/**\n * This function adds all used integrations to the SDK info in the event.\n * @param event The event that will be filled with all integrations.\n */\nfunction applyIntegrationsMetadata(event: Event, integrationNames: string[]): void {\n  if (integrationNames.length > 0) {\n    event.sdk = event.sdk || {};\n    event.sdk.integrations = [...(event.sdk.integrations || []), ...integrationNames];\n  }\n}\n\n/**\n * Applies `normalize` function on necessary `Event` attributes to make them safe for serialization.\n * Normalized keys:\n * - `breadcrumbs.data`\n * - `user`\n * - `contexts`\n * - `extra`\n * @param event Event\n * @returns Normalized event\n */\nfunction normalizeEvent(event: Event | null, depth: number, maxBreadth: number): Event | null {\n  if (!event) {\n    return null;\n  }\n\n  const normalized: Event = {\n    ...event,\n    ...(event.breadcrumbs && {\n      breadcrumbs: event.breadcrumbs.map(b => ({\n        ...b,\n        ...(b.data && {\n          data: normalize(b.data, depth, maxBreadth),\n        }),\n      })),\n    }),\n    ...(event.user && {\n      user: normalize(event.user, depth, maxBreadth),\n    }),\n    ...(event.contexts && {\n      contexts: normalize(event.contexts, depth, maxBreadth),\n    }),\n    ...(event.extra && {\n      extra: normalize(event.extra, depth, maxBreadth),\n    }),\n  };\n\n  // event.contexts.trace stores information about a Transaction. Similarly,\n  // event.spans[] stores information about child Spans. Given that a\n  // Transaction is conceptually a Span, normalization should apply to both\n  // Transactions and Spans consistently.\n  // For now the decision is to skip normalization of Transactions and Spans,\n  // so this block overwrites the normalized event to add back the original\n  // Transaction information prior to normalization.\n  if (event.contexts?.trace && normalized.contexts) {\n    normalized.contexts.trace = event.contexts.trace;\n\n    // event.contexts.trace.data may contain circular/dangerous data so we need to normalize it\n    if (event.contexts.trace.data) {\n      normalized.contexts.trace.data = normalize(event.contexts.trace.data, depth, maxBreadth);\n    }\n  }\n\n  // event.spans[].data may contain circular/dangerous data so we need to normalize it\n  if (event.spans) {\n    normalized.spans = event.spans.map(span => {\n      return {\n        ...span,\n        ...(span.data && {\n          data: normalize(span.data, depth, maxBreadth),\n        }),\n      };\n    });\n  }\n\n  // event.contexts.flags (FeatureFlagContext) stores context for our feature\n  // flag integrations. It has a greater nesting depth than our other typed\n  // Contexts, so we re-normalize with a fixed depth of 3 here. We do not want\n  // to skip this in case of conflicting, user-provided context.\n  if (event.contexts?.flags && normalized.contexts) {\n    normalized.contexts.flags = normalize(event.contexts.flags, 3, maxBreadth);\n  }\n\n  return normalized;\n}\n\nfunction getFinalScope(scope: Scope | undefined, captureContext: CaptureContext | undefined): Scope | undefined {\n  if (!captureContext) {\n    return scope;\n  }\n\n  const finalScope = scope ? scope.clone() : new Scope();\n  finalScope.update(captureContext);\n  return finalScope;\n}\n\n/**\n * Parse either an `EventHint` directly, or convert a `CaptureContext` to an `EventHint`.\n * This is used to allow to update method signatures that used to accept a `CaptureContext` but should now accept an `EventHint`.\n */\nexport function parseEventHintOrCaptureContext(\n  hint: ExclusiveEventHintOrCaptureContext | undefined,\n): EventHint | undefined {\n  if (!hint) {\n    return undefined;\n  }\n\n  // If you pass a Scope or `() => Scope` as CaptureContext, we just return this as captureContext\n  if (hintIsScopeOrFunction(hint)) {\n    return { captureContext: hint };\n  }\n\n  if (hintIsScopeContext(hint)) {\n    return {\n      captureContext: hint,\n    };\n  }\n\n  return hint;\n}\n\nfunction hintIsScopeOrFunction(hint: CaptureContext | EventHint): hint is Scope | ((scope: Scope) => Scope) {\n  return hint instanceof Scope || typeof hint === 'function';\n}\n\ntype ScopeContextProperty = keyof ScopeContext;\nconst captureContextKeys: readonly ScopeContextProperty[] = [\n  'user',\n  'level',\n  'extra',\n  'contexts',\n  'tags',\n  'fingerprint',\n  'propagationContext',\n] as const;\n\nfunction hintIsScopeContext(hint: Partial<ScopeContext> | EventHint): hint is Partial<ScopeContext> {\n  return Object.keys(hint).some(key => captureContextKeys.includes(key as ScopeContextProperty));\n}\n","import type { Span, SpanStatus } from '../types-hoist';\n\nexport const SPAN_STATUS_UNSET = 0;\nexport const SPAN_STATUS_OK = 1;\nexport const SPAN_STATUS_ERROR = 2;\n\n/**\n * Converts a HTTP status code into a sentry status with a message.\n *\n * @param httpStatus The HTTP response status code.\n * @returns The span status or unknown_error.\n */\n// https://develop.sentry.dev/sdk/event-payloads/span/\nexport function getSpanStatusFromHttpCode(httpStatus: number): SpanStatus {\n  if (httpStatus < 400 && httpStatus >= 100) {\n    return { code: SPAN_STATUS_OK };\n  }\n\n  if (httpStatus >= 400 && httpStatus < 500) {\n    switch (httpStatus) {\n      case 401:\n        return { code: SPAN_STATUS_ERROR, message: 'unauthenticated' };\n      case 403:\n        return { code: SPAN_STATUS_ERROR, message: 'permission_denied' };\n      case 404:\n        return { code: SPAN_STATUS_ERROR, message: 'not_found' };\n      case 409:\n        return { code: SPAN_STATUS_ERROR, message: 'already_exists' };\n      case 413:\n        return { code: SPAN_STATUS_ERROR, message: 'failed_precondition' };\n      case 429:\n        return { code: SPAN_STATUS_ERROR, message: 'resource_exhausted' };\n      case 499:\n        return { code: SPAN_STATUS_ERROR, message: 'cancelled' };\n      default:\n        return { code: SPAN_STATUS_ERROR, message: 'invalid_argument' };\n    }\n  }\n\n  if (httpStatus >= 500 && httpStatus < 600) {\n    switch (httpStatus) {\n      case 501:\n        return { code: SPAN_STATUS_ERROR, message: 'unimplemented' };\n      case 503:\n        return { code: SPAN_STATUS_ERROR, message: 'unavailable' };\n      case 504:\n        return { code: SPAN_STATUS_ERROR, message: 'deadline_exceeded' };\n      default:\n        return { code: SPAN_STATUS_ERROR, message: 'internal_error' };\n    }\n  }\n\n  return { code: SPAN_STATUS_ERROR, message: 'unknown_error' };\n}\n\n/**\n * Sets the Http status attributes on the current span based on the http code.\n * Additionally, the span's status is updated, depending on the http code.\n */\nexport function setHttpStatus(span: Span, httpStatus: number): void {\n  span.setAttribute('http.response.status_code', httpStatus);\n\n  const spanStatus = getSpanStatusFromHttpCode(httpStatus);\n  if (spanStatus.message !== 'unknown_error') {\n    span.setStatus(spanStatus);\n  }\n}\n","import { getAsyncContextStrategy } from '../asyncContext';\nimport { getMainCarrier } from '../carrier';\nimport { getCurrentScope } from '../currentScopes';\nimport {\n  SEMANTIC_ATTRIBUTE_SENTRY_CUSTOM_SPAN_NAME,\n  SEMANTIC_ATTRIBUTE_SENTRY_OP,\n  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,\n  SEMANTIC_ATTRIBUTE_SENTRY_SOURCE,\n} from '../semanticAttributes';\nimport type { SentrySpan } from '../tracing/sentrySpan';\nimport { SPAN_STATUS_OK, SPAN_STATUS_UNSET } from '../tracing/spanstatus';\nimport { getCapturedScopesOnSpan } from '../tracing/utils';\nimport type {\n  Span,\n  SpanAttributes,\n  SpanJSON,\n  SpanOrigin,\n  SpanStatus,\n  SpanTimeInput,\n  TraceContext,\n} from '../types-hoist';\nimport type { SpanLink, SpanLinkJSON } from '../types-hoist/link';\nimport { consoleSandbox } from '../utils-hoist/logger';\nimport { addNonEnumerableProperty, dropUndefinedKeys } from '../utils-hoist/object';\nimport { generateSpanId } from '../utils-hoist/propagationContext';\nimport { timestampInSeconds } from '../utils-hoist/time';\nimport { generateSentryTraceHeader } from '../utils-hoist/tracing';\nimport { _getSpanForScope } from './spanOnScope';\n\n// These are aligned with OpenTelemetry trace flags\nexport const TRACE_FLAG_NONE = 0x0;\nexport const TRACE_FLAG_SAMPLED = 0x1;\n\nlet hasShownSpanDropWarning = false;\n\n/**\n * Convert a span to a trace context, which can be sent as the `trace` context in an event.\n * By default, this will only include trace_id, span_id & parent_span_id.\n * If `includeAllData` is true, it will also include data, op, status & origin.\n */\nexport function spanToTransactionTraceContext(span: Span): TraceContext {\n  const { spanId: span_id, traceId: trace_id } = span.spanContext();\n  const { data, op, parent_span_id, status, origin, links } = spanToJSON(span);\n\n  return dropUndefinedKeys({\n    parent_span_id,\n    span_id,\n    trace_id,\n    data,\n    op,\n    status,\n    origin,\n    links,\n  });\n}\n\n/**\n * Convert a span to a trace context, which can be sent as the `trace` context in a non-transaction event.\n */\nexport function spanToTraceContext(span: Span): TraceContext {\n  const { spanId, traceId: trace_id, isRemote } = span.spanContext();\n\n  // If the span is remote, we use a random/virtual span as span_id to the trace context,\n  // and the remote span as parent_span_id\n  const parent_span_id = isRemote ? spanId : spanToJSON(span).parent_span_id;\n  const scope = getCapturedScopesOnSpan(span).scope;\n\n  const span_id = isRemote ? scope?.getPropagationContext().propagationSpanId || generateSpanId() : spanId;\n\n  return dropUndefinedKeys({\n    parent_span_id,\n    span_id,\n    trace_id,\n  });\n}\n\n/**\n * Convert a Span to a Sentry trace header.\n */\nexport function spanToTraceHeader(span: Span): string {\n  const { traceId, spanId } = span.spanContext();\n  const sampled = spanIsSampled(span);\n  return generateSentryTraceHeader(traceId, spanId, sampled);\n}\n\n/**\n *  Converts the span links array to a flattened version to be sent within an envelope.\n *\n *  If the links array is empty, it returns `undefined` so the empty value can be dropped before it's sent.\n */\nexport function convertSpanLinksForEnvelope(links?: SpanLink[]): SpanLinkJSON[] | undefined {\n  if (links && links.length > 0) {\n    return links.map(({ context: { spanId, traceId, traceFlags, ...restContext }, attributes }) => ({\n      span_id: spanId,\n      trace_id: traceId,\n      sampled: traceFlags === TRACE_FLAG_SAMPLED,\n      attributes,\n      ...restContext,\n    }));\n  } else {\n    return undefined;\n  }\n}\n\n/**\n * Convert a span time input into a timestamp in seconds.\n */\nexport function spanTimeInputToSeconds(input: SpanTimeInput | undefined): number {\n  if (typeof input === 'number') {\n    return ensureTimestampInSeconds(input);\n  }\n\n  if (Array.isArray(input)) {\n    // See {@link HrTime} for the array-based time format\n    return input[0] + input[1] / 1e9;\n  }\n\n  if (input instanceof Date) {\n    return ensureTimestampInSeconds(input.getTime());\n  }\n\n  return timestampInSeconds();\n}\n\n/**\n * Converts a timestamp to second, if it was in milliseconds, or keeps it as second.\n */\nfunction ensureTimestampInSeconds(timestamp: number): number {\n  const isMs = timestamp > 9999999999;\n  return isMs ? timestamp / 1000 : timestamp;\n}\n\n/**\n * Convert a span to a JSON representation.\n */\n// Note: Because of this, we currently have a circular type dependency (which we opted out of in package.json).\n// This is not avoidable as we need `spanToJSON` in `spanUtils.ts`, which in turn is needed by `span.ts` for backwards compatibility.\n// And `spanToJSON` needs the Span class from `span.ts` to check here.\nexport function spanToJSON(span: Span): SpanJSON {\n  if (spanIsSentrySpan(span)) {\n    return span.getSpanJSON();\n  }\n\n  const { spanId: span_id, traceId: trace_id } = span.spanContext();\n\n  // Handle a span from @opentelemetry/sdk-base-trace's `Span` class\n  if (spanIsOpenTelemetrySdkTraceBaseSpan(span)) {\n    const { attributes, startTime, name, endTime, parentSpanId, status, links } = span;\n\n    return dropUndefinedKeys({\n      span_id,\n      trace_id,\n      data: attributes,\n      description: name,\n      parent_span_id: parentSpanId,\n      start_timestamp: spanTimeInputToSeconds(startTime),\n      // This is [0,0] by default in OTEL, in which case we want to interpret this as no end time\n      timestamp: spanTimeInputToSeconds(endTime) || undefined,\n      status: getStatusMessage(status),\n      op: attributes[SEMANTIC_ATTRIBUTE_SENTRY_OP],\n      origin: attributes[SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN] as SpanOrigin | undefined,\n      links: convertSpanLinksForEnvelope(links),\n    });\n  }\n\n  // Finally, at least we have `spanContext()`....\n  // This should not actually happen in reality, but we need to handle it for type safety.\n  return {\n    span_id,\n    trace_id,\n    start_timestamp: 0,\n    data: {},\n  };\n}\n\nfunction spanIsOpenTelemetrySdkTraceBaseSpan(span: Span): span is OpenTelemetrySdkTraceBaseSpan {\n  const castSpan = span as Partial<OpenTelemetrySdkTraceBaseSpan>;\n  return !!castSpan.attributes && !!castSpan.startTime && !!castSpan.name && !!castSpan.endTime && !!castSpan.status;\n}\n\n/** Exported only for tests. */\nexport interface OpenTelemetrySdkTraceBaseSpan extends Span {\n  attributes: SpanAttributes;\n  startTime: SpanTimeInput;\n  name: string;\n  status: SpanStatus;\n  endTime: SpanTimeInput;\n  parentSpanId?: string;\n  links?: SpanLink[];\n}\n\n/**\n * Sadly, due to circular dependency checks we cannot actually import the Span class here and check for instanceof.\n * :( So instead we approximate this by checking if it has the `getSpanJSON` method.\n */\nfunction spanIsSentrySpan(span: Span): span is SentrySpan {\n  return typeof (span as SentrySpan).getSpanJSON === 'function';\n}\n\n/**\n * Returns true if a span is sampled.\n * In most cases, you should just use `span.isRecording()` instead.\n * However, this has a slightly different semantic, as it also returns false if the span is finished.\n * So in the case where this distinction is important, use this method.\n */\nexport function spanIsSampled(span: Span): boolean {\n  // We align our trace flags with the ones OpenTelemetry use\n  // So we also check for sampled the same way they do.\n  const { traceFlags } = span.spanContext();\n  return traceFlags === TRACE_FLAG_SAMPLED;\n}\n\n/** Get the status message to use for a JSON representation of a span. */\nexport function getStatusMessage(status: SpanStatus | undefined): string | undefined {\n  if (!status || status.code === SPAN_STATUS_UNSET) {\n    return undefined;\n  }\n\n  if (status.code === SPAN_STATUS_OK) {\n    return 'ok';\n  }\n\n  return status.message || 'unknown_error';\n}\n\nconst CHILD_SPANS_FIELD = '_sentryChildSpans';\nconst ROOT_SPAN_FIELD = '_sentryRootSpan';\n\ntype SpanWithPotentialChildren = Span & {\n  [CHILD_SPANS_FIELD]?: Set<Span>;\n  [ROOT_SPAN_FIELD]?: Span;\n};\n\n/**\n * Adds an opaque child span reference to a span.\n */\nexport function addChildSpanToSpan(span: SpanWithPotentialChildren, childSpan: Span): void {\n  // We store the root span reference on the child span\n  // We need this for `getRootSpan()` to work\n  const rootSpan = span[ROOT_SPAN_FIELD] || span;\n  addNonEnumerableProperty(childSpan as SpanWithPotentialChildren, ROOT_SPAN_FIELD, rootSpan);\n\n  // We store a list of child spans on the parent span\n  // We need this for `getSpanDescendants()` to work\n  if (span[CHILD_SPANS_FIELD]) {\n    span[CHILD_SPANS_FIELD].add(childSpan);\n  } else {\n    addNonEnumerableProperty(span, CHILD_SPANS_FIELD, new Set([childSpan]));\n  }\n}\n\n/** This is only used internally by Idle Spans. */\nexport function removeChildSpanFromSpan(span: SpanWithPotentialChildren, childSpan: Span): void {\n  if (span[CHILD_SPANS_FIELD]) {\n    span[CHILD_SPANS_FIELD].delete(childSpan);\n  }\n}\n\n/**\n * Returns an array of the given span and all of its descendants.\n */\nexport function getSpanDescendants(span: SpanWithPotentialChildren): Span[] {\n  const resultSet = new Set<Span>();\n\n  function addSpanChildren(span: SpanWithPotentialChildren): void {\n    // This exit condition is required to not infinitely loop in case of a circular dependency.\n    if (resultSet.has(span)) {\n      return;\n      // We want to ignore unsampled spans (e.g. non recording spans)\n    } else if (spanIsSampled(span)) {\n      resultSet.add(span);\n      const childSpans = span[CHILD_SPANS_FIELD] ? Array.from(span[CHILD_SPANS_FIELD]) : [];\n      for (const childSpan of childSpans) {\n        addSpanChildren(childSpan);\n      }\n    }\n  }\n\n  addSpanChildren(span);\n\n  return Array.from(resultSet);\n}\n\n/**\n * Returns the root span of a given span.\n */\nexport function getRootSpan(span: SpanWithPotentialChildren): Span {\n  return span[ROOT_SPAN_FIELD] || span;\n}\n\n/**\n * Returns the currently active span.\n */\nexport function getActiveSpan(): Span | undefined {\n  const carrier = getMainCarrier();\n  const acs = getAsyncContextStrategy(carrier);\n  if (acs.getActiveSpan) {\n    return acs.getActiveSpan();\n  }\n\n  return _getSpanForScope(getCurrentScope());\n}\n\n/**\n * Logs a warning once if `beforeSendSpan` is used to drop spans.\n */\nexport function showSpanDropWarning(): void {\n  if (!hasShownSpanDropWarning) {\n    consoleSandbox(() => {\n      // eslint-disable-next-line no-console\n      console.warn(\n        '[Sentry] Returning null from `beforeSendSpan` is disallowed. To drop certain spans, configure the respective integrations directly.',\n      );\n    });\n    hasShownSpanDropWarning = true;\n  }\n}\n\n/**\n * Updates the name of the given span and ensures that the span name is not\n * overwritten by the Sentry SDK.\n *\n * Use this function instead of `span.updateName()` if you want to make sure that\n * your name is kept. For some spans, for example root `http.server` spans the\n * Sentry SDK would otherwise overwrite the span name with a high-quality name\n * it infers when the span ends.\n *\n * Use this function in server code or when your span is started on the server\n * and on the client (browser). If you only update a span name on the client,\n * you can also use `span.updateName()` the SDK does not overwrite the name.\n *\n * @param span - The span to update the name of.\n * @param name - The name to set on the span.\n */\nexport function updateSpanName(span: Span, name: string): void {\n  span.updateName(name);\n  span.setAttributes({\n    [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'custom',\n    [SEMANTIC_ATTRIBUTE_SENTRY_CUSTOM_SPAN_NAME]: name,\n  });\n}\n","import { forwardRef } from \"react\";\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nfunction BlockIcon(props, ref) {\n  return /*#__PURE__*/_jsx(\"svg\", {\n    xmlns: \"http://www.w3.org/2000/svg\",\n    width: \"1em\",\n    height: \"1em\",\n    fill: \"currentColor\",\n    viewBox: \"0 0 24 24\",\n    ref: ref,\n    ...props,\n    children: /*#__PURE__*/_jsx(\"path\", {\n      d: \"M12 22a9.7 9.7 0 0 1-3.9-.788 10.1 10.1 0 0 1-3.175-2.137q-1.35-1.35-2.137-3.175A9.7 9.7 0 0 1 2 12q0-2.075.788-3.9a10.1 10.1 0 0 1 2.137-3.175q1.35-1.35 3.175-2.137A9.7 9.7 0 0 1 12 2q2.075 0 3.9.788a10.1 10.1 0 0 1 3.175 2.137q1.35 1.35 2.137 3.175A9.7 9.7 0 0 1 22 12a9.7 9.7 0 0 1-.788 3.9 10.1 10.1 0 0 1-2.137 3.175q-1.35 1.35-3.175 2.137A9.7 9.7 0 0 1 12 22m0-2q3.35 0 5.675-2.325T20 12q0-1.35-.437-2.6A8 8 0 0 0 18.3 7.1L7.1 18.3q1.05.825 2.3 1.262T12 20m-6.3-3.1L16.9 5.7a8 8 0 0 0-2.3-1.263A7.8 7.8 0 0 0 12 4Q8.65 4 6.325 6.325T4 12q0 1.35.438 2.6A8 8 0 0 0 5.7 16.9\"\n    })\n  });\n}\n;\nBlockIcon.displayName = \"BlockIcon\";\nexport default forwardRef(BlockIcon);","import { forwardRef } from \"react\";\nimport { jsx as _jsx, jsxs as _jsxs } from \"react/jsx-runtime\";\nfunction ChatProblemIcon(props, ref) {\n  return /*#__PURE__*/_jsxs(\"svg\", {\n    xmlns: \"http://www.w3.org/2000/svg\",\n    width: \"1em\",\n    height: \"1em\",\n    fill: \"currentColor\",\n    viewBox: \"0 0 24 24\",\n    ref: ref,\n    ...props,\n    children: [/*#__PURE__*/_jsx(\"path\", {\n      d: \"M12.713 16.713A.97.97 0 0 1 12 17a.97.97 0 0 1-.713-.288A.97.97 0 0 1 11 16q0-.424.287-.713A.97.97 0 0 1 12 15q.424 0 .713.287.287.288.287.713 0 .424-.287.712m0-3.999A.97.97 0 0 1 12 13a.97.97 0 0 1-.713-.287A.97.97 0 0 1 11 12V8q0-.424.287-.713A.97.97 0 0 1 12 7q.424 0 .713.287Q13 7.576 13 8v4q0 .424-.287.713\"\n    }), /*#__PURE__*/_jsx(\"path\", {\n      d: \"M2.95 16.3a10.2 10.2 0 0 1-.712-2.1A10.2 10.2 0 0 1 2 12q0-2.075.788-3.9a10.1 10.1 0 0 1 2.137-3.175q1.35-1.35 3.175-2.137A9.7 9.7 0 0 1 12 2q2.075 0 3.9.788a10.1 10.1 0 0 1 3.175 2.137q1.35 1.35 2.137 3.175A9.7 9.7 0 0 1 22 12a9.7 9.7 0 0 1-.788 3.9 10.1 10.1 0 0 1-2.137 3.175q-1.35 1.35-3.175 2.137A9.7 9.7 0 0 1 12 22q-1.125 0-2.2-.238a10.2 10.2 0 0 1-2.1-.712L2.75 22.5a.94.94 0 0 1-1-.25.94.94 0 0 1-.25-1zm4.2 2.8a1 1 0 0 1 .275-.062q.15-.013.275-.013.225 0 .438.038.212.036.412.137a7.4 7.4 0 0 0 1.675.6Q11.1 20 12 20q3.35 0 5.675-2.325T20 12t-2.325-5.675T12 4 6.325 6.325 4 12q0 .9.2 1.775t.6 1.675q.176.325.188.688t-.088.712l-.95 3.2z\"\n    })]\n  });\n}\n;\nChatProblemIcon.displayName = \"ChatProblemIcon\";\nexport default forwardRef(ChatProblemIcon);","import { forwardRef } from \"react\";\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nfunction ChatIcon(props, ref) {\n  return /*#__PURE__*/_jsx(\"svg\", {\n    xmlns: \"http://www.w3.org/2000/svg\",\n    width: \"1em\",\n    height: \"1em\",\n    fill: \"currentColor\",\n    viewBox: \"0 0 24 24\",\n    ref: ref,\n    ...props,\n    children: /*#__PURE__*/_jsx(\"path\", {\n      d: \"m1.5 21.25 1.45-4.95a10.2 10.2 0 0 1-.712-2.1A10.2 10.2 0 0 1 2 12q0-2.075.788-3.9a10.1 10.1 0 0 1 2.137-3.175q1.35-1.35 3.175-2.137A9.7 9.7 0 0 1 12 2q2.075 0 3.9.788a10.1 10.1 0 0 1 3.175 2.137q1.35 1.35 2.137 3.175A9.7 9.7 0 0 1 22 12a9.7 9.7 0 0 1-.788 3.9 10.1 10.1 0 0 1-2.137 3.175q-1.35 1.35-3.175 2.137A9.7 9.7 0 0 1 12 22q-1.125 0-2.2-.238a10.2 10.2 0 0 1-2.1-.712L2.75 22.5a.94.94 0 0 1-1-.25.94.94 0 0 1-.25-1m2.45-1.2 3.2-.95a1 1 0 0 1 .275-.062q.15-.013.275-.013.225 0 .438.038.212.036.412.137a7.4 7.4 0 0 0 1.675.6Q11.1 20 12 20q3.35 0 5.675-2.325T20 12t-2.325-5.675T12 4 6.325 6.325 4 12q0 .9.2 1.775t.6 1.675q.176.325.188.688t-.088.712z\"\n    })\n  });\n}\n;\nChatIcon.displayName = \"ChatIcon\";\nexport default forwardRef(ChatIcon);","import { forwardRef } from \"react\";\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nfunction CheckIcon(props, ref) {\n  return /*#__PURE__*/_jsx(\"svg\", {\n    xmlns: \"http://www.w3.org/2000/svg\",\n    width: \"1em\",\n    height: \"1em\",\n    fill: \"currentColor\",\n    viewBox: \"0 0 24 24\",\n    ref: ref,\n    ...props,\n    children: /*#__PURE__*/_jsx(\"path\", {\n      d: \"M9.55 17.575q-.2 0-.375-.062a.9.9 0 0 1-.325-.213L4.55 13q-.274-.274-.262-.713.012-.437.287-.712a.95.95 0 0 1 .7-.275q.425 0 .7.275L9.55 15.15l8.475-8.475q.274-.275.713-.275.437 0 .712.275.275.274.275.713 0 .437-.275.712l-9.2 9.2q-.15.15-.325.212a1.1 1.1 0 0 1-.375.063\"\n    })\n  });\n}\n;\nCheckIcon.displayName = \"CheckIcon\";\nexport default forwardRef(CheckIcon);","import { forwardRef } from \"react\";\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nfunction ChevronLeftIcon(props, ref) {\n  return /*#__PURE__*/_jsx(\"svg\", {\n    xmlns: \"http://www.w3.org/2000/svg\",\n    width: \"1em\",\n    height: \"1em\",\n    fill: \"currentColor\",\n    viewBox: \"0 0 24 24\",\n    ref: ref,\n    ...props,\n    children: /*#__PURE__*/_jsx(\"path\", {\n      d: \"m13.3 17.3-4.6-4.6a.9.9 0 0 1-.213-.325A1.1 1.1 0 0 1 8.425 12q0-.2.062-.375A.9.9 0 0 1 8.7 11.3l4.6-4.6a.95.95 0 0 1 .7-.275q.425 0 .7.275a.95.95 0 0 1 .275.7.95.95 0 0 1-.275.7L10.8 12l3.9 3.9a.95.95 0 0 1 .275.7.95.95 0 0 1-.275.7.95.95 0 0 1-.7.275.95.95 0 0 1-.7-.275\"\n    })\n  });\n}\n;\nChevronLeftIcon.displayName = \"ChevronLeftIcon\";\nexport default forwardRef(ChevronLeftIcon);","import { forwardRef } from \"react\";\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nfunction CloseIcon(props, ref) {\n  return /*#__PURE__*/_jsx(\"svg\", {\n    xmlns: \"http://www.w3.org/2000/svg\",\n    width: \"1em\",\n    height: \"1em\",\n    fill: \"currentColor\",\n    viewBox: \"0 0 24 24\",\n    ref: ref,\n    ...props,\n    children: /*#__PURE__*/_jsx(\"path\", {\n      d: \"M6.293 6.293a1 1 0 0 1 1.414 0L12 10.586l4.293-4.293a1 1 0 1 1 1.414 1.414L13.414 12l4.293 4.293a1 1 0 0 1-1.414 1.414L12 13.414l-4.293 4.293a1 1 0 0 1-1.414-1.414L10.586 12 6.293 7.707a1 1 0 0 1 0-1.414\"\n    })\n  });\n}\n;\nCloseIcon.displayName = \"CloseIcon\";\nexport default forwardRef(CloseIcon);","import { forwardRef } from \"react\";\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nfunction CollapseIcon(props, ref) {\n  return /*#__PURE__*/_jsx(\"svg\", {\n    xmlns: \"http://www.w3.org/2000/svg\",\n    width: \"1em\",\n    height: \"1em\",\n    fill: \"currentColor\",\n    viewBox: \"0 0 24 24\",\n    ref: ref,\n    ...props,\n    children: /*#__PURE__*/_jsx(\"path\", {\n      d: \"M12 11.034a1 1 0 0 0 .29.702l.005.005c.18.18.43.29.705.29h8a1 1 0 0 0 0-2h-5.586L22 3.445a1 1 0 0 0-1.414-1.414L14 8.617V3.031a1 1 0 1 0-2 0zm0 1.963a1 1 0 0 0-.29-.702l-.005-.004A1 1 0 0 0 11 12H3a1 1 0 1 0 0 2h5.586L2 20.586A1 1 0 1 0 3.414 22L10 15.414V21a1 1 0 0 0 2 0z\"\n    })\n  });\n}\n;\nCollapseIcon.displayName = \"CollapseIcon\";\nexport default forwardRef(CollapseIcon);","import { forwardRef } from \"react\";\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nfunction DeleteIcon(props, ref) {\n  return /*#__PURE__*/_jsx(\"svg\", {\n    xmlns: \"http://www.w3.org/2000/svg\",\n    width: \"1em\",\n    height: \"1em\",\n    fill: \"currentColor\",\n    viewBox: \"0 0 24 24\",\n    ref: ref,\n    ...props,\n    children: /*#__PURE__*/_jsx(\"path\", {\n      d: \"M7 21q-.824 0-1.412-.587A1.93 1.93 0 0 1 5 19V6a.97.97 0 0 1-.713-.287A.97.97 0 0 1 4 5q0-.424.287-.713A.97.97 0 0 1 5 4h4q0-.424.287-.712A.97.97 0 0 1 10 3h4q.424 0 .713.288Q15 3.575 15 4h4q.424 0 .712.287Q20 4.576 20 5t-.288.713A.97.97 0 0 1 19 6v13q0 .824-.587 1.413A1.93 1.93 0 0 1 17 21zM7 6v13h10V6zm2 10q0 .424.287.712Q9.576 17 10 17t.713-.288A.97.97 0 0 0 11 16V9a.97.97 0 0 0-.287-.713A.97.97 0 0 0 10 8a.97.97 0 0 0-.713.287A.97.97 0 0 0 9 9zm4 0q0 .424.287.712.288.288.713.288.424 0 .713-.288A.97.97 0 0 0 15 16V9a.97.97 0 0 0-.287-.713A.97.97 0 0 0 14 8a.97.97 0 0 0-.713.287A.97.97 0 0 0 13 9z\"\n    })\n  });\n}\n;\nDeleteIcon.displayName = \"DeleteIcon\";\nexport default forwardRef(DeleteIcon);","import { forwardRef } from \"react\";\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nfunction DownloadIcon(props, ref) {\n  return /*#__PURE__*/_jsx(\"svg\", {\n    xmlns: \"http://www.w3.org/2000/svg\",\n    width: \"1em\",\n    height: \"1em\",\n    fill: \"currentColor\",\n    viewBox: \"0 0 24 24\",\n    ref: ref,\n    ...props,\n    children: /*#__PURE__*/_jsx(\"path\", {\n      d: \"M12 15.575q-.2 0-.375-.062a.9.9 0 0 1-.325-.213l-3.6-3.6a.95.95 0 0 1-.275-.7q0-.425.275-.7.274-.275.712-.288t.713.263L11 12.15V5q0-.424.287-.713A.97.97 0 0 1 12 4q.424 0 .713.287Q13 4.576 13 5v7.15l1.875-1.875q.274-.274.713-.263.437.014.712.288a.95.95 0 0 1 .275.7.95.95 0 0 1-.275.7l-3.6 3.6q-.15.15-.325.212a1.1 1.1 0 0 1-.375.063M6 20q-.824 0-1.412-.587A1.93 1.93 0 0 1 4 18v-2q0-.424.287-.713A.97.97 0 0 1 5 15q.424 0 .713.287Q6 15.576 6 16v2h12v-2q0-.424.288-.713A.97.97 0 0 1 19 15q.424 0 .712.287.288.288.288.713v2q0 .824-.587 1.413A1.93 1.93 0 0 1 18 20z\"\n    })\n  });\n}\n;\nDownloadIcon.displayName = \"DownloadIcon\";\nexport default forwardRef(DownloadIcon);","import { forwardRef } from \"react\";\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nfunction EditIcon(props, ref) {\n  return /*#__PURE__*/_jsx(\"svg\", {\n    xmlns: \"http://www.w3.org/2000/svg\",\n    width: \"1em\",\n    height: \"1em\",\n    fill: \"currentColor\",\n    viewBox: \"0 0 24 24\",\n    ref: ref,\n    ...props,\n    children: /*#__PURE__*/_jsx(\"path\", {\n      fillRule: \"evenodd\",\n      d: \"M15.706 2.637a2 2 0 0 1 2.829 0l2.828 2.828a2 2 0 0 1 0 2.829L9.605 20.052a1 1 0 0 1-.465.263L3.483 21.73a1 1 0 0 1-1.212-1.213l1.414-5.657a1 1 0 0 1 .263-.465zm1.224 7.262L14.102 7.07l-8.544 8.544-.943 3.771 3.771-.943z\",\n      clipRule: \"evenodd\"\n    })\n  });\n}\n;\nEditIcon.displayName = \"EditIcon\";\nexport default forwardRef(EditIcon);","import { forwardRef } from \"react\";\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nfunction ErrorIcon(props, ref) {\n  return /*#__PURE__*/_jsx(\"svg\", {\n    xmlns: \"http://www.w3.org/2000/svg\",\n    width: \"1em\",\n    height: \"1em\",\n    fill: \"currentColor\",\n    viewBox: \"0 0 24 24\",\n    ref: ref,\n    ...props,\n    children: /*#__PURE__*/_jsx(\"path\", {\n      d: \"M12 17q.424 0 .713-.288A.97.97 0 0 0 13 16a.97.97 0 0 0-.287-.713A.97.97 0 0 0 12 15a.97.97 0 0 0-.713.287A.97.97 0 0 0 11 16q0 .424.287.712.288.288.713.288m0-4q.424 0 .713-.287A.97.97 0 0 0 13 12V8a.97.97 0 0 0-.287-.713A.97.97 0 0 0 12 7a.97.97 0 0 0-.713.287A.97.97 0 0 0 11 8v4q0 .424.287.713.288.287.713.287m0 9a9.7 9.7 0 0 1-3.9-.788 10.1 10.1 0 0 1-3.175-2.137q-1.35-1.35-2.137-3.175A9.7 9.7 0 0 1 2 12q0-2.075.788-3.9a10.1 10.1 0 0 1 2.137-3.175q1.35-1.35 3.175-2.137A9.7 9.7 0 0 1 12 2q2.075 0 3.9.788a10.1 10.1 0 0 1 3.175 2.137q1.35 1.35 2.137 3.175A9.7 9.7 0 0 1 22 12a9.7 9.7 0 0 1-.788 3.9 10.1 10.1 0 0 1-2.137 3.175q-1.35 1.35-3.175 2.137A9.7 9.7 0 0 1 12 22m0-2q3.35 0 5.675-2.325T20 12t-2.325-5.675T12 4 6.325 6.325 4 12t2.325 5.675T12 20\"\n    })\n  });\n}\n;\nErrorIcon.displayName = \"ErrorIcon\";\nexport default forwardRef(ErrorIcon);","import { forwardRef } from \"react\";\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nfunction ExpandIcon(props, ref) {\n  return /*#__PURE__*/_jsx(\"svg\", {\n    xmlns: \"http://www.w3.org/2000/svg\",\n    width: \"1em\",\n    height: \"1em\",\n    fill: \"currentColor\",\n    viewBox: \"0 0 24 24\",\n    ref: ref,\n    ...props,\n    children: /*#__PURE__*/_jsx(\"path\", {\n      d: \"M21 3.997a1 1 0 0 0-.29-.702l-.005-.004A1 1 0 0 0 20 3h-8a1 1 0 1 0 0 2h5.586L5 17.586V12a1 1 0 1 0-2 0v8.003a1 1 0 0 0 .29.702l.005.004c.18.18.43.291.705.291h8a1 1 0 1 0 0-2H6.414L19 6.414V12a1 1 0 1 0 2 0z\"\n    })\n  });\n}\n;\nExpandIcon.displayName = \"ExpandIcon\";\nexport default forwardRef(ExpandIcon);","import { forwardRef } from \"react\";\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nfunction FilesIcon(props, ref) {\n  return /*#__PURE__*/_jsx(\"svg\", {\n    xmlns: \"http://www.w3.org/2000/svg\",\n    width: \"1em\",\n    height: \"1em\",\n    fill: \"currentColor\",\n    viewBox: \"0 0 24 24\",\n    ref: ref,\n    ...props,\n    children: /*#__PURE__*/_jsx(\"path\", {\n      d: \"M6 22q-.824 0-1.412-.587A1.93 1.93 0 0 1 4 20V4q0-.824.588-1.412A1.93 1.93 0 0 1 6 2h7.175a1.98 1.98 0 0 1 1.4.575l4.85 4.85q.275.275.425.638.15.361.15.762V20q0 .824-.587 1.413A1.93 1.93 0 0 1 18 22zm7-14V4H6v16h12V9h-4a.97.97 0 0 1-.713-.287A.97.97 0 0 1 13 8\"\n    })\n  });\n}\n;\nFilesIcon.displayName = \"FilesIcon\";\nexport default forwardRef(FilesIcon);","import { forwardRef } from \"react\";\nimport { jsx as _jsx, jsxs as _jsxs } from \"react/jsx-runtime\";\nfunction LeaveIcon(props, ref) {\n  return /*#__PURE__*/_jsxs(\"svg\", {\n    xmlns: \"http://www.w3.org/2000/svg\",\n    width: \"1em\",\n    height: \"1em\",\n    fill: \"currentColor\",\n    viewBox: \"0 0 24 24\",\n    ref: ref,\n    ...props,\n    children: [/*#__PURE__*/_jsx(\"path\", {\n      d: \"M14 13q.424 0 .713-.287A.97.97 0 0 0 15 12a.97.97 0 0 0-.287-.713A.97.97 0 0 0 14 11a.97.97 0 0 0-.713.287A.97.97 0 0 0 13 12q0 .424.287.713.288.287.713.287\"\n    }), /*#__PURE__*/_jsx(\"path\", {\n      d: \"M10.385 21.788A1 1 0 0 1 10 21V3a1.003 1.003 0 0 1 1.242-.97l8 2A1 1 0 0 1 20 5v14a1 1 0 0 1-.758.97l-8 2a1 1 0 0 1-.857-.182M18 5.781l-6-1.5v15.438l6-1.5zM9 6H7v12h2v2H7a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2h2z\"\n    })]\n  });\n}\n;\nLeaveIcon.displayName = \"LeaveIcon\";\nexport default forwardRef(LeaveIcon);","import { forwardRef } from \"react\";\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nfunction LinkIcon(props, ref) {\n  return /*#__PURE__*/_jsx(\"svg\", {\n    xmlns: \"http://www.w3.org/2000/svg\",\n    width: \"1em\",\n    height: \"1em\",\n    fill: \"currentColor\",\n    viewBox: \"0 0 24 24\",\n    ref: ref,\n    ...props,\n    children: /*#__PURE__*/_jsx(\"path\", {\n      d: \"M12 19.071q-1.467 1.467-3.536 1.467-2.067 0-3.535-1.467t-1.467-3.535q0-2.07 1.467-3.536L7.05 9.879q.3-.3.707-.3t.707.3.301.707-.3.707l-2.122 2.121a2.9 2.9 0 0 0-.884 2.122q0 1.237.884 2.12.884.885 2.121.885t2.122-.884l2.121-2.121q.3-.3.707-.3t.707.3.3.707q0 .405-.3.707zm-1.414-4.243q-.3.3-.707.301a.97.97 0 0 1-.707-.3q-.3-.3-.301-.708 0-.405.3-.707l4.243-4.242q.3-.3.707-.3t.707.3.3.707-.3.707zm6.364-.707q-.3.3-.707.3a.97.97 0 0 1-.707-.3q-.3-.3-.301-.707 0-.405.3-.707l2.122-2.121q.884-.885.884-2.121 0-1.238-.884-2.122a2.9 2.9 0 0 0-2.121-.884q-1.237 0-2.122.884l-2.121 2.122q-.3.3-.707.3a.97.97 0 0 1-.707-.3q-.3-.3-.3-.708 0-.405.3-.707L12 4.93q1.467-1.467 3.536-1.467t3.535 1.467 1.467 3.536T19.071 12z\"\n    })\n  });\n}\n;\nLinkIcon.displayName = \"LinkIcon\";\nexport default forwardRef(LinkIcon);","import { forwardRef } from \"react\";\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nfunction LocationPinSolidIcon(props, ref) {\n  return /*#__PURE__*/_jsx(\"svg\", {\n    xmlns: \"http://www.w3.org/2000/svg\",\n    width: \"1em\",\n    height: \"1em\",\n    fill: \"currentColor\",\n    viewBox: \"0 0 24 24\",\n    ref: ref,\n    ...props,\n    children: /*#__PURE__*/_jsx(\"path\", {\n      d: \"M12 21.325a2.1 2.1 0 0 1-.7-.125 1.8 1.8 0 0 1-.625-.375A39 39 0 0 1 7.8 17.9q-1.25-1.425-2.087-2.762-.838-1.338-1.275-2.575Q4 11.325 4 10.2q0-3.75 2.412-5.975T12 2t5.587 2.225T20 10.2q0 1.125-.437 2.363-.438 1.237-1.275 2.574A22 22 0 0 1 16.2 17.9a39 39 0 0 1-2.875 2.925 1.8 1.8 0 0 1-.625.375 2.1 2.1 0 0 1-.7.125M12 12q.825 0 1.412-.588Q14 10.826 14 10t-.588-1.412A1.93 1.93 0 0 0 12 8q-.825 0-1.412.588A1.93 1.93 0 0 0 10 10q0 .825.588 1.412Q11.175 12 12 12\"\n    })\n  });\n}\n;\nLocationPinSolidIcon.displayName = \"LocationPinSolidIcon\";\nexport default forwardRef(LocationPinSolidIcon);","import { forwardRef } from \"react\";\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nfunction MentionIcon(props, ref) {\n  return /*#__PURE__*/_jsx(\"svg\", {\n    xmlns: \"http://www.w3.org/2000/svg\",\n    width: \"1em\",\n    height: \"1em\",\n    fill: \"currentColor\",\n    viewBox: \"0 0 24 24\",\n    ref: ref,\n    ...props,\n    children: /*#__PURE__*/_jsx(\"path\", {\n      d: \"M12 4a8 8 0 1 0 0 16 1 1 0 1 1 0 2C6.477 22 2 17.523 2 12S6.477 2 12 2s10 4.477 10 10v1.5a3.5 3.5 0 0 1-6.396 1.966A5 5 0 1 1 17 12v1.5a1.5 1.5 0 0 0 3 0V12a8 8 0 0 0-8-8m3 8a3 3 0 1 0-6 0 3 3 0 0 0 6 0\"\n    })\n  });\n}\n;\nMentionIcon.displayName = \"MentionIcon\";\nexport default forwardRef(MentionIcon);","import { forwardRef } from \"react\";\nimport { jsx as _jsx, jsxs as _jsxs } from \"react/jsx-runtime\";\nfunction PopOutIcon(props, ref) {\n  return /*#__PURE__*/_jsxs(\"svg\", {\n    xmlns: \"http://www.w3.org/2000/svg\",\n    width: \"1em\",\n    height: \"1em\",\n    fill: \"currentColor\",\n    viewBox: \"0 0 24 24\",\n    ref: ref,\n    ...props,\n    children: [/*#__PURE__*/_jsx(\"path\", {\n      d: \"M5 3h6a1 1 0 1 1 0 2H5v14h14v-6a1 1 0 1 1 2 0v6a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2\"\n    }), /*#__PURE__*/_jsx(\"path\", {\n      d: \"M15 3h5a1 1 0 0 1 1 1v5a1 1 0 1 1-2 0V6.414l-6.293 6.293a1 1 0 0 1-1.414-1.414L17.586 5H15a1 1 0 1 1 0-2\"\n    })]\n  });\n}\n;\nPopOutIcon.displayName = \"PopOutIcon\";\nexport default forwardRef(PopOutIcon);","import { forwardRef } from \"react\";\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nfunction SearchIcon(props, ref) {\n  return /*#__PURE__*/_jsx(\"svg\", {\n    xmlns: \"http://www.w3.org/2000/svg\",\n    width: \"1em\",\n    height: \"1em\",\n    fill: \"currentColor\",\n    viewBox: \"0 0 24 24\",\n    ref: ref,\n    ...props,\n    children: /*#__PURE__*/_jsx(\"path\", {\n      d: \"M15.05 16.463a7.5 7.5 0 1 1 1.414-1.414l3.243 3.244a1 1 0 0 1-1.414 1.414zM16 10.5a5.5 5.5 0 1 0-11 0 5.5 5.5 0 0 0 11 0\"\n    })\n  });\n}\n;\nSearchIcon.displayName = \"SearchIcon\";\nexport default forwardRef(SearchIcon);","import { forwardRef } from \"react\";\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nfunction ShareIcon(props, ref) {\n  return /*#__PURE__*/_jsx(\"svg\", {\n    xmlns: \"http://www.w3.org/2000/svg\",\n    width: \"1em\",\n    height: \"1em\",\n    fill: \"currentColor\",\n    viewBox: \"0 0 24 24\",\n    ref: ref,\n    ...props,\n    children: /*#__PURE__*/_jsx(\"path\", {\n      d: \"M12 16a.97.97 0 0 1-.713-.287A.97.97 0 0 1 11 15V7.85L9.125 9.725q-.3.3-.7.3T7.7 9.7a.93.93 0 0 1-.288-.713A.98.98 0 0 1 7.7 8.3l3.6-3.6q.15-.15.325-.213.175-.062.375-.062t.375.062a.9.9 0 0 1 .325.213l3.6 3.6q.3.3.287.712a.98.98 0 0 1-.287.688q-.3.3-.713.313a.93.93 0 0 1-.712-.288L13 7.85V15q0 .424-.287.713A.97.97 0 0 1 12 16m-6 4q-.824 0-1.412-.587A1.93 1.93 0 0 1 4 18v-2q0-.424.287-.713A.97.97 0 0 1 5 15q.424 0 .713.287Q6 15.576 6 16v2h12v-2q0-.424.288-.713A.97.97 0 0 1 19 15q.424 0 .712.287.288.288.288.713v2q0 .824-.587 1.413A1.93 1.93 0 0 1 18 20z\"\n    })\n  });\n}\n;\nShareIcon.displayName = \"ShareIcon\";\nexport default forwardRef(ShareIcon);","import { forwardRef } from \"react\";\nimport { jsx as _jsx, jsxs as _jsxs } from \"react/jsx-runtime\";\nfunction ThreadsIcon(props, ref) {\n  return /*#__PURE__*/_jsxs(\"svg\", {\n    xmlns: \"http://www.w3.org/2000/svg\",\n    width: \"1em\",\n    height: \"1em\",\n    fill: \"currentColor\",\n    viewBox: \"0 0 24 24\",\n    ref: ref,\n    ...props,\n    children: [/*#__PURE__*/_jsx(\"path\", {\n      d: \"M7 10a.97.97 0 0 1-.713-.287A.97.97 0 0 1 6 9q0-.424.287-.713A.97.97 0 0 1 7 8h10q.424 0 .712.287Q18 8.576 18 9t-.288.713A.97.97 0 0 1 17 10zm0 4a.97.97 0 0 1-.713-.287A.97.97 0 0 1 6 13q0-.424.287-.713A.97.97 0 0 1 7 12h6q.424 0 .713.287.287.288.287.713 0 .424-.287.713A.97.97 0 0 1 13 14z\"\n    }), /*#__PURE__*/_jsx(\"path\", {\n      d: \"M3.707 21.293c-.63.63-1.707.184-1.707-.707V5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v12a2 2 0 0 1-2 2H6zM6 17h14V5H4v13.172l.586-.586A2 2 0 0 1 6 17\"\n    })]\n  });\n}\n;\nThreadsIcon.displayName = \"ThreadsIcon\";\nexport default forwardRef(ThreadsIcon);","import { forwardRef } from \"react\";\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nfunction UserAddIcon(props, ref) {\n  return /*#__PURE__*/_jsx(\"svg\", {\n    xmlns: \"http://www.w3.org/2000/svg\",\n    width: \"1em\",\n    height: \"1em\",\n    fill: \"currentColor\",\n    viewBox: \"0 0 24 24\",\n    ref: ref,\n    ...props,\n    children: /*#__PURE__*/_jsx(\"path\", {\n      d: \"M10 12q-1.65 0-2.825-1.175T6 8t1.175-2.825T10 4t2.825 1.175T14 8t-1.175 2.825T10 12m-8 6v-.8q0-.85.438-1.562.437-.713 1.162-1.088a14.8 14.8 0 0 1 3.15-1.163A13.8 13.8 0 0 1 10 13q1.65 0 3.25.387 1.6.388 3.15 1.163.724.375 1.163 1.087Q18 16.35 18 17.2v.8q0 .824-.587 1.413A1.93 1.93 0 0 1 16 20H4q-.824 0-1.412-.587A1.93 1.93 0 0 1 2 18m2 0h12v-.8a.97.97 0 0 0-.5-.85q-1.35-.675-2.725-1.012a11.6 11.6 0 0 0-5.55 0Q5.85 15.675 4.5 16.35a.97.97 0 0 0-.5.85zm6-8q.825 0 1.412-.588Q12 8.826 12 8q0-.824-.588-1.412A1.93 1.93 0 0 0 10 6q-.825 0-1.412.588A1.93 1.93 0 0 0 8 8q0 .825.588 1.412Q9.175 10 10 10m7 1h2v2q0 .424.288.713.287.287.712.287.424 0 .712-.287A.97.97 0 0 0 21 13v-2h2q.424 0 .712-.287A.97.97 0 0 0 24 10a.97.97 0 0 0-.288-.713A.97.97 0 0 0 23 9h-2V7a.97.97 0 0 0-.288-.713A.97.97 0 0 0 20 6a.97.97 0 0 0-.712.287A.97.97 0 0 0 19 7v2h-2a.97.97 0 0 0-.712.287A.97.97 0 0 0 16 10q0 .424.288.713.287.287.712.287\"\n    })\n  });\n}\n;\nUserAddIcon.displayName = \"UserAddIcon\";\nexport default forwardRef(UserAddIcon);","import { forwardRef } from \"react\";\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nfunction UserSolidIcon(props, ref) {\n  return /*#__PURE__*/_jsx(\"svg\", {\n    xmlns: \"http://www.w3.org/2000/svg\",\n    width: \"1em\",\n    height: \"1em\",\n    fill: \"currentColor\",\n    viewBox: \"0 0 24 24\",\n    ref: ref,\n    ...props,\n    children: /*#__PURE__*/_jsx(\"path\", {\n      d: \"M12 12q-1.65 0-2.825-1.175T8 8t1.175-2.825T12 4t2.825 1.175T16 8t-1.175 2.825T12 12m-8 6v-.8q0-.85.438-1.562.437-.713 1.162-1.088a14.8 14.8 0 0 1 3.15-1.163A13.8 13.8 0 0 1 12 13q1.65 0 3.25.387 1.6.388 3.15 1.163.724.375 1.163 1.087Q20 16.35 20 17.2v.8q0 .824-.587 1.413A1.93 1.93 0 0 1 18 20H6q-.824 0-1.412-.587A1.93 1.93 0 0 1 4 18\"\n    })\n  });\n}\n;\nUserSolidIcon.displayName = \"UserSolidIcon\";\nexport default forwardRef(UserSolidIcon);","import { forwardRef } from \"react\";\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nfunction VerifiedIcon(props, ref) {\n  return /*#__PURE__*/_jsx(\"svg\", {\n    xmlns: \"http://www.w3.org/2000/svg\",\n    width: \"1em\",\n    height: \"1em\",\n    fill: \"currentColor\",\n    viewBox: \"0 0 24 24\",\n    ref: ref,\n    ...props,\n    children: /*#__PURE__*/_jsx(\"path\", {\n      d: \"M8.15 21.75 6.7 19.3l-2.75-.6a.94.94 0 0 1-.6-.387.93.93 0 0 1-.175-.688L3.45 14.8l-1.875-2.15a.93.93 0 0 1-.25-.65q0-.375.25-.65L3.45 9.2l-.275-2.825a.93.93 0 0 1 .175-.687.94.94 0 0 1 .6-.388l2.75-.6 1.45-2.45a.98.98 0 0 1 .55-.437.97.97 0 0 1 .7.037l2.6 1.1 2.6-1.1a.97.97 0 0 1 .7-.038q.35.112.55.438L17.3 4.7l2.75.6q.375.075.6.388.225.312.175.687L20.55 9.2l1.875 2.15q.25.275.25.65t-.25.65L20.55 14.8l.275 2.825a.93.93 0 0 1-.175.688.94.94 0 0 1-.6.387l-2.75.6-1.45 2.45a.98.98 0 0 1-.55.438.97.97 0 0 1-.7-.038l-2.6-1.1-2.6 1.1a.97.97 0 0 1-.7.038.98.98 0 0 1-.55-.438m2.8-9.05L9.5 11.275A.93.93 0 0 0 8.812 11q-.412 0-.712.3a.95.95 0 0 0-.275.7q0 .425.275.7l2.15 2.15q.3.3.7.3t.7-.3l4.25-4.25q.3-.3.287-.7a1.06 1.06 0 0 0-.287-.7 1.02 1.02 0 0 0-.713-.312.93.93 0 0 0-.712.287z\"\n    })\n  });\n}\n;\nVerifiedIcon.displayName = \"VerifiedIcon\";\nexport default forwardRef(VerifiedIcon);","import { forwardRef } from \"react\";\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nfunction VideoCallSolidIcon(props, ref) {\n  return /*#__PURE__*/_jsx(\"svg\", {\n    xmlns: \"http://www.w3.org/2000/svg\",\n    width: \"1em\",\n    height: \"1em\",\n    fill: \"currentColor\",\n    viewBox: \"0 0 24 24\",\n    ref: ref,\n    ...props,\n    children: /*#__PURE__*/_jsx(\"path\", {\n      d: \"M6 4h10a2 2 0 0 1 2 2v4.286l3.35-2.871a1 1 0 0 1 1.65.76v7.65a1 1 0 0 1-1.65.76L18 13.715V18a2 2 0 0 1-2 2H6a4 4 0 0 1-4-4V8a4 4 0 0 1 4-4\"\n    })\n  });\n}\n;\nVideoCallSolidIcon.displayName = \"VideoCallSolidIcon\";\nexport default forwardRef(VideoCallSolidIcon);","import { forwardRef } from \"react\";\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nfunction VisibilityOffIcon(props, ref) {\n  return /*#__PURE__*/_jsx(\"svg\", {\n    xmlns: \"http://www.w3.org/2000/svg\",\n    width: \"1em\",\n    height: \"1em\",\n    fill: \"currentColor\",\n    viewBox: \"0 0 24 24\",\n    ref: ref,\n    ...props,\n    children: /*#__PURE__*/_jsx(\"path\", {\n      d: \"m16.1 13.3-1.45-1.45q.225-1.175-.675-2.2t-2.325-.8L10.2 7.4q.424-.2.863-.3A4.2 4.2 0 0 1 12 7q1.875 0 3.188 1.312Q16.5 9.625 16.5 11.5q0 .5-.1.938t-.3.862m3.2 3.15-1.45-1.4a11 11 0 0 0 1.688-1.588A9 9 0 0 0 20.8 11.5q-1.25-2.524-3.588-4.013Q14.875 6 12 6q-.724 0-1.425.1a10 10 0 0 0-1.375.3L7.65 4.85A11.1 11.1 0 0 1 12 4q3.575 0 6.425 1.887T22.7 10.8a.8.8 0 0 1 .1.313q.025.188.025.387a2 2 0 0 1-.125.7 10.9 10.9 0 0 1-3.4 4.25m-.2 5.45-3.5-3.45q-.874.274-1.762.413Q12.95 19 12 19q-3.575 0-6.425-1.887T1.3 12.2a.8.8 0 0 1-.1-.312 3 3 0 0 1 0-.763.8.8 0 0 1 .1-.3Q1.825 9.7 2.55 8.75A13.3 13.3 0 0 1 4.15 7L2.075 4.9a.93.93 0 0 1-.275-.688q0-.412.3-.712a.95.95 0 0 1 .7-.275q.425 0 .7.275l17 17q.275.275.288.688a.93.93 0 0 1-.288.712.95.95 0 0 1-.7.275.95.95 0 0 1-.7-.275M5.55 8.4q-.725.65-1.325 1.425A9 9 0 0 0 3.2 11.5q1.25 2.524 3.588 4.012T12 17q.5 0 .975-.062.475-.063.975-.138l-.9-.95q-.274.075-.525.113A3.5 3.5 0 0 1 12 16q-1.875 0-3.187-1.312Q7.5 13.375 7.5 11.5q0-.274.038-.525.037-.25.112-.525z\"\n    })\n  });\n}\n;\nVisibilityOffIcon.displayName = \"VisibilityOffIcon\";\nexport default forwardRef(VisibilityOffIcon);","import { forwardRef } from \"react\";\nimport { jsx as _jsx, jsxs as _jsxs } from \"react/jsx-runtime\";\nfunction WarningIcon(props, ref) {\n  return /*#__PURE__*/_jsxs(\"svg\", {\n    xmlns: \"http://www.w3.org/2000/svg\",\n    width: \"1em\",\n    height: \"1em\",\n    fill: \"currentColor\",\n    viewBox: \"0 0 24 24\",\n    ref: ref,\n    ...props,\n    children: [/*#__PURE__*/_jsx(\"path\", {\n      d: \"M12.713 17.713A.97.97 0 0 1 12 18a.97.97 0 0 1-.713-.288A.97.97 0 0 1 11 17q0-.424.287-.712A.97.97 0 0 1 12 16q.424 0 .713.288.287.287.287.712 0 .424-.287.712m0-3.999A.97.97 0 0 1 12 14a.97.97 0 0 1-.713-.287A.97.97 0 0 1 11 13V9q0-.424.287-.713A.97.97 0 0 1 12 8q.424 0 .713.287Q13 8.576 13 9v4q0 .424-.287.713\"\n    }), /*#__PURE__*/_jsx(\"path\", {\n      fillRule: \"evenodd\",\n      d: \"M10.264 3.039c.767-1.344 2.705-1.344 3.472 0l8.554 14.969c.762 1.333-.2 2.992-1.736 2.992H3.446c-1.535 0-2.498-1.659-1.736-2.992zM3.446 19 12 4.031 20.554 19z\",\n      clipRule: \"evenodd\"\n    })]\n  });\n}\n;\nWarningIcon.displayName = \"WarningIcon\";\nexport default forwardRef(WarningIcon);","var _path;\nfunction _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }\nimport * as React from \"react\";\nimport { forwardRef } from \"react\";\nvar SvgDownload = function SvgDownload(props, ref) {\n  return /*#__PURE__*/React.createElement(\"svg\", _extends({\n    xmlns: \"http://www.w3.org/2000/svg\",\n    fill: \"currentColor\",\n    viewBox: \"0 0 24 24\",\n    role: \"presentation\",\n    \"aria-hidden\": true,\n    ref: ref\n  }, props), _path || (_path = /*#__PURE__*/React.createElement(\"path\", {\n    d: \"M12 15.575q-.2 0-.375-.062a.9.9 0 0 1-.325-.213l-3.6-3.6a.95.95 0 0 1-.275-.7q0-.425.275-.7.274-.275.712-.288t.713.263L11 12.15V5q0-.424.287-.713A.97.97 0 0 1 12 4q.424 0 .713.287Q13 4.576 13 5v7.15l1.875-1.875q.274-.274.713-.263.437.014.712.288a.95.95 0 0 1 .275.7.95.95 0 0 1-.275.7l-3.6 3.6q-.15.15-.325.212a1.1 1.1 0 0 1-.375.063M6 20q-.824 0-1.412-.587A1.93 1.93 0 0 1 4 18v-2q0-.424.287-.713A.97.97 0 0 1 5 15q.424 0 .713.287Q6 15.576 6 16v2h12v-2q0-.424.288-.713A.97.97 0 0 1 19 15q.424 0 .712.287.288.288.288.713v2q0 .824-.587 1.413A1.93 1.93 0 0 1 18 20z\"\n  })));\n};\nvar ForwardRef = /*#__PURE__*/forwardRef(SvgDownload);\nexport { ForwardRef as Icon };\nexport default \"icons/download.364c774.svg\";","/*\nCopyright 2023 New Vector Ltd.\n\nSPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial\nPlease see LICENSE files in the repository root for full details.\n*/\n\nexport const MX_USERNAME_PREFIX = \"@\";\nexport const MX_ROOM_PREFIX = \"#\";\nexport const MX_ALIAS_PREFIX = \"+\";\n\nconst graphemeSegmenter = new Intl.Segmenter();\n\n/**\n * returns the first (non-sigil) character of 'name',\n * converted to uppercase\n * @param {string} name\n * @return {string} the first letter\n */\nexport function getInitialLetter(name: string): string {\n  if (name.length < 1) {\n    return \"\";\n  }\n\n  const initial = name[0];\n  if ([MX_USERNAME_PREFIX, MX_ROOM_PREFIX, MX_ALIAS_PREFIX].includes(initial)) {\n    name = name.substring(1);\n  }\n\n  // rely on a grapheme cluster splitter so that we don't break apart compound emojis\n  const result = graphemeSegmenter.segment(name)[Symbol.iterator]().next();\n  return result.done ? \"\" : result.value.segment;\n}\n","/*\nCopyright 2023 New Vector Ltd.\n\nSPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial\nPlease see LICENSE files in the repository root for full details.\n*/\n\nimport classnames from \"classnames\";\nimport React, { ComponentProps, forwardRef } from \"react\";\nimport { getInitialLetter } from \"../../utils/string\";\nimport styles from \"./Avatar.module.css\";\nimport { useIdColorHash } from \"./useIdColorHash\";\n\ntype AvatarProps = (ComponentProps<\"button\"> | ComponentProps<\"span\">) & {\n  /**\n   * The avatar image URL, if any.\n   */\n  src?: React.ComponentProps<\"img\">[\"src\"];\n  /**\n   * The Matrix ID, Room ID, or Alias to generate the color when no image source\n   * is provided. Also used as a fallback when name is empty.\n   */\n  id: string;\n  /**\n   * The name used for the initial letter displayed when no image source is provided.\n   */\n  name: string;\n  /**\n   * Defines the avatar type, typically round, square is usually for spaces.\n   * @default \"round\"\n   */\n  type?: \"square\" | \"round\";\n  /**\n   * The avatar size in CSS units, e.g. `\"24px\"`.\n   */\n  size?: CSSStyleDeclaration[\"height\"];\n  /**\n   * On click handler, will turn the avatar into a button element.\n   */\n  onClick?: (e: React.MouseEvent) => void;\n  /**\n   * Key down handler, will turn the avatar into a button element.\n   */\n  onKeyDown?: (e: React.KeyboardEvent) => void;\n  /**\n   * Key up handler, will turn the avatar into a button element.\n   */\n  onKeyUp?: (e: React.KeyboardEvent) => void;\n  /**\n   * Callback when the image has failed to load.\n   */\n  onError?: React.ComponentProps<\"img\">[\"onError\"];\n};\n\n/**\n * Some props warrant that the avatar become a button for accessibility purposes\n * @param props Avatar props\n * @returns whether the avatar should be a button or not\n */\nfunction shouldBeAButton(props: Partial<AvatarProps>): boolean {\n  return !!(props.onClick || props.onKeyDown || props.onKeyUp);\n}\n\n/**\n * Avatar component that will fallback to an initial letter over a coloured\n * background if no source is provided or if the source has failed to load.\n */\nexport const Avatar = forwardRef<\n  HTMLSpanElement | HTMLButtonElement,\n  AvatarProps\n>(function Avatar(\n  {\n    src,\n    id,\n    name = \"\",\n    type = \"round\",\n    className = \"\",\n    size,\n    style = {},\n    onError,\n    ...props\n  },\n  ref,\n) {\n  return React.createElement(\n    shouldBeAButton(props) ? \"button\" : \"span\",\n    {\n      ref,\n      role: \"img\",\n      // Default the aria-label to id\n      \"aria-label\": id,\n      ...props,\n      \"data-type\": type,\n      \"data-color\": useIdColorHash(id),\n      className: classnames(styles.avatar, className, {\n        [styles[\"avatar-imageless\"]]: !src,\n      }),\n      style: {\n        ...style,\n        \"--cpd-avatar-size\": size,\n      } as React.CSSProperties,\n    },\n    <React.Fragment>\n      {!src ? (\n        getInitialLetter(name)\n      ) : (\n        <img\n          loading=\"lazy\"\n          alt=\"\"\n          src={src}\n          referrerPolicy=\"no-referrer\"\n          className={classnames(styles.image)}\n          data-type={type}\n          style={style}\n          width={size}\n          height={size}\n          onError={onError}\n        />\n      )}\n    </React.Fragment>,\n  );\n});\n","export default \"<!--\\nCopyright 2023 New Vector Ltd.\\n\\nSPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial\\nPlease see LICENSE files in the repository root for full details.\\n-->\\n\\n<svg>\\n  <clipPath id=\\\"cpdAvatarClip\\\" clipPathUnits=\\\"objectBoundingBox\\\">\\n    <!-- \\n        All values below need to be between 0 and 1\\n        for objectBoundingBox to work\\n     -->\\n    <path d=\\\"\\n        M 0.875 0.16666\\n        A 0.5 0.5 0 1 0 0.875 0.83333\\n        Q 0.65 0.5 0.875 0.16666\\n        Z\\n     \\\"/>\\n  </clipPath>\\n</svg>\\n\"","/*\nCopyright 2023 New Vector Ltd.\n\nSPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial\nPlease see LICENSE files in the repository root for full details.\n*/\n\nimport classnames from \"classnames\";\nimport React, { useEffect } from \"react\";\nimport styles from \"./Avatar.module.css\";\nimport clipMask from \"./avatar-clip.mask.svg?raw\";\n\ntype AvatarStackProps = {\n  className?: string;\n};\n\nconst AVATAR_MASK_ID = \"cpdAvatarClipSvg\";\nlet AvatarStackUsageCount = 0;\n\n/**\n * Renders a stack of avatars and clips the content appropriately.\n *\n * The `type` of avatars should always be set to `round`\n * And all the avatars should have the same size.\n */\nexport const AvatarStack: React.FC<\n  React.PropsWithChildren<AvatarStackProps>\n> = ({ children, className }) => {\n  /**\n   * The `clip-path` property in CSS supports a `path()` function, however\n   * that has to use pixel values.\n   * `clipPathUnits=\"objectBoundingBox\"` only exists inside an SVG document.\n   * Which is why we have the external `avatar-clip.mask.svg`.\n   *\n   * It is possible to load this SVG externally using `url(path/to/doc.svg#id)`\n   * But this is only supported in Firefox\n   * This leaves us with no choice but rendering SVG inline in the HTML document\n   * And making sure there is always only a single instance regardless of the\n   * amount of `AvatarStack` instance in the document.\n   */\n  useEffect(() => {\n    if (AvatarStackUsageCount === 0) {\n      const svgMask = `\n        <div aria-hidden=\"true\" id=\"${AVATAR_MASK_ID}\" class=\"${styles[\"clip-path\"]}\">\n          ${clipMask}\n        </div>\n      `;\n      document.body.insertAdjacentHTML(\"beforeend\", svgMask);\n    }\n    AvatarStackUsageCount++;\n    return () => {\n      AvatarStackUsageCount--;\n      if (AvatarStackUsageCount <= 0) {\n        // Cleanup the mask if there are no instances of `AvatarStack` left\n        // on the page\n        document.getElementById(AVATAR_MASK_ID)?.remove();\n      }\n    };\n  }, []);\n\n  return (\n    <div className={classnames(styles[\"stacked-avatars\"], className)}>\n      {children}\n    </div>\n  );\n};\n","/*\nCopyright 2023 New Vector Ltd.\n\nSPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial\nPlease see LICENSE files in the repository root for full details.\n*/\n\n/**\n * Determines a number for a given Matrix ID or room ID, helps disambiguating users\n * who are trying to impersonate someone else.\n * @param id - a Matrix ID or room ID\n * @returns a hash of the ID provided\n */\nexport function useIdColorHash(id: string): number {\n  const MIN = 1;\n  const MAX = 6;\n  // Sum up the values of all the char codes in the string\n  const charCodeSum = id.split(\"\").reduce((sum, char) => {\n    return sum + char.charCodeAt(0);\n  }, 0);\n  return (charCodeSum % MAX) + MIN;\n}\n","/*\nCopyright 2023 New Vector Ltd.\n\nSPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial\nPlease see LICENSE files in the repository root for full details.\n*/\n\nimport classnames from \"classnames\";\nimport React, { PropsWithChildren } from \"react\";\nimport styles from \"./Badge.module.css\";\nimport { Typography } from \"../Typography/Typography\";\n\ntype BadgeProps = {\n  /**\n   * The CSS class name.\n   */\n  className?: string;\n  /**\n   * The type of badge.\n   */\n  kind?: \"default\" | \"grey\" | \"on-solid\" | \"blue\" | \"green\" | \"red\";\n};\n\n/**\n * A Badge component.\n */\nexport const Badge: React.FC<PropsWithChildren<BadgeProps>> = ({\n  children,\n  kind = \"default\",\n  className,\n}) => {\n  const classes = classnames(styles.badge, className);\n  return (\n    <Typography\n      as=\"span\"\n      size=\"sm\"\n      weight=\"medium\"\n      className={classes}\n      data-kind={kind}\n    >\n      {children}\n    </Typography>\n  );\n};\n","/*\nCopyright 2023, 2024 New Vector Ltd.\n\nSPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial\nPlease see LICENSE files in the repository root for full details.\n*/\n\nimport classNames from \"classnames\";\nimport React, {\n  ComponentType,\n  PropsWithChildren,\n  forwardRef,\n  ForwardedRef,\n  Ref,\n} from \"react\";\nimport styles from \"./Button.module.css\";\nimport { UnstyledButton, UnstyledButtonPropsFor } from \"./UnstyledButton\";\n\ninterface ButtonComponent {\n  // With the explicit `as` prop\n  <C extends React.ElementType>(\n    props: { as: C } & ButtonPropsFor<C>,\n  ): React.ReactElement;\n  // Without the explicit `as` prop, defaulting to a <button>\n  (props: ButtonPropsFor<\"button\">): React.ReactElement;\n}\n\ntype ButtonOwnProps = PropsWithChildren<{\n  /**\n   * The type of button.\n   * Note: \"destructive\" is deprecated, please use the destructive prop in\n   * conjunction with another button kind.\n   */\n  kind?: \"primary\" | \"secondary\" | \"tertiary\" | \"destructive\";\n  /**\n   * The t-shirt size of the button.\n   */\n  size?: \"sm\" | \"lg\";\n\n  /**\n   * Whether the button is an icon only button.\n   */\n  iconOnly?: boolean;\n\n  /**\n   * An icon to display within the button.\n   */\n  Icon?: ComponentType<React.SVGAttributes<SVGElement>>;\n  /**\n   * Whether this button triggers a destructive action.\n   * @default false\n   */\n  destructive?: boolean;\n}>;\n\ntype ButtonPropsFor<C extends React.ElementType> = ButtonOwnProps &\n  UnstyledButtonPropsFor<C>;\n\n/**\n * A button component that can be transformed into a link, but keep the button\n * styling using the `as` property.\n */\nexport const Button = forwardRef(function Button<\n  C extends React.ElementType = \"button\",\n>(\n  {\n    as,\n    kind: kindProp = \"primary\",\n    size = \"lg\",\n    children,\n    className,\n    iconOnly,\n    Icon,\n    destructive: destructiveProp,\n    disabled,\n    ...props\n  }: ButtonPropsFor<C> & { as?: C },\n  ref: ForwardedRef<C>,\n): React.ReactElement {\n  // Fallback for the deprecated \"destructive\" kind\n  const [kind, destructive] =\n    kindProp === \"destructive\"\n      ? [\"secondary\", true]\n      : [kindProp, destructiveProp];\n\n  const classes = classNames(styles.button, className, {\n    [styles[\"has-icon\"]]: Icon,\n    [styles[\"icon-only\"]]: iconOnly,\n    [styles.destructive]: destructive,\n  });\n\n  const iconSize = iconOnly && size === \"lg\" ? 24 : 20;\n\n  return (\n    <UnstyledButton\n      {...props}\n      as={as || (\"button\" as const)}\n      ref={ref as Ref<C>}\n      className={classes}\n      data-size={size}\n      data-kind={kind}\n      tabIndex={0}\n      disabled={disabled}\n    >\n      {Icon && (\n        <Icon\n          width={iconSize}\n          height={iconSize}\n          className={styles.icon}\n          aria-hidden={true}\n        />\n      )}\n      {children}\n    </UnstyledButton>\n  );\n}) as ButtonComponent;\n","/*\nCopyright 2023 New Vector Ltd.\n\nSPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial\nPlease see LICENSE files in the repository root for full details.\n*/\n\nimport React, { PropsWithChildren, forwardRef } from \"react\";\nimport classnames from \"classnames\";\n\nimport styles from \"./IconButton.module.css\";\nimport { UnstyledButton, UnstyledButtonPropsFor } from \"../UnstyledButton\";\nimport { IndicatorIcon } from \"../../Icon/IndicatorIcon/IndicatorIcon\";\nimport { Tooltip } from \"../../Tooltip/Tooltip\";\n\ntype IconButtonProps = UnstyledButtonPropsFor<\"button\"> & {\n  /**\n   * The CSS class name.\n   */\n  className?: string;\n  /**\n   * The size of the button in CSS units, e.g. `\"24px\"`.\n   * Note that this is the size of the *button* itself: the icon will be 0.75 * this size\n   * @default 32px\n   */\n  size?: CSSStyleDeclaration[\"height\"];\n  /**\n   * The icon button indicator dot displayed on the top right\n   * As in IndicatorIcon\n   */\n  indicator?: \"default\" | \"success\" | \"critical\";\n  /**\n   * Whether the button is interactable\n   */\n  disabled?: boolean;\n  /**\n   * Whether this button triggers a destructive action.\n   * @default false\n   */\n  destructive?: boolean;\n  /**\n   * Optional tooltip for the button\n   */\n  tooltip?: string;\n  subtleBackground?: boolean;\n};\n\n/**\n * Display an icon as a button. Can render an indicator\n */\nexport const IconButton = forwardRef<\n  HTMLButtonElement,\n  PropsWithChildren<IconButtonProps>\n>(function IconButton(\n  {\n    children,\n    className,\n    indicator,\n    size = \"32px\",\n    style,\n    disabled,\n    destructive,\n    tooltip,\n    subtleBackground,\n    ...props\n  },\n  ref,\n) {\n  const classes = classnames(styles[\"icon-button\"], className, {\n    [styles.destructive]: destructive,\n    [styles[\"subtle-bg\"]]: subtleBackground,\n  });\n\n  const button = (\n    <UnstyledButton\n      as=\"button\"\n      ref={ref}\n      className={classes}\n      style={\n        {\n          \"--cpd-icon-button-size\": size,\n          ...style,\n        } as React.CSSProperties\n      }\n      disabled={disabled}\n      {...props}\n      data-indicator={indicator}\n    >\n      <IndicatorIcon\n        indicator={indicator}\n        colour={disabled ? \"var(--cpd-color-icon-disabled)\" : undefined}\n      >\n        {React.Children.only(children)}\n      </IndicatorIcon>\n    </UnstyledButton>\n  );\n\n  return tooltip ? <Tooltip label={tooltip}>{button}</Tooltip> : button;\n});\n","/*\nCopyright 2023 New Vector Ltd.\n\nSPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial\nPlease see LICENSE files in the repository root for full details.\n*/\n\nimport React, { PropsWithChildren, forwardRef, ForwardedRef, Ref } from \"react\";\n\ninterface ButtonComponent {\n  // With the explicit `as` prop\n  <C extends React.ElementType>(\n    props: { as: C } & UnstyledButtonPropsFor<C>,\n  ): React.ReactElement;\n  // Without the explicit `as` prop, defaulting to a <button>\n  (props: UnstyledButtonPropsFor<\"button\">): React.ReactElement;\n}\n\ntype UnstyledButtonProps = PropsWithChildren<{\n  /**\n   * Note that disabled attribute is not added to buttons, so that disabled buttons are discoverable by keyboard.\n   * `aria-disabled` attribute is used to indicate button is disabled.\n   * Event handlers are not passed to disabled buttons (onClick, onSubmit, etc.)\n   */\n  disabled?: boolean;\n}>;\n\nexport type UnstyledButtonPropsFor<C extends React.ElementType> =\n  UnstyledButtonProps &\n    Omit<\n      React.ComponentPropsWithoutRef<C>,\n      keyof UnstyledButtonProps | \"as\"\n    > & {\n      ref?: React.Ref<React.ComponentRef<C>>;\n    };\n\n/**\n * Unstyled button component. Can be disabled and optionally rendered as an anchor.\n * Intended to be wrapped with styles and exported as new button type - eg `IconButton` or `Button`.\n *\n * Not to be used externally.\n */\nexport const UnstyledButton = forwardRef(function UnstyledButton<\n  C extends React.ElementType = \"button\",\n>(\n  {\n    as,\n    children,\n    className,\n    disabled,\n    ...props\n  }: UnstyledButtonPropsFor<C> & { as?: C },\n  ref: ForwardedRef<C>,\n): React.ReactElement {\n  const Component = as || (\"button\" as const);\n\n  const {\n    onClick,\n    onSubmit,\n    onPointerDown,\n    onPointerUp,\n    onKeyDown,\n    onKeyUp,\n    onKeyPress,\n    ...restProps\n  } = props;\n  const eventHandlers = disabled\n    ? {}\n    : {\n        onClick,\n        onSubmit,\n        onPointerDown,\n        onPointerUp,\n        onKeyDown,\n        onKeyUp,\n        onKeyPress,\n      };\n\n  return (\n    <Component\n      {...restProps}\n      ref={ref as Ref<C>}\n      className={className}\n      // All elements roles should be overriden at the exceptions of anchors\n      // We want them to behave like links but look like buttons\n      role={as === \"a\" ? \"link\" : \"button\"}\n      tabIndex={0}\n      {...eventHandlers}\n      aria-disabled={disabled}\n    >\n      {children}\n    </Component>\n  );\n}) as ButtonComponent;\n","/*\nCopyright 2025 New Vector Ltd.\nCopyright 2023 The Matrix.org Foundation C.I.C.\nCopyright 2023 New Vector Ltd\n\nSPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial\nPlease see LICENSE files in the repository root for full details.\n*/\n\nimport classnames from \"classnames\";\nimport React, { ComponentProps, ComponentRef, forwardRef } from \"react\";\nimport CheckIcon from \"@vector-im/compound-design-tokens/assets/web/icons/check\";\nimport { Control } from \"@radix-ui/react-form\";\n\nimport styles from \"./Checkbox.module.css\";\n\ntype Props = {\n  /**\n   * The CSS class name.\n   */\n  className?: string;\n} & Omit<ComponentProps<\"input\">, \"type\">;\n\n/**\n * A styled checkbox input, for standalone use.\n */\nexport const CheckboxInput = forwardRef<HTMLInputElement, Props>(\n  function Checkbox({ className, ...props }, ref) {\n    const classes = classnames(styles.container, className);\n    return (\n      <div className={classes}>\n        <input ref={ref} className={styles.input} {...props} type=\"checkbox\" />\n        <div className={styles.ui}>\n          <CheckIcon aria-hidden={true} />\n        </div>\n      </div>\n    );\n  },\n);\n\n/**\n * A styled checkbox input wrapped in a `Control` component, for use in Radix forms.\n */\nexport const CheckboxControl = forwardRef<\n  ComponentRef<typeof CheckboxInput>,\n  ComponentProps<typeof CheckboxInput>\n>(function CheckboxControl(props, ref) {\n  return (\n    <Control asChild>\n      <CheckboxInput ref={ref} {...props} />\n    </Control>\n  );\n});\n","/*\nCopyright 2023 New Vector Ltd.\n\nSPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial\nPlease see LICENSE files in the repository root for full details.\n*/\n\nimport React, {\n  ComponentPropsWithoutRef,\n  ReactNode,\n  forwardRef,\n  Children,\n} from \"react\";\nimport classNames from \"classnames\";\n\nimport styles from \"./Glass.module.css\";\n\ninterface Props extends ComponentPropsWithoutRef<\"div\"> {\n  /**\n   * The child component.\n   */\n  children: ReactNode;\n  /**\n   * The CSS class.\n   */\n  className?: string;\n}\n\n/**\n * Adds a border of glass around a child component.\n */\nexport const Glass = forwardRef<HTMLDivElement, Props>(\n  ({ children, className, ...rest }, ref) => (\n    <div ref={ref} className={classNames(className, styles.glass)} {...rest}>\n      {Children.only(children)}\n    </div>\n  ),\n);\n\nGlass.displayName = \"Glass\";\n","/*\nCopyright 2024 New Vector Ltd.\n\nSPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial\nPlease see LICENSE files in the repository root for full details.\n*/\n\nimport React, { PropsWithChildren, forwardRef } from \"react\";\nimport classnames from \"classnames\";\n\nimport styles from \"./IndicatorIcon.module.css\";\n\ntype IconButtonProps = {\n  /**\n   * The CSS class name.\n   */\n  className?: string;\n  /**\n   * The icon size in CSS units, e.g. `\"24px\"`.\n   * @default 100%\n   */\n  size?: CSSStyleDeclaration[\"height\"];\n  /**\n   * The icon colour.\n   */\n  colour?: string;\n  /**\n   * The indicator dot displayed on the top right\n   * Names based on the colours used for the dot, or undefined for no dot.\n   */\n  indicator?: \"default\" | \"success\" | \"critical\";\n};\n\nexport const IndicatorIcon = forwardRef<\n  HTMLDivElement,\n  PropsWithChildren<IconButtonProps>\n>(function IconButton(\n  { children, className, size = \"100%\", colour, indicator },\n  ref,\n) {\n  const classes = classnames(styles[\"indicator-icon\"], className);\n  return (\n    <div\n      ref={ref}\n      className={classes}\n      data-indicator={indicator}\n      style={\n        {\n          \"--cpd-icon-button-size\": size,\n          \"--cpd-color-icon-tertiary\": colour,\n        } as React.CSSProperties\n      }\n    >\n      {React.Children.only(children)}\n    </div>\n  );\n});\n","import { forwardRef } from \"react\";\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nfunction SpinnerIcon(props, ref) {\n  return /*#__PURE__*/_jsx(\"svg\", {\n    xmlns: \"http://www.w3.org/2000/svg\",\n    width: \"1em\",\n    height: \"1em\",\n    fill: \"currentColor\",\n    viewBox: \"0 0 24 24\",\n    ref: ref,\n    ...props,\n    children: /*#__PURE__*/_jsx(\"path\", {\n      fillRule: \"evenodd\",\n      d: \"M12 4.031a8 8 0 1 0 8 8 1 1 0 0 1 2 0c0 5.523-4.477 10-10 10s-10-4.477-10-10 4.477-10 10-10a1 1 0 1 1 0 2\",\n      clipRule: \"evenodd\"\n    })\n  });\n}\n;\nSpinnerIcon.displayName = \"SpinnerIcon\";\nexport default forwardRef(SpinnerIcon);","/*\nCopyright 2024 New Vector Ltd.\n\nSPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial\nPlease see LICENSE files in the repository root for full details.\n*/\n\nimport React, { SVGAttributes, forwardRef } from \"react\";\nimport styles from \"./InlineSpinner.module.css\";\nimport SpinnerIcon from \"@vector-im/compound-design-tokens/assets/web/icons/spinner\";\n\ntype InlineSpinnerProps = {\n  size?: number;\n} & SVGAttributes<SVGElement>;\n\nexport const InlineSpinner = forwardRef<SVGSVGElement, InlineSpinnerProps>(\n  function InlineSpinner({ size = 20, ...props }, ref) {\n    return (\n      <SpinnerIcon\n        ref={ref}\n        className={styles.icon}\n        style={{ width: size, height: size }}\n        {...props}\n      />\n    );\n  },\n);\n","/*\nCopyright 2023 New Vector Ltd.\n\nSPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial\nPlease see LICENSE files in the repository root for full details.\n*/\n\nimport React, { forwardRef, PropsWithChildren } from \"react\";\nimport styles from \"./Link.module.css\";\nimport classNames from \"classnames\";\n\ntype LinkProps = {\n  /**\n   * The CSS class name.\n   */\n  className?: string;\n  /**\n   * The type of link.\n   * @default \"primary\"\n   */\n  kind?: \"primary\" | \"critical\";\n  /**\n   * The size of link.\n   * @default \"medium\"\n   */\n  size?: \"small\" | \"medium\";\n} & Omit<React.HTMLProps<HTMLAnchorElement>, \"rel\" | \"size\">;\n\n/**\n * A link component.\n */\nexport const Link = forwardRef<HTMLAnchorElement, PropsWithChildren<LinkProps>>(\n  function Link(\n    { children, className, kind = \"primary\", size = \"medium\", ...props },\n    ref,\n  ) {\n    return (\n      <a\n        ref={ref}\n        {...props}\n        rel=\"noreferrer noopener\"\n        className={classNames(styles.link, className)}\n        data-kind={kind}\n        data-size={size}\n      >\n        {children}\n      </a>\n    );\n  },\n);\n","// packages/react/context/src/createContext.tsx\nimport * as React from \"react\";\nimport { jsx } from \"react/jsx-runtime\";\nfunction createContext2(rootComponentName, defaultContext) {\n  const Context = React.createContext(defaultContext);\n  const Provider = (props) => {\n    const { children, ...context } = props;\n    const value = React.useMemo(() => context, Object.values(context));\n    return /* @__PURE__ */ jsx(Context.Provider, { value, children });\n  };\n  Provider.displayName = rootComponentName + \"Provider\";\n  function useContext2(consumerName) {\n    const context = React.useContext(Context);\n    if (context) return context;\n    if (defaultContext !== void 0) return defaultContext;\n    throw new Error(`\\`${consumerName}\\` must be used within \\`${rootComponentName}\\``);\n  }\n  return [Provider, useContext2];\n}\nfunction createContextScope(scopeName, createContextScopeDeps = []) {\n  let defaultContexts = [];\n  function createContext3(rootComponentName, defaultContext) {\n    const BaseContext = React.createContext(defaultContext);\n    const index = defaultContexts.length;\n    defaultContexts = [...defaultContexts, defaultContext];\n    const Provider = (props) => {\n      const { scope, children, ...context } = props;\n      const Context = scope?.[scopeName]?.[index] || BaseContext;\n      const value = React.useMemo(() => context, Object.values(context));\n      return /* @__PURE__ */ jsx(Context.Provider, { value, children });\n    };\n    Provider.displayName = rootComponentName + \"Provider\";\n    function useContext2(consumerName, scope) {\n      const Context = scope?.[scopeName]?.[index] || BaseContext;\n      const context = React.useContext(Context);\n      if (context) return context;\n      if (defaultContext !== void 0) return defaultContext;\n      throw new Error(`\\`${consumerName}\\` must be used within \\`${rootComponentName}\\``);\n    }\n    return [Provider, useContext2];\n  }\n  const createScope = () => {\n    const scopeContexts = defaultContexts.map((defaultContext) => {\n      return React.createContext(defaultContext);\n    });\n    return function useScope(scope) {\n      const contexts = scope?.[scopeName] || scopeContexts;\n      return React.useMemo(\n        () => ({ [`__scope${scopeName}`]: { ...scope, [scopeName]: contexts } }),\n        [scope, contexts]\n      );\n    };\n  };\n  createScope.scopeName = scopeName;\n  return [createContext3, composeContextScopes(createScope, ...createContextScopeDeps)];\n}\nfunction composeContextScopes(...scopes) {\n  const baseScope = scopes[0];\n  if (scopes.length === 1) return baseScope;\n  const createScope = () => {\n    const scopeHooks = scopes.map((createScope2) => ({\n      useScope: createScope2(),\n      scopeName: createScope2.scopeName\n    }));\n    return function useComposedScopes(overrideScopes) {\n      const nextScopes = scopeHooks.reduce((nextScopes2, { useScope, scopeName }) => {\n        const scopeProps = useScope(overrideScopes);\n        const currentScope = scopeProps[`__scope${scopeName}`];\n        return { ...nextScopes2, ...currentScope };\n      }, {});\n      return React.useMemo(() => ({ [`__scope${baseScope.scopeName}`]: nextScopes }), [nextScopes]);\n    };\n  };\n  createScope.scopeName = baseScope.scopeName;\n  return createScope;\n}\nexport {\n  createContext2 as createContext,\n  createContextScope\n};\n//# sourceMappingURL=index.mjs.map\n","// packages/react/use-callback-ref/src/useCallbackRef.tsx\nimport * as React from \"react\";\nfunction useCallbackRef(callback) {\n  const callbackRef = React.useRef(callback);\n  React.useEffect(() => {\n    callbackRef.current = callback;\n  });\n  return React.useMemo(() => (...args) => callbackRef.current?.(...args), []);\n}\nexport {\n  useCallbackRef\n};\n//# sourceMappingURL=index.mjs.map\n","// packages/react/use-controllable-state/src/useControllableState.tsx\nimport * as React from \"react\";\nimport { useCallbackRef } from \"@radix-ui/react-use-callback-ref\";\nfunction useControllableState({\n  prop,\n  defaultProp,\n  onChange = () => {\n  }\n}) {\n  const [uncontrolledProp, setUncontrolledProp] = useUncontrolledState({ defaultProp, onChange });\n  const isControlled = prop !== void 0;\n  const value = isControlled ? prop : uncontrolledProp;\n  const handleChange = useCallbackRef(onChange);\n  const setValue = React.useCallback(\n    (nextValue) => {\n      if (isControlled) {\n        const setter = nextValue;\n        const value2 = typeof nextValue === \"function\" ? setter(prop) : nextValue;\n        if (value2 !== prop) handleChange(value2);\n      } else {\n        setUncontrolledProp(nextValue);\n      }\n    },\n    [isControlled, prop, setUncontrolledProp, handleChange]\n  );\n  return [value, setValue];\n}\nfunction useUncontrolledState({\n  defaultProp,\n  onChange\n}) {\n  const uncontrolledState = React.useState(defaultProp);\n  const [value] = uncontrolledState;\n  const prevValueRef = React.useRef(value);\n  const handleChange = useCallbackRef(onChange);\n  React.useEffect(() => {\n    if (prevValueRef.current !== value) {\n      handleChange(value);\n      prevValueRef.current = value;\n    }\n  }, [value, prevValueRef, handleChange]);\n  return uncontrolledState;\n}\nexport {\n  useControllableState\n};\n//# sourceMappingURL=index.mjs.map\n","\"use client\";\n\n// packages/react/collection/src/Collection.tsx\nimport React from \"react\";\nimport { createContextScope } from \"@radix-ui/react-context\";\nimport { useComposedRefs } from \"@radix-ui/react-compose-refs\";\nimport { Slot } from \"@radix-ui/react-slot\";\nimport { jsx } from \"react/jsx-runtime\";\nfunction createCollection(name) {\n  const PROVIDER_NAME = name + \"CollectionProvider\";\n  const [createCollectionContext, createCollectionScope] = createContextScope(PROVIDER_NAME);\n  const [CollectionProviderImpl, useCollectionContext] = createCollectionContext(\n    PROVIDER_NAME,\n    { collectionRef: { current: null }, itemMap: /* @__PURE__ */ new Map() }\n  );\n  const CollectionProvider = (props) => {\n    const { scope, children } = props;\n    const ref = React.useRef(null);\n    const itemMap = React.useRef(/* @__PURE__ */ new Map()).current;\n    return /* @__PURE__ */ jsx(CollectionProviderImpl, { scope, itemMap, collectionRef: ref, children });\n  };\n  CollectionProvider.displayName = PROVIDER_NAME;\n  const COLLECTION_SLOT_NAME = name + \"CollectionSlot\";\n  const CollectionSlot = React.forwardRef(\n    (props, forwardedRef) => {\n      const { scope, children } = props;\n      const context = useCollectionContext(COLLECTION_SLOT_NAME, scope);\n      const composedRefs = useComposedRefs(forwardedRef, context.collectionRef);\n      return /* @__PURE__ */ jsx(Slot, { ref: composedRefs, children });\n    }\n  );\n  CollectionSlot.displayName = COLLECTION_SLOT_NAME;\n  const ITEM_SLOT_NAME = name + \"CollectionItemSlot\";\n  const ITEM_DATA_ATTR = \"data-radix-collection-item\";\n  const CollectionItemSlot = React.forwardRef(\n    (props, forwardedRef) => {\n      const { scope, children, ...itemData } = props;\n      const ref = React.useRef(null);\n      const composedRefs = useComposedRefs(forwardedRef, ref);\n      const context = useCollectionContext(ITEM_SLOT_NAME, scope);\n      React.useEffect(() => {\n        context.itemMap.set(ref, { ref, ...itemData });\n        return () => void context.itemMap.delete(ref);\n      });\n      return /* @__PURE__ */ jsx(Slot, { ...{ [ITEM_DATA_ATTR]: \"\" }, ref: composedRefs, children });\n    }\n  );\n  CollectionItemSlot.displayName = ITEM_SLOT_NAME;\n  function useCollection(scope) {\n    const context = useCollectionContext(name + \"CollectionConsumer\", scope);\n    const getItems = React.useCallback(() => {\n      const collectionNode = context.collectionRef.current;\n      if (!collectionNode) return [];\n      const orderedNodes = Array.from(collectionNode.querySelectorAll(`[${ITEM_DATA_ATTR}]`));\n      const items = Array.from(context.itemMap.values());\n      const orderedItems = items.sort(\n        (a, b) => orderedNodes.indexOf(a.ref.current) - orderedNodes.indexOf(b.ref.current)\n      );\n      return orderedItems;\n    }, [context.collectionRef, context.itemMap]);\n    return getItems;\n  }\n  return [\n    { Provider: CollectionProvider, Slot: CollectionSlot, ItemSlot: CollectionItemSlot },\n    useCollection,\n    createCollectionScope\n  ];\n}\nexport {\n  createCollection\n};\n//# sourceMappingURL=index.mjs.map\n","// packages/react/context/src/createContext.tsx\nimport * as React from \"react\";\nimport { jsx } from \"react/jsx-runtime\";\nfunction createContext2(rootComponentName, defaultContext) {\n  const Context = React.createContext(defaultContext);\n  const Provider = (props) => {\n    const { children, ...context } = props;\n    const value = React.useMemo(() => context, Object.values(context));\n    return /* @__PURE__ */ jsx(Context.Provider, { value, children });\n  };\n  Provider.displayName = rootComponentName + \"Provider\";\n  function useContext2(consumerName) {\n    const context = React.useContext(Context);\n    if (context) return context;\n    if (defaultContext !== void 0) return defaultContext;\n    throw new Error(`\\`${consumerName}\\` must be used within \\`${rootComponentName}\\``);\n  }\n  return [Provider, useContext2];\n}\nfunction createContextScope(scopeName, createContextScopeDeps = []) {\n  let defaultContexts = [];\n  function createContext3(rootComponentName, defaultContext) {\n    const BaseContext = React.createContext(defaultContext);\n    const index = defaultContexts.length;\n    defaultContexts = [...defaultContexts, defaultContext];\n    const Provider = (props) => {\n      const { scope, children, ...context } = props;\n      const Context = scope?.[scopeName]?.[index] || BaseContext;\n      const value = React.useMemo(() => context, Object.values(context));\n      return /* @__PURE__ */ jsx(Context.Provider, { value, children });\n    };\n    Provider.displayName = rootComponentName + \"Provider\";\n    function useContext2(consumerName, scope) {\n      const Context = scope?.[scopeName]?.[index] || BaseContext;\n      const context = React.useContext(Context);\n      if (context) return context;\n      if (defaultContext !== void 0) return defaultContext;\n      throw new Error(`\\`${consumerName}\\` must be used within \\`${rootComponentName}\\``);\n    }\n    return [Provider, useContext2];\n  }\n  const createScope = () => {\n    const scopeContexts = defaultContexts.map((defaultContext) => {\n      return React.createContext(defaultContext);\n    });\n    return function useScope(scope) {\n      const contexts = scope?.[scopeName] || scopeContexts;\n      return React.useMemo(\n        () => ({ [`__scope${scopeName}`]: { ...scope, [scopeName]: contexts } }),\n        [scope, contexts]\n      );\n    };\n  };\n  createScope.scopeName = scopeName;\n  return [createContext3, composeContextScopes(createScope, ...createContextScopeDeps)];\n}\nfunction composeContextScopes(...scopes) {\n  const baseScope = scopes[0];\n  if (scopes.length === 1) return baseScope;\n  const createScope = () => {\n    const scopeHooks = scopes.map((createScope2) => ({\n      useScope: createScope2(),\n      scopeName: createScope2.scopeName\n    }));\n    return function useComposedScopes(overrideScopes) {\n      const nextScopes = scopeHooks.reduce((nextScopes2, { useScope, scopeName }) => {\n        const scopeProps = useScope(overrideScopes);\n        const currentScope = scopeProps[`__scope${scopeName}`];\n        return { ...nextScopes2, ...currentScope };\n      }, {});\n      return React.useMemo(() => ({ [`__scope${baseScope.scopeName}`]: nextScopes }), [nextScopes]);\n    };\n  };\n  createScope.scopeName = baseScope.scopeName;\n  return createScope;\n}\nexport {\n  createContext2 as createContext,\n  createContextScope\n};\n//# sourceMappingURL=index.mjs.map\n","// packages/react/direction/src/Direction.tsx\nimport * as React from \"react\";\nimport { jsx } from \"react/jsx-runtime\";\nvar DirectionContext = React.createContext(void 0);\nvar DirectionProvider = (props) => {\n  const { dir, children } = props;\n  return /* @__PURE__ */ jsx(DirectionContext.Provider, { value: dir, children });\n};\nfunction useDirection(localDir) {\n  const globalDir = React.useContext(DirectionContext);\n  return localDir || globalDir || \"ltr\";\n}\nvar Provider = DirectionProvider;\nexport {\n  DirectionProvider,\n  Provider,\n  useDirection\n};\n//# sourceMappingURL=index.mjs.map\n","\"use client\";\n\n// packages/react/dismissable-layer/src/DismissableLayer.tsx\nimport * as React from \"react\";\nimport { composeEventHandlers } from \"@radix-ui/primitive\";\nimport { Primitive, dispatchDiscreteCustomEvent } from \"@radix-ui/react-primitive\";\nimport { useComposedRefs } from \"@radix-ui/react-compose-refs\";\nimport { useCallbackRef } from \"@radix-ui/react-use-callback-ref\";\nimport { useEscapeKeydown } from \"@radix-ui/react-use-escape-keydown\";\nimport { jsx } from \"react/jsx-runtime\";\nvar DISMISSABLE_LAYER_NAME = \"DismissableLayer\";\nvar CONTEXT_UPDATE = \"dismissableLayer.update\";\nvar POINTER_DOWN_OUTSIDE = \"dismissableLayer.pointerDownOutside\";\nvar FOCUS_OUTSIDE = \"dismissableLayer.focusOutside\";\nvar originalBodyPointerEvents;\nvar DismissableLayerContext = React.createContext({\n  layers: /* @__PURE__ */ new Set(),\n  layersWithOutsidePointerEventsDisabled: /* @__PURE__ */ new Set(),\n  branches: /* @__PURE__ */ new Set()\n});\nvar DismissableLayer = React.forwardRef(\n  (props, forwardedRef) => {\n    const {\n      disableOutsidePointerEvents = false,\n      onEscapeKeyDown,\n      onPointerDownOutside,\n      onFocusOutside,\n      onInteractOutside,\n      onDismiss,\n      ...layerProps\n    } = props;\n    const context = React.useContext(DismissableLayerContext);\n    const [node, setNode] = React.useState(null);\n    const ownerDocument = node?.ownerDocument ?? globalThis?.document;\n    const [, force] = React.useState({});\n    const composedRefs = useComposedRefs(forwardedRef, (node2) => setNode(node2));\n    const layers = Array.from(context.layers);\n    const [highestLayerWithOutsidePointerEventsDisabled] = [...context.layersWithOutsidePointerEventsDisabled].slice(-1);\n    const highestLayerWithOutsidePointerEventsDisabledIndex = layers.indexOf(highestLayerWithOutsidePointerEventsDisabled);\n    const index = node ? layers.indexOf(node) : -1;\n    const isBodyPointerEventsDisabled = context.layersWithOutsidePointerEventsDisabled.size > 0;\n    const isPointerEventsEnabled = index >= highestLayerWithOutsidePointerEventsDisabledIndex;\n    const pointerDownOutside = usePointerDownOutside((event) => {\n      const target = event.target;\n      const isPointerDownOnBranch = [...context.branches].some((branch) => branch.contains(target));\n      if (!isPointerEventsEnabled || isPointerDownOnBranch) return;\n      onPointerDownOutside?.(event);\n      onInteractOutside?.(event);\n      if (!event.defaultPrevented) onDismiss?.();\n    }, ownerDocument);\n    const focusOutside = useFocusOutside((event) => {\n      const target = event.target;\n      const isFocusInBranch = [...context.branches].some((branch) => branch.contains(target));\n      if (isFocusInBranch) return;\n      onFocusOutside?.(event);\n      onInteractOutside?.(event);\n      if (!event.defaultPrevented) onDismiss?.();\n    }, ownerDocument);\n    useEscapeKeydown((event) => {\n      const isHighestLayer = index === context.layers.size - 1;\n      if (!isHighestLayer) return;\n      onEscapeKeyDown?.(event);\n      if (!event.defaultPrevented && onDismiss) {\n        event.preventDefault();\n        onDismiss();\n      }\n    }, ownerDocument);\n    React.useEffect(() => {\n      if (!node) return;\n      if (disableOutsidePointerEvents) {\n        if (context.layersWithOutsidePointerEventsDisabled.size === 0) {\n          originalBodyPointerEvents = ownerDocument.body.style.pointerEvents;\n          ownerDocument.body.style.pointerEvents = \"none\";\n        }\n        context.layersWithOutsidePointerEventsDisabled.add(node);\n      }\n      context.layers.add(node);\n      dispatchUpdate();\n      return () => {\n        if (disableOutsidePointerEvents && context.layersWithOutsidePointerEventsDisabled.size === 1) {\n          ownerDocument.body.style.pointerEvents = originalBodyPointerEvents;\n        }\n      };\n    }, [node, ownerDocument, disableOutsidePointerEvents, context]);\n    React.useEffect(() => {\n      return () => {\n        if (!node) return;\n        context.layers.delete(node);\n        context.layersWithOutsidePointerEventsDisabled.delete(node);\n        dispatchUpdate();\n      };\n    }, [node, context]);\n    React.useEffect(() => {\n      const handleUpdate = () => force({});\n      document.addEventListener(CONTEXT_UPDATE, handleUpdate);\n      return () => document.removeEventListener(CONTEXT_UPDATE, handleUpdate);\n    }, []);\n    return /* @__PURE__ */ jsx(\n      Primitive.div,\n      {\n        ...layerProps,\n        ref: composedRefs,\n        style: {\n          pointerEvents: isBodyPointerEventsDisabled ? isPointerEventsEnabled ? \"auto\" : \"none\" : void 0,\n          ...props.style\n        },\n        onFocusCapture: composeEventHandlers(props.onFocusCapture, focusOutside.onFocusCapture),\n        onBlurCapture: composeEventHandlers(props.onBlurCapture, focusOutside.onBlurCapture),\n        onPointerDownCapture: composeEventHandlers(\n          props.onPointerDownCapture,\n          pointerDownOutside.onPointerDownCapture\n        )\n      }\n    );\n  }\n);\nDismissableLayer.displayName = DISMISSABLE_LAYER_NAME;\nvar BRANCH_NAME = \"DismissableLayerBranch\";\nvar DismissableLayerBranch = React.forwardRef((props, forwardedRef) => {\n  const context = React.useContext(DismissableLayerContext);\n  const ref = React.useRef(null);\n  const composedRefs = useComposedRefs(forwardedRef, ref);\n  React.useEffect(() => {\n    const node = ref.current;\n    if (node) {\n      context.branches.add(node);\n      return () => {\n        context.branches.delete(node);\n      };\n    }\n  }, [context.branches]);\n  return /* @__PURE__ */ jsx(Primitive.div, { ...props, ref: composedRefs });\n});\nDismissableLayerBranch.displayName = BRANCH_NAME;\nfunction usePointerDownOutside(onPointerDownOutside, ownerDocument = globalThis?.document) {\n  const handlePointerDownOutside = useCallbackRef(onPointerDownOutside);\n  const isPointerInsideReactTreeRef = React.useRef(false);\n  const handleClickRef = React.useRef(() => {\n  });\n  React.useEffect(() => {\n    const handlePointerDown = (event) => {\n      if (event.target && !isPointerInsideReactTreeRef.current) {\n        let handleAndDispatchPointerDownOutsideEvent2 = function() {\n          handleAndDispatchCustomEvent(\n            POINTER_DOWN_OUTSIDE,\n            handlePointerDownOutside,\n            eventDetail,\n            { discrete: true }\n          );\n        };\n        var handleAndDispatchPointerDownOutsideEvent = handleAndDispatchPointerDownOutsideEvent2;\n        const eventDetail = { originalEvent: event };\n        if (event.pointerType === \"touch\") {\n          ownerDocument.removeEventListener(\"click\", handleClickRef.current);\n          handleClickRef.current = handleAndDispatchPointerDownOutsideEvent2;\n          ownerDocument.addEventListener(\"click\", handleClickRef.current, { once: true });\n        } else {\n          handleAndDispatchPointerDownOutsideEvent2();\n        }\n      } else {\n        ownerDocument.removeEventListener(\"click\", handleClickRef.current);\n      }\n      isPointerInsideReactTreeRef.current = false;\n    };\n    const timerId = window.setTimeout(() => {\n      ownerDocument.addEventListener(\"pointerdown\", handlePointerDown);\n    }, 0);\n    return () => {\n      window.clearTimeout(timerId);\n      ownerDocument.removeEventListener(\"pointerdown\", handlePointerDown);\n      ownerDocument.removeEventListener(\"click\", handleClickRef.current);\n    };\n  }, [ownerDocument, handlePointerDownOutside]);\n  return {\n    // ensures we check React component tree (not just DOM tree)\n    onPointerDownCapture: () => isPointerInsideReactTreeRef.current = true\n  };\n}\nfunction useFocusOutside(onFocusOutside, ownerDocument = globalThis?.document) {\n  const handleFocusOutside = useCallbackRef(onFocusOutside);\n  const isFocusInsideReactTreeRef = React.useRef(false);\n  React.useEffect(() => {\n    const handleFocus = (event) => {\n      if (event.target && !isFocusInsideReactTreeRef.current) {\n        const eventDetail = { originalEvent: event };\n        handleAndDispatchCustomEvent(FOCUS_OUTSIDE, handleFocusOutside, eventDetail, {\n          discrete: false\n        });\n      }\n    };\n    ownerDocument.addEventListener(\"focusin\", handleFocus);\n    return () => ownerDocument.removeEventListener(\"focusin\", handleFocus);\n  }, [ownerDocument, handleFocusOutside]);\n  return {\n    onFocusCapture: () => isFocusInsideReactTreeRef.current = true,\n    onBlurCapture: () => isFocusInsideReactTreeRef.current = false\n  };\n}\nfunction dispatchUpdate() {\n  const event = new CustomEvent(CONTEXT_UPDATE);\n  document.dispatchEvent(event);\n}\nfunction handleAndDispatchCustomEvent(name, handler, detail, { discrete }) {\n  const target = detail.originalEvent.target;\n  const event = new CustomEvent(name, { bubbles: false, cancelable: true, detail });\n  if (handler) target.addEventListener(name, handler, { once: true });\n  if (discrete) {\n    dispatchDiscreteCustomEvent(target, event);\n  } else {\n    target.dispatchEvent(event);\n  }\n}\nvar Root = DismissableLayer;\nvar Branch = DismissableLayerBranch;\nexport {\n  Branch,\n  DismissableLayer,\n  DismissableLayerBranch,\n  Root\n};\n//# sourceMappingURL=index.mjs.map\n","// packages/react/use-escape-keydown/src/useEscapeKeydown.tsx\nimport * as React from \"react\";\nimport { useCallbackRef } from \"@radix-ui/react-use-callback-ref\";\nfunction useEscapeKeydown(onEscapeKeyDownProp, ownerDocument = globalThis?.document) {\n  const onEscapeKeyDown = useCallbackRef(onEscapeKeyDownProp);\n  React.useEffect(() => {\n    const handleKeyDown = (event) => {\n      if (event.key === \"Escape\") {\n        onEscapeKeyDown(event);\n      }\n    };\n    ownerDocument.addEventListener(\"keydown\", handleKeyDown, { capture: true });\n    return () => ownerDocument.removeEventListener(\"keydown\", handleKeyDown, { capture: true });\n  }, [onEscapeKeyDown, ownerDocument]);\n}\nexport {\n  useEscapeKeydown\n};\n//# sourceMappingURL=index.mjs.map\n","\"use client\";\n\n// packages/react/focus-guards/src/FocusGuards.tsx\nimport * as React from \"react\";\nvar count = 0;\nfunction FocusGuards(props) {\n  useFocusGuards();\n  return props.children;\n}\nfunction useFocusGuards() {\n  React.useEffect(() => {\n    const edgeGuards = document.querySelectorAll(\"[data-radix-focus-guard]\");\n    document.body.insertAdjacentElement(\"afterbegin\", edgeGuards[0] ?? createFocusGuard());\n    document.body.insertAdjacentElement(\"beforeend\", edgeGuards[1] ?? createFocusGuard());\n    count++;\n    return () => {\n      if (count === 1) {\n        document.querySelectorAll(\"[data-radix-focus-guard]\").forEach((node) => node.remove());\n      }\n      count--;\n    };\n  }, []);\n}\nfunction createFocusGuard() {\n  const element = document.createElement(\"span\");\n  element.setAttribute(\"data-radix-focus-guard\", \"\");\n  element.tabIndex = 0;\n  element.style.outline = \"none\";\n  element.style.opacity = \"0\";\n  element.style.position = \"fixed\";\n  element.style.pointerEvents = \"none\";\n  return element;\n}\nvar Root = FocusGuards;\nexport {\n  FocusGuards,\n  Root,\n  useFocusGuards\n};\n//# sourceMappingURL=index.mjs.map\n","\"use client\";\n\n// packages/react/focus-scope/src/FocusScope.tsx\nimport * as React from \"react\";\nimport { useComposedRefs } from \"@radix-ui/react-compose-refs\";\nimport { Primitive } from \"@radix-ui/react-primitive\";\nimport { useCallbackRef } from \"@radix-ui/react-use-callback-ref\";\nimport { jsx } from \"react/jsx-runtime\";\nvar AUTOFOCUS_ON_MOUNT = \"focusScope.autoFocusOnMount\";\nvar AUTOFOCUS_ON_UNMOUNT = \"focusScope.autoFocusOnUnmount\";\nvar EVENT_OPTIONS = { bubbles: false, cancelable: true };\nvar FOCUS_SCOPE_NAME = \"FocusScope\";\nvar FocusScope = React.forwardRef((props, forwardedRef) => {\n  const {\n    loop = false,\n    trapped = false,\n    onMountAutoFocus: onMountAutoFocusProp,\n    onUnmountAutoFocus: onUnmountAutoFocusProp,\n    ...scopeProps\n  } = props;\n  const [container, setContainer] = React.useState(null);\n  const onMountAutoFocus = useCallbackRef(onMountAutoFocusProp);\n  const onUnmountAutoFocus = useCallbackRef(onUnmountAutoFocusProp);\n  const lastFocusedElementRef = React.useRef(null);\n  const composedRefs = useComposedRefs(forwardedRef, (node) => setContainer(node));\n  const focusScope = React.useRef({\n    paused: false,\n    pause() {\n      this.paused = true;\n    },\n    resume() {\n      this.paused = false;\n    }\n  }).current;\n  React.useEffect(() => {\n    if (trapped) {\n      let handleFocusIn2 = function(event) {\n        if (focusScope.paused || !container) return;\n        const target = event.target;\n        if (container.contains(target)) {\n          lastFocusedElementRef.current = target;\n        } else {\n          focus(lastFocusedElementRef.current, { select: true });\n        }\n      }, handleFocusOut2 = function(event) {\n        if (focusScope.paused || !container) return;\n        const relatedTarget = event.relatedTarget;\n        if (relatedTarget === null) return;\n        if (!container.contains(relatedTarget)) {\n          focus(lastFocusedElementRef.current, { select: true });\n        }\n      }, handleMutations2 = function(mutations) {\n        const focusedElement = document.activeElement;\n        if (focusedElement !== document.body) return;\n        for (const mutation of mutations) {\n          if (mutation.removedNodes.length > 0) focus(container);\n        }\n      };\n      var handleFocusIn = handleFocusIn2, handleFocusOut = handleFocusOut2, handleMutations = handleMutations2;\n      document.addEventListener(\"focusin\", handleFocusIn2);\n      document.addEventListener(\"focusout\", handleFocusOut2);\n      const mutationObserver = new MutationObserver(handleMutations2);\n      if (container) mutationObserver.observe(container, { childList: true, subtree: true });\n      return () => {\n        document.removeEventListener(\"focusin\", handleFocusIn2);\n        document.removeEventListener(\"focusout\", handleFocusOut2);\n        mutationObserver.disconnect();\n      };\n    }\n  }, [trapped, container, focusScope.paused]);\n  React.useEffect(() => {\n    if (container) {\n      focusScopesStack.add(focusScope);\n      const previouslyFocusedElement = document.activeElement;\n      const hasFocusedCandidate = container.contains(previouslyFocusedElement);\n      if (!hasFocusedCandidate) {\n        const mountEvent = new CustomEvent(AUTOFOCUS_ON_MOUNT, EVENT_OPTIONS);\n        container.addEventListener(AUTOFOCUS_ON_MOUNT, onMountAutoFocus);\n        container.dispatchEvent(mountEvent);\n        if (!mountEvent.defaultPrevented) {\n          focusFirst(removeLinks(getTabbableCandidates(container)), { select: true });\n          if (document.activeElement === previouslyFocusedElement) {\n            focus(container);\n          }\n        }\n      }\n      return () => {\n        container.removeEventListener(AUTOFOCUS_ON_MOUNT, onMountAutoFocus);\n        setTimeout(() => {\n          const unmountEvent = new CustomEvent(AUTOFOCUS_ON_UNMOUNT, EVENT_OPTIONS);\n          container.addEventListener(AUTOFOCUS_ON_UNMOUNT, onUnmountAutoFocus);\n          container.dispatchEvent(unmountEvent);\n          if (!unmountEvent.defaultPrevented) {\n            focus(previouslyFocusedElement ?? document.body, { select: true });\n          }\n          container.removeEventListener(AUTOFOCUS_ON_UNMOUNT, onUnmountAutoFocus);\n          focusScopesStack.remove(focusScope);\n        }, 0);\n      };\n    }\n  }, [container, onMountAutoFocus, onUnmountAutoFocus, focusScope]);\n  const handleKeyDown = React.useCallback(\n    (event) => {\n      if (!loop && !trapped) return;\n      if (focusScope.paused) return;\n      const isTabKey = event.key === \"Tab\" && !event.altKey && !event.ctrlKey && !event.metaKey;\n      const focusedElement = document.activeElement;\n      if (isTabKey && focusedElement) {\n        const container2 = event.currentTarget;\n        const [first, last] = getTabbableEdges(container2);\n        const hasTabbableElementsInside = first && last;\n        if (!hasTabbableElementsInside) {\n          if (focusedElement === container2) event.preventDefault();\n        } else {\n          if (!event.shiftKey && focusedElement === last) {\n            event.preventDefault();\n            if (loop) focus(first, { select: true });\n          } else if (event.shiftKey && focusedElement === first) {\n            event.preventDefault();\n            if (loop) focus(last, { select: true });\n          }\n        }\n      }\n    },\n    [loop, trapped, focusScope.paused]\n  );\n  return /* @__PURE__ */ jsx(Primitive.div, { tabIndex: -1, ...scopeProps, ref: composedRefs, onKeyDown: handleKeyDown });\n});\nFocusScope.displayName = FOCUS_SCOPE_NAME;\nfunction focusFirst(candidates, { select = false } = {}) {\n  const previouslyFocusedElement = document.activeElement;\n  for (const candidate of candidates) {\n    focus(candidate, { select });\n    if (document.activeElement !== previouslyFocusedElement) return;\n  }\n}\nfunction getTabbableEdges(container) {\n  const candidates = getTabbableCandidates(container);\n  const first = findVisible(candidates, container);\n  const last = findVisible(candidates.reverse(), container);\n  return [first, last];\n}\nfunction getTabbableCandidates(container) {\n  const nodes = [];\n  const walker = document.createTreeWalker(container, NodeFilter.SHOW_ELEMENT, {\n    acceptNode: (node) => {\n      const isHiddenInput = node.tagName === \"INPUT\" && node.type === \"hidden\";\n      if (node.disabled || node.hidden || isHiddenInput) return NodeFilter.FILTER_SKIP;\n      return node.tabIndex >= 0 ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;\n    }\n  });\n  while (walker.nextNode()) nodes.push(walker.currentNode);\n  return nodes;\n}\nfunction findVisible(elements, container) {\n  for (const element of elements) {\n    if (!isHidden(element, { upTo: container })) return element;\n  }\n}\nfunction isHidden(node, { upTo }) {\n  if (getComputedStyle(node).visibility === \"hidden\") return true;\n  while (node) {\n    if (upTo !== void 0 && node === upTo) return false;\n    if (getComputedStyle(node).display === \"none\") return true;\n    node = node.parentElement;\n  }\n  return false;\n}\nfunction isSelectableInput(element) {\n  return element instanceof HTMLInputElement && \"select\" in element;\n}\nfunction focus(element, { select = false } = {}) {\n  if (element && element.focus) {\n    const previouslyFocusedElement = document.activeElement;\n    element.focus({ preventScroll: true });\n    if (element !== previouslyFocusedElement && isSelectableInput(element) && select)\n      element.select();\n  }\n}\nvar focusScopesStack = createFocusScopesStack();\nfunction createFocusScopesStack() {\n  let stack = [];\n  return {\n    add(focusScope) {\n      const activeFocusScope = stack[0];\n      if (focusScope !== activeFocusScope) {\n        activeFocusScope?.pause();\n      }\n      stack = arrayRemove(stack, focusScope);\n      stack.unshift(focusScope);\n    },\n    remove(focusScope) {\n      stack = arrayRemove(stack, focusScope);\n      stack[0]?.resume();\n    }\n  };\n}\nfunction arrayRemove(array, item) {\n  const updatedArray = [...array];\n  const index = updatedArray.indexOf(item);\n  if (index !== -1) {\n    updatedArray.splice(index, 1);\n  }\n  return updatedArray;\n}\nfunction removeLinks(items) {\n  return items.filter((item) => item.tagName !== \"A\");\n}\nvar Root = FocusScope;\nexport {\n  FocusScope,\n  Root\n};\n//# sourceMappingURL=index.mjs.map\n","// packages/react/arrow/src/Arrow.tsx\nimport * as React from \"react\";\nimport { Primitive } from \"@radix-ui/react-primitive\";\nimport { jsx } from \"react/jsx-runtime\";\nvar NAME = \"Arrow\";\nvar Arrow = React.forwardRef((props, forwardedRef) => {\n  const { children, width = 10, height = 5, ...arrowProps } = props;\n  return /* @__PURE__ */ jsx(\n    Primitive.svg,\n    {\n      ...arrowProps,\n      ref: forwardedRef,\n      width,\n      height,\n      viewBox: \"0 0 30 10\",\n      preserveAspectRatio: \"none\",\n      children: props.asChild ? children : /* @__PURE__ */ jsx(\"polygon\", { points: \"0,0 30,0 15,10\" })\n    }\n  );\n});\nArrow.displayName = NAME;\nvar Root = Arrow;\nexport {\n  Arrow,\n  Root\n};\n//# sourceMappingURL=index.mjs.map\n","\"use client\";\n\n// packages/react/popper/src/Popper.tsx\nimport * as React from \"react\";\nimport {\n  useFloating,\n  autoUpdate,\n  offset,\n  shift,\n  limitShift,\n  hide,\n  arrow as floatingUIarrow,\n  flip,\n  size\n} from \"@floating-ui/react-dom\";\nimport * as ArrowPrimitive from \"@radix-ui/react-arrow\";\nimport { useComposedRefs } from \"@radix-ui/react-compose-refs\";\nimport { createContextScope } from \"@radix-ui/react-context\";\nimport { Primitive } from \"@radix-ui/react-primitive\";\nimport { useCallbackRef } from \"@radix-ui/react-use-callback-ref\";\nimport { useLayoutEffect } from \"@radix-ui/react-use-layout-effect\";\nimport { useSize } from \"@radix-ui/react-use-size\";\nimport { jsx } from \"react/jsx-runtime\";\nvar SIDE_OPTIONS = [\"top\", \"right\", \"bottom\", \"left\"];\nvar ALIGN_OPTIONS = [\"start\", \"center\", \"end\"];\nvar POPPER_NAME = \"Popper\";\nvar [createPopperContext, createPopperScope] = createContextScope(POPPER_NAME);\nvar [PopperProvider, usePopperContext] = createPopperContext(POPPER_NAME);\nvar Popper = (props) => {\n  const { __scopePopper, children } = props;\n  const [anchor, setAnchor] = React.useState(null);\n  return /* @__PURE__ */ jsx(PopperProvider, { scope: __scopePopper, anchor, onAnchorChange: setAnchor, children });\n};\nPopper.displayName = POPPER_NAME;\nvar ANCHOR_NAME = \"PopperAnchor\";\nvar PopperAnchor = React.forwardRef(\n  (props, forwardedRef) => {\n    const { __scopePopper, virtualRef, ...anchorProps } = props;\n    const context = usePopperContext(ANCHOR_NAME, __scopePopper);\n    const ref = React.useRef(null);\n    const composedRefs = useComposedRefs(forwardedRef, ref);\n    React.useEffect(() => {\n      context.onAnchorChange(virtualRef?.current || ref.current);\n    });\n    return virtualRef ? null : /* @__PURE__ */ jsx(Primitive.div, { ...anchorProps, ref: composedRefs });\n  }\n);\nPopperAnchor.displayName = ANCHOR_NAME;\nvar CONTENT_NAME = \"PopperContent\";\nvar [PopperContentProvider, useContentContext] = createPopperContext(CONTENT_NAME);\nvar PopperContent = React.forwardRef(\n  (props, forwardedRef) => {\n    const {\n      __scopePopper,\n      side = \"bottom\",\n      sideOffset = 0,\n      align = \"center\",\n      alignOffset = 0,\n      arrowPadding = 0,\n      avoidCollisions = true,\n      collisionBoundary = [],\n      collisionPadding: collisionPaddingProp = 0,\n      sticky = \"partial\",\n      hideWhenDetached = false,\n      updatePositionStrategy = \"optimized\",\n      onPlaced,\n      ...contentProps\n    } = props;\n    const context = usePopperContext(CONTENT_NAME, __scopePopper);\n    const [content, setContent] = React.useState(null);\n    const composedRefs = useComposedRefs(forwardedRef, (node) => setContent(node));\n    const [arrow, setArrow] = React.useState(null);\n    const arrowSize = useSize(arrow);\n    const arrowWidth = arrowSize?.width ?? 0;\n    const arrowHeight = arrowSize?.height ?? 0;\n    const desiredPlacement = side + (align !== \"center\" ? \"-\" + align : \"\");\n    const collisionPadding = typeof collisionPaddingProp === \"number\" ? collisionPaddingProp : { top: 0, right: 0, bottom: 0, left: 0, ...collisionPaddingProp };\n    const boundary = Array.isArray(collisionBoundary) ? collisionBoundary : [collisionBoundary];\n    const hasExplicitBoundaries = boundary.length > 0;\n    const detectOverflowOptions = {\n      padding: collisionPadding,\n      boundary: boundary.filter(isNotNull),\n      // with `strategy: 'fixed'`, this is the only way to get it to respect boundaries\n      altBoundary: hasExplicitBoundaries\n    };\n    const { refs, floatingStyles, placement, isPositioned, middlewareData } = useFloating({\n      // default to `fixed` strategy so users don't have to pick and we also avoid focus scroll issues\n      strategy: \"fixed\",\n      placement: desiredPlacement,\n      whileElementsMounted: (...args) => {\n        const cleanup = autoUpdate(...args, {\n          animationFrame: updatePositionStrategy === \"always\"\n        });\n        return cleanup;\n      },\n      elements: {\n        reference: context.anchor\n      },\n      middleware: [\n        offset({ mainAxis: sideOffset + arrowHeight, alignmentAxis: alignOffset }),\n        avoidCollisions && shift({\n          mainAxis: true,\n          crossAxis: false,\n          limiter: sticky === \"partial\" ? limitShift() : void 0,\n          ...detectOverflowOptions\n        }),\n        avoidCollisions && flip({ ...detectOverflowOptions }),\n        size({\n          ...detectOverflowOptions,\n          apply: ({ elements, rects, availableWidth, availableHeight }) => {\n            const { width: anchorWidth, height: anchorHeight } = rects.reference;\n            const contentStyle = elements.floating.style;\n            contentStyle.setProperty(\"--radix-popper-available-width\", `${availableWidth}px`);\n            contentStyle.setProperty(\"--radix-popper-available-height\", `${availableHeight}px`);\n            contentStyle.setProperty(\"--radix-popper-anchor-width\", `${anchorWidth}px`);\n            contentStyle.setProperty(\"--radix-popper-anchor-height\", `${anchorHeight}px`);\n          }\n        }),\n        arrow && floatingUIarrow({ element: arrow, padding: arrowPadding }),\n        transformOrigin({ arrowWidth, arrowHeight }),\n        hideWhenDetached && hide({ strategy: \"referenceHidden\", ...detectOverflowOptions })\n      ]\n    });\n    const [placedSide, placedAlign] = getSideAndAlignFromPlacement(placement);\n    const handlePlaced = useCallbackRef(onPlaced);\n    useLayoutEffect(() => {\n      if (isPositioned) {\n        handlePlaced?.();\n      }\n    }, [isPositioned, handlePlaced]);\n    const arrowX = middlewareData.arrow?.x;\n    const arrowY = middlewareData.arrow?.y;\n    const cannotCenterArrow = middlewareData.arrow?.centerOffset !== 0;\n    const [contentZIndex, setContentZIndex] = React.useState();\n    useLayoutEffect(() => {\n      if (content) setContentZIndex(window.getComputedStyle(content).zIndex);\n    }, [content]);\n    return /* @__PURE__ */ jsx(\n      \"div\",\n      {\n        ref: refs.setFloating,\n        \"data-radix-popper-content-wrapper\": \"\",\n        style: {\n          ...floatingStyles,\n          transform: isPositioned ? floatingStyles.transform : \"translate(0, -200%)\",\n          // keep off the page when measuring\n          minWidth: \"max-content\",\n          zIndex: contentZIndex,\n          [\"--radix-popper-transform-origin\"]: [\n            middlewareData.transformOrigin?.x,\n            middlewareData.transformOrigin?.y\n          ].join(\" \"),\n          // hide the content if using the hide middleware and should be hidden\n          // set visibility to hidden and disable pointer events so the UI behaves\n          // as if the PopperContent isn't there at all\n          ...middlewareData.hide?.referenceHidden && {\n            visibility: \"hidden\",\n            pointerEvents: \"none\"\n          }\n        },\n        dir: props.dir,\n        children: /* @__PURE__ */ jsx(\n          PopperContentProvider,\n          {\n            scope: __scopePopper,\n            placedSide,\n            onArrowChange: setArrow,\n            arrowX,\n            arrowY,\n            shouldHideArrow: cannotCenterArrow,\n            children: /* @__PURE__ */ jsx(\n              Primitive.div,\n              {\n                \"data-side\": placedSide,\n                \"data-align\": placedAlign,\n                ...contentProps,\n                ref: composedRefs,\n                style: {\n                  ...contentProps.style,\n                  // if the PopperContent hasn't been placed yet (not all measurements done)\n                  // we prevent animations so that users's animation don't kick in too early referring wrong sides\n                  animation: !isPositioned ? \"none\" : void 0\n                }\n              }\n            )\n          }\n        )\n      }\n    );\n  }\n);\nPopperContent.displayName = CONTENT_NAME;\nvar ARROW_NAME = \"PopperArrow\";\nvar OPPOSITE_SIDE = {\n  top: \"bottom\",\n  right: \"left\",\n  bottom: \"top\",\n  left: \"right\"\n};\nvar PopperArrow = React.forwardRef(function PopperArrow2(props, forwardedRef) {\n  const { __scopePopper, ...arrowProps } = props;\n  const contentContext = useContentContext(ARROW_NAME, __scopePopper);\n  const baseSide = OPPOSITE_SIDE[contentContext.placedSide];\n  return (\n    // we have to use an extra wrapper because `ResizeObserver` (used by `useSize`)\n    // doesn't report size as we'd expect on SVG elements.\n    // it reports their bounding box which is effectively the largest path inside the SVG.\n    /* @__PURE__ */ jsx(\n      \"span\",\n      {\n        ref: contentContext.onArrowChange,\n        style: {\n          position: \"absolute\",\n          left: contentContext.arrowX,\n          top: contentContext.arrowY,\n          [baseSide]: 0,\n          transformOrigin: {\n            top: \"\",\n            right: \"0 0\",\n            bottom: \"center 0\",\n            left: \"100% 0\"\n          }[contentContext.placedSide],\n          transform: {\n            top: \"translateY(100%)\",\n            right: \"translateY(50%) rotate(90deg) translateX(-50%)\",\n            bottom: `rotate(180deg)`,\n            left: \"translateY(50%) rotate(-90deg) translateX(50%)\"\n          }[contentContext.placedSide],\n          visibility: contentContext.shouldHideArrow ? \"hidden\" : void 0\n        },\n        children: /* @__PURE__ */ jsx(\n          ArrowPrimitive.Root,\n          {\n            ...arrowProps,\n            ref: forwardedRef,\n            style: {\n              ...arrowProps.style,\n              // ensures the element can be measured correctly (mostly for if SVG)\n              display: \"block\"\n            }\n          }\n        )\n      }\n    )\n  );\n});\nPopperArrow.displayName = ARROW_NAME;\nfunction isNotNull(value) {\n  return value !== null;\n}\nvar transformOrigin = (options) => ({\n  name: \"transformOrigin\",\n  options,\n  fn(data) {\n    const { placement, rects, middlewareData } = data;\n    const cannotCenterArrow = middlewareData.arrow?.centerOffset !== 0;\n    const isArrowHidden = cannotCenterArrow;\n    const arrowWidth = isArrowHidden ? 0 : options.arrowWidth;\n    const arrowHeight = isArrowHidden ? 0 : options.arrowHeight;\n    const [placedSide, placedAlign] = getSideAndAlignFromPlacement(placement);\n    const noArrowAlign = { start: \"0%\", center: \"50%\", end: \"100%\" }[placedAlign];\n    const arrowXCenter = (middlewareData.arrow?.x ?? 0) + arrowWidth / 2;\n    const arrowYCenter = (middlewareData.arrow?.y ?? 0) + arrowHeight / 2;\n    let x = \"\";\n    let y = \"\";\n    if (placedSide === \"bottom\") {\n      x = isArrowHidden ? noArrowAlign : `${arrowXCenter}px`;\n      y = `${-arrowHeight}px`;\n    } else if (placedSide === \"top\") {\n      x = isArrowHidden ? noArrowAlign : `${arrowXCenter}px`;\n      y = `${rects.floating.height + arrowHeight}px`;\n    } else if (placedSide === \"right\") {\n      x = `${-arrowHeight}px`;\n      y = isArrowHidden ? noArrowAlign : `${arrowYCenter}px`;\n    } else if (placedSide === \"left\") {\n      x = `${rects.floating.width + arrowHeight}px`;\n      y = isArrowHidden ? noArrowAlign : `${arrowYCenter}px`;\n    }\n    return { data: { x, y } };\n  }\n});\nfunction getSideAndAlignFromPlacement(placement) {\n  const [side, align = \"center\"] = placement.split(\"-\");\n  return [side, align];\n}\nvar Root2 = Popper;\nvar Anchor = PopperAnchor;\nvar Content = PopperContent;\nvar Arrow = PopperArrow;\nexport {\n  ALIGN_OPTIONS,\n  Anchor,\n  Arrow,\n  Content,\n  Popper,\n  PopperAnchor,\n  PopperArrow,\n  PopperContent,\n  Root2 as Root,\n  SIDE_OPTIONS,\n  createPopperScope\n};\n//# sourceMappingURL=index.mjs.map\n","// packages/react/use-size/src/useSize.tsx\nimport * as React from \"react\";\nimport { useLayoutEffect } from \"@radix-ui/react-use-layout-effect\";\nfunction useSize(element) {\n  const [size, setSize] = React.useState(void 0);\n  useLayoutEffect(() => {\n    if (element) {\n      setSize({ width: element.offsetWidth, height: element.offsetHeight });\n      const resizeObserver = new ResizeObserver((entries) => {\n        if (!Array.isArray(entries)) {\n          return;\n        }\n        if (!entries.length) {\n          return;\n        }\n        const entry = entries[0];\n        let width;\n        let height;\n        if (\"borderBoxSize\" in entry) {\n          const borderSizeEntry = entry[\"borderBoxSize\"];\n          const borderSize = Array.isArray(borderSizeEntry) ? borderSizeEntry[0] : borderSizeEntry;\n          width = borderSize[\"inlineSize\"];\n          height = borderSize[\"blockSize\"];\n        } else {\n          width = element.offsetWidth;\n          height = element.offsetHeight;\n        }\n        setSize({ width, height });\n      });\n      resizeObserver.observe(element, { box: \"border-box\" });\n      return () => resizeObserver.unobserve(element);\n    } else {\n      setSize(void 0);\n    }\n  }, [element]);\n  return size;\n}\nexport {\n  useSize\n};\n//# sourceMappingURL=index.mjs.map\n","\"use client\";\n\n// packages/react/portal/src/Portal.tsx\nimport * as React from \"react\";\nimport ReactDOM from \"react-dom\";\nimport { Primitive } from \"@radix-ui/react-primitive\";\nimport { useLayoutEffect } from \"@radix-ui/react-use-layout-effect\";\nimport { jsx } from \"react/jsx-runtime\";\nvar PORTAL_NAME = \"Portal\";\nvar Portal = React.forwardRef((props, forwardedRef) => {\n  const { container: containerProp, ...portalProps } = props;\n  const [mounted, setMounted] = React.useState(false);\n  useLayoutEffect(() => setMounted(true), []);\n  const container = containerProp || mounted && globalThis?.document?.body;\n  return container ? ReactDOM.createPortal(/* @__PURE__ */ jsx(Primitive.div, { ...portalProps, ref: forwardedRef }), container) : null;\n});\nPortal.displayName = PORTAL_NAME;\nvar Root = Portal;\nexport {\n  Portal,\n  Root\n};\n//# sourceMappingURL=index.mjs.map\n","\"use client\";\n\n// packages/react/presence/src/Presence.tsx\nimport * as React2 from \"react\";\nimport { useComposedRefs } from \"@radix-ui/react-compose-refs\";\nimport { useLayoutEffect } from \"@radix-ui/react-use-layout-effect\";\n\n// packages/react/presence/src/useStateMachine.tsx\nimport * as React from \"react\";\nfunction useStateMachine(initialState, machine) {\n  return React.useReducer((state, event) => {\n    const nextState = machine[state][event];\n    return nextState ?? state;\n  }, initialState);\n}\n\n// packages/react/presence/src/Presence.tsx\nvar Presence = (props) => {\n  const { present, children } = props;\n  const presence = usePresence(present);\n  const child = typeof children === \"function\" ? children({ present: presence.isPresent }) : React2.Children.only(children);\n  const ref = useComposedRefs(presence.ref, getElementRef(child));\n  const forceMount = typeof children === \"function\";\n  return forceMount || presence.isPresent ? React2.cloneElement(child, { ref }) : null;\n};\nPresence.displayName = \"Presence\";\nfunction usePresence(present) {\n  const [node, setNode] = React2.useState();\n  const stylesRef = React2.useRef({});\n  const prevPresentRef = React2.useRef(present);\n  const prevAnimationNameRef = React2.useRef(\"none\");\n  const initialState = present ? \"mounted\" : \"unmounted\";\n  const [state, send] = useStateMachine(initialState, {\n    mounted: {\n      UNMOUNT: \"unmounted\",\n      ANIMATION_OUT: \"unmountSuspended\"\n    },\n    unmountSuspended: {\n      MOUNT: \"mounted\",\n      ANIMATION_END: \"unmounted\"\n    },\n    unmounted: {\n      MOUNT: \"mounted\"\n    }\n  });\n  React2.useEffect(() => {\n    const currentAnimationName = getAnimationName(stylesRef.current);\n    prevAnimationNameRef.current = state === \"mounted\" ? currentAnimationName : \"none\";\n  }, [state]);\n  useLayoutEffect(() => {\n    const styles = stylesRef.current;\n    const wasPresent = prevPresentRef.current;\n    const hasPresentChanged = wasPresent !== present;\n    if (hasPresentChanged) {\n      const prevAnimationName = prevAnimationNameRef.current;\n      const currentAnimationName = getAnimationName(styles);\n      if (present) {\n        send(\"MOUNT\");\n      } else if (currentAnimationName === \"none\" || styles?.display === \"none\") {\n        send(\"UNMOUNT\");\n      } else {\n        const isAnimating = prevAnimationName !== currentAnimationName;\n        if (wasPresent && isAnimating) {\n          send(\"ANIMATION_OUT\");\n        } else {\n          send(\"UNMOUNT\");\n        }\n      }\n      prevPresentRef.current = present;\n    }\n  }, [present, send]);\n  useLayoutEffect(() => {\n    if (node) {\n      let timeoutId;\n      const ownerWindow = node.ownerDocument.defaultView ?? window;\n      const handleAnimationEnd = (event) => {\n        const currentAnimationName = getAnimationName(stylesRef.current);\n        const isCurrentAnimation = currentAnimationName.includes(event.animationName);\n        if (event.target === node && isCurrentAnimation) {\n          send(\"ANIMATION_END\");\n          if (!prevPresentRef.current) {\n            const currentFillMode = node.style.animationFillMode;\n            node.style.animationFillMode = \"forwards\";\n            timeoutId = ownerWindow.setTimeout(() => {\n              if (node.style.animationFillMode === \"forwards\") {\n                node.style.animationFillMode = currentFillMode;\n              }\n            });\n          }\n        }\n      };\n      const handleAnimationStart = (event) => {\n        if (event.target === node) {\n          prevAnimationNameRef.current = getAnimationName(stylesRef.current);\n        }\n      };\n      node.addEventListener(\"animationstart\", handleAnimationStart);\n      node.addEventListener(\"animationcancel\", handleAnimationEnd);\n      node.addEventListener(\"animationend\", handleAnimationEnd);\n      return () => {\n        ownerWindow.clearTimeout(timeoutId);\n        node.removeEventListener(\"animationstart\", handleAnimationStart);\n        node.removeEventListener(\"animationcancel\", handleAnimationEnd);\n        node.removeEventListener(\"animationend\", handleAnimationEnd);\n      };\n    } else {\n      send(\"ANIMATION_END\");\n    }\n  }, [node, send]);\n  return {\n    isPresent: [\"mounted\", \"unmountSuspended\"].includes(state),\n    ref: React2.useCallback((node2) => {\n      if (node2) stylesRef.current = getComputedStyle(node2);\n      setNode(node2);\n    }, [])\n  };\n}\nfunction getAnimationName(styles) {\n  return styles?.animationName || \"none\";\n}\nfunction getElementRef(element) {\n  let getter = Object.getOwnPropertyDescriptor(element.props, \"ref\")?.get;\n  let mayWarn = getter && \"isReactWarning\" in getter && getter.isReactWarning;\n  if (mayWarn) {\n    return element.ref;\n  }\n  getter = Object.getOwnPropertyDescriptor(element, \"ref\")?.get;\n  mayWarn = getter && \"isReactWarning\" in getter && getter.isReactWarning;\n  if (mayWarn) {\n    return element.props.ref;\n  }\n  return element.props.ref || element.ref;\n}\nexport {\n  Presence\n};\n//# sourceMappingURL=index.mjs.map\n","\"use client\";\n\n// packages/react/roving-focus/src/RovingFocusGroup.tsx\nimport * as React from \"react\";\nimport { composeEventHandlers } from \"@radix-ui/primitive\";\nimport { createCollection } from \"@radix-ui/react-collection\";\nimport { useComposedRefs } from \"@radix-ui/react-compose-refs\";\nimport { createContextScope } from \"@radix-ui/react-context\";\nimport { useId } from \"@radix-ui/react-id\";\nimport { Primitive } from \"@radix-ui/react-primitive\";\nimport { useCallbackRef } from \"@radix-ui/react-use-callback-ref\";\nimport { useControllableState } from \"@radix-ui/react-use-controllable-state\";\nimport { useDirection } from \"@radix-ui/react-direction\";\nimport { jsx } from \"react/jsx-runtime\";\nvar ENTRY_FOCUS = \"rovingFocusGroup.onEntryFocus\";\nvar EVENT_OPTIONS = { bubbles: false, cancelable: true };\nvar GROUP_NAME = \"RovingFocusGroup\";\nvar [Collection, useCollection, createCollectionScope] = createCollection(GROUP_NAME);\nvar [createRovingFocusGroupContext, createRovingFocusGroupScope] = createContextScope(\n  GROUP_NAME,\n  [createCollectionScope]\n);\nvar [RovingFocusProvider, useRovingFocusContext] = createRovingFocusGroupContext(GROUP_NAME);\nvar RovingFocusGroup = React.forwardRef(\n  (props, forwardedRef) => {\n    return /* @__PURE__ */ jsx(Collection.Provider, { scope: props.__scopeRovingFocusGroup, children: /* @__PURE__ */ jsx(Collection.Slot, { scope: props.__scopeRovingFocusGroup, children: /* @__PURE__ */ jsx(RovingFocusGroupImpl, { ...props, ref: forwardedRef }) }) });\n  }\n);\nRovingFocusGroup.displayName = GROUP_NAME;\nvar RovingFocusGroupImpl = React.forwardRef((props, forwardedRef) => {\n  const {\n    __scopeRovingFocusGroup,\n    orientation,\n    loop = false,\n    dir,\n    currentTabStopId: currentTabStopIdProp,\n    defaultCurrentTabStopId,\n    onCurrentTabStopIdChange,\n    onEntryFocus,\n    preventScrollOnEntryFocus = false,\n    ...groupProps\n  } = props;\n  const ref = React.useRef(null);\n  const composedRefs = useComposedRefs(forwardedRef, ref);\n  const direction = useDirection(dir);\n  const [currentTabStopId = null, setCurrentTabStopId] = useControllableState({\n    prop: currentTabStopIdProp,\n    defaultProp: defaultCurrentTabStopId,\n    onChange: onCurrentTabStopIdChange\n  });\n  const [isTabbingBackOut, setIsTabbingBackOut] = React.useState(false);\n  const handleEntryFocus = useCallbackRef(onEntryFocus);\n  const getItems = useCollection(__scopeRovingFocusGroup);\n  const isClickFocusRef = React.useRef(false);\n  const [focusableItemsCount, setFocusableItemsCount] = React.useState(0);\n  React.useEffect(() => {\n    const node = ref.current;\n    if (node) {\n      node.addEventListener(ENTRY_FOCUS, handleEntryFocus);\n      return () => node.removeEventListener(ENTRY_FOCUS, handleEntryFocus);\n    }\n  }, [handleEntryFocus]);\n  return /* @__PURE__ */ jsx(\n    RovingFocusProvider,\n    {\n      scope: __scopeRovingFocusGroup,\n      orientation,\n      dir: direction,\n      loop,\n      currentTabStopId,\n      onItemFocus: React.useCallback(\n        (tabStopId) => setCurrentTabStopId(tabStopId),\n        [setCurrentTabStopId]\n      ),\n      onItemShiftTab: React.useCallback(() => setIsTabbingBackOut(true), []),\n      onFocusableItemAdd: React.useCallback(\n        () => setFocusableItemsCount((prevCount) => prevCount + 1),\n        []\n      ),\n      onFocusableItemRemove: React.useCallback(\n        () => setFocusableItemsCount((prevCount) => prevCount - 1),\n        []\n      ),\n      children: /* @__PURE__ */ jsx(\n        Primitive.div,\n        {\n          tabIndex: isTabbingBackOut || focusableItemsCount === 0 ? -1 : 0,\n          \"data-orientation\": orientation,\n          ...groupProps,\n          ref: composedRefs,\n          style: { outline: \"none\", ...props.style },\n          onMouseDown: composeEventHandlers(props.onMouseDown, () => {\n            isClickFocusRef.current = true;\n          }),\n          onFocus: composeEventHandlers(props.onFocus, (event) => {\n            const isKeyboardFocus = !isClickFocusRef.current;\n            if (event.target === event.currentTarget && isKeyboardFocus && !isTabbingBackOut) {\n              const entryFocusEvent = new CustomEvent(ENTRY_FOCUS, EVENT_OPTIONS);\n              event.currentTarget.dispatchEvent(entryFocusEvent);\n              if (!entryFocusEvent.defaultPrevented) {\n                const items = getItems().filter((item) => item.focusable);\n                const activeItem = items.find((item) => item.active);\n                const currentItem = items.find((item) => item.id === currentTabStopId);\n                const candidateItems = [activeItem, currentItem, ...items].filter(\n                  Boolean\n                );\n                const candidateNodes = candidateItems.map((item) => item.ref.current);\n                focusFirst(candidateNodes, preventScrollOnEntryFocus);\n              }\n            }\n            isClickFocusRef.current = false;\n          }),\n          onBlur: composeEventHandlers(props.onBlur, () => setIsTabbingBackOut(false))\n        }\n      )\n    }\n  );\n});\nvar ITEM_NAME = \"RovingFocusGroupItem\";\nvar RovingFocusGroupItem = React.forwardRef(\n  (props, forwardedRef) => {\n    const {\n      __scopeRovingFocusGroup,\n      focusable = true,\n      active = false,\n      tabStopId,\n      ...itemProps\n    } = props;\n    const autoId = useId();\n    const id = tabStopId || autoId;\n    const context = useRovingFocusContext(ITEM_NAME, __scopeRovingFocusGroup);\n    const isCurrentTabStop = context.currentTabStopId === id;\n    const getItems = useCollection(__scopeRovingFocusGroup);\n    const { onFocusableItemAdd, onFocusableItemRemove } = context;\n    React.useEffect(() => {\n      if (focusable) {\n        onFocusableItemAdd();\n        return () => onFocusableItemRemove();\n      }\n    }, [focusable, onFocusableItemAdd, onFocusableItemRemove]);\n    return /* @__PURE__ */ jsx(\n      Collection.ItemSlot,\n      {\n        scope: __scopeRovingFocusGroup,\n        id,\n        focusable,\n        active,\n        children: /* @__PURE__ */ jsx(\n          Primitive.span,\n          {\n            tabIndex: isCurrentTabStop ? 0 : -1,\n            \"data-orientation\": context.orientation,\n            ...itemProps,\n            ref: forwardedRef,\n            onMouseDown: composeEventHandlers(props.onMouseDown, (event) => {\n              if (!focusable) event.preventDefault();\n              else context.onItemFocus(id);\n            }),\n            onFocus: composeEventHandlers(props.onFocus, () => context.onItemFocus(id)),\n            onKeyDown: composeEventHandlers(props.onKeyDown, (event) => {\n              if (event.key === \"Tab\" && event.shiftKey) {\n                context.onItemShiftTab();\n                return;\n              }\n              if (event.target !== event.currentTarget) return;\n              const focusIntent = getFocusIntent(event, context.orientation, context.dir);\n              if (focusIntent !== void 0) {\n                if (event.metaKey || event.ctrlKey || event.altKey || event.shiftKey) return;\n                event.preventDefault();\n                const items = getItems().filter((item) => item.focusable);\n                let candidateNodes = items.map((item) => item.ref.current);\n                if (focusIntent === \"last\") candidateNodes.reverse();\n                else if (focusIntent === \"prev\" || focusIntent === \"next\") {\n                  if (focusIntent === \"prev\") candidateNodes.reverse();\n                  const currentIndex = candidateNodes.indexOf(event.currentTarget);\n                  candidateNodes = context.loop ? wrapArray(candidateNodes, currentIndex + 1) : candidateNodes.slice(currentIndex + 1);\n                }\n                setTimeout(() => focusFirst(candidateNodes));\n              }\n            })\n          }\n        )\n      }\n    );\n  }\n);\nRovingFocusGroupItem.displayName = ITEM_NAME;\nvar MAP_KEY_TO_FOCUS_INTENT = {\n  ArrowLeft: \"prev\",\n  ArrowUp: \"prev\",\n  ArrowRight: \"next\",\n  ArrowDown: \"next\",\n  PageUp: \"first\",\n  Home: \"first\",\n  PageDown: \"last\",\n  End: \"last\"\n};\nfunction getDirectionAwareKey(key, dir) {\n  if (dir !== \"rtl\") return key;\n  return key === \"ArrowLeft\" ? \"ArrowRight\" : key === \"ArrowRight\" ? \"ArrowLeft\" : key;\n}\nfunction getFocusIntent(event, orientation, dir) {\n  const key = getDirectionAwareKey(event.key, dir);\n  if (orientation === \"vertical\" && [\"ArrowLeft\", \"ArrowRight\"].includes(key)) return void 0;\n  if (orientation === \"horizontal\" && [\"ArrowUp\", \"ArrowDown\"].includes(key)) return void 0;\n  return MAP_KEY_TO_FOCUS_INTENT[key];\n}\nfunction focusFirst(candidates, preventScroll = false) {\n  const PREVIOUSLY_FOCUSED_ELEMENT = document.activeElement;\n  for (const candidate of candidates) {\n    if (candidate === PREVIOUSLY_FOCUSED_ELEMENT) return;\n    candidate.focus({ preventScroll });\n    if (document.activeElement !== PREVIOUSLY_FOCUSED_ELEMENT) return;\n  }\n}\nfunction wrapArray(array, startIndex) {\n  return array.map((_, index) => array[(startIndex + index) % array.length]);\n}\nvar Root = RovingFocusGroup;\nvar Item = RovingFocusGroupItem;\nexport {\n  Item,\n  Root,\n  RovingFocusGroup,\n  RovingFocusGroupItem,\n  createRovingFocusGroupScope\n};\n//# sourceMappingURL=index.mjs.map\n","var getDefaultParent = function (originalTarget) {\n    if (typeof document === 'undefined') {\n        return null;\n    }\n    var sampleTarget = Array.isArray(originalTarget) ? originalTarget[0] : originalTarget;\n    return sampleTarget.ownerDocument.body;\n};\nvar counterMap = new WeakMap();\nvar uncontrolledNodes = new WeakMap();\nvar markerMap = {};\nvar lockCount = 0;\nvar unwrapHost = function (node) {\n    return node && (node.host || unwrapHost(node.parentNode));\n};\nvar correctTargets = function (parent, targets) {\n    return targets\n        .map(function (target) {\n        if (parent.contains(target)) {\n            return target;\n        }\n        var correctedTarget = unwrapHost(target);\n        if (correctedTarget && parent.contains(correctedTarget)) {\n            return correctedTarget;\n        }\n        console.error('aria-hidden', target, 'in not contained inside', parent, '. Doing nothing');\n        return null;\n    })\n        .filter(function (x) { return Boolean(x); });\n};\n/**\n * Marks everything except given node(or nodes) as aria-hidden\n * @param {Element | Element[]} originalTarget - elements to keep on the page\n * @param [parentNode] - top element, defaults to document.body\n * @param {String} [markerName] - a special attribute to mark every node\n * @param {String} [controlAttribute] - html Attribute to control\n * @return {Undo} undo command\n */\nvar applyAttributeToOthers = function (originalTarget, parentNode, markerName, controlAttribute) {\n    var targets = correctTargets(parentNode, Array.isArray(originalTarget) ? originalTarget : [originalTarget]);\n    if (!markerMap[markerName]) {\n        markerMap[markerName] = new WeakMap();\n    }\n    var markerCounter = markerMap[markerName];\n    var hiddenNodes = [];\n    var elementsToKeep = new Set();\n    var elementsToStop = new Set(targets);\n    var keep = function (el) {\n        if (!el || elementsToKeep.has(el)) {\n            return;\n        }\n        elementsToKeep.add(el);\n        keep(el.parentNode);\n    };\n    targets.forEach(keep);\n    var deep = function (parent) {\n        if (!parent || elementsToStop.has(parent)) {\n            return;\n        }\n        Array.prototype.forEach.call(parent.children, function (node) {\n            if (elementsToKeep.has(node)) {\n                deep(node);\n            }\n            else {\n                try {\n                    var attr = node.getAttribute(controlAttribute);\n                    var alreadyHidden = attr !== null && attr !== 'false';\n                    var counterValue = (counterMap.get(node) || 0) + 1;\n                    var markerValue = (markerCounter.get(node) || 0) + 1;\n                    counterMap.set(node, counterValue);\n                    markerCounter.set(node, markerValue);\n                    hiddenNodes.push(node);\n                    if (counterValue === 1 && alreadyHidden) {\n                        uncontrolledNodes.set(node, true);\n                    }\n                    if (markerValue === 1) {\n                        node.setAttribute(markerName, 'true');\n                    }\n                    if (!alreadyHidden) {\n                        node.setAttribute(controlAttribute, 'true');\n                    }\n                }\n                catch (e) {\n                    console.error('aria-hidden: cannot operate on ', node, e);\n                }\n            }\n        });\n    };\n    deep(parentNode);\n    elementsToKeep.clear();\n    lockCount++;\n    return function () {\n        hiddenNodes.forEach(function (node) {\n            var counterValue = counterMap.get(node) - 1;\n            var markerValue = markerCounter.get(node) - 1;\n            counterMap.set(node, counterValue);\n            markerCounter.set(node, markerValue);\n            if (!counterValue) {\n                if (!uncontrolledNodes.has(node)) {\n                    node.removeAttribute(controlAttribute);\n                }\n                uncontrolledNodes.delete(node);\n            }\n            if (!markerValue) {\n                node.removeAttribute(markerName);\n            }\n        });\n        lockCount--;\n        if (!lockCount) {\n            // clear\n            counterMap = new WeakMap();\n            counterMap = new WeakMap();\n            uncontrolledNodes = new WeakMap();\n            markerMap = {};\n        }\n    };\n};\n/**\n * Marks everything except given node(or nodes) as aria-hidden\n * @param {Element | Element[]} originalTarget - elements to keep on the page\n * @param [parentNode] - top element, defaults to document.body\n * @param {String} [markerName] - a special attribute to mark every node\n * @return {Undo} undo command\n */\nexport var hideOthers = function (originalTarget, parentNode, markerName) {\n    if (markerName === void 0) { markerName = 'data-aria-hidden'; }\n    var targets = Array.from(Array.isArray(originalTarget) ? originalTarget : [originalTarget]);\n    var activeParentNode = parentNode || getDefaultParent(originalTarget);\n    if (!activeParentNode) {\n        return function () { return null; };\n    }\n    // we should not hide ariaLive elements - https://github.com/theKashey/aria-hidden/issues/10\n    targets.push.apply(targets, Array.from(activeParentNode.querySelectorAll('[aria-live]')));\n    return applyAttributeToOthers(targets, activeParentNode, markerName, 'aria-hidden');\n};\n/**\n * Marks everything except given node(or nodes) as inert\n * @param {Element | Element[]} originalTarget - elements to keep on the page\n * @param [parentNode] - top element, defaults to document.body\n * @param {String} [markerName] - a special attribute to mark every node\n * @return {Undo} undo command\n */\nexport var inertOthers = function (originalTarget, parentNode, markerName) {\n    if (markerName === void 0) { markerName = 'data-inert-ed'; }\n    var activeParentNode = parentNode || getDefaultParent(originalTarget);\n    if (!activeParentNode) {\n        return function () { return null; };\n    }\n    return applyAttributeToOthers(originalTarget, activeParentNode, markerName, 'inert');\n};\n/**\n * @returns if current browser supports inert\n */\nexport var supportsInert = function () {\n    return typeof HTMLElement !== 'undefined' && HTMLElement.prototype.hasOwnProperty('inert');\n};\n/**\n * Automatic function to \"suppress\" DOM elements - _hide_ or _inert_ in the best possible way\n * @param {Element | Element[]} originalTarget - elements to keep on the page\n * @param [parentNode] - top element, defaults to document.body\n * @param {String} [markerName] - a special attribute to mark every node\n * @return {Undo} undo command\n */\nexport var suppressOthers = function (originalTarget, parentNode, markerName) {\n    if (markerName === void 0) { markerName = 'data-suppressed'; }\n    return (supportsInert() ? inertOthers : hideOthers)(originalTarget, parentNode, markerName);\n};\n","export var zeroRightClassName = 'right-scroll-bar-position';\nexport var fullWidthClassName = 'width-before-scroll-bar';\nexport var noScrollbarsClassName = 'with-scroll-bars-hidden';\n/**\n * Name of a CSS variable containing the amount of \"hidden\" scrollbar\n * ! might be undefined ! use will fallback!\n */\nexport var removedBarSizeVariable = '--removed-body-scroll-bar-size';\n","/**\n * Assigns a value for a given ref, no matter of the ref format\n * @param {RefObject} ref - a callback function or ref object\n * @param value - a new value\n *\n * @see https://github.com/theKashey/use-callback-ref#assignref\n * @example\n * const refObject = useRef();\n * const refFn = (ref) => {....}\n *\n * assignRef(refObject, \"refValue\");\n * assignRef(refFn, \"refValue\");\n */\nexport function assignRef(ref, value) {\n    if (typeof ref === 'function') {\n        ref(value);\n    }\n    else if (ref) {\n        ref.current = value;\n    }\n    return ref;\n}\n","import * as React from 'react';\nimport { assignRef } from './assignRef';\nimport { useCallbackRef } from './useRef';\nvar useIsomorphicLayoutEffect = typeof window !== 'undefined' ? React.useLayoutEffect : React.useEffect;\nvar currentValues = new WeakMap();\n/**\n * Merges two or more refs together providing a single interface to set their value\n * @param {RefObject|Ref} refs\n * @returns {MutableRefObject} - a new ref, which translates all changes to {refs}\n *\n * @see {@link mergeRefs} a version without buit-in memoization\n * @see https://github.com/theKashey/use-callback-ref#usemergerefs\n * @example\n * const Component = React.forwardRef((props, ref) => {\n *   const ownRef = useRef();\n *   const domRef = useMergeRefs([ref, ownRef]); // 👈 merge together\n *   return <div ref={domRef}>...</div>\n * }\n */\nexport function useMergeRefs(refs, defaultValue) {\n    var callbackRef = useCallbackRef(defaultValue || null, function (newValue) {\n        return refs.forEach(function (ref) { return assignRef(ref, newValue); });\n    });\n    // handle refs changes - added or removed\n    useIsomorphicLayoutEffect(function () {\n        var oldValue = currentValues.get(callbackRef);\n        if (oldValue) {\n            var prevRefs_1 = new Set(oldValue);\n            var nextRefs_1 = new Set(refs);\n            var current_1 = callbackRef.current;\n            prevRefs_1.forEach(function (ref) {\n                if (!nextRefs_1.has(ref)) {\n                    assignRef(ref, null);\n                }\n            });\n            nextRefs_1.forEach(function (ref) {\n                if (!prevRefs_1.has(ref)) {\n                    assignRef(ref, current_1);\n                }\n            });\n        }\n        currentValues.set(callbackRef, refs);\n    }, [refs]);\n    return callbackRef;\n}\n","import { useState } from 'react';\n/**\n * creates a MutableRef with ref change callback\n * @param initialValue - initial ref value\n * @param {Function} callback - a callback to run when value changes\n *\n * @example\n * const ref = useCallbackRef(0, (newValue, oldValue) => console.log(oldValue, '->', newValue);\n * ref.current = 1;\n * // prints 0 -> 1\n *\n * @see https://reactjs.org/docs/hooks-reference.html#useref\n * @see https://github.com/theKashey/use-callback-ref#usecallbackref---to-replace-reactuseref\n * @returns {MutableRefObject}\n */\nexport function useCallbackRef(initialValue, callback) {\n    var ref = useState(function () { return ({\n        // value\n        value: initialValue,\n        // last callback\n        callback: callback,\n        // \"memoized\" public interface\n        facade: {\n            get current() {\n                return ref.value;\n            },\n            set current(value) {\n                var last = ref.value;\n                if (last !== value) {\n                    ref.value = value;\n                    ref.callback(value, last);\n                }\n            },\n        },\n    }); })[0];\n    // update callback\n    ref.callback = callback;\n    return ref.facade;\n}\n","import { createSidecarMedium } from 'use-sidecar';\nexport var effectCar = createSidecarMedium();\n","import { __assign, __rest } from \"tslib\";\nimport * as React from 'react';\nimport { fullWidthClassName, zeroRightClassName } from 'react-remove-scroll-bar/constants';\nimport { useMergeRefs } from 'use-callback-ref';\nimport { effectCar } from './medium';\nvar nothing = function () {\n    return;\n};\n/**\n * Removes scrollbar from the page and contain the scroll within the Lock\n */\nvar RemoveScroll = React.forwardRef(function (props, parentRef) {\n    var ref = React.useRef(null);\n    var _a = React.useState({\n        onScrollCapture: nothing,\n        onWheelCapture: nothing,\n        onTouchMoveCapture: nothing,\n    }), callbacks = _a[0], setCallbacks = _a[1];\n    var forwardProps = props.forwardProps, children = props.children, className = props.className, removeScrollBar = props.removeScrollBar, enabled = props.enabled, shards = props.shards, sideCar = props.sideCar, noIsolation = props.noIsolation, inert = props.inert, allowPinchZoom = props.allowPinchZoom, _b = props.as, Container = _b === void 0 ? 'div' : _b, gapMode = props.gapMode, rest = __rest(props, [\"forwardProps\", \"children\", \"className\", \"removeScrollBar\", \"enabled\", \"shards\", \"sideCar\", \"noIsolation\", \"inert\", \"allowPinchZoom\", \"as\", \"gapMode\"]);\n    var SideCar = sideCar;\n    var containerRef = useMergeRefs([ref, parentRef]);\n    var containerProps = __assign(__assign({}, rest), callbacks);\n    return (React.createElement(React.Fragment, null,\n        enabled && (React.createElement(SideCar, { sideCar: effectCar, removeScrollBar: removeScrollBar, shards: shards, noIsolation: noIsolation, inert: inert, setCallbacks: setCallbacks, allowPinchZoom: !!allowPinchZoom, lockRef: ref, gapMode: gapMode })),\n        forwardProps ? (React.cloneElement(React.Children.only(children), __assign(__assign({}, containerProps), { ref: containerRef }))) : (React.createElement(Container, __assign({}, containerProps, { className: className, ref: containerRef }), children))));\n});\nRemoveScroll.defaultProps = {\n    enabled: true,\n    removeScrollBar: true,\n    inert: false,\n};\nRemoveScroll.classNames = {\n    fullWidth: fullWidthClassName,\n    zeroRight: zeroRightClassName,\n};\nexport { RemoveScroll };\n","import { __assign, __rest } from \"tslib\";\nimport * as React from 'react';\nvar SideCar = function (_a) {\n    var sideCar = _a.sideCar, rest = __rest(_a, [\"sideCar\"]);\n    if (!sideCar) {\n        throw new Error('Sidecar: please provide `sideCar` property to import the right car');\n    }\n    var Target = sideCar.read();\n    if (!Target) {\n        throw new Error('Sidecar medium not found');\n    }\n    return React.createElement(Target, __assign({}, rest));\n};\nSideCar.isSideCarExport = true;\nexport function exportSidecar(medium, exported) {\n    medium.useMedium(exported);\n    return SideCar;\n}\n","var currentNonce;\nexport var setNonce = function (nonce) {\n    currentNonce = nonce;\n};\nexport var getNonce = function () {\n    if (currentNonce) {\n        return currentNonce;\n    }\n    if (typeof __webpack_nonce__ !== 'undefined') {\n        return __webpack_nonce__;\n    }\n    return undefined;\n};\n","import { getNonce } from 'get-nonce';\nfunction makeStyleTag() {\n    if (!document)\n        return null;\n    var tag = document.createElement('style');\n    tag.type = 'text/css';\n    var nonce = getNonce();\n    if (nonce) {\n        tag.setAttribute('nonce', nonce);\n    }\n    return tag;\n}\nfunction injectStyles(tag, css) {\n    // @ts-ignore\n    if (tag.styleSheet) {\n        // @ts-ignore\n        tag.styleSheet.cssText = css;\n    }\n    else {\n        tag.appendChild(document.createTextNode(css));\n    }\n}\nfunction insertStyleTag(tag) {\n    var head = document.head || document.getElementsByTagName('head')[0];\n    head.appendChild(tag);\n}\nexport var stylesheetSingleton = function () {\n    var counter = 0;\n    var stylesheet = null;\n    return {\n        add: function (style) {\n            if (counter == 0) {\n                if ((stylesheet = makeStyleTag())) {\n                    injectStyles(stylesheet, style);\n                    insertStyleTag(stylesheet);\n                }\n            }\n            counter++;\n        },\n        remove: function () {\n            counter--;\n            if (!counter && stylesheet) {\n                stylesheet.parentNode && stylesheet.parentNode.removeChild(stylesheet);\n                stylesheet = null;\n            }\n        },\n    };\n};\n","import { styleHookSingleton } from './hook';\n/**\n * create a Component to add styles on demand\n * - styles are added when first instance is mounted\n * - styles are removed when the last instance is unmounted\n * - changing styles in runtime does nothing unless dynamic is set. But with multiple components that can lead to the undefined behavior\n */\nexport var styleSingleton = function () {\n    var useStyle = styleHookSingleton();\n    var Sheet = function (_a) {\n        var styles = _a.styles, dynamic = _a.dynamic;\n        useStyle(styles, dynamic);\n        return null;\n    };\n    return Sheet;\n};\n","import * as React from 'react';\nimport { stylesheetSingleton } from './singleton';\n/**\n * creates a hook to control style singleton\n * @see {@link styleSingleton} for a safer component version\n * @example\n * ```tsx\n * const useStyle = styleHookSingleton();\n * ///\n * useStyle('body { overflow: hidden}');\n */\nexport var styleHookSingleton = function () {\n    var sheet = stylesheetSingleton();\n    return function (styles, isDynamic) {\n        React.useEffect(function () {\n            sheet.add(styles);\n            return function () {\n                sheet.remove();\n            };\n        }, [styles && isDynamic]);\n    };\n};\n","export var zeroGap = {\n    left: 0,\n    top: 0,\n    right: 0,\n    gap: 0,\n};\nvar parse = function (x) { return parseInt(x || '', 10) || 0; };\nvar getOffset = function (gapMode) {\n    var cs = window.getComputedStyle(document.body);\n    var left = cs[gapMode === 'padding' ? 'paddingLeft' : 'marginLeft'];\n    var top = cs[gapMode === 'padding' ? 'paddingTop' : 'marginTop'];\n    var right = cs[gapMode === 'padding' ? 'paddingRight' : 'marginRight'];\n    return [parse(left), parse(top), parse(right)];\n};\nexport var getGapWidth = function (gapMode) {\n    if (gapMode === void 0) { gapMode = 'margin'; }\n    if (typeof window === 'undefined') {\n        return zeroGap;\n    }\n    var offsets = getOffset(gapMode);\n    var documentWidth = document.documentElement.clientWidth;\n    var windowWidth = window.innerWidth;\n    return {\n        left: offsets[0],\n        top: offsets[1],\n        right: offsets[2],\n        gap: Math.max(0, windowWidth - documentWidth + offsets[2] - offsets[0]),\n    };\n};\n","import * as React from 'react';\nimport { styleSingleton } from 'react-style-singleton';\nimport { fullWidthClassName, zeroRightClassName, noScrollbarsClassName, removedBarSizeVariable } from './constants';\nimport { getGapWidth } from './utils';\nvar Style = styleSingleton();\nexport var lockAttribute = 'data-scroll-locked';\n// important tip - once we measure scrollBar width and remove them\n// we could not repeat this operation\n// thus we are using style-singleton - only the first \"yet correct\" style will be applied.\nvar getStyles = function (_a, allowRelative, gapMode, important) {\n    var left = _a.left, top = _a.top, right = _a.right, gap = _a.gap;\n    if (gapMode === void 0) { gapMode = 'margin'; }\n    return \"\\n  .\".concat(noScrollbarsClassName, \" {\\n   overflow: hidden \").concat(important, \";\\n   padding-right: \").concat(gap, \"px \").concat(important, \";\\n  }\\n  body[\").concat(lockAttribute, \"] {\\n    overflow: hidden \").concat(important, \";\\n    overscroll-behavior: contain;\\n    \").concat([\n        allowRelative && \"position: relative \".concat(important, \";\"),\n        gapMode === 'margin' &&\n            \"\\n    padding-left: \".concat(left, \"px;\\n    padding-top: \").concat(top, \"px;\\n    padding-right: \").concat(right, \"px;\\n    margin-left:0;\\n    margin-top:0;\\n    margin-right: \").concat(gap, \"px \").concat(important, \";\\n    \"),\n        gapMode === 'padding' && \"padding-right: \".concat(gap, \"px \").concat(important, \";\"),\n    ]\n        .filter(Boolean)\n        .join(''), \"\\n  }\\n  \\n  .\").concat(zeroRightClassName, \" {\\n    right: \").concat(gap, \"px \").concat(important, \";\\n  }\\n  \\n  .\").concat(fullWidthClassName, \" {\\n    margin-right: \").concat(gap, \"px \").concat(important, \";\\n  }\\n  \\n  .\").concat(zeroRightClassName, \" .\").concat(zeroRightClassName, \" {\\n    right: 0 \").concat(important, \";\\n  }\\n  \\n  .\").concat(fullWidthClassName, \" .\").concat(fullWidthClassName, \" {\\n    margin-right: 0 \").concat(important, \";\\n  }\\n  \\n  body[\").concat(lockAttribute, \"] {\\n    \").concat(removedBarSizeVariable, \": \").concat(gap, \"px;\\n  }\\n\");\n};\nvar getCurrentUseCounter = function () {\n    var counter = parseInt(document.body.getAttribute(lockAttribute) || '0', 10);\n    return isFinite(counter) ? counter : 0;\n};\nexport var useLockAttribute = function () {\n    React.useEffect(function () {\n        document.body.setAttribute(lockAttribute, (getCurrentUseCounter() + 1).toString());\n        return function () {\n            var newCounter = getCurrentUseCounter() - 1;\n            if (newCounter <= 0) {\n                document.body.removeAttribute(lockAttribute);\n            }\n            else {\n                document.body.setAttribute(lockAttribute, newCounter.toString());\n            }\n        };\n    }, []);\n};\n/**\n * Removes page scrollbar and blocks page scroll when mounted\n */\nexport var RemoveScrollBar = function (_a) {\n    var noRelative = _a.noRelative, noImportant = _a.noImportant, _b = _a.gapMode, gapMode = _b === void 0 ? 'margin' : _b;\n    useLockAttribute();\n    /*\n     gap will be measured on every component mount\n     however it will be used only by the \"first\" invocation\n     due to singleton nature of <Style\n     */\n    var gap = React.useMemo(function () { return getGapWidth(gapMode); }, [gapMode]);\n    return React.createElement(Style, { styles: getStyles(gap, !noRelative, gapMode, !noImportant ? '!important' : '') });\n};\n","var passiveSupported = false;\nif (typeof window !== 'undefined') {\n    try {\n        var options = Object.defineProperty({}, 'passive', {\n            get: function () {\n                passiveSupported = true;\n                return true;\n            },\n        });\n        // @ts-ignore\n        window.addEventListener('test', options, options);\n        // @ts-ignore\n        window.removeEventListener('test', options, options);\n    }\n    catch (err) {\n        passiveSupported = false;\n    }\n}\nexport var nonPassive = passiveSupported ? { passive: false } : false;\n","var alwaysContainsScroll = function (node) {\n    // textarea will always _contain_ scroll inside self. It only can be hidden\n    return node.tagName === 'TEXTAREA';\n};\nvar elementCanBeScrolled = function (node, overflow) {\n    if (!(node instanceof Element)) {\n        return false;\n    }\n    var styles = window.getComputedStyle(node);\n    return (\n    // not-not-scrollable\n    styles[overflow] !== 'hidden' &&\n        // contains scroll inside self\n        !(styles.overflowY === styles.overflowX && !alwaysContainsScroll(node) && styles[overflow] === 'visible'));\n};\nvar elementCouldBeVScrolled = function (node) { return elementCanBeScrolled(node, 'overflowY'); };\nvar elementCouldBeHScrolled = function (node) { return elementCanBeScrolled(node, 'overflowX'); };\nexport var locationCouldBeScrolled = function (axis, node) {\n    var ownerDocument = node.ownerDocument;\n    var current = node;\n    do {\n        // Skip over shadow root\n        if (typeof ShadowRoot !== 'undefined' && current instanceof ShadowRoot) {\n            current = current.host;\n        }\n        var isScrollable = elementCouldBeScrolled(axis, current);\n        if (isScrollable) {\n            var _a = getScrollVariables(axis, current), scrollHeight = _a[1], clientHeight = _a[2];\n            if (scrollHeight > clientHeight) {\n                return true;\n            }\n        }\n        current = current.parentNode;\n    } while (current && current !== ownerDocument.body);\n    return false;\n};\nvar getVScrollVariables = function (_a) {\n    var scrollTop = _a.scrollTop, scrollHeight = _a.scrollHeight, clientHeight = _a.clientHeight;\n    return [\n        scrollTop,\n        scrollHeight,\n        clientHeight,\n    ];\n};\nvar getHScrollVariables = function (_a) {\n    var scrollLeft = _a.scrollLeft, scrollWidth = _a.scrollWidth, clientWidth = _a.clientWidth;\n    return [\n        scrollLeft,\n        scrollWidth,\n        clientWidth,\n    ];\n};\nvar elementCouldBeScrolled = function (axis, node) {\n    return axis === 'v' ? elementCouldBeVScrolled(node) : elementCouldBeHScrolled(node);\n};\nvar getScrollVariables = function (axis, node) {\n    return axis === 'v' ? getVScrollVariables(node) : getHScrollVariables(node);\n};\nvar getDirectionFactor = function (axis, direction) {\n    /**\n     * If the element's direction is rtl (right-to-left), then scrollLeft is 0 when the scrollbar is at its rightmost position,\n     * and then increasingly negative as you scroll towards the end of the content.\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/Element/scrollLeft\n     */\n    return axis === 'h' && direction === 'rtl' ? -1 : 1;\n};\nexport var handleScroll = function (axis, endTarget, event, sourceDelta, noOverscroll) {\n    var directionFactor = getDirectionFactor(axis, window.getComputedStyle(endTarget).direction);\n    var delta = directionFactor * sourceDelta;\n    // find scrollable target\n    var target = event.target;\n    var targetInLock = endTarget.contains(target);\n    var shouldCancelScroll = false;\n    var isDeltaPositive = delta > 0;\n    var availableScroll = 0;\n    var availableScrollTop = 0;\n    do {\n        var _a = getScrollVariables(axis, target), position = _a[0], scroll_1 = _a[1], capacity = _a[2];\n        var elementScroll = scroll_1 - capacity - directionFactor * position;\n        if (position || elementScroll) {\n            if (elementCouldBeScrolled(axis, target)) {\n                availableScroll += elementScroll;\n                availableScrollTop += position;\n            }\n        }\n        if (target instanceof ShadowRoot) {\n            target = target.host;\n        }\n        else {\n            target = target.parentNode;\n        }\n    } while (\n    // portaled content\n    (!targetInLock && target !== document.body) ||\n        // self content\n        (targetInLock && (endTarget.contains(target) || endTarget === target)));\n    // handle epsilon around 0 (non standard zoom levels)\n    if (isDeltaPositive &&\n        ((noOverscroll && Math.abs(availableScroll) < 1) || (!noOverscroll && delta > availableScroll))) {\n        shouldCancelScroll = true;\n    }\n    else if (!isDeltaPositive &&\n        ((noOverscroll && Math.abs(availableScrollTop) < 1) || (!noOverscroll && -delta > availableScrollTop))) {\n        shouldCancelScroll = true;\n    }\n    return shouldCancelScroll;\n};\n","import { __spreadArray } from \"tslib\";\nimport * as React from 'react';\nimport { RemoveScrollBar } from 'react-remove-scroll-bar';\nimport { styleSingleton } from 'react-style-singleton';\nimport { nonPassive } from './aggresiveCapture';\nimport { handleScroll, locationCouldBeScrolled } from './handleScroll';\nexport var getTouchXY = function (event) {\n    return 'changedTouches' in event ? [event.changedTouches[0].clientX, event.changedTouches[0].clientY] : [0, 0];\n};\nexport var getDeltaXY = function (event) { return [event.deltaX, event.deltaY]; };\nvar extractRef = function (ref) {\n    return ref && 'current' in ref ? ref.current : ref;\n};\nvar deltaCompare = function (x, y) { return x[0] === y[0] && x[1] === y[1]; };\nvar generateStyle = function (id) { return \"\\n  .block-interactivity-\".concat(id, \" {pointer-events: none;}\\n  .allow-interactivity-\").concat(id, \" {pointer-events: all;}\\n\"); };\nvar idCounter = 0;\nvar lockStack = [];\nexport function RemoveScrollSideCar(props) {\n    var shouldPreventQueue = React.useRef([]);\n    var touchStartRef = React.useRef([0, 0]);\n    var activeAxis = React.useRef();\n    var id = React.useState(idCounter++)[0];\n    var Style = React.useState(styleSingleton)[0];\n    var lastProps = React.useRef(props);\n    React.useEffect(function () {\n        lastProps.current = props;\n    }, [props]);\n    React.useEffect(function () {\n        if (props.inert) {\n            document.body.classList.add(\"block-interactivity-\".concat(id));\n            var allow_1 = __spreadArray([props.lockRef.current], (props.shards || []).map(extractRef), true).filter(Boolean);\n            allow_1.forEach(function (el) { return el.classList.add(\"allow-interactivity-\".concat(id)); });\n            return function () {\n                document.body.classList.remove(\"block-interactivity-\".concat(id));\n                allow_1.forEach(function (el) { return el.classList.remove(\"allow-interactivity-\".concat(id)); });\n            };\n        }\n        return;\n    }, [props.inert, props.lockRef.current, props.shards]);\n    var shouldCancelEvent = React.useCallback(function (event, parent) {\n        if (('touches' in event && event.touches.length === 2) || (event.type === 'wheel' && event.ctrlKey)) {\n            return !lastProps.current.allowPinchZoom;\n        }\n        var touch = getTouchXY(event);\n        var touchStart = touchStartRef.current;\n        var deltaX = 'deltaX' in event ? event.deltaX : touchStart[0] - touch[0];\n        var deltaY = 'deltaY' in event ? event.deltaY : touchStart[1] - touch[1];\n        var currentAxis;\n        var target = event.target;\n        var moveDirection = Math.abs(deltaX) > Math.abs(deltaY) ? 'h' : 'v';\n        // allow horizontal touch move on Range inputs. They will not cause any scroll\n        if ('touches' in event && moveDirection === 'h' && target.type === 'range') {\n            return false;\n        }\n        var canBeScrolledInMainDirection = locationCouldBeScrolled(moveDirection, target);\n        if (!canBeScrolledInMainDirection) {\n            return true;\n        }\n        if (canBeScrolledInMainDirection) {\n            currentAxis = moveDirection;\n        }\n        else {\n            currentAxis = moveDirection === 'v' ? 'h' : 'v';\n            canBeScrolledInMainDirection = locationCouldBeScrolled(moveDirection, target);\n            // other axis might be not scrollable\n        }\n        if (!canBeScrolledInMainDirection) {\n            return false;\n        }\n        if (!activeAxis.current && 'changedTouches' in event && (deltaX || deltaY)) {\n            activeAxis.current = currentAxis;\n        }\n        if (!currentAxis) {\n            return true;\n        }\n        var cancelingAxis = activeAxis.current || currentAxis;\n        return handleScroll(cancelingAxis, parent, event, cancelingAxis === 'h' ? deltaX : deltaY, true);\n    }, []);\n    var shouldPrevent = React.useCallback(function (_event) {\n        var event = _event;\n        if (!lockStack.length || lockStack[lockStack.length - 1] !== Style) {\n            // not the last active\n            return;\n        }\n        var delta = 'deltaY' in event ? getDeltaXY(event) : getTouchXY(event);\n        var sourceEvent = shouldPreventQueue.current.filter(function (e) { return e.name === event.type && (e.target === event.target || event.target === e.shadowParent) && deltaCompare(e.delta, delta); })[0];\n        // self event, and should be canceled\n        if (sourceEvent && sourceEvent.should) {\n            if (event.cancelable) {\n                event.preventDefault();\n            }\n            return;\n        }\n        // outside or shard event\n        if (!sourceEvent) {\n            var shardNodes = (lastProps.current.shards || [])\n                .map(extractRef)\n                .filter(Boolean)\n                .filter(function (node) { return node.contains(event.target); });\n            var shouldStop = shardNodes.length > 0 ? shouldCancelEvent(event, shardNodes[0]) : !lastProps.current.noIsolation;\n            if (shouldStop) {\n                if (event.cancelable) {\n                    event.preventDefault();\n                }\n            }\n        }\n    }, []);\n    var shouldCancel = React.useCallback(function (name, delta, target, should) {\n        var event = { name: name, delta: delta, target: target, should: should, shadowParent: getOutermostShadowParent(target) };\n        shouldPreventQueue.current.push(event);\n        setTimeout(function () {\n            shouldPreventQueue.current = shouldPreventQueue.current.filter(function (e) { return e !== event; });\n        }, 1);\n    }, []);\n    var scrollTouchStart = React.useCallback(function (event) {\n        touchStartRef.current = getTouchXY(event);\n        activeAxis.current = undefined;\n    }, []);\n    var scrollWheel = React.useCallback(function (event) {\n        shouldCancel(event.type, getDeltaXY(event), event.target, shouldCancelEvent(event, props.lockRef.current));\n    }, []);\n    var scrollTouchMove = React.useCallback(function (event) {\n        shouldCancel(event.type, getTouchXY(event), event.target, shouldCancelEvent(event, props.lockRef.current));\n    }, []);\n    React.useEffect(function () {\n        lockStack.push(Style);\n        props.setCallbacks({\n            onScrollCapture: scrollWheel,\n            onWheelCapture: scrollWheel,\n            onTouchMoveCapture: scrollTouchMove,\n        });\n        document.addEventListener('wheel', shouldPrevent, nonPassive);\n        document.addEventListener('touchmove', shouldPrevent, nonPassive);\n        document.addEventListener('touchstart', scrollTouchStart, nonPassive);\n        return function () {\n            lockStack = lockStack.filter(function (inst) { return inst !== Style; });\n            document.removeEventListener('wheel', shouldPrevent, nonPassive);\n            document.removeEventListener('touchmove', shouldPrevent, nonPassive);\n            document.removeEventListener('touchstart', scrollTouchStart, nonPassive);\n        };\n    }, []);\n    var removeScrollBar = props.removeScrollBar, inert = props.inert;\n    return (React.createElement(React.Fragment, null,\n        inert ? React.createElement(Style, { styles: generateStyle(id) }) : null,\n        removeScrollBar ? React.createElement(RemoveScrollBar, { gapMode: props.gapMode }) : null));\n}\nfunction getOutermostShadowParent(node) {\n    var shadowParent = null;\n    while (node !== null) {\n        if (node instanceof ShadowRoot) {\n            shadowParent = node.host;\n            node = node.host;\n        }\n        node = node.parentNode;\n    }\n    return shadowParent;\n}\n","import { exportSidecar } from 'use-sidecar';\nimport { RemoveScrollSideCar } from './SideEffect';\nimport { effectCar } from './medium';\nexport default exportSidecar(effectCar, RemoveScrollSideCar);\n","import { __assign } from \"tslib\";\nimport * as React from 'react';\nimport { RemoveScroll } from './UI';\nimport SideCar from './sidecar';\nvar ReactRemoveScroll = React.forwardRef(function (props, ref) { return (React.createElement(RemoveScroll, __assign({}, props, { ref: ref, sideCar: SideCar }))); });\nReactRemoveScroll.classNames = RemoveScroll.classNames;\nexport default ReactRemoveScroll;\n","\"use client\";\n\n// packages/react/menu/src/Menu.tsx\nimport * as React from \"react\";\nimport { composeEventHandlers } from \"@radix-ui/primitive\";\nimport { createCollection } from \"@radix-ui/react-collection\";\nimport { useComposedRefs, composeRefs } from \"@radix-ui/react-compose-refs\";\nimport { createContextScope } from \"@radix-ui/react-context\";\nimport { useDirection } from \"@radix-ui/react-direction\";\nimport { DismissableLayer } from \"@radix-ui/react-dismissable-layer\";\nimport { useFocusGuards } from \"@radix-ui/react-focus-guards\";\nimport { FocusScope } from \"@radix-ui/react-focus-scope\";\nimport { useId } from \"@radix-ui/react-id\";\nimport * as PopperPrimitive from \"@radix-ui/react-popper\";\nimport { createPopperScope } from \"@radix-ui/react-popper\";\nimport { Portal as PortalPrimitive } from \"@radix-ui/react-portal\";\nimport { Presence } from \"@radix-ui/react-presence\";\nimport { Primitive, dispatchDiscreteCustomEvent } from \"@radix-ui/react-primitive\";\nimport * as RovingFocusGroup from \"@radix-ui/react-roving-focus\";\nimport { createRovingFocusGroupScope } from \"@radix-ui/react-roving-focus\";\nimport { Slot } from \"@radix-ui/react-slot\";\nimport { useCallbackRef } from \"@radix-ui/react-use-callback-ref\";\nimport { hideOthers } from \"aria-hidden\";\nimport { RemoveScroll } from \"react-remove-scroll\";\nimport { jsx } from \"react/jsx-runtime\";\nvar SELECTION_KEYS = [\"Enter\", \" \"];\nvar FIRST_KEYS = [\"ArrowDown\", \"PageUp\", \"Home\"];\nvar LAST_KEYS = [\"ArrowUp\", \"PageDown\", \"End\"];\nvar FIRST_LAST_KEYS = [...FIRST_KEYS, ...LAST_KEYS];\nvar SUB_OPEN_KEYS = {\n  ltr: [...SELECTION_KEYS, \"ArrowRight\"],\n  rtl: [...SELECTION_KEYS, \"ArrowLeft\"]\n};\nvar SUB_CLOSE_KEYS = {\n  ltr: [\"ArrowLeft\"],\n  rtl: [\"ArrowRight\"]\n};\nvar MENU_NAME = \"Menu\";\nvar [Collection, useCollection, createCollectionScope] = createCollection(MENU_NAME);\nvar [createMenuContext, createMenuScope] = createContextScope(MENU_NAME, [\n  createCollectionScope,\n  createPopperScope,\n  createRovingFocusGroupScope\n]);\nvar usePopperScope = createPopperScope();\nvar useRovingFocusGroupScope = createRovingFocusGroupScope();\nvar [MenuProvider, useMenuContext] = createMenuContext(MENU_NAME);\nvar [MenuRootProvider, useMenuRootContext] = createMenuContext(MENU_NAME);\nvar Menu = (props) => {\n  const { __scopeMenu, open = false, children, dir, onOpenChange, modal = true } = props;\n  const popperScope = usePopperScope(__scopeMenu);\n  const [content, setContent] = React.useState(null);\n  const isUsingKeyboardRef = React.useRef(false);\n  const handleOpenChange = useCallbackRef(onOpenChange);\n  const direction = useDirection(dir);\n  React.useEffect(() => {\n    const handleKeyDown = () => {\n      isUsingKeyboardRef.current = true;\n      document.addEventListener(\"pointerdown\", handlePointer, { capture: true, once: true });\n      document.addEventListener(\"pointermove\", handlePointer, { capture: true, once: true });\n    };\n    const handlePointer = () => isUsingKeyboardRef.current = false;\n    document.addEventListener(\"keydown\", handleKeyDown, { capture: true });\n    return () => {\n      document.removeEventListener(\"keydown\", handleKeyDown, { capture: true });\n      document.removeEventListener(\"pointerdown\", handlePointer, { capture: true });\n      document.removeEventListener(\"pointermove\", handlePointer, { capture: true });\n    };\n  }, []);\n  return /* @__PURE__ */ jsx(PopperPrimitive.Root, { ...popperScope, children: /* @__PURE__ */ jsx(\n    MenuProvider,\n    {\n      scope: __scopeMenu,\n      open,\n      onOpenChange: handleOpenChange,\n      content,\n      onContentChange: setContent,\n      children: /* @__PURE__ */ jsx(\n        MenuRootProvider,\n        {\n          scope: __scopeMenu,\n          onClose: React.useCallback(() => handleOpenChange(false), [handleOpenChange]),\n          isUsingKeyboardRef,\n          dir: direction,\n          modal,\n          children\n        }\n      )\n    }\n  ) });\n};\nMenu.displayName = MENU_NAME;\nvar ANCHOR_NAME = \"MenuAnchor\";\nvar MenuAnchor = React.forwardRef(\n  (props, forwardedRef) => {\n    const { __scopeMenu, ...anchorProps } = props;\n    const popperScope = usePopperScope(__scopeMenu);\n    return /* @__PURE__ */ jsx(PopperPrimitive.Anchor, { ...popperScope, ...anchorProps, ref: forwardedRef });\n  }\n);\nMenuAnchor.displayName = ANCHOR_NAME;\nvar PORTAL_NAME = \"MenuPortal\";\nvar [PortalProvider, usePortalContext] = createMenuContext(PORTAL_NAME, {\n  forceMount: void 0\n});\nvar MenuPortal = (props) => {\n  const { __scopeMenu, forceMount, children, container } = props;\n  const context = useMenuContext(PORTAL_NAME, __scopeMenu);\n  return /* @__PURE__ */ jsx(PortalProvider, { scope: __scopeMenu, forceMount, children: /* @__PURE__ */ jsx(Presence, { present: forceMount || context.open, children: /* @__PURE__ */ jsx(PortalPrimitive, { asChild: true, container, children }) }) });\n};\nMenuPortal.displayName = PORTAL_NAME;\nvar CONTENT_NAME = \"MenuContent\";\nvar [MenuContentProvider, useMenuContentContext] = createMenuContext(CONTENT_NAME);\nvar MenuContent = React.forwardRef(\n  (props, forwardedRef) => {\n    const portalContext = usePortalContext(CONTENT_NAME, props.__scopeMenu);\n    const { forceMount = portalContext.forceMount, ...contentProps } = props;\n    const context = useMenuContext(CONTENT_NAME, props.__scopeMenu);\n    const rootContext = useMenuRootContext(CONTENT_NAME, props.__scopeMenu);\n    return /* @__PURE__ */ jsx(Collection.Provider, { scope: props.__scopeMenu, children: /* @__PURE__ */ jsx(Presence, { present: forceMount || context.open, children: /* @__PURE__ */ jsx(Collection.Slot, { scope: props.__scopeMenu, children: rootContext.modal ? /* @__PURE__ */ jsx(MenuRootContentModal, { ...contentProps, ref: forwardedRef }) : /* @__PURE__ */ jsx(MenuRootContentNonModal, { ...contentProps, ref: forwardedRef }) }) }) });\n  }\n);\nvar MenuRootContentModal = React.forwardRef(\n  (props, forwardedRef) => {\n    const context = useMenuContext(CONTENT_NAME, props.__scopeMenu);\n    const ref = React.useRef(null);\n    const composedRefs = useComposedRefs(forwardedRef, ref);\n    React.useEffect(() => {\n      const content = ref.current;\n      if (content) return hideOthers(content);\n    }, []);\n    return /* @__PURE__ */ jsx(\n      MenuContentImpl,\n      {\n        ...props,\n        ref: composedRefs,\n        trapFocus: context.open,\n        disableOutsidePointerEvents: context.open,\n        disableOutsideScroll: true,\n        onFocusOutside: composeEventHandlers(\n          props.onFocusOutside,\n          (event) => event.preventDefault(),\n          { checkForDefaultPrevented: false }\n        ),\n        onDismiss: () => context.onOpenChange(false)\n      }\n    );\n  }\n);\nvar MenuRootContentNonModal = React.forwardRef((props, forwardedRef) => {\n  const context = useMenuContext(CONTENT_NAME, props.__scopeMenu);\n  return /* @__PURE__ */ jsx(\n    MenuContentImpl,\n    {\n      ...props,\n      ref: forwardedRef,\n      trapFocus: false,\n      disableOutsidePointerEvents: false,\n      disableOutsideScroll: false,\n      onDismiss: () => context.onOpenChange(false)\n    }\n  );\n});\nvar MenuContentImpl = React.forwardRef(\n  (props, forwardedRef) => {\n    const {\n      __scopeMenu,\n      loop = false,\n      trapFocus,\n      onOpenAutoFocus,\n      onCloseAutoFocus,\n      disableOutsidePointerEvents,\n      onEntryFocus,\n      onEscapeKeyDown,\n      onPointerDownOutside,\n      onFocusOutside,\n      onInteractOutside,\n      onDismiss,\n      disableOutsideScroll,\n      ...contentProps\n    } = props;\n    const context = useMenuContext(CONTENT_NAME, __scopeMenu);\n    const rootContext = useMenuRootContext(CONTENT_NAME, __scopeMenu);\n    const popperScope = usePopperScope(__scopeMenu);\n    const rovingFocusGroupScope = useRovingFocusGroupScope(__scopeMenu);\n    const getItems = useCollection(__scopeMenu);\n    const [currentItemId, setCurrentItemId] = React.useState(null);\n    const contentRef = React.useRef(null);\n    const composedRefs = useComposedRefs(forwardedRef, contentRef, context.onContentChange);\n    const timerRef = React.useRef(0);\n    const searchRef = React.useRef(\"\");\n    const pointerGraceTimerRef = React.useRef(0);\n    const pointerGraceIntentRef = React.useRef(null);\n    const pointerDirRef = React.useRef(\"right\");\n    const lastPointerXRef = React.useRef(0);\n    const ScrollLockWrapper = disableOutsideScroll ? RemoveScroll : React.Fragment;\n    const scrollLockWrapperProps = disableOutsideScroll ? { as: Slot, allowPinchZoom: true } : void 0;\n    const handleTypeaheadSearch = (key) => {\n      const search = searchRef.current + key;\n      const items = getItems().filter((item) => !item.disabled);\n      const currentItem = document.activeElement;\n      const currentMatch = items.find((item) => item.ref.current === currentItem)?.textValue;\n      const values = items.map((item) => item.textValue);\n      const nextMatch = getNextMatch(values, search, currentMatch);\n      const newItem = items.find((item) => item.textValue === nextMatch)?.ref.current;\n      (function updateSearch(value) {\n        searchRef.current = value;\n        window.clearTimeout(timerRef.current);\n        if (value !== \"\") timerRef.current = window.setTimeout(() => updateSearch(\"\"), 1e3);\n      })(search);\n      if (newItem) {\n        setTimeout(() => newItem.focus());\n      }\n    };\n    React.useEffect(() => {\n      return () => window.clearTimeout(timerRef.current);\n    }, []);\n    useFocusGuards();\n    const isPointerMovingToSubmenu = React.useCallback((event) => {\n      const isMovingTowards = pointerDirRef.current === pointerGraceIntentRef.current?.side;\n      return isMovingTowards && isPointerInGraceArea(event, pointerGraceIntentRef.current?.area);\n    }, []);\n    return /* @__PURE__ */ jsx(\n      MenuContentProvider,\n      {\n        scope: __scopeMenu,\n        searchRef,\n        onItemEnter: React.useCallback(\n          (event) => {\n            if (isPointerMovingToSubmenu(event)) event.preventDefault();\n          },\n          [isPointerMovingToSubmenu]\n        ),\n        onItemLeave: React.useCallback(\n          (event) => {\n            if (isPointerMovingToSubmenu(event)) return;\n            contentRef.current?.focus();\n            setCurrentItemId(null);\n          },\n          [isPointerMovingToSubmenu]\n        ),\n        onTriggerLeave: React.useCallback(\n          (event) => {\n            if (isPointerMovingToSubmenu(event)) event.preventDefault();\n          },\n          [isPointerMovingToSubmenu]\n        ),\n        pointerGraceTimerRef,\n        onPointerGraceIntentChange: React.useCallback((intent) => {\n          pointerGraceIntentRef.current = intent;\n        }, []),\n        children: /* @__PURE__ */ jsx(ScrollLockWrapper, { ...scrollLockWrapperProps, children: /* @__PURE__ */ jsx(\n          FocusScope,\n          {\n            asChild: true,\n            trapped: trapFocus,\n            onMountAutoFocus: composeEventHandlers(onOpenAutoFocus, (event) => {\n              event.preventDefault();\n              contentRef.current?.focus({ preventScroll: true });\n            }),\n            onUnmountAutoFocus: onCloseAutoFocus,\n            children: /* @__PURE__ */ jsx(\n              DismissableLayer,\n              {\n                asChild: true,\n                disableOutsidePointerEvents,\n                onEscapeKeyDown,\n                onPointerDownOutside,\n                onFocusOutside,\n                onInteractOutside,\n                onDismiss,\n                children: /* @__PURE__ */ jsx(\n                  RovingFocusGroup.Root,\n                  {\n                    asChild: true,\n                    ...rovingFocusGroupScope,\n                    dir: rootContext.dir,\n                    orientation: \"vertical\",\n                    loop,\n                    currentTabStopId: currentItemId,\n                    onCurrentTabStopIdChange: setCurrentItemId,\n                    onEntryFocus: composeEventHandlers(onEntryFocus, (event) => {\n                      if (!rootContext.isUsingKeyboardRef.current) event.preventDefault();\n                    }),\n                    preventScrollOnEntryFocus: true,\n                    children: /* @__PURE__ */ jsx(\n                      PopperPrimitive.Content,\n                      {\n                        role: \"menu\",\n                        \"aria-orientation\": \"vertical\",\n                        \"data-state\": getOpenState(context.open),\n                        \"data-radix-menu-content\": \"\",\n                        dir: rootContext.dir,\n                        ...popperScope,\n                        ...contentProps,\n                        ref: composedRefs,\n                        style: { outline: \"none\", ...contentProps.style },\n                        onKeyDown: composeEventHandlers(contentProps.onKeyDown, (event) => {\n                          const target = event.target;\n                          const isKeyDownInside = target.closest(\"[data-radix-menu-content]\") === event.currentTarget;\n                          const isModifierKey = event.ctrlKey || event.altKey || event.metaKey;\n                          const isCharacterKey = event.key.length === 1;\n                          if (isKeyDownInside) {\n                            if (event.key === \"Tab\") event.preventDefault();\n                            if (!isModifierKey && isCharacterKey) handleTypeaheadSearch(event.key);\n                          }\n                          const content = contentRef.current;\n                          if (event.target !== content) return;\n                          if (!FIRST_LAST_KEYS.includes(event.key)) return;\n                          event.preventDefault();\n                          const items = getItems().filter((item) => !item.disabled);\n                          const candidateNodes = items.map((item) => item.ref.current);\n                          if (LAST_KEYS.includes(event.key)) candidateNodes.reverse();\n                          focusFirst(candidateNodes);\n                        }),\n                        onBlur: composeEventHandlers(props.onBlur, (event) => {\n                          if (!event.currentTarget.contains(event.target)) {\n                            window.clearTimeout(timerRef.current);\n                            searchRef.current = \"\";\n                          }\n                        }),\n                        onPointerMove: composeEventHandlers(\n                          props.onPointerMove,\n                          whenMouse((event) => {\n                            const target = event.target;\n                            const pointerXHasChanged = lastPointerXRef.current !== event.clientX;\n                            if (event.currentTarget.contains(target) && pointerXHasChanged) {\n                              const newDir = event.clientX > lastPointerXRef.current ? \"right\" : \"left\";\n                              pointerDirRef.current = newDir;\n                              lastPointerXRef.current = event.clientX;\n                            }\n                          })\n                        )\n                      }\n                    )\n                  }\n                )\n              }\n            )\n          }\n        ) })\n      }\n    );\n  }\n);\nMenuContent.displayName = CONTENT_NAME;\nvar GROUP_NAME = \"MenuGroup\";\nvar MenuGroup = React.forwardRef(\n  (props, forwardedRef) => {\n    const { __scopeMenu, ...groupProps } = props;\n    return /* @__PURE__ */ jsx(Primitive.div, { role: \"group\", ...groupProps, ref: forwardedRef });\n  }\n);\nMenuGroup.displayName = GROUP_NAME;\nvar LABEL_NAME = \"MenuLabel\";\nvar MenuLabel = React.forwardRef(\n  (props, forwardedRef) => {\n    const { __scopeMenu, ...labelProps } = props;\n    return /* @__PURE__ */ jsx(Primitive.div, { ...labelProps, ref: forwardedRef });\n  }\n);\nMenuLabel.displayName = LABEL_NAME;\nvar ITEM_NAME = \"MenuItem\";\nvar ITEM_SELECT = \"menu.itemSelect\";\nvar MenuItem = React.forwardRef(\n  (props, forwardedRef) => {\n    const { disabled = false, onSelect, ...itemProps } = props;\n    const ref = React.useRef(null);\n    const rootContext = useMenuRootContext(ITEM_NAME, props.__scopeMenu);\n    const contentContext = useMenuContentContext(ITEM_NAME, props.__scopeMenu);\n    const composedRefs = useComposedRefs(forwardedRef, ref);\n    const isPointerDownRef = React.useRef(false);\n    const handleSelect = () => {\n      const menuItem = ref.current;\n      if (!disabled && menuItem) {\n        const itemSelectEvent = new CustomEvent(ITEM_SELECT, { bubbles: true, cancelable: true });\n        menuItem.addEventListener(ITEM_SELECT, (event) => onSelect?.(event), { once: true });\n        dispatchDiscreteCustomEvent(menuItem, itemSelectEvent);\n        if (itemSelectEvent.defaultPrevented) {\n          isPointerDownRef.current = false;\n        } else {\n          rootContext.onClose();\n        }\n      }\n    };\n    return /* @__PURE__ */ jsx(\n      MenuItemImpl,\n      {\n        ...itemProps,\n        ref: composedRefs,\n        disabled,\n        onClick: composeEventHandlers(props.onClick, handleSelect),\n        onPointerDown: (event) => {\n          props.onPointerDown?.(event);\n          isPointerDownRef.current = true;\n        },\n        onPointerUp: composeEventHandlers(props.onPointerUp, (event) => {\n          if (!isPointerDownRef.current) event.currentTarget?.click();\n        }),\n        onKeyDown: composeEventHandlers(props.onKeyDown, (event) => {\n          const isTypingAhead = contentContext.searchRef.current !== \"\";\n          if (disabled || isTypingAhead && event.key === \" \") return;\n          if (SELECTION_KEYS.includes(event.key)) {\n            event.currentTarget.click();\n            event.preventDefault();\n          }\n        })\n      }\n    );\n  }\n);\nMenuItem.displayName = ITEM_NAME;\nvar MenuItemImpl = React.forwardRef(\n  (props, forwardedRef) => {\n    const { __scopeMenu, disabled = false, textValue, ...itemProps } = props;\n    const contentContext = useMenuContentContext(ITEM_NAME, __scopeMenu);\n    const rovingFocusGroupScope = useRovingFocusGroupScope(__scopeMenu);\n    const ref = React.useRef(null);\n    const composedRefs = useComposedRefs(forwardedRef, ref);\n    const [isFocused, setIsFocused] = React.useState(false);\n    const [textContent, setTextContent] = React.useState(\"\");\n    React.useEffect(() => {\n      const menuItem = ref.current;\n      if (menuItem) {\n        setTextContent((menuItem.textContent ?? \"\").trim());\n      }\n    }, [itemProps.children]);\n    return /* @__PURE__ */ jsx(\n      Collection.ItemSlot,\n      {\n        scope: __scopeMenu,\n        disabled,\n        textValue: textValue ?? textContent,\n        children: /* @__PURE__ */ jsx(RovingFocusGroup.Item, { asChild: true, ...rovingFocusGroupScope, focusable: !disabled, children: /* @__PURE__ */ jsx(\n          Primitive.div,\n          {\n            role: \"menuitem\",\n            \"data-highlighted\": isFocused ? \"\" : void 0,\n            \"aria-disabled\": disabled || void 0,\n            \"data-disabled\": disabled ? \"\" : void 0,\n            ...itemProps,\n            ref: composedRefs,\n            onPointerMove: composeEventHandlers(\n              props.onPointerMove,\n              whenMouse((event) => {\n                if (disabled) {\n                  contentContext.onItemLeave(event);\n                } else {\n                  contentContext.onItemEnter(event);\n                  if (!event.defaultPrevented) {\n                    const item = event.currentTarget;\n                    item.focus({ preventScroll: true });\n                  }\n                }\n              })\n            ),\n            onPointerLeave: composeEventHandlers(\n              props.onPointerLeave,\n              whenMouse((event) => contentContext.onItemLeave(event))\n            ),\n            onFocus: composeEventHandlers(props.onFocus, () => setIsFocused(true)),\n            onBlur: composeEventHandlers(props.onBlur, () => setIsFocused(false))\n          }\n        ) })\n      }\n    );\n  }\n);\nvar CHECKBOX_ITEM_NAME = \"MenuCheckboxItem\";\nvar MenuCheckboxItem = React.forwardRef(\n  (props, forwardedRef) => {\n    const { checked = false, onCheckedChange, ...checkboxItemProps } = props;\n    return /* @__PURE__ */ jsx(ItemIndicatorProvider, { scope: props.__scopeMenu, checked, children: /* @__PURE__ */ jsx(\n      MenuItem,\n      {\n        role: \"menuitemcheckbox\",\n        \"aria-checked\": isIndeterminate(checked) ? \"mixed\" : checked,\n        ...checkboxItemProps,\n        ref: forwardedRef,\n        \"data-state\": getCheckedState(checked),\n        onSelect: composeEventHandlers(\n          checkboxItemProps.onSelect,\n          () => onCheckedChange?.(isIndeterminate(checked) ? true : !checked),\n          { checkForDefaultPrevented: false }\n        )\n      }\n    ) });\n  }\n);\nMenuCheckboxItem.displayName = CHECKBOX_ITEM_NAME;\nvar RADIO_GROUP_NAME = \"MenuRadioGroup\";\nvar [RadioGroupProvider, useRadioGroupContext] = createMenuContext(\n  RADIO_GROUP_NAME,\n  { value: void 0, onValueChange: () => {\n  } }\n);\nvar MenuRadioGroup = React.forwardRef(\n  (props, forwardedRef) => {\n    const { value, onValueChange, ...groupProps } = props;\n    const handleValueChange = useCallbackRef(onValueChange);\n    return /* @__PURE__ */ jsx(RadioGroupProvider, { scope: props.__scopeMenu, value, onValueChange: handleValueChange, children: /* @__PURE__ */ jsx(MenuGroup, { ...groupProps, ref: forwardedRef }) });\n  }\n);\nMenuRadioGroup.displayName = RADIO_GROUP_NAME;\nvar RADIO_ITEM_NAME = \"MenuRadioItem\";\nvar MenuRadioItem = React.forwardRef(\n  (props, forwardedRef) => {\n    const { value, ...radioItemProps } = props;\n    const context = useRadioGroupContext(RADIO_ITEM_NAME, props.__scopeMenu);\n    const checked = value === context.value;\n    return /* @__PURE__ */ jsx(ItemIndicatorProvider, { scope: props.__scopeMenu, checked, children: /* @__PURE__ */ jsx(\n      MenuItem,\n      {\n        role: \"menuitemradio\",\n        \"aria-checked\": checked,\n        ...radioItemProps,\n        ref: forwardedRef,\n        \"data-state\": getCheckedState(checked),\n        onSelect: composeEventHandlers(\n          radioItemProps.onSelect,\n          () => context.onValueChange?.(value),\n          { checkForDefaultPrevented: false }\n        )\n      }\n    ) });\n  }\n);\nMenuRadioItem.displayName = RADIO_ITEM_NAME;\nvar ITEM_INDICATOR_NAME = \"MenuItemIndicator\";\nvar [ItemIndicatorProvider, useItemIndicatorContext] = createMenuContext(\n  ITEM_INDICATOR_NAME,\n  { checked: false }\n);\nvar MenuItemIndicator = React.forwardRef(\n  (props, forwardedRef) => {\n    const { __scopeMenu, forceMount, ...itemIndicatorProps } = props;\n    const indicatorContext = useItemIndicatorContext(ITEM_INDICATOR_NAME, __scopeMenu);\n    return /* @__PURE__ */ jsx(\n      Presence,\n      {\n        present: forceMount || isIndeterminate(indicatorContext.checked) || indicatorContext.checked === true,\n        children: /* @__PURE__ */ jsx(\n          Primitive.span,\n          {\n            ...itemIndicatorProps,\n            ref: forwardedRef,\n            \"data-state\": getCheckedState(indicatorContext.checked)\n          }\n        )\n      }\n    );\n  }\n);\nMenuItemIndicator.displayName = ITEM_INDICATOR_NAME;\nvar SEPARATOR_NAME = \"MenuSeparator\";\nvar MenuSeparator = React.forwardRef(\n  (props, forwardedRef) => {\n    const { __scopeMenu, ...separatorProps } = props;\n    return /* @__PURE__ */ jsx(\n      Primitive.div,\n      {\n        role: \"separator\",\n        \"aria-orientation\": \"horizontal\",\n        ...separatorProps,\n        ref: forwardedRef\n      }\n    );\n  }\n);\nMenuSeparator.displayName = SEPARATOR_NAME;\nvar ARROW_NAME = \"MenuArrow\";\nvar MenuArrow = React.forwardRef(\n  (props, forwardedRef) => {\n    const { __scopeMenu, ...arrowProps } = props;\n    const popperScope = usePopperScope(__scopeMenu);\n    return /* @__PURE__ */ jsx(PopperPrimitive.Arrow, { ...popperScope, ...arrowProps, ref: forwardedRef });\n  }\n);\nMenuArrow.displayName = ARROW_NAME;\nvar SUB_NAME = \"MenuSub\";\nvar [MenuSubProvider, useMenuSubContext] = createMenuContext(SUB_NAME);\nvar MenuSub = (props) => {\n  const { __scopeMenu, children, open = false, onOpenChange } = props;\n  const parentMenuContext = useMenuContext(SUB_NAME, __scopeMenu);\n  const popperScope = usePopperScope(__scopeMenu);\n  const [trigger, setTrigger] = React.useState(null);\n  const [content, setContent] = React.useState(null);\n  const handleOpenChange = useCallbackRef(onOpenChange);\n  React.useEffect(() => {\n    if (parentMenuContext.open === false) handleOpenChange(false);\n    return () => handleOpenChange(false);\n  }, [parentMenuContext.open, handleOpenChange]);\n  return /* @__PURE__ */ jsx(PopperPrimitive.Root, { ...popperScope, children: /* @__PURE__ */ jsx(\n    MenuProvider,\n    {\n      scope: __scopeMenu,\n      open,\n      onOpenChange: handleOpenChange,\n      content,\n      onContentChange: setContent,\n      children: /* @__PURE__ */ jsx(\n        MenuSubProvider,\n        {\n          scope: __scopeMenu,\n          contentId: useId(),\n          triggerId: useId(),\n          trigger,\n          onTriggerChange: setTrigger,\n          children\n        }\n      )\n    }\n  ) });\n};\nMenuSub.displayName = SUB_NAME;\nvar SUB_TRIGGER_NAME = \"MenuSubTrigger\";\nvar MenuSubTrigger = React.forwardRef(\n  (props, forwardedRef) => {\n    const context = useMenuContext(SUB_TRIGGER_NAME, props.__scopeMenu);\n    const rootContext = useMenuRootContext(SUB_TRIGGER_NAME, props.__scopeMenu);\n    const subContext = useMenuSubContext(SUB_TRIGGER_NAME, props.__scopeMenu);\n    const contentContext = useMenuContentContext(SUB_TRIGGER_NAME, props.__scopeMenu);\n    const openTimerRef = React.useRef(null);\n    const { pointerGraceTimerRef, onPointerGraceIntentChange } = contentContext;\n    const scope = { __scopeMenu: props.__scopeMenu };\n    const clearOpenTimer = React.useCallback(() => {\n      if (openTimerRef.current) window.clearTimeout(openTimerRef.current);\n      openTimerRef.current = null;\n    }, []);\n    React.useEffect(() => clearOpenTimer, [clearOpenTimer]);\n    React.useEffect(() => {\n      const pointerGraceTimer = pointerGraceTimerRef.current;\n      return () => {\n        window.clearTimeout(pointerGraceTimer);\n        onPointerGraceIntentChange(null);\n      };\n    }, [pointerGraceTimerRef, onPointerGraceIntentChange]);\n    return /* @__PURE__ */ jsx(MenuAnchor, { asChild: true, ...scope, children: /* @__PURE__ */ jsx(\n      MenuItemImpl,\n      {\n        id: subContext.triggerId,\n        \"aria-haspopup\": \"menu\",\n        \"aria-expanded\": context.open,\n        \"aria-controls\": subContext.contentId,\n        \"data-state\": getOpenState(context.open),\n        ...props,\n        ref: composeRefs(forwardedRef, subContext.onTriggerChange),\n        onClick: (event) => {\n          props.onClick?.(event);\n          if (props.disabled || event.defaultPrevented) return;\n          event.currentTarget.focus();\n          if (!context.open) context.onOpenChange(true);\n        },\n        onPointerMove: composeEventHandlers(\n          props.onPointerMove,\n          whenMouse((event) => {\n            contentContext.onItemEnter(event);\n            if (event.defaultPrevented) return;\n            if (!props.disabled && !context.open && !openTimerRef.current) {\n              contentContext.onPointerGraceIntentChange(null);\n              openTimerRef.current = window.setTimeout(() => {\n                context.onOpenChange(true);\n                clearOpenTimer();\n              }, 100);\n            }\n          })\n        ),\n        onPointerLeave: composeEventHandlers(\n          props.onPointerLeave,\n          whenMouse((event) => {\n            clearOpenTimer();\n            const contentRect = context.content?.getBoundingClientRect();\n            if (contentRect) {\n              const side = context.content?.dataset.side;\n              const rightSide = side === \"right\";\n              const bleed = rightSide ? -5 : 5;\n              const contentNearEdge = contentRect[rightSide ? \"left\" : \"right\"];\n              const contentFarEdge = contentRect[rightSide ? \"right\" : \"left\"];\n              contentContext.onPointerGraceIntentChange({\n                area: [\n                  // Apply a bleed on clientX to ensure that our exit point is\n                  // consistently within polygon bounds\n                  { x: event.clientX + bleed, y: event.clientY },\n                  { x: contentNearEdge, y: contentRect.top },\n                  { x: contentFarEdge, y: contentRect.top },\n                  { x: contentFarEdge, y: contentRect.bottom },\n                  { x: contentNearEdge, y: contentRect.bottom }\n                ],\n                side\n              });\n              window.clearTimeout(pointerGraceTimerRef.current);\n              pointerGraceTimerRef.current = window.setTimeout(\n                () => contentContext.onPointerGraceIntentChange(null),\n                300\n              );\n            } else {\n              contentContext.onTriggerLeave(event);\n              if (event.defaultPrevented) return;\n              contentContext.onPointerGraceIntentChange(null);\n            }\n          })\n        ),\n        onKeyDown: composeEventHandlers(props.onKeyDown, (event) => {\n          const isTypingAhead = contentContext.searchRef.current !== \"\";\n          if (props.disabled || isTypingAhead && event.key === \" \") return;\n          if (SUB_OPEN_KEYS[rootContext.dir].includes(event.key)) {\n            context.onOpenChange(true);\n            context.content?.focus();\n            event.preventDefault();\n          }\n        })\n      }\n    ) });\n  }\n);\nMenuSubTrigger.displayName = SUB_TRIGGER_NAME;\nvar SUB_CONTENT_NAME = \"MenuSubContent\";\nvar MenuSubContent = React.forwardRef(\n  (props, forwardedRef) => {\n    const portalContext = usePortalContext(CONTENT_NAME, props.__scopeMenu);\n    const { forceMount = portalContext.forceMount, ...subContentProps } = props;\n    const context = useMenuContext(CONTENT_NAME, props.__scopeMenu);\n    const rootContext = useMenuRootContext(CONTENT_NAME, props.__scopeMenu);\n    const subContext = useMenuSubContext(SUB_CONTENT_NAME, props.__scopeMenu);\n    const ref = React.useRef(null);\n    const composedRefs = useComposedRefs(forwardedRef, ref);\n    return /* @__PURE__ */ jsx(Collection.Provider, { scope: props.__scopeMenu, children: /* @__PURE__ */ jsx(Presence, { present: forceMount || context.open, children: /* @__PURE__ */ jsx(Collection.Slot, { scope: props.__scopeMenu, children: /* @__PURE__ */ jsx(\n      MenuContentImpl,\n      {\n        id: subContext.contentId,\n        \"aria-labelledby\": subContext.triggerId,\n        ...subContentProps,\n        ref: composedRefs,\n        align: \"start\",\n        side: rootContext.dir === \"rtl\" ? \"left\" : \"right\",\n        disableOutsidePointerEvents: false,\n        disableOutsideScroll: false,\n        trapFocus: false,\n        onOpenAutoFocus: (event) => {\n          if (rootContext.isUsingKeyboardRef.current) ref.current?.focus();\n          event.preventDefault();\n        },\n        onCloseAutoFocus: (event) => event.preventDefault(),\n        onFocusOutside: composeEventHandlers(props.onFocusOutside, (event) => {\n          if (event.target !== subContext.trigger) context.onOpenChange(false);\n        }),\n        onEscapeKeyDown: composeEventHandlers(props.onEscapeKeyDown, (event) => {\n          rootContext.onClose();\n          event.preventDefault();\n        }),\n        onKeyDown: composeEventHandlers(props.onKeyDown, (event) => {\n          const isKeyDownInside = event.currentTarget.contains(event.target);\n          const isCloseKey = SUB_CLOSE_KEYS[rootContext.dir].includes(event.key);\n          if (isKeyDownInside && isCloseKey) {\n            context.onOpenChange(false);\n            subContext.trigger?.focus();\n            event.preventDefault();\n          }\n        })\n      }\n    ) }) }) });\n  }\n);\nMenuSubContent.displayName = SUB_CONTENT_NAME;\nfunction getOpenState(open) {\n  return open ? \"open\" : \"closed\";\n}\nfunction isIndeterminate(checked) {\n  return checked === \"indeterminate\";\n}\nfunction getCheckedState(checked) {\n  return isIndeterminate(checked) ? \"indeterminate\" : checked ? \"checked\" : \"unchecked\";\n}\nfunction focusFirst(candidates) {\n  const PREVIOUSLY_FOCUSED_ELEMENT = document.activeElement;\n  for (const candidate of candidates) {\n    if (candidate === PREVIOUSLY_FOCUSED_ELEMENT) return;\n    candidate.focus();\n    if (document.activeElement !== PREVIOUSLY_FOCUSED_ELEMENT) return;\n  }\n}\nfunction wrapArray(array, startIndex) {\n  return array.map((_, index) => array[(startIndex + index) % array.length]);\n}\nfunction getNextMatch(values, search, currentMatch) {\n  const isRepeated = search.length > 1 && Array.from(search).every((char) => char === search[0]);\n  const normalizedSearch = isRepeated ? search[0] : search;\n  const currentMatchIndex = currentMatch ? values.indexOf(currentMatch) : -1;\n  let wrappedValues = wrapArray(values, Math.max(currentMatchIndex, 0));\n  const excludeCurrentMatch = normalizedSearch.length === 1;\n  if (excludeCurrentMatch) wrappedValues = wrappedValues.filter((v) => v !== currentMatch);\n  const nextMatch = wrappedValues.find(\n    (value) => value.toLowerCase().startsWith(normalizedSearch.toLowerCase())\n  );\n  return nextMatch !== currentMatch ? nextMatch : void 0;\n}\nfunction isPointInPolygon(point, polygon) {\n  const { x, y } = point;\n  let inside = false;\n  for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {\n    const xi = polygon[i].x;\n    const yi = polygon[i].y;\n    const xj = polygon[j].x;\n    const yj = polygon[j].y;\n    const intersect = yi > y !== yj > y && x < (xj - xi) * (y - yi) / (yj - yi) + xi;\n    if (intersect) inside = !inside;\n  }\n  return inside;\n}\nfunction isPointerInGraceArea(event, area) {\n  if (!area) return false;\n  const cursorPos = { x: event.clientX, y: event.clientY };\n  return isPointInPolygon(cursorPos, area);\n}\nfunction whenMouse(handler) {\n  return (event) => event.pointerType === \"mouse\" ? handler(event) : void 0;\n}\nvar Root3 = Menu;\nvar Anchor2 = MenuAnchor;\nvar Portal = MenuPortal;\nvar Content2 = MenuContent;\nvar Group = MenuGroup;\nvar Label = MenuLabel;\nvar Item2 = MenuItem;\nvar CheckboxItem = MenuCheckboxItem;\nvar RadioGroup = MenuRadioGroup;\nvar RadioItem = MenuRadioItem;\nvar ItemIndicator = MenuItemIndicator;\nvar Separator = MenuSeparator;\nvar Arrow2 = MenuArrow;\nvar Sub = MenuSub;\nvar SubTrigger = MenuSubTrigger;\nvar SubContent = MenuSubContent;\nexport {\n  Anchor2 as Anchor,\n  Arrow2 as Arrow,\n  CheckboxItem,\n  Content2 as Content,\n  Group,\n  Item2 as Item,\n  ItemIndicator,\n  Label,\n  Menu,\n  MenuAnchor,\n  MenuArrow,\n  MenuCheckboxItem,\n  MenuContent,\n  MenuGroup,\n  MenuItem,\n  MenuItemIndicator,\n  MenuLabel,\n  MenuPortal,\n  MenuRadioGroup,\n  MenuRadioItem,\n  MenuSeparator,\n  MenuSub,\n  MenuSubContent,\n  MenuSubTrigger,\n  Portal,\n  RadioGroup,\n  RadioItem,\n  Root3 as Root,\n  Separator,\n  Sub,\n  SubContent,\n  SubTrigger,\n  createMenuScope\n};\n//# sourceMappingURL=index.mjs.map\n","\"use client\";\n\n// packages/react/dropdown-menu/src/DropdownMenu.tsx\nimport * as React from \"react\";\nimport { composeEventHandlers } from \"@radix-ui/primitive\";\nimport { composeRefs } from \"@radix-ui/react-compose-refs\";\nimport { createContextScope } from \"@radix-ui/react-context\";\nimport { useControllableState } from \"@radix-ui/react-use-controllable-state\";\nimport { Primitive } from \"@radix-ui/react-primitive\";\nimport * as MenuPrimitive from \"@radix-ui/react-menu\";\nimport { createMenuScope } from \"@radix-ui/react-menu\";\nimport { useId } from \"@radix-ui/react-id\";\nimport { jsx } from \"react/jsx-runtime\";\nvar DROPDOWN_MENU_NAME = \"DropdownMenu\";\nvar [createDropdownMenuContext, createDropdownMenuScope] = createContextScope(\n  DROPDOWN_MENU_NAME,\n  [createMenuScope]\n);\nvar useMenuScope = createMenuScope();\nvar [DropdownMenuProvider, useDropdownMenuContext] = createDropdownMenuContext(DROPDOWN_MENU_NAME);\nvar DropdownMenu = (props) => {\n  const {\n    __scopeDropdownMenu,\n    children,\n    dir,\n    open: openProp,\n    defaultOpen,\n    onOpenChange,\n    modal = true\n  } = props;\n  const menuScope = useMenuScope(__scopeDropdownMenu);\n  const triggerRef = React.useRef(null);\n  const [open = false, setOpen] = useControllableState({\n    prop: openProp,\n    defaultProp: defaultOpen,\n    onChange: onOpenChange\n  });\n  return /* @__PURE__ */ jsx(\n    DropdownMenuProvider,\n    {\n      scope: __scopeDropdownMenu,\n      triggerId: useId(),\n      triggerRef,\n      contentId: useId(),\n      open,\n      onOpenChange: setOpen,\n      onOpenToggle: React.useCallback(() => setOpen((prevOpen) => !prevOpen), [setOpen]),\n      modal,\n      children: /* @__PURE__ */ jsx(MenuPrimitive.Root, { ...menuScope, open, onOpenChange: setOpen, dir, modal, children })\n    }\n  );\n};\nDropdownMenu.displayName = DROPDOWN_MENU_NAME;\nvar TRIGGER_NAME = \"DropdownMenuTrigger\";\nvar DropdownMenuTrigger = React.forwardRef(\n  (props, forwardedRef) => {\n    const { __scopeDropdownMenu, disabled = false, ...triggerProps } = props;\n    const context = useDropdownMenuContext(TRIGGER_NAME, __scopeDropdownMenu);\n    const menuScope = useMenuScope(__scopeDropdownMenu);\n    return /* @__PURE__ */ jsx(MenuPrimitive.Anchor, { asChild: true, ...menuScope, children: /* @__PURE__ */ jsx(\n      Primitive.button,\n      {\n        type: \"button\",\n        id: context.triggerId,\n        \"aria-haspopup\": \"menu\",\n        \"aria-expanded\": context.open,\n        \"aria-controls\": context.open ? context.contentId : void 0,\n        \"data-state\": context.open ? \"open\" : \"closed\",\n        \"data-disabled\": disabled ? \"\" : void 0,\n        disabled,\n        ...triggerProps,\n        ref: composeRefs(forwardedRef, context.triggerRef),\n        onPointerDown: composeEventHandlers(props.onPointerDown, (event) => {\n          if (!disabled && event.button === 0 && event.ctrlKey === false) {\n            context.onOpenToggle();\n            if (!context.open) event.preventDefault();\n          }\n        }),\n        onKeyDown: composeEventHandlers(props.onKeyDown, (event) => {\n          if (disabled) return;\n          if ([\"Enter\", \" \"].includes(event.key)) context.onOpenToggle();\n          if (event.key === \"ArrowDown\") context.onOpenChange(true);\n          if ([\"Enter\", \" \", \"ArrowDown\"].includes(event.key)) event.preventDefault();\n        })\n      }\n    ) });\n  }\n);\nDropdownMenuTrigger.displayName = TRIGGER_NAME;\nvar PORTAL_NAME = \"DropdownMenuPortal\";\nvar DropdownMenuPortal = (props) => {\n  const { __scopeDropdownMenu, ...portalProps } = props;\n  const menuScope = useMenuScope(__scopeDropdownMenu);\n  return /* @__PURE__ */ jsx(MenuPrimitive.Portal, { ...menuScope, ...portalProps });\n};\nDropdownMenuPortal.displayName = PORTAL_NAME;\nvar CONTENT_NAME = \"DropdownMenuContent\";\nvar DropdownMenuContent = React.forwardRef(\n  (props, forwardedRef) => {\n    const { __scopeDropdownMenu, ...contentProps } = props;\n    const context = useDropdownMenuContext(CONTENT_NAME, __scopeDropdownMenu);\n    const menuScope = useMenuScope(__scopeDropdownMenu);\n    const hasInteractedOutsideRef = React.useRef(false);\n    return /* @__PURE__ */ jsx(\n      MenuPrimitive.Content,\n      {\n        id: context.contentId,\n        \"aria-labelledby\": context.triggerId,\n        ...menuScope,\n        ...contentProps,\n        ref: forwardedRef,\n        onCloseAutoFocus: composeEventHandlers(props.onCloseAutoFocus, (event) => {\n          if (!hasInteractedOutsideRef.current) context.triggerRef.current?.focus();\n          hasInteractedOutsideRef.current = false;\n          event.preventDefault();\n        }),\n        onInteractOutside: composeEventHandlers(props.onInteractOutside, (event) => {\n          const originalEvent = event.detail.originalEvent;\n          const ctrlLeftClick = originalEvent.button === 0 && originalEvent.ctrlKey === true;\n          const isRightClick = originalEvent.button === 2 || ctrlLeftClick;\n          if (!context.modal || isRightClick) hasInteractedOutsideRef.current = true;\n        }),\n        style: {\n          ...props.style,\n          // re-namespace exposed content custom properties\n          ...{\n            \"--radix-dropdown-menu-content-transform-origin\": \"var(--radix-popper-transform-origin)\",\n            \"--radix-dropdown-menu-content-available-width\": \"var(--radix-popper-available-width)\",\n            \"--radix-dropdown-menu-content-available-height\": \"var(--radix-popper-available-height)\",\n            \"--radix-dropdown-menu-trigger-width\": \"var(--radix-popper-anchor-width)\",\n            \"--radix-dropdown-menu-trigger-height\": \"var(--radix-popper-anchor-height)\"\n          }\n        }\n      }\n    );\n  }\n);\nDropdownMenuContent.displayName = CONTENT_NAME;\nvar GROUP_NAME = \"DropdownMenuGroup\";\nvar DropdownMenuGroup = React.forwardRef(\n  (props, forwardedRef) => {\n    const { __scopeDropdownMenu, ...groupProps } = props;\n    const menuScope = useMenuScope(__scopeDropdownMenu);\n    return /* @__PURE__ */ jsx(MenuPrimitive.Group, { ...menuScope, ...groupProps, ref: forwardedRef });\n  }\n);\nDropdownMenuGroup.displayName = GROUP_NAME;\nvar LABEL_NAME = \"DropdownMenuLabel\";\nvar DropdownMenuLabel = React.forwardRef(\n  (props, forwardedRef) => {\n    const { __scopeDropdownMenu, ...labelProps } = props;\n    const menuScope = useMenuScope(__scopeDropdownMenu);\n    return /* @__PURE__ */ jsx(MenuPrimitive.Label, { ...menuScope, ...labelProps, ref: forwardedRef });\n  }\n);\nDropdownMenuLabel.displayName = LABEL_NAME;\nvar ITEM_NAME = \"DropdownMenuItem\";\nvar DropdownMenuItem = React.forwardRef(\n  (props, forwardedRef) => {\n    const { __scopeDropdownMenu, ...itemProps } = props;\n    const menuScope = useMenuScope(__scopeDropdownMenu);\n    return /* @__PURE__ */ jsx(MenuPrimitive.Item, { ...menuScope, ...itemProps, ref: forwardedRef });\n  }\n);\nDropdownMenuItem.displayName = ITEM_NAME;\nvar CHECKBOX_ITEM_NAME = \"DropdownMenuCheckboxItem\";\nvar DropdownMenuCheckboxItem = React.forwardRef((props, forwardedRef) => {\n  const { __scopeDropdownMenu, ...checkboxItemProps } = props;\n  const menuScope = useMenuScope(__scopeDropdownMenu);\n  return /* @__PURE__ */ jsx(MenuPrimitive.CheckboxItem, { ...menuScope, ...checkboxItemProps, ref: forwardedRef });\n});\nDropdownMenuCheckboxItem.displayName = CHECKBOX_ITEM_NAME;\nvar RADIO_GROUP_NAME = \"DropdownMenuRadioGroup\";\nvar DropdownMenuRadioGroup = React.forwardRef((props, forwardedRef) => {\n  const { __scopeDropdownMenu, ...radioGroupProps } = props;\n  const menuScope = useMenuScope(__scopeDropdownMenu);\n  return /* @__PURE__ */ jsx(MenuPrimitive.RadioGroup, { ...menuScope, ...radioGroupProps, ref: forwardedRef });\n});\nDropdownMenuRadioGroup.displayName = RADIO_GROUP_NAME;\nvar RADIO_ITEM_NAME = \"DropdownMenuRadioItem\";\nvar DropdownMenuRadioItem = React.forwardRef((props, forwardedRef) => {\n  const { __scopeDropdownMenu, ...radioItemProps } = props;\n  const menuScope = useMenuScope(__scopeDropdownMenu);\n  return /* @__PURE__ */ jsx(MenuPrimitive.RadioItem, { ...menuScope, ...radioItemProps, ref: forwardedRef });\n});\nDropdownMenuRadioItem.displayName = RADIO_ITEM_NAME;\nvar INDICATOR_NAME = \"DropdownMenuItemIndicator\";\nvar DropdownMenuItemIndicator = React.forwardRef((props, forwardedRef) => {\n  const { __scopeDropdownMenu, ...itemIndicatorProps } = props;\n  const menuScope = useMenuScope(__scopeDropdownMenu);\n  return /* @__PURE__ */ jsx(MenuPrimitive.ItemIndicator, { ...menuScope, ...itemIndicatorProps, ref: forwardedRef });\n});\nDropdownMenuItemIndicator.displayName = INDICATOR_NAME;\nvar SEPARATOR_NAME = \"DropdownMenuSeparator\";\nvar DropdownMenuSeparator = React.forwardRef((props, forwardedRef) => {\n  const { __scopeDropdownMenu, ...separatorProps } = props;\n  const menuScope = useMenuScope(__scopeDropdownMenu);\n  return /* @__PURE__ */ jsx(MenuPrimitive.Separator, { ...menuScope, ...separatorProps, ref: forwardedRef });\n});\nDropdownMenuSeparator.displayName = SEPARATOR_NAME;\nvar ARROW_NAME = \"DropdownMenuArrow\";\nvar DropdownMenuArrow = React.forwardRef(\n  (props, forwardedRef) => {\n    const { __scopeDropdownMenu, ...arrowProps } = props;\n    const menuScope = useMenuScope(__scopeDropdownMenu);\n    return /* @__PURE__ */ jsx(MenuPrimitive.Arrow, { ...menuScope, ...arrowProps, ref: forwardedRef });\n  }\n);\nDropdownMenuArrow.displayName = ARROW_NAME;\nvar DropdownMenuSub = (props) => {\n  const { __scopeDropdownMenu, children, open: openProp, onOpenChange, defaultOpen } = props;\n  const menuScope = useMenuScope(__scopeDropdownMenu);\n  const [open = false, setOpen] = useControllableState({\n    prop: openProp,\n    defaultProp: defaultOpen,\n    onChange: onOpenChange\n  });\n  return /* @__PURE__ */ jsx(MenuPrimitive.Sub, { ...menuScope, open, onOpenChange: setOpen, children });\n};\nvar SUB_TRIGGER_NAME = \"DropdownMenuSubTrigger\";\nvar DropdownMenuSubTrigger = React.forwardRef((props, forwardedRef) => {\n  const { __scopeDropdownMenu, ...subTriggerProps } = props;\n  const menuScope = useMenuScope(__scopeDropdownMenu);\n  return /* @__PURE__ */ jsx(MenuPrimitive.SubTrigger, { ...menuScope, ...subTriggerProps, ref: forwardedRef });\n});\nDropdownMenuSubTrigger.displayName = SUB_TRIGGER_NAME;\nvar SUB_CONTENT_NAME = \"DropdownMenuSubContent\";\nvar DropdownMenuSubContent = React.forwardRef((props, forwardedRef) => {\n  const { __scopeDropdownMenu, ...subContentProps } = props;\n  const menuScope = useMenuScope(__scopeDropdownMenu);\n  return /* @__PURE__ */ jsx(\n    MenuPrimitive.SubContent,\n    {\n      ...menuScope,\n      ...subContentProps,\n      ref: forwardedRef,\n      style: {\n        ...props.style,\n        // re-namespace exposed content custom properties\n        ...{\n          \"--radix-dropdown-menu-content-transform-origin\": \"var(--radix-popper-transform-origin)\",\n          \"--radix-dropdown-menu-content-available-width\": \"var(--radix-popper-available-width)\",\n          \"--radix-dropdown-menu-content-available-height\": \"var(--radix-popper-available-height)\",\n          \"--radix-dropdown-menu-trigger-width\": \"var(--radix-popper-anchor-width)\",\n          \"--radix-dropdown-menu-trigger-height\": \"var(--radix-popper-anchor-height)\"\n        }\n      }\n    }\n  );\n});\nDropdownMenuSubContent.displayName = SUB_CONTENT_NAME;\nvar Root2 = DropdownMenu;\nvar Trigger = DropdownMenuTrigger;\nvar Portal2 = DropdownMenuPortal;\nvar Content2 = DropdownMenuContent;\nvar Group2 = DropdownMenuGroup;\nvar Label2 = DropdownMenuLabel;\nvar Item2 = DropdownMenuItem;\nvar CheckboxItem2 = DropdownMenuCheckboxItem;\nvar RadioGroup2 = DropdownMenuRadioGroup;\nvar RadioItem2 = DropdownMenuRadioItem;\nvar ItemIndicator2 = DropdownMenuItemIndicator;\nvar Separator2 = DropdownMenuSeparator;\nvar Arrow2 = DropdownMenuArrow;\nvar Sub2 = DropdownMenuSub;\nvar SubTrigger2 = DropdownMenuSubTrigger;\nvar SubContent2 = DropdownMenuSubContent;\nexport {\n  Arrow2 as Arrow,\n  CheckboxItem2 as CheckboxItem,\n  Content2 as Content,\n  DropdownMenu,\n  DropdownMenuArrow,\n  DropdownMenuCheckboxItem,\n  DropdownMenuContent,\n  DropdownMenuGroup,\n  DropdownMenuItem,\n  DropdownMenuItemIndicator,\n  DropdownMenuLabel,\n  DropdownMenuPortal,\n  DropdownMenuRadioGroup,\n  DropdownMenuRadioItem,\n  DropdownMenuSeparator,\n  DropdownMenuSub,\n  DropdownMenuSubContent,\n  DropdownMenuSubTrigger,\n  DropdownMenuTrigger,\n  Group2 as Group,\n  Item2 as Item,\n  ItemIndicator2 as ItemIndicator,\n  Label2 as Label,\n  Portal2 as Portal,\n  RadioGroup2 as RadioGroup,\n  RadioItem2 as RadioItem,\n  Root2 as Root,\n  Separator2 as Separator,\n  Sub2 as Sub,\n  SubContent2 as SubContent,\n  SubTrigger2 as SubTrigger,\n  Trigger,\n  createDropdownMenuScope\n};\n//# sourceMappingURL=index.mjs.map\n","/*\n * Copyright 2025 New Vector Ltd\n *\n * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial\n * Please see LICENSE files in the repository root for full details.\n */\n\nimport React from \"react\";\nimport { Text } from \"../Typography/Text.tsx\";\nimport styles from \"./MenuTitle.module.css\";\nimport classnames from \"classnames\";\n\ninterface MenuTitleProps {\n  /**\n   * The title of the menu.\n   */\n  title: string;\n  /**\n   * The id of the menu title.\n   */\n  id?: string;\n  /**\n   * The CSS class.\n   */\n  className?: string;\n}\n\nexport const MenuTitle: React.FC<MenuTitleProps> = ({\n  title,\n  id,\n  className,\n}) => {\n  const classes = classnames(styles[\"menu-title\"], className);\n\n  return (\n    <Text as=\"h3\" id={id} className={classes} size=\"sm\" weight=\"semibold\">\n      {title}\n    </Text>\n  );\n};\n","/*\nCopyright 2023 New Vector Ltd.\n\nSPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial\nPlease see LICENSE files in the repository root for full details.\n*/\n\nimport classnames from \"classnames\";\nimport React, {\n  ComponentPropsWithoutRef,\n  ReactNode,\n  forwardRef,\n  useId,\n} from \"react\";\nimport styles from \"./FloatingMenu.module.css\";\nimport { MenuTitle } from \"./MenuTitle.tsx\";\n\ninterface Props extends ComponentPropsWithoutRef<\"div\"> {\n  /**\n   * The menu title.\n   */\n  title: string;\n  /**\n   * Whether to show the title. If false, the title will be hidden but still used as a label for screen readers.\n   */\n  showTitle?: boolean;\n  /**\n   * The CSS class.\n   */\n  className?: string;\n  /**\n   * The menu contents.\n   */\n  children: ReactNode;\n}\n\n/**\n * A menu in a floating box, as commonly seen on desktop.\n */\n// This an internal component not intended for export! Consumers should use it\n// via the Menu or ContextMenu components.\nexport const FloatingMenu = forwardRef<HTMLDivElement, Props>(\n  ({ title, showTitle = true, className, children, ...props }, ref) => {\n    const titleId = useId();\n    return (\n      <div\n        role=\"menu\"\n        ref={ref}\n        aria-label={showTitle ? undefined : title}\n        aria-labelledby={showTitle ? titleId : undefined}\n        className={classnames(className, styles.menu)}\n        {...props}\n      >\n        {showTitle && (\n          <MenuTitle className={styles.title} title={title} id={titleId} />\n        )}\n        {children}\n      </div>\n    );\n  },\n);\n\nFloatingMenu.displayName = \"FloatingMenu\";\n","// packages/react/context/src/createContext.tsx\nimport * as React from \"react\";\nimport { jsx } from \"react/jsx-runtime\";\nfunction createContext2(rootComponentName, defaultContext) {\n  const Context = React.createContext(defaultContext);\n  const Provider = (props) => {\n    const { children, ...context } = props;\n    const value = React.useMemo(() => context, Object.values(context));\n    return /* @__PURE__ */ jsx(Context.Provider, { value, children });\n  };\n  Provider.displayName = rootComponentName + \"Provider\";\n  function useContext2(consumerName) {\n    const context = React.useContext(Context);\n    if (context) return context;\n    if (defaultContext !== void 0) return defaultContext;\n    throw new Error(`\\`${consumerName}\\` must be used within \\`${rootComponentName}\\``);\n  }\n  return [Provider, useContext2];\n}\nfunction createContextScope(scopeName, createContextScopeDeps = []) {\n  let defaultContexts = [];\n  function createContext3(rootComponentName, defaultContext) {\n    const BaseContext = React.createContext(defaultContext);\n    const index = defaultContexts.length;\n    defaultContexts = [...defaultContexts, defaultContext];\n    const Provider = (props) => {\n      const { scope, children, ...context } = props;\n      const Context = scope?.[scopeName]?.[index] || BaseContext;\n      const value = React.useMemo(() => context, Object.values(context));\n      return /* @__PURE__ */ jsx(Context.Provider, { value, children });\n    };\n    Provider.displayName = rootComponentName + \"Provider\";\n    function useContext2(consumerName, scope) {\n      const Context = scope?.[scopeName]?.[index] || BaseContext;\n      const context = React.useContext(Context);\n      if (context) return context;\n      if (defaultContext !== void 0) return defaultContext;\n      throw new Error(`\\`${consumerName}\\` must be used within \\`${rootComponentName}\\``);\n    }\n    return [Provider, useContext2];\n  }\n  const createScope = () => {\n    const scopeContexts = defaultContexts.map((defaultContext) => {\n      return React.createContext(defaultContext);\n    });\n    return function useScope(scope) {\n      const contexts = scope?.[scopeName] || scopeContexts;\n      return React.useMemo(\n        () => ({ [`__scope${scopeName}`]: { ...scope, [scopeName]: contexts } }),\n        [scope, contexts]\n      );\n    };\n  };\n  createScope.scopeName = scopeName;\n  return [createContext3, composeContextScopes(createScope, ...createContextScopeDeps)];\n}\nfunction composeContextScopes(...scopes) {\n  const baseScope = scopes[0];\n  if (scopes.length === 1) return baseScope;\n  const createScope = () => {\n    const scopeHooks = scopes.map((createScope2) => ({\n      useScope: createScope2(),\n      scopeName: createScope2.scopeName\n    }));\n    return function useComposedScopes(overrideScopes) {\n      const nextScopes = scopeHooks.reduce((nextScopes2, { useScope, scopeName }) => {\n        const scopeProps = useScope(overrideScopes);\n        const currentScope = scopeProps[`__scope${scopeName}`];\n        return { ...nextScopes2, ...currentScope };\n      }, {});\n      return React.useMemo(() => ({ [`__scope${baseScope.scopeName}`]: nextScopes }), [nextScopes]);\n    };\n  };\n  createScope.scopeName = baseScope.scopeName;\n  return createScope;\n}\nexport {\n  createContext2 as createContext,\n  createContextScope\n};\n//# sourceMappingURL=index.mjs.map\n","\"use client\";\n\n// packages/react/dialog/src/Dialog.tsx\nimport * as React from \"react\";\nimport { composeEventHandlers } from \"@radix-ui/primitive\";\nimport { useComposedRefs } from \"@radix-ui/react-compose-refs\";\nimport { createContext, createContextScope } from \"@radix-ui/react-context\";\nimport { useId } from \"@radix-ui/react-id\";\nimport { useControllableState } from \"@radix-ui/react-use-controllable-state\";\nimport { DismissableLayer } from \"@radix-ui/react-dismissable-layer\";\nimport { FocusScope } from \"@radix-ui/react-focus-scope\";\nimport { Portal as PortalPrimitive } from \"@radix-ui/react-portal\";\nimport { Presence } from \"@radix-ui/react-presence\";\nimport { Primitive } from \"@radix-ui/react-primitive\";\nimport { useFocusGuards } from \"@radix-ui/react-focus-guards\";\nimport { RemoveScroll } from \"react-remove-scroll\";\nimport { hideOthers } from \"aria-hidden\";\nimport { Slot } from \"@radix-ui/react-slot\";\nimport { Fragment, jsx, jsxs } from \"react/jsx-runtime\";\nvar DIALOG_NAME = \"Dialog\";\nvar [createDialogContext, createDialogScope] = createContextScope(DIALOG_NAME);\nvar [DialogProvider, useDialogContext] = createDialogContext(DIALOG_NAME);\nvar Dialog = (props) => {\n  const {\n    __scopeDialog,\n    children,\n    open: openProp,\n    defaultOpen,\n    onOpenChange,\n    modal = true\n  } = props;\n  const triggerRef = React.useRef(null);\n  const contentRef = React.useRef(null);\n  const [open = false, setOpen] = useControllableState({\n    prop: openProp,\n    defaultProp: defaultOpen,\n    onChange: onOpenChange\n  });\n  return /* @__PURE__ */ jsx(\n    DialogProvider,\n    {\n      scope: __scopeDialog,\n      triggerRef,\n      contentRef,\n      contentId: useId(),\n      titleId: useId(),\n      descriptionId: useId(),\n      open,\n      onOpenChange: setOpen,\n      onOpenToggle: React.useCallback(() => setOpen((prevOpen) => !prevOpen), [setOpen]),\n      modal,\n      children\n    }\n  );\n};\nDialog.displayName = DIALOG_NAME;\nvar TRIGGER_NAME = \"DialogTrigger\";\nvar DialogTrigger = React.forwardRef(\n  (props, forwardedRef) => {\n    const { __scopeDialog, ...triggerProps } = props;\n    const context = useDialogContext(TRIGGER_NAME, __scopeDialog);\n    const composedTriggerRef = useComposedRefs(forwardedRef, context.triggerRef);\n    return /* @__PURE__ */ jsx(\n      Primitive.button,\n      {\n        type: \"button\",\n        \"aria-haspopup\": \"dialog\",\n        \"aria-expanded\": context.open,\n        \"aria-controls\": context.contentId,\n        \"data-state\": getState(context.open),\n        ...triggerProps,\n        ref: composedTriggerRef,\n        onClick: composeEventHandlers(props.onClick, context.onOpenToggle)\n      }\n    );\n  }\n);\nDialogTrigger.displayName = TRIGGER_NAME;\nvar PORTAL_NAME = \"DialogPortal\";\nvar [PortalProvider, usePortalContext] = createDialogContext(PORTAL_NAME, {\n  forceMount: void 0\n});\nvar DialogPortal = (props) => {\n  const { __scopeDialog, forceMount, children, container } = props;\n  const context = useDialogContext(PORTAL_NAME, __scopeDialog);\n  return /* @__PURE__ */ jsx(PortalProvider, { scope: __scopeDialog, forceMount, children: React.Children.map(children, (child) => /* @__PURE__ */ jsx(Presence, { present: forceMount || context.open, children: /* @__PURE__ */ jsx(PortalPrimitive, { asChild: true, container, children: child }) })) });\n};\nDialogPortal.displayName = PORTAL_NAME;\nvar OVERLAY_NAME = \"DialogOverlay\";\nvar DialogOverlay = React.forwardRef(\n  (props, forwardedRef) => {\n    const portalContext = usePortalContext(OVERLAY_NAME, props.__scopeDialog);\n    const { forceMount = portalContext.forceMount, ...overlayProps } = props;\n    const context = useDialogContext(OVERLAY_NAME, props.__scopeDialog);\n    return context.modal ? /* @__PURE__ */ jsx(Presence, { present: forceMount || context.open, children: /* @__PURE__ */ jsx(DialogOverlayImpl, { ...overlayProps, ref: forwardedRef }) }) : null;\n  }\n);\nDialogOverlay.displayName = OVERLAY_NAME;\nvar DialogOverlayImpl = React.forwardRef(\n  (props, forwardedRef) => {\n    const { __scopeDialog, ...overlayProps } = props;\n    const context = useDialogContext(OVERLAY_NAME, __scopeDialog);\n    return (\n      // Make sure `Content` is scrollable even when it doesn't live inside `RemoveScroll`\n      // ie. when `Overlay` and `Content` are siblings\n      /* @__PURE__ */ jsx(RemoveScroll, { as: Slot, allowPinchZoom: true, shards: [context.contentRef], children: /* @__PURE__ */ jsx(\n        Primitive.div,\n        {\n          \"data-state\": getState(context.open),\n          ...overlayProps,\n          ref: forwardedRef,\n          style: { pointerEvents: \"auto\", ...overlayProps.style }\n        }\n      ) })\n    );\n  }\n);\nvar CONTENT_NAME = \"DialogContent\";\nvar DialogContent = React.forwardRef(\n  (props, forwardedRef) => {\n    const portalContext = usePortalContext(CONTENT_NAME, props.__scopeDialog);\n    const { forceMount = portalContext.forceMount, ...contentProps } = props;\n    const context = useDialogContext(CONTENT_NAME, props.__scopeDialog);\n    return /* @__PURE__ */ jsx(Presence, { present: forceMount || context.open, children: context.modal ? /* @__PURE__ */ jsx(DialogContentModal, { ...contentProps, ref: forwardedRef }) : /* @__PURE__ */ jsx(DialogContentNonModal, { ...contentProps, ref: forwardedRef }) });\n  }\n);\nDialogContent.displayName = CONTENT_NAME;\nvar DialogContentModal = React.forwardRef(\n  (props, forwardedRef) => {\n    const context = useDialogContext(CONTENT_NAME, props.__scopeDialog);\n    const contentRef = React.useRef(null);\n    const composedRefs = useComposedRefs(forwardedRef, context.contentRef, contentRef);\n    React.useEffect(() => {\n      const content = contentRef.current;\n      if (content) return hideOthers(content);\n    }, []);\n    return /* @__PURE__ */ jsx(\n      DialogContentImpl,\n      {\n        ...props,\n        ref: composedRefs,\n        trapFocus: context.open,\n        disableOutsidePointerEvents: true,\n        onCloseAutoFocus: composeEventHandlers(props.onCloseAutoFocus, (event) => {\n          event.preventDefault();\n          context.triggerRef.current?.focus();\n        }),\n        onPointerDownOutside: composeEventHandlers(props.onPointerDownOutside, (event) => {\n          const originalEvent = event.detail.originalEvent;\n          const ctrlLeftClick = originalEvent.button === 0 && originalEvent.ctrlKey === true;\n          const isRightClick = originalEvent.button === 2 || ctrlLeftClick;\n          if (isRightClick) event.preventDefault();\n        }),\n        onFocusOutside: composeEventHandlers(\n          props.onFocusOutside,\n          (event) => event.preventDefault()\n        )\n      }\n    );\n  }\n);\nvar DialogContentNonModal = React.forwardRef(\n  (props, forwardedRef) => {\n    const context = useDialogContext(CONTENT_NAME, props.__scopeDialog);\n    const hasInteractedOutsideRef = React.useRef(false);\n    const hasPointerDownOutsideRef = React.useRef(false);\n    return /* @__PURE__ */ jsx(\n      DialogContentImpl,\n      {\n        ...props,\n        ref: forwardedRef,\n        trapFocus: false,\n        disableOutsidePointerEvents: false,\n        onCloseAutoFocus: (event) => {\n          props.onCloseAutoFocus?.(event);\n          if (!event.defaultPrevented) {\n            if (!hasInteractedOutsideRef.current) context.triggerRef.current?.focus();\n            event.preventDefault();\n          }\n          hasInteractedOutsideRef.current = false;\n          hasPointerDownOutsideRef.current = false;\n        },\n        onInteractOutside: (event) => {\n          props.onInteractOutside?.(event);\n          if (!event.defaultPrevented) {\n            hasInteractedOutsideRef.current = true;\n            if (event.detail.originalEvent.type === \"pointerdown\") {\n              hasPointerDownOutsideRef.current = true;\n            }\n          }\n          const target = event.target;\n          const targetIsTrigger = context.triggerRef.current?.contains(target);\n          if (targetIsTrigger) event.preventDefault();\n          if (event.detail.originalEvent.type === \"focusin\" && hasPointerDownOutsideRef.current) {\n            event.preventDefault();\n          }\n        }\n      }\n    );\n  }\n);\nvar DialogContentImpl = React.forwardRef(\n  (props, forwardedRef) => {\n    const { __scopeDialog, trapFocus, onOpenAutoFocus, onCloseAutoFocus, ...contentProps } = props;\n    const context = useDialogContext(CONTENT_NAME, __scopeDialog);\n    const contentRef = React.useRef(null);\n    const composedRefs = useComposedRefs(forwardedRef, contentRef);\n    useFocusGuards();\n    return /* @__PURE__ */ jsxs(Fragment, { children: [\n      /* @__PURE__ */ jsx(\n        FocusScope,\n        {\n          asChild: true,\n          loop: true,\n          trapped: trapFocus,\n          onMountAutoFocus: onOpenAutoFocus,\n          onUnmountAutoFocus: onCloseAutoFocus,\n          children: /* @__PURE__ */ jsx(\n            DismissableLayer,\n            {\n              role: \"dialog\",\n              id: context.contentId,\n              \"aria-describedby\": context.descriptionId,\n              \"aria-labelledby\": context.titleId,\n              \"data-state\": getState(context.open),\n              ...contentProps,\n              ref: composedRefs,\n              onDismiss: () => context.onOpenChange(false)\n            }\n          )\n        }\n      ),\n      /* @__PURE__ */ jsxs(Fragment, { children: [\n        /* @__PURE__ */ jsx(TitleWarning, { titleId: context.titleId }),\n        /* @__PURE__ */ jsx(DescriptionWarning, { contentRef, descriptionId: context.descriptionId })\n      ] })\n    ] });\n  }\n);\nvar TITLE_NAME = \"DialogTitle\";\nvar DialogTitle = React.forwardRef(\n  (props, forwardedRef) => {\n    const { __scopeDialog, ...titleProps } = props;\n    const context = useDialogContext(TITLE_NAME, __scopeDialog);\n    return /* @__PURE__ */ jsx(Primitive.h2, { id: context.titleId, ...titleProps, ref: forwardedRef });\n  }\n);\nDialogTitle.displayName = TITLE_NAME;\nvar DESCRIPTION_NAME = \"DialogDescription\";\nvar DialogDescription = React.forwardRef(\n  (props, forwardedRef) => {\n    const { __scopeDialog, ...descriptionProps } = props;\n    const context = useDialogContext(DESCRIPTION_NAME, __scopeDialog);\n    return /* @__PURE__ */ jsx(Primitive.p, { id: context.descriptionId, ...descriptionProps, ref: forwardedRef });\n  }\n);\nDialogDescription.displayName = DESCRIPTION_NAME;\nvar CLOSE_NAME = \"DialogClose\";\nvar DialogClose = React.forwardRef(\n  (props, forwardedRef) => {\n    const { __scopeDialog, ...closeProps } = props;\n    const context = useDialogContext(CLOSE_NAME, __scopeDialog);\n    return /* @__PURE__ */ jsx(\n      Primitive.button,\n      {\n        type: \"button\",\n        ...closeProps,\n        ref: forwardedRef,\n        onClick: composeEventHandlers(props.onClick, () => context.onOpenChange(false))\n      }\n    );\n  }\n);\nDialogClose.displayName = CLOSE_NAME;\nfunction getState(open) {\n  return open ? \"open\" : \"closed\";\n}\nvar TITLE_WARNING_NAME = \"DialogTitleWarning\";\nvar [WarningProvider, useWarningContext] = createContext(TITLE_WARNING_NAME, {\n  contentName: CONTENT_NAME,\n  titleName: TITLE_NAME,\n  docsSlug: \"dialog\"\n});\nvar TitleWarning = ({ titleId }) => {\n  const titleWarningContext = useWarningContext(TITLE_WARNING_NAME);\n  const MESSAGE = `\\`${titleWarningContext.contentName}\\` requires a \\`${titleWarningContext.titleName}\\` for the component to be accessible for screen reader users.\n\nIf you want to hide the \\`${titleWarningContext.titleName}\\`, you can wrap it with our VisuallyHidden component.\n\nFor more information, see https://radix-ui.com/primitives/docs/components/${titleWarningContext.docsSlug}`;\n  React.useEffect(() => {\n    if (titleId) {\n      const hasTitle = document.getElementById(titleId);\n      if (!hasTitle) console.error(MESSAGE);\n    }\n  }, [MESSAGE, titleId]);\n  return null;\n};\nvar DESCRIPTION_WARNING_NAME = \"DialogDescriptionWarning\";\nvar DescriptionWarning = ({ contentRef, descriptionId }) => {\n  const descriptionWarningContext = useWarningContext(DESCRIPTION_WARNING_NAME);\n  const MESSAGE = `Warning: Missing \\`Description\\` or \\`aria-describedby={undefined}\\` for {${descriptionWarningContext.contentName}}.`;\n  React.useEffect(() => {\n    const describedById = contentRef.current?.getAttribute(\"aria-describedby\");\n    if (descriptionId && describedById) {\n      const hasDescription = document.getElementById(descriptionId);\n      if (!hasDescription) console.warn(MESSAGE);\n    }\n  }, [MESSAGE, contentRef, descriptionId]);\n  return null;\n};\nvar Root = Dialog;\nvar Trigger = DialogTrigger;\nvar Portal = DialogPortal;\nvar Overlay = DialogOverlay;\nvar Content = DialogContent;\nvar Title = DialogTitle;\nvar Description = DialogDescription;\nvar Close = DialogClose;\nexport {\n  Close,\n  Content,\n  Description,\n  Dialog,\n  DialogClose,\n  DialogContent,\n  DialogDescription,\n  DialogOverlay,\n  DialogPortal,\n  DialogTitle,\n  DialogTrigger,\n  Overlay,\n  Portal,\n  Root,\n  Title,\n  Trigger,\n  WarningProvider,\n  createDialogScope\n};\n//# sourceMappingURL=index.mjs.map\n","'use client';\nfunction __insertCSS(code) {\n  if (!code || typeof document == 'undefined') return\n  let head = document.head || document.getElementsByTagName('head')[0]\n  let style = document.createElement('style')\n  style.type = 'text/css'\n  head.appendChild(style)\n  ;style.styleSheet ? (style.styleSheet.cssText = code) : style.appendChild(document.createTextNode(code))\n}\n\nimport * as DialogPrimitive from '@radix-ui/react-dialog';\nimport * as React from 'react';\nimport React__default, { useLayoutEffect, useEffect, useMemo } from 'react';\n\nconst DrawerContext = React__default.createContext({\n    drawerRef: {\n        current: null\n    },\n    overlayRef: {\n        current: null\n    },\n    onPress: ()=>{},\n    onRelease: ()=>{},\n    onDrag: ()=>{},\n    onNestedDrag: ()=>{},\n    onNestedOpenChange: ()=>{},\n    onNestedRelease: ()=>{},\n    openProp: undefined,\n    dismissible: false,\n    isOpen: false,\n    isDragging: false,\n    keyboardIsOpen: {\n        current: false\n    },\n    snapPointsOffset: null,\n    snapPoints: null,\n    handleOnly: false,\n    modal: false,\n    shouldFade: false,\n    activeSnapPoint: null,\n    onOpenChange: ()=>{},\n    setActiveSnapPoint: ()=>{},\n    closeDrawer: ()=>{},\n    direction: 'bottom',\n    shouldAnimate: {\n        current: true\n    },\n    shouldScaleBackground: false,\n    setBackgroundColorOnScale: true,\n    noBodyStyles: false,\n    container: null,\n    autoFocus: false\n});\nconst useDrawerContext = ()=>{\n    const context = React__default.useContext(DrawerContext);\n    if (!context) {\n        throw new Error('useDrawerContext must be used within a Drawer.Root');\n    }\n    return context;\n};\n\n__insertCSS(\"[data-vaul-drawer]{touch-action:none;will-change:transform;transition:transform .5s cubic-bezier(.32, .72, 0, 1);animation-duration:.5s;animation-timing-function:cubic-bezier(0.32,0.72,0,1)}[data-vaul-drawer][data-vaul-snap-points=false][data-vaul-drawer-direction=bottom][data-state=open]{animation-name:slideFromBottom}[data-vaul-drawer][data-vaul-snap-points=false][data-vaul-drawer-direction=bottom][data-state=closed]{animation-name:slideToBottom}[data-vaul-drawer][data-vaul-snap-points=false][data-vaul-drawer-direction=top][data-state=open]{animation-name:slideFromTop}[data-vaul-drawer][data-vaul-snap-points=false][data-vaul-drawer-direction=top][data-state=closed]{animation-name:slideToTop}[data-vaul-drawer][data-vaul-snap-points=false][data-vaul-drawer-direction=left][data-state=open]{animation-name:slideFromLeft}[data-vaul-drawer][data-vaul-snap-points=false][data-vaul-drawer-direction=left][data-state=closed]{animation-name:slideToLeft}[data-vaul-drawer][data-vaul-snap-points=false][data-vaul-drawer-direction=right][data-state=open]{animation-name:slideFromRight}[data-vaul-drawer][data-vaul-snap-points=false][data-vaul-drawer-direction=right][data-state=closed]{animation-name:slideToRight}[data-vaul-drawer][data-vaul-snap-points=true][data-vaul-drawer-direction=bottom]{transform:translate3d(0,var(--initial-transform,100%),0)}[data-vaul-drawer][data-vaul-snap-points=true][data-vaul-drawer-direction=top]{transform:translate3d(0,calc(var(--initial-transform,100%) * -1),0)}[data-vaul-drawer][data-vaul-snap-points=true][data-vaul-drawer-direction=left]{transform:translate3d(calc(var(--initial-transform,100%) * -1),0,0)}[data-vaul-drawer][data-vaul-snap-points=true][data-vaul-drawer-direction=right]{transform:translate3d(var(--initial-transform,100%),0,0)}[data-vaul-drawer][data-vaul-delayed-snap-points=true][data-vaul-drawer-direction=top]{transform:translate3d(0,var(--snap-point-height,0),0)}[data-vaul-drawer][data-vaul-delayed-snap-points=true][data-vaul-drawer-direction=bottom]{transform:translate3d(0,var(--snap-point-height,0),0)}[data-vaul-drawer][data-vaul-delayed-snap-points=true][data-vaul-drawer-direction=left]{transform:translate3d(var(--snap-point-height,0),0,0)}[data-vaul-drawer][data-vaul-delayed-snap-points=true][data-vaul-drawer-direction=right]{transform:translate3d(var(--snap-point-height,0),0,0)}[data-vaul-overlay][data-vaul-snap-points=false]{animation-duration:.5s;animation-timing-function:cubic-bezier(0.32,0.72,0,1)}[data-vaul-overlay][data-vaul-snap-points=false][data-state=open]{animation-name:fadeIn}[data-vaul-overlay][data-state=closed]{animation-name:fadeOut}[data-vaul-animate=false]{animation:none!important}[data-vaul-overlay][data-vaul-snap-points=true]{opacity:0;transition:opacity .5s cubic-bezier(.32, .72, 0, 1)}[data-vaul-overlay][data-vaul-snap-points=true]{opacity:1}[data-vaul-drawer]:not([data-vaul-custom-container=true])::after{content:'';position:absolute;background:inherit;background-color:inherit}[data-vaul-drawer][data-vaul-drawer-direction=top]::after{top:initial;bottom:100%;left:0;right:0;height:200%}[data-vaul-drawer][data-vaul-drawer-direction=bottom]::after{top:100%;bottom:initial;left:0;right:0;height:200%}[data-vaul-drawer][data-vaul-drawer-direction=left]::after{left:initial;right:100%;top:0;bottom:0;width:200%}[data-vaul-drawer][data-vaul-drawer-direction=right]::after{left:100%;right:initial;top:0;bottom:0;width:200%}[data-vaul-overlay][data-vaul-snap-points=true]:not([data-vaul-snap-points-overlay=true]):not(\\n[data-state=closed]\\n){opacity:0}[data-vaul-overlay][data-vaul-snap-points-overlay=true]{opacity:1}[data-vaul-handle]{display:block;position:relative;opacity:.7;background:#e2e2e4;margin-left:auto;margin-right:auto;height:5px;width:32px;border-radius:1rem;touch-action:pan-y}[data-vaul-handle]:active,[data-vaul-handle]:hover{opacity:1}[data-vaul-handle-hitarea]{position:absolute;left:50%;top:50%;transform:translate(-50%,-50%);width:max(100%,2.75rem);height:max(100%,2.75rem);touch-action:inherit}@media (hover:hover) and (pointer:fine){[data-vaul-drawer]{user-select:none}}@media (pointer:fine){[data-vaul-handle-hitarea]:{width:100%;height:100%}}@keyframes fadeIn{from{opacity:0}to{opacity:1}}@keyframes fadeOut{to{opacity:0}}@keyframes slideFromBottom{from{transform:translate3d(0,var(--initial-transform,100%),0)}to{transform:translate3d(0,0,0)}}@keyframes slideToBottom{to{transform:translate3d(0,var(--initial-transform,100%),0)}}@keyframes slideFromTop{from{transform:translate3d(0,calc(var(--initial-transform,100%) * -1),0)}to{transform:translate3d(0,0,0)}}@keyframes slideToTop{to{transform:translate3d(0,calc(var(--initial-transform,100%) * -1),0)}}@keyframes slideFromLeft{from{transform:translate3d(calc(var(--initial-transform,100%) * -1),0,0)}to{transform:translate3d(0,0,0)}}@keyframes slideToLeft{to{transform:translate3d(calc(var(--initial-transform,100%) * -1),0,0)}}@keyframes slideFromRight{from{transform:translate3d(var(--initial-transform,100%),0,0)}to{transform:translate3d(0,0,0)}}@keyframes slideToRight{to{transform:translate3d(var(--initial-transform,100%),0,0)}}\");\n\nfunction isMobileFirefox() {\n    const userAgent = navigator.userAgent;\n    return typeof window !== 'undefined' && (/Firefox/.test(userAgent) && /Mobile/.test(userAgent) || // Android Firefox\n    /FxiOS/.test(userAgent) // iOS Firefox\n    );\n}\nfunction isMac() {\n    return testPlatform(/^Mac/);\n}\nfunction isIPhone() {\n    return testPlatform(/^iPhone/);\n}\nfunction isSafari() {\n    return /^((?!chrome|android).)*safari/i.test(navigator.userAgent);\n}\nfunction isIPad() {\n    return testPlatform(/^iPad/) || // iPadOS 13 lies and says it's a Mac, but we can distinguish by detecting touch support.\n    isMac() && navigator.maxTouchPoints > 1;\n}\nfunction isIOS() {\n    return isIPhone() || isIPad();\n}\nfunction testPlatform(re) {\n    return typeof window !== 'undefined' && window.navigator != null ? re.test(window.navigator.platform) : undefined;\n}\n\n// This code comes from https://github.com/adobe/react-spectrum/blob/main/packages/%40react-aria/overlays/src/usePreventScroll.ts\nconst KEYBOARD_BUFFER = 24;\nconst useIsomorphicLayoutEffect = typeof window !== 'undefined' ? useLayoutEffect : useEffect;\nfunction chain$1(...callbacks) {\n    return (...args)=>{\n        for (let callback of callbacks){\n            if (typeof callback === 'function') {\n                callback(...args);\n            }\n        }\n    };\n}\n// @ts-ignore\nconst visualViewport = typeof document !== 'undefined' && window.visualViewport;\nfunction isScrollable(node) {\n    let style = window.getComputedStyle(node);\n    return /(auto|scroll)/.test(style.overflow + style.overflowX + style.overflowY);\n}\nfunction getScrollParent(node) {\n    if (isScrollable(node)) {\n        node = node.parentElement;\n    }\n    while(node && !isScrollable(node)){\n        node = node.parentElement;\n    }\n    return node || document.scrollingElement || document.documentElement;\n}\n// HTML input types that do not cause the software keyboard to appear.\nconst nonTextInputTypes = new Set([\n    'checkbox',\n    'radio',\n    'range',\n    'color',\n    'file',\n    'image',\n    'button',\n    'submit',\n    'reset'\n]);\n// The number of active usePreventScroll calls. Used to determine whether to revert back to the original page style/scroll position\nlet preventScrollCount = 0;\nlet restore;\n/**\n * Prevents scrolling on the document body on mount, and\n * restores it on unmount. Also ensures that content does not\n * shift due to the scrollbars disappearing.\n */ function usePreventScroll(options = {}) {\n    let { isDisabled } = options;\n    useIsomorphicLayoutEffect(()=>{\n        if (isDisabled) {\n            return;\n        }\n        preventScrollCount++;\n        if (preventScrollCount === 1) {\n            if (isIOS()) {\n                restore = preventScrollMobileSafari();\n            }\n        }\n        return ()=>{\n            preventScrollCount--;\n            if (preventScrollCount === 0) {\n                restore == null ? void 0 : restore();\n            }\n        };\n    }, [\n        isDisabled\n    ]);\n}\n// Mobile Safari is a whole different beast. Even with overflow: hidden,\n// it still scrolls the page in many situations:\n//\n// 1. When the bottom toolbar and address bar are collapsed, page scrolling is always allowed.\n// 2. When the keyboard is visible, the viewport does not resize. Instead, the keyboard covers part of\n//    it, so it becomes scrollable.\n// 3. When tapping on an input, the page always scrolls so that the input is centered in the visual viewport.\n//    This may cause even fixed position elements to scroll off the screen.\n// 4. When using the next/previous buttons in the keyboard to navigate between inputs, the whole page always\n//    scrolls, even if the input is inside a nested scrollable element that could be scrolled instead.\n//\n// In order to work around these cases, and prevent scrolling without jankiness, we do a few things:\n//\n// 1. Prevent default on `touchmove` events that are not in a scrollable element. This prevents touch scrolling\n//    on the window.\n// 2. Prevent default on `touchmove` events inside a scrollable element when the scroll position is at the\n//    top or bottom. This avoids the whole page scrolling instead, but does prevent overscrolling.\n// 3. Prevent default on `touchend` events on input elements and handle focusing the element ourselves.\n// 4. When focusing an input, apply a transform to trick Safari into thinking the input is at the top\n//    of the page, which prevents it from scrolling the page. After the input is focused, scroll the element\n//    into view ourselves, without scrolling the whole page.\n// 5. Offset the body by the scroll position using a negative margin and scroll to the top. This should appear the\n//    same visually, but makes the actual scroll position always zero. This is required to make all of the\n//    above work or Safari will still try to scroll the page when focusing an input.\n// 6. As a last resort, handle window scroll events, and scroll back to the top. This can happen when attempting\n//    to navigate to an input with the next/previous buttons that's outside a modal.\nfunction preventScrollMobileSafari() {\n    let scrollable;\n    let lastY = 0;\n    let onTouchStart = (e)=>{\n        // Store the nearest scrollable parent element from the element that the user touched.\n        scrollable = getScrollParent(e.target);\n        if (scrollable === document.documentElement && scrollable === document.body) {\n            return;\n        }\n        lastY = e.changedTouches[0].pageY;\n    };\n    let onTouchMove = (e)=>{\n        // Prevent scrolling the window.\n        if (!scrollable || scrollable === document.documentElement || scrollable === document.body) {\n            e.preventDefault();\n            return;\n        }\n        // Prevent scrolling up when at the top and scrolling down when at the bottom\n        // of a nested scrollable area, otherwise mobile Safari will start scrolling\n        // the window instead. Unfortunately, this disables bounce scrolling when at\n        // the top but it's the best we can do.\n        let y = e.changedTouches[0].pageY;\n        let scrollTop = scrollable.scrollTop;\n        let bottom = scrollable.scrollHeight - scrollable.clientHeight;\n        if (bottom === 0) {\n            return;\n        }\n        if (scrollTop <= 0 && y > lastY || scrollTop >= bottom && y < lastY) {\n            e.preventDefault();\n        }\n        lastY = y;\n    };\n    let onTouchEnd = (e)=>{\n        let target = e.target;\n        // Apply this change if we're not already focused on the target element\n        if (isInput(target) && target !== document.activeElement) {\n            e.preventDefault();\n            // Apply a transform to trick Safari into thinking the input is at the top of the page\n            // so it doesn't try to scroll it into view. When tapping on an input, this needs to\n            // be done before the \"focus\" event, so we have to focus the element ourselves.\n            target.style.transform = 'translateY(-2000px)';\n            target.focus();\n            requestAnimationFrame(()=>{\n                target.style.transform = '';\n            });\n        }\n    };\n    let onFocus = (e)=>{\n        let target = e.target;\n        if (isInput(target)) {\n            // Transform also needs to be applied in the focus event in cases where focus moves\n            // other than tapping on an input directly, e.g. the next/previous buttons in the\n            // software keyboard. In these cases, it seems applying the transform in the focus event\n            // is good enough, whereas when tapping an input, it must be done before the focus event. 🤷‍♂️\n            target.style.transform = 'translateY(-2000px)';\n            requestAnimationFrame(()=>{\n                target.style.transform = '';\n                // This will have prevented the browser from scrolling the focused element into view,\n                // so we need to do this ourselves in a way that doesn't cause the whole page to scroll.\n                if (visualViewport) {\n                    if (visualViewport.height < window.innerHeight) {\n                        // If the keyboard is already visible, do this after one additional frame\n                        // to wait for the transform to be removed.\n                        requestAnimationFrame(()=>{\n                            scrollIntoView(target);\n                        });\n                    } else {\n                        // Otherwise, wait for the visual viewport to resize before scrolling so we can\n                        // measure the correct position to scroll to.\n                        visualViewport.addEventListener('resize', ()=>scrollIntoView(target), {\n                            once: true\n                        });\n                    }\n                }\n            });\n        }\n    };\n    let onWindowScroll = ()=>{\n        // Last resort. If the window scrolled, scroll it back to the top.\n        // It should always be at the top because the body will have a negative margin (see below).\n        window.scrollTo(0, 0);\n    };\n    // Record the original scroll position so we can restore it.\n    // Then apply a negative margin to the body to offset it by the scroll position. This will\n    // enable us to scroll the window to the top, which is required for the rest of this to work.\n    let scrollX = window.pageXOffset;\n    let scrollY = window.pageYOffset;\n    let restoreStyles = chain$1(setStyle(document.documentElement, 'paddingRight', `${window.innerWidth - document.documentElement.clientWidth}px`));\n    // Scroll to the top. The negative margin on the body will make this appear the same.\n    window.scrollTo(0, 0);\n    let removeEvents = chain$1(addEvent(document, 'touchstart', onTouchStart, {\n        passive: false,\n        capture: true\n    }), addEvent(document, 'touchmove', onTouchMove, {\n        passive: false,\n        capture: true\n    }), addEvent(document, 'touchend', onTouchEnd, {\n        passive: false,\n        capture: true\n    }), addEvent(document, 'focus', onFocus, true), addEvent(window, 'scroll', onWindowScroll));\n    return ()=>{\n        // Restore styles and scroll the page back to where it was.\n        restoreStyles();\n        removeEvents();\n        window.scrollTo(scrollX, scrollY);\n    };\n}\n// Sets a CSS property on an element, and returns a function to revert it to the previous value.\nfunction setStyle(element, style, value) {\n    // https://github.com/microsoft/TypeScript/issues/17827#issuecomment-391663310\n    // @ts-ignore\n    let cur = element.style[style];\n    // @ts-ignore\n    element.style[style] = value;\n    return ()=>{\n        // @ts-ignore\n        element.style[style] = cur;\n    };\n}\n// Adds an event listener to an element, and returns a function to remove it.\nfunction addEvent(target, event, handler, options) {\n    // @ts-ignore\n    target.addEventListener(event, handler, options);\n    return ()=>{\n        // @ts-ignore\n        target.removeEventListener(event, handler, options);\n    };\n}\nfunction scrollIntoView(target) {\n    let root = document.scrollingElement || document.documentElement;\n    while(target && target !== root){\n        // Find the parent scrollable element and adjust the scroll position if the target is not already in view.\n        let scrollable = getScrollParent(target);\n        if (scrollable !== document.documentElement && scrollable !== document.body && scrollable !== target) {\n            let scrollableTop = scrollable.getBoundingClientRect().top;\n            let targetTop = target.getBoundingClientRect().top;\n            let targetBottom = target.getBoundingClientRect().bottom;\n            // Buffer is needed for some edge cases\n            const keyboardHeight = scrollable.getBoundingClientRect().bottom + KEYBOARD_BUFFER;\n            if (targetBottom > keyboardHeight) {\n                scrollable.scrollTop += targetTop - scrollableTop;\n            }\n        }\n        // @ts-ignore\n        target = scrollable.parentElement;\n    }\n}\nfunction isInput(target) {\n    return target instanceof HTMLInputElement && !nonTextInputTypes.has(target.type) || target instanceof HTMLTextAreaElement || target instanceof HTMLElement && target.isContentEditable;\n}\n\n// This code comes from https://github.com/radix-ui/primitives/tree/main/packages/react/compose-refs\n/**\n * Set a given ref to a given value\n * This utility takes care of different types of refs: callback refs and RefObject(s)\n */ function setRef(ref, value) {\n    if (typeof ref === 'function') {\n        ref(value);\n    } else if (ref !== null && ref !== undefined) {\n        ref.current = value;\n    }\n}\n/**\n * A utility to compose multiple refs together\n * Accepts callback refs and RefObject(s)\n */ function composeRefs(...refs) {\n    return (node)=>refs.forEach((ref)=>setRef(ref, node));\n}\n/**\n * A custom hook that composes multiple refs\n * Accepts callback refs and RefObject(s)\n */ function useComposedRefs(...refs) {\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    return React.useCallback(composeRefs(...refs), refs);\n}\n\nconst cache = new WeakMap();\nfunction set(el, styles, ignoreCache = false) {\n    if (!el || !(el instanceof HTMLElement)) return;\n    let originalStyles = {};\n    Object.entries(styles).forEach(([key, value])=>{\n        if (key.startsWith('--')) {\n            el.style.setProperty(key, value);\n            return;\n        }\n        originalStyles[key] = el.style[key];\n        el.style[key] = value;\n    });\n    if (ignoreCache) return;\n    cache.set(el, originalStyles);\n}\nfunction reset(el, prop) {\n    if (!el || !(el instanceof HTMLElement)) return;\n    let originalStyles = cache.get(el);\n    if (!originalStyles) {\n        return;\n    }\n    {\n        el.style[prop] = originalStyles[prop];\n    }\n}\nconst isVertical = (direction)=>{\n    switch(direction){\n        case 'top':\n        case 'bottom':\n            return true;\n        case 'left':\n        case 'right':\n            return false;\n        default:\n            return direction;\n    }\n};\nfunction getTranslate(element, direction) {\n    if (!element) {\n        return null;\n    }\n    const style = window.getComputedStyle(element);\n    const transform = // @ts-ignore\n    style.transform || style.webkitTransform || style.mozTransform;\n    let mat = transform.match(/^matrix3d\\((.+)\\)$/);\n    if (mat) {\n        // https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/matrix3d\n        return parseFloat(mat[1].split(', ')[isVertical(direction) ? 13 : 12]);\n    }\n    // https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/matrix\n    mat = transform.match(/^matrix\\((.+)\\)$/);\n    return mat ? parseFloat(mat[1].split(', ')[isVertical(direction) ? 5 : 4]) : null;\n}\nfunction dampenValue(v) {\n    return 8 * (Math.log(v + 1) - 2);\n}\nfunction assignStyle(element, style) {\n    if (!element) return ()=>{};\n    const prevStyle = element.style.cssText;\n    Object.assign(element.style, style);\n    return ()=>{\n        element.style.cssText = prevStyle;\n    };\n}\n/**\n * Receives functions as arguments and returns a new function that calls all.\n */ function chain(...fns) {\n    return (...args)=>{\n        for (const fn of fns){\n            if (typeof fn === 'function') {\n                // @ts-ignore\n                fn(...args);\n            }\n        }\n    };\n}\n\nconst TRANSITIONS = {\n    DURATION: 0.5,\n    EASE: [\n        0.32,\n        0.72,\n        0,\n        1\n    ]\n};\nconst VELOCITY_THRESHOLD = 0.4;\nconst CLOSE_THRESHOLD = 0.25;\nconst SCROLL_LOCK_TIMEOUT = 100;\nconst BORDER_RADIUS = 8;\nconst NESTED_DISPLACEMENT = 16;\nconst WINDOW_TOP_OFFSET = 26;\nconst DRAG_CLASS = 'vaul-dragging';\n\n// This code comes from https://github.com/radix-ui/primitives/blob/main/packages/react/use-controllable-state/src/useControllableState.tsx\nfunction useCallbackRef(callback) {\n    const callbackRef = React__default.useRef(callback);\n    React__default.useEffect(()=>{\n        callbackRef.current = callback;\n    });\n    // https://github.com/facebook/react/issues/19240\n    return React__default.useMemo(()=>(...args)=>callbackRef.current == null ? void 0 : callbackRef.current.call(callbackRef, ...args), []);\n}\nfunction useUncontrolledState({ defaultProp, onChange }) {\n    const uncontrolledState = React__default.useState(defaultProp);\n    const [value] = uncontrolledState;\n    const prevValueRef = React__default.useRef(value);\n    const handleChange = useCallbackRef(onChange);\n    React__default.useEffect(()=>{\n        if (prevValueRef.current !== value) {\n            handleChange(value);\n            prevValueRef.current = value;\n        }\n    }, [\n        value,\n        prevValueRef,\n        handleChange\n    ]);\n    return uncontrolledState;\n}\nfunction useControllableState({ prop, defaultProp, onChange = ()=>{} }) {\n    const [uncontrolledProp, setUncontrolledProp] = useUncontrolledState({\n        defaultProp,\n        onChange\n    });\n    const isControlled = prop !== undefined;\n    const value = isControlled ? prop : uncontrolledProp;\n    const handleChange = useCallbackRef(onChange);\n    const setValue = React__default.useCallback((nextValue)=>{\n        if (isControlled) {\n            const setter = nextValue;\n            const value = typeof nextValue === 'function' ? setter(prop) : nextValue;\n            if (value !== prop) handleChange(value);\n        } else {\n            setUncontrolledProp(nextValue);\n        }\n    }, [\n        isControlled,\n        prop,\n        setUncontrolledProp,\n        handleChange\n    ]);\n    return [\n        value,\n        setValue\n    ];\n}\n\nfunction useSnapPoints({ activeSnapPointProp, setActiveSnapPointProp, snapPoints, drawerRef, overlayRef, fadeFromIndex, onSnapPointChange, direction = 'bottom', container, snapToSequentialPoint }) {\n    const [activeSnapPoint, setActiveSnapPoint] = useControllableState({\n        prop: activeSnapPointProp,\n        defaultProp: snapPoints == null ? void 0 : snapPoints[0],\n        onChange: setActiveSnapPointProp\n    });\n    const [windowDimensions, setWindowDimensions] = React__default.useState(typeof window !== 'undefined' ? {\n        innerWidth: window.innerWidth,\n        innerHeight: window.innerHeight\n    } : undefined);\n    React__default.useEffect(()=>{\n        function onResize() {\n            setWindowDimensions({\n                innerWidth: window.innerWidth,\n                innerHeight: window.innerHeight\n            });\n        }\n        window.addEventListener('resize', onResize);\n        return ()=>window.removeEventListener('resize', onResize);\n    }, []);\n    const isLastSnapPoint = React__default.useMemo(()=>activeSnapPoint === (snapPoints == null ? void 0 : snapPoints[snapPoints.length - 1]) || null, [\n        snapPoints,\n        activeSnapPoint\n    ]);\n    const activeSnapPointIndex = React__default.useMemo(()=>{\n        var _snapPoints_findIndex;\n        return (_snapPoints_findIndex = snapPoints == null ? void 0 : snapPoints.findIndex((snapPoint)=>snapPoint === activeSnapPoint)) != null ? _snapPoints_findIndex : null;\n    }, [\n        snapPoints,\n        activeSnapPoint\n    ]);\n    const shouldFade = snapPoints && snapPoints.length > 0 && (fadeFromIndex || fadeFromIndex === 0) && !Number.isNaN(fadeFromIndex) && snapPoints[fadeFromIndex] === activeSnapPoint || !snapPoints;\n    const snapPointsOffset = React__default.useMemo(()=>{\n        const containerSize = container ? {\n            width: container.getBoundingClientRect().width,\n            height: container.getBoundingClientRect().height\n        } : typeof window !== 'undefined' ? {\n            width: window.innerWidth,\n            height: window.innerHeight\n        } : {\n            width: 0,\n            height: 0\n        };\n        var _snapPoints_map;\n        return (_snapPoints_map = snapPoints == null ? void 0 : snapPoints.map((snapPoint)=>{\n            const isPx = typeof snapPoint === 'string';\n            let snapPointAsNumber = 0;\n            if (isPx) {\n                snapPointAsNumber = parseInt(snapPoint, 10);\n            }\n            if (isVertical(direction)) {\n                const height = isPx ? snapPointAsNumber : windowDimensions ? snapPoint * containerSize.height : 0;\n                if (windowDimensions) {\n                    return direction === 'bottom' ? containerSize.height - height : -containerSize.height + height;\n                }\n                return height;\n            }\n            const width = isPx ? snapPointAsNumber : windowDimensions ? snapPoint * containerSize.width : 0;\n            if (windowDimensions) {\n                return direction === 'right' ? containerSize.width - width : -containerSize.width + width;\n            }\n            return width;\n        })) != null ? _snapPoints_map : [];\n    }, [\n        snapPoints,\n        windowDimensions,\n        container\n    ]);\n    const activeSnapPointOffset = React__default.useMemo(()=>activeSnapPointIndex !== null ? snapPointsOffset == null ? void 0 : snapPointsOffset[activeSnapPointIndex] : null, [\n        snapPointsOffset,\n        activeSnapPointIndex\n    ]);\n    const snapToPoint = React__default.useCallback((dimension)=>{\n        var _snapPointsOffset_findIndex;\n        const newSnapPointIndex = (_snapPointsOffset_findIndex = snapPointsOffset == null ? void 0 : snapPointsOffset.findIndex((snapPointDim)=>snapPointDim === dimension)) != null ? _snapPointsOffset_findIndex : null;\n        onSnapPointChange(newSnapPointIndex);\n        set(drawerRef.current, {\n            transition: `transform ${TRANSITIONS.DURATION}s cubic-bezier(${TRANSITIONS.EASE.join(',')})`,\n            transform: isVertical(direction) ? `translate3d(0, ${dimension}px, 0)` : `translate3d(${dimension}px, 0, 0)`\n        });\n        if (snapPointsOffset && newSnapPointIndex !== snapPointsOffset.length - 1 && fadeFromIndex !== undefined && newSnapPointIndex !== fadeFromIndex && newSnapPointIndex < fadeFromIndex) {\n            set(overlayRef.current, {\n                transition: `opacity ${TRANSITIONS.DURATION}s cubic-bezier(${TRANSITIONS.EASE.join(',')})`,\n                opacity: '0'\n            });\n        } else {\n            set(overlayRef.current, {\n                transition: `opacity ${TRANSITIONS.DURATION}s cubic-bezier(${TRANSITIONS.EASE.join(',')})`,\n                opacity: '1'\n            });\n        }\n        setActiveSnapPoint(snapPoints == null ? void 0 : snapPoints[Math.max(newSnapPointIndex, 0)]);\n    }, [\n        drawerRef.current,\n        snapPoints,\n        snapPointsOffset,\n        fadeFromIndex,\n        overlayRef,\n        setActiveSnapPoint\n    ]);\n    React__default.useEffect(()=>{\n        if (activeSnapPoint || activeSnapPointProp) {\n            var _snapPoints_findIndex;\n            const newIndex = (_snapPoints_findIndex = snapPoints == null ? void 0 : snapPoints.findIndex((snapPoint)=>snapPoint === activeSnapPointProp || snapPoint === activeSnapPoint)) != null ? _snapPoints_findIndex : -1;\n            if (snapPointsOffset && newIndex !== -1 && typeof snapPointsOffset[newIndex] === 'number') {\n                snapToPoint(snapPointsOffset[newIndex]);\n            }\n        }\n    }, [\n        activeSnapPoint,\n        activeSnapPointProp,\n        snapPoints,\n        snapPointsOffset,\n        snapToPoint\n    ]);\n    function onRelease({ draggedDistance, closeDrawer, velocity, dismissible }) {\n        if (fadeFromIndex === undefined) return;\n        const currentPosition = direction === 'bottom' || direction === 'right' ? (activeSnapPointOffset != null ? activeSnapPointOffset : 0) - draggedDistance : (activeSnapPointOffset != null ? activeSnapPointOffset : 0) + draggedDistance;\n        const isOverlaySnapPoint = activeSnapPointIndex === fadeFromIndex - 1;\n        const isFirst = activeSnapPointIndex === 0;\n        const hasDraggedUp = draggedDistance > 0;\n        if (isOverlaySnapPoint) {\n            set(overlayRef.current, {\n                transition: `opacity ${TRANSITIONS.DURATION}s cubic-bezier(${TRANSITIONS.EASE.join(',')})`\n            });\n        }\n        if (!snapToSequentialPoint && velocity > 2 && !hasDraggedUp) {\n            if (dismissible) closeDrawer();\n            else snapToPoint(snapPointsOffset[0]); // snap to initial point\n            return;\n        }\n        if (!snapToSequentialPoint && velocity > 2 && hasDraggedUp && snapPointsOffset && snapPoints) {\n            snapToPoint(snapPointsOffset[snapPoints.length - 1]);\n            return;\n        }\n        // Find the closest snap point to the current position\n        const closestSnapPoint = snapPointsOffset == null ? void 0 : snapPointsOffset.reduce((prev, curr)=>{\n            if (typeof prev !== 'number' || typeof curr !== 'number') return prev;\n            return Math.abs(curr - currentPosition) < Math.abs(prev - currentPosition) ? curr : prev;\n        });\n        const dim = isVertical(direction) ? window.innerHeight : window.innerWidth;\n        if (velocity > VELOCITY_THRESHOLD && Math.abs(draggedDistance) < dim * 0.4) {\n            const dragDirection = hasDraggedUp ? 1 : -1; // 1 = up, -1 = down\n            // Don't do anything if we swipe upwards while being on the last snap point\n            if (dragDirection > 0 && isLastSnapPoint && snapPoints) {\n                snapToPoint(snapPointsOffset[snapPoints.length - 1]);\n                return;\n            }\n            if (isFirst && dragDirection < 0 && dismissible) {\n                closeDrawer();\n            }\n            if (activeSnapPointIndex === null) return;\n            snapToPoint(snapPointsOffset[activeSnapPointIndex + dragDirection]);\n            return;\n        }\n        snapToPoint(closestSnapPoint);\n    }\n    function onDrag({ draggedDistance }) {\n        if (activeSnapPointOffset === null) return;\n        const newValue = direction === 'bottom' || direction === 'right' ? activeSnapPointOffset - draggedDistance : activeSnapPointOffset + draggedDistance;\n        // Don't do anything if we exceed the last(biggest) snap point\n        if ((direction === 'bottom' || direction === 'right') && newValue < snapPointsOffset[snapPointsOffset.length - 1]) {\n            return;\n        }\n        if ((direction === 'top' || direction === 'left') && newValue > snapPointsOffset[snapPointsOffset.length - 1]) {\n            return;\n        }\n        set(drawerRef.current, {\n            transform: isVertical(direction) ? `translate3d(0, ${newValue}px, 0)` : `translate3d(${newValue}px, 0, 0)`\n        });\n    }\n    function getPercentageDragged(absDraggedDistance, isDraggingDown) {\n        if (!snapPoints || typeof activeSnapPointIndex !== 'number' || !snapPointsOffset || fadeFromIndex === undefined) return null;\n        // If this is true we are dragging to a snap point that is supposed to have an overlay\n        const isOverlaySnapPoint = activeSnapPointIndex === fadeFromIndex - 1;\n        const isOverlaySnapPointOrHigher = activeSnapPointIndex >= fadeFromIndex;\n        if (isOverlaySnapPointOrHigher && isDraggingDown) {\n            return 0;\n        }\n        // Don't animate, but still use this one if we are dragging away from the overlaySnapPoint\n        if (isOverlaySnapPoint && !isDraggingDown) return 1;\n        if (!shouldFade && !isOverlaySnapPoint) return null;\n        // Either fadeFrom index or the one before\n        const targetSnapPointIndex = isOverlaySnapPoint ? activeSnapPointIndex + 1 : activeSnapPointIndex - 1;\n        // Get the distance from overlaySnapPoint to the one before or vice-versa to calculate the opacity percentage accordingly\n        const snapPointDistance = isOverlaySnapPoint ? snapPointsOffset[targetSnapPointIndex] - snapPointsOffset[targetSnapPointIndex - 1] : snapPointsOffset[targetSnapPointIndex + 1] - snapPointsOffset[targetSnapPointIndex];\n        const percentageDragged = absDraggedDistance / Math.abs(snapPointDistance);\n        if (isOverlaySnapPoint) {\n            return 1 - percentageDragged;\n        } else {\n            return percentageDragged;\n        }\n    }\n    return {\n        isLastSnapPoint,\n        activeSnapPoint,\n        shouldFade,\n        getPercentageDragged,\n        setActiveSnapPoint,\n        activeSnapPointIndex,\n        onRelease,\n        onDrag,\n        snapPointsOffset\n    };\n}\n\nconst noop = ()=>()=>{};\nfunction useScaleBackground() {\n    const { direction, isOpen, shouldScaleBackground, setBackgroundColorOnScale, noBodyStyles } = useDrawerContext();\n    const timeoutIdRef = React__default.useRef(null);\n    const initialBackgroundColor = useMemo(()=>document.body.style.backgroundColor, []);\n    function getScale() {\n        return (window.innerWidth - WINDOW_TOP_OFFSET) / window.innerWidth;\n    }\n    React__default.useEffect(()=>{\n        if (isOpen && shouldScaleBackground) {\n            if (timeoutIdRef.current) clearTimeout(timeoutIdRef.current);\n            const wrapper = document.querySelector('[data-vaul-drawer-wrapper]') || document.querySelector('[vaul-drawer-wrapper]');\n            if (!wrapper) return;\n            chain(setBackgroundColorOnScale && !noBodyStyles ? assignStyle(document.body, {\n                background: 'black'\n            }) : noop, assignStyle(wrapper, {\n                transformOrigin: isVertical(direction) ? 'top' : 'left',\n                transitionProperty: 'transform, border-radius',\n                transitionDuration: `${TRANSITIONS.DURATION}s`,\n                transitionTimingFunction: `cubic-bezier(${TRANSITIONS.EASE.join(',')})`\n            }));\n            const wrapperStylesCleanup = assignStyle(wrapper, {\n                borderRadius: `${BORDER_RADIUS}px`,\n                overflow: 'hidden',\n                ...isVertical(direction) ? {\n                    transform: `scale(${getScale()}) translate3d(0, calc(env(safe-area-inset-top) + 14px), 0)`\n                } : {\n                    transform: `scale(${getScale()}) translate3d(calc(env(safe-area-inset-top) + 14px), 0, 0)`\n                }\n            });\n            return ()=>{\n                wrapperStylesCleanup();\n                timeoutIdRef.current = window.setTimeout(()=>{\n                    if (initialBackgroundColor) {\n                        document.body.style.background = initialBackgroundColor;\n                    } else {\n                        document.body.style.removeProperty('background');\n                    }\n                }, TRANSITIONS.DURATION * 1000);\n            };\n        }\n    }, [\n        isOpen,\n        shouldScaleBackground,\n        initialBackgroundColor\n    ]);\n}\n\nlet previousBodyPosition = null;\n/**\n * This hook is necessary to prevent buggy behavior on iOS devices (need to test on Android).\n * I won't get into too much detail about what bugs it solves, but so far I've found that setting the body to `position: fixed` is the most reliable way to prevent those bugs.\n * Issues that this hook solves:\n * https://github.com/emilkowalski/vaul/issues/435\n * https://github.com/emilkowalski/vaul/issues/433\n * And more that I discovered, but were just not reported.\n */ function usePositionFixed({ isOpen, modal, nested, hasBeenOpened, preventScrollRestoration, noBodyStyles }) {\n    const [activeUrl, setActiveUrl] = React__default.useState(()=>typeof window !== 'undefined' ? window.location.href : '');\n    const scrollPos = React__default.useRef(0);\n    const setPositionFixed = React__default.useCallback(()=>{\n        // All browsers on iOS will return true here.\n        if (!isSafari()) return;\n        // If previousBodyPosition is already set, don't set it again.\n        if (previousBodyPosition === null && isOpen && !noBodyStyles) {\n            previousBodyPosition = {\n                position: document.body.style.position,\n                top: document.body.style.top,\n                left: document.body.style.left,\n                height: document.body.style.height,\n                right: 'unset'\n            };\n            // Update the dom inside an animation frame\n            const { scrollX, innerHeight } = window;\n            document.body.style.setProperty('position', 'fixed', 'important');\n            Object.assign(document.body.style, {\n                top: `${-scrollPos.current}px`,\n                left: `${-scrollX}px`,\n                right: '0px',\n                height: 'auto'\n            });\n            window.setTimeout(()=>window.requestAnimationFrame(()=>{\n                    // Attempt to check if the bottom bar appeared due to the position change\n                    const bottomBarHeight = innerHeight - window.innerHeight;\n                    if (bottomBarHeight && scrollPos.current >= innerHeight) {\n                        // Move the content further up so that the bottom bar doesn't hide it\n                        document.body.style.top = `${-(scrollPos.current + bottomBarHeight)}px`;\n                    }\n                }), 300);\n        }\n    }, [\n        isOpen\n    ]);\n    const restorePositionSetting = React__default.useCallback(()=>{\n        // All browsers on iOS will return true here.\n        if (!isSafari()) return;\n        if (previousBodyPosition !== null && !noBodyStyles) {\n            // Convert the position from \"px\" to Int\n            const y = -parseInt(document.body.style.top, 10);\n            const x = -parseInt(document.body.style.left, 10);\n            // Restore styles\n            Object.assign(document.body.style, previousBodyPosition);\n            window.requestAnimationFrame(()=>{\n                if (preventScrollRestoration && activeUrl !== window.location.href) {\n                    setActiveUrl(window.location.href);\n                    return;\n                }\n                window.scrollTo(x, y);\n            });\n            previousBodyPosition = null;\n        }\n    }, [\n        activeUrl\n    ]);\n    React__default.useEffect(()=>{\n        function onScroll() {\n            scrollPos.current = window.scrollY;\n        }\n        onScroll();\n        window.addEventListener('scroll', onScroll);\n        return ()=>{\n            window.removeEventListener('scroll', onScroll);\n        };\n    }, []);\n    React__default.useEffect(()=>{\n        if (!modal) return;\n        return ()=>{\n            if (typeof document === 'undefined') return;\n            // Another drawer is opened, safe to ignore the execution\n            const hasDrawerOpened = !!document.querySelector('[data-vaul-drawer]');\n            if (hasDrawerOpened) return;\n            restorePositionSetting();\n        };\n    }, [\n        modal,\n        restorePositionSetting\n    ]);\n    React__default.useEffect(()=>{\n        if (nested || !hasBeenOpened) return;\n        // This is needed to force Safari toolbar to show **before** the drawer starts animating to prevent a gnarly shift from happening\n        if (isOpen) {\n            // avoid for standalone mode (PWA)\n            const isStandalone = window.matchMedia('(display-mode: standalone)').matches;\n            !isStandalone && setPositionFixed();\n            if (!modal) {\n                window.setTimeout(()=>{\n                    restorePositionSetting();\n                }, 500);\n            }\n        } else {\n            restorePositionSetting();\n        }\n    }, [\n        isOpen,\n        hasBeenOpened,\n        activeUrl,\n        modal,\n        nested,\n        setPositionFixed,\n        restorePositionSetting\n    ]);\n    return {\n        restorePositionSetting\n    };\n}\n\nfunction Root({ open: openProp, onOpenChange, children, onDrag: onDragProp, onRelease: onReleaseProp, snapPoints, shouldScaleBackground = false, setBackgroundColorOnScale = true, closeThreshold = CLOSE_THRESHOLD, scrollLockTimeout = SCROLL_LOCK_TIMEOUT, dismissible = true, handleOnly = false, fadeFromIndex = snapPoints && snapPoints.length - 1, activeSnapPoint: activeSnapPointProp, setActiveSnapPoint: setActiveSnapPointProp, fixed, modal = true, onClose, nested, noBodyStyles = false, direction = 'bottom', defaultOpen = false, disablePreventScroll = true, snapToSequentialPoint = false, preventScrollRestoration = false, repositionInputs = true, onAnimationEnd, container, autoFocus = false }) {\n    var _drawerRef_current, _drawerRef_current1;\n    const [isOpen = false, setIsOpen] = useControllableState({\n        defaultProp: defaultOpen,\n        prop: openProp,\n        onChange: (o)=>{\n            onOpenChange == null ? void 0 : onOpenChange(o);\n            if (!o && !nested) {\n                restorePositionSetting();\n            }\n            setTimeout(()=>{\n                onAnimationEnd == null ? void 0 : onAnimationEnd(o);\n            }, TRANSITIONS.DURATION * 1000);\n            if (o && !modal) {\n                if (typeof window !== 'undefined') {\n                    window.requestAnimationFrame(()=>{\n                        document.body.style.pointerEvents = 'auto';\n                    });\n                }\n            }\n            if (!o) {\n                // This will be removed when the exit animation ends (`500ms`)\n                document.body.style.pointerEvents = 'auto';\n            }\n        }\n    });\n    const [hasBeenOpened, setHasBeenOpened] = React__default.useState(false);\n    const [isDragging, setIsDragging] = React__default.useState(false);\n    const [justReleased, setJustReleased] = React__default.useState(false);\n    const overlayRef = React__default.useRef(null);\n    const openTime = React__default.useRef(null);\n    const dragStartTime = React__default.useRef(null);\n    const dragEndTime = React__default.useRef(null);\n    const lastTimeDragPrevented = React__default.useRef(null);\n    const isAllowedToDrag = React__default.useRef(false);\n    const nestedOpenChangeTimer = React__default.useRef(null);\n    const pointerStart = React__default.useRef(0);\n    const keyboardIsOpen = React__default.useRef(false);\n    const shouldAnimate = React__default.useRef(!defaultOpen);\n    const previousDiffFromInitial = React__default.useRef(0);\n    const drawerRef = React__default.useRef(null);\n    const drawerHeightRef = React__default.useRef(((_drawerRef_current = drawerRef.current) == null ? void 0 : _drawerRef_current.getBoundingClientRect().height) || 0);\n    const drawerWidthRef = React__default.useRef(((_drawerRef_current1 = drawerRef.current) == null ? void 0 : _drawerRef_current1.getBoundingClientRect().width) || 0);\n    const initialDrawerHeight = React__default.useRef(0);\n    const onSnapPointChange = React__default.useCallback((activeSnapPointIndex)=>{\n        // Change openTime ref when we reach the last snap point to prevent dragging for 500ms incase it's scrollable.\n        if (snapPoints && activeSnapPointIndex === snapPointsOffset.length - 1) openTime.current = new Date();\n    }, []);\n    const { activeSnapPoint, activeSnapPointIndex, setActiveSnapPoint, onRelease: onReleaseSnapPoints, snapPointsOffset, onDrag: onDragSnapPoints, shouldFade, getPercentageDragged: getSnapPointsPercentageDragged } = useSnapPoints({\n        snapPoints,\n        activeSnapPointProp,\n        setActiveSnapPointProp,\n        drawerRef,\n        fadeFromIndex,\n        overlayRef,\n        onSnapPointChange,\n        direction,\n        container,\n        snapToSequentialPoint\n    });\n    usePreventScroll({\n        isDisabled: !isOpen || isDragging || !modal || justReleased || !hasBeenOpened || !repositionInputs || !disablePreventScroll\n    });\n    const { restorePositionSetting } = usePositionFixed({\n        isOpen,\n        modal,\n        nested: nested != null ? nested : false,\n        hasBeenOpened,\n        preventScrollRestoration,\n        noBodyStyles\n    });\n    function getScale() {\n        return (window.innerWidth - WINDOW_TOP_OFFSET) / window.innerWidth;\n    }\n    function onPress(event) {\n        var _drawerRef_current, _drawerRef_current1;\n        if (!dismissible && !snapPoints) return;\n        if (drawerRef.current && !drawerRef.current.contains(event.target)) return;\n        drawerHeightRef.current = ((_drawerRef_current = drawerRef.current) == null ? void 0 : _drawerRef_current.getBoundingClientRect().height) || 0;\n        drawerWidthRef.current = ((_drawerRef_current1 = drawerRef.current) == null ? void 0 : _drawerRef_current1.getBoundingClientRect().width) || 0;\n        setIsDragging(true);\n        dragStartTime.current = new Date();\n        // iOS doesn't trigger mouseUp after scrolling so we need to listen to touched in order to disallow dragging\n        if (isIOS()) {\n            window.addEventListener('touchend', ()=>isAllowedToDrag.current = false, {\n                once: true\n            });\n        }\n        // Ensure we maintain correct pointer capture even when going outside of the drawer\n        event.target.setPointerCapture(event.pointerId);\n        pointerStart.current = isVertical(direction) ? event.pageY : event.pageX;\n    }\n    function shouldDrag(el, isDraggingInDirection) {\n        var _window_getSelection;\n        let element = el;\n        const highlightedText = (_window_getSelection = window.getSelection()) == null ? void 0 : _window_getSelection.toString();\n        const swipeAmount = drawerRef.current ? getTranslate(drawerRef.current, direction) : null;\n        const date = new Date();\n        // Fixes https://github.com/emilkowalski/vaul/issues/483\n        if (element.tagName === 'SELECT') {\n            return false;\n        }\n        if (element.hasAttribute('data-vaul-no-drag') || element.closest('[data-vaul-no-drag]')) {\n            return false;\n        }\n        if (direction === 'right' || direction === 'left') {\n            return true;\n        }\n        // Allow scrolling when animating\n        if (openTime.current && date.getTime() - openTime.current.getTime() < 500) {\n            return false;\n        }\n        if (swipeAmount !== null) {\n            if (direction === 'bottom' ? swipeAmount > 0 : swipeAmount < 0) {\n                return true;\n            }\n        }\n        // Don't drag if there's highlighted text\n        if (highlightedText && highlightedText.length > 0) {\n            return false;\n        }\n        // Disallow dragging if drawer was scrolled within `scrollLockTimeout`\n        if (lastTimeDragPrevented.current && date.getTime() - lastTimeDragPrevented.current.getTime() < scrollLockTimeout && swipeAmount === 0) {\n            lastTimeDragPrevented.current = date;\n            return false;\n        }\n        if (isDraggingInDirection) {\n            lastTimeDragPrevented.current = date;\n            // We are dragging down so we should allow scrolling\n            return false;\n        }\n        // Keep climbing up the DOM tree as long as there's a parent\n        while(element){\n            // Check if the element is scrollable\n            if (element.scrollHeight > element.clientHeight) {\n                if (element.scrollTop !== 0) {\n                    lastTimeDragPrevented.current = new Date();\n                    // The element is scrollable and not scrolled to the top, so don't drag\n                    return false;\n                }\n                if (element.getAttribute('role') === 'dialog') {\n                    return true;\n                }\n            }\n            // Move up to the parent element\n            element = element.parentNode;\n        }\n        // No scrollable parents not scrolled to the top found, so drag\n        return true;\n    }\n    function onDrag(event) {\n        if (!drawerRef.current) {\n            return;\n        }\n        // We need to know how much of the drawer has been dragged in percentages so that we can transform background accordingly\n        if (isDragging) {\n            const directionMultiplier = direction === 'bottom' || direction === 'right' ? 1 : -1;\n            const draggedDistance = (pointerStart.current - (isVertical(direction) ? event.pageY : event.pageX)) * directionMultiplier;\n            const isDraggingInDirection = draggedDistance > 0;\n            // Pre condition for disallowing dragging in the close direction.\n            const noCloseSnapPointsPreCondition = snapPoints && !dismissible && !isDraggingInDirection;\n            // Disallow dragging down to close when first snap point is the active one and dismissible prop is set to false.\n            if (noCloseSnapPointsPreCondition && activeSnapPointIndex === 0) return;\n            // We need to capture last time when drag with scroll was triggered and have a timeout between\n            const absDraggedDistance = Math.abs(draggedDistance);\n            const wrapper = document.querySelector('[data-vaul-drawer-wrapper]');\n            const drawerDimension = direction === 'bottom' || direction === 'top' ? drawerHeightRef.current : drawerWidthRef.current;\n            // Calculate the percentage dragged, where 1 is the closed position\n            let percentageDragged = absDraggedDistance / drawerDimension;\n            const snapPointPercentageDragged = getSnapPointsPercentageDragged(absDraggedDistance, isDraggingInDirection);\n            if (snapPointPercentageDragged !== null) {\n                percentageDragged = snapPointPercentageDragged;\n            }\n            // Disallow close dragging beyond the smallest snap point.\n            if (noCloseSnapPointsPreCondition && percentageDragged >= 1) {\n                return;\n            }\n            if (!isAllowedToDrag.current && !shouldDrag(event.target, isDraggingInDirection)) return;\n            drawerRef.current.classList.add(DRAG_CLASS);\n            // If shouldDrag gave true once after pressing down on the drawer, we set isAllowedToDrag to true and it will remain true until we let go, there's no reason to disable dragging mid way, ever, and that's the solution to it\n            isAllowedToDrag.current = true;\n            set(drawerRef.current, {\n                transition: 'none'\n            });\n            set(overlayRef.current, {\n                transition: 'none'\n            });\n            if (snapPoints) {\n                onDragSnapPoints({\n                    draggedDistance\n                });\n            }\n            // Run this only if snapPoints are not defined or if we are at the last snap point (highest one)\n            if (isDraggingInDirection && !snapPoints) {\n                const dampenedDraggedDistance = dampenValue(draggedDistance);\n                const translateValue = Math.min(dampenedDraggedDistance * -1, 0) * directionMultiplier;\n                set(drawerRef.current, {\n                    transform: isVertical(direction) ? `translate3d(0, ${translateValue}px, 0)` : `translate3d(${translateValue}px, 0, 0)`\n                });\n                return;\n            }\n            const opacityValue = 1 - percentageDragged;\n            if (shouldFade || fadeFromIndex && activeSnapPointIndex === fadeFromIndex - 1) {\n                onDragProp == null ? void 0 : onDragProp(event, percentageDragged);\n                set(overlayRef.current, {\n                    opacity: `${opacityValue}`,\n                    transition: 'none'\n                }, true);\n            }\n            if (wrapper && overlayRef.current && shouldScaleBackground) {\n                // Calculate percentageDragged as a fraction (0 to 1)\n                const scaleValue = Math.min(getScale() + percentageDragged * (1 - getScale()), 1);\n                const borderRadiusValue = 8 - percentageDragged * 8;\n                const translateValue = Math.max(0, 14 - percentageDragged * 14);\n                set(wrapper, {\n                    borderRadius: `${borderRadiusValue}px`,\n                    transform: isVertical(direction) ? `scale(${scaleValue}) translate3d(0, ${translateValue}px, 0)` : `scale(${scaleValue}) translate3d(${translateValue}px, 0, 0)`,\n                    transition: 'none'\n                }, true);\n            }\n            if (!snapPoints) {\n                const translateValue = absDraggedDistance * directionMultiplier;\n                set(drawerRef.current, {\n                    transform: isVertical(direction) ? `translate3d(0, ${translateValue}px, 0)` : `translate3d(${translateValue}px, 0, 0)`\n                });\n            }\n        }\n    }\n    React__default.useEffect(()=>{\n        window.requestAnimationFrame(()=>{\n            shouldAnimate.current = true;\n        });\n    }, []);\n    React__default.useEffect(()=>{\n        var _window_visualViewport;\n        function onVisualViewportChange() {\n            if (!drawerRef.current || !repositionInputs) return;\n            const focusedElement = document.activeElement;\n            if (isInput(focusedElement) || keyboardIsOpen.current) {\n                var _window_visualViewport;\n                const visualViewportHeight = ((_window_visualViewport = window.visualViewport) == null ? void 0 : _window_visualViewport.height) || 0;\n                const totalHeight = window.innerHeight;\n                // This is the height of the keyboard\n                let diffFromInitial = totalHeight - visualViewportHeight;\n                const drawerHeight = drawerRef.current.getBoundingClientRect().height || 0;\n                // Adjust drawer height only if it's tall enough\n                const isTallEnough = drawerHeight > totalHeight * 0.8;\n                if (!initialDrawerHeight.current) {\n                    initialDrawerHeight.current = drawerHeight;\n                }\n                const offsetFromTop = drawerRef.current.getBoundingClientRect().top;\n                // visualViewport height may change due to somq e subtle changes to the keyboard. Checking if the height changed by 60 or more will make sure that they keyboard really changed its open state.\n                if (Math.abs(previousDiffFromInitial.current - diffFromInitial) > 60) {\n                    keyboardIsOpen.current = !keyboardIsOpen.current;\n                }\n                if (snapPoints && snapPoints.length > 0 && snapPointsOffset && activeSnapPointIndex) {\n                    const activeSnapPointHeight = snapPointsOffset[activeSnapPointIndex] || 0;\n                    diffFromInitial += activeSnapPointHeight;\n                }\n                previousDiffFromInitial.current = diffFromInitial;\n                // We don't have to change the height if the input is in view, when we are here we are in the opened keyboard state so we can correctly check if the input is in view\n                if (drawerHeight > visualViewportHeight || keyboardIsOpen.current) {\n                    const height = drawerRef.current.getBoundingClientRect().height;\n                    let newDrawerHeight = height;\n                    if (height > visualViewportHeight) {\n                        newDrawerHeight = visualViewportHeight - (isTallEnough ? offsetFromTop : WINDOW_TOP_OFFSET);\n                    }\n                    // When fixed, don't move the drawer upwards if there's space, but rather only change it's height so it's fully scrollable when the keyboard is open\n                    if (fixed) {\n                        drawerRef.current.style.height = `${height - Math.max(diffFromInitial, 0)}px`;\n                    } else {\n                        drawerRef.current.style.height = `${Math.max(newDrawerHeight, visualViewportHeight - offsetFromTop)}px`;\n                    }\n                } else if (!isMobileFirefox()) {\n                    drawerRef.current.style.height = `${initialDrawerHeight.current}px`;\n                }\n                if (snapPoints && snapPoints.length > 0 && !keyboardIsOpen.current) {\n                    drawerRef.current.style.bottom = `0px`;\n                } else {\n                    // Negative bottom value would never make sense\n                    drawerRef.current.style.bottom = `${Math.max(diffFromInitial, 0)}px`;\n                }\n            }\n        }\n        (_window_visualViewport = window.visualViewport) == null ? void 0 : _window_visualViewport.addEventListener('resize', onVisualViewportChange);\n        return ()=>{\n            var _window_visualViewport;\n            return (_window_visualViewport = window.visualViewport) == null ? void 0 : _window_visualViewport.removeEventListener('resize', onVisualViewportChange);\n        };\n    }, [\n        activeSnapPointIndex,\n        snapPoints,\n        snapPointsOffset\n    ]);\n    function closeDrawer(fromWithin) {\n        cancelDrag();\n        onClose == null ? void 0 : onClose();\n        if (!fromWithin) {\n            setIsOpen(false);\n        }\n        setTimeout(()=>{\n            if (snapPoints) {\n                setActiveSnapPoint(snapPoints[0]);\n            }\n        }, TRANSITIONS.DURATION * 1000); // seconds to ms\n    }\n    function resetDrawer() {\n        if (!drawerRef.current) return;\n        const wrapper = document.querySelector('[data-vaul-drawer-wrapper]');\n        const currentSwipeAmount = getTranslate(drawerRef.current, direction);\n        set(drawerRef.current, {\n            transform: 'translate3d(0, 0, 0)',\n            transition: `transform ${TRANSITIONS.DURATION}s cubic-bezier(${TRANSITIONS.EASE.join(',')})`\n        });\n        set(overlayRef.current, {\n            transition: `opacity ${TRANSITIONS.DURATION}s cubic-bezier(${TRANSITIONS.EASE.join(',')})`,\n            opacity: '1'\n        });\n        // Don't reset background if swiped upwards\n        if (shouldScaleBackground && currentSwipeAmount && currentSwipeAmount > 0 && isOpen) {\n            set(wrapper, {\n                borderRadius: `${BORDER_RADIUS}px`,\n                overflow: 'hidden',\n                ...isVertical(direction) ? {\n                    transform: `scale(${getScale()}) translate3d(0, calc(env(safe-area-inset-top) + 14px), 0)`,\n                    transformOrigin: 'top'\n                } : {\n                    transform: `scale(${getScale()}) translate3d(calc(env(safe-area-inset-top) + 14px), 0, 0)`,\n                    transformOrigin: 'left'\n                },\n                transitionProperty: 'transform, border-radius',\n                transitionDuration: `${TRANSITIONS.DURATION}s`,\n                transitionTimingFunction: `cubic-bezier(${TRANSITIONS.EASE.join(',')})`\n            }, true);\n        }\n    }\n    function cancelDrag() {\n        if (!isDragging || !drawerRef.current) return;\n        drawerRef.current.classList.remove(DRAG_CLASS);\n        isAllowedToDrag.current = false;\n        setIsDragging(false);\n        dragEndTime.current = new Date();\n    }\n    function onRelease(event) {\n        if (!isDragging || !drawerRef.current) return;\n        drawerRef.current.classList.remove(DRAG_CLASS);\n        isAllowedToDrag.current = false;\n        setIsDragging(false);\n        dragEndTime.current = new Date();\n        const swipeAmount = getTranslate(drawerRef.current, direction);\n        if (!event || !shouldDrag(event.target, false) || !swipeAmount || Number.isNaN(swipeAmount)) return;\n        if (dragStartTime.current === null) return;\n        const timeTaken = dragEndTime.current.getTime() - dragStartTime.current.getTime();\n        const distMoved = pointerStart.current - (isVertical(direction) ? event.pageY : event.pageX);\n        const velocity = Math.abs(distMoved) / timeTaken;\n        if (velocity > 0.05) {\n            // `justReleased` is needed to prevent the drawer from focusing on an input when the drag ends, as it's not the intent most of the time.\n            setJustReleased(true);\n            setTimeout(()=>{\n                setJustReleased(false);\n            }, 200);\n        }\n        if (snapPoints) {\n            const directionMultiplier = direction === 'bottom' || direction === 'right' ? 1 : -1;\n            onReleaseSnapPoints({\n                draggedDistance: distMoved * directionMultiplier,\n                closeDrawer,\n                velocity,\n                dismissible\n            });\n            onReleaseProp == null ? void 0 : onReleaseProp(event, true);\n            return;\n        }\n        // Moved upwards, don't do anything\n        if (direction === 'bottom' || direction === 'right' ? distMoved > 0 : distMoved < 0) {\n            resetDrawer();\n            onReleaseProp == null ? void 0 : onReleaseProp(event, true);\n            return;\n        }\n        if (velocity > VELOCITY_THRESHOLD) {\n            closeDrawer();\n            onReleaseProp == null ? void 0 : onReleaseProp(event, false);\n            return;\n        }\n        var _drawerRef_current_getBoundingClientRect_height;\n        const visibleDrawerHeight = Math.min((_drawerRef_current_getBoundingClientRect_height = drawerRef.current.getBoundingClientRect().height) != null ? _drawerRef_current_getBoundingClientRect_height : 0, window.innerHeight);\n        var _drawerRef_current_getBoundingClientRect_width;\n        const visibleDrawerWidth = Math.min((_drawerRef_current_getBoundingClientRect_width = drawerRef.current.getBoundingClientRect().width) != null ? _drawerRef_current_getBoundingClientRect_width : 0, window.innerWidth);\n        const isHorizontalSwipe = direction === 'left' || direction === 'right';\n        if (Math.abs(swipeAmount) >= (isHorizontalSwipe ? visibleDrawerWidth : visibleDrawerHeight) * closeThreshold) {\n            closeDrawer();\n            onReleaseProp == null ? void 0 : onReleaseProp(event, false);\n            return;\n        }\n        onReleaseProp == null ? void 0 : onReleaseProp(event, true);\n        resetDrawer();\n    }\n    React__default.useEffect(()=>{\n        // Trigger enter animation without using CSS animation\n        if (isOpen) {\n            set(document.documentElement, {\n                scrollBehavior: 'auto'\n            });\n            openTime.current = new Date();\n        }\n        return ()=>{\n            reset(document.documentElement, 'scrollBehavior');\n        };\n    }, [\n        isOpen\n    ]);\n    function onNestedOpenChange(o) {\n        const scale = o ? (window.innerWidth - NESTED_DISPLACEMENT) / window.innerWidth : 1;\n        const y = o ? -NESTED_DISPLACEMENT : 0;\n        if (nestedOpenChangeTimer.current) {\n            window.clearTimeout(nestedOpenChangeTimer.current);\n        }\n        set(drawerRef.current, {\n            transition: `transform ${TRANSITIONS.DURATION}s cubic-bezier(${TRANSITIONS.EASE.join(',')})`,\n            transform: `scale(${scale}) translate3d(0, ${y}px, 0)`\n        });\n        if (!o && drawerRef.current) {\n            nestedOpenChangeTimer.current = setTimeout(()=>{\n                const translateValue = getTranslate(drawerRef.current, direction);\n                set(drawerRef.current, {\n                    transition: 'none',\n                    transform: isVertical(direction) ? `translate3d(0, ${translateValue}px, 0)` : `translate3d(${translateValue}px, 0, 0)`\n                });\n            }, 500);\n        }\n    }\n    function onNestedDrag(_event, percentageDragged) {\n        if (percentageDragged < 0) return;\n        const initialScale = (window.innerWidth - NESTED_DISPLACEMENT) / window.innerWidth;\n        const newScale = initialScale + percentageDragged * (1 - initialScale);\n        const newTranslate = -NESTED_DISPLACEMENT + percentageDragged * NESTED_DISPLACEMENT;\n        set(drawerRef.current, {\n            transform: isVertical(direction) ? `scale(${newScale}) translate3d(0, ${newTranslate}px, 0)` : `scale(${newScale}) translate3d(${newTranslate}px, 0, 0)`,\n            transition: 'none'\n        });\n    }\n    function onNestedRelease(_event, o) {\n        const dim = isVertical(direction) ? window.innerHeight : window.innerWidth;\n        const scale = o ? (dim - NESTED_DISPLACEMENT) / dim : 1;\n        const translate = o ? -NESTED_DISPLACEMENT : 0;\n        if (o) {\n            set(drawerRef.current, {\n                transition: `transform ${TRANSITIONS.DURATION}s cubic-bezier(${TRANSITIONS.EASE.join(',')})`,\n                transform: isVertical(direction) ? `scale(${scale}) translate3d(0, ${translate}px, 0)` : `scale(${scale}) translate3d(${translate}px, 0, 0)`\n            });\n        }\n    }\n    React__default.useEffect(()=>{\n        if (!modal) {\n            // Need to do this manually unfortunately\n            window.requestAnimationFrame(()=>{\n                document.body.style.pointerEvents = 'auto';\n            });\n        }\n    }, [\n        modal\n    ]);\n    return /*#__PURE__*/ React__default.createElement(DialogPrimitive.Root, {\n        defaultOpen: defaultOpen,\n        onOpenChange: (open)=>{\n            if (!dismissible && !open) return;\n            if (open) {\n                setHasBeenOpened(true);\n            } else {\n                closeDrawer(true);\n            }\n            setIsOpen(open);\n        },\n        open: isOpen\n    }, /*#__PURE__*/ React__default.createElement(DrawerContext.Provider, {\n        value: {\n            activeSnapPoint,\n            snapPoints,\n            setActiveSnapPoint,\n            drawerRef,\n            overlayRef,\n            onOpenChange,\n            onPress,\n            onRelease,\n            onDrag,\n            dismissible,\n            shouldAnimate,\n            handleOnly,\n            isOpen,\n            isDragging,\n            shouldFade,\n            closeDrawer,\n            onNestedDrag,\n            onNestedOpenChange,\n            onNestedRelease,\n            keyboardIsOpen,\n            modal,\n            snapPointsOffset,\n            activeSnapPointIndex,\n            direction,\n            shouldScaleBackground,\n            setBackgroundColorOnScale,\n            noBodyStyles,\n            container,\n            autoFocus\n        }\n    }, children));\n}\nconst Overlay = /*#__PURE__*/ React__default.forwardRef(function({ ...rest }, ref) {\n    const { overlayRef, snapPoints, onRelease, shouldFade, isOpen, modal, shouldAnimate } = useDrawerContext();\n    const composedRef = useComposedRefs(ref, overlayRef);\n    const hasSnapPoints = snapPoints && snapPoints.length > 0;\n    // Overlay is the component that is locking scroll, removing it will unlock the scroll without having to dig into Radix's Dialog library\n    if (!modal) {\n        return null;\n    }\n    const onMouseUp = React__default.useCallback((event)=>onRelease(event), [\n        onRelease\n    ]);\n    return /*#__PURE__*/ React__default.createElement(DialogPrimitive.Overlay, {\n        onMouseUp: onMouseUp,\n        ref: composedRef,\n        \"data-vaul-overlay\": \"\",\n        \"data-vaul-snap-points\": isOpen && hasSnapPoints ? 'true' : 'false',\n        \"data-vaul-snap-points-overlay\": isOpen && shouldFade ? 'true' : 'false',\n        \"data-vaul-animate\": (shouldAnimate == null ? void 0 : shouldAnimate.current) ? 'true' : 'false',\n        ...rest\n    });\n});\nOverlay.displayName = 'Drawer.Overlay';\nconst Content = /*#__PURE__*/ React__default.forwardRef(function({ onPointerDownOutside, style, onOpenAutoFocus, ...rest }, ref) {\n    const { drawerRef, onPress, onRelease, onDrag, keyboardIsOpen, snapPointsOffset, activeSnapPointIndex, modal, isOpen, direction, snapPoints, container, handleOnly, shouldAnimate, autoFocus } = useDrawerContext();\n    // Needed to use transition instead of animations\n    const [delayedSnapPoints, setDelayedSnapPoints] = React__default.useState(false);\n    const composedRef = useComposedRefs(ref, drawerRef);\n    const pointerStartRef = React__default.useRef(null);\n    const lastKnownPointerEventRef = React__default.useRef(null);\n    const wasBeyondThePointRef = React__default.useRef(false);\n    const hasSnapPoints = snapPoints && snapPoints.length > 0;\n    useScaleBackground();\n    const isDeltaInDirection = (delta, direction, threshold = 0)=>{\n        if (wasBeyondThePointRef.current) return true;\n        const deltaY = Math.abs(delta.y);\n        const deltaX = Math.abs(delta.x);\n        const isDeltaX = deltaX > deltaY;\n        const dFactor = [\n            'bottom',\n            'right'\n        ].includes(direction) ? 1 : -1;\n        if (direction === 'left' || direction === 'right') {\n            const isReverseDirection = delta.x * dFactor < 0;\n            if (!isReverseDirection && deltaX >= 0 && deltaX <= threshold) {\n                return isDeltaX;\n            }\n        } else {\n            const isReverseDirection = delta.y * dFactor < 0;\n            if (!isReverseDirection && deltaY >= 0 && deltaY <= threshold) {\n                return !isDeltaX;\n            }\n        }\n        wasBeyondThePointRef.current = true;\n        return true;\n    };\n    React__default.useEffect(()=>{\n        if (hasSnapPoints) {\n            window.requestAnimationFrame(()=>{\n                setDelayedSnapPoints(true);\n            });\n        }\n    }, []);\n    function handleOnPointerUp(event) {\n        pointerStartRef.current = null;\n        wasBeyondThePointRef.current = false;\n        onRelease(event);\n    }\n    return /*#__PURE__*/ React__default.createElement(DialogPrimitive.Content, {\n        \"data-vaul-drawer-direction\": direction,\n        \"data-vaul-drawer\": \"\",\n        \"data-vaul-delayed-snap-points\": delayedSnapPoints ? 'true' : 'false',\n        \"data-vaul-snap-points\": isOpen && hasSnapPoints ? 'true' : 'false',\n        \"data-vaul-custom-container\": container ? 'true' : 'false',\n        \"data-vaul-animate\": (shouldAnimate == null ? void 0 : shouldAnimate.current) ? 'true' : 'false',\n        ...rest,\n        ref: composedRef,\n        style: snapPointsOffset && snapPointsOffset.length > 0 ? {\n            '--snap-point-height': `${snapPointsOffset[activeSnapPointIndex != null ? activeSnapPointIndex : 0]}px`,\n            ...style\n        } : style,\n        onPointerDown: (event)=>{\n            if (handleOnly) return;\n            rest.onPointerDown == null ? void 0 : rest.onPointerDown.call(rest, event);\n            pointerStartRef.current = {\n                x: event.pageX,\n                y: event.pageY\n            };\n            onPress(event);\n        },\n        onOpenAutoFocus: (e)=>{\n            onOpenAutoFocus == null ? void 0 : onOpenAutoFocus(e);\n            if (!autoFocus) {\n                e.preventDefault();\n            }\n        },\n        onPointerDownOutside: (e)=>{\n            onPointerDownOutside == null ? void 0 : onPointerDownOutside(e);\n            if (!modal || e.defaultPrevented) {\n                e.preventDefault();\n                return;\n            }\n            if (keyboardIsOpen.current) {\n                keyboardIsOpen.current = false;\n            }\n        },\n        onFocusOutside: (e)=>{\n            if (!modal) {\n                e.preventDefault();\n                return;\n            }\n        },\n        onPointerMove: (event)=>{\n            lastKnownPointerEventRef.current = event;\n            if (handleOnly) return;\n            rest.onPointerMove == null ? void 0 : rest.onPointerMove.call(rest, event);\n            if (!pointerStartRef.current) return;\n            const yPosition = event.pageY - pointerStartRef.current.y;\n            const xPosition = event.pageX - pointerStartRef.current.x;\n            const swipeStartThreshold = event.pointerType === 'touch' ? 10 : 2;\n            const delta = {\n                x: xPosition,\n                y: yPosition\n            };\n            const isAllowedToSwipe = isDeltaInDirection(delta, direction, swipeStartThreshold);\n            if (isAllowedToSwipe) onDrag(event);\n            else if (Math.abs(xPosition) > swipeStartThreshold || Math.abs(yPosition) > swipeStartThreshold) {\n                pointerStartRef.current = null;\n            }\n        },\n        onPointerUp: (event)=>{\n            rest.onPointerUp == null ? void 0 : rest.onPointerUp.call(rest, event);\n            pointerStartRef.current = null;\n            wasBeyondThePointRef.current = false;\n            onRelease(event);\n        },\n        onPointerOut: (event)=>{\n            rest.onPointerOut == null ? void 0 : rest.onPointerOut.call(rest, event);\n            handleOnPointerUp(lastKnownPointerEventRef.current);\n        },\n        onContextMenu: (event)=>{\n            rest.onContextMenu == null ? void 0 : rest.onContextMenu.call(rest, event);\n            if (lastKnownPointerEventRef.current) {\n                handleOnPointerUp(lastKnownPointerEventRef.current);\n            }\n        }\n    });\n});\nContent.displayName = 'Drawer.Content';\nconst LONG_HANDLE_PRESS_TIMEOUT = 250;\nconst DOUBLE_TAP_TIMEOUT = 120;\nconst Handle = /*#__PURE__*/ React__default.forwardRef(function({ preventCycle = false, children, ...rest }, ref) {\n    const { closeDrawer, isDragging, snapPoints, activeSnapPoint, setActiveSnapPoint, dismissible, handleOnly, isOpen, onPress, onDrag } = useDrawerContext();\n    const closeTimeoutIdRef = React__default.useRef(null);\n    const shouldCancelInteractionRef = React__default.useRef(false);\n    function handleStartCycle() {\n        // Stop if this is the second click of a double click\n        if (shouldCancelInteractionRef.current) {\n            handleCancelInteraction();\n            return;\n        }\n        window.setTimeout(()=>{\n            handleCycleSnapPoints();\n        }, DOUBLE_TAP_TIMEOUT);\n    }\n    function handleCycleSnapPoints() {\n        // Prevent accidental taps while resizing drawer\n        if (isDragging || preventCycle || shouldCancelInteractionRef.current) {\n            handleCancelInteraction();\n            return;\n        }\n        // Make sure to clear the timeout id if the user releases the handle before the cancel timeout\n        handleCancelInteraction();\n        if (!snapPoints || snapPoints.length === 0) {\n            if (!dismissible) {\n                closeDrawer();\n            }\n            return;\n        }\n        const isLastSnapPoint = activeSnapPoint === snapPoints[snapPoints.length - 1];\n        if (isLastSnapPoint && dismissible) {\n            closeDrawer();\n            return;\n        }\n        const currentSnapIndex = snapPoints.findIndex((point)=>point === activeSnapPoint);\n        if (currentSnapIndex === -1) return; // activeSnapPoint not found in snapPoints\n        const nextSnapPoint = snapPoints[currentSnapIndex + 1];\n        setActiveSnapPoint(nextSnapPoint);\n    }\n    function handleStartInteraction() {\n        closeTimeoutIdRef.current = window.setTimeout(()=>{\n            // Cancel click interaction on a long press\n            shouldCancelInteractionRef.current = true;\n        }, LONG_HANDLE_PRESS_TIMEOUT);\n    }\n    function handleCancelInteraction() {\n        if (closeTimeoutIdRef.current) {\n            window.clearTimeout(closeTimeoutIdRef.current);\n        }\n        shouldCancelInteractionRef.current = false;\n    }\n    return /*#__PURE__*/ React__default.createElement(\"div\", {\n        onClick: handleStartCycle,\n        onPointerCancel: handleCancelInteraction,\n        onPointerDown: (e)=>{\n            if (handleOnly) onPress(e);\n            handleStartInteraction();\n        },\n        onPointerMove: (e)=>{\n            if (handleOnly) onDrag(e);\n        },\n        // onPointerUp is already handled by the content component\n        ref: ref,\n        \"data-vaul-drawer-visible\": isOpen ? 'true' : 'false',\n        \"data-vaul-handle\": \"\",\n        \"aria-hidden\": \"true\",\n        ...rest\n    }, /*#__PURE__*/ React__default.createElement(\"span\", {\n        \"data-vaul-handle-hitarea\": \"\",\n        \"aria-hidden\": \"true\"\n    }, children));\n});\nHandle.displayName = 'Drawer.Handle';\nfunction NestedRoot({ onDrag, onOpenChange, ...rest }) {\n    const { onNestedDrag, onNestedOpenChange, onNestedRelease } = useDrawerContext();\n    if (!onNestedDrag) {\n        throw new Error('Drawer.NestedRoot must be placed in another drawer');\n    }\n    return /*#__PURE__*/ React__default.createElement(Root, {\n        nested: true,\n        onClose: ()=>{\n            onNestedOpenChange(false);\n        },\n        onDrag: (e, p)=>{\n            onNestedDrag(e, p);\n            onDrag == null ? void 0 : onDrag(e, p);\n        },\n        onOpenChange: (o)=>{\n            if (o) {\n                onNestedOpenChange(o);\n            }\n        },\n        onRelease: onNestedRelease,\n        ...rest\n    });\n}\nfunction Portal(props) {\n    const context = useDrawerContext();\n    const { container = context.container, ...portalProps } = props;\n    return /*#__PURE__*/ React__default.createElement(DialogPrimitive.Portal, {\n        container: container,\n        ...portalProps\n    });\n}\nconst Drawer = {\n    Root,\n    NestedRoot,\n    Content,\n    Overlay,\n    Trigger: DialogPrimitive.Trigger,\n    Portal,\n    Handle,\n    Close: DialogPrimitive.Close,\n    Title: DialogPrimitive.Title,\n    Description: DialogPrimitive.Description\n};\n\nexport { Content, Drawer, Handle, NestedRoot, Overlay, Portal, Root };\n","/*\nCopyright 2023 New Vector Ltd.\n\nSPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial\nPlease see LICENSE files in the repository root for full details.\n*/\n\n/**\n * Gets the platform on which the application is running.\n * If the userAgent could not be determined, this will default to \"other\"\n */\nexport function getPlatform(): \"android\" | \"ios\" | \"other\" {\n  // The granularity of this value is kind of arbitrary: it distinguishes exactly\n  // the platforms that this library needs to know about in order to correctly\n  // implement the designs.\n\n  // Some SSR environments don't provide access to this.\n  const userAgent = globalThis.navigator?.userAgent;\n\n  if (/android/i.test(userAgent)) {\n    return \"android\";\n    // We include 'Mac' here and double-check for touch support because iPads on\n    // iOS 13 pretend to be a MacOS desktop\n  } else if (\n    /iPad|iPhone|iPod|Mac/.test(userAgent) &&\n    \"ontouchend\" in document\n  ) {\n    return \"ios\";\n  } else {\n    return \"other\";\n  }\n}\n","/*\nCopyright 2023 New Vector Ltd.\n\nSPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial\nPlease see LICENSE files in the repository root for full details.\n*/\n\nimport React, { ComponentPropsWithoutRef, ReactNode, forwardRef } from \"react\";\nimport styles from \"./DrawerMenu.module.css\";\nimport { getPlatform } from \"../../utils/platform\";\nimport classNames from \"classnames\";\n\ninterface Props extends ComponentPropsWithoutRef<\"div\"> {\n  /**\n   * The menu title.\n   */\n  title: string;\n  /**\n   * The menu contents.\n   */\n  children: ReactNode;\n}\n\n/**\n * A menu in a drawer, as commonly seen on mobile.\n */\n// This an internal component not intended for export! Consumers should use it\n// via the Menu or ContextMenu components.\nexport const DrawerMenu = forwardRef<HTMLDivElement, Props>(\n  ({ title, children, className, ...props }, ref) => (\n    <div\n      ref={ref}\n      className={classNames(className, styles.drawer)}\n      aria-label={title}\n      data-platform={getPlatform()}\n      {...props}\n      role=\"menu\"\n    >\n      <div className={styles.body}>{children}</div>\n    </div>\n  ),\n);\n\nDrawerMenu.displayName = \"DrawerMenu\";\n","/*\nCopyright 2023 New Vector Ltd.\n\nSPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial\nPlease see LICENSE files in the repository root for full details.\n*/\n\nimport React, { FC, ReactNode, useMemo } from \"react\";\nimport {\n  Root,\n  Trigger,\n  Portal,\n  Content,\n  DropdownMenuItem,\n} from \"@radix-ui/react-dropdown-menu\";\nimport { FloatingMenu } from \"./FloatingMenu\";\nimport { Drawer } from \"vaul\";\nimport classnames from \"classnames\";\nimport drawerMenu from \"./DrawerMenu.module.css\";\nimport { MenuContext, MenuData, MenuItemWrapperProps } from \"./MenuContext\";\nimport { DrawerMenu } from \"./DrawerMenu\";\nimport { getPlatform } from \"../../utils/platform\";\n\ninterface Props {\n  /**\n   * The menu title. This can be hidden with `showTitle={false}` in which case it will only\n   * be a label for screen readers.\n   */\n  title: string;\n  /**\n   * Controls whether the title is displayed (see `title` prop). Titles are only displayed on\n   * web: on mobile, this parameter is ignored.\n   */\n  showTitle?: boolean;\n  /**\n   * Whether the menu is open.\n   */\n  open: boolean;\n  /**\n   * Event handler called when the open state of the menu changes. This includes\n   * anything like clicking the trigger, selecting a menu item, or dismissing\n   * the menu with the mouse or keyboard.\n   */\n  onOpenChange: (open: boolean) => void;\n  /**\n   * The button that opens the menu. This must be a component that accepts a ref\n   * and spreads props.\n   * https://www.radix-ui.com/primitives/docs/guides/composition\n   */\n  trigger: ReactNode;\n  /**\n   * The menu contents.\n   */\n  children: ReactNode;\n  /**\n   * The side of the trigger on which to place the menu. Note that the menu may\n   * still end up on a different side than the one you request if there isn't\n   * enough space.\n   * @default bottom\n   */\n  side?: \"top\" | \"right\" | \"bottom\" | \"left\";\n  /**\n   * The edge along which the menu and trigger will be aligned.\n   * @default center\n   */\n  align?: \"start\" | \"center\" | \"end\";\n}\n\nconst DropdownMenuItemWrapper: FC<MenuItemWrapperProps> = ({\n  onSelect,\n  children,\n}) => (\n  <DropdownMenuItem onSelect={onSelect ?? undefined} asChild>\n    {children}\n  </DropdownMenuItem>\n);\n\n/**\n * A menu opened by pressing a button.\n */\nexport const Menu: FC<Props> = ({\n  title,\n  showTitle = true,\n  open,\n  onOpenChange,\n  trigger,\n  children: childrenProp,\n  side = \"bottom\",\n  align = \"center\",\n}) => {\n  // Normally, the menu takes the form of a floating box. But on Android and\n  // iOS, the menu should morph into a drawer\n  const platform = getPlatform();\n  const drawer = platform === \"android\" || platform === \"ios\";\n  const context: MenuData = useMemo(\n    () => ({\n      MenuItemWrapper: drawer ? null : DropdownMenuItemWrapper,\n      onOpenChange,\n    }),\n    [onOpenChange],\n  );\n  const children = (\n    <MenuContext.Provider value={context}>{childrenProp}</MenuContext.Provider>\n  );\n\n  return drawer ? (\n    <Drawer.Root open={open} onOpenChange={onOpenChange}>\n      <Drawer.Trigger asChild>{trigger}</Drawer.Trigger>\n      <Drawer.Portal>\n        <Drawer.Overlay className={classnames(drawerMenu.bg)} />\n        <Drawer.Content asChild>\n          <DrawerMenu title={title}>{children}</DrawerMenu>\n        </Drawer.Content>\n      </Drawer.Portal>\n    </Drawer.Root>\n  ) : (\n    <Root open={open} onOpenChange={onOpenChange}>\n      <Trigger asChild>{trigger}</Trigger>\n      <Portal>\n        <Content\n          asChild\n          side={side}\n          align={align}\n          sideOffset={8}\n          onCloseAutoFocus={(event) => {\n            // https://www.radix-ui.com/primitives/docs/components/dropdown-menu#content => onCloseAutoFocus\n            // Prevent the default behavior of focusing the trigger when the menu closes\n            event.preventDefault();\n          }}\n        >\n          <FloatingMenu title={title} showTitle={showTitle}>\n            {children}\n          </FloatingMenu>\n        </Content>\n      </Portal>\n    </Root>\n  );\n};\n","/*\nCopyright 2023 New Vector Ltd.\n\nSPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial\nPlease see LICENSE files in the repository root for full details.\n*/\n\nimport { ComponentType, ReactNode, createContext } from \"react\";\n\nexport interface MenuItemWrapperProps {\n  /**\n   * Event callback for when the item is selected via mouse, touch, or keyboard.\n   * Calling event.preventDefault in this handler will prevent the menu from\n   * being dismissed.\n   */\n  onSelect: (e: Event) => void;\n  children: ReactNode;\n}\n\nexport interface MenuData {\n  /**\n   * A component that wraps interactive menu items.\n   */\n  MenuItemWrapper: ComponentType<MenuItemWrapperProps> | null;\n  /**\n   * Event handler called when the open state of the menu changes.\n   */\n  onOpenChange: (open: boolean) => void;\n}\n\n/**\n * A React context providing information about the menu in which a given\n * component resides.\n */\nexport const MenuContext = createContext<MenuData | null>(null);\n","import { forwardRef } from \"react\";\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nfunction ChevronRightIcon(props, ref) {\n  return /*#__PURE__*/_jsx(\"svg\", {\n    xmlns: \"http://www.w3.org/2000/svg\",\n    width: \"1em\",\n    height: \"1em\",\n    fill: \"currentColor\",\n    viewBox: \"0 0 24 24\",\n    ref: ref,\n    ...props,\n    children: /*#__PURE__*/_jsx(\"path\", {\n      d: \"M8.7 17.3a.95.95 0 0 1-.275-.7q0-.425.275-.7l3.9-3.9-3.9-3.9a.95.95 0 0 1-.275-.7q0-.425.275-.7a.95.95 0 0 1 .7-.275q.425 0 .7.275l4.6 4.6q.15.15.213.325.062.175.062.375t-.062.375a.9.9 0 0 1-.213.325l-4.6 4.6a.95.95 0 0 1-.7.275.95.95 0 0 1-.7-.275\"\n    })\n  });\n}\n;\nChevronRightIcon.displayName = \"ChevronRightIcon\";\nexport default forwardRef(ChevronRightIcon);","/*\nCopyright 2023 New Vector Ltd.\n\nSPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial\nPlease see LICENSE files in the repository root for full details.\n*/\n\nimport classnames from \"classnames\";\nimport React, {\n  ComponentPropsWithoutRef,\n  ComponentType,\n  ElementType,\n  isValidElement,\n  ReactElement,\n  SVGAttributes,\n  useCallback,\n  useContext,\n  MouseEventHandler,\n} from \"react\";\nimport styles from \"./MenuItem.module.css\";\nimport { Text } from \"../Typography/Text\";\nimport ChevronRightIcon from \"@vector-im/compound-design-tokens/assets/web/icons/chevron-right\";\nimport { MenuContext } from \"./MenuContext\";\nimport { Slot } from \"@radix-ui/react-slot\";\n\ntype MenuItemElement = \"button\" | \"a\" | \"div\";\n\ntype Props<C extends MenuItemElement> = {\n  /**\n   * The element type of this menu item.\n   * @default button\n   */\n  as?: C;\n  /**\n   * The CSS class name.\n   */\n  className?: string;\n  /**\n   * The icon to show on this menu item.\n   * When `Icon` is a ReactElement, it should spread the props\n   */\n  Icon: ComponentType<SVGAttributes<SVGElement>> | ReactElement;\n  /**\n   * The label to show on this menu item.\n   */\n  // This prop is required because it's rare to not want a label\n  label: string | null;\n  /**\n   * Additional properties to pass to the Text label component.\n   */\n  labelProps?: ComponentPropsWithoutRef<typeof Text>;\n  /**\n   * Event callback for when the item is selected via mouse, touch, or keyboard.\n   * Calling event.preventDefault in this handler will prevent the menu from\n   * being dismissed.\n   */\n  // This prop is required because it's rare to not want a selection handler\n  onSelect: ((e: Event) => void) | null;\n  /**\n   * Event callback for when the item is clicked.\n   * @param e\n   */\n  onClick?: MouseEventHandler<HTMLElementTagNameMap[C]>;\n  /**\n   * The color variant of the menu item.\n   * @default primary\n   */\n  kind?: \"primary\" | \"critical\";\n  disabled?: boolean;\n  /**\n   * Whether to hide the chevron navigation hint.\n   */\n  hideChevron?: boolean;\n} & Omit<ComponentPropsWithoutRef<C>, \"onSelect\" | \"onClick\">;\n\n/**\n * An item within a menu, acting either as a navigation button, or simply a\n * container for other interactive elements.\n * Must be used within a compound Menu or other `menu` or `menubar` aria role subtree.\n */\nexport const MenuItem = <C extends MenuItemElement = \"button\">({\n  as,\n  className,\n  Icon,\n  label,\n  labelProps,\n  onSelect,\n  kind = \"primary\",\n  children,\n  onClick: onClickProp,\n  disabled,\n  hideChevron,\n  ...props\n}: Props<C>): React.ReactElement => {\n  const Component = as ?? (\"button\" as ElementType);\n  const context = useContext(MenuContext);\n\n  const onClick = useCallback(\n    (e: Parameters<Exclude<typeof onClickProp, undefined>>[0]) => {\n      (onClickProp as ((e_: typeof e) => void) | undefined)?.(e);\n      // If there is no wrapper component to automatically handle onSelect, we\n      // need to handle it manually, dismissing the menu as the default action\n      if (onSelect !== null && context?.MenuItemWrapper == null) {\n        const selectEvent = new CustomEvent(\"menu.itemSelect\", {\n          bubbles: true,\n          cancelable: true,\n        });\n        onSelect(selectEvent);\n        if (!selectEvent.defaultPrevented) context?.onOpenChange(false);\n      }\n    },\n    [context, onSelect],\n  );\n\n  const iconIsReactElement = isValidElement(Icon);\n  const componentIcon = Icon as ReactElement;\n  const SvgIcon = Icon as ComponentType<SVGAttributes<SVGElement>>;\n\n  const content = (\n    <Component\n      role=\"menuitem\"\n      {...props}\n      className={classnames(className, styles.item, {\n        [styles.interactive]: onSelect !== null,\n        [styles[\"no-label\"]]: label === null,\n        [styles[\"disabled\"]]: disabled,\n      })}\n      data-kind={kind}\n      onClick={onClick}\n      disabled={Component === \"button\" ? disabled : undefined}\n      aria-disabled={Component === \"button\" ? undefined : disabled}\n    >\n      {iconIsReactElement ? (\n        <Slot className={styles.icon}>{componentIcon}</Slot>\n      ) : (\n        <SvgIcon\n          width={24}\n          height={24}\n          className={styles.icon}\n          aria-hidden={true}\n        />\n      )}\n\n      {label !== null && (\n        <Text\n          className={styles.label}\n          size=\"md\"\n          weight=\"medium\"\n          as=\"span\"\n          {...labelProps}\n        >\n          {label}\n        </Text>\n      )}\n      {/* We use CSS to swap between this navigation hint and the provided\n      children on hover - see the styles module. */}\n      {!hideChevron && (Component === \"button\" || Component === \"a\") && (\n        <ChevronRightIcon\n          width={8}\n          height={24}\n          className={styles[\"nav-hint\"]}\n          aria-hidden={true}\n          /* The SVG is a small icon in a large canvas. It probably ought to be\n             cropped, but we can adjust the viewBox here to chop off the horizontal\n             space to get it closer to the right hand edge.\n           */\n          viewBox=\"8 0 8 24\"\n        />\n      )}\n      {children}\n    </Component>\n  );\n\n  return context?.MenuItemWrapper == null || onSelect === null ? (\n    content\n  ) : (\n    <context.MenuItemWrapper onSelect={onSelect}>\n      {content}\n    </context.MenuItemWrapper>\n  );\n};\n","// packages/react/separator/src/Separator.tsx\nimport * as React from \"react\";\nimport { Primitive } from \"@radix-ui/react-primitive\";\nimport { jsx } from \"react/jsx-runtime\";\nvar NAME = \"Separator\";\nvar DEFAULT_ORIENTATION = \"horizontal\";\nvar ORIENTATIONS = [\"horizontal\", \"vertical\"];\nvar Separator = React.forwardRef((props, forwardedRef) => {\n  const { decorative, orientation: orientationProp = DEFAULT_ORIENTATION, ...domProps } = props;\n  const orientation = isValidOrientation(orientationProp) ? orientationProp : DEFAULT_ORIENTATION;\n  const ariaOrientation = orientation === \"vertical\" ? orientation : void 0;\n  const semanticProps = decorative ? { role: \"none\" } : { \"aria-orientation\": ariaOrientation, role: \"separator\" };\n  return /* @__PURE__ */ jsx(\n    Primitive.div,\n    {\n      \"data-orientation\": orientation,\n      ...semanticProps,\n      ...domProps,\n      ref: forwardedRef\n    }\n  );\n});\nSeparator.displayName = NAME;\nfunction isValidOrientation(orientation) {\n  return ORIENTATIONS.includes(orientation);\n}\nvar Root = Separator;\nexport {\n  Root,\n  Separator\n};\n//# sourceMappingURL=index.mjs.map\n","/*\nCopyright 2023, 2024 New Vector Ltd.\n\nSPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial\nPlease see LICENSE files in the repository root for full details.\n*/\n\nimport classnames from \"classnames\";\nimport * as RadixSeparator from \"@radix-ui/react-separator\";\nimport React, {\n  ComponentProps,\n  PropsWithoutRef,\n  Ref,\n  forwardRef,\n  useEffect,\n  useRef,\n} from \"react\";\nimport styles from \"./Separator.module.css\";\nimport { useMergeRefs } from \"@floating-ui/react\";\n\ntype SeparatorProps = {\n  /**\n   * The CSS class name.\n   */\n  className?: string;\n  /**\n   * The spacing on either side of the separator.\n   * @default var(--cpd-space-2x)\n   */\n  spacing?: string;\n  /**\n   * The style of separator.\n   * @default primary\n   */\n  kind?: \"primary\" | \"secondary\" | \"section\";\n} & ComponentProps<typeof RadixSeparator.Root>;\n\nconst SPACING_CUSTOM_PROP = \"--cpd-separator-spacing\";\n\n/**\n * A separator component.\n */\nexport const Separator = forwardRef(\n  (\n    {\n      className,\n      spacing, // Default provided via global.css\n      kind = \"primary\",\n      ...props\n    }: PropsWithoutRef<SeparatorProps>,\n    theirRef?: Ref<HTMLDivElement>,\n  ) => {\n    const classes = classnames(styles.separator, className);\n    const ourRef = useRef<HTMLDivElement | null>(null);\n    const ref = useMergeRefs([ourRef, theirRef]);\n\n    useEffect(() => {\n      const style = ourRef.current?.style;\n      if (spacing) {\n        style?.setProperty(SPACING_CUSTOM_PROP, spacing);\n      } else {\n        style?.removeProperty(SPACING_CUSTOM_PROP);\n      }\n    }, [spacing]);\n\n    return (\n      <RadixSeparator.Root\n        {...props}\n        className={classes}\n        ref={ref}\n        data-kind={kind}\n      />\n    );\n  },\n);\n\nSeparator.displayName = \"Separator\";\n","/*\n * Copyright 2024 New Vector Ltd.\n *\n * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial\n * Please see LICENSE files in the repository root for full details.\n */\n\nimport { createContext, useContext } from \"react\";\nimport { useTooltip } from \"./useTooltip\";\n\ntype ContextType = ReturnType<typeof useTooltip> | null;\n/**\n * The context for the Tooltip components.\n */\nexport const TooltipContext = createContext<ContextType>(null);\n\n/**\n * Provides the context for the Tooltip components.\n */\nexport function useTooltipContext() {\n  const context = useContext(TooltipContext);\n\n  if (context == null) {\n    throw new Error(\"Tooltip components must be wrapped in <Tooltip />\");\n  }\n\n  return context;\n}\n","/*\nCopyright 2023, 2024 New Vector Ltd.\n\nSPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial\nPlease see LICENSE files in the repository root for full details.\n*/\n\nimport { TooltipContext, useTooltipContext } from \"./TooltipContext\";\nimport {\n  FloatingArrow,\n  FloatingPortal,\n  useMergeRefs,\n} from \"@floating-ui/react\";\nimport React, {\n  PropsWithChildren,\n  Ref,\n  JSX,\n  isValidElement,\n  cloneElement,\n  useMemo,\n  ReactNode,\n  FC,\n  ReactElement,\n} from \"react\";\n\nimport classNames from \"classnames\";\nimport styles from \"./Tooltip.module.css\";\nimport {\n  CommonUseTooltipProps,\n  TooltipDescription,\n  TooltipLabel,\n  useTooltip,\n} from \"./useTooltip\";\n\n// Unfortunately Omit doesn't distribute nicely over sum types, so we have to\n// piece together the useTooltip options type by hand\ntype TooltipProps = Omit<CommonUseTooltipProps, \"isTriggerInteractive\"> &\n  (TooltipLabel | TooltipDescription) & {\n    /**\n     * Whether the trigger element is interactive.\n     * When trigger is interactive:\n     *      - tooltip will be shown after a 300ms delay.\n     * When trigger is not interactive:\n     *      - tooltip will be shown instantly when pointer enters trigger.\n     *      - trigger will be wrapped in a span with a tab index from prop nonInteractiveTriggerTabIndex\n     * @default true\n     */\n    isTriggerInteractive?: boolean;\n    /**\n     * The tab index for the non interactive trigger.\n     * @default 0\n     */\n    nonInteractiveTriggerTabIndex?: number;\n  };\n\nconst hasLabel = (\n  props: TooltipLabel | TooltipDescription,\n): props is TooltipLabel => \"label\" in props && !!props.label;\n\n/**\n * A tooltip component\n */\nexport function Tooltip({\n  children,\n  isTriggerInteractive = true,\n  nonInteractiveTriggerTabIndex = 0,\n  ...props\n}: PropsWithChildren<TooltipProps>): JSX.Element {\n  const context = useTooltip({ isTriggerInteractive, ...props });\n\n  return (\n    <TooltipContext.Provider value={context}>\n      <TooltipAnchor\n        isTriggerInteractive={isTriggerInteractive}\n        nonInteractiveTriggerTabIndex={nonInteractiveTriggerTabIndex}\n      >\n        {children}\n      </TooltipAnchor>\n      <TooltipContent>\n        <span id={context.labelId}>\n          {hasLabel(props) ? props.label : props.description}\n        </span>\n        <Caption />\n      </TooltipContent>\n    </TooltipContext.Provider>\n  );\n}\n\nfunction Caption() {\n  const { caption, captionId } = useTooltipContext();\n  if (!caption) return null;\n\n  const isCaptionString = typeof caption === \"string\";\n  const Container = isCaptionString ? \"span\" : \"div\";\n\n  /**\n   * Forcing dark theme, so that we have the correct contrast when\n   * using the text color secondary on a solid dark background.\n   * This is temporary and should only remain until we figure out\n   * the approach to on-solid tokens\n   **/\n  return (\n    <Container\n      id={captionId}\n      className={classNames(styles.caption, \"cpd-theme-dark\")}\n    >\n      {caption}\n    </Container>\n  );\n}\n\n/**\n * The content of the tooltip\n * @param children\n */\nfunction TooltipContent({\n  children,\n}: Readonly<PropsWithChildren>): JSX.Element | null {\n  const {\n    context: floatingContext,\n    open,\n    arrowRef,\n    purpose,\n    ...rest\n  } = useTooltipContext();\n\n  // Label tooltips are kept in the DOM even when not visually open\n  if (!open && purpose !== \"label\") return null;\n\n  return (\n    <FloatingPortal>\n      <div\n        ref={rest.refs.setFloating}\n        style={rest.floatingStyles}\n        {...rest.tooltipProps}\n        {...rest.getFloatingProps()}\n        className={classNames(styles.tooltip, {\n          [styles.invisible]: purpose === \"label\" && !open,\n        })}\n      >\n        <FloatingArrow\n          ref={arrowRef}\n          context={floatingContext}\n          // design absolute value\n          width={10}\n          height={6}\n          className={styles.arrow}\n        />\n        {children}\n      </div>\n    </FloatingPortal>\n  );\n}\n\ninterface TooltipAnchorProps {\n  children: ReactNode;\n  isTriggerInteractive: boolean;\n  nonInteractiveTriggerTabIndex?: number;\n}\n\n/**\n * The anchor of the tooltip\n * @param children\n */\nconst TooltipAnchor: FC<TooltipAnchorProps> = ({\n  children,\n  isTriggerInteractive,\n  nonInteractiveTriggerTabIndex,\n}) => {\n  const context = useTooltipContext();\n\n  // The children can have a ref and we don't want to discard it\n  // Doing a dirty cast to get the optional ref\n  const childrenRef = (children as unknown as { ref?: Ref<HTMLElement> })?.ref;\n  const ref = useMergeRefs([context.refs.setReference, childrenRef]);\n\n  const element = useMemo(() => {\n    if (!isValidElement(children)) return;\n\n    if (isTriggerInteractive) {\n      const props = context.getReferenceProps({\n        // To support React 18, we need to explicitly pass the children's props. See  https://github.com/element-hq/compound/issues/333\n        // In React 19, this is not necessary. `getReferenceProps` is able to get the props directly from the ref.\n        ...(typeof children.props === \"object\" ? children.props : {}),\n        ref,\n      });\n      return cloneElement(children, props);\n    } else {\n      // For a non-interactive trigger, we want most of the props to go on the\n      // span element that we provide, since that's what receives focus, but it\n      // should still be the trigger that receives the label/description. It\n      // would be wrong to label the span element, as it lacks a role.\n      const props = context.getReferenceProps({\n        ref,\n        tabIndex: nonInteractiveTriggerTabIndex,\n      });\n      const {\n        \"aria-labelledby\": labelId,\n        \"aria-describedby\": descriptionId,\n        ...spanProps\n      } = props;\n      return (\n        <span tabIndex={nonInteractiveTriggerTabIndex} {...spanProps}>\n          {cloneElement(children as ReactElement<Record<string, unknown>>, {\n            \"aria-labelledby\": labelId,\n            \"aria-describedby\": descriptionId,\n          })}\n        </span>\n      );\n    }\n  }, [context, ref, children]);\n\n  if (!element) {\n    throw new Error(\"Tooltip anchor must be a single valid React element\");\n  }\n\n  return element;\n};\n","/*\n * Copyright 2024 New Vector Ltd.\n *\n * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial\n * Please see LICENSE files in the repository root for full details.\n */\n\nimport {\n  arrow,\n  autoUpdate,\n  flip,\n  offset,\n  OpenChangeReason,\n  Placement,\n  shift,\n  useDelayGroup,\n  useDismiss,\n  useFloating,\n  useFocus,\n  useHover,\n  useId,\n  useInteractions,\n  useRole,\n} from \"@floating-ui/react\";\nimport {\n  useMemo,\n  useRef,\n  useState,\n  JSX,\n  AriaAttributes,\n  useEffect,\n} from \"react\";\nimport { hoverDelay } from \"./TooltipProvider\";\n\nexport interface CommonUseTooltipProps {\n  /**\n   * The controlled open state of the tooltip.\n   * If provided, the tooltip will be in controlled mode.\n   * When true, the tooltip is always open. When false, the tooltip is always hidden.\n   * When undefined, the tooltip will manage its own open state.\n   * You will mostly want to omit this property. Will be used the vast majority\n   * of the time during development.\n   * @default undefined\n   */\n  open?: boolean;\n  /**\n   * Whether the tooltip should be forced to be in a closed state.\n   */\n  // TODO: Deprecate this? It seems redundant to open: false.\n  disabled?: boolean;\n  /**\n   * The caption of the tooltip.\n   * JSX.Element can be used to provide accessibility content like kbd element.\n   * Keep in mind, the caption should not be used for interactive content.\n   */\n  caption?: string | JSX.Element;\n  /**\n   * The event handler for the open change.\n   */\n  onOpenChange?: (\n    open: boolean,\n    event?: Event | undefined,\n    reason?: OpenChangeReason | undefined,\n  ) => void;\n  /**\n   * The placement of the tooltip.\n   * @default \"bottom\"\n   */\n  placement?: Placement;\n  /**\n   * Whether the trigger element is interactive.\n   * When trigger is interactive:\n   *      - tooltip will be shown after a 300ms delay.\n   * When trigger is not interactive:\n   *      - tooltip will be shown instantly when pointer enters trigger.\n   *      - trigger will be wrapped in a span with a tab index from prop nonInteractiveTriggerTabIndex\n   */\n  isTriggerInteractive: boolean;\n\n  /**\n   * Additional aria-* attributes to pass through to the floating tooltip for\n   * edge cases which require more user awareness like errors & alerts.\n   */\n  \"aria-atomic\"?: AriaAttributes[\"aria-atomic\"];\n  \"aria-live\"?: AriaAttributes[\"aria-live\"];\n}\n\nexport interface TooltipLabel {\n  /**\n   * A label for the target element.\n   */\n  label: string;\n}\n\nexport interface TooltipDescription {\n  /**\n   * A description for the target element.\n   */\n  description: string;\n}\n\ntype UseTooltipProps = CommonUseTooltipProps &\n  (TooltipLabel | TooltipDescription);\n\nexport function useTooltip({\n  open: controlledOpen,\n  disabled = false,\n  onOpenChange,\n  placement = \"bottom\",\n  isTriggerInteractive,\n  caption,\n  \"aria-atomic\": ariaAtomic,\n  \"aria-live\": ariaLive,\n  ...props\n}: UseTooltipProps) {\n  const labelId = useId();\n  const captionId = useId();\n  const arrowRef = useRef(null);\n\n  const [uncontrolledOpen, setUncontrolledOpen] = useState(false);\n\n  // Use controlledOpen if it is provided, otherwise use uncontrolledOpen\n  const open = disabled ? false : (controlledOpen ?? uncontrolledOpen);\n  const setOpen = (\n    open: boolean,\n    event?: Event | undefined,\n    reason?: OpenChangeReason | undefined,\n  ) => {\n    onOpenChange?.(open, event, reason);\n    // we are in uncontrolled mode\n    if (controlledOpen === undefined) setUncontrolledOpen(open);\n  };\n\n  const data = useFloating({\n    placement,\n    open,\n    onOpenChange: setOpen,\n    whileElementsMounted: autoUpdate,\n    middleware: [\n      // arrow height 6px\n      offset(6),\n      flip({\n        crossAxis: placement.includes(\"-\"),\n        fallbackAxisSideDirection: \"start\",\n        padding: 5,\n      }),\n      shift({ padding: 5 }),\n      // add the little arrow along with the floating content\n      arrow({\n        element: arrowRef,\n      }),\n    ],\n  });\n\n  const context = data.context;\n  const { delay, initialDelay } = useDelayGroup(context);\n  // We can tell if no delay group has been provided, because the delay will\n  // default to zero\n  if (initialDelay !== hoverDelay)\n    throw new Error(\"Tooltips must be wrapped in a global <TooltipProvider>\");\n\n  const hover = useHover(context, {\n    move: false,\n    enabled: controlledOpen === undefined,\n    // Show tooltip after a delay when trigger is interactive\n    delay: isTriggerInteractive ? delay : {},\n    mouseOnly: true,\n  });\n\n  const focus = useFocus(context, {\n    enabled: controlledOpen === undefined,\n  });\n\n  // On touch screens, show the tooltip on a long press\n  const pressTimer = useRef<number | undefined>(undefined);\n  useEffect(() => () => window.clearTimeout(pressTimer.current), []);\n  const press = useMemo(() => {\n    const onTouchEnd = () => {\n      if (pressTimer.current === undefined)\n        pressTimer.current = window.setTimeout(() => {\n          setOpen(false);\n          pressTimer.current = undefined;\n        }, 1500);\n      else window.clearTimeout(pressTimer.current);\n    };\n    return {\n      // Set these props on the anchor element\n      reference: {\n        onTouchStart: () => {\n          if (pressTimer.current !== undefined)\n            window.clearTimeout(pressTimer.current);\n          pressTimer.current = window.setTimeout(() => {\n            setOpen(true);\n            pressTimer.current = undefined;\n          }, 500);\n        },\n        onTouchEnd,\n        onTouchCancel: onTouchEnd,\n      },\n    };\n  }, []);\n\n  const dismiss = useDismiss(context);\n\n  const purpose = \"label\" in props ? \"label\" : \"description\";\n  // A descriptive tooltip should set role=\"tooltip\" and aria-describedby\n  const role = useRole(context, {\n    enabled: purpose === \"description\",\n    role: \"tooltip\",\n  });\n\n  // A label tooltip should set aria-labelledby with no role regardless of\n  // whether the tooltip is visible.\n  // (Source: https://zoebijl.github.io/apg-tooltip/#tooltip-main-label)\n  // useRole doesn't support this use case correctly, so we do it manually.\n  const label = useMemo(\n    () =>\n      purpose === \"label\"\n        ? {\n            // Set these props on the anchor element\n            reference: {\n              \"aria-labelledby\": labelId,\n              \"aria-describedby\": caption ? captionId : undefined,\n            },\n          }\n        : {},\n    [purpose, labelId, captionId],\n  );\n\n  const interactions = useInteractions([\n    hover,\n    focus,\n    press,\n    dismiss,\n    role,\n    label,\n  ]);\n\n  return useMemo(\n    () => ({\n      labelId,\n      captionId: caption ? captionId : undefined,\n      caption,\n      purpose: purpose as \"label\" | \"description\",\n      open,\n      setOpen,\n      tooltipProps: {\n        \"aria-atomic\": ariaAtomic,\n        \"aria-live\": ariaLive,\n      },\n      ...interactions,\n      ...data,\n      arrowRef,\n    }),\n    [\n      labelId,\n      captionId,\n      caption,\n      role,\n      open,\n      setOpen,\n      interactions,\n      data,\n      arrowRef,\n    ],\n  );\n}\n","import { FloatingDelayGroup } from \"@floating-ui/react\";\nimport React, { FC } from \"react\";\n\nexport const hoverDelay = { open: 300, close: 0 };\n\ninterface Props {\n  children: React.ReactNode;\n}\n\n/**\n * Enables tooltips to share a global \"warm-up\" period for their hover delay.\n * You must wrap your application in this component for tooltips to function.\n */\nexport const TooltipProvider: FC<Props> = ({ children }) => (\n  <FloatingDelayGroup delay={hoverDelay} timeoutMs={300}>\n    {children}\n  </FloatingDelayGroup>\n);\n\nTooltipProvider.displayName = \"TooltipProvider\";\n","/*\nCopyright 2025 New Vector Ltd.\nCopyright 2023 The Matrix.org Foundation C.I.C.\n\nSPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial\nPlease see LICENSE files in the repository root for full details.\n*/\n\nimport React from \"react\";\nimport { Typography } from \"./Typography\";\nimport { Text } from \"./Text\";\n\ntype TypographyProps = React.ComponentProps<typeof Typography>;\n\n/**\n * A heading component.\n */\nexport const Heading: React.FC<\n  Omit<TypographyProps, \"type\"> & {\n    // xs is not a valid heading size\n    size?: Exclude<TypographyProps[\"size\"], \"xs\">;\n  }\n> = ({ as = \"h1\", children, ...props }) => {\n  return (\n    <Typography as={as} type=\"heading\" {...props}>\n      {children}\n    </Typography>\n  );\n};\n\ntype HeadingProps = Omit<\n  React.ComponentProps<typeof Heading>,\n  \"as\" | \"weight\" | \"size\"\n>;\n\n/**\n * A Heading level-1 styled component. Underlying HTML element can be changed\n * usign the `as` property.\n */\nexport const H1: React.FC<HeadingProps> = ({ children, ...props }) => {\n  return (\n    <Heading as=\"h1\" weight=\"semibold\" size=\"xl\" {...props}>\n      {children}\n    </Heading>\n  );\n};\n\n/**\n * A Heading level-2 styled component. Underlying HTML element can be changed\n * usign the `as` property.\n */\nexport const H2: React.FC<HeadingProps> = ({ children, ...props }) => {\n  return (\n    <Heading as=\"h2\" weight=\"semibold\" size=\"lg\" {...props}>\n      {children}\n    </Heading>\n  );\n};\n\n/**\n * A Heading level-3 styled component. Underlying HTML element can be changed\n * usign the `as` property.\n */\nexport const H3: React.FC<HeadingProps> = ({ children, ...props }) => {\n  return (\n    <Heading as=\"h3\" weight=\"semibold\" size=\"md\" {...props}>\n      {children}\n    </Heading>\n  );\n};\n\n/**\n * A Heading level-4 styled component. Underlying HTML element can be changed\n * usign the `as` property.\n */\nexport const H4: React.FC<HeadingProps> = ({ children, ...props }) => {\n  return (\n    <Heading as=\"h4\" weight=\"semibold\" size=\"sm\" {...props}>\n      {children}\n    </Heading>\n  );\n};\n\n/**\n * A Heading level-5 styled component. Underlying HTML element can be changed\n * usign the `as` property.\n */\nexport const H5: React.FC<HeadingProps> = ({ children, ...props }) => {\n  return (\n    <Text as=\"h5\" weight=\"semibold\" size=\"lg\" {...props}>\n      {children}\n    </Text>\n  );\n};\n\n/**\n * A Heading level-6 styled component. Underlying HTML element can be changed\n * usign the `as` property.\n */\nexport const H6: React.FC<HeadingProps> = ({ children, ...props }) => {\n  return (\n    <Text as=\"h6\" weight=\"semibold\" size=\"md\" {...props}>\n      {children}\n    </Text>\n  );\n};\n","/*\nCopyright 2025 New Vector Ltd.\nCopyright 2023 The Matrix.org Foundation C.I.C.\n\nSPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial\nPlease see LICENSE files in the repository root for full details.\n*/\n\nimport React from \"react\";\nimport { Typography } from \"./Typography\";\n\ntype TypographyProps = React.ComponentProps<typeof Typography>;\n\n/**\n * A text component. Underlying HTML element can be changed using the `as`\n * property. Will default to be a paragraph.\n */\nexport const Text: React.FC<\n  Omit<TypographyProps, \"type\"> & {\n    // xl is not a valid text size\n    size?: Exclude<TypographyProps[\"size\"], \"xl\">;\n  }\n> = ({ as = \"p\", children, ...props }) => {\n  return (\n    <Typography as={as} type=\"body\" {...props}>\n      {children}\n    </Typography>\n  );\n};\n","/*\nCopyright 2025 New Vector Ltd.\nCopyright 2023 The Matrix.org Foundation C.I.C.\n\nSPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial\nPlease see LICENSE files in the repository root for full details.\n*/\n\nimport React, { PropsWithChildren } from \"react\";\nimport classNames from \"classnames\";\n\nimport styles from \"./Typography.module.css\";\n\ntype TypographyProps<C extends React.ElementType> = {\n  /**\n   * The HTML tag.\n   * @default \"p\"\n   */\n  as?: C;\n  /**\n   * The type of content.\n   */\n  type?: \"body\" | \"heading\";\n  /**\n   * The font weight.\n   */\n  weight?: \"regular\" | \"semibold\" | \"medium\" | \"bold\";\n  /**\n   * The t-shirt size of the content.\n   */\n  size?: \"xs\" | \"sm\" | \"md\" | \"lg\" | \"xl\";\n  /**\n   * The CSS class name.\n   */\n  className?: string;\n} & React.ComponentPropsWithoutRef<C>;\n\nexport const Typography = <C extends React.ElementType = \"p\">({\n  as,\n  children,\n  type = \"body\",\n  weight = \"regular\",\n  size = \"md\",\n  className,\n  ...restProps\n}: PropsWithChildren<TypographyProps<C>>): React.ReactElement => {\n  const Component = as || \"p\";\n\n  return (\n    <Component\n      {...restProps}\n      className={classNames(\n        styles.typography,\n        styles[`font-${type}-${size}-${weight}`],\n        className,\n      )}\n    >\n      {children}\n    </Component>\n  );\n};\n","'use strict';\n\nvar possibleNames = require('possible-typed-array-names');\n\nvar g = typeof globalThis === 'undefined' ? global : globalThis;\n\n/** @type {import('.')} */\nmodule.exports = function availableTypedArrays() {\n\tvar /** @type {ReturnType<typeof availableTypedArrays>} */ out = [];\n\tfor (var i = 0; i < possibleNames.length; i++) {\n\t\tif (typeof g[possibleNames[i]] === 'function') {\n\t\t\t// @ts-expect-error\n\t\t\tout[out.length] = possibleNames[i];\n\t\t}\n\t}\n\treturn out;\n};\n","/**\n * A mutex lock for coordination across async functions\n */\nexport default class AwaitLock {\n  #acquired: boolean = false;\n  #waitingResolvers: Set<() => void> = new Set();\n\n  /**\n   * Whether the lock is currently acquired or not. Accessing this property does not affect the\n   * status of the lock.\n   */\n  get acquired(): boolean {\n    return this.#acquired;\n  }\n\n  /**\n   * Acquires the lock, waiting if necessary for it to become free if it is already locked. The\n   * returned promise is fulfilled once the lock is acquired.\n   *\n   * A timeout (in milliseconds) may be optionally provided. If the lock cannot be acquired before\n   * the timeout elapses, the returned promise is rejected with an error. The behavior of invalid\n   * timeout values depends on how `setTimeout` handles those values.\n   *\n   * After acquiring the lock, you **must** call `release` when you are done with it.\n   */\n  acquireAsync({ timeout }: { timeout?: number } = {}): Promise<void> {\n    if (!this.#acquired) {\n      this.#acquired = true;\n      return Promise.resolve();\n    }\n\n    if (timeout == null) {\n      return new Promise((resolve) => {\n        this.#waitingResolvers.add(resolve);\n      });\n    }\n\n    let resolver: () => void;\n    let timer: ReturnType<typeof setTimeout>;\n\n    return Promise.race<void>([\n      new Promise((resolve) => {\n        resolver = () => {\n          clearTimeout(timer);\n          resolve();\n        };\n        this.#waitingResolvers.add(resolver);\n      }),\n      new Promise<void>((_, reject) => {\n        timer = setTimeout(() => {\n          this.#waitingResolvers.delete(resolver);\n          reject(new Error(`Timed out waiting for lock`));\n        }, timeout);\n      }),\n    ]);\n  }\n\n  /**\n   * Acquires the lock if it is free and otherwise returns immediately without waiting. Returns\n   * `true` if the lock was free and is now acquired, and `false` otherwise.\n   *\n   * This method differs from calling `acquireAsync` with a zero-millisecond timeout in that it runs\n   * synchronously without waiting for the JavaScript task queue.\n   */\n  tryAcquire(): boolean {\n    if (!this.#acquired) {\n      this.#acquired = true;\n      return true;\n    }\n\n    return false;\n  }\n\n  /**\n   * Releases the lock and gives it to the next waiting acquirer, if there is one. Each acquirer\n   * must release the lock exactly once.\n   */\n  release(): void {\n    if (!this.#acquired) {\n      throw new Error(`Cannot release an unacquired lock`);\n    }\n\n    if (this.#waitingResolvers.size > 0) {\n      // Sets preserve insertion order like a queue\n      const [resolve] = this.#waitingResolvers;\n      this.#waitingResolvers.delete(resolve);\n      resolve();\n    } else {\n      this.#acquired = false;\n    }\n  }\n}\n","const digitCharacters = [\n  \"0\",\n  \"1\",\n  \"2\",\n  \"3\",\n  \"4\",\n  \"5\",\n  \"6\",\n  \"7\",\n  \"8\",\n  \"9\",\n  \"A\",\n  \"B\",\n  \"C\",\n  \"D\",\n  \"E\",\n  \"F\",\n  \"G\",\n  \"H\",\n  \"I\",\n  \"J\",\n  \"K\",\n  \"L\",\n  \"M\",\n  \"N\",\n  \"O\",\n  \"P\",\n  \"Q\",\n  \"R\",\n  \"S\",\n  \"T\",\n  \"U\",\n  \"V\",\n  \"W\",\n  \"X\",\n  \"Y\",\n  \"Z\",\n  \"a\",\n  \"b\",\n  \"c\",\n  \"d\",\n  \"e\",\n  \"f\",\n  \"g\",\n  \"h\",\n  \"i\",\n  \"j\",\n  \"k\",\n  \"l\",\n  \"m\",\n  \"n\",\n  \"o\",\n  \"p\",\n  \"q\",\n  \"r\",\n  \"s\",\n  \"t\",\n  \"u\",\n  \"v\",\n  \"w\",\n  \"x\",\n  \"y\",\n  \"z\",\n  \"#\",\n  \"$\",\n  \"%\",\n  \"*\",\n  \"+\",\n  \",\",\n  \"-\",\n  \".\",\n  \":\",\n  \";\",\n  \"=\",\n  \"?\",\n  \"@\",\n  \"[\",\n  \"]\",\n  \"^\",\n  \"_\",\n  \"{\",\n  \"|\",\n  \"}\",\n  \"~\",\n];\n\nexport const decode83 = (str: String) => {\n  let value = 0;\n  for (let i = 0; i < str.length; i++) {\n    const c = str[i];\n    const digit = digitCharacters.indexOf(c);\n    value = value * 83 + digit;\n  }\n  return value;\n};\n\nexport const encode83 = (n: number, length: number): string => {\n  var result = \"\";\n  for (let i = 1; i <= length; i++) {\n    let digit = (Math.floor(n) / Math.pow(83, length - i)) % 83;\n    result += digitCharacters[Math.floor(digit)];\n  }\n  return result;\n};\n","export const sRGBToLinear = (value: number) => {\n  let v = value / 255;\n  if (v <= 0.04045) {\n    return v / 12.92;\n  } else {\n    return Math.pow((v + 0.055) / 1.055, 2.4);\n  }\n};\n\nexport const linearTosRGB = (value: number) => {\n  let v = Math.max(0, Math.min(1, value));\n  if (v <= 0.0031308) {\n    return Math.trunc(v * 12.92 * 255 + 0.5);\n  } else {\n    return Math.trunc((1.055 * Math.pow(v, 1 / 2.4) - 0.055) * 255 + 0.5);\n  }\n};\n\nexport const sign = (n: number) => (n < 0 ? -1 : 1);\n\nexport const signPow = (val: number, exp: number) =>\n  sign(val) * Math.pow(Math.abs(val), exp);\n","export class ValidationError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = \"ValidationError\";\n    this.message = message;\n  }\n}\n","import { decode83 } from \"./base83\";\nimport { sRGBToLinear, signPow, linearTosRGB } from \"./utils\";\nimport { ValidationError } from \"./error\";\n\n/**\n * Returns an error message if invalid or undefined if valid\n * @param blurhash\n */\nconst validateBlurhash = (blurhash: string) => {\n  if (!blurhash || blurhash.length < 6) {\n    throw new ValidationError(\n      \"The blurhash string must be at least 6 characters\"\n    );\n  }\n\n  const sizeFlag = decode83(blurhash[0]);\n  const numY = Math.floor(sizeFlag / 9) + 1;\n  const numX = (sizeFlag % 9) + 1;\n\n  if (blurhash.length !== 4 + 2 * numX * numY) {\n    throw new ValidationError(\n      `blurhash length mismatch: length is ${\n        blurhash.length\n      } but it should be ${4 + 2 * numX * numY}`\n    );\n  }\n};\n\nexport const isBlurhashValid = (\n  blurhash: string\n): { result: boolean; errorReason?: string } => {\n  try {\n    validateBlurhash(blurhash);\n  } catch (error) {\n    return { result: false, errorReason: error.message };\n  }\n\n  return { result: true };\n};\n\nconst decodeDC = (value: number) => {\n  const intR = value >> 16;\n  const intG = (value >> 8) & 255;\n  const intB = value & 255;\n  return [sRGBToLinear(intR), sRGBToLinear(intG), sRGBToLinear(intB)];\n};\n\nconst decodeAC = (value: number, maximumValue: number) => {\n  const quantR = Math.floor(value / (19 * 19));\n  const quantG = Math.floor(value / 19) % 19;\n  const quantB = value % 19;\n\n  const rgb = [\n    signPow((quantR - 9) / 9, 2.0) * maximumValue,\n    signPow((quantG - 9) / 9, 2.0) * maximumValue,\n    signPow((quantB - 9) / 9, 2.0) * maximumValue,\n  ];\n\n  return rgb;\n};\n\nconst decode = (\n  blurhash: string,\n  width: number,\n  height: number,\n  punch?: number\n) => {\n  validateBlurhash(blurhash);\n\n  punch = punch | 1;\n\n  const sizeFlag = decode83(blurhash[0]);\n  const numY = Math.floor(sizeFlag / 9) + 1;\n  const numX = (sizeFlag % 9) + 1;\n\n  const quantisedMaximumValue = decode83(blurhash[1]);\n  const maximumValue = (quantisedMaximumValue + 1) / 166;\n\n  const colors = new Array(numX * numY);\n\n  for (let i = 0; i < colors.length; i++) {\n    if (i === 0) {\n      const value = decode83(blurhash.substring(2, 6));\n      colors[i] = decodeDC(value);\n    } else {\n      const value = decode83(blurhash.substring(4 + i * 2, 6 + i * 2));\n      colors[i] = decodeAC(value, maximumValue * punch);\n    }\n  }\n\n  const bytesPerRow = width * 4;\n  const pixels = new Uint8ClampedArray(bytesPerRow * height);\n\n  for (let y = 0; y < height; y++) {\n    for (let x = 0; x < width; x++) {\n      let r = 0;\n      let g = 0;\n      let b = 0;\n\n      for (let j = 0; j < numY; j++) {\n        for (let i = 0; i < numX; i++) {\n          const basis =\n            Math.cos((Math.PI * x * i) / width) *\n            Math.cos((Math.PI * y * j) / height);\n          let color = colors[i + j * numX];\n          r += color[0] * basis;\n          g += color[1] * basis;\n          b += color[2] * basis;\n        }\n      }\n\n      let intR = linearTosRGB(r);\n      let intG = linearTosRGB(g);\n      let intB = linearTosRGB(b);\n\n      pixels[4 * x + 0 + y * bytesPerRow] = intR;\n      pixels[4 * x + 1 + y * bytesPerRow] = intG;\n      pixels[4 * x + 2 + y * bytesPerRow] = intB;\n      pixels[4 * x + 3 + y * bytesPerRow] = 255; // alpha\n    }\n  }\n  return pixels;\n};\n\nexport default decode;\n","var BrowserslistError = require('./error')\n\nfunction noop() {}\n\nmodule.exports = {\n  loadQueries: function loadQueries() {\n    throw new BrowserslistError(\n      'Sharable configs are not supported in client-side build of Browserslist'\n    )\n  },\n\n  getStat: function getStat(opts) {\n    return opts.stats\n  },\n\n  loadConfig: function loadConfig(opts) {\n    if (opts.config) {\n      throw new BrowserslistError(\n        'Browserslist config are not supported in client-side build'\n      )\n    }\n  },\n\n  loadCountry: function loadCountry() {\n    throw new BrowserslistError(\n      'Country statistics are not supported ' +\n        'in client-side build of Browserslist'\n    )\n  },\n\n  loadFeature: function loadFeature() {\n    throw new BrowserslistError(\n      'Supports queries are not available in client-side build of Browserslist'\n    )\n  },\n\n  currentNode: function currentNode(resolve, context) {\n    return resolve(['maintained node versions'], context)[0]\n  },\n\n  parseConfig: noop,\n\n  readConfig: noop,\n\n  findConfig: noop,\n\n  findConfigFile: noop,\n\n  clearCaches: noop,\n\n  oldDataWarning: noop,\n\n  env: {}\n}\n","function BrowserslistError(message) {\n  this.name = 'BrowserslistError'\n  this.message = message\n  this.browserslist = true\n  if (Error.captureStackTrace) {\n    Error.captureStackTrace(this, BrowserslistError)\n  }\n}\n\nBrowserslistError.prototype = Error.prototype\n\nmodule.exports = BrowserslistError\n","var jsReleases = require('node-releases/data/processed/envs.json')\nvar agents = require('caniuse-lite/dist/unpacker/agents').agents\nvar e2c = require('electron-to-chromium/versions')\nvar jsEOL = require('node-releases/data/release-schedule/release-schedule.json')\nvar path = require('path')\n\nvar BrowserslistError = require('./error')\nvar env = require('./node')\nvar parseWithoutCache = require('./parse') // Will load browser.js in webpack\n\nvar YEAR = 365.259641 * 24 * 60 * 60 * 1000\nvar ANDROID_EVERGREEN_FIRST = '37'\nvar OP_MOB_BLINK_FIRST = 14\n\n// Helpers\n\nfunction isVersionsMatch(versionA, versionB) {\n  return (versionA + '.').indexOf(versionB + '.') === 0\n}\n\nfunction isEolReleased(name) {\n  var version = name.slice(1)\n  return browserslist.nodeVersions.some(function (i) {\n    return isVersionsMatch(i, version)\n  })\n}\n\nfunction normalize(versions) {\n  return versions.filter(function (version) {\n    return typeof version === 'string'\n  })\n}\n\nfunction normalizeElectron(version) {\n  var versionToUse = version\n  if (version.split('.').length === 3) {\n    versionToUse = version.split('.').slice(0, -1).join('.')\n  }\n  return versionToUse\n}\n\nfunction nameMapper(name) {\n  return function mapName(version) {\n    return name + ' ' + version\n  }\n}\n\nfunction getMajor(version) {\n  return parseInt(version.split('.')[0])\n}\n\nfunction getMajorVersions(released, number) {\n  if (released.length === 0) return []\n  var majorVersions = uniq(released.map(getMajor))\n  var minimum = majorVersions[majorVersions.length - number]\n  if (!minimum) {\n    return released\n  }\n  var selected = []\n  for (var i = released.length - 1; i >= 0; i--) {\n    if (minimum > getMajor(released[i])) break\n    selected.unshift(released[i])\n  }\n  return selected\n}\n\nfunction uniq(array) {\n  var filtered = []\n  for (var i = 0; i < array.length; i++) {\n    if (filtered.indexOf(array[i]) === -1) filtered.push(array[i])\n  }\n  return filtered\n}\n\nfunction fillUsage(result, name, data) {\n  for (var i in data) {\n    result[name + ' ' + i] = data[i]\n  }\n}\n\nfunction generateFilter(sign, version) {\n  version = parseFloat(version)\n  if (sign === '>') {\n    return function (v) {\n      return parseLatestFloat(v) > version\n    }\n  } else if (sign === '>=') {\n    return function (v) {\n      return parseLatestFloat(v) >= version\n    }\n  } else if (sign === '<') {\n    return function (v) {\n      return parseFloat(v) < version\n    }\n  } else {\n    return function (v) {\n      return parseFloat(v) <= version\n    }\n  }\n\n  function parseLatestFloat(v) {\n    return parseFloat(v.split('-')[1] || v)\n  }\n}\n\nfunction generateSemverFilter(sign, version) {\n  version = version.split('.').map(parseSimpleInt)\n  version[1] = version[1] || 0\n  version[2] = version[2] || 0\n  if (sign === '>') {\n    return function (v) {\n      v = v.split('.').map(parseSimpleInt)\n      return compareSemver(v, version) > 0\n    }\n  } else if (sign === '>=') {\n    return function (v) {\n      v = v.split('.').map(parseSimpleInt)\n      return compareSemver(v, version) >= 0\n    }\n  } else if (sign === '<') {\n    return function (v) {\n      v = v.split('.').map(parseSimpleInt)\n      return compareSemver(version, v) > 0\n    }\n  } else {\n    return function (v) {\n      v = v.split('.').map(parseSimpleInt)\n      return compareSemver(version, v) >= 0\n    }\n  }\n}\n\nfunction parseSimpleInt(x) {\n  return parseInt(x)\n}\n\nfunction compare(a, b) {\n  if (a < b) return -1\n  if (a > b) return +1\n  return 0\n}\n\nfunction compareSemver(a, b) {\n  return (\n    compare(parseInt(a[0]), parseInt(b[0])) ||\n    compare(parseInt(a[1] || '0'), parseInt(b[1] || '0')) ||\n    compare(parseInt(a[2] || '0'), parseInt(b[2] || '0'))\n  )\n}\n\n// this follows the npm-like semver behavior\nfunction semverFilterLoose(operator, range) {\n  range = range.split('.').map(parseSimpleInt)\n  if (typeof range[1] === 'undefined') {\n    range[1] = 'x'\n  }\n  // ignore any patch version because we only return minor versions\n  // range[2] = 'x'\n  switch (operator) {\n    case '<=':\n      return function (version) {\n        version = version.split('.').map(parseSimpleInt)\n        return compareSemverLoose(version, range) <= 0\n      }\n    case '>=':\n    default:\n      return function (version) {\n        version = version.split('.').map(parseSimpleInt)\n        return compareSemverLoose(version, range) >= 0\n      }\n  }\n}\n\n// this follows the npm-like semver behavior\nfunction compareSemverLoose(version, range) {\n  if (version[0] !== range[0]) {\n    return version[0] < range[0] ? -1 : +1\n  }\n  if (range[1] === 'x') {\n    return 0\n  }\n  if (version[1] !== range[1]) {\n    return version[1] < range[1] ? -1 : +1\n  }\n  return 0\n}\n\nfunction resolveVersion(data, version) {\n  if (data.versions.indexOf(version) !== -1) {\n    return version\n  } else if (browserslist.versionAliases[data.name][version]) {\n    return browserslist.versionAliases[data.name][version]\n  } else {\n    return false\n  }\n}\n\nfunction normalizeVersion(data, version) {\n  var resolved = resolveVersion(data, version)\n  if (resolved) {\n    return resolved\n  } else if (data.versions.length === 1) {\n    return data.versions[0]\n  } else {\n    return false\n  }\n}\n\nfunction filterByYear(since, context) {\n  since = since / 1000\n  return Object.keys(agents).reduce(function (selected, name) {\n    var data = byName(name, context)\n    if (!data) return selected\n    var versions = Object.keys(data.releaseDate).filter(function (v) {\n      var date = data.releaseDate[v]\n      return date !== null && date >= since\n    })\n    return selected.concat(versions.map(nameMapper(data.name)))\n  }, [])\n}\n\nfunction cloneData(data) {\n  return {\n    name: data.name,\n    versions: data.versions,\n    released: data.released,\n    releaseDate: data.releaseDate\n  }\n}\n\nfunction byName(name, context) {\n  name = name.toLowerCase()\n  name = browserslist.aliases[name] || name\n  if (context.mobileToDesktop && browserslist.desktopNames[name]) {\n    var desktop = browserslist.data[browserslist.desktopNames[name]]\n    if (name === 'android') {\n      return normalizeAndroidData(cloneData(browserslist.data[name]), desktop)\n    } else {\n      var cloned = cloneData(desktop)\n      cloned.name = name\n      return cloned\n    }\n  }\n  return browserslist.data[name]\n}\n\nfunction normalizeAndroidVersions(androidVersions, chromeVersions) {\n  var iFirstEvergreen = chromeVersions.indexOf(ANDROID_EVERGREEN_FIRST)\n  return androidVersions\n    .filter(function (version) {\n      return /^(?:[2-4]\\.|[34]$)/.test(version)\n    })\n    .concat(chromeVersions.slice(iFirstEvergreen))\n}\n\nfunction copyObject(obj) {\n  var copy = {}\n  for (var key in obj) {\n    copy[key] = obj[key]\n  }\n  return copy\n}\n\nfunction normalizeAndroidData(android, chrome) {\n  android.released = normalizeAndroidVersions(android.released, chrome.released)\n  android.versions = normalizeAndroidVersions(android.versions, chrome.versions)\n  android.releaseDate = copyObject(android.releaseDate)\n  android.released.forEach(function (v) {\n    if (android.releaseDate[v] === undefined) {\n      android.releaseDate[v] = chrome.releaseDate[v]\n    }\n  })\n  return android\n}\n\nfunction checkName(name, context) {\n  var data = byName(name, context)\n  if (!data) throw new BrowserslistError('Unknown browser ' + name)\n  return data\n}\n\nfunction unknownQuery(query) {\n  return new BrowserslistError(\n    'Unknown browser query `' +\n      query +\n      '`. ' +\n      'Maybe you are using old Browserslist or made typo in query.'\n  )\n}\n\n// Adjusts last X versions queries for some mobile browsers,\n// where caniuse data jumps from a legacy version to the latest\nfunction filterJumps(list, name, nVersions, context) {\n  var jump = 1\n  switch (name) {\n    case 'android':\n      if (context.mobileToDesktop) return list\n      var released = browserslist.data.chrome.released\n      jump = released.length - released.indexOf(ANDROID_EVERGREEN_FIRST)\n      break\n    case 'op_mob':\n      var latest = browserslist.data.op_mob.released.slice(-1)[0]\n      jump = getMajor(latest) - OP_MOB_BLINK_FIRST + 1\n      break\n    default:\n      return list\n  }\n  if (nVersions <= jump) {\n    return list.slice(-1)\n  }\n  return list.slice(jump - 1 - nVersions)\n}\n\nfunction isSupported(flags, withPartial) {\n  return (\n    typeof flags === 'string' &&\n    (flags.indexOf('y') >= 0 || (withPartial && flags.indexOf('a') >= 0))\n  )\n}\n\nfunction resolve(queries, context) {\n  return parseQueries(queries).reduce(function (result, node, index) {\n    if (node.not && index === 0) {\n      throw new BrowserslistError(\n        'Write any browsers query (for instance, `defaults`) ' +\n          'before `' +\n          node.query +\n          '`'\n      )\n    }\n    var type = QUERIES[node.type]\n    var array = type.select.call(browserslist, context, node).map(function (j) {\n      var parts = j.split(' ')\n      if (parts[1] === '0') {\n        return parts[0] + ' ' + byName(parts[0], context).versions[0]\n      } else {\n        return j\n      }\n    })\n\n    if (node.compose === 'and') {\n      if (node.not) {\n        return result.filter(function (j) {\n          return array.indexOf(j) === -1\n        })\n      } else {\n        return result.filter(function (j) {\n          return array.indexOf(j) !== -1\n        })\n      }\n    } else {\n      if (node.not) {\n        var filter = {}\n        array.forEach(function (j) {\n          filter[j] = true\n        })\n        return result.filter(function (j) {\n          return !filter[j]\n        })\n      }\n      return result.concat(array)\n    }\n  }, [])\n}\n\nfunction prepareOpts(opts) {\n  if (typeof opts === 'undefined') opts = {}\n\n  if (typeof opts.path === 'undefined') {\n    opts.path = path.resolve ? path.resolve('.') : '.'\n  }\n\n  return opts\n}\n\nfunction prepareQueries(queries, opts) {\n  if (typeof queries === 'undefined' || queries === null) {\n    var config = browserslist.loadConfig(opts)\n    if (config) {\n      queries = config\n    } else {\n      queries = browserslist.defaults\n    }\n  }\n\n  return queries\n}\n\nfunction checkQueries(queries) {\n  if (!(typeof queries === 'string' || Array.isArray(queries))) {\n    throw new BrowserslistError(\n      'Browser queries must be an array or string. Got ' + typeof queries + '.'\n    )\n  }\n}\n\nvar cache = {}\nvar parseCache = {}\n\nfunction browserslist(queries, opts) {\n  opts = prepareOpts(opts)\n  queries = prepareQueries(queries, opts)\n  checkQueries(queries)\n\n  var needsPath = parseQueries(queries).some(function (node) {\n    return QUERIES[node.type].needsPath\n  })\n  var context = {\n    ignoreUnknownVersions: opts.ignoreUnknownVersions,\n    dangerousExtend: opts.dangerousExtend,\n    mobileToDesktop: opts.mobileToDesktop,\n    env: opts.env\n  }\n  // Removing to avoid using context.path without marking query as needsPath\n  if (needsPath) {\n    context.path = opts.path\n  }\n\n  env.oldDataWarning(browserslist.data)\n  var stats = env.getStat(opts, browserslist.data)\n  if (stats) {\n    context.customUsage = {}\n    for (var browser in stats) {\n      fillUsage(context.customUsage, browser, stats[browser])\n    }\n  }\n\n  var cacheKey = JSON.stringify([queries, context])\n  if (cache[cacheKey]) return cache[cacheKey]\n\n  var result = uniq(resolve(queries, context)).sort(function (name1, name2) {\n    name1 = name1.split(' ')\n    name2 = name2.split(' ')\n    if (name1[0] === name2[0]) {\n      // assumptions on caniuse data\n      // 1) version ranges never overlaps\n      // 2) if version is not a range, it never contains `-`\n      var version1 = name1[1].split('-')[0]\n      var version2 = name2[1].split('-')[0]\n      return compareSemver(version2.split('.'), version1.split('.'))\n    } else {\n      return compare(name1[0], name2[0])\n    }\n  })\n  if (!env.env.BROWSERSLIST_DISABLE_CACHE) {\n    cache[cacheKey] = result\n  }\n  return result\n}\n\nfunction parseQueries(queries) {\n  var cacheKey = JSON.stringify(queries)\n  if (cacheKey in parseCache) return parseCache[cacheKey]\n  var result = parseWithoutCache(QUERIES, queries)\n  if (!env.env.BROWSERSLIST_DISABLE_CACHE) {\n    parseCache[cacheKey] = result\n  }\n  return result\n}\n\nbrowserslist.parse = function (queries, opts) {\n  opts = prepareOpts(opts)\n  queries = prepareQueries(queries, opts)\n  checkQueries(queries)\n  return parseQueries(queries)\n}\n\n// Will be filled by Can I Use data below\nbrowserslist.cache = {}\nbrowserslist.data = {}\nbrowserslist.usage = {\n  global: {},\n  custom: null\n}\n\n// Default browsers query\nbrowserslist.defaults = ['> 0.5%', 'last 2 versions', 'Firefox ESR', 'not dead']\n\n// Browser names aliases\nbrowserslist.aliases = {\n  fx: 'firefox',\n  ff: 'firefox',\n  ios: 'ios_saf',\n  explorer: 'ie',\n  blackberry: 'bb',\n  explorermobile: 'ie_mob',\n  operamini: 'op_mini',\n  operamobile: 'op_mob',\n  chromeandroid: 'and_chr',\n  firefoxandroid: 'and_ff',\n  ucandroid: 'and_uc',\n  qqandroid: 'and_qq'\n}\n\n// Can I Use only provides a few versions for some browsers (e.g. and_chr).\n// Fallback to a similar browser for unknown versions\n// Note op_mob is not included as its chromium versions are not in sync with Opera desktop\nbrowserslist.desktopNames = {\n  and_chr: 'chrome',\n  and_ff: 'firefox',\n  ie_mob: 'ie',\n  android: 'chrome' // has extra processing logic\n}\n\n// Aliases to work with joined versions like `ios_saf 7.0-7.1`\nbrowserslist.versionAliases = {}\n\nbrowserslist.clearCaches = env.clearCaches\nbrowserslist.parseConfig = env.parseConfig\nbrowserslist.readConfig = env.readConfig\nbrowserslist.findConfigFile = env.findConfigFile\nbrowserslist.findConfig = env.findConfig\nbrowserslist.loadConfig = env.loadConfig\n\nbrowserslist.coverage = function (browsers, stats) {\n  var data\n  if (typeof stats === 'undefined') {\n    data = browserslist.usage.global\n  } else if (stats === 'my stats') {\n    var opts = {}\n    opts.path = path.resolve ? path.resolve('.') : '.'\n    var customStats = env.getStat(opts)\n    if (!customStats) {\n      throw new BrowserslistError('Custom usage statistics was not provided')\n    }\n    data = {}\n    for (var browser in customStats) {\n      fillUsage(data, browser, customStats[browser])\n    }\n  } else if (typeof stats === 'string') {\n    if (stats.length > 2) {\n      stats = stats.toLowerCase()\n    } else {\n      stats = stats.toUpperCase()\n    }\n    env.loadCountry(browserslist.usage, stats, browserslist.data)\n    data = browserslist.usage[stats]\n  } else {\n    if ('dataByBrowser' in stats) {\n      stats = stats.dataByBrowser\n    }\n    data = {}\n    for (var name in stats) {\n      for (var version in stats[name]) {\n        data[name + ' ' + version] = stats[name][version]\n      }\n    }\n  }\n\n  return browsers.reduce(function (all, i) {\n    var usage = data[i]\n    if (usage === undefined) {\n      usage = data[i.replace(/ \\S+$/, ' 0')]\n    }\n    return all + (usage || 0)\n  }, 0)\n}\n\nfunction nodeQuery(context, node) {\n  var matched = browserslist.nodeVersions.filter(function (i) {\n    return isVersionsMatch(i, node.version)\n  })\n  if (matched.length === 0) {\n    if (context.ignoreUnknownVersions) {\n      return []\n    } else {\n      throw new BrowserslistError(\n        'Unknown version ' + node.version + ' of Node.js'\n      )\n    }\n  }\n  return ['node ' + matched[matched.length - 1]]\n}\n\nfunction sinceQuery(context, node) {\n  var year = parseInt(node.year)\n  var month = parseInt(node.month || '01') - 1\n  var day = parseInt(node.day || '01')\n  return filterByYear(Date.UTC(year, month, day, 0, 0, 0), context)\n}\n\nfunction coverQuery(context, node) {\n  var coverage = parseFloat(node.coverage)\n  var usage = browserslist.usage.global\n  if (node.place) {\n    if (node.place.match(/^my\\s+stats$/i)) {\n      if (!context.customUsage) {\n        throw new BrowserslistError('Custom usage statistics was not provided')\n      }\n      usage = context.customUsage\n    } else {\n      var place\n      if (node.place.length === 2) {\n        place = node.place.toUpperCase()\n      } else {\n        place = node.place.toLowerCase()\n      }\n      env.loadCountry(browserslist.usage, place, browserslist.data)\n      usage = browserslist.usage[place]\n    }\n  }\n  var versions = Object.keys(usage).sort(function (a, b) {\n    return usage[b] - usage[a]\n  })\n  var coveraged = 0\n  var result = []\n  var version\n  for (var i = 0; i < versions.length; i++) {\n    version = versions[i]\n    if (usage[version] === 0) break\n    coveraged += usage[version]\n    result.push(version)\n    if (coveraged >= coverage) break\n  }\n  return result\n}\n\nvar QUERIES = {\n  last_major_versions: {\n    matches: ['versions'],\n    regexp: /^last\\s+(\\d+)\\s+major\\s+versions?$/i,\n    select: function (context, node) {\n      return Object.keys(agents).reduce(function (selected, name) {\n        var data = byName(name, context)\n        if (!data) return selected\n        var list = getMajorVersions(data.released, node.versions)\n        list = list.map(nameMapper(data.name))\n        list = filterJumps(list, data.name, node.versions, context)\n        return selected.concat(list)\n      }, [])\n    }\n  },\n  last_versions: {\n    matches: ['versions'],\n    regexp: /^last\\s+(\\d+)\\s+versions?$/i,\n    select: function (context, node) {\n      return Object.keys(agents).reduce(function (selected, name) {\n        var data = byName(name, context)\n        if (!data) return selected\n        var list = data.released.slice(-node.versions)\n        list = list.map(nameMapper(data.name))\n        list = filterJumps(list, data.name, node.versions, context)\n        return selected.concat(list)\n      }, [])\n    }\n  },\n  last_electron_major_versions: {\n    matches: ['versions'],\n    regexp: /^last\\s+(\\d+)\\s+electron\\s+major\\s+versions?$/i,\n    select: function (context, node) {\n      var validVersions = getMajorVersions(Object.keys(e2c), node.versions)\n      return validVersions.map(function (i) {\n        return 'chrome ' + e2c[i]\n      })\n    }\n  },\n  last_node_major_versions: {\n    matches: ['versions'],\n    regexp: /^last\\s+(\\d+)\\s+node\\s+major\\s+versions?$/i,\n    select: function (context, node) {\n      return getMajorVersions(browserslist.nodeVersions, node.versions).map(\n        function (version) {\n          return 'node ' + version\n        }\n      )\n    }\n  },\n  last_browser_major_versions: {\n    matches: ['versions', 'browser'],\n    regexp: /^last\\s+(\\d+)\\s+(\\w+)\\s+major\\s+versions?$/i,\n    select: function (context, node) {\n      var data = checkName(node.browser, context)\n      var validVersions = getMajorVersions(data.released, node.versions)\n      var list = validVersions.map(nameMapper(data.name))\n      list = filterJumps(list, data.name, node.versions, context)\n      return list\n    }\n  },\n  last_electron_versions: {\n    matches: ['versions'],\n    regexp: /^last\\s+(\\d+)\\s+electron\\s+versions?$/i,\n    select: function (context, node) {\n      return Object.keys(e2c)\n        .slice(-node.versions)\n        .map(function (i) {\n          return 'chrome ' + e2c[i]\n        })\n    }\n  },\n  last_node_versions: {\n    matches: ['versions'],\n    regexp: /^last\\s+(\\d+)\\s+node\\s+versions?$/i,\n    select: function (context, node) {\n      return browserslist.nodeVersions\n        .slice(-node.versions)\n        .map(function (version) {\n          return 'node ' + version\n        })\n    }\n  },\n  last_browser_versions: {\n    matches: ['versions', 'browser'],\n    regexp: /^last\\s+(\\d+)\\s+(\\w+)\\s+versions?$/i,\n    select: function (context, node) {\n      var data = checkName(node.browser, context)\n      var list = data.released.slice(-node.versions).map(nameMapper(data.name))\n      list = filterJumps(list, data.name, node.versions, context)\n      return list\n    }\n  },\n  unreleased_versions: {\n    matches: [],\n    regexp: /^unreleased\\s+versions$/i,\n    select: function (context) {\n      return Object.keys(agents).reduce(function (selected, name) {\n        var data = byName(name, context)\n        if (!data) return selected\n        var list = data.versions.filter(function (v) {\n          return data.released.indexOf(v) === -1\n        })\n        list = list.map(nameMapper(data.name))\n        return selected.concat(list)\n      }, [])\n    }\n  },\n  unreleased_electron_versions: {\n    matches: [],\n    regexp: /^unreleased\\s+electron\\s+versions?$/i,\n    select: function () {\n      return []\n    }\n  },\n  unreleased_browser_versions: {\n    matches: ['browser'],\n    regexp: /^unreleased\\s+(\\w+)\\s+versions?$/i,\n    select: function (context, node) {\n      var data = checkName(node.browser, context)\n      return data.versions\n        .filter(function (v) {\n          return data.released.indexOf(v) === -1\n        })\n        .map(nameMapper(data.name))\n    }\n  },\n  last_years: {\n    matches: ['years'],\n    regexp: /^last\\s+(\\d*.?\\d+)\\s+years?$/i,\n    select: function (context, node) {\n      return filterByYear(Date.now() - YEAR * node.years, context)\n    }\n  },\n  since_y: {\n    matches: ['year'],\n    regexp: /^since (\\d+)$/i,\n    select: sinceQuery\n  },\n  since_y_m: {\n    matches: ['year', 'month'],\n    regexp: /^since (\\d+)-(\\d+)$/i,\n    select: sinceQuery\n  },\n  since_y_m_d: {\n    matches: ['year', 'month', 'day'],\n    regexp: /^since (\\d+)-(\\d+)-(\\d+)$/i,\n    select: sinceQuery\n  },\n  popularity: {\n    matches: ['sign', 'popularity'],\n    regexp: /^(>=?|<=?)\\s*(\\d+|\\d+\\.\\d+|\\.\\d+)%$/,\n    select: function (context, node) {\n      var popularity = parseFloat(node.popularity)\n      var usage = browserslist.usage.global\n      return Object.keys(usage).reduce(function (result, version) {\n        if (node.sign === '>') {\n          if (usage[version] > popularity) {\n            result.push(version)\n          }\n        } else if (node.sign === '<') {\n          if (usage[version] < popularity) {\n            result.push(version)\n          }\n        } else if (node.sign === '<=') {\n          if (usage[version] <= popularity) {\n            result.push(version)\n          }\n        } else if (usage[version] >= popularity) {\n          result.push(version)\n        }\n        return result\n      }, [])\n    }\n  },\n  popularity_in_my_stats: {\n    matches: ['sign', 'popularity'],\n    regexp: /^(>=?|<=?)\\s*(\\d+|\\d+\\.\\d+|\\.\\d+)%\\s+in\\s+my\\s+stats$/,\n    select: function (context, node) {\n      var popularity = parseFloat(node.popularity)\n      if (!context.customUsage) {\n        throw new BrowserslistError('Custom usage statistics was not provided')\n      }\n      var usage = context.customUsage\n      return Object.keys(usage).reduce(function (result, version) {\n        var percentage = usage[version]\n        if (percentage == null) {\n          return result\n        }\n\n        if (node.sign === '>') {\n          if (percentage > popularity) {\n            result.push(version)\n          }\n        } else if (node.sign === '<') {\n          if (percentage < popularity) {\n            result.push(version)\n          }\n        } else if (node.sign === '<=') {\n          if (percentage <= popularity) {\n            result.push(version)\n          }\n        } else if (percentage >= popularity) {\n          result.push(version)\n        }\n        return result\n      }, [])\n    }\n  },\n  popularity_in_config_stats: {\n    matches: ['sign', 'popularity', 'config'],\n    regexp: /^(>=?|<=?)\\s*(\\d+|\\d+\\.\\d+|\\.\\d+)%\\s+in\\s+(\\S+)\\s+stats$/,\n    select: function (context, node) {\n      var popularity = parseFloat(node.popularity)\n      var stats = env.loadStat(context, node.config, browserslist.data)\n      if (stats) {\n        context.customUsage = {}\n        for (var browser in stats) {\n          fillUsage(context.customUsage, browser, stats[browser])\n        }\n      }\n      if (!context.customUsage) {\n        throw new BrowserslistError('Custom usage statistics was not provided')\n      }\n      var usage = context.customUsage\n      return Object.keys(usage).reduce(function (result, version) {\n        var percentage = usage[version]\n        if (percentage == null) {\n          return result\n        }\n\n        if (node.sign === '>') {\n          if (percentage > popularity) {\n            result.push(version)\n          }\n        } else if (node.sign === '<') {\n          if (percentage < popularity) {\n            result.push(version)\n          }\n        } else if (node.sign === '<=') {\n          if (percentage <= popularity) {\n            result.push(version)\n          }\n        } else if (percentage >= popularity) {\n          result.push(version)\n        }\n        return result\n      }, [])\n    }\n  },\n  popularity_in_place: {\n    matches: ['sign', 'popularity', 'place'],\n    regexp: /^(>=?|<=?)\\s*(\\d+|\\d+\\.\\d+|\\.\\d+)%\\s+in\\s+((alt-)?\\w\\w)$/,\n    select: function (context, node) {\n      var popularity = parseFloat(node.popularity)\n      var place = node.place\n      if (place.length === 2) {\n        place = place.toUpperCase()\n      } else {\n        place = place.toLowerCase()\n      }\n      env.loadCountry(browserslist.usage, place, browserslist.data)\n      var usage = browserslist.usage[place]\n      return Object.keys(usage).reduce(function (result, version) {\n        var percentage = usage[version]\n        if (percentage == null) {\n          return result\n        }\n\n        if (node.sign === '>') {\n          if (percentage > popularity) {\n            result.push(version)\n          }\n        } else if (node.sign === '<') {\n          if (percentage < popularity) {\n            result.push(version)\n          }\n        } else if (node.sign === '<=') {\n          if (percentage <= popularity) {\n            result.push(version)\n          }\n        } else if (percentage >= popularity) {\n          result.push(version)\n        }\n        return result\n      }, [])\n    }\n  },\n  cover: {\n    matches: ['coverage'],\n    regexp: /^cover\\s+(\\d+|\\d+\\.\\d+|\\.\\d+)%$/i,\n    select: coverQuery\n  },\n  cover_in: {\n    matches: ['coverage', 'place'],\n    regexp: /^cover\\s+(\\d+|\\d+\\.\\d+|\\.\\d+)%\\s+in\\s+(my\\s+stats|(alt-)?\\w\\w)$/i,\n    select: coverQuery\n  },\n  supports: {\n    matches: ['supportType', 'feature'],\n    regexp: /^(?:(fully|partially)\\s+)?supports\\s+([\\w-]+)$/,\n    select: function (context, node) {\n      env.loadFeature(browserslist.cache, node.feature)\n      var withPartial = node.supportType !== 'fully'\n      var features = browserslist.cache[node.feature]\n      var result = []\n      for (var name in features) {\n        var data = byName(name, context)\n        // Only check desktop when latest released mobile has support\n        var iMax = data.released.length - 1\n        while (iMax >= 0) {\n          if (data.released[iMax] in features[name]) break\n          iMax--\n        }\n        var checkDesktop =\n          context.mobileToDesktop &&\n          name in browserslist.desktopNames &&\n          isSupported(features[name][data.released[iMax]], withPartial)\n        data.versions.forEach(function (version) {\n          var flags = features[name][version]\n          if (flags === undefined && checkDesktop) {\n            flags = features[browserslist.desktopNames[name]][version]\n          }\n          if (isSupported(flags, withPartial)) {\n            result.push(name + ' ' + version)\n          }\n        })\n      }\n      return result\n    }\n  },\n  electron_range: {\n    matches: ['from', 'to'],\n    regexp: /^electron\\s+([\\d.]+)\\s*-\\s*([\\d.]+)$/i,\n    select: function (context, node) {\n      var fromToUse = normalizeElectron(node.from)\n      var toToUse = normalizeElectron(node.to)\n      var from = parseFloat(node.from)\n      var to = parseFloat(node.to)\n      if (!e2c[fromToUse]) {\n        throw new BrowserslistError('Unknown version ' + from + ' of electron')\n      }\n      if (!e2c[toToUse]) {\n        throw new BrowserslistError('Unknown version ' + to + ' of electron')\n      }\n      return Object.keys(e2c)\n        .filter(function (i) {\n          var parsed = parseFloat(i)\n          return parsed >= from && parsed <= to\n        })\n        .map(function (i) {\n          return 'chrome ' + e2c[i]\n        })\n    }\n  },\n  node_range: {\n    matches: ['from', 'to'],\n    regexp: /^node\\s+([\\d.]+)\\s*-\\s*([\\d.]+)$/i,\n    select: function (context, node) {\n      return browserslist.nodeVersions\n        .filter(semverFilterLoose('>=', node.from))\n        .filter(semverFilterLoose('<=', node.to))\n        .map(function (v) {\n          return 'node ' + v\n        })\n    }\n  },\n  browser_range: {\n    matches: ['browser', 'from', 'to'],\n    regexp: /^(\\w+)\\s+([\\d.]+)\\s*-\\s*([\\d.]+)$/i,\n    select: function (context, node) {\n      var data = checkName(node.browser, context)\n      var from = parseFloat(normalizeVersion(data, node.from) || node.from)\n      var to = parseFloat(normalizeVersion(data, node.to) || node.to)\n      function filter(v) {\n        var parsed = parseFloat(v)\n        return parsed >= from && parsed <= to\n      }\n      return data.released.filter(filter).map(nameMapper(data.name))\n    }\n  },\n  electron_ray: {\n    matches: ['sign', 'version'],\n    regexp: /^electron\\s*(>=?|<=?)\\s*([\\d.]+)$/i,\n    select: function (context, node) {\n      var versionToUse = normalizeElectron(node.version)\n      return Object.keys(e2c)\n        .filter(generateFilter(node.sign, versionToUse))\n        .map(function (i) {\n          return 'chrome ' + e2c[i]\n        })\n    }\n  },\n  node_ray: {\n    matches: ['sign', 'version'],\n    regexp: /^node\\s*(>=?|<=?)\\s*([\\d.]+)$/i,\n    select: function (context, node) {\n      return browserslist.nodeVersions\n        .filter(generateSemverFilter(node.sign, node.version))\n        .map(function (v) {\n          return 'node ' + v\n        })\n    }\n  },\n  browser_ray: {\n    matches: ['browser', 'sign', 'version'],\n    regexp: /^(\\w+)\\s*(>=?|<=?)\\s*([\\d.]+)$/,\n    select: function (context, node) {\n      var version = node.version\n      var data = checkName(node.browser, context)\n      var alias = browserslist.versionAliases[data.name][version]\n      if (alias) version = alias\n      return data.released\n        .filter(generateFilter(node.sign, version))\n        .map(function (v) {\n          return data.name + ' ' + v\n        })\n    }\n  },\n  firefox_esr: {\n    matches: [],\n    regexp: /^(firefox|ff|fx)\\s+esr$/i,\n    select: function () {\n      return ['firefox 128']\n    }\n  },\n  opera_mini_all: {\n    matches: [],\n    regexp: /(operamini|op_mini)\\s+all/i,\n    select: function () {\n      return ['op_mini all']\n    }\n  },\n  electron_version: {\n    matches: ['version'],\n    regexp: /^electron\\s+([\\d.]+)$/i,\n    select: function (context, node) {\n      var versionToUse = normalizeElectron(node.version)\n      var chrome = e2c[versionToUse]\n      if (!chrome) {\n        throw new BrowserslistError(\n          'Unknown version ' + node.version + ' of electron'\n        )\n      }\n      return ['chrome ' + chrome]\n    }\n  },\n  node_major_version: {\n    matches: ['version'],\n    regexp: /^node\\s+(\\d+)$/i,\n    select: nodeQuery\n  },\n  node_minor_version: {\n    matches: ['version'],\n    regexp: /^node\\s+(\\d+\\.\\d+)$/i,\n    select: nodeQuery\n  },\n  node_patch_version: {\n    matches: ['version'],\n    regexp: /^node\\s+(\\d+\\.\\d+\\.\\d+)$/i,\n    select: nodeQuery\n  },\n  current_node: {\n    matches: [],\n    regexp: /^current\\s+node$/i,\n    select: function (context) {\n      return [env.currentNode(resolve, context)]\n    }\n  },\n  maintained_node: {\n    matches: [],\n    regexp: /^maintained\\s+node\\s+versions$/i,\n    select: function (context) {\n      var now = Date.now()\n      var queries = Object.keys(jsEOL)\n        .filter(function (key) {\n          return (\n            now < Date.parse(jsEOL[key].end) &&\n            now > Date.parse(jsEOL[key].start) &&\n            isEolReleased(key)\n          )\n        })\n        .map(function (key) {\n          return 'node ' + key.slice(1)\n        })\n      return resolve(queries, context)\n    }\n  },\n  phantomjs_1_9: {\n    matches: [],\n    regexp: /^phantomjs\\s+1.9$/i,\n    select: function () {\n      return ['safari 5']\n    }\n  },\n  phantomjs_2_1: {\n    matches: [],\n    regexp: /^phantomjs\\s+2.1$/i,\n    select: function () {\n      return ['safari 6']\n    }\n  },\n  browser_version: {\n    matches: ['browser', 'version'],\n    regexp: /^(\\w+)\\s+(tp|[\\d.]+)$/i,\n    select: function (context, node) {\n      var version = node.version\n      if (/^tp$/i.test(version)) version = 'TP'\n      var data = checkName(node.browser, context)\n      var alias = normalizeVersion(data, version)\n      if (alias) {\n        version = alias\n      } else {\n        if (version.indexOf('.') === -1) {\n          alias = version + '.0'\n        } else {\n          alias = version.replace(/\\.0$/, '')\n        }\n        alias = normalizeVersion(data, alias)\n        if (alias) {\n          version = alias\n        } else if (context.ignoreUnknownVersions) {\n          return []\n        } else {\n          throw new BrowserslistError(\n            'Unknown version ' + version + ' of ' + node.browser\n          )\n        }\n      }\n      return [data.name + ' ' + version]\n    }\n  },\n  browserslist_config: {\n    matches: [],\n    regexp: /^browserslist config$/i,\n    needsPath: true,\n    select: function (context) {\n      return browserslist(undefined, context)\n    }\n  },\n  extends: {\n    matches: ['config'],\n    regexp: /^extends (.+)$/i,\n    needsPath: true,\n    select: function (context, node) {\n      return resolve(env.loadQueries(context, node.config), context)\n    }\n  },\n  defaults: {\n    matches: [],\n    regexp: /^defaults$/i,\n    select: function (context) {\n      return resolve(browserslist.defaults, context)\n    }\n  },\n  dead: {\n    matches: [],\n    regexp: /^dead$/i,\n    select: function (context) {\n      var dead = [\n        'Baidu >= 0',\n        'ie <= 11',\n        'ie_mob <= 11',\n        'bb <= 10',\n        'op_mob <= 12.1',\n        'samsung 4'\n      ]\n      return resolve(dead, context)\n    }\n  },\n  unknown: {\n    matches: [],\n    regexp: /^(\\w+)$/i,\n    select: function (context, node) {\n      if (byName(node.query, context)) {\n        throw new BrowserslistError(\n          'Specify versions in Browserslist query for browser ' + node.query\n        )\n      } else {\n        throw unknownQuery(node.query)\n      }\n    }\n  }\n}\n\n// Get and convert Can I Use data\n\n;(function () {\n  for (var name in agents) {\n    var browser = agents[name]\n    browserslist.data[name] = {\n      name: name,\n      versions: normalize(agents[name].versions),\n      released: normalize(agents[name].versions.slice(0, -3)),\n      releaseDate: agents[name].release_date\n    }\n    fillUsage(browserslist.usage.global, name, browser.usage_global)\n\n    browserslist.versionAliases[name] = {}\n    for (var i = 0; i < browser.versions.length; i++) {\n      var full = browser.versions[i]\n      if (!full) continue\n\n      if (full.indexOf('-') !== -1) {\n        var interval = full.split('-')\n        for (var j = 0; j < interval.length; j++) {\n          browserslist.versionAliases[name][interval[j]] = full\n        }\n      }\n    }\n  }\n\n  browserslist.nodeVersions = jsReleases.map(function (release) {\n    return release.version\n  })\n})()\n\nmodule.exports = browserslist\n","var AND_REGEXP = /^\\s+and\\s+(.*)/i\nvar OR_REGEXP = /^(?:,\\s*|\\s+or\\s+)(.*)/i\n\nfunction flatten(array) {\n  if (!Array.isArray(array)) return [array]\n  return array.reduce(function (a, b) {\n    return a.concat(flatten(b))\n  }, [])\n}\n\nfunction find(string, predicate) {\n  for (var max = string.length, n = 1; n <= max; n++) {\n    var parsed = string.substr(-n, n)\n    if (predicate(parsed, n, max)) {\n      return string.slice(0, -n)\n    }\n  }\n  return ''\n}\n\nfunction matchQuery(all, query) {\n  var node = { query: query }\n  if (query.indexOf('not ') === 0) {\n    node.not = true\n    query = query.slice(4)\n  }\n\n  for (var name in all) {\n    var type = all[name]\n    var match = query.match(type.regexp)\n    if (match) {\n      node.type = name\n      for (var i = 0; i < type.matches.length; i++) {\n        node[type.matches[i]] = match[i + 1]\n      }\n      return node\n    }\n  }\n\n  node.type = 'unknown'\n  return node\n}\n\nfunction matchBlock(all, string, qs) {\n  var node\n  return find(string, function (parsed, n, max) {\n    if (AND_REGEXP.test(parsed)) {\n      node = matchQuery(all, parsed.match(AND_REGEXP)[1])\n      node.compose = 'and'\n      qs.unshift(node)\n      return true\n    } else if (OR_REGEXP.test(parsed)) {\n      node = matchQuery(all, parsed.match(OR_REGEXP)[1])\n      node.compose = 'or'\n      qs.unshift(node)\n      return true\n    } else if (n === max) {\n      node = matchQuery(all, parsed.trim())\n      node.compose = 'or'\n      qs.unshift(node)\n      return true\n    }\n    return false\n  })\n}\n\nmodule.exports = function parse(all, queries) {\n  if (!Array.isArray(queries)) queries = [queries]\n  return flatten(\n    queries.map(function (block) {\n      var qs = []\n      do {\n        block = matchBlock(all, block, qs)\n      } while (block)\n      return qs\n    })\n  )\n}\n","'use strict';\n\nvar bind = require('function-bind');\n\nvar $apply = require('./functionApply');\nvar $call = require('./functionCall');\nvar $reflectApply = require('./reflectApply');\n\n/** @type {import('./actualApply')} */\nmodule.exports = $reflectApply || bind.call($call, $apply);\n","'use strict';\n\nvar bind = require('function-bind');\nvar $apply = require('./functionApply');\nvar actualApply = require('./actualApply');\n\n/** @type {import('./applyBind')} */\nmodule.exports = function applyBind() {\n\treturn actualApply(bind, $apply, arguments);\n};\n","'use strict';\n\n/** @type {import('./functionApply')} */\nmodule.exports = Function.prototype.apply;\n","'use strict';\n\n/** @type {import('./functionCall')} */\nmodule.exports = Function.prototype.call;\n","'use strict';\n\nvar bind = require('function-bind');\nvar $TypeError = require('es-errors/type');\n\nvar $call = require('./functionCall');\nvar $actualApply = require('./actualApply');\n\n/** @type {import('.')} */\nmodule.exports = function callBindBasic(args) {\n\tif (args.length < 1 || typeof args[0] !== 'function') {\n\t\tthrow new $TypeError('a function is required');\n\t}\n\treturn $actualApply(bind, $call, args);\n};\n","'use strict';\n\n/** @type {import('./reflectApply')} */\nmodule.exports = typeof Reflect !== 'undefined' && Reflect && Reflect.apply;\n","'use strict';\n\nvar GetIntrinsic = require('get-intrinsic');\n\nvar callBind = require('./');\n\nvar $indexOf = callBind(GetIntrinsic('String.prototype.indexOf'));\n\nmodule.exports = function callBoundIntrinsic(name, allowMissing) {\n\tvar intrinsic = GetIntrinsic(name, !!allowMissing);\n\tif (typeof intrinsic === 'function' && $indexOf(name, '.prototype.') > -1) {\n\t\treturn callBind(intrinsic);\n\t}\n\treturn intrinsic;\n};\n","'use strict';\n\nvar setFunctionLength = require('set-function-length');\n\nvar $defineProperty = require('es-define-property');\n\nvar callBindBasic = require('call-bind-apply-helpers');\nvar applyBind = require('call-bind-apply-helpers/applyBind');\n\nmodule.exports = function callBind(originalFunction) {\n\tvar func = callBindBasic(arguments);\n\tvar adjustedLength = originalFunction.length - (arguments.length - 1);\n\treturn setFunctionLength(\n\t\tfunc,\n\t\t1 + (adjustedLength > 0 ? adjustedLength : 0),\n\t\ttrue\n\t);\n};\n\nif ($defineProperty) {\n\t$defineProperty(module.exports, 'apply', { value: applyBind });\n} else {\n\tmodule.exports.apply = applyBind;\n}\n","'use strict';\n\nvar GetIntrinsic = require('get-intrinsic');\n\nvar callBindBasic = require('call-bind-apply-helpers');\n\n/** @type {(thisArg: string, searchString: string, position?: number) => number} */\nvar $indexOf = callBindBasic([GetIntrinsic('%String.prototype.indexOf%')]);\n\n/** @type {import('.')} */\nmodule.exports = function callBoundIntrinsic(name, allowMissing) {\n\t// eslint-disable-next-line no-extra-parens\n\tvar intrinsic = /** @type {Parameters<typeof callBindBasic>[0][0]} */ (GetIntrinsic(name, !!allowMissing));\n\tif (typeof intrinsic === 'function' && $indexOf(name, '.prototype.') > -1) {\n\t\treturn callBindBasic([intrinsic]);\n\t}\n\treturn intrinsic;\n};\n","module.exports={A:{A:{K:0,E:0,F:0,G:0.033801,A:0,B:0.371811,kC:0},B:\"ms\",C:[\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"kC\",\"K\",\"E\",\"F\",\"G\",\"A\",\"B\",\"\",\"\",\"\"],E:\"IE\",F:{kC:962323200,K:998870400,E:1161129600,F:1237420800,G:1300060800,A:1346716800,B:1381968000}},B:{A:{\"6\":0.003558,\"7\":0,\"8\":0.003558,\"9\":0.003558,C:0,L:0,M:0,H:0,N:0,O:0.003558,P:0.117414,Q:0,I:0,R:0,S:0,T:0,U:0,V:0,W:0,X:0,Y:0,Z:0,a:0,b:0.010674,c:0,d:0,e:0,f:0,g:0,h:0,i:0,j:0,k:0,l:0,m:0,n:0,o:0,p:0,q:0,r:0.003558,s:0.049812,t:0,u:0.003558,v:0.007116,w:0.007116,x:0.010674,AB:0.003558,BB:0.021348,CB:0.010674,DB:0.014232,EB:0.007116,FB:0.010674,GB:0.010674,HB:0.021348,IB:0.021348,JB:0.01779,KB:0.021348,LB:0.067602,MB:2.88198,D:1.62245},B:\"webkit\",C:[\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"C\",\"L\",\"M\",\"H\",\"N\",\"O\",\"P\",\"Q\",\"I\",\"R\",\"S\",\"T\",\"U\",\"V\",\"W\",\"X\",\"Y\",\"Z\",\"a\",\"b\",\"c\",\"d\",\"e\",\"f\",\"g\",\"h\",\"i\",\"j\",\"k\",\"l\",\"m\",\"n\",\"o\",\"p\",\"q\",\"r\",\"s\",\"t\",\"u\",\"v\",\"w\",\"x\",\"6\",\"7\",\"8\",\"9\",\"AB\",\"BB\",\"CB\",\"DB\",\"EB\",\"FB\",\"GB\",\"HB\",\"IB\",\"JB\",\"KB\",\"LB\",\"MB\",\"D\",\"\",\"\",\"\"],E:\"Edge\",F:{\"6\":1689897600,\"7\":1692576000,\"8\":1694649600,\"9\":1697155200,C:1438128000,L:1447286400,M:1470096000,H:1491868800,N:1508198400,O:1525046400,P:1542067200,Q:1579046400,I:1581033600,R:1586736000,S:1590019200,T:1594857600,U:1598486400,V:1602201600,W:1605830400,X:1611360000,Y:1614816000,Z:1618358400,a:1622073600,b:1626912000,c:1630627200,d:1632441600,e:1634774400,f:1637539200,g:1641427200,h:1643932800,i:1646265600,j:1649635200,k:1651190400,l:1653955200,m:1655942400,n:1659657600,o:1661990400,p:1664755200,q:1666915200,r:1670198400,s:1673481600,t:1675900800,u:1678665600,v:1680825600,w:1683158400,x:1685664000,AB:1698969600,BB:1701993600,CB:1706227200,DB:1708732800,EB:1711152000,FB:1713398400,GB:1715990400,HB:1718841600,IB:1721865600,JB:1724371200,KB:1726704000,LB:1729123200,MB:1731542400,D:1737417600},D:{C:\"ms\",L:\"ms\",M:\"ms\",H:\"ms\",N:\"ms\",O:\"ms\",P:\"ms\"}},C:{A:{\"0\":0,\"1\":0,\"2\":0,\"3\":0,\"4\":0,\"5\":0,\"6\":0.234828,\"7\":0,\"8\":0,\"9\":0.085392,lC:0,IC:0,J:0,NB:0,K:0,E:0,F:0,G:0,A:0,B:0.021348,C:0,L:0,M:0,H:0,N:0,O:0,P:0,OB:0,y:0,z:0,PB:0,QB:0,RB:0,SB:0,TB:0,UB:0,VB:0,WB:0,XB:0,YB:0,ZB:0,aB:0,bB:0,cB:0,dB:0,eB:0.007116,fB:0.003558,gB:0,hB:0,iB:0.003558,jB:0,kB:0,lB:0,mB:0,nB:0.028464,oB:0,pB:0,qB:0.003558,rB:0.014232,sB:0,tB:0,JC:0.003558,uB:0,KC:0,vB:0,wB:0,xB:0,yB:0,zB:0,\"0B\":0,\"1B\":0,\"2B\":0,\"3B\":0,\"4B\":0,\"5B\":0,\"6B\":0,\"7B\":0,\"8B\":0,\"9B\":0,AC:0,BC:0.010674,Q:0,I:0,R:0,LC:0,S:0,T:0,U:0,V:0,W:0,X:0.003558,Y:0,Z:0,a:0,b:0,c:0,d:0,e:0,f:0,g:0,h:0,i:0,j:0,k:0,l:0,m:0.007116,n:0,o:0,p:0,q:0,r:0,s:0.003558,t:0,u:0,v:0,w:0.007116,x:0,AB:0,BB:0.003558,CB:0.003558,DB:0,EB:0,FB:0,GB:0.01779,HB:0,IB:0.007116,JB:0.078276,KB:0.003558,LB:0.007116,MB:0.010674,D:0.021348,MC:0.49812,NC:1.02826,OC:0.007116,PC:0,mC:0,nC:0,oC:0,pC:0},B:\"moz\",C:[\"lC\",\"IC\",\"oC\",\"pC\",\"J\",\"NB\",\"K\",\"E\",\"F\",\"G\",\"A\",\"B\",\"C\",\"L\",\"M\",\"H\",\"N\",\"O\",\"P\",\"OB\",\"y\",\"z\",\"0\",\"1\",\"2\",\"3\",\"4\",\"5\",\"PB\",\"QB\",\"RB\",\"SB\",\"TB\",\"UB\",\"VB\",\"WB\",\"XB\",\"YB\",\"ZB\",\"aB\",\"bB\",\"cB\",\"dB\",\"eB\",\"fB\",\"gB\",\"hB\",\"iB\",\"jB\",\"kB\",\"lB\",\"mB\",\"nB\",\"oB\",\"pB\",\"qB\",\"rB\",\"sB\",\"tB\",\"JC\",\"uB\",\"KC\",\"vB\",\"wB\",\"xB\",\"yB\",\"zB\",\"0B\",\"1B\",\"2B\",\"3B\",\"4B\",\"5B\",\"6B\",\"7B\",\"8B\",\"9B\",\"AC\",\"BC\",\"Q\",\"I\",\"R\",\"LC\",\"S\",\"T\",\"U\",\"V\",\"W\",\"X\",\"Y\",\"Z\",\"a\",\"b\",\"c\",\"d\",\"e\",\"f\",\"g\",\"h\",\"i\",\"j\",\"k\",\"l\",\"m\",\"n\",\"o\",\"p\",\"q\",\"r\",\"s\",\"t\",\"u\",\"v\",\"w\",\"x\",\"6\",\"7\",\"8\",\"9\",\"AB\",\"BB\",\"CB\",\"DB\",\"EB\",\"FB\",\"GB\",\"HB\",\"IB\",\"JB\",\"KB\",\"LB\",\"MB\",\"D\",\"MC\",\"NC\",\"OC\",\"PC\",\"mC\",\"nC\"],E:\"Firefox\",F:{\"0\":1368489600,\"1\":1372118400,\"2\":1375747200,\"3\":1379376000,\"4\":1386633600,\"5\":1391472000,\"6\":1688428800,\"7\":1690848000,\"8\":1693267200,\"9\":1695686400,lC:1161648000,IC:1213660800,oC:1246320000,pC:1264032000,J:1300752000,NB:1308614400,K:1313452800,E:1317081600,F:1317081600,G:1320710400,A:1324339200,B:1327968000,C:1331596800,L:1335225600,M:1338854400,H:1342483200,N:1346112000,O:1349740800,P:1353628800,OB:1357603200,y:1361232000,z:1364860800,PB:1395100800,QB:1398729600,RB:1402358400,SB:1405987200,TB:1409616000,UB:1413244800,VB:1417392000,WB:1421107200,XB:1424736000,YB:1428278400,ZB:1431475200,aB:1435881600,bB:1439251200,cB:1442880000,dB:1446508800,eB:1450137600,fB:1453852800,gB:1457395200,hB:1461628800,iB:1465257600,jB:1470096000,kB:1474329600,lB:1479168000,mB:1485216000,nB:1488844800,oB:1492560000,pB:1497312000,qB:1502150400,rB:1506556800,sB:1510617600,tB:1516665600,JC:1520985600,uB:1525824000,KC:1529971200,vB:1536105600,wB:1540252800,xB:1544486400,yB:1548720000,zB:1552953600,\"0B\":1558396800,\"1B\":1562630400,\"2B\":1567468800,\"3B\":1571788800,\"4B\":1575331200,\"5B\":1578355200,\"6B\":1581379200,\"7B\":1583798400,\"8B\":1586304000,\"9B\":1588636800,AC:1591056000,BC:1593475200,Q:1595894400,I:1598313600,R:1600732800,LC:1603152000,S:1605571200,T:1607990400,U:1611619200,V:1614038400,W:1616457600,X:1618790400,Y:1622505600,Z:1626134400,a:1628553600,b:1630972800,c:1633392000,d:1635811200,e:1638835200,f:1641859200,g:1644364800,h:1646697600,i:1649116800,j:1651536000,k:1653955200,l:1656374400,m:1658793600,n:1661212800,o:1663632000,p:1666051200,q:1668470400,r:1670889600,s:1673913600,t:1676332800,u:1678752000,v:1681171200,w:1683590400,x:1686009600,AB:1698105600,BB:1700524800,CB:1702944000,DB:1705968000,EB:1708387200,FB:1710806400,GB:1713225600,HB:1715644800,IB:1718064000,JB:1720483200,KB:1722902400,LB:1725321600,MB:1727740800,D:1730160000,MC:1732579200,NC:1736208000,OC:1738627200,PC:null,mC:null,nC:null}},D:{A:{\"0\":0,\"1\":0,\"2\":0,\"3\":0,\"4\":0,\"5\":0,\"6\":0.024906,\"7\":0.110298,\"8\":0.067602,\"9\":0.056928,J:0,NB:0,K:0,E:0,F:0,G:0,A:0,B:0,C:0,L:0,M:0,H:0,N:0,O:0,P:0,OB:0,y:0,z:0,PB:0,QB:0,RB:0,SB:0,TB:0,UB:0,VB:0,WB:0,XB:0,YB:0,ZB:0.007116,aB:0,bB:0,cB:0,dB:0,eB:0,fB:0,gB:0.003558,hB:0,iB:0.003558,jB:0.014232,kB:0.014232,lB:0.024906,mB:0,nB:0.007116,oB:0.007116,pB:0,qB:0,rB:0.010674,sB:0,tB:0.007116,JC:0,uB:0,KC:0.007116,vB:0,wB:0,xB:0,yB:0,zB:0.021348,\"0B\":0,\"1B\":0,\"2B\":0.007116,\"3B\":0.010674,\"4B\":0,\"5B\":0,\"6B\":0.007116,\"7B\":0.007116,\"8B\":0.003558,\"9B\":0.003558,AC:0.010674,BC:0.010674,Q:0.08895,I:0.010674,R:0.024906,S:0.032022,T:0,U:0.010674,V:0.01779,W:0.067602,X:0.010674,Y:0.007116,Z:0.007116,a:0.03558,b:0.010674,c:0.010674,d:0.032022,e:0.014232,f:0.007116,g:0.014232,h:0.039138,i:0.010674,j:0.007116,k:0.014232,l:0.010674,m:0.099624,n:0.042696,o:0.010674,p:0.01779,q:0.024906,r:0.039138,s:1.04605,t:0.021348,u:0.028464,v:0.039138,w:0.145878,x:0.07116,AB:0.039138,BB:0.056928,CB:0.08895,DB:0.074718,EB:0.078276,FB:0.138762,GB:0.814782,HB:0.295314,IB:0.224154,JB:0.156552,KB:0.14232,LB:0.384264,MB:12.7946,D:3.25201,MC:0.014232,NC:0.007116,OC:0,PC:0},B:\"webkit\",C:[\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"J\",\"NB\",\"K\",\"E\",\"F\",\"G\",\"A\",\"B\",\"C\",\"L\",\"M\",\"H\",\"N\",\"O\",\"P\",\"OB\",\"y\",\"z\",\"0\",\"1\",\"2\",\"3\",\"4\",\"5\",\"PB\",\"QB\",\"RB\",\"SB\",\"TB\",\"UB\",\"VB\",\"WB\",\"XB\",\"YB\",\"ZB\",\"aB\",\"bB\",\"cB\",\"dB\",\"eB\",\"fB\",\"gB\",\"hB\",\"iB\",\"jB\",\"kB\",\"lB\",\"mB\",\"nB\",\"oB\",\"pB\",\"qB\",\"rB\",\"sB\",\"tB\",\"JC\",\"uB\",\"KC\",\"vB\",\"wB\",\"xB\",\"yB\",\"zB\",\"0B\",\"1B\",\"2B\",\"3B\",\"4B\",\"5B\",\"6B\",\"7B\",\"8B\",\"9B\",\"AC\",\"BC\",\"Q\",\"I\",\"R\",\"S\",\"T\",\"U\",\"V\",\"W\",\"X\",\"Y\",\"Z\",\"a\",\"b\",\"c\",\"d\",\"e\",\"f\",\"g\",\"h\",\"i\",\"j\",\"k\",\"l\",\"m\",\"n\",\"o\",\"p\",\"q\",\"r\",\"s\",\"t\",\"u\",\"v\",\"w\",\"x\",\"6\",\"7\",\"8\",\"9\",\"AB\",\"BB\",\"CB\",\"DB\",\"EB\",\"FB\",\"GB\",\"HB\",\"IB\",\"JB\",\"KB\",\"LB\",\"MB\",\"D\",\"MC\",\"NC\",\"OC\",\"PC\"],E:\"Chrome\",F:{\"0\":1343692800,\"1\":1348531200,\"2\":1352246400,\"3\":1357862400,\"4\":1361404800,\"5\":1364428800,\"6\":1689724800,\"7\":1692057600,\"8\":1694476800,\"9\":1696896000,J:1264377600,NB:1274745600,K:1283385600,E:1287619200,F:1291248000,G:1296777600,A:1299542400,B:1303862400,C:1307404800,L:1312243200,M:1316131200,H:1316131200,N:1319500800,O:1323734400,P:1328659200,OB:1332892800,y:1337040000,z:1340668800,PB:1369094400,QB:1374105600,RB:1376956800,SB:1384214400,TB:1389657600,UB:1392940800,VB:1397001600,WB:1400544000,XB:1405468800,YB:1409011200,ZB:1412640000,aB:1416268800,bB:1421798400,cB:1425513600,dB:1429401600,eB:1432080000,fB:1437523200,gB:1441152000,hB:1444780800,iB:1449014400,jB:1453248000,kB:1456963200,lB:1460592000,mB:1464134400,nB:1469059200,oB:1472601600,pB:1476230400,qB:1480550400,rB:1485302400,sB:1489017600,tB:1492560000,JC:1496707200,uB:1500940800,KC:1504569600,vB:1508198400,wB:1512518400,xB:1516752000,yB:1520294400,zB:1523923200,\"0B\":1527552000,\"1B\":1532390400,\"2B\":1536019200,\"3B\":1539648000,\"4B\":1543968000,\"5B\":1548720000,\"6B\":1552348800,\"7B\":1555977600,\"8B\":1559606400,\"9B\":1564444800,AC:1568073600,BC:1571702400,Q:1575936000,I:1580860800,R:1586304000,S:1589846400,T:1594684800,U:1598313600,V:1601942400,W:1605571200,X:1611014400,Y:1614556800,Z:1618272000,a:1621987200,b:1626739200,c:1630368000,d:1632268800,e:1634601600,f:1637020800,g:1641340800,h:1643673600,i:1646092800,j:1648512000,k:1650931200,l:1653350400,m:1655769600,n:1659398400,o:1661817600,p:1664236800,q:1666656000,r:1669680000,s:1673308800,t:1675728000,u:1678147200,v:1680566400,w:1682985600,x:1685404800,AB:1698710400,BB:1701993600,CB:1705968000,DB:1708387200,EB:1710806400,FB:1713225600,GB:1715644800,HB:1718064000,IB:1721174400,JB:1724112000,KB:1726531200,LB:1728950400,MB:1731369600,D:1736812800,MC:1738627200,NC:null,OC:null,PC:null}},E:{A:{J:0,NB:0,K:0,E:0,F:0,G:0,A:0,B:0,C:0,L:0.003558,M:0.01779,H:0.003558,qC:0,QC:0,rC:0,sC:0,tC:0,uC:0,RC:0,CC:0.003558,DC:0.007116,vC:0.039138,wC:0.05337,xC:0.010674,SC:0.007116,TC:0.014232,EC:0.01779,yC:0.167226,FC:0.024906,UC:0.028464,VC:0.021348,WC:0.049812,XC:0.01779,YC:0.028464,zC:0.224154,GC:0.014232,ZC:0.024906,aC:0.024906,bC:0.028464,cC:0.064044,dC:0.131646,\"0C\":0.39138,HC:0.067602,eC:0.939312,fC:0.416286,gC:0.028464,hC:0,\"1C\":0},B:\"webkit\",C:[\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"qC\",\"QC\",\"J\",\"NB\",\"rC\",\"K\",\"sC\",\"E\",\"tC\",\"F\",\"G\",\"uC\",\"A\",\"RC\",\"B\",\"CC\",\"C\",\"DC\",\"L\",\"vC\",\"M\",\"wC\",\"H\",\"xC\",\"SC\",\"TC\",\"EC\",\"yC\",\"FC\",\"UC\",\"VC\",\"WC\",\"XC\",\"YC\",\"zC\",\"GC\",\"ZC\",\"aC\",\"bC\",\"cC\",\"dC\",\"0C\",\"HC\",\"eC\",\"fC\",\"gC\",\"hC\",\"1C\",\"\"],E:\"Safari\",F:{qC:1205798400,QC:1226534400,J:1244419200,NB:1275868800,rC:1311120000,K:1343174400,sC:1382400000,E:1382400000,tC:1410998400,F:1413417600,G:1443657600,uC:1458518400,A:1474329600,RC:1490572800,B:1505779200,CC:1522281600,C:1537142400,DC:1553472000,L:1568851200,vC:1585008000,M:1600214400,wC:1619395200,H:1632096000,xC:1635292800,SC:1639353600,TC:1647216000,EC:1652745600,yC:1658275200,FC:1662940800,UC:1666569600,VC:1670889600,WC:1674432000,XC:1679875200,YC:1684368000,zC:1690156800,GC:1695686400,ZC:1698192000,aC:1702252800,bC:1705881600,cC:1709596800,dC:1715558400,\"0C\":1722211200,HC:1726444800,eC:1730073600,fC:1733875200,gC:1737936000,hC:null,\"1C\":null}},F:{A:{\"0\":0,\"1\":0,\"2\":0,\"3\":0,\"4\":0,\"5\":0,G:0,B:0,C:0,H:0,N:0,O:0,P:0,OB:0,y:0,z:0,PB:0,QB:0,RB:0,SB:0,TB:0,UB:0,VB:0,WB:0,XB:0,YB:0,ZB:0,aB:0,bB:0.003558,cB:0,dB:0,eB:0,fB:0,gB:0,hB:0.014232,iB:0,jB:0,kB:0,lB:0,mB:0,nB:0,oB:0,pB:0,qB:0,rB:0,sB:0,tB:0,uB:0,vB:0,wB:0,xB:0,yB:0,zB:0,\"0B\":0,\"1B\":0,\"2B\":0,\"3B\":0,\"4B\":0,\"5B\":0,\"6B\":0,\"7B\":0,\"8B\":0,\"9B\":0,AC:0,BC:0,Q:0,I:0,R:0,LC:0,S:0,T:0,U:0,V:0.032022,W:0.010674,X:0,Y:0,Z:0,a:0,b:0,c:0,d:0,e:0.032022,f:0,g:0,h:0,i:0,j:0,k:0,l:0.010674,m:0,n:0,o:0,p:0,q:0,r:0,s:0,t:0,u:0,v:0,w:0,x:0.313104,\"2C\":0,\"3C\":0,\"4C\":0,\"5C\":0,CC:0,iC:0,\"6C\":0,DC:0},B:\"webkit\",C:[\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"G\",\"2C\",\"3C\",\"4C\",\"5C\",\"B\",\"CC\",\"iC\",\"6C\",\"C\",\"DC\",\"H\",\"N\",\"O\",\"P\",\"OB\",\"y\",\"z\",\"0\",\"1\",\"2\",\"3\",\"4\",\"5\",\"PB\",\"QB\",\"RB\",\"SB\",\"TB\",\"UB\",\"VB\",\"WB\",\"XB\",\"YB\",\"ZB\",\"aB\",\"bB\",\"cB\",\"dB\",\"eB\",\"fB\",\"gB\",\"hB\",\"iB\",\"jB\",\"kB\",\"lB\",\"mB\",\"nB\",\"oB\",\"pB\",\"qB\",\"rB\",\"sB\",\"tB\",\"uB\",\"vB\",\"wB\",\"xB\",\"yB\",\"zB\",\"0B\",\"1B\",\"2B\",\"3B\",\"4B\",\"5B\",\"6B\",\"7B\",\"8B\",\"9B\",\"AC\",\"BC\",\"Q\",\"I\",\"R\",\"LC\",\"S\",\"T\",\"U\",\"V\",\"W\",\"X\",\"Y\",\"Z\",\"a\",\"b\",\"c\",\"d\",\"e\",\"f\",\"g\",\"h\",\"i\",\"j\",\"k\",\"l\",\"m\",\"n\",\"o\",\"p\",\"q\",\"r\",\"s\",\"t\",\"u\",\"v\",\"w\",\"x\",\"\",\"\",\"\"],E:\"Opera\",F:{\"0\":1401753600,\"1\":1405987200,\"2\":1409616000,\"3\":1413331200,\"4\":1417132800,\"5\":1422316800,G:1150761600,\"2C\":1223424000,\"3C\":1251763200,\"4C\":1267488000,\"5C\":1277942400,B:1292457600,CC:1302566400,iC:1309219200,\"6C\":1323129600,C:1323129600,DC:1352073600,H:1372723200,N:1377561600,O:1381104000,P:1386288000,OB:1390867200,y:1393891200,z:1399334400,PB:1425945600,QB:1430179200,RB:1433808000,SB:1438646400,TB:1442448000,UB:1445904000,VB:1449100800,WB:1454371200,XB:1457308800,YB:1462320000,ZB:1465344000,aB:1470096000,bB:1474329600,cB:1477267200,dB:1481587200,eB:1486425600,fB:1490054400,gB:1494374400,hB:1498003200,iB:1502236800,jB:1506470400,kB:1510099200,lB:1515024000,mB:1517961600,nB:1521676800,oB:1525910400,pB:1530144000,qB:1534982400,rB:1537833600,sB:1543363200,tB:1548201600,uB:1554768000,vB:1561593600,wB:1566259200,xB:1570406400,yB:1573689600,zB:1578441600,\"0B\":1583971200,\"1B\":1587513600,\"2B\":1592956800,\"3B\":1595894400,\"4B\":1600128000,\"5B\":1603238400,\"6B\":1613520000,\"7B\":1612224000,\"8B\":1616544000,\"9B\":1619568000,AC:1623715200,BC:1627948800,Q:1631577600,I:1633392000,R:1635984000,LC:1638403200,S:1642550400,T:1644969600,U:1647993600,V:1650412800,W:1652745600,X:1654646400,Y:1657152000,Z:1660780800,a:1663113600,b:1668816000,c:1668643200,d:1671062400,e:1675209600,f:1677024000,g:1679529600,h:1681948800,i:1684195200,j:1687219200,k:1690329600,l:1692748800,m:1696204800,n:1699920000,o:1699920000,p:1702944000,q:1707264000,r:1710115200,s:1711497600,t:1716336000,u:1719273600,v:1721088000,w:1724284800,x:1727222400},D:{G:\"o\",B:\"o\",C:\"o\",\"2C\":\"o\",\"3C\":\"o\",\"4C\":\"o\",\"5C\":\"o\",CC:\"o\",iC:\"o\",\"6C\":\"o\",DC:\"o\"}},G:{A:{F:0,QC:0,\"7C\":0,jC:0.00293498,\"8C\":0,\"9C\":0.00733744,AD:0.00880493,BD:0,CD:0.00293498,DD:0.0220123,ED:0.00440246,FD:0.0322847,GD:0.0924517,HD:0.0102724,ID:0.00586995,JD:0.155554,KD:0.00293498,LD:0.0176099,MD:0.00586995,ND:0.0220123,OD:0.143814,PD:0.0689719,QD:0.0352197,SC:0.0366872,TC:0.0425571,EC:0.0498946,RD:0.585528,FC:0.0880493,UC:0.192241,VC:0.0983217,WC:0.171696,XC:0.0366872,YC:0.0704394,SD:0.713199,GC:0.0454921,ZC:0.0807118,aC:0.063102,bC:0.0895167,cC:0.192241,dC:0.463726,TD:1.59369,HC:0.490141,eC:6.52592,fC:2.20123,gC:0.190773,hC:0},B:\"webkit\",C:[\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"QC\",\"7C\",\"jC\",\"8C\",\"9C\",\"AD\",\"F\",\"BD\",\"CD\",\"DD\",\"ED\",\"FD\",\"GD\",\"HD\",\"ID\",\"JD\",\"KD\",\"LD\",\"MD\",\"ND\",\"OD\",\"PD\",\"QD\",\"SC\",\"TC\",\"EC\",\"RD\",\"FC\",\"UC\",\"VC\",\"WC\",\"XC\",\"YC\",\"SD\",\"GC\",\"ZC\",\"aC\",\"bC\",\"cC\",\"dC\",\"TD\",\"HC\",\"eC\",\"fC\",\"gC\",\"hC\",\"\",\"\"],E:\"Safari on iOS\",F:{QC:1270252800,\"7C\":1283904000,jC:1299628800,\"8C\":1331078400,\"9C\":1359331200,AD:1394409600,F:1410912000,BD:1413763200,CD:1442361600,DD:1458518400,ED:1473724800,FD:1490572800,GD:1505779200,HD:1522281600,ID:1537142400,JD:1553472000,KD:1568851200,LD:1572220800,MD:1580169600,ND:1585008000,OD:1600214400,PD:1619395200,QD:1632096000,SC:1639353600,TC:1647216000,EC:1652659200,RD:1658275200,FC:1662940800,UC:1666569600,VC:1670889600,WC:1674432000,XC:1679875200,YC:1684368000,SD:1690156800,GC:1694995200,ZC:1698192000,aC:1702252800,bC:1705881600,cC:1709596800,dC:1715558400,TD:1722211200,HC:1726444800,eC:1730073600,fC:1733875200,gC:1737936000,hC:null}},H:{A:{UD:0.04},B:\"o\",C:[\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"UD\",\"\",\"\",\"\"],E:\"Opera Mini\",F:{UD:1426464000}},I:{A:{IC:0,J:0,D:0.308567,VD:0,WD:0,XD:0,YD:0.0000309216,jC:0.0000618432,ZD:0,aD:0.000371059},B:\"webkit\",C:[\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"VD\",\"WD\",\"XD\",\"IC\",\"J\",\"YD\",\"jC\",\"ZD\",\"aD\",\"D\",\"\",\"\",\"\"],E:\"Android Browser\",F:{VD:1256515200,WD:1274313600,XD:1291593600,IC:1298332800,J:1318896000,YD:1341792000,jC:1374624000,ZD:1386547200,aD:1401667200,D:1737676800}},J:{A:{E:0,A:0},B:\"webkit\",C:[\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"E\",\"A\",\"\",\"\",\"\"],E:\"Blackberry Browser\",F:{E:1325376000,A:1359504000}},K:{A:{A:0,B:0,C:0,I:1.03581,CC:0,iC:0,DC:0},B:\"o\",C:[\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"A\",\"B\",\"CC\",\"iC\",\"C\",\"DC\",\"I\",\"\",\"\",\"\"],E:\"Opera Mobile\",F:{A:1287100800,B:1300752000,CC:1314835200,iC:1318291200,C:1330300800,DC:1349740800,I:1709769600},D:{I:\"webkit\"}},L:{A:{D:46.1904},B:\"webkit\",C:[\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"D\",\"\",\"\",\"\"],E:\"Chrome for Android\",F:{D:1737676800}},M:{A:{D:0.334984},B:\"moz\",C:[\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"D\",\"\",\"\",\"\"],E:\"Firefox for Android\",F:{D:1730160000}},N:{A:{A:0,B:0},B:\"ms\",C:[\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"A\",\"B\",\"\",\"\",\"\"],E:\"IE Mobile\",F:{A:1340150400,B:1353456000}},O:{A:{EC:0.83746},B:\"webkit\",C:[\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"EC\",\"\",\"\",\"\"],E:\"UC Browser for Android\",F:{EC:1710115200},D:{EC:\"webkit\"}},P:{A:{\"0\":0.0330772,\"1\":0.0330772,\"2\":0.0441029,\"3\":0.0441029,\"4\":0.110257,\"5\":1.90745,J:0.0661544,y:0,z:0.0220515,bD:0.0110257,cD:0,dD:0.0110257,eD:0,fD:0,RC:0,gD:0,hD:0,iD:0,jD:0,kD:0,FC:0,GC:0.0110257,HC:0,lD:0},B:\"webkit\",C:[\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"J\",\"bD\",\"cD\",\"dD\",\"eD\",\"fD\",\"RC\",\"gD\",\"hD\",\"iD\",\"jD\",\"kD\",\"FC\",\"GC\",\"HC\",\"lD\",\"y\",\"z\",\"0\",\"1\",\"2\",\"3\",\"4\",\"5\",\"\",\"\",\"\"],E:\"Samsung Internet\",F:{\"0\":1689292800,\"1\":1697587200,\"2\":1711497600,\"3\":1715126400,\"4\":1717718400,\"5\":1725667200,J:1461024000,bD:1481846400,cD:1509408000,dD:1528329600,eD:1546128000,fD:1554163200,RC:1567900800,gD:1582588800,hD:1593475200,iD:1605657600,jD:1618531200,kD:1629072000,FC:1640736000,GC:1651708800,HC:1659657600,lD:1667260800,y:1677369600,z:1684454400}},Q:{A:{mD:0.199702},B:\"webkit\",C:[\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"mD\",\"\",\"\",\"\"],E:\"QQ Browser\",F:{mD:1710288000}},R:{A:{nD:0},B:\"webkit\",C:[\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"nD\",\"\",\"\",\"\"],E:\"Baidu Browser\",F:{nD:1710201600}},S:{A:{oD:0.019326,pD:0},B:\"moz\",C:[\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"\",\"oD\",\"pD\",\"\",\"\",\"\"],E:\"KaiOS Browser\",F:{oD:1527811200,pD:1631664000}}};\n","module.exports={\"0\":\"22\",\"1\":\"23\",\"2\":\"24\",\"3\":\"25\",\"4\":\"26\",\"5\":\"27\",\"6\":\"115\",\"7\":\"116\",\"8\":\"117\",\"9\":\"118\",A:\"10\",B:\"11\",C:\"12\",D:\"132\",E:\"7\",F:\"8\",G:\"9\",H:\"15\",I:\"80\",J:\"4\",K:\"6\",L:\"13\",M:\"14\",N:\"16\",O:\"17\",P:\"18\",Q:\"79\",R:\"81\",S:\"83\",T:\"84\",U:\"85\",V:\"86\",W:\"87\",X:\"88\",Y:\"89\",Z:\"90\",a:\"91\",b:\"92\",c:\"93\",d:\"94\",e:\"95\",f:\"96\",g:\"97\",h:\"98\",i:\"99\",j:\"100\",k:\"101\",l:\"102\",m:\"103\",n:\"104\",o:\"105\",p:\"106\",q:\"107\",r:\"108\",s:\"109\",t:\"110\",u:\"111\",v:\"112\",w:\"113\",x:\"114\",y:\"20\",z:\"21\",AB:\"119\",BB:\"120\",CB:\"121\",DB:\"122\",EB:\"123\",FB:\"124\",GB:\"125\",HB:\"126\",IB:\"127\",JB:\"128\",KB:\"129\",LB:\"130\",MB:\"131\",NB:\"5\",OB:\"19\",PB:\"28\",QB:\"29\",RB:\"30\",SB:\"31\",TB:\"32\",UB:\"33\",VB:\"34\",WB:\"35\",XB:\"36\",YB:\"37\",ZB:\"38\",aB:\"39\",bB:\"40\",cB:\"41\",dB:\"42\",eB:\"43\",fB:\"44\",gB:\"45\",hB:\"46\",iB:\"47\",jB:\"48\",kB:\"49\",lB:\"50\",mB:\"51\",nB:\"52\",oB:\"53\",pB:\"54\",qB:\"55\",rB:\"56\",sB:\"57\",tB:\"58\",uB:\"60\",vB:\"62\",wB:\"63\",xB:\"64\",yB:\"65\",zB:\"66\",\"0B\":\"67\",\"1B\":\"68\",\"2B\":\"69\",\"3B\":\"70\",\"4B\":\"71\",\"5B\":\"72\",\"6B\":\"73\",\"7B\":\"74\",\"8B\":\"75\",\"9B\":\"76\",AC:\"77\",BC:\"78\",CC:\"11.1\",DC:\"12.1\",EC:\"15.5\",FC:\"16.0\",GC:\"17.0\",HC:\"18.0\",IC:\"3\",JC:\"59\",KC:\"61\",LC:\"82\",MC:\"133\",NC:\"134\",OC:\"135\",PC:\"136\",QC:\"3.2\",RC:\"10.1\",SC:\"15.2-15.3\",TC:\"15.4\",UC:\"16.1\",VC:\"16.2\",WC:\"16.3\",XC:\"16.4\",YC:\"16.5\",ZC:\"17.1\",aC:\"17.2\",bC:\"17.3\",cC:\"17.4\",dC:\"17.5\",eC:\"18.1\",fC:\"18.2\",gC:\"18.3\",hC:\"18.4\",iC:\"11.5\",jC:\"4.2-4.3\",kC:\"5.5\",lC:\"2\",mC:\"137\",nC:\"138\",oC:\"3.5\",pC:\"3.6\",qC:\"3.1\",rC:\"5.1\",sC:\"6.1\",tC:\"7.1\",uC:\"9.1\",vC:\"13.1\",wC:\"14.1\",xC:\"15.1\",yC:\"15.6\",zC:\"16.6\",\"0C\":\"17.6\",\"1C\":\"TP\",\"2C\":\"9.5-9.6\",\"3C\":\"10.0-10.1\",\"4C\":\"10.5\",\"5C\":\"10.6\",\"6C\":\"11.6\",\"7C\":\"4.0-4.1\",\"8C\":\"5.0-5.1\",\"9C\":\"6.0-6.1\",AD:\"7.0-7.1\",BD:\"8.1-8.4\",CD:\"9.0-9.2\",DD:\"9.3\",ED:\"10.0-10.2\",FD:\"10.3\",GD:\"11.0-11.2\",HD:\"11.3-11.4\",ID:\"12.0-12.1\",JD:\"12.2-12.5\",KD:\"13.0-13.1\",LD:\"13.2\",MD:\"13.3\",ND:\"13.4-13.7\",OD:\"14.0-14.4\",PD:\"14.5-14.8\",QD:\"15.0-15.1\",RD:\"15.6-15.8\",SD:\"16.6-16.7\",TD:\"17.6-17.7\",UD:\"all\",VD:\"2.1\",WD:\"2.2\",XD:\"2.3\",YD:\"4.1\",ZD:\"4.4\",aD:\"4.4.3-4.4.4\",bD:\"5.0-5.4\",cD:\"6.2-6.4\",dD:\"7.2-7.4\",eD:\"8.2\",fD:\"9.2\",gD:\"11.1-11.2\",hD:\"12.0\",iD:\"13.0\",jD:\"14.0\",kD:\"15.0\",lD:\"19.0\",mD:\"14.9\",nD:\"13.52\",oD:\"2.5\",pD:\"3.0-3.1\"};\n","module.exports={A:\"ie\",B:\"edge\",C:\"firefox\",D:\"chrome\",E:\"safari\",F:\"opera\",G:\"ios_saf\",H:\"op_mini\",I:\"android\",J:\"bb\",K:\"op_mob\",L:\"and_chr\",M:\"and_ff\",N:\"ie_mob\",O:\"and_uc\",P:\"samsung\",Q:\"and_qq\",R:\"baidu\",S:\"kaios\"};\n","'use strict'\n\nconst browsers = require('./browsers').browsers\nconst versions = require('./browserVersions').browserVersions\nconst agentsData = require('../../data/agents')\n\nfunction unpackBrowserVersions(versionsData) {\n  return Object.keys(versionsData).reduce((usage, version) => {\n    usage[versions[version]] = versionsData[version]\n    return usage\n  }, {})\n}\n\nmodule.exports.agents = Object.keys(agentsData).reduce((map, key) => {\n  let versionsData = agentsData[key]\n  map[browsers[key]] = Object.keys(versionsData).reduce((data, entry) => {\n    if (entry === 'A') {\n      data.usage_global = unpackBrowserVersions(versionsData[entry])\n    } else if (entry === 'C') {\n      data.versions = versionsData[entry].reduce((list, version) => {\n        if (version === '') {\n          list.push(null)\n        } else {\n          list.push(versions[version])\n        }\n        return list\n      }, [])\n    } else if (entry === 'D') {\n      data.prefix_exceptions = unpackBrowserVersions(versionsData[entry])\n    } else if (entry === 'E') {\n      data.browser = versionsData[entry]\n    } else if (entry === 'F') {\n      data.release_date = Object.keys(versionsData[entry]).reduce(\n        (map2, key2) => {\n          map2[versions[key2]] = versionsData[entry][key2]\n          return map2\n        },\n        {}\n      )\n    } else {\n      // entry is B\n      data.prefix = versionsData[entry]\n    }\n    return data\n  }, {})\n  return map\n}, {})\n","module.exports.browserVersions = require('../../data/browserVersions')\n","module.exports.browsers = require('../../data/browsers')\n","/*!\n\tCopyright (c) 2018 Jed Watson.\n\tLicensed under the MIT License (MIT), see\n\thttp://jedwatson.github.io/classnames\n*/\n/* global define */\n\n(function () {\n\t'use strict';\n\n\tvar hasOwn = {}.hasOwnProperty;\n\n\tfunction classNames () {\n\t\tvar classes = '';\n\n\t\tfor (var i = 0; i < arguments.length; i++) {\n\t\t\tvar arg = arguments[i];\n\t\t\tif (arg) {\n\t\t\t\tclasses = appendClass(classes, parseValue(arg));\n\t\t\t}\n\t\t}\n\n\t\treturn classes;\n\t}\n\n\tfunction parseValue (arg) {\n\t\tif (typeof arg === 'string' || typeof arg === 'number') {\n\t\t\treturn arg;\n\t\t}\n\n\t\tif (typeof arg !== 'object') {\n\t\t\treturn '';\n\t\t}\n\n\t\tif (Array.isArray(arg)) {\n\t\t\treturn classNames.apply(null, arg);\n\t\t}\n\n\t\tif (arg.toString !== Object.prototype.toString && !arg.toString.toString().includes('[native code]')) {\n\t\t\treturn arg.toString();\n\t\t}\n\n\t\tvar classes = '';\n\n\t\tfor (var key in arg) {\n\t\t\tif (hasOwn.call(arg, key) && arg[key]) {\n\t\t\t\tclasses = appendClass(classes, key);\n\t\t\t}\n\t\t}\n\n\t\treturn classes;\n\t}\n\n\tfunction appendClass (value, newClass) {\n\t\tif (!newClass) {\n\t\t\treturn value;\n\t\t}\n\t\n\t\tif (value) {\n\t\t\treturn value + ' ' + newClass;\n\t\t}\n\t\n\t\treturn value + newClass;\n\t}\n\n\tif (typeof module !== 'undefined' && module.exports) {\n\t\tclassNames.default = classNames;\n\t\tmodule.exports = classNames;\n\t} else if (typeof define === 'function' && typeof define.amd === 'object' && define.amd) {\n\t\t// register as 'classnames', consistent with npm package name\n\t\tdefine('classnames', [], function () {\n\t\t\treturn classNames;\n\t\t});\n\t} else {\n\t\twindow.classNames = classNames;\n\t}\n}());\n","\"use strict\";\n\nfunction isContainer(node) {\n    switch (node._type) {\n        case \"document\":\n        case \"block_quote\":\n        case \"list\":\n        case \"item\":\n        case \"paragraph\":\n        case \"heading\":\n        case \"emph\":\n        case \"strong\":\n        case \"link\":\n        case \"image\":\n        case \"custom_inline\":\n        case \"custom_block\":\n            return true;\n        default:\n            return false;\n    }\n}\n\nvar resumeAt = function(node, entering) {\n    this.current = node;\n    this.entering = entering === true;\n};\n\nvar next = function() {\n    var cur = this.current;\n    var entering = this.entering;\n\n    if (cur === null) {\n        return null;\n    }\n\n    var container = isContainer(cur);\n\n    if (entering && container) {\n        if (cur._firstChild) {\n            this.current = cur._firstChild;\n            this.entering = true;\n        } else {\n            // stay on node but exit\n            this.entering = false;\n        }\n    } else if (cur === this.root) {\n        this.current = null;\n    } else if (cur._next === null) {\n        this.current = cur._parent;\n        this.entering = false;\n    } else {\n        this.current = cur._next;\n        this.entering = true;\n    }\n\n    return { entering: entering, node: cur };\n};\n\nvar NodeWalker = function(root) {\n    return {\n        current: root,\n        root: root,\n        entering: true,\n        next: next,\n        resumeAt: resumeAt\n    };\n};\n\nvar Node = function(nodeType, sourcepos) {\n    this._type = nodeType;\n    this._parent = null;\n    this._firstChild = null;\n    this._lastChild = null;\n    this._prev = null;\n    this._next = null;\n    this._sourcepos = sourcepos;\n    this._open = true;\n    this._string_content = null;\n    this._literal = null;\n    this._listData = {};\n    this._info = null;\n    this._destination = null;\n    this._title = null;\n    this._isFenced = false;\n    this._fenceChar = null;\n    this._fenceLength = 0;\n    this._fenceOffset = null;\n    this._level = null;\n    this._onEnter = null;\n    this._onExit = null;\n};\n\nvar proto = Node.prototype;\n\nObject.defineProperty(proto, \"isContainer\", {\n    get: function() {\n        return isContainer(this);\n    }\n});\n\nObject.defineProperty(proto, \"type\", {\n    get: function() {\n        return this._type;\n    }\n});\n\nObject.defineProperty(proto, \"firstChild\", {\n    get: function() {\n        return this._firstChild;\n    }\n});\n\nObject.defineProperty(proto, \"lastChild\", {\n    get: function() {\n        return this._lastChild;\n    }\n});\n\nObject.defineProperty(proto, \"next\", {\n    get: function() {\n        return this._next;\n    }\n});\n\nObject.defineProperty(proto, \"prev\", {\n    get: function() {\n        return this._prev;\n    }\n});\n\nObject.defineProperty(proto, \"parent\", {\n    get: function() {\n        return this._parent;\n    }\n});\n\nObject.defineProperty(proto, \"sourcepos\", {\n    get: function() {\n        return this._sourcepos;\n    }\n});\n\nObject.defineProperty(proto, \"literal\", {\n    get: function() {\n        return this._literal;\n    },\n    set: function(s) {\n        this._literal = s;\n    }\n});\n\nObject.defineProperty(proto, \"destination\", {\n    get: function() {\n        return this._destination;\n    },\n    set: function(s) {\n        this._destination = s;\n    }\n});\n\nObject.defineProperty(proto, \"title\", {\n    get: function() {\n        return this._title;\n    },\n    set: function(s) {\n        this._title = s;\n    }\n});\n\nObject.defineProperty(proto, \"info\", {\n    get: function() {\n        return this._info;\n    },\n    set: function(s) {\n        this._info = s;\n    }\n});\n\nObject.defineProperty(proto, \"level\", {\n    get: function() {\n        return this._level;\n    },\n    set: function(s) {\n        this._level = s;\n    }\n});\n\nObject.defineProperty(proto, \"listType\", {\n    get: function() {\n        return this._listData.type;\n    },\n    set: function(t) {\n        this._listData.type = t;\n    }\n});\n\nObject.defineProperty(proto, \"listTight\", {\n    get: function() {\n        return this._listData.tight;\n    },\n    set: function(t) {\n        this._listData.tight = t;\n    }\n});\n\nObject.defineProperty(proto, \"listStart\", {\n    get: function() {\n        return this._listData.start;\n    },\n    set: function(n) {\n        this._listData.start = n;\n    }\n});\n\nObject.defineProperty(proto, \"listDelimiter\", {\n    get: function() {\n        return this._listData.delimiter;\n    },\n    set: function(delim) {\n        this._listData.delimiter = delim;\n    }\n});\n\nObject.defineProperty(proto, \"onEnter\", {\n    get: function() {\n        return this._onEnter;\n    },\n    set: function(s) {\n        this._onEnter = s;\n    }\n});\n\nObject.defineProperty(proto, \"onExit\", {\n    get: function() {\n        return this._onExit;\n    },\n    set: function(s) {\n        this._onExit = s;\n    }\n});\n\nNode.prototype.appendChild = function(child) {\n    child.unlink();\n    child._parent = this;\n    if (this._lastChild) {\n        this._lastChild._next = child;\n        child._prev = this._lastChild;\n        this._lastChild = child;\n    } else {\n        this._firstChild = child;\n        this._lastChild = child;\n    }\n};\n\nNode.prototype.prependChild = function(child) {\n    child.unlink();\n    child._parent = this;\n    if (this._firstChild) {\n        this._firstChild._prev = child;\n        child._next = this._firstChild;\n        this._firstChild = child;\n    } else {\n        this._firstChild = child;\n        this._lastChild = child;\n    }\n};\n\nNode.prototype.unlink = function() {\n    if (this._prev) {\n        this._prev._next = this._next;\n    } else if (this._parent) {\n        this._parent._firstChild = this._next;\n    }\n    if (this._next) {\n        this._next._prev = this._prev;\n    } else if (this._parent) {\n        this._parent._lastChild = this._prev;\n    }\n    this._parent = null;\n    this._next = null;\n    this._prev = null;\n};\n\nNode.prototype.insertAfter = function(sibling) {\n    sibling.unlink();\n    sibling._next = this._next;\n    if (sibling._next) {\n        sibling._next._prev = sibling;\n    }\n    sibling._prev = this;\n    this._next = sibling;\n    sibling._parent = this._parent;\n    if (!sibling._next) {\n        sibling._parent._lastChild = sibling;\n    }\n};\n\nNode.prototype.insertBefore = function(sibling) {\n    sibling.unlink();\n    sibling._prev = this._prev;\n    if (sibling._prev) {\n        sibling._prev._next = sibling;\n    }\n    sibling._next = this;\n    this._prev = sibling;\n    sibling._parent = this._parent;\n    if (!sibling._prev) {\n        sibling._parent._firstChild = sibling;\n    }\n};\n\nNode.prototype.walker = function() {\n    var walker = new NodeWalker(this);\n    return walker;\n};\n\nexport default Node;\n\n/* Example of use of walker:\n\n var walker = w.walker();\n var event;\n\n while (event = walker.next()) {\n console.log(event.entering, event.node.type);\n }\n\n */\n","\"use strict\";\n\n// derived from https://github.com/mathiasbynens/String.fromCodePoint\n/*! http://mths.be/fromcodepoint v0.2.1 by @mathias */\n\nvar _fromCodePoint;\n\nexport default function fromCodePoint(_) {\n    return _fromCodePoint(_);\n}\n\nif (String.fromCodePoint) {\n    _fromCodePoint = function(_) {\n        try {\n            return String.fromCodePoint(_);\n        } catch (e) {\n            if (e instanceof RangeError) {\n                return String.fromCharCode(0xfffd);\n            }\n            throw e;\n        }\n    };\n} else {\n    var stringFromCharCode = String.fromCharCode;\n    var floor = Math.floor;\n    _fromCodePoint = function() {\n        var MAX_SIZE = 0x4000;\n        var codeUnits = [];\n        var highSurrogate;\n        var lowSurrogate;\n        var index = -1;\n        var length = arguments.length;\n        if (!length) {\n            return \"\";\n        }\n        var result = \"\";\n        while (++index < length) {\n            var codePoint = Number(arguments[index]);\n            if (\n                !isFinite(codePoint) || // `NaN`, `+Infinity`, or `-Infinity`\n                codePoint < 0 || // not a valid Unicode code point\n                codePoint > 0x10ffff || // not a valid Unicode code point\n                floor(codePoint) !== codePoint // not an integer\n            ) {\n                return String.fromCharCode(0xfffd);\n            }\n            if (codePoint <= 0xffff) {\n                // BMP code point\n                codeUnits.push(codePoint);\n            } else {\n                // Astral code point; split in surrogate halves\n                // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae\n                codePoint -= 0x10000;\n                highSurrogate = (codePoint >> 10) + 0xd800;\n                lowSurrogate = (codePoint % 0x400) + 0xdc00;\n                codeUnits.push(highSurrogate, lowSurrogate);\n            }\n            if (index + 1 === length || codeUnits.length > MAX_SIZE) {\n                result += stringFromCharCode.apply(null, codeUnits);\n                codeUnits.length = 0;\n            }\n        }\n        return result;\n    };\n}\n","\"use strict\";\n\nimport encode from \"mdurl/encode.js\";\nimport { decodeHTMLStrict } from \"entities\";\n\nvar C_BACKSLASH = 92;\n\nvar ENTITY = \"&(?:#x[a-f0-9]{1,6}|#[0-9]{1,7}|[a-z][a-z0-9]{1,31});\";\n\nvar TAGNAME = \"[A-Za-z][A-Za-z0-9-]*\";\nvar ATTRIBUTENAME = \"[a-zA-Z_:][a-zA-Z0-9:._-]*\";\nvar UNQUOTEDVALUE = \"[^\\\"'=<>`\\\\x00-\\\\x20]+\";\nvar SINGLEQUOTEDVALUE = \"'[^']*'\";\nvar DOUBLEQUOTEDVALUE = '\"[^\"]*\"';\nvar ATTRIBUTEVALUE =\n    \"(?:\" +\n    UNQUOTEDVALUE +\n    \"|\" +\n    SINGLEQUOTEDVALUE +\n    \"|\" +\n    DOUBLEQUOTEDVALUE +\n    \")\";\nvar ATTRIBUTEVALUESPEC = \"(?:\" + \"\\\\s*=\" + \"\\\\s*\" + ATTRIBUTEVALUE + \")\";\nvar ATTRIBUTE = \"(?:\" + \"\\\\s+\" + ATTRIBUTENAME + ATTRIBUTEVALUESPEC + \"?)\";\nvar OPENTAG = \"<\" + TAGNAME + ATTRIBUTE + \"*\" + \"\\\\s*/?>\";\nvar CLOSETAG = \"</\" + TAGNAME + \"\\\\s*[>]\";\nvar HTMLCOMMENT = \"<!-->|<!--->|<!--[\\\\s\\\\S]*?-->\"\nvar PROCESSINGINSTRUCTION = \"[<][?][\\\\s\\\\S]*?[?][>]\";\nvar DECLARATION = \"<![A-Za-z]+\" + \"[^>]*>\";\nvar CDATA = \"<!\\\\[CDATA\\\\[[\\\\s\\\\S]*?\\\\]\\\\]>\";\nvar HTMLTAG =\n    \"(?:\" +\n    OPENTAG +\n    \"|\" +\n    CLOSETAG +\n    \"|\" +\n    HTMLCOMMENT +\n    \"|\" +\n    PROCESSINGINSTRUCTION +\n    \"|\" +\n    DECLARATION +\n    \"|\" +\n    CDATA +\n    \")\";\nvar reHtmlTag = new RegExp(\"^\" + HTMLTAG);\n\nvar reBackslashOrAmp = /[\\\\&]/;\n\nvar ESCAPABLE = \"[!\\\"#$%&'()*+,./:;<=>?@[\\\\\\\\\\\\]^_`{|}~-]\";\n\nvar reEntityOrEscapedChar = new RegExp(\"\\\\\\\\\" + ESCAPABLE + \"|\" + ENTITY, \"gi\");\n\nvar XMLSPECIAL = '[&<>\"]';\n\nvar reXmlSpecial = new RegExp(XMLSPECIAL, \"g\");\n\nvar unescapeChar = function(s) {\n    if (s.charCodeAt(0) === C_BACKSLASH) {\n        return s.charAt(1);\n    } else {\n        return decodeHTMLStrict(s);\n    }\n};\n\n// Replace entities and backslash escapes with literal characters.\nvar unescapeString = function(s) {\n    if (reBackslashOrAmp.test(s)) {\n        return s.replace(reEntityOrEscapedChar, unescapeChar);\n    } else {\n        return s;\n    }\n};\n\nvar normalizeURI = function(uri) {\n    try {\n        return encode(uri);\n    } catch (err) {\n        return uri;\n    }\n};\n\nvar replaceUnsafeChar = function(s) {\n    switch (s) {\n        case \"&\":\n            return \"&amp;\";\n        case \"<\":\n            return \"&lt;\";\n        case \">\":\n            return \"&gt;\";\n        case '\"':\n            return \"&quot;\";\n        default:\n            return s;\n    }\n};\n\nvar escapeXml = function(s) {\n    if (reXmlSpecial.test(s)) {\n        return s.replace(reXmlSpecial, replaceUnsafeChar);\n    } else {\n        return s;\n    }\n};\n\nexport {\n    unescapeString,\n    normalizeURI,\n    escapeXml,\n    reHtmlTag,\n    OPENTAG,\n    CLOSETAG,\n    ENTITY,\n    ESCAPABLE\n};\n","\"use strict\";\n\nimport Node from \"./node.js\";\nimport * as common from \"./common.js\";\nimport fromCodePoint from \"./from-code-point.js\";\nimport { decodeHTMLStrict } from \"entities\";\n\nvar normalizeURI = common.normalizeURI;\nvar unescapeString = common.unescapeString;\n\n// Constants for character codes:\n\nvar C_NEWLINE = 10;\nvar C_ASTERISK = 42;\nvar C_UNDERSCORE = 95;\nvar C_BACKTICK = 96;\nvar C_OPEN_BRACKET = 91;\nvar C_CLOSE_BRACKET = 93;\nvar C_LESSTHAN = 60;\nvar C_BANG = 33;\nvar C_BACKSLASH = 92;\nvar C_AMPERSAND = 38;\nvar C_OPEN_PAREN = 40;\nvar C_CLOSE_PAREN = 41;\nvar C_COLON = 58;\nvar C_SINGLEQUOTE = 39;\nvar C_DOUBLEQUOTE = 34;\n\n// Some regexps used in inline parser:\n\nvar ESCAPABLE = common.ESCAPABLE;\nvar ESCAPED_CHAR = \"\\\\\\\\\" + ESCAPABLE;\n\nvar ENTITY = common.ENTITY;\nvar reHtmlTag = common.reHtmlTag;\n\nvar rePunctuation = new RegExp(\n    /^[!\"#$%&'()*+,\\-./:;<=>?@\\[\\]\\\\^_`{|}~\\p{P}\\p{S}]/u);\n\nvar reLinkTitle = new RegExp(\n    '^(?:\"(' +\n        ESCAPED_CHAR +\n        '|\\\\\\\\[^\\\\\\\\]' +\n        '|[^\\\\\\\\\"\\\\x00])*\"' +\n        \"|\" +\n        \"'(\" +\n        ESCAPED_CHAR +\n        '|\\\\\\\\[^\\\\\\\\]' +\n        \"|[^\\\\\\\\'\\\\x00])*'\" +\n        \"|\" +\n        \"\\\\((\" +\n        ESCAPED_CHAR +\n        '|\\\\\\\\[^\\\\\\\\]' +\n        \"|[^\\\\\\\\()\\\\x00])*\\\\))\"\n);\n\nvar reLinkDestinationBraces = /^(?:<(?:[^<>\\n\\\\\\x00]|\\\\.)*>)/;\n\nvar reEscapable = new RegExp(\"^\" + ESCAPABLE);\n\nvar reEntityHere = new RegExp(\"^\" + ENTITY, \"i\");\n\nvar reTicks = /`+/;\n\nvar reTicksHere = /^`+/;\n\nvar reEllipses = /\\.\\.\\./g;\n\nvar reDash = /--+/g;\n\nvar reEmailAutolink = /^<([a-zA-Z0-9.!#$%&'*+\\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*)>/;\n\nvar reAutolink = /^<[A-Za-z][A-Za-z0-9.+-]{1,31}:[^<>\\x00-\\x20]*>/i;\n\nvar reSpnl = /^ *(?:\\n *)?/;\n\nvar reWhitespaceChar = /^[ \\t\\n\\x0b\\x0c\\x0d]/;\n\nvar reUnicodeWhitespaceChar = /^\\s/;\n\nvar reFinalSpace = / *$/;\n\nvar reInitialSpace = /^ */;\n\nvar reSpaceAtEndOfLine = /^ *(?:\\n|$)/;\n\nvar reLinkLabel = /^\\[(?:[^\\\\\\[\\]]|\\\\.){0,1000}\\]/s;\n\n// Matches a string of non-special characters.\nvar reMain = /^[^\\n`\\[\\]\\\\!<&*_'\"]+/m;\n\nvar text = function(s) {\n    var node = new Node(\"text\");\n    node._literal = s;\n    return node;\n};\n\n// normalize a reference in reference link (remove []s, trim,\n// collapse internal space, unicode case fold.\n// See commonmark/commonmark.js#168.\nvar normalizeReference = function(string) {\n    return string\n        .slice(1, string.length - 1)\n        .trim()\n        .replace(/[ \\t\\r\\n]+/g, \" \")\n        .toLowerCase()\n        .toUpperCase();\n};\n\n// INLINE PARSER\n\n// These are methods of an InlineParser object, defined below.\n// An InlineParser keeps track of a subject (a string to be\n// parsed) and a position in that subject.\n\n// If re matches at current position in the subject, advance\n// position in subject and return the match; otherwise return null.\nvar match = function(re) {\n    var m = re.exec(this.subject.slice(this.pos));\n    if (m === null) {\n        return null;\n    } else {\n        this.pos += m.index + m[0].length;\n        return m[0];\n    }\n};\n\n// Returns the code for the character at the current subject position, or -1\n// there are no more characters.\nvar peek = function() {\n    if (this.pos < this.subject.length) {\n        return this.subject.charCodeAt(this.pos);\n    } else {\n        return -1;\n    }\n};\n\n// Parse zero or more space characters, including at most one newline\nvar spnl = function() {\n    this.match(reSpnl);\n    return true;\n};\n\n// All of the parsers below try to match something at the current position\n// in the subject.  If they succeed in matching anything, they\n// return the inline matched, advancing the subject.\n\n// Attempt to parse backticks, adding either a backtick code span or a\n// literal sequence of backticks.\nvar parseBackticks = function(block) {\n    var ticks = this.match(reTicksHere);\n    if (ticks === null) {\n        return false;\n    }\n    var afterOpenTicks = this.pos;\n    var matched;\n    var node;\n    var contents;\n    while ((matched = this.match(reTicks)) !== null) {\n        if (matched === ticks) {\n            node = new Node(\"code\");\n            contents = this.subject\n                .slice(afterOpenTicks, this.pos - ticks.length)\n                .replace(/\\n/gm, \" \");\n            if (\n                contents.length > 0 &&\n                contents.match(/[^ ]/) !== null &&\n                contents[0] == \" \" &&\n                contents[contents.length - 1] == \" \"\n            ) {\n                node._literal = contents.slice(1, contents.length - 1);\n            } else {\n                node._literal = contents;\n            }\n            block.appendChild(node);\n            return true;\n        }\n    }\n    // If we got here, we didn't match a closing backtick sequence.\n    this.pos = afterOpenTicks;\n    block.appendChild(text(ticks));\n    return true;\n};\n\n// Parse a backslash-escaped special character, adding either the escaped\n// character, a hard line break (if the backslash is followed by a newline),\n// or a literal backslash to the block's children.  Assumes current character\n// is a backslash.\nvar parseBackslash = function(block) {\n    var subj = this.subject;\n    var node;\n    this.pos += 1;\n    if (this.peek() === C_NEWLINE) {\n        this.pos += 1;\n        node = new Node(\"linebreak\");\n        block.appendChild(node);\n    } else if (reEscapable.test(subj.charAt(this.pos))) {\n        block.appendChild(text(subj.charAt(this.pos)));\n        this.pos += 1;\n    } else {\n        block.appendChild(text(\"\\\\\"));\n    }\n    return true;\n};\n\n// Attempt to parse an autolink (URL or email in pointy brackets).\nvar parseAutolink = function(block) {\n    var m;\n    var dest;\n    var node;\n    if ((m = this.match(reEmailAutolink))) {\n        dest = m.slice(1, m.length - 1);\n        node = new Node(\"link\");\n        node._destination = normalizeURI(\"mailto:\" + dest);\n        node._title = \"\";\n        node.appendChild(text(dest));\n        block.appendChild(node);\n        return true;\n    } else if ((m = this.match(reAutolink))) {\n        dest = m.slice(1, m.length - 1);\n        node = new Node(\"link\");\n        node._destination = normalizeURI(dest);\n        node._title = \"\";\n        node.appendChild(text(dest));\n        block.appendChild(node);\n        return true;\n    } else {\n        return false;\n    }\n};\n\n// Attempt to parse a raw HTML tag.\nvar parseHtmlTag = function(block) {\n    var m = this.match(reHtmlTag);\n    if (m === null) {\n        return false;\n    } else {\n        var node = new Node(\"html_inline\");\n        node._literal = m;\n        block.appendChild(node);\n        return true;\n    }\n};\n\n// Scan a sequence of characters with code cc, and return information about\n// the number of delimiters and whether they are positioned such that\n// they can open and/or close emphasis or strong emphasis.  A utility\n// function for strong/emph parsing.\nvar scanDelims = function(cc) {\n    var numdelims = 0;\n    var char_before, char_after, cc_after;\n    var startpos = this.pos;\n    var left_flanking, right_flanking, can_open, can_close;\n    var after_is_whitespace,\n        after_is_punctuation,\n        before_is_whitespace,\n        before_is_punctuation;\n\n    if (cc === C_SINGLEQUOTE || cc === C_DOUBLEQUOTE) {\n        numdelims++;\n        this.pos++;\n    } else {\n        while (this.peek() === cc) {\n            numdelims++;\n            this.pos++;\n        }\n    }\n\n    if (numdelims === 0) {\n        return null;\n    }\n\n    char_before = startpos === 0 ? \"\\n\" : this.subject.charAt(startpos - 1);\n\n    cc_after = this.peek();\n    if (cc_after === -1) {\n        char_after = \"\\n\";\n    } else {\n        char_after = fromCodePoint(cc_after);\n    }\n\n    after_is_whitespace = reUnicodeWhitespaceChar.test(char_after);\n    after_is_punctuation = rePunctuation.test(char_after);\n    before_is_whitespace = reUnicodeWhitespaceChar.test(char_before);\n    before_is_punctuation = rePunctuation.test(char_before);\n\n    left_flanking =\n        !after_is_whitespace &&\n        (!after_is_punctuation ||\n            before_is_whitespace ||\n            before_is_punctuation);\n    right_flanking =\n        !before_is_whitespace &&\n        (!before_is_punctuation || after_is_whitespace || after_is_punctuation);\n    if (cc === C_UNDERSCORE) {\n        can_open = left_flanking && (!right_flanking || before_is_punctuation);\n        can_close = right_flanking && (!left_flanking || after_is_punctuation);\n    } else if (cc === C_SINGLEQUOTE || cc === C_DOUBLEQUOTE) {\n        can_open = left_flanking && !right_flanking;\n        can_close = right_flanking;\n    } else {\n        can_open = left_flanking;\n        can_close = right_flanking;\n    }\n    this.pos = startpos;\n    return { numdelims: numdelims, can_open: can_open, can_close: can_close };\n};\n\n// Handle a delimiter marker for emphasis or a quote.\nvar handleDelim = function(cc, block) {\n    var res = this.scanDelims(cc);\n    if (!res) {\n        return false;\n    }\n    var numdelims = res.numdelims;\n    var startpos = this.pos;\n    var contents;\n\n    this.pos += numdelims;\n    if (cc === C_SINGLEQUOTE) {\n        contents = \"\\u2019\";\n    } else if (cc === C_DOUBLEQUOTE) {\n        contents = \"\\u201C\";\n    } else {\n        contents = this.subject.slice(startpos, this.pos);\n    }\n    var node = text(contents);\n    block.appendChild(node);\n\n    // Add entry to stack for this opener\n    if (\n        (res.can_open || res.can_close) &&\n        (this.options.smart || (cc !== C_SINGLEQUOTE && cc !== C_DOUBLEQUOTE))\n    ) {\n        this.delimiters = {\n            cc: cc,\n            numdelims: numdelims,\n            origdelims: numdelims,\n            node: node,\n            previous: this.delimiters,\n            next: null,\n            can_open: res.can_open,\n            can_close: res.can_close\n        };\n        if (this.delimiters.previous !== null) {\n            this.delimiters.previous.next = this.delimiters;\n        }\n    }\n\n    return true;\n};\n\nvar removeDelimiter = function(delim) {\n    if (delim.previous !== null) {\n        delim.previous.next = delim.next;\n    }\n    if (delim.next === null) {\n        // top of stack\n        this.delimiters = delim.previous;\n    } else {\n        delim.next.previous = delim.previous;\n    }\n};\n\nvar removeDelimitersBetween = function(bottom, top) {\n    if (bottom.next !== top) {\n        bottom.next = top;\n        top.previous = bottom;\n    }\n};\n\nvar processEmphasis = function(stack_bottom) {\n    var opener, closer, old_closer;\n    var opener_inl, closer_inl;\n    var tempstack;\n    var use_delims;\n    var tmp, next;\n    var opener_found;\n    var openers_bottom = [];\n    var openers_bottom_index;\n    var odd_match = false;\n\n    for (var i = 0; i < 14; i++) {\n        openers_bottom[i] = stack_bottom;\n    }\n    // find first closer above stack_bottom:\n    closer = this.delimiters;\n    while (closer !== null && closer.previous !== stack_bottom) {\n        closer = closer.previous;\n    }\n    // move forward, looking for closers, and handling each\n    while (closer !== null) {\n        var closercc = closer.cc;\n        if (!closer.can_close) {\n            closer = closer.next;\n        } else {\n            // found emphasis closer. now look back for first matching opener:\n            opener = closer.previous;\n            opener_found = false;\n            switch (closercc) {\n               case C_SINGLEQUOTE:\n                 openers_bottom_index = 0;\n                 break;\n               case C_DOUBLEQUOTE:\n                 openers_bottom_index = 1;\n                 break;\n               case C_UNDERSCORE:\n                 openers_bottom_index = 2 + (closer.can_open ? 3 : 0)\n                                          + (closer.origdelims % 3);\n                 break;\n               case C_ASTERISK:\n                 openers_bottom_index = 8 + (closer.can_open ? 3 : 0)\n                                          + (closer.origdelims % 3);\n                 break;\n            }\n            while (\n                opener !== null &&\n                opener !== stack_bottom &&\n                opener !== openers_bottom[openers_bottom_index]\n            ) {\n                odd_match =\n                    (closer.can_open || opener.can_close) &&\n                    closer.origdelims % 3 !== 0 &&\n                    (opener.origdelims + closer.origdelims) % 3 === 0;\n                if (opener.cc === closer.cc && opener.can_open && !odd_match) {\n                    opener_found = true;\n                    break;\n                }\n                opener = opener.previous;\n            }\n            old_closer = closer;\n\n            if (closercc === C_ASTERISK || closercc === C_UNDERSCORE) {\n                if (!opener_found) {\n                    closer = closer.next;\n                } else {\n                    // calculate actual number of delimiters used from closer\n                    use_delims =\n                        closer.numdelims >= 2 && opener.numdelims >= 2 ? 2 : 1;\n\n                    opener_inl = opener.node;\n                    closer_inl = closer.node;\n\n                    // remove used delimiters from stack elts and inlines\n                    opener.numdelims -= use_delims;\n                    closer.numdelims -= use_delims;\n                    opener_inl._literal = opener_inl._literal.slice(\n                        0,\n                        opener_inl._literal.length - use_delims\n                    );\n                    closer_inl._literal = closer_inl._literal.slice(\n                        0,\n                        closer_inl._literal.length - use_delims\n                    );\n\n                    // build contents for new emph element\n                    var emph = new Node(use_delims === 1 ? \"emph\" : \"strong\");\n\n                    tmp = opener_inl._next;\n                    while (tmp && tmp !== closer_inl) {\n                        next = tmp._next;\n                        tmp.unlink();\n                        emph.appendChild(tmp);\n                        tmp = next;\n                    }\n\n                    opener_inl.insertAfter(emph);\n\n                    // remove elts between opener and closer in delimiters stack\n                    removeDelimitersBetween(opener, closer);\n\n                    // if opener has 0 delims, remove it and the inline\n                    if (opener.numdelims === 0) {\n                        opener_inl.unlink();\n                        this.removeDelimiter(opener);\n                    }\n\n                    if (closer.numdelims === 0) {\n                        closer_inl.unlink();\n                        tempstack = closer.next;\n                        this.removeDelimiter(closer);\n                        closer = tempstack;\n                    }\n                }\n            } else if (closercc === C_SINGLEQUOTE) {\n                closer.node._literal = \"\\u2019\";\n                if (opener_found) {\n                    opener.node._literal = \"\\u2018\";\n                }\n                closer = closer.next;\n            } else if (closercc === C_DOUBLEQUOTE) {\n                closer.node._literal = \"\\u201D\";\n                if (opener_found) {\n                    opener.node.literal = \"\\u201C\";\n                }\n                closer = closer.next;\n            }\n            if (!opener_found) {\n                // Set lower bound for future searches for openers:\n                openers_bottom[openers_bottom_index] =\n                    old_closer.previous;\n                if (!old_closer.can_open) {\n                    // We can remove a closer that can't be an opener,\n                    // once we've seen there's no matching opener:\n                    this.removeDelimiter(old_closer);\n                }\n            }\n        }\n    }\n\n    // remove all delimiters\n    while (this.delimiters !== null && this.delimiters !== stack_bottom) {\n        this.removeDelimiter(this.delimiters);\n    }\n};\n\n// Attempt to parse link title (sans quotes), returning the string\n// or null if no match.\nvar parseLinkTitle = function() {\n    var title = this.match(reLinkTitle);\n    if (title === null) {\n        return null;\n    } else {\n        // chop off quotes from title and unescape:\n        return unescapeString(title.slice(1, -1));\n    }\n};\n\n// Attempt to parse link destination, returning the string or\n// null if no match.\nvar parseLinkDestination = function() {\n    var res = this.match(reLinkDestinationBraces);\n    if (res === null) {\n        if (this.peek() === C_LESSTHAN) {\n            return null;\n        }\n        // TODO handrolled parser; res should be null or the string\n        var savepos = this.pos;\n        var openparens = 0;\n        var c;\n        while ((c = this.peek()) !== -1) {\n            if (\n                c === C_BACKSLASH &&\n                reEscapable.test(this.subject.charAt(this.pos + 1))\n            ) {\n                this.pos += 1;\n                if (this.peek() !== -1) {\n                    this.pos += 1;\n                }\n            } else if (c === C_OPEN_PAREN) {\n                this.pos += 1;\n                openparens += 1;\n            } else if (c === C_CLOSE_PAREN) {\n                if (openparens < 1) {\n                    break;\n                } else {\n                    this.pos += 1;\n                    openparens -= 1;\n                }\n            } else if (reWhitespaceChar.exec(fromCodePoint(c)) !== null) {\n                break;\n            } else {\n                this.pos += 1;\n            }\n        }\n        if (this.pos === savepos && c !== C_CLOSE_PAREN) {\n            return null;\n        }\n        if (openparens !== 0) {\n            return null;\n        }\n        res = this.subject.slice(savepos, this.pos);\n        return normalizeURI(unescapeString(res));\n    } else {\n        // chop off surrounding <..>:\n        return normalizeURI(unescapeString(res.slice(1, -1)));\n    }\n};\n\n// Attempt to parse a link label, returning number of characters parsed.\nvar parseLinkLabel = function() {\n    var m = this.match(reLinkLabel);\n    if (m === null || m.length > 1001) {\n        return 0;\n    } else {\n        return m.length;\n    }\n};\n\n// Add open bracket to delimiter stack and add a text node to block's children.\nvar parseOpenBracket = function(block) {\n    var startpos = this.pos;\n    this.pos += 1;\n\n    var node = text(\"[\");\n    block.appendChild(node);\n\n    // Add entry to stack for this opener\n    this.addBracket(node, startpos, false);\n    return true;\n};\n\n// IF next character is [, and ! delimiter to delimiter stack and\n// add a text node to block's children.  Otherwise just add a text node.\nvar parseBang = function(block) {\n    var startpos = this.pos;\n    this.pos += 1;\n    if (this.peek() === C_OPEN_BRACKET) {\n        this.pos += 1;\n\n        var node = text(\"![\");\n        block.appendChild(node);\n\n        // Add entry to stack for this opener\n        this.addBracket(node, startpos + 1, true);\n    } else {\n        block.appendChild(text(\"!\"));\n    }\n    return true;\n};\n\n// Try to match close bracket against an opening in the delimiter\n// stack.  Add either a link or image, or a plain [ character,\n// to block's children.  If there is a matching delimiter,\n// remove it from the delimiter stack.\nvar parseCloseBracket = function(block) {\n    var startpos;\n    var is_image;\n    var dest;\n    var title;\n    var matched = false;\n    var reflabel;\n    var opener;\n\n    this.pos += 1;\n    startpos = this.pos;\n\n    // get last [ or ![\n    opener = this.brackets;\n\n    if (opener === null) {\n        // no matched opener, just return a literal\n        block.appendChild(text(\"]\"));\n        return true;\n    }\n\n    if (!opener.active) {\n        // no matched opener, just return a literal\n        block.appendChild(text(\"]\"));\n        // take opener off brackets stack\n        this.removeBracket();\n        return true;\n    }\n\n    // If we got here, open is a potential opener\n    is_image = opener.image;\n\n    // Check to see if we have a link/image\n\n    var savepos = this.pos;\n\n    // Inline link?\n    if (this.peek() === C_OPEN_PAREN) {\n        this.pos++;\n        if (\n            this.spnl() &&\n            (dest = this.parseLinkDestination()) !== null &&\n            this.spnl() &&\n            // make sure there's a space before the title:\n            ((reWhitespaceChar.test(this.subject.charAt(this.pos - 1)) &&\n                (title = this.parseLinkTitle())) ||\n                true) &&\n            this.spnl() &&\n            this.peek() === C_CLOSE_PAREN\n        ) {\n            this.pos += 1;\n            matched = true;\n        } else {\n            this.pos = savepos;\n        }\n    }\n\n    if (!matched) {\n        // Next, see if there's a link label\n        var beforelabel = this.pos;\n        var n = this.parseLinkLabel();\n        if (n > 2) {\n            reflabel = this.subject.slice(beforelabel, beforelabel + n);\n        } else if (!opener.bracketAfter) {\n            // Empty or missing second label means to use the first label as the reference.\n            // The reference must not contain a bracket. If we know there's a bracket, we don't even bother checking it.\n            reflabel = this.subject.slice(opener.index, startpos);\n        }\n        if (n === 0) {\n            // If shortcut reference link, rewind before spaces we skipped.\n            this.pos = savepos;\n        }\n\n        if (reflabel) {\n            // lookup rawlabel in refmap\n            var link = this.refmap[normalizeReference(reflabel)];\n            if (link) {\n                dest = link.destination;\n                title = link.title;\n                matched = true;\n            }\n        }\n    }\n\n    if (matched) {\n        var node = new Node(is_image ? \"image\" : \"link\");\n        node._destination = dest;\n        node._title = title || \"\";\n\n        var tmp, next;\n        tmp = opener.node._next;\n        while (tmp) {\n            next = tmp._next;\n            tmp.unlink();\n            node.appendChild(tmp);\n            tmp = next;\n        }\n        block.appendChild(node);\n        this.processEmphasis(opener.previousDelimiter);\n        this.removeBracket();\n        opener.node.unlink();\n\n        // We remove this bracket and processEmphasis will remove later delimiters.\n        // Now, for a link, we also deactivate earlier link openers.\n        // (no links in links)\n        if (!is_image) {\n            opener = this.brackets;\n            while (opener !== null) {\n                if (!opener.image) {\n                    opener.active = false; // deactivate this opener\n                }\n                opener = opener.previous;\n            }\n        }\n\n        return true;\n    } else {\n        // no match\n\n        this.removeBracket(); // remove this opener from stack\n        this.pos = startpos;\n        block.appendChild(text(\"]\"));\n        return true;\n    }\n};\n\nvar addBracket = function(node, index, image) {\n    if (this.brackets !== null) {\n        this.brackets.bracketAfter = true;\n    }\n    this.brackets = {\n        node: node,\n        previous: this.brackets,\n        previousDelimiter: this.delimiters,\n        index: index,\n        image: image,\n        active: true\n    };\n};\n\nvar removeBracket = function() {\n    this.brackets = this.brackets.previous;\n};\n\n// Attempt to parse an entity.\nvar parseEntity = function(block) {\n    var m;\n    if ((m = this.match(reEntityHere))) {\n        block.appendChild(text(decodeHTMLStrict(m)));\n        return true;\n    } else {\n        return false;\n    }\n};\n\n// Parse a run of ordinary characters, or a single character with\n// a special meaning in markdown, as a plain string.\nvar parseString = function(block) {\n    var m;\n    if ((m = this.match(reMain))) {\n        if (this.options.smart) {\n            block.appendChild(\n                text(\n                    m\n                        .replace(reEllipses, \"\\u2026\")\n                        .replace(reDash, function(chars) {\n                            var enCount = 0;\n                            var emCount = 0;\n                            if (chars.length % 3 === 0) {\n                                // If divisible by 3, use all em dashes\n                                emCount = chars.length / 3;\n                            } else if (chars.length % 2 === 0) {\n                                // If divisible by 2, use all en dashes\n                                enCount = chars.length / 2;\n                            } else if (chars.length % 3 === 2) {\n                                // If 2 extra dashes, use en dash for last 2; em dashes for rest\n                                enCount = 1;\n                                emCount = (chars.length - 2) / 3;\n                            } else {\n                                // Use en dashes for last 4 hyphens; em dashes for rest\n                                enCount = 2;\n                                emCount = (chars.length - 4) / 3;\n                            }\n                            return (\n                                \"\\u2014\".repeat(emCount) +\n                                \"\\u2013\".repeat(enCount)\n                            );\n                        })\n                )\n            );\n        } else {\n            block.appendChild(text(m));\n        }\n        return true;\n    } else {\n        return false;\n    }\n};\n\n// Parse a newline.  If it was preceded by two spaces, return a hard\n// line break; otherwise a soft line break.\nvar parseNewline = function(block) {\n    this.pos += 1; // assume we're at a \\n\n    // check previous node for trailing spaces\n    var lastc = block._lastChild;\n    if (\n        lastc &&\n        lastc.type === \"text\" &&\n        lastc._literal[lastc._literal.length - 1] === \" \"\n    ) {\n        var hardbreak = lastc._literal[lastc._literal.length - 2] === \" \";\n        lastc._literal = lastc._literal.replace(reFinalSpace, \"\");\n        block.appendChild(new Node(hardbreak ? \"linebreak\" : \"softbreak\"));\n    } else {\n        block.appendChild(new Node(\"softbreak\"));\n    }\n    this.match(reInitialSpace); // gobble leading spaces in next line\n    return true;\n};\n\n// Attempt to parse a link reference, modifying refmap.\nvar parseReference = function(s, refmap) {\n    this.subject = s;\n    this.pos = 0;\n    var rawlabel;\n    var dest;\n    var title;\n    var matchChars;\n    var startpos = this.pos;\n\n    // label:\n    matchChars = this.parseLinkLabel();\n    if (matchChars === 0) {\n        return 0;\n    } else {\n        rawlabel = this.subject.slice(0, matchChars);\n    }\n\n    // colon:\n    if (this.peek() === C_COLON) {\n        this.pos++;\n    } else {\n        this.pos = startpos;\n        return 0;\n    }\n\n    //  link url\n    this.spnl();\n\n    dest = this.parseLinkDestination();\n    if (dest === null) {\n        this.pos = startpos;\n        return 0;\n    }\n\n    var beforetitle = this.pos;\n    this.spnl();\n    if (this.pos !== beforetitle) {\n        title = this.parseLinkTitle();\n    }\n    if (title === null) {\n        // rewind before spaces\n        this.pos = beforetitle;\n    }\n\n    // make sure we're at line end:\n    var atLineEnd = true;\n    if (this.match(reSpaceAtEndOfLine) === null) {\n        if (title === null) {\n            atLineEnd = false;\n        } else {\n            // the potential title we found is not at the line end,\n            // but it could still be a legal link reference if we\n            // discard the title\n            title = null;\n            // rewind before spaces\n            this.pos = beforetitle;\n            // and instead check if the link URL is at the line end\n            atLineEnd = this.match(reSpaceAtEndOfLine) !== null;\n        }\n    }\n\n    if (!atLineEnd) {\n        this.pos = startpos;\n        return 0;\n    }\n\n    var normlabel = normalizeReference(rawlabel);\n    if (normlabel === \"\") {\n        // label must contain non-whitespace characters\n        this.pos = startpos;\n        return 0;\n    }\n\n    if (!refmap[normlabel]) {\n        refmap[normlabel] = { destination: dest, title: title === null ? \"\" : title };\n    }\n    return this.pos - startpos;\n};\n\n// Parse the next inline element in subject, advancing subject position.\n// On success, add the result to block's children and return true.\n// On failure, return false.\nvar parseInline = function(block) {\n    var res = false;\n    var c = this.peek();\n    if (c === -1) {\n        return false;\n    }\n    switch (c) {\n        case C_NEWLINE:\n            res = this.parseNewline(block);\n            break;\n        case C_BACKSLASH:\n            res = this.parseBackslash(block);\n            break;\n        case C_BACKTICK:\n            res = this.parseBackticks(block);\n            break;\n        case C_ASTERISK:\n        case C_UNDERSCORE:\n            res = this.handleDelim(c, block);\n            break;\n        case C_SINGLEQUOTE:\n        case C_DOUBLEQUOTE:\n            res = this.options.smart && this.handleDelim(c, block);\n            break;\n        case C_OPEN_BRACKET:\n            res = this.parseOpenBracket(block);\n            break;\n        case C_BANG:\n            res = this.parseBang(block);\n            break;\n        case C_CLOSE_BRACKET:\n            res = this.parseCloseBracket(block);\n            break;\n        case C_LESSTHAN:\n            res = this.parseAutolink(block) || this.parseHtmlTag(block);\n            break;\n        case C_AMPERSAND:\n            res = this.parseEntity(block);\n            break;\n        default:\n            res = this.parseString(block);\n            break;\n    }\n    if (!res) {\n        this.pos += 1;\n        block.appendChild(text(fromCodePoint(c)));\n    }\n\n    return true;\n};\n\n// Parse string content in block into inline children,\n// using refmap to resolve references.\nvar parseInlines = function(block) {\n    this.subject = block._string_content.trim();\n    this.pos = 0;\n    this.delimiters = null;\n    this.brackets = null;\n    while (this.parseInline(block)) {}\n    block._string_content = null; // allow raw string to be garbage collected\n    this.processEmphasis(null);\n};\n\n// The InlineParser object.\nfunction InlineParser(options) {\n    return {\n        subject: \"\",\n        delimiters: null, // used by handleDelim method\n        brackets: null,\n        pos: 0,\n        refmap: {},\n        match: match,\n        peek: peek,\n        spnl: spnl,\n        parseBackticks: parseBackticks,\n        parseBackslash: parseBackslash,\n        parseAutolink: parseAutolink,\n        parseHtmlTag: parseHtmlTag,\n        scanDelims: scanDelims,\n        handleDelim: handleDelim,\n        parseLinkTitle: parseLinkTitle,\n        parseLinkDestination: parseLinkDestination,\n        parseLinkLabel: parseLinkLabel,\n        parseOpenBracket: parseOpenBracket,\n        parseBang: parseBang,\n        parseCloseBracket: parseCloseBracket,\n        addBracket: addBracket,\n        removeBracket: removeBracket,\n        parseEntity: parseEntity,\n        parseString: parseString,\n        parseNewline: parseNewline,\n        parseReference: parseReference,\n        parseInline: parseInline,\n        processEmphasis: processEmphasis,\n        removeDelimiter: removeDelimiter,\n        options: options || {},\n        parse: parseInlines\n    };\n}\n\nexport default InlineParser;\n","\"use strict\";\n\nimport Node from \"./node.js\";\nimport { unescapeString, OPENTAG, CLOSETAG } from \"./common.js\";\nimport InlineParser from \"./inlines.js\";\n\nvar CODE_INDENT = 4;\n\nvar C_TAB = 9;\nvar C_NEWLINE = 10;\nvar C_GREATERTHAN = 62;\nvar C_LESSTHAN = 60;\nvar C_SPACE = 32;\nvar C_OPEN_BRACKET = 91;\n\nvar reHtmlBlockOpen = [\n    /./, // dummy for 0\n    /^<(?:script|pre|textarea|style)(?:\\s|>|$)/i,\n    /^<!--/,\n    /^<[?]/,\n    /^<![A-Za-z]/,\n    /^<!\\[CDATA\\[/,\n    /^<[/]?(?:address|article|aside|base|basefont|blockquote|body|caption|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption|figure|footer|form|frame|frameset|h[123456]|head|header|hr|html|iframe|legend|li|link|main|menu|menuitem|nav|noframes|ol|optgroup|option|p|param|section|search|summary|table|tbody|td|tfoot|th|thead|title|tr|track|ul)(?:\\s|[/]?[>]|$)/i,\n    new RegExp(\"^(?:\" + OPENTAG + \"|\" + CLOSETAG + \")\\\\s*$\", \"i\")\n];\n\nvar reHtmlBlockClose = [\n    /./, // dummy for 0\n    /<\\/(?:script|pre|textarea|style)>/i,\n    /-->/,\n    /\\?>/,\n    />/,\n    /\\]\\]>/\n];\n\nvar reThematicBreak = /^(?:\\*[ \\t]*){3,}$|^(?:_[ \\t]*){3,}$|^(?:-[ \\t]*){3,}$/;\n\nvar reMaybeSpecial = /^[#`~*+_=<>0-9-]/;\n\nvar reNonSpace = /[^ \\t\\f\\v\\r\\n]/;\n\nvar reBulletListMarker = /^[*+-]/;\n\nvar reOrderedListMarker = /^(\\d{1,9})([.)])/;\n\nvar reATXHeadingMarker = /^#{1,6}(?:[ \\t]+|$)/;\n\nvar reCodeFence = /^`{3,}(?!.*`)|^~{3,}/;\n\nvar reClosingCodeFence = /^(?:`{3,}|~{3,})(?=[ \\t]*$)/;\n\nvar reSetextHeadingLine = /^(?:=+|-+)[ \\t]*$/;\n\nvar reLineEnding = /\\r\\n|\\n|\\r/;\n\n// Returns true if string contains only space characters.\nvar isBlank = function(s) {\n    return !reNonSpace.test(s);\n};\n\nvar isSpaceOrTab = function(c) {\n    return c === C_SPACE || c === C_TAB;\n};\n\nvar peek = function(ln, pos) {\n    if (pos < ln.length) {\n        return ln.charCodeAt(pos);\n    } else {\n        return -1;\n    }\n};\n\n// DOC PARSER\n\n// These are methods of a Parser object, defined below.\n\n// Returns true if block ends with a blank line.\nvar endsWithBlankLine = function(block) {\n    return block.next &&\n        block.sourcepos[1][0] !== block.next.sourcepos[0][0] - 1;\n};\n\n// Add a line to the block at the tip.  We assume the tip\n// can accept lines -- that check should be done before calling this.\nvar addLine = function() {\n    if (this.partiallyConsumedTab) {\n        this.offset += 1; // skip over tab\n        // add space characters:\n        var charsToTab = 4 - (this.column % 4);\n        this.tip._string_content += \" \".repeat(charsToTab);\n    }\n    this.tip._string_content += this.currentLine.slice(this.offset) + \"\\n\";\n};\n\n// Add block of type tag as a child of the tip.  If the tip can't\n// accept children, close and finalize it and try its parent,\n// and so on til we find a block that can accept children.\nvar addChild = function(tag, offset) {\n    while (!this.blocks[this.tip.type].canContain(tag)) {\n        this.finalize(this.tip, this.lineNumber - 1);\n    }\n\n    var column_number = offset + 1; // offset 0 = column 1\n    var newBlock = new Node(tag, [\n        [this.lineNumber, column_number],\n        [0, 0]\n    ]);\n    newBlock._string_content = \"\";\n    this.tip.appendChild(newBlock);\n    this.tip = newBlock;\n    return newBlock;\n};\n\n// Parse a list marker and return data on the marker (type,\n// start, delimiter, bullet character, padding) or null.\nvar parseListMarker = function(parser, container) {\n    var rest = parser.currentLine.slice(parser.nextNonspace);\n    var match;\n    var nextc;\n    var spacesStartCol;\n    var spacesStartOffset;\n    var data = {\n        type: null,\n        tight: true, // lists are tight by default\n        bulletChar: null,\n        start: null,\n        delimiter: null,\n        padding: null,\n        markerOffset: parser.indent\n    };\n    if (parser.indent >= 4) {\n        return null;\n    }\n    if ((match = rest.match(reBulletListMarker))) {\n        data.type = \"bullet\";\n        data.bulletChar = match[0][0];\n    } else if (\n        (match = rest.match(reOrderedListMarker)) &&\n        (container.type !== \"paragraph\" || match[1] == 1)\n    ) {\n        data.type = \"ordered\";\n        data.start = parseInt(match[1]);\n        data.delimiter = match[2];\n    } else {\n        return null;\n    }\n    // make sure we have spaces after\n    nextc = peek(parser.currentLine, parser.nextNonspace + match[0].length);\n    if (!(nextc === -1 || nextc === C_TAB || nextc === C_SPACE)) {\n        return null;\n    }\n\n    // if it interrupts paragraph, make sure first line isn't blank\n    if (\n        container.type === \"paragraph\" &&\n        !parser.currentLine\n            .slice(parser.nextNonspace + match[0].length)\n            .match(reNonSpace)\n    ) {\n        return null;\n    }\n\n    // we've got a match! advance offset and calculate padding\n    parser.advanceNextNonspace(); // to start of marker\n    parser.advanceOffset(match[0].length, true); // to end of marker\n    spacesStartCol = parser.column;\n    spacesStartOffset = parser.offset;\n    do {\n        parser.advanceOffset(1, true);\n        nextc = peek(parser.currentLine, parser.offset);\n    } while (parser.column - spacesStartCol < 5 && isSpaceOrTab(nextc));\n    var blank_item = peek(parser.currentLine, parser.offset) === -1;\n    var spaces_after_marker = parser.column - spacesStartCol;\n    if (spaces_after_marker >= 5 || spaces_after_marker < 1 || blank_item) {\n        data.padding = match[0].length + 1;\n        parser.column = spacesStartCol;\n        parser.offset = spacesStartOffset;\n        if (isSpaceOrTab(peek(parser.currentLine, parser.offset))) {\n            parser.advanceOffset(1, true);\n        }\n    } else {\n        data.padding = match[0].length + spaces_after_marker;\n    }\n    return data;\n};\n\n// Returns true if the two list items are of the same type,\n// with the same delimiter and bullet character.  This is used\n// in agglomerating list items into lists.\nvar listsMatch = function(list_data, item_data) {\n    return (\n        list_data.type === item_data.type &&\n        list_data.delimiter === item_data.delimiter &&\n        list_data.bulletChar === item_data.bulletChar\n    );\n};\n\n// Finalize and close any unmatched blocks.\nvar closeUnmatchedBlocks = function() {\n    if (!this.allClosed) {\n        // finalize any blocks not matched\n        while (this.oldtip !== this.lastMatchedContainer) {\n            var parent = this.oldtip._parent;\n            this.finalize(this.oldtip, this.lineNumber - 1);\n            this.oldtip = parent;\n        }\n        this.allClosed = true;\n    }\n};\n\n// Remove link reference definitions from given tree.\nvar removeLinkReferenceDefinitions = function(parser, tree) {\n    var event, node;\n    var walker = tree.walker();\n    var emptyNodes = [];\n\n    while ((event = walker.next())) {\n        node = event.node;\n        if (event.entering && node.type === \"paragraph\") {\n            var pos;\n            var hasReferenceDefs = false;\n\n            // Try parsing the beginning as link reference definitions;\n            // Note that link reference definitions must be the beginning of a\n            // paragraph node since link reference definitions cannot interrupt\n            // paragraphs.\n            while (\n                peek(node._string_content, 0) === C_OPEN_BRACKET &&\n                    (pos = parser.inlineParser.parseReference(\n                        node._string_content,\n                        parser.refmap\n                    ))\n            ) {\n                const removedText = node._string_content.slice(0, pos);\n\n                node._string_content = node._string_content.slice(pos);\n                hasReferenceDefs = true;\n\n                const lines = removedText.split(\"\\n\");\n\n                // -1 for final newline.\n                node.sourcepos[0][0] += lines.length - 1;\n            }\n            if (hasReferenceDefs && isBlank(node._string_content)) {\n                emptyNodes.push(node);\n            }\n        }\n    }\n\n    for (node of emptyNodes) {\n        node.unlink();\n    }\n};\n\n// 'finalize' is run when the block is closed.\n// 'continue' is run to check whether the block is continuing\n// at a certain line and offset (e.g. whether a block quote\n// contains a `>`.  It returns 0 for matched, 1 for not matched,\n// and 2 for \"we've dealt with this line completely, go to next.\"\nvar blocks = {\n    document: {\n        continue: function() {\n            return 0;\n        },\n        finalize: function(parser, block) {\n            removeLinkReferenceDefinitions(parser, block);\n            return;\n        },\n        canContain: function(t) {\n            return t !== \"item\";\n        },\n        acceptsLines: false\n    },\n    list: {\n        continue: function() {\n            return 0;\n        },\n        finalize: function(parser, block) {\n            var item = block._firstChild;\n            while (item) {\n                // check for non-final list item ending with blank line:\n                if (item._next && endsWithBlankLine(item)) {\n                    block._listData.tight = false;\n                    break;\n                }\n                // recurse into children of list item, to see if there are\n                // spaces between any of them:\n                var subitem = item._firstChild;\n                while (subitem) {\n                    if (\n                        subitem._next &&\n                        endsWithBlankLine(subitem)\n                    ) {\n                        block._listData.tight = false;\n                        break;\n                    }\n                    subitem = subitem._next;\n                }\n                item = item._next;\n            }\n            block.sourcepos[1] = block._lastChild.sourcepos[1];\n        },\n        canContain: function(t) {\n            return t === \"item\";\n        },\n        acceptsLines: false\n    },\n    block_quote: {\n        continue: function(parser) {\n            var ln = parser.currentLine;\n            if (\n                !parser.indented &&\n                peek(ln, parser.nextNonspace) === C_GREATERTHAN\n            ) {\n                parser.advanceNextNonspace();\n                parser.advanceOffset(1, false);\n                if (isSpaceOrTab(peek(ln, parser.offset))) {\n                    parser.advanceOffset(1, true);\n                }\n            } else {\n                return 1;\n            }\n            return 0;\n        },\n        finalize: function() {\n            return;\n        },\n        canContain: function(t) {\n            return t !== \"item\";\n        },\n        acceptsLines: false\n    },\n    item: {\n        continue: function(parser, container) {\n            if (parser.blank) {\n                if (container._firstChild == null) {\n                    // Blank line after empty list item\n                    return 1;\n                } else {\n                    parser.advanceNextNonspace();\n                }\n            } else if (\n                parser.indent >=\n                container._listData.markerOffset + container._listData.padding\n            ) {\n                parser.advanceOffset(\n                    container._listData.markerOffset +\n                        container._listData.padding,\n                    true\n                );\n            } else {\n                return 1;\n            }\n            return 0;\n        },\n        finalize: function(parser, block) {\n            if (block._lastChild) {\n                block.sourcepos[1] = block._lastChild.sourcepos[1];\n            } else {\n                // Empty list item\n                block.sourcepos[1][0] = block.sourcepos[0][0];\n                block.sourcepos[1][1] =\n                    block._listData.markerOffset + block._listData.padding;\n            }\n\n            return;\n        },\n        canContain: function(t) {\n            return t !== \"item\";\n        },\n        acceptsLines: false\n    },\n    heading: {\n        continue: function() {\n            // a heading can never container > 1 line, so fail to match:\n            return 1;\n        },\n        finalize: function() {\n            return;\n        },\n        canContain: function() {\n            return false;\n        },\n        acceptsLines: false\n    },\n    thematic_break: {\n        continue: function() {\n            // a thematic break can never container > 1 line, so fail to match:\n            return 1;\n        },\n        finalize: function() {\n            return;\n        },\n        canContain: function() {\n            return false;\n        },\n        acceptsLines: false\n    },\n    code_block: {\n        continue: function(parser, container) {\n            var ln = parser.currentLine;\n            var indent = parser.indent;\n            if (container._isFenced) {\n                // fenced\n                var match =\n                    indent <= 3 &&\n                    ln.charAt(parser.nextNonspace) === container._fenceChar &&\n                    ln.slice(parser.nextNonspace).match(reClosingCodeFence);\n                if (match && match[0].length >= container._fenceLength) {\n                    // closing fence - we're at end of line, so we can return\n                    parser.lastLineLength =\n                        parser.offset + indent + match[0].length;\n                    parser.finalize(container, parser.lineNumber);\n                    return 2;\n                } else {\n                    // skip optional spaces of fence offset\n                    var i = container._fenceOffset;\n                    while (i > 0 && isSpaceOrTab(peek(ln, parser.offset))) {\n                        parser.advanceOffset(1, true);\n                        i--;\n                    }\n                }\n            } else {\n                // indented\n                if (indent >= CODE_INDENT) {\n                    parser.advanceOffset(CODE_INDENT, true);\n                } else if (parser.blank) {\n                    parser.advanceNextNonspace();\n                } else {\n                    return 1;\n                }\n            }\n            return 0;\n        },\n        finalize: function(parser, block) {\n            if (block._isFenced) {\n                // fenced\n                // first line becomes info string\n                var content = block._string_content;\n                var newlinePos = content.indexOf(\"\\n\");\n                var firstLine = content.slice(0, newlinePos);\n                var rest = content.slice(newlinePos + 1);\n                block.info = unescapeString(firstLine.trim());\n                block._literal = rest;\n            } else {\n                // indented\n                var lines = block._string_content.split(\"\\n\");\n                // Note that indented code block cannot be empty, so\n                // lines.length cannot be zero.\n                while (/^[ \\t]*$/.test(lines[lines.length - 1])) {\n                    lines.pop();\n                }\n                block._literal = lines.join(\"\\n\") + \"\\n\";\n                block.sourcepos[1][0] =\n                    block.sourcepos[0][0] + lines.length - 1;\n                block.sourcepos[1][1] =\n                    block.sourcepos[0][1] + lines[lines.length - 1].length - 1;\n            }\n            block._string_content = null; // allow GC\n        },\n        canContain: function() {\n            return false;\n        },\n        acceptsLines: true\n    },\n    html_block: {\n        continue: function(parser, container) {\n            return parser.blank &&\n                (container._htmlBlockType === 6 ||\n                    container._htmlBlockType === 7)\n                ? 1\n                : 0;\n        },\n        finalize: function(parser, block) {\n            block._literal = block._string_content.replace(/\\n$/, '');\n            block._string_content = null; // allow GC\n        },\n        canContain: function() {\n            return false;\n        },\n        acceptsLines: true\n    },\n    paragraph: {\n        continue: function(parser) {\n            return parser.blank ? 1 : 0;\n        },\n        finalize: function() {\n            return;\n        },\n        canContain: function() {\n            return false;\n        },\n        acceptsLines: true\n    }\n};\n\n// block start functions.  Return values:\n// 0 = no match\n// 1 = matched container, keep going\n// 2 = matched leaf, no more block starts\nvar blockStarts = [\n    // block quote\n    function(parser) {\n        if (\n            !parser.indented &&\n            peek(parser.currentLine, parser.nextNonspace) === C_GREATERTHAN\n        ) {\n            parser.advanceNextNonspace();\n            parser.advanceOffset(1, false);\n            // optional following space\n            if (isSpaceOrTab(peek(parser.currentLine, parser.offset))) {\n                parser.advanceOffset(1, true);\n            }\n            parser.closeUnmatchedBlocks();\n            parser.addChild(\"block_quote\", parser.nextNonspace);\n            return 1;\n        } else {\n            return 0;\n        }\n    },\n\n    // ATX heading\n    function(parser) {\n        var match;\n        if (\n            !parser.indented &&\n            (match = parser.currentLine\n                .slice(parser.nextNonspace)\n                .match(reATXHeadingMarker))\n        ) {\n            parser.advanceNextNonspace();\n            parser.advanceOffset(match[0].length, false);\n            parser.closeUnmatchedBlocks();\n            var container = parser.addChild(\"heading\", parser.nextNonspace);\n            container.level = match[0].trim().length; // number of #s\n            // remove trailing ###s:\n            container._string_content = parser.currentLine\n                .slice(parser.offset)\n                .replace(/^[ \\t]*#+[ \\t]*$/, \"\")\n                .replace(/[ \\t]+#+[ \\t]*$/, \"\");\n            parser.advanceOffset(parser.currentLine.length - parser.offset);\n            return 2;\n        } else {\n            return 0;\n        }\n    },\n\n    // Fenced code block\n    function(parser) {\n        var match;\n        if (\n            !parser.indented &&\n            (match = parser.currentLine\n                .slice(parser.nextNonspace)\n                .match(reCodeFence))\n        ) {\n            var fenceLength = match[0].length;\n            parser.closeUnmatchedBlocks();\n            var container = parser.addChild(\"code_block\", parser.nextNonspace);\n            container._isFenced = true;\n            container._fenceLength = fenceLength;\n            container._fenceChar = match[0][0];\n            container._fenceOffset = parser.indent;\n            parser.advanceNextNonspace();\n            parser.advanceOffset(fenceLength, false);\n            return 2;\n        } else {\n            return 0;\n        }\n    },\n\n    // HTML block\n    function(parser, container) {\n        if (\n            !parser.indented &&\n            peek(parser.currentLine, parser.nextNonspace) === C_LESSTHAN\n        ) {\n            var s = parser.currentLine.slice(parser.nextNonspace);\n            var blockType;\n\n            for (blockType = 1; blockType <= 7; blockType++) {\n                if (\n                    reHtmlBlockOpen[blockType].test(s) &&\n                    (blockType < 7 || (container.type !== \"paragraph\" &&\n                     !(!parser.allClosed && !parser.blank &&\n                       parser.tip.type === \"paragraph\") // maybe lazy\n                    ))\n                ) {\n                    parser.closeUnmatchedBlocks();\n                    // We don't adjust parser.offset;\n                    // spaces are part of the HTML block:\n                    var b = parser.addChild(\"html_block\", parser.offset);\n                    b._htmlBlockType = blockType;\n                    return 2;\n                }\n            }\n        }\n\n        return 0;\n    },\n\n    // Setext heading\n    function(parser, container) {\n        var match;\n        if (\n            !parser.indented &&\n            container.type === \"paragraph\" &&\n            (match = parser.currentLine\n                .slice(parser.nextNonspace)\n                .match(reSetextHeadingLine))\n        ) {\n            parser.closeUnmatchedBlocks();\n            // resolve reference link definitiosn\n            var pos;\n            while (\n                peek(container._string_content, 0) === C_OPEN_BRACKET &&\n                (pos = parser.inlineParser.parseReference(\n                    container._string_content,\n                    parser.refmap\n                ))\n            ) {\n                container._string_content = container._string_content.slice(\n                    pos\n                );\n            }\n            if (container._string_content.length > 0) {\n                var heading = new Node(\"heading\", container.sourcepos);\n                heading.level = match[0][0] === \"=\" ? 1 : 2;\n                heading._string_content = container._string_content;\n                container.insertAfter(heading);\n                container.unlink();\n                parser.tip = heading;\n                parser.advanceOffset(\n                    parser.currentLine.length - parser.offset,\n                    false\n                );\n                return 2;\n            } else {\n                return 0;\n            }\n        } else {\n            return 0;\n        }\n    },\n\n    // thematic break\n    function(parser) {\n        if (\n            !parser.indented &&\n            reThematicBreak.test(parser.currentLine.slice(parser.nextNonspace))\n        ) {\n            parser.closeUnmatchedBlocks();\n            parser.addChild(\"thematic_break\", parser.nextNonspace);\n            parser.advanceOffset(\n                parser.currentLine.length - parser.offset,\n                false\n            );\n            return 2;\n        } else {\n            return 0;\n        }\n    },\n\n    // list item\n    function(parser, container) {\n        var data;\n\n        if (\n            (!parser.indented || container.type === \"list\") &&\n            (data = parseListMarker(parser, container))\n        ) {\n            parser.closeUnmatchedBlocks();\n\n            // add the list if needed\n            if (\n                parser.tip.type !== \"list\" ||\n                !listsMatch(container._listData, data)\n            ) {\n                container = parser.addChild(\"list\", parser.nextNonspace);\n                container._listData = data;\n            }\n\n            // add the list item\n            container = parser.addChild(\"item\", parser.nextNonspace);\n            container._listData = data;\n            return 1;\n        } else {\n            return 0;\n        }\n    },\n\n    // indented code block\n    function(parser) {\n        if (\n            parser.indented &&\n            parser.tip.type !== \"paragraph\" &&\n            !parser.blank\n        ) {\n            // indented code\n            parser.advanceOffset(CODE_INDENT, true);\n            parser.closeUnmatchedBlocks();\n            parser.addChild(\"code_block\", parser.offset);\n            return 2;\n        } else {\n            return 0;\n        }\n    }\n];\n\nvar advanceOffset = function(count, columns) {\n    var currentLine = this.currentLine;\n    var charsToTab, charsToAdvance;\n    var c;\n    while (count > 0 && (c = currentLine[this.offset])) {\n        if (c === \"\\t\") {\n            charsToTab = 4 - (this.column % 4);\n            if (columns) {\n                this.partiallyConsumedTab = charsToTab > count;\n                charsToAdvance = charsToTab > count ? count : charsToTab;\n                this.column += charsToAdvance;\n                this.offset += this.partiallyConsumedTab ? 0 : 1;\n                count -= charsToAdvance;\n            } else {\n                this.partiallyConsumedTab = false;\n                this.column += charsToTab;\n                this.offset += 1;\n                count -= 1;\n            }\n        } else {\n            this.partiallyConsumedTab = false;\n            this.offset += 1;\n            this.column += 1; // assume ascii; block starts are ascii\n            count -= 1;\n        }\n    }\n};\n\nvar advanceNextNonspace = function() {\n    this.offset = this.nextNonspace;\n    this.column = this.nextNonspaceColumn;\n    this.partiallyConsumedTab = false;\n};\n\nvar findNextNonspace = function() {\n    var currentLine = this.currentLine;\n    var i = this.offset;\n    var cols = this.column;\n    var c;\n\n    while ((c = currentLine.charAt(i)) !== \"\") {\n        if (c === \" \") {\n            i++;\n            cols++;\n        } else if (c === \"\\t\") {\n            i++;\n            cols += 4 - (cols % 4);\n        } else {\n            break;\n        }\n    }\n    this.blank = c === \"\\n\" || c === \"\\r\" || c === \"\";\n    this.nextNonspace = i;\n    this.nextNonspaceColumn = cols;\n    this.indent = this.nextNonspaceColumn - this.column;\n    this.indented = this.indent >= CODE_INDENT;\n};\n\n// Analyze a line of text and update the document appropriately.\n// We parse markdown text by calling this on each line of input,\n// then finalizing the document.\nvar incorporateLine = function(ln) {\n    var all_matched = true;\n    var t;\n\n    var container = this.doc;\n    this.oldtip = this.tip;\n    this.offset = 0;\n    this.column = 0;\n    this.blank = false;\n    this.partiallyConsumedTab = false;\n    this.lineNumber += 1;\n\n    // replace NUL characters for security\n    if (ln.indexOf(\"\\u0000\") !== -1) {\n        ln = ln.replace(/\\0/g, \"\\uFFFD\");\n    }\n\n    this.currentLine = ln;\n\n    // For each containing block, try to parse the associated line start.\n    // Bail out on failure: container will point to the last matching block.\n    // Set all_matched to false if not all containers match.\n    var lastChild;\n    while ((lastChild = container._lastChild) && lastChild._open) {\n        container = lastChild;\n\n        this.findNextNonspace();\n\n        switch (this.blocks[container.type].continue(this, container)) {\n            case 0: // we've matched, keep going\n                break;\n            case 1: // we've failed to match a block\n                all_matched = false;\n                break;\n            case 2: // we've hit end of line for fenced code close and can return\n                return;\n            default:\n                throw \"continue returned illegal value, must be 0, 1, or 2\";\n        }\n        if (!all_matched) {\n            container = container._parent; // back up to last matching block\n            break;\n        }\n    }\n\n    this.allClosed = container === this.oldtip;\n    this.lastMatchedContainer = container;\n\n    var matchedLeaf =\n        container.type !== \"paragraph\" && blocks[container.type].acceptsLines;\n    var starts = this.blockStarts;\n    var startsLen = starts.length;\n    // Unless last matched container is a code block, try new container starts,\n    // adding children to the last matched container:\n    while (!matchedLeaf) {\n        this.findNextNonspace();\n\n        // this is a little performance optimization:\n        if (\n            !this.indented &&\n            !reMaybeSpecial.test(ln.slice(this.nextNonspace))\n        ) {\n            this.advanceNextNonspace();\n            break;\n        }\n\n        var i = 0;\n        while (i < startsLen) {\n            var res = starts[i](this, container);\n            if (res === 1) {\n                container = this.tip;\n                break;\n            } else if (res === 2) {\n                container = this.tip;\n                matchedLeaf = true;\n                break;\n            } else {\n                i++;\n            }\n        }\n\n        if (i === startsLen) {\n            // nothing matched\n            this.advanceNextNonspace();\n            break;\n        }\n    }\n\n    // What remains at the offset is a text line.  Add the text to the\n    // appropriate container.\n\n    // First check for a lazy paragraph continuation:\n    if (!this.allClosed && !this.blank && this.tip.type === \"paragraph\") {\n        // lazy paragraph continuation\n        this.addLine();\n    } else {\n        // not a lazy continuation\n\n        // finalize any blocks not matched\n        this.closeUnmatchedBlocks();\n\n        t = container.type;\n\n        if (this.blocks[t].acceptsLines) {\n            this.addLine();\n            // if HtmlBlock, check for end condition\n            if (\n                t === \"html_block\" &&\n                container._htmlBlockType >= 1 &&\n                container._htmlBlockType <= 5 &&\n                reHtmlBlockClose[container._htmlBlockType].test(\n                    this.currentLine.slice(this.offset)\n                )\n            ) {\n                this.lastLineLength = ln.length;\n                this.finalize(container, this.lineNumber);\n            }\n        } else if (this.offset < ln.length && !this.blank) {\n            // create paragraph container for line\n            container = this.addChild(\"paragraph\", this.offset);\n            this.advanceNextNonspace();\n            this.addLine();\n        }\n    }\n    this.lastLineLength = ln.length;\n};\n\n// Finalize a block.  Close it and do any necessary postprocessing,\n// e.g. creating string_content from strings, setting the 'tight'\n// or 'loose' status of a list, and parsing the beginnings\n// of paragraphs for reference definitions.  Reset the tip to the\n// parent of the closed block.\nvar finalize = function(block, lineNumber) {\n    var above = block._parent;\n    block._open = false;\n    block.sourcepos[1] = [lineNumber, this.lastLineLength];\n\n    this.blocks[block.type].finalize(this, block);\n\n    this.tip = above;\n};\n\n// Walk through a block & children recursively, parsing string content\n// into inline content where appropriate.\nvar processInlines = function(block) {\n    var node, event, t;\n    var walker = block.walker();\n    this.inlineParser.refmap = this.refmap;\n    this.inlineParser.options = this.options;\n    while ((event = walker.next())) {\n        node = event.node;\n        t = node.type;\n        if (!event.entering && (t === \"paragraph\" || t === \"heading\")) {\n            this.inlineParser.parse(node);\n        }\n    }\n};\n\nvar Document = function() {\n    var doc = new Node(\"document\", [\n        [1, 1],\n        [0, 0]\n    ]);\n    return doc;\n};\n\n// The main parsing function.  Returns a parsed document AST.\nvar parse = function(input) {\n    this.doc = new Document();\n    this.tip = this.doc;\n    this.refmap = {};\n    this.lineNumber = 0;\n    this.lastLineLength = 0;\n    this.offset = 0;\n    this.column = 0;\n    this.lastMatchedContainer = this.doc;\n    this.currentLine = \"\";\n    if (this.options.time) {\n        console.time(\"preparing input\");\n    }\n    var lines = input.split(reLineEnding);\n    var len = lines.length;\n    if (input.charCodeAt(input.length - 1) === C_NEWLINE) {\n        // ignore last blank line created by final newline\n        len -= 1;\n    }\n    if (this.options.time) {\n        console.timeEnd(\"preparing input\");\n    }\n    if (this.options.time) {\n        console.time(\"block parsing\");\n    }\n    for (var i = 0; i < len; i++) {\n        this.incorporateLine(lines[i]);\n    }\n    while (this.tip) {\n        this.finalize(this.tip, len);\n    }\n    if (this.options.time) {\n        console.timeEnd(\"block parsing\");\n    }\n    if (this.options.time) {\n        console.time(\"inline parsing\");\n    }\n    this.processInlines(this.doc);\n    if (this.options.time) {\n        console.timeEnd(\"inline parsing\");\n    }\n    return this.doc;\n};\n\n// The Parser object.\nfunction Parser(options) {\n    return {\n        doc: new Document(),\n        blocks: blocks,\n        blockStarts: blockStarts,\n        tip: this.doc,\n        oldtip: this.doc,\n        currentLine: \"\",\n        lineNumber: 0,\n        offset: 0,\n        column: 0,\n        nextNonspace: 0,\n        nextNonspaceColumn: 0,\n        indent: 0,\n        indented: false,\n        blank: false,\n        partiallyConsumedTab: false,\n        allClosed: true,\n        lastMatchedContainer: this.doc,\n        refmap: {},\n        lastLineLength: 0,\n        inlineParser: new InlineParser(options),\n        findNextNonspace: findNextNonspace,\n        advanceOffset: advanceOffset,\n        advanceNextNonspace: advanceNextNonspace,\n        addLine: addLine,\n        addChild: addChild,\n        incorporateLine: incorporateLine,\n        finalize: finalize,\n        processInlines: processInlines,\n        closeUnmatchedBlocks: closeUnmatchedBlocks,\n        parse: parse,\n        options: options || {}\n    };\n}\n\nexport default Parser;\n","\"use strict\";\n\nfunction Renderer() {}\n\n/**\n *  Walks the AST and calls member methods for each Node type.\n *\n *  @param ast {Node} The root of the abstract syntax tree.\n */\nfunction render(ast) {\n    var walker = ast.walker(),\n        event,\n        type;\n\n    this.buffer = \"\";\n    this.lastOut = \"\\n\";\n\n    while ((event = walker.next())) {\n        type = event.node.type;\n        if (this[type]) {\n            this[type](event.node, event.entering);\n        }\n    }\n    return this.buffer;\n}\n\n/**\n *  Concatenate a literal string to the buffer.\n *\n *  @param str {String} The string to concatenate.\n */\nfunction lit(str) {\n    this.buffer += str;\n    this.lastOut = str;\n}\n\n/**\n *  Output a newline to the buffer.\n */\nfunction cr() {\n    if (this.lastOut !== \"\\n\") {\n        this.lit(\"\\n\");\n    }\n}\n\n/**\n *  Concatenate a string to the buffer possibly escaping the content.\n *\n *  Concrete renderer implementations should override this method.\n *\n *  @param str {String} The string to concatenate.\n */\nfunction out(str) {\n    this.lit(str);\n}\n\n/**\n *  Escape a string for the target renderer.\n *\n *  Abstract function that should be implemented by concrete\n *  renderer implementations.\n *\n *  @param str {String} The string to escape.\n */\nfunction esc(str) {\n    return str;\n}\n\nRenderer.prototype.render = render;\nRenderer.prototype.out = out;\nRenderer.prototype.lit = lit;\nRenderer.prototype.cr = cr;\nRenderer.prototype.esc = esc;\n\nexport default Renderer;\n","\"use strict\";\n\nimport { escapeXml } from \"../common.js\";\nimport Renderer from \"./renderer.js\";\n\nvar reUnsafeProtocol = /^javascript:|vbscript:|file:|data:/i;\nvar reSafeDataProtocol = /^data:image\\/(?:png|gif|jpeg|webp)/i;\n\nvar potentiallyUnsafe = function(url) {\n    return reUnsafeProtocol.test(url) && !reSafeDataProtocol.test(url);\n};\n\n// Helper function to produce an HTML tag.\nfunction tag(name, attrs, selfclosing) {\n    if (this.disableTags > 0) {\n        return;\n    }\n    this.buffer += \"<\" + name;\n    if (attrs && attrs.length > 0) {\n        var i = 0;\n        var attrib;\n        while ((attrib = attrs[i]) !== undefined) {\n            this.buffer += \" \" + attrib[0] + '=\"' + attrib[1] + '\"';\n            i++;\n        }\n    }\n    if (selfclosing) {\n        this.buffer += \" /\";\n    }\n    this.buffer += \">\";\n    this.lastOut = \">\";\n}\n\nfunction HtmlRenderer(options) {\n    options = options || {};\n    // by default, soft breaks are rendered as newlines in HTML\n    options.softbreak = options.softbreak || \"\\n\";\n    // set to \"<br />\" to make them hard breaks\n    // set to \" \" if you want to ignore line wrapping in source\n    this.esc = options.esc || escapeXml;\n    // escape html with a custom function\n    // else use escapeXml\n\n    this.disableTags = 0;\n    this.lastOut = \"\\n\";\n    this.options = options;\n}\n\n/* Node methods */\n\nfunction text(node) {\n    this.out(node.literal);\n}\n\nfunction softbreak() {\n    this.lit(this.options.softbreak);\n}\n\nfunction linebreak() {\n    this.tag(\"br\", [], true);\n    this.cr();\n}\n\nfunction link(node, entering) {\n    var attrs = this.attrs(node);\n    if (entering) {\n        if (!(this.options.safe && potentiallyUnsafe(node.destination))) {\n            attrs.push([\"href\", this.esc(node.destination)]);\n        }\n        if (node.title) {\n            attrs.push([\"title\", this.esc(node.title)]);\n        }\n        this.tag(\"a\", attrs);\n    } else {\n        this.tag(\"/a\");\n    }\n}\n\nfunction image(node, entering) {\n    if (entering) {\n        if (this.disableTags === 0) {\n            if (this.options.safe && potentiallyUnsafe(node.destination)) {\n                this.lit('<img src=\"\" alt=\"');\n            } else {\n                this.lit('<img src=\"' + this.esc(node.destination) + '\" alt=\"');\n            }\n        }\n        this.disableTags += 1;\n    } else {\n        this.disableTags -= 1;\n        if (this.disableTags === 0) {\n            if (node.title) {\n                this.lit('\" title=\"' + this.esc(node.title));\n            }\n            this.lit('\" />');\n        }\n    }\n}\n\nfunction emph(node, entering) {\n    this.tag(entering ? \"em\" : \"/em\");\n}\n\nfunction strong(node, entering) {\n    this.tag(entering ? \"strong\" : \"/strong\");\n}\n\nfunction paragraph(node, entering) {\n    var grandparent = node.parent.parent,\n        attrs = this.attrs(node);\n    if (grandparent !== null && grandparent.type === \"list\") {\n        if (grandparent.listTight) {\n            return;\n        }\n    }\n    if (entering) {\n        this.cr();\n        this.tag(\"p\", attrs);\n    } else {\n        this.tag(\"/p\");\n        this.cr();\n    }\n}\n\nfunction heading(node, entering) {\n    var tagname = \"h\" + node.level,\n        attrs = this.attrs(node);\n    if (entering) {\n        this.cr();\n        this.tag(tagname, attrs);\n    } else {\n        this.tag(\"/\" + tagname);\n        this.cr();\n    }\n}\n\nfunction code(node) {\n    this.tag(\"code\");\n    this.out(node.literal);\n    this.tag(\"/code\");\n}\n\nfunction code_block(node) {\n    var info_words = node.info ? node.info.split(/\\s+/) : [],\n        attrs = this.attrs(node);\n    if (info_words.length > 0 && info_words[0].length > 0) {\n        var cls = this.esc(info_words[0]);\n        if (!/^language-/.exec(cls)) {\n          cls = \"language-\" + cls;\n        }\n        attrs.push([\"class\", cls]);\n    }\n    this.cr();\n    this.tag(\"pre\");\n    this.tag(\"code\", attrs);\n    this.out(node.literal);\n    this.tag(\"/code\");\n    this.tag(\"/pre\");\n    this.cr();\n}\n\nfunction thematic_break(node) {\n    var attrs = this.attrs(node);\n    this.cr();\n    this.tag(\"hr\", attrs, true);\n    this.cr();\n}\n\nfunction block_quote(node, entering) {\n    var attrs = this.attrs(node);\n    if (entering) {\n        this.cr();\n        this.tag(\"blockquote\", attrs);\n        this.cr();\n    } else {\n        this.cr();\n        this.tag(\"/blockquote\");\n        this.cr();\n    }\n}\n\nfunction list(node, entering) {\n    var tagname = node.listType === \"bullet\" ? \"ul\" : \"ol\",\n        attrs = this.attrs(node);\n\n    if (entering) {\n        var start = node.listStart;\n        if (start !== null && start !== 1) {\n            attrs.push([\"start\", start.toString()]);\n        }\n        this.cr();\n        this.tag(tagname, attrs);\n        this.cr();\n    } else {\n        this.cr();\n        this.tag(\"/\" + tagname);\n        this.cr();\n    }\n}\n\nfunction item(node, entering) {\n    var attrs = this.attrs(node);\n    if (entering) {\n        this.tag(\"li\", attrs);\n    } else {\n        this.tag(\"/li\");\n        this.cr();\n    }\n}\n\nfunction html_inline(node) {\n    if (this.options.safe) {\n        this.lit(\"<!-- raw HTML omitted -->\");\n    } else {\n        this.lit(node.literal);\n    }\n}\n\nfunction html_block(node) {\n    this.cr();\n    if (this.options.safe) {\n        this.lit(\"<!-- raw HTML omitted -->\");\n    } else {\n        this.lit(node.literal);\n    }\n    this.cr();\n}\n\nfunction custom_inline(node, entering) {\n    if (entering && node.onEnter) {\n        this.lit(node.onEnter);\n    } else if (!entering && node.onExit) {\n        this.lit(node.onExit);\n    }\n}\n\nfunction custom_block(node, entering) {\n    this.cr();\n    if (entering && node.onEnter) {\n        this.lit(node.onEnter);\n    } else if (!entering && node.onExit) {\n        this.lit(node.onExit);\n    }\n    this.cr();\n}\n\n/* Helper methods */\n\nfunction out(s) {\n    this.lit(this.esc(s));\n}\n\nfunction attrs(node) {\n    var att = [];\n    if (this.options.sourcepos) {\n        var pos = node.sourcepos;\n        if (pos) {\n            att.push([\n                \"data-sourcepos\",\n                String(pos[0][0]) +\n                    \":\" +\n                    String(pos[0][1]) +\n                    \"-\" +\n                    String(pos[1][0]) +\n                    \":\" +\n                    String(pos[1][1])\n            ]);\n        }\n    }\n    return att;\n}\n\n// quick browser-compatible inheritance\nHtmlRenderer.prototype = Object.create(Renderer.prototype);\n\nHtmlRenderer.prototype.text = text;\nHtmlRenderer.prototype.html_inline = html_inline;\nHtmlRenderer.prototype.html_block = html_block;\nHtmlRenderer.prototype.softbreak = softbreak;\nHtmlRenderer.prototype.linebreak = linebreak;\nHtmlRenderer.prototype.link = link;\nHtmlRenderer.prototype.image = image;\nHtmlRenderer.prototype.emph = emph;\nHtmlRenderer.prototype.strong = strong;\nHtmlRenderer.prototype.paragraph = paragraph;\nHtmlRenderer.prototype.heading = heading;\nHtmlRenderer.prototype.code = code;\nHtmlRenderer.prototype.code_block = code_block;\nHtmlRenderer.prototype.thematic_break = thematic_break;\nHtmlRenderer.prototype.block_quote = block_quote;\nHtmlRenderer.prototype.list = list;\nHtmlRenderer.prototype.item = item;\nHtmlRenderer.prototype.custom_inline = custom_inline;\nHtmlRenderer.prototype.custom_block = custom_block;\n\nHtmlRenderer.prototype.esc = escapeXml;\n\nHtmlRenderer.prototype.out = out;\nHtmlRenderer.prototype.tag = tag;\nHtmlRenderer.prototype.attrs = attrs;\n\nexport default HtmlRenderer;\n","\"use strict\";\n\nimport Renderer from \"./renderer.js\";\nimport { escapeXml } from \"../common.js\";\n\nvar reXMLTag = /\\<[^>]*\\>/;\n\nfunction toTagName(s) {\n    return s.replace(/([a-z])([A-Z])/g, \"$1_$2\").toLowerCase();\n}\n\nfunction XmlRenderer(options) {\n    options = options || {};\n\n    this.disableTags = 0;\n    this.lastOut = \"\\n\";\n\n    this.indentLevel = 0;\n    this.indent = \"  \";\n    \n    this.esc = options.esc || escapeXml;\n    // escape html with a custom function\n    // else use escapeXml\n\n    this.options = options;\n}\n\nfunction render(ast) {\n    this.buffer = \"\";\n\n    var attrs;\n    var tagname;\n    var walker = ast.walker();\n    var event, node, entering;\n    var container;\n    var selfClosing;\n    var nodetype;\n\n    var options = this.options;\n\n    if (options.time) {\n        console.time(\"rendering\");\n    }\n\n    this.buffer += '<?xml version=\"1.0\" encoding=\"UTF-8\"?>\\n';\n    this.buffer += '<!DOCTYPE document SYSTEM \"CommonMark.dtd\">\\n';\n\n    while ((event = walker.next())) {\n        entering = event.entering;\n        node = event.node;\n        nodetype = node.type;\n\n        container = node.isContainer;\n\n        selfClosing =\n            nodetype === \"thematic_break\" ||\n            nodetype === \"linebreak\" ||\n            nodetype === \"softbreak\";\n\n        tagname = toTagName(nodetype);\n\n        if (entering) {\n            attrs = [];\n\n            switch (nodetype) {\n                case \"document\":\n                    attrs.push([\"xmlns\", \"http://commonmark.org/xml/1.0\"]);\n                    break;\n                case \"list\":\n                    if (node.listType !== null) {\n                        attrs.push([\"type\", node.listType.toLowerCase()]);\n                    }\n                    if (node.listStart !== null) {\n                        attrs.push([\"start\", String(node.listStart)]);\n                    }\n                    if (node.listTight !== null) {\n                        attrs.push([\n                            \"tight\",\n                            node.listTight ? \"true\" : \"false\"\n                        ]);\n                    }\n                    var delim = node.listDelimiter;\n                    if (delim !== null) {\n                        var delimword = \"\";\n                        if (delim === \".\") {\n                            delimword = \"period\";\n                        } else {\n                            delimword = \"paren\";\n                        }\n                        attrs.push([\"delimiter\", delimword]);\n                    }\n                    break;\n                case \"code_block\":\n                    if (node.info) {\n                        attrs.push([\"info\", node.info]);\n                    }\n                    break;\n                case \"heading\":\n                    attrs.push([\"level\", String(node.level)]);\n                    break;\n                case \"link\":\n                case \"image\":\n                    attrs.push([\"destination\", node.destination]);\n                    attrs.push([\"title\", node.title]);\n                    break;\n                case \"custom_inline\":\n                case \"custom_block\":\n                    attrs.push([\"on_enter\", node.onEnter]);\n                    attrs.push([\"on_exit\", node.onExit]);\n                    break;\n                default:\n                    break;\n            }\n            if (options.sourcepos) {\n                var pos = node.sourcepos;\n                if (pos) {\n                    attrs.push([\n                        \"sourcepos\",\n                        String(pos[0][0]) +\n                            \":\" +\n                            String(pos[0][1]) +\n                            \"-\" +\n                            String(pos[1][0]) +\n                            \":\" +\n                            String(pos[1][1])\n                    ]);\n                }\n            }\n\n            this.cr();\n            this.out(this.tag(tagname, attrs, selfClosing));\n            if (container) {\n                this.indentLevel += 1;\n            } else if (!container && !selfClosing) {\n                var lit = node.literal;\n                if (lit) {\n                    this.out(this.esc(lit));\n                }\n                this.out(this.tag(\"/\" + tagname));\n            }\n        } else {\n            this.indentLevel -= 1;\n            this.cr();\n            this.out(this.tag(\"/\" + tagname));\n        }\n    }\n    if (options.time) {\n        console.timeEnd(\"rendering\");\n    }\n    this.buffer += \"\\n\";\n    return this.buffer;\n}\n\nfunction out(s) {\n    if (this.disableTags > 0) {\n        this.buffer += s.replace(reXMLTag, \"\");\n    } else {\n        this.buffer += s;\n    }\n    this.lastOut = s;\n}\n\nfunction cr() {\n    if (this.lastOut !== \"\\n\") {\n        this.buffer += \"\\n\";\n        this.lastOut = \"\\n\";\n        for (var i = this.indentLevel; i > 0; i--) {\n            this.buffer += this.indent;\n        }\n    }\n}\n\n// Helper function to produce an XML tag.\nfunction tag(name, attrs, selfclosing) {\n    var result = \"<\" + name;\n    if (attrs && attrs.length > 0) {\n        var i = 0;\n        var attrib;\n        while ((attrib = attrs[i]) !== undefined) {\n            result += \" \" + attrib[0] + '=\"' + this.esc(attrib[1]) + '\"';\n            i++;\n        }\n    }\n    if (selfclosing) {\n        result += \" /\";\n    }\n    result += \">\";\n    return result;\n}\n\n// quick browser-compatible inheritance\nXmlRenderer.prototype = Object.create(Renderer.prototype);\n\nXmlRenderer.prototype.render = render;\nXmlRenderer.prototype.out = out;\nXmlRenderer.prototype.cr = cr;\nXmlRenderer.prototype.tag = tag;\nXmlRenderer.prototype.esc = escapeXml;\n\nexport default XmlRenderer;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.decodeXML = exports.decodeHTMLStrict = exports.decodeHTML = exports.determineBranch = exports.JUMP_OFFSET_BASE = exports.BinTrieFlags = exports.xmlDecodeTree = exports.htmlDecodeTree = void 0;\nvar decode_data_html_1 = __importDefault(require(\"./generated/decode-data-html\"));\nexports.htmlDecodeTree = decode_data_html_1.default;\nvar decode_data_xml_1 = __importDefault(require(\"./generated/decode-data-xml\"));\nexports.xmlDecodeTree = decode_data_xml_1.default;\nvar decode_codepoint_1 = __importDefault(require(\"./decode_codepoint\"));\nvar BinTrieFlags;\n(function (BinTrieFlags) {\n    BinTrieFlags[BinTrieFlags[\"HAS_VALUE\"] = 32768] = \"HAS_VALUE\";\n    BinTrieFlags[BinTrieFlags[\"BRANCH_LENGTH\"] = 32512] = \"BRANCH_LENGTH\";\n    BinTrieFlags[BinTrieFlags[\"MULTI_BYTE\"] = 128] = \"MULTI_BYTE\";\n    BinTrieFlags[BinTrieFlags[\"JUMP_TABLE\"] = 127] = \"JUMP_TABLE\";\n})(BinTrieFlags = exports.BinTrieFlags || (exports.BinTrieFlags = {}));\nexports.JUMP_OFFSET_BASE = 48 /* ZERO */ - 1;\nfunction getDecoder(decodeTree) {\n    return function decodeHTMLBinary(str, strict) {\n        var ret = \"\";\n        var lastIdx = 0;\n        var strIdx = 0;\n        while ((strIdx = str.indexOf(\"&\", strIdx)) >= 0) {\n            ret += str.slice(lastIdx, strIdx);\n            lastIdx = strIdx;\n            // Skip the \"&\"\n            strIdx += 1;\n            // If we have a numeric entity, handle this separately.\n            if (str.charCodeAt(strIdx) === 35 /* NUM */) {\n                // Skip the leading \"&#\". For hex entities, also skip the leading \"x\".\n                var start = strIdx + 1;\n                var base = 10;\n                var cp = str.charCodeAt(start);\n                if ((cp | 32 /* To_LOWER_BIT */) === 120 /* LOWER_X */) {\n                    base = 16;\n                    strIdx += 1;\n                    start += 1;\n                }\n                while (((cp = str.charCodeAt(++strIdx)) >= 48 /* ZERO */ &&\n                    cp <= 57 /* NINE */) ||\n                    (base === 16 &&\n                        (cp | 32 /* To_LOWER_BIT */) >= 97 /* LOWER_A */ &&\n                        (cp | 32 /* To_LOWER_BIT */) <= 102 /* LOWER_F */))\n                    ;\n                if (start !== strIdx) {\n                    var entity = str.substring(start, strIdx);\n                    var parsed = parseInt(entity, base);\n                    if (str.charCodeAt(strIdx) === 59 /* SEMI */) {\n                        strIdx += 1;\n                    }\n                    else if (strict) {\n                        continue;\n                    }\n                    ret += decode_codepoint_1.default(parsed);\n                    lastIdx = strIdx;\n                }\n                continue;\n            }\n            var result = null;\n            var excess = 1;\n            var treeIdx = 0;\n            var current = decodeTree[treeIdx];\n            for (; strIdx < str.length; strIdx++, excess++) {\n                treeIdx = determineBranch(decodeTree, current, treeIdx + 1, str.charCodeAt(strIdx));\n                if (treeIdx < 0)\n                    break;\n                current = decodeTree[treeIdx];\n                // If the branch is a value, store it and continue\n                if (current & BinTrieFlags.HAS_VALUE) {\n                    // If we have a legacy entity while parsing strictly, just skip the number of bytes\n                    if (strict && str.charCodeAt(strIdx) !== 59 /* SEMI */) {\n                        // No need to consider multi-byte values, as the legacy entity is always a single byte\n                        treeIdx += 1;\n                    }\n                    else {\n                        // If this is a surrogate pair, combine the higher bits from the node with the next byte\n                        result =\n                            current & BinTrieFlags.MULTI_BYTE\n                                ? String.fromCharCode(decodeTree[++treeIdx], decodeTree[++treeIdx])\n                                : String.fromCharCode(decodeTree[++treeIdx]);\n                        excess = 0;\n                    }\n                }\n            }\n            if (result != null) {\n                ret += result;\n                lastIdx = strIdx - excess + 1;\n            }\n        }\n        return ret + str.slice(lastIdx);\n    };\n}\nfunction determineBranch(decodeTree, current, nodeIdx, char) {\n    if (current <= 128) {\n        return char === current ? nodeIdx : -1;\n    }\n    var branchCount = (current & BinTrieFlags.BRANCH_LENGTH) >> 8;\n    if (branchCount === 0) {\n        return -1;\n    }\n    if (branchCount === 1) {\n        return char === decodeTree[nodeIdx] ? nodeIdx + 1 : -1;\n    }\n    var jumpOffset = current & BinTrieFlags.JUMP_TABLE;\n    if (jumpOffset) {\n        var value = char - exports.JUMP_OFFSET_BASE - jumpOffset;\n        return value < 0 || value > branchCount\n            ? -1\n            : decodeTree[nodeIdx + value] - 1;\n    }\n    // Binary search for the character.\n    var lo = nodeIdx;\n    var hi = lo + branchCount - 1;\n    while (lo <= hi) {\n        var mid = (lo + hi) >>> 1;\n        var midVal = decodeTree[mid];\n        if (midVal < char) {\n            lo = mid + 1;\n        }\n        else if (midVal > char) {\n            hi = mid - 1;\n        }\n        else {\n            return decodeTree[mid + branchCount];\n        }\n    }\n    return -1;\n}\nexports.determineBranch = determineBranch;\nvar htmlDecoder = getDecoder(decode_data_html_1.default);\nvar xmlDecoder = getDecoder(decode_data_xml_1.default);\nfunction decodeHTML(str) {\n    return htmlDecoder(str, false);\n}\nexports.decodeHTML = decodeHTML;\nfunction decodeHTMLStrict(str) {\n    return htmlDecoder(str, true);\n}\nexports.decodeHTMLStrict = decodeHTMLStrict;\nfunction decodeXML(str) {\n    return xmlDecoder(str, true);\n}\nexports.decodeXML = decodeXML;\n","\"use strict\";\n// Adapted from https://github.com/mathiasbynens/he/blob/36afe179392226cf1b6ccdb16ebbb7a5a844d93a/src/he.js#L106-L134\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar decodeMap = new Map([\n    [0, 65533],\n    [128, 8364],\n    [130, 8218],\n    [131, 402],\n    [132, 8222],\n    [133, 8230],\n    [134, 8224],\n    [135, 8225],\n    [136, 710],\n    [137, 8240],\n    [138, 352],\n    [139, 8249],\n    [140, 338],\n    [142, 381],\n    [145, 8216],\n    [146, 8217],\n    [147, 8220],\n    [148, 8221],\n    [149, 8226],\n    [150, 8211],\n    [151, 8212],\n    [152, 732],\n    [153, 8482],\n    [154, 353],\n    [155, 8250],\n    [156, 339],\n    [158, 382],\n    [159, 376],\n]);\nvar fromCodePoint = \n// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition, node/no-unsupported-features/es-builtins\nString.fromCodePoint ||\n    function (codePoint) {\n        var output = \"\";\n        if (codePoint > 0xffff) {\n            codePoint -= 0x10000;\n            output += String.fromCharCode(((codePoint >>> 10) & 0x3ff) | 0xd800);\n            codePoint = 0xdc00 | (codePoint & 0x3ff);\n        }\n        output += String.fromCharCode(codePoint);\n        return output;\n    };\nfunction decodeCodePoint(codePoint) {\n    var _a;\n    if ((codePoint >= 0xd800 && codePoint <= 0xdfff) || codePoint > 0x10ffff) {\n        return \"\\uFFFD\";\n    }\n    return fromCodePoint((_a = decodeMap.get(codePoint)) !== null && _a !== void 0 ? _a : codePoint);\n}\nexports.default = decodeCodePoint;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.getTrie = exports.encodeHTMLTrieRe = exports.getCodePoint = void 0;\nvar entities_json_1 = __importDefault(require(\"./maps/entities.json\"));\nfunction isHighSurrugate(c) {\n    return (c & 64512 /* Mask */) === 55296 /* High */;\n}\n// For compatibility with node < 4, we wrap `codePointAt`\nexports.getCodePoint = \n// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\nString.prototype.codePointAt != null\n    ? function (str, index) { return str.codePointAt(index); }\n    : // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae\n        function (c, index) {\n            return isHighSurrugate(c.charCodeAt(index))\n                ? (c.charCodeAt(index) - 55296 /* High */) * 0x400 +\n                    c.charCodeAt(index + 1) -\n                    0xdc00 +\n                    0x10000\n                : c.charCodeAt(index);\n        };\nvar htmlTrie = getTrie(entities_json_1.default);\nfunction encodeHTMLTrieRe(regExp, str) {\n    var _a;\n    var ret = \"\";\n    var lastIdx = 0;\n    var match;\n    while ((match = regExp.exec(str)) !== null) {\n        var i = match.index;\n        var char = str.charCodeAt(i);\n        var next = htmlTrie.get(char);\n        if (next) {\n            if (next.next != null && i + 1 < str.length) {\n                var value = (_a = next.next.get(str.charCodeAt(i + 1))) === null || _a === void 0 ? void 0 : _a.value;\n                if (value != null) {\n                    ret += str.substring(lastIdx, i) + value;\n                    regExp.lastIndex += 1;\n                    lastIdx = i + 2;\n                    continue;\n                }\n            }\n            ret += str.substring(lastIdx, i) + next.value;\n            lastIdx = i + 1;\n        }\n        else {\n            ret += str.substring(lastIdx, i) + \"&#x\" + exports.getCodePoint(str, i).toString(16) + \";\";\n            // Increase by 1 if we have a surrogate pair\n            lastIdx = regExp.lastIndex += Number(isHighSurrugate(char));\n        }\n    }\n    return ret + str.substr(lastIdx);\n}\nexports.encodeHTMLTrieRe = encodeHTMLTrieRe;\nfunction getTrie(map) {\n    var _a, _b, _c, _d;\n    var trie = new Map();\n    for (var _i = 0, _e = Object.keys(map); _i < _e.length; _i++) {\n        var value = _e[_i];\n        var key = map[value];\n        // Resolve the key\n        var lastMap = trie;\n        for (var i = 0; i < key.length - 1; i++) {\n            var char = key.charCodeAt(i);\n            var next = (_a = lastMap.get(char)) !== null && _a !== void 0 ? _a : {};\n            lastMap.set(char, next);\n            lastMap = (_b = next.next) !== null && _b !== void 0 ? _b : (next.next = new Map());\n        }\n        var val = (_c = lastMap.get(key.charCodeAt(key.length - 1))) !== null && _c !== void 0 ? _c : {};\n        (_d = val.value) !== null && _d !== void 0 ? _d : (val.value = \"&\" + value + \";\");\n        lastMap.set(key.charCodeAt(key.length - 1), val);\n    }\n    return trie;\n}\nexports.getTrie = getTrie;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.escapeUTF8 = exports.escape = exports.encodeNonAsciiHTML = exports.encodeHTML = exports.encodeXML = void 0;\nvar xml_json_1 = __importDefault(require(\"./maps/xml.json\"));\nvar encode_trie_1 = require(\"./encode-trie\");\nvar entities_json_1 = __importDefault(require(\"./maps/entities.json\"));\nvar htmlReplacer = getCharRegExp(entities_json_1.default, true);\nvar xmlReplacer = getCharRegExp(xml_json_1.default, true);\nvar xmlInvalidChars = getCharRegExp(xml_json_1.default, false);\nvar xmlCodeMap = new Map(Object.keys(xml_json_1.default).map(function (k) { return [\n    xml_json_1.default[k].charCodeAt(0),\n    \"&\" + k + \";\",\n]; }));\n/**\n * Encodes all non-ASCII characters, as well as characters not valid in XML\n * documents using XML entities.\n *\n * If a character has no equivalent entity, a\n * numeric hexadecimal reference (eg. `&#xfc;`) will be used.\n */\nfunction encodeXML(str) {\n    var ret = \"\";\n    var lastIdx = 0;\n    var match;\n    while ((match = xmlReplacer.exec(str)) !== null) {\n        var i = match.index;\n        var char = str.charCodeAt(i);\n        var next = xmlCodeMap.get(char);\n        if (next) {\n            ret += str.substring(lastIdx, i) + next;\n            lastIdx = i + 1;\n        }\n        else {\n            ret += str.substring(lastIdx, i) + \"&#x\" + encode_trie_1.getCodePoint(str, i).toString(16) + \";\";\n            // Increase by 1 if we have a surrogate pair\n            lastIdx = xmlReplacer.lastIndex += Number((char & 65408) === 0xd800);\n        }\n    }\n    return ret + str.substr(lastIdx);\n}\nexports.encodeXML = encodeXML;\n/**\n * Encodes all entities and non-ASCII characters in the input.\n *\n * This includes characters that are valid ASCII characters in HTML documents.\n * For example `#` will be encoded as `&num;`. To get a more compact output,\n * consider using the `encodeNonAsciiHTML` function.\n *\n * If a character has no equivalent entity, a\n * numeric hexadecimal reference (eg. `&#xfc;`) will be used.\n */\nfunction encodeHTML(data) {\n    return encode_trie_1.encodeHTMLTrieRe(htmlReplacer, data);\n}\nexports.encodeHTML = encodeHTML;\n/**\n * Encodes all non-ASCII characters, as well as characters not valid in HTML\n * documents using HTML entities.\n *\n * If a character has no equivalent entity, a\n * numeric hexadecimal reference (eg. `&#xfc;`) will be used.\n */\nfunction encodeNonAsciiHTML(data) {\n    return encode_trie_1.encodeHTMLTrieRe(xmlReplacer, data);\n}\nexports.encodeNonAsciiHTML = encodeNonAsciiHTML;\nfunction getCharRegExp(map, nonAscii) {\n    // Collect the start characters of all entities\n    var chars = Object.keys(map)\n        .map(function (k) { return \"\\\\\" + map[k].charAt(0); })\n        .filter(function (v) { return !nonAscii || v.charCodeAt(1) < 128; })\n        .sort(function (a, b) { return a.charCodeAt(1) - b.charCodeAt(1); })\n        // Remove duplicates\n        .filter(function (v, i, a) { return v !== a[i + 1]; });\n    // Add ranges to single characters.\n    for (var start = 0; start < chars.length - 1; start++) {\n        // Find the end of a run of characters\n        var end = start;\n        while (end < chars.length - 1 &&\n            chars[end].charCodeAt(1) + 1 === chars[end + 1].charCodeAt(1)) {\n            end += 1;\n        }\n        var count = 1 + end - start;\n        // We want to replace at least three characters\n        if (count < 3)\n            continue;\n        chars.splice(start, count, chars[start] + \"-\" + chars[end]);\n    }\n    return new RegExp(\"[\" + chars.join(\"\") + (nonAscii ? \"\\\\x80-\\\\uFFFF\" : \"\") + \"]\", \"g\");\n}\n/**\n * Encodes all non-ASCII characters, as well as characters not valid in XML\n * documents using numeric hexadecimal reference (eg. `&#xfc;`).\n *\n * Have a look at `escapeUTF8` if you want a more concise output at the expense\n * of reduced transportability.\n *\n * @param data String to escape.\n */\nexports.escape = encodeXML;\n/**\n * Encodes all characters not valid in XML documents using XML entities.\n *\n * Note that the output will be character-set dependent.\n *\n * @param data String to escape.\n */\nfunction escapeUTF8(data) {\n    var match;\n    var lastIdx = 0;\n    var result = \"\";\n    while ((match = xmlInvalidChars.exec(data))) {\n        if (lastIdx !== match.index) {\n            result += data.substring(lastIdx, match.index);\n        }\n        // We know that this chararcter will be in `inverseXML`\n        result += xmlCodeMap.get(match[0].charCodeAt(0));\n        // Every match will be of length 1\n        lastIdx = match.index + 1;\n    }\n    return result + data.substring(lastIdx);\n}\nexports.escapeUTF8 = escapeUTF8;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n// Generated using scripts/write-decode-map.ts\n// prettier-ignore\nexports.default = new Uint16Array([14866, 60, 237, 340, 721, 1312, 1562, 1654, 1838, 1957, 2183, 2239, 2301, 2958, 3037, 3893, 4123, 4298, 4330, 4801, 5191, 5395, 5752, 5903, 5943, 5972, 6050, 0, 0, 0, 0, 0, 0, 6135, 6565, 7422, 8183, 8738, 9242, 9503, 9938, 10189, 10573, 10637, 10715, 11950, 12246, 13539, 13950, 14445, 14533, 15364, 16514, 16980, 17390, 17763, 17849, 18036, 18125, 4096, 69, 77, 97, 98, 99, 102, 103, 108, 109, 110, 111, 112, 114, 115, 116, 117, 92, 100, 106, 115, 122, 137, 142, 151, 157, 163, 167, 182, 196, 204, 220, 229, 108, 105, 103, 33024, 198, 59, 32768, 198, 80, 33024, 38, 59, 32768, 38, 99, 117, 116, 101, 33024, 193, 59, 32768, 193, 114, 101, 118, 101, 59, 32768, 258, 512, 105, 121, 127, 134, 114, 99, 33024, 194, 59, 32768, 194, 59, 32768, 1040, 114, 59, 32896, 55349, 56580, 114, 97, 118, 101, 33024, 192, 59, 32768, 192, 112, 104, 97, 59, 32768, 913, 97, 99, 114, 59, 32768, 256, 100, 59, 32768, 10835, 512, 103, 112, 172, 177, 111, 110, 59, 32768, 260, 102, 59, 32896, 55349, 56632, 112, 108, 121, 70, 117, 110, 99, 116, 105, 111, 110, 59, 32768, 8289, 105, 110, 103, 33024, 197, 59, 32768, 197, 512, 99, 115, 209, 214, 114, 59, 32896, 55349, 56476, 105, 103, 110, 59, 32768, 8788, 105, 108, 100, 101, 33024, 195, 59, 32768, 195, 109, 108, 33024, 196, 59, 32768, 196, 2048, 97, 99, 101, 102, 111, 114, 115, 117, 253, 278, 282, 310, 315, 321, 327, 332, 512, 99, 114, 258, 267, 107, 115, 108, 97, 115, 104, 59, 32768, 8726, 583, 271, 274, 59, 32768, 10983, 101, 100, 59, 32768, 8966, 121, 59, 32768, 1041, 768, 99, 114, 116, 289, 296, 306, 97, 117, 115, 101, 59, 32768, 8757, 110, 111, 117, 108, 108, 105, 115, 59, 32768, 8492, 97, 59, 32768, 914, 114, 59, 32896, 55349, 56581, 112, 102, 59, 32896, 55349, 56633, 101, 118, 101, 59, 32768, 728, 99, 114, 59, 32768, 8492, 109, 112, 101, 113, 59, 32768, 8782, 3584, 72, 79, 97, 99, 100, 101, 102, 104, 105, 108, 111, 114, 115, 117, 368, 373, 380, 426, 461, 466, 487, 491, 495, 533, 593, 695, 701, 707, 99, 121, 59, 32768, 1063, 80, 89, 33024, 169, 59, 32768, 169, 768, 99, 112, 121, 387, 393, 419, 117, 116, 101, 59, 32768, 262, 512, 59, 105, 398, 400, 32768, 8914, 116, 97, 108, 68, 105, 102, 102, 101, 114, 101, 110, 116, 105, 97, 108, 68, 59, 32768, 8517, 108, 101, 121, 115, 59, 32768, 8493, 1024, 97, 101, 105, 111, 435, 441, 449, 454, 114, 111, 110, 59, 32768, 268, 100, 105, 108, 33024, 199, 59, 32768, 199, 114, 99, 59, 32768, 264, 110, 105, 110, 116, 59, 32768, 8752, 111, 116, 59, 32768, 266, 512, 100, 110, 471, 478, 105, 108, 108, 97, 59, 32768, 184, 116, 101, 114, 68, 111, 116, 59, 32768, 183, 114, 59, 32768, 8493, 105, 59, 32768, 935, 114, 99, 108, 101, 1024, 68, 77, 80, 84, 508, 513, 520, 526, 111, 116, 59, 32768, 8857, 105, 110, 117, 115, 59, 32768, 8854, 108, 117, 115, 59, 32768, 8853, 105, 109, 101, 115, 59, 32768, 8855, 111, 512, 99, 115, 539, 562, 107, 119, 105, 115, 101, 67, 111, 110, 116, 111, 117, 114, 73, 110, 116, 101, 103, 114, 97, 108, 59, 32768, 8754, 101, 67, 117, 114, 108, 121, 512, 68, 81, 573, 586, 111, 117, 98, 108, 101, 81, 117, 111, 116, 101, 59, 32768, 8221, 117, 111, 116, 101, 59, 32768, 8217, 1024, 108, 110, 112, 117, 602, 614, 648, 664, 111, 110, 512, 59, 101, 609, 611, 32768, 8759, 59, 32768, 10868, 768, 103, 105, 116, 621, 629, 634, 114, 117, 101, 110, 116, 59, 32768, 8801, 110, 116, 59, 32768, 8751, 111, 117, 114, 73, 110, 116, 101, 103, 114, 97, 108, 59, 32768, 8750, 512, 102, 114, 653, 656, 59, 32768, 8450, 111, 100, 117, 99, 116, 59, 32768, 8720, 110, 116, 101, 114, 67, 108, 111, 99, 107, 119, 105, 115, 101, 67, 111, 110, 116, 111, 117, 114, 73, 110, 116, 101, 103, 114, 97, 108, 59, 32768, 8755, 111, 115, 115, 59, 32768, 10799, 99, 114, 59, 32896, 55349, 56478, 112, 512, 59, 67, 713, 715, 32768, 8915, 97, 112, 59, 32768, 8781, 2816, 68, 74, 83, 90, 97, 99, 101, 102, 105, 111, 115, 743, 758, 763, 768, 773, 795, 809, 821, 826, 910, 1295, 512, 59, 111, 748, 750, 32768, 8517, 116, 114, 97, 104, 100, 59, 32768, 10513, 99, 121, 59, 32768, 1026, 99, 121, 59, 32768, 1029, 99, 121, 59, 32768, 1039, 768, 103, 114, 115, 780, 786, 790, 103, 101, 114, 59, 32768, 8225, 114, 59, 32768, 8609, 104, 118, 59, 32768, 10980, 512, 97, 121, 800, 806, 114, 111, 110, 59, 32768, 270, 59, 32768, 1044, 108, 512, 59, 116, 815, 817, 32768, 8711, 97, 59, 32768, 916, 114, 59, 32896, 55349, 56583, 512, 97, 102, 831, 897, 512, 99, 109, 836, 891, 114, 105, 116, 105, 99, 97, 108, 1024, 65, 68, 71, 84, 852, 859, 877, 884, 99, 117, 116, 101, 59, 32768, 180, 111, 581, 864, 867, 59, 32768, 729, 98, 108, 101, 65, 99, 117, 116, 101, 59, 32768, 733, 114, 97, 118, 101, 59, 32768, 96, 105, 108, 100, 101, 59, 32768, 732, 111, 110, 100, 59, 32768, 8900, 102, 101, 114, 101, 110, 116, 105, 97, 108, 68, 59, 32768, 8518, 2113, 920, 0, 0, 0, 925, 946, 0, 1139, 102, 59, 32896, 55349, 56635, 768, 59, 68, 69, 931, 933, 938, 32768, 168, 111, 116, 59, 32768, 8412, 113, 117, 97, 108, 59, 32768, 8784, 98, 108, 101, 1536, 67, 68, 76, 82, 85, 86, 961, 978, 996, 1080, 1101, 1125, 111, 110, 116, 111, 117, 114, 73, 110, 116, 101, 103, 114, 97, 108, 59, 32768, 8751, 111, 1093, 985, 0, 0, 988, 59, 32768, 168, 110, 65, 114, 114, 111, 119, 59, 32768, 8659, 512, 101, 111, 1001, 1034, 102, 116, 768, 65, 82, 84, 1010, 1017, 1029, 114, 114, 111, 119, 59, 32768, 8656, 105, 103, 104, 116, 65, 114, 114, 111, 119, 59, 32768, 8660, 101, 101, 59, 32768, 10980, 110, 103, 512, 76, 82, 1041, 1068, 101, 102, 116, 512, 65, 82, 1049, 1056, 114, 114, 111, 119, 59, 32768, 10232, 105, 103, 104, 116, 65, 114, 114, 111, 119, 59, 32768, 10234, 105, 103, 104, 116, 65, 114, 114, 111, 119, 59, 32768, 10233, 105, 103, 104, 116, 512, 65, 84, 1089, 1096, 114, 114, 111, 119, 59, 32768, 8658, 101, 101, 59, 32768, 8872, 112, 1042, 1108, 0, 0, 1115, 114, 114, 111, 119, 59, 32768, 8657, 111, 119, 110, 65, 114, 114, 111, 119, 59, 32768, 8661, 101, 114, 116, 105, 99, 97, 108, 66, 97, 114, 59, 32768, 8741, 110, 1536, 65, 66, 76, 82, 84, 97, 1152, 1179, 1186, 1236, 1272, 1288, 114, 114, 111, 119, 768, 59, 66, 85, 1163, 1165, 1170, 32768, 8595, 97, 114, 59, 32768, 10515, 112, 65, 114, 114, 111, 119, 59, 32768, 8693, 114, 101, 118, 101, 59, 32768, 785, 101, 102, 116, 1315, 1196, 0, 1209, 0, 1220, 105, 103, 104, 116, 86, 101, 99, 116, 111, 114, 59, 32768, 10576, 101, 101, 86, 101, 99, 116, 111, 114, 59, 32768, 10590, 101, 99, 116, 111, 114, 512, 59, 66, 1229, 1231, 32768, 8637, 97, 114, 59, 32768, 10582, 105, 103, 104, 116, 805, 1245, 0, 1256, 101, 101, 86, 101, 99, 116, 111, 114, 59, 32768, 10591, 101, 99, 116, 111, 114, 512, 59, 66, 1265, 1267, 32768, 8641, 97, 114, 59, 32768, 10583, 101, 101, 512, 59, 65, 1279, 1281, 32768, 8868, 114, 114, 111, 119, 59, 32768, 8615, 114, 114, 111, 119, 59, 32768, 8659, 512, 99, 116, 1300, 1305, 114, 59, 32896, 55349, 56479, 114, 111, 107, 59, 32768, 272, 4096, 78, 84, 97, 99, 100, 102, 103, 108, 109, 111, 112, 113, 115, 116, 117, 120, 1344, 1348, 1354, 1363, 1386, 1391, 1396, 1405, 1413, 1460, 1475, 1483, 1514, 1527, 1531, 1538, 71, 59, 32768, 330, 72, 33024, 208, 59, 32768, 208, 99, 117, 116, 101, 33024, 201, 59, 32768, 201, 768, 97, 105, 121, 1370, 1376, 1383, 114, 111, 110, 59, 32768, 282, 114, 99, 33024, 202, 59, 32768, 202, 59, 32768, 1069, 111, 116, 59, 32768, 278, 114, 59, 32896, 55349, 56584, 114, 97, 118, 101, 33024, 200, 59, 32768, 200, 101, 109, 101, 110, 116, 59, 32768, 8712, 512, 97, 112, 1418, 1423, 99, 114, 59, 32768, 274, 116, 121, 1060, 1431, 0, 0, 1444, 109, 97, 108, 108, 83, 113, 117, 97, 114, 101, 59, 32768, 9723, 101, 114, 121, 83, 109, 97, 108, 108, 83, 113, 117, 97, 114, 101, 59, 32768, 9643, 512, 103, 112, 1465, 1470, 111, 110, 59, 32768, 280, 102, 59, 32896, 55349, 56636, 115, 105, 108, 111, 110, 59, 32768, 917, 117, 512, 97, 105, 1489, 1504, 108, 512, 59, 84, 1495, 1497, 32768, 10869, 105, 108, 100, 101, 59, 32768, 8770, 108, 105, 98, 114, 105, 117, 109, 59, 32768, 8652, 512, 99, 105, 1519, 1523, 114, 59, 32768, 8496, 109, 59, 32768, 10867, 97, 59, 32768, 919, 109, 108, 33024, 203, 59, 32768, 203, 512, 105, 112, 1543, 1549, 115, 116, 115, 59, 32768, 8707, 111, 110, 101, 110, 116, 105, 97, 108, 69, 59, 32768, 8519, 1280, 99, 102, 105, 111, 115, 1572, 1576, 1581, 1620, 1648, 121, 59, 32768, 1060, 114, 59, 32896, 55349, 56585, 108, 108, 101, 100, 1060, 1591, 0, 0, 1604, 109, 97, 108, 108, 83, 113, 117, 97, 114, 101, 59, 32768, 9724, 101, 114, 121, 83, 109, 97, 108, 108, 83, 113, 117, 97, 114, 101, 59, 32768, 9642, 1601, 1628, 0, 1633, 0, 0, 1639, 102, 59, 32896, 55349, 56637, 65, 108, 108, 59, 32768, 8704, 114, 105, 101, 114, 116, 114, 102, 59, 32768, 8497, 99, 114, 59, 32768, 8497, 3072, 74, 84, 97, 98, 99, 100, 102, 103, 111, 114, 115, 116, 1678, 1683, 1688, 1701, 1708, 1729, 1734, 1739, 1742, 1748, 1828, 1834, 99, 121, 59, 32768, 1027, 33024, 62, 59, 32768, 62, 109, 109, 97, 512, 59, 100, 1696, 1698, 32768, 915, 59, 32768, 988, 114, 101, 118, 101, 59, 32768, 286, 768, 101, 105, 121, 1715, 1721, 1726, 100, 105, 108, 59, 32768, 290, 114, 99, 59, 32768, 284, 59, 32768, 1043, 111, 116, 59, 32768, 288, 114, 59, 32896, 55349, 56586, 59, 32768, 8921, 112, 102, 59, 32896, 55349, 56638, 101, 97, 116, 101, 114, 1536, 69, 70, 71, 76, 83, 84, 1766, 1783, 1794, 1803, 1809, 1821, 113, 117, 97, 108, 512, 59, 76, 1775, 1777, 32768, 8805, 101, 115, 115, 59, 32768, 8923, 117, 108, 108, 69, 113, 117, 97, 108, 59, 32768, 8807, 114, 101, 97, 116, 101, 114, 59, 32768, 10914, 101, 115, 115, 59, 32768, 8823, 108, 97, 110, 116, 69, 113, 117, 97, 108, 59, 32768, 10878, 105, 108, 100, 101, 59, 32768, 8819, 99, 114, 59, 32896, 55349, 56482, 59, 32768, 8811, 2048, 65, 97, 99, 102, 105, 111, 115, 117, 1854, 1861, 1874, 1880, 1884, 1897, 1919, 1934, 82, 68, 99, 121, 59, 32768, 1066, 512, 99, 116, 1866, 1871, 101, 107, 59, 32768, 711, 59, 32768, 94, 105, 114, 99, 59, 32768, 292, 114, 59, 32768, 8460, 108, 98, 101, 114, 116, 83, 112, 97, 99, 101, 59, 32768, 8459, 833, 1902, 0, 1906, 102, 59, 32768, 8461, 105, 122, 111, 110, 116, 97, 108, 76, 105, 110, 101, 59, 32768, 9472, 512, 99, 116, 1924, 1928, 114, 59, 32768, 8459, 114, 111, 107, 59, 32768, 294, 109, 112, 533, 1940, 1950, 111, 119, 110, 72, 117, 109, 112, 59, 32768, 8782, 113, 117, 97, 108, 59, 32768, 8783, 3584, 69, 74, 79, 97, 99, 100, 102, 103, 109, 110, 111, 115, 116, 117, 1985, 1990, 1996, 2001, 2010, 2025, 2030, 2034, 2043, 2077, 2134, 2155, 2160, 2167, 99, 121, 59, 32768, 1045, 108, 105, 103, 59, 32768, 306, 99, 121, 59, 32768, 1025, 99, 117, 116, 101, 33024, 205, 59, 32768, 205, 512, 105, 121, 2015, 2022, 114, 99, 33024, 206, 59, 32768, 206, 59, 32768, 1048, 111, 116, 59, 32768, 304, 114, 59, 32768, 8465, 114, 97, 118, 101, 33024, 204, 59, 32768, 204, 768, 59, 97, 112, 2050, 2052, 2070, 32768, 8465, 512, 99, 103, 2057, 2061, 114, 59, 32768, 298, 105, 110, 97, 114, 121, 73, 59, 32768, 8520, 108, 105, 101, 115, 59, 32768, 8658, 837, 2082, 0, 2110, 512, 59, 101, 2086, 2088, 32768, 8748, 512, 103, 114, 2093, 2099, 114, 97, 108, 59, 32768, 8747, 115, 101, 99, 116, 105, 111, 110, 59, 32768, 8898, 105, 115, 105, 98, 108, 101, 512, 67, 84, 2120, 2127, 111, 109, 109, 97, 59, 32768, 8291, 105, 109, 101, 115, 59, 32768, 8290, 768, 103, 112, 116, 2141, 2146, 2151, 111, 110, 59, 32768, 302, 102, 59, 32896, 55349, 56640, 97, 59, 32768, 921, 99, 114, 59, 32768, 8464, 105, 108, 100, 101, 59, 32768, 296, 828, 2172, 0, 2177, 99, 121, 59, 32768, 1030, 108, 33024, 207, 59, 32768, 207, 1280, 99, 102, 111, 115, 117, 2193, 2206, 2211, 2217, 2232, 512, 105, 121, 2198, 2203, 114, 99, 59, 32768, 308, 59, 32768, 1049, 114, 59, 32896, 55349, 56589, 112, 102, 59, 32896, 55349, 56641, 820, 2222, 0, 2227, 114, 59, 32896, 55349, 56485, 114, 99, 121, 59, 32768, 1032, 107, 99, 121, 59, 32768, 1028, 1792, 72, 74, 97, 99, 102, 111, 115, 2253, 2258, 2263, 2269, 2283, 2288, 2294, 99, 121, 59, 32768, 1061, 99, 121, 59, 32768, 1036, 112, 112, 97, 59, 32768, 922, 512, 101, 121, 2274, 2280, 100, 105, 108, 59, 32768, 310, 59, 32768, 1050, 114, 59, 32896, 55349, 56590, 112, 102, 59, 32896, 55349, 56642, 99, 114, 59, 32896, 55349, 56486, 2816, 74, 84, 97, 99, 101, 102, 108, 109, 111, 115, 116, 2323, 2328, 2333, 2374, 2396, 2775, 2780, 2797, 2804, 2934, 2954, 99, 121, 59, 32768, 1033, 33024, 60, 59, 32768, 60, 1280, 99, 109, 110, 112, 114, 2344, 2350, 2356, 2360, 2370, 117, 116, 101, 59, 32768, 313, 98, 100, 97, 59, 32768, 923, 103, 59, 32768, 10218, 108, 97, 99, 101, 116, 114, 102, 59, 32768, 8466, 114, 59, 32768, 8606, 768, 97, 101, 121, 2381, 2387, 2393, 114, 111, 110, 59, 32768, 317, 100, 105, 108, 59, 32768, 315, 59, 32768, 1051, 512, 102, 115, 2401, 2702, 116, 2560, 65, 67, 68, 70, 82, 84, 85, 86, 97, 114, 2423, 2470, 2479, 2530, 2537, 2561, 2618, 2666, 2683, 2690, 512, 110, 114, 2428, 2441, 103, 108, 101, 66, 114, 97, 99, 107, 101, 116, 59, 32768, 10216, 114, 111, 119, 768, 59, 66, 82, 2451, 2453, 2458, 32768, 8592, 97, 114, 59, 32768, 8676, 105, 103, 104, 116, 65, 114, 114, 111, 119, 59, 32768, 8646, 101, 105, 108, 105, 110, 103, 59, 32768, 8968, 111, 838, 2485, 0, 2498, 98, 108, 101, 66, 114, 97, 99, 107, 101, 116, 59, 32768, 10214, 110, 805, 2503, 0, 2514, 101, 101, 86, 101, 99, 116, 111, 114, 59, 32768, 10593, 101, 99, 116, 111, 114, 512, 59, 66, 2523, 2525, 32768, 8643, 97, 114, 59, 32768, 10585, 108, 111, 111, 114, 59, 32768, 8970, 105, 103, 104, 116, 512, 65, 86, 2546, 2553, 114, 114, 111, 119, 59, 32768, 8596, 101, 99, 116, 111, 114, 59, 32768, 10574, 512, 101, 114, 2566, 2591, 101, 768, 59, 65, 86, 2574, 2576, 2583, 32768, 8867, 114, 114, 111, 119, 59, 32768, 8612, 101, 99, 116, 111, 114, 59, 32768, 10586, 105, 97, 110, 103, 108, 101, 768, 59, 66, 69, 2604, 2606, 2611, 32768, 8882, 97, 114, 59, 32768, 10703, 113, 117, 97, 108, 59, 32768, 8884, 112, 768, 68, 84, 86, 2626, 2638, 2649, 111, 119, 110, 86, 101, 99, 116, 111, 114, 59, 32768, 10577, 101, 101, 86, 101, 99, 116, 111, 114, 59, 32768, 10592, 101, 99, 116, 111, 114, 512, 59, 66, 2659, 2661, 32768, 8639, 97, 114, 59, 32768, 10584, 101, 99, 116, 111, 114, 512, 59, 66, 2676, 2678, 32768, 8636, 97, 114, 59, 32768, 10578, 114, 114, 111, 119, 59, 32768, 8656, 105, 103, 104, 116, 97, 114, 114, 111, 119, 59, 32768, 8660, 115, 1536, 69, 70, 71, 76, 83, 84, 2716, 2730, 2741, 2750, 2756, 2768, 113, 117, 97, 108, 71, 114, 101, 97, 116, 101, 114, 59, 32768, 8922, 117, 108, 108, 69, 113, 117, 97, 108, 59, 32768, 8806, 114, 101, 97, 116, 101, 114, 59, 32768, 8822, 101, 115, 115, 59, 32768, 10913, 108, 97, 110, 116, 69, 113, 117, 97, 108, 59, 32768, 10877, 105, 108, 100, 101, 59, 32768, 8818, 114, 59, 32896, 55349, 56591, 512, 59, 101, 2785, 2787, 32768, 8920, 102, 116, 97, 114, 114, 111, 119, 59, 32768, 8666, 105, 100, 111, 116, 59, 32768, 319, 768, 110, 112, 119, 2811, 2899, 2904, 103, 1024, 76, 82, 108, 114, 2821, 2848, 2860, 2887, 101, 102, 116, 512, 65, 82, 2829, 2836, 114, 114, 111, 119, 59, 32768, 10229, 105, 103, 104, 116, 65, 114, 114, 111, 119, 59, 32768, 10231, 105, 103, 104, 116, 65, 114, 114, 111, 119, 59, 32768, 10230, 101, 102, 116, 512, 97, 114, 2868, 2875, 114, 114, 111, 119, 59, 32768, 10232, 105, 103, 104, 116, 97, 114, 114, 111, 119, 59, 32768, 10234, 105, 103, 104, 116, 97, 114, 114, 111, 119, 59, 32768, 10233, 102, 59, 32896, 55349, 56643, 101, 114, 512, 76, 82, 2911, 2922, 101, 102, 116, 65, 114, 114, 111, 119, 59, 32768, 8601, 105, 103, 104, 116, 65, 114, 114, 111, 119, 59, 32768, 8600, 768, 99, 104, 116, 2941, 2945, 2948, 114, 59, 32768, 8466, 59, 32768, 8624, 114, 111, 107, 59, 32768, 321, 59, 32768, 8810, 2048, 97, 99, 101, 102, 105, 111, 115, 117, 2974, 2978, 2982, 3007, 3012, 3022, 3028, 3033, 112, 59, 32768, 10501, 121, 59, 32768, 1052, 512, 100, 108, 2987, 2998, 105, 117, 109, 83, 112, 97, 99, 101, 59, 32768, 8287, 108, 105, 110, 116, 114, 102, 59, 32768, 8499, 114, 59, 32896, 55349, 56592, 110, 117, 115, 80, 108, 117, 115, 59, 32768, 8723, 112, 102, 59, 32896, 55349, 56644, 99, 114, 59, 32768, 8499, 59, 32768, 924, 2304, 74, 97, 99, 101, 102, 111, 115, 116, 117, 3055, 3060, 3067, 3089, 3201, 3206, 3874, 3880, 3889, 99, 121, 59, 32768, 1034, 99, 117, 116, 101, 59, 32768, 323, 768, 97, 101, 121, 3074, 3080, 3086, 114, 111, 110, 59, 32768, 327, 100, 105, 108, 59, 32768, 325, 59, 32768, 1053, 768, 103, 115, 119, 3096, 3160, 3194, 97, 116, 105, 118, 101, 768, 77, 84, 86, 3108, 3121, 3145, 101, 100, 105, 117, 109, 83, 112, 97, 99, 101, 59, 32768, 8203, 104, 105, 512, 99, 110, 3128, 3137, 107, 83, 112, 97, 99, 101, 59, 32768, 8203, 83, 112, 97, 99, 101, 59, 32768, 8203, 101, 114, 121, 84, 104, 105, 110, 83, 112, 97, 99, 101, 59, 32768, 8203, 116, 101, 100, 512, 71, 76, 3168, 3184, 114, 101, 97, 116, 101, 114, 71, 114, 101, 97, 116, 101, 114, 59, 32768, 8811, 101, 115, 115, 76, 101, 115, 115, 59, 32768, 8810, 76, 105, 110, 101, 59, 32768, 10, 114, 59, 32896, 55349, 56593, 1024, 66, 110, 112, 116, 3215, 3222, 3238, 3242, 114, 101, 97, 107, 59, 32768, 8288, 66, 114, 101, 97, 107, 105, 110, 103, 83, 112, 97, 99, 101, 59, 32768, 160, 102, 59, 32768, 8469, 3328, 59, 67, 68, 69, 71, 72, 76, 78, 80, 82, 83, 84, 86, 3269, 3271, 3293, 3312, 3352, 3430, 3455, 3551, 3589, 3625, 3678, 3821, 3861, 32768, 10988, 512, 111, 117, 3276, 3286, 110, 103, 114, 117, 101, 110, 116, 59, 32768, 8802, 112, 67, 97, 112, 59, 32768, 8813, 111, 117, 98, 108, 101, 86, 101, 114, 116, 105, 99, 97, 108, 66, 97, 114, 59, 32768, 8742, 768, 108, 113, 120, 3319, 3327, 3345, 101, 109, 101, 110, 116, 59, 32768, 8713, 117, 97, 108, 512, 59, 84, 3335, 3337, 32768, 8800, 105, 108, 100, 101, 59, 32896, 8770, 824, 105, 115, 116, 115, 59, 32768, 8708, 114, 101, 97, 116, 101, 114, 1792, 59, 69, 70, 71, 76, 83, 84, 3373, 3375, 3382, 3394, 3404, 3410, 3423, 32768, 8815, 113, 117, 97, 108, 59, 32768, 8817, 117, 108, 108, 69, 113, 117, 97, 108, 59, 32896, 8807, 824, 114, 101, 97, 116, 101, 114, 59, 32896, 8811, 824, 101, 115, 115, 59, 32768, 8825, 108, 97, 110, 116, 69, 113, 117, 97, 108, 59, 32896, 10878, 824, 105, 108, 100, 101, 59, 32768, 8821, 117, 109, 112, 533, 3437, 3448, 111, 119, 110, 72, 117, 109, 112, 59, 32896, 8782, 824, 113, 117, 97, 108, 59, 32896, 8783, 824, 101, 512, 102, 115, 3461, 3492, 116, 84, 114, 105, 97, 110, 103, 108, 101, 768, 59, 66, 69, 3477, 3479, 3485, 32768, 8938, 97, 114, 59, 32896, 10703, 824, 113, 117, 97, 108, 59, 32768, 8940, 115, 1536, 59, 69, 71, 76, 83, 84, 3506, 3508, 3515, 3524, 3531, 3544, 32768, 8814, 113, 117, 97, 108, 59, 32768, 8816, 114, 101, 97, 116, 101, 114, 59, 32768, 8824, 101, 115, 115, 59, 32896, 8810, 824, 108, 97, 110, 116, 69, 113, 117, 97, 108, 59, 32896, 10877, 824, 105, 108, 100, 101, 59, 32768, 8820, 101, 115, 116, 101, 100, 512, 71, 76, 3561, 3578, 114, 101, 97, 116, 101, 114, 71, 114, 101, 97, 116, 101, 114, 59, 32896, 10914, 824, 101, 115, 115, 76, 101, 115, 115, 59, 32896, 10913, 824, 114, 101, 99, 101, 100, 101, 115, 768, 59, 69, 83, 3603, 3605, 3613, 32768, 8832, 113, 117, 97, 108, 59, 32896, 10927, 824, 108, 97, 110, 116, 69, 113, 117, 97, 108, 59, 32768, 8928, 512, 101, 105, 3630, 3645, 118, 101, 114, 115, 101, 69, 108, 101, 109, 101, 110, 116, 59, 32768, 8716, 103, 104, 116, 84, 114, 105, 97, 110, 103, 108, 101, 768, 59, 66, 69, 3663, 3665, 3671, 32768, 8939, 97, 114, 59, 32896, 10704, 824, 113, 117, 97, 108, 59, 32768, 8941, 512, 113, 117, 3683, 3732, 117, 97, 114, 101, 83, 117, 512, 98, 112, 3694, 3712, 115, 101, 116, 512, 59, 69, 3702, 3705, 32896, 8847, 824, 113, 117, 97, 108, 59, 32768, 8930, 101, 114, 115, 101, 116, 512, 59, 69, 3722, 3725, 32896, 8848, 824, 113, 117, 97, 108, 59, 32768, 8931, 768, 98, 99, 112, 3739, 3757, 3801, 115, 101, 116, 512, 59, 69, 3747, 3750, 32896, 8834, 8402, 113, 117, 97, 108, 59, 32768, 8840, 99, 101, 101, 100, 115, 1024, 59, 69, 83, 84, 3771, 3773, 3781, 3793, 32768, 8833, 113, 117, 97, 108, 59, 32896, 10928, 824, 108, 97, 110, 116, 69, 113, 117, 97, 108, 59, 32768, 8929, 105, 108, 100, 101, 59, 32896, 8831, 824, 101, 114, 115, 101, 116, 512, 59, 69, 3811, 3814, 32896, 8835, 8402, 113, 117, 97, 108, 59, 32768, 8841, 105, 108, 100, 101, 1024, 59, 69, 70, 84, 3834, 3836, 3843, 3854, 32768, 8769, 113, 117, 97, 108, 59, 32768, 8772, 117, 108, 108, 69, 113, 117, 97, 108, 59, 32768, 8775, 105, 108, 100, 101, 59, 32768, 8777, 101, 114, 116, 105, 99, 97, 108, 66, 97, 114, 59, 32768, 8740, 99, 114, 59, 32896, 55349, 56489, 105, 108, 100, 101, 33024, 209, 59, 32768, 209, 59, 32768, 925, 3584, 69, 97, 99, 100, 102, 103, 109, 111, 112, 114, 115, 116, 117, 118, 3921, 3927, 3936, 3951, 3958, 3963, 3972, 3996, 4002, 4034, 4037, 4055, 4071, 4078, 108, 105, 103, 59, 32768, 338, 99, 117, 116, 101, 33024, 211, 59, 32768, 211, 512, 105, 121, 3941, 3948, 114, 99, 33024, 212, 59, 32768, 212, 59, 32768, 1054, 98, 108, 97, 99, 59, 32768, 336, 114, 59, 32896, 55349, 56594, 114, 97, 118, 101, 33024, 210, 59, 32768, 210, 768, 97, 101, 105, 3979, 3984, 3989, 99, 114, 59, 32768, 332, 103, 97, 59, 32768, 937, 99, 114, 111, 110, 59, 32768, 927, 112, 102, 59, 32896, 55349, 56646, 101, 110, 67, 117, 114, 108, 121, 512, 68, 81, 4014, 4027, 111, 117, 98, 108, 101, 81, 117, 111, 116, 101, 59, 32768, 8220, 117, 111, 116, 101, 59, 32768, 8216, 59, 32768, 10836, 512, 99, 108, 4042, 4047, 114, 59, 32896, 55349, 56490, 97, 115, 104, 33024, 216, 59, 32768, 216, 105, 573, 4060, 4067, 100, 101, 33024, 213, 59, 32768, 213, 101, 115, 59, 32768, 10807, 109, 108, 33024, 214, 59, 32768, 214, 101, 114, 512, 66, 80, 4085, 4109, 512, 97, 114, 4090, 4094, 114, 59, 32768, 8254, 97, 99, 512, 101, 107, 4101, 4104, 59, 32768, 9182, 101, 116, 59, 32768, 9140, 97, 114, 101, 110, 116, 104, 101, 115, 105, 115, 59, 32768, 9180, 2304, 97, 99, 102, 104, 105, 108, 111, 114, 115, 4141, 4150, 4154, 4159, 4163, 4166, 4176, 4198, 4284, 114, 116, 105, 97, 108, 68, 59, 32768, 8706, 121, 59, 32768, 1055, 114, 59, 32896, 55349, 56595, 105, 59, 32768, 934, 59, 32768, 928, 117, 115, 77, 105, 110, 117, 115, 59, 32768, 177, 512, 105, 112, 4181, 4194, 110, 99, 97, 114, 101, 112, 108, 97, 110, 101, 59, 32768, 8460, 102, 59, 32768, 8473, 1024, 59, 101, 105, 111, 4207, 4209, 4251, 4256, 32768, 10939, 99, 101, 100, 101, 115, 1024, 59, 69, 83, 84, 4223, 4225, 4232, 4244, 32768, 8826, 113, 117, 97, 108, 59, 32768, 10927, 108, 97, 110, 116, 69, 113, 117, 97, 108, 59, 32768, 8828, 105, 108, 100, 101, 59, 32768, 8830, 109, 101, 59, 32768, 8243, 512, 100, 112, 4261, 4267, 117, 99, 116, 59, 32768, 8719, 111, 114, 116, 105, 111, 110, 512, 59, 97, 4278, 4280, 32768, 8759, 108, 59, 32768, 8733, 512, 99, 105, 4289, 4294, 114, 59, 32896, 55349, 56491, 59, 32768, 936, 1024, 85, 102, 111, 115, 4306, 4313, 4318, 4323, 79, 84, 33024, 34, 59, 32768, 34, 114, 59, 32896, 55349, 56596, 112, 102, 59, 32768, 8474, 99, 114, 59, 32896, 55349, 56492, 3072, 66, 69, 97, 99, 101, 102, 104, 105, 111, 114, 115, 117, 4354, 4360, 4366, 4395, 4417, 4473, 4477, 4481, 4743, 4764, 4776, 4788, 97, 114, 114, 59, 32768, 10512, 71, 33024, 174, 59, 32768, 174, 768, 99, 110, 114, 4373, 4379, 4383, 117, 116, 101, 59, 32768, 340, 103, 59, 32768, 10219, 114, 512, 59, 116, 4389, 4391, 32768, 8608, 108, 59, 32768, 10518, 768, 97, 101, 121, 4402, 4408, 4414, 114, 111, 110, 59, 32768, 344, 100, 105, 108, 59, 32768, 342, 59, 32768, 1056, 512, 59, 118, 4422, 4424, 32768, 8476, 101, 114, 115, 101, 512, 69, 85, 4433, 4458, 512, 108, 113, 4438, 4446, 101, 109, 101, 110, 116, 59, 32768, 8715, 117, 105, 108, 105, 98, 114, 105, 117, 109, 59, 32768, 8651, 112, 69, 113, 117, 105, 108, 105, 98, 114, 105, 117, 109, 59, 32768, 10607, 114, 59, 32768, 8476, 111, 59, 32768, 929, 103, 104, 116, 2048, 65, 67, 68, 70, 84, 85, 86, 97, 4501, 4547, 4556, 4607, 4614, 4671, 4719, 4736, 512, 110, 114, 4506, 4519, 103, 108, 101, 66, 114, 97, 99, 107, 101, 116, 59, 32768, 10217, 114, 111, 119, 768, 59, 66, 76, 4529, 4531, 4536, 32768, 8594, 97, 114, 59, 32768, 8677, 101, 102, 116, 65, 114, 114, 111, 119, 59, 32768, 8644, 101, 105, 108, 105, 110, 103, 59, 32768, 8969, 111, 838, 4562, 0, 4575, 98, 108, 101, 66, 114, 97, 99, 107, 101, 116, 59, 32768, 10215, 110, 805, 4580, 0, 4591, 101, 101, 86, 101, 99, 116, 111, 114, 59, 32768, 10589, 101, 99, 116, 111, 114, 512, 59, 66, 4600, 4602, 32768, 8642, 97, 114, 59, 32768, 10581, 108, 111, 111, 114, 59, 32768, 8971, 512, 101, 114, 4619, 4644, 101, 768, 59, 65, 86, 4627, 4629, 4636, 32768, 8866, 114, 114, 111, 119, 59, 32768, 8614, 101, 99, 116, 111, 114, 59, 32768, 10587, 105, 97, 110, 103, 108, 101, 768, 59, 66, 69, 4657, 4659, 4664, 32768, 8883, 97, 114, 59, 32768, 10704, 113, 117, 97, 108, 59, 32768, 8885, 112, 768, 68, 84, 86, 4679, 4691, 4702, 111, 119, 110, 86, 101, 99, 116, 111, 114, 59, 32768, 10575, 101, 101, 86, 101, 99, 116, 111, 114, 59, 32768, 10588, 101, 99, 116, 111, 114, 512, 59, 66, 4712, 4714, 32768, 8638, 97, 114, 59, 32768, 10580, 101, 99, 116, 111, 114, 512, 59, 66, 4729, 4731, 32768, 8640, 97, 114, 59, 32768, 10579, 114, 114, 111, 119, 59, 32768, 8658, 512, 112, 117, 4748, 4752, 102, 59, 32768, 8477, 110, 100, 73, 109, 112, 108, 105, 101, 115, 59, 32768, 10608, 105, 103, 104, 116, 97, 114, 114, 111, 119, 59, 32768, 8667, 512, 99, 104, 4781, 4785, 114, 59, 32768, 8475, 59, 32768, 8625, 108, 101, 68, 101, 108, 97, 121, 101, 100, 59, 32768, 10740, 3328, 72, 79, 97, 99, 102, 104, 105, 109, 111, 113, 115, 116, 117, 4827, 4842, 4849, 4856, 4889, 4894, 4949, 4955, 4967, 4973, 5059, 5065, 5070, 512, 67, 99, 4832, 4838, 72, 99, 121, 59, 32768, 1065, 121, 59, 32768, 1064, 70, 84, 99, 121, 59, 32768, 1068, 99, 117, 116, 101, 59, 32768, 346, 1280, 59, 97, 101, 105, 121, 4867, 4869, 4875, 4881, 4886, 32768, 10940, 114, 111, 110, 59, 32768, 352, 100, 105, 108, 59, 32768, 350, 114, 99, 59, 32768, 348, 59, 32768, 1057, 114, 59, 32896, 55349, 56598, 111, 114, 116, 1024, 68, 76, 82, 85, 4906, 4917, 4928, 4940, 111, 119, 110, 65, 114, 114, 111, 119, 59, 32768, 8595, 101, 102, 116, 65, 114, 114, 111, 119, 59, 32768, 8592, 105, 103, 104, 116, 65, 114, 114, 111, 119, 59, 32768, 8594, 112, 65, 114, 114, 111, 119, 59, 32768, 8593, 103, 109, 97, 59, 32768, 931, 97, 108, 108, 67, 105, 114, 99, 108, 101, 59, 32768, 8728, 112, 102, 59, 32896, 55349, 56650, 1091, 4979, 0, 0, 4983, 116, 59, 32768, 8730, 97, 114, 101, 1024, 59, 73, 83, 85, 4994, 4996, 5010, 5052, 32768, 9633, 110, 116, 101, 114, 115, 101, 99, 116, 105, 111, 110, 59, 32768, 8851, 117, 512, 98, 112, 5016, 5033, 115, 101, 116, 512, 59, 69, 5024, 5026, 32768, 8847, 113, 117, 97, 108, 59, 32768, 8849, 101, 114, 115, 101, 116, 512, 59, 69, 5043, 5045, 32768, 8848, 113, 117, 97, 108, 59, 32768, 8850, 110, 105, 111, 110, 59, 32768, 8852, 99, 114, 59, 32896, 55349, 56494, 97, 114, 59, 32768, 8902, 1024, 98, 99, 109, 112, 5079, 5102, 5155, 5158, 512, 59, 115, 5084, 5086, 32768, 8912, 101, 116, 512, 59, 69, 5093, 5095, 32768, 8912, 113, 117, 97, 108, 59, 32768, 8838, 512, 99, 104, 5107, 5148, 101, 101, 100, 115, 1024, 59, 69, 83, 84, 5120, 5122, 5129, 5141, 32768, 8827, 113, 117, 97, 108, 59, 32768, 10928, 108, 97, 110, 116, 69, 113, 117, 97, 108, 59, 32768, 8829, 105, 108, 100, 101, 59, 32768, 8831, 84, 104, 97, 116, 59, 32768, 8715, 59, 32768, 8721, 768, 59, 101, 115, 5165, 5167, 5185, 32768, 8913, 114, 115, 101, 116, 512, 59, 69, 5176, 5178, 32768, 8835, 113, 117, 97, 108, 59, 32768, 8839, 101, 116, 59, 32768, 8913, 2816, 72, 82, 83, 97, 99, 102, 104, 105, 111, 114, 115, 5213, 5221, 5227, 5241, 5252, 5274, 5279, 5323, 5362, 5368, 5378, 79, 82, 78, 33024, 222, 59, 32768, 222, 65, 68, 69, 59, 32768, 8482, 512, 72, 99, 5232, 5237, 99, 121, 59, 32768, 1035, 121, 59, 32768, 1062, 512, 98, 117, 5246, 5249, 59, 32768, 9, 59, 32768, 932, 768, 97, 101, 121, 5259, 5265, 5271, 114, 111, 110, 59, 32768, 356, 100, 105, 108, 59, 32768, 354, 59, 32768, 1058, 114, 59, 32896, 55349, 56599, 512, 101, 105, 5284, 5300, 835, 5289, 0, 5297, 101, 102, 111, 114, 101, 59, 32768, 8756, 97, 59, 32768, 920, 512, 99, 110, 5305, 5315, 107, 83, 112, 97, 99, 101, 59, 32896, 8287, 8202, 83, 112, 97, 99, 101, 59, 32768, 8201, 108, 100, 101, 1024, 59, 69, 70, 84, 5335, 5337, 5344, 5355, 32768, 8764, 113, 117, 97, 108, 59, 32768, 8771, 117, 108, 108, 69, 113, 117, 97, 108, 59, 32768, 8773, 105, 108, 100, 101, 59, 32768, 8776, 112, 102, 59, 32896, 55349, 56651, 105, 112, 108, 101, 68, 111, 116, 59, 32768, 8411, 512, 99, 116, 5383, 5388, 114, 59, 32896, 55349, 56495, 114, 111, 107, 59, 32768, 358, 5426, 5417, 5444, 5458, 5473, 0, 5480, 5485, 0, 0, 0, 0, 0, 5494, 5500, 5564, 5579, 0, 5726, 5732, 5738, 5745, 512, 99, 114, 5421, 5429, 117, 116, 101, 33024, 218, 59, 32768, 218, 114, 512, 59, 111, 5435, 5437, 32768, 8607, 99, 105, 114, 59, 32768, 10569, 114, 820, 5449, 0, 5453, 121, 59, 32768, 1038, 118, 101, 59, 32768, 364, 512, 105, 121, 5462, 5469, 114, 99, 33024, 219, 59, 32768, 219, 59, 32768, 1059, 98, 108, 97, 99, 59, 32768, 368, 114, 59, 32896, 55349, 56600, 114, 97, 118, 101, 33024, 217, 59, 32768, 217, 97, 99, 114, 59, 32768, 362, 512, 100, 105, 5504, 5548, 101, 114, 512, 66, 80, 5511, 5535, 512, 97, 114, 5516, 5520, 114, 59, 32768, 95, 97, 99, 512, 101, 107, 5527, 5530, 59, 32768, 9183, 101, 116, 59, 32768, 9141, 97, 114, 101, 110, 116, 104, 101, 115, 105, 115, 59, 32768, 9181, 111, 110, 512, 59, 80, 5555, 5557, 32768, 8899, 108, 117, 115, 59, 32768, 8846, 512, 103, 112, 5568, 5573, 111, 110, 59, 32768, 370, 102, 59, 32896, 55349, 56652, 2048, 65, 68, 69, 84, 97, 100, 112, 115, 5595, 5624, 5635, 5648, 5664, 5671, 5682, 5712, 114, 114, 111, 119, 768, 59, 66, 68, 5606, 5608, 5613, 32768, 8593, 97, 114, 59, 32768, 10514, 111, 119, 110, 65, 114, 114, 111, 119, 59, 32768, 8645, 111, 119, 110, 65, 114, 114, 111, 119, 59, 32768, 8597, 113, 117, 105, 108, 105, 98, 114, 105, 117, 109, 59, 32768, 10606, 101, 101, 512, 59, 65, 5655, 5657, 32768, 8869, 114, 114, 111, 119, 59, 32768, 8613, 114, 114, 111, 119, 59, 32768, 8657, 111, 119, 110, 97, 114, 114, 111, 119, 59, 32768, 8661, 101, 114, 512, 76, 82, 5689, 5700, 101, 102, 116, 65, 114, 114, 111, 119, 59, 32768, 8598, 105, 103, 104, 116, 65, 114, 114, 111, 119, 59, 32768, 8599, 105, 512, 59, 108, 5718, 5720, 32768, 978, 111, 110, 59, 32768, 933, 105, 110, 103, 59, 32768, 366, 99, 114, 59, 32896, 55349, 56496, 105, 108, 100, 101, 59, 32768, 360, 109, 108, 33024, 220, 59, 32768, 220, 2304, 68, 98, 99, 100, 101, 102, 111, 115, 118, 5770, 5776, 5781, 5785, 5798, 5878, 5883, 5889, 5895, 97, 115, 104, 59, 32768, 8875, 97, 114, 59, 32768, 10987, 121, 59, 32768, 1042, 97, 115, 104, 512, 59, 108, 5793, 5795, 32768, 8873, 59, 32768, 10982, 512, 101, 114, 5803, 5806, 59, 32768, 8897, 768, 98, 116, 121, 5813, 5818, 5866, 97, 114, 59, 32768, 8214, 512, 59, 105, 5823, 5825, 32768, 8214, 99, 97, 108, 1024, 66, 76, 83, 84, 5837, 5842, 5848, 5859, 97, 114, 59, 32768, 8739, 105, 110, 101, 59, 32768, 124, 101, 112, 97, 114, 97, 116, 111, 114, 59, 32768, 10072, 105, 108, 100, 101, 59, 32768, 8768, 84, 104, 105, 110, 83, 112, 97, 99, 101, 59, 32768, 8202, 114, 59, 32896, 55349, 56601, 112, 102, 59, 32896, 55349, 56653, 99, 114, 59, 32896, 55349, 56497, 100, 97, 115, 104, 59, 32768, 8874, 1280, 99, 101, 102, 111, 115, 5913, 5919, 5925, 5930, 5936, 105, 114, 99, 59, 32768, 372, 100, 103, 101, 59, 32768, 8896, 114, 59, 32896, 55349, 56602, 112, 102, 59, 32896, 55349, 56654, 99, 114, 59, 32896, 55349, 56498, 1024, 102, 105, 111, 115, 5951, 5956, 5959, 5965, 114, 59, 32896, 55349, 56603, 59, 32768, 926, 112, 102, 59, 32896, 55349, 56655, 99, 114, 59, 32896, 55349, 56499, 2304, 65, 73, 85, 97, 99, 102, 111, 115, 117, 5990, 5995, 6000, 6005, 6014, 6027, 6032, 6038, 6044, 99, 121, 59, 32768, 1071, 99, 121, 59, 32768, 1031, 99, 121, 59, 32768, 1070, 99, 117, 116, 101, 33024, 221, 59, 32768, 221, 512, 105, 121, 6019, 6024, 114, 99, 59, 32768, 374, 59, 32768, 1067, 114, 59, 32896, 55349, 56604, 112, 102, 59, 32896, 55349, 56656, 99, 114, 59, 32896, 55349, 56500, 109, 108, 59, 32768, 376, 2048, 72, 97, 99, 100, 101, 102, 111, 115, 6066, 6071, 6078, 6092, 6097, 6119, 6123, 6128, 99, 121, 59, 32768, 1046, 99, 117, 116, 101, 59, 32768, 377, 512, 97, 121, 6083, 6089, 114, 111, 110, 59, 32768, 381, 59, 32768, 1047, 111, 116, 59, 32768, 379, 835, 6102, 0, 6116, 111, 87, 105, 100, 116, 104, 83, 112, 97, 99, 101, 59, 32768, 8203, 97, 59, 32768, 918, 114, 59, 32768, 8488, 112, 102, 59, 32768, 8484, 99, 114, 59, 32896, 55349, 56501, 5938, 6159, 6168, 6175, 0, 6214, 6222, 6233, 0, 0, 0, 0, 6242, 6267, 6290, 6429, 6444, 0, 6495, 6503, 6531, 6540, 0, 6547, 99, 117, 116, 101, 33024, 225, 59, 32768, 225, 114, 101, 118, 101, 59, 32768, 259, 1536, 59, 69, 100, 105, 117, 121, 6187, 6189, 6193, 6196, 6203, 6210, 32768, 8766, 59, 32896, 8766, 819, 59, 32768, 8767, 114, 99, 33024, 226, 59, 32768, 226, 116, 101, 33024, 180, 59, 32768, 180, 59, 32768, 1072, 108, 105, 103, 33024, 230, 59, 32768, 230, 512, 59, 114, 6226, 6228, 32768, 8289, 59, 32896, 55349, 56606, 114, 97, 118, 101, 33024, 224, 59, 32768, 224, 512, 101, 112, 6246, 6261, 512, 102, 112, 6251, 6257, 115, 121, 109, 59, 32768, 8501, 104, 59, 32768, 8501, 104, 97, 59, 32768, 945, 512, 97, 112, 6271, 6284, 512, 99, 108, 6276, 6280, 114, 59, 32768, 257, 103, 59, 32768, 10815, 33024, 38, 59, 32768, 38, 1077, 6295, 0, 0, 6326, 1280, 59, 97, 100, 115, 118, 6305, 6307, 6312, 6315, 6322, 32768, 8743, 110, 100, 59, 32768, 10837, 59, 32768, 10844, 108, 111, 112, 101, 59, 32768, 10840, 59, 32768, 10842, 1792, 59, 101, 108, 109, 114, 115, 122, 6340, 6342, 6345, 6349, 6391, 6410, 6422, 32768, 8736, 59, 32768, 10660, 101, 59, 32768, 8736, 115, 100, 512, 59, 97, 6356, 6358, 32768, 8737, 2098, 6368, 6371, 6374, 6377, 6380, 6383, 6386, 6389, 59, 32768, 10664, 59, 32768, 10665, 59, 32768, 10666, 59, 32768, 10667, 59, 32768, 10668, 59, 32768, 10669, 59, 32768, 10670, 59, 32768, 10671, 116, 512, 59, 118, 6397, 6399, 32768, 8735, 98, 512, 59, 100, 6405, 6407, 32768, 8894, 59, 32768, 10653, 512, 112, 116, 6415, 6419, 104, 59, 32768, 8738, 59, 32768, 197, 97, 114, 114, 59, 32768, 9084, 512, 103, 112, 6433, 6438, 111, 110, 59, 32768, 261, 102, 59, 32896, 55349, 56658, 1792, 59, 69, 97, 101, 105, 111, 112, 6458, 6460, 6463, 6469, 6472, 6476, 6480, 32768, 8776, 59, 32768, 10864, 99, 105, 114, 59, 32768, 10863, 59, 32768, 8778, 100, 59, 32768, 8779, 115, 59, 32768, 39, 114, 111, 120, 512, 59, 101, 6488, 6490, 32768, 8776, 113, 59, 32768, 8778, 105, 110, 103, 33024, 229, 59, 32768, 229, 768, 99, 116, 121, 6509, 6514, 6517, 114, 59, 32896, 55349, 56502, 59, 32768, 42, 109, 112, 512, 59, 101, 6524, 6526, 32768, 8776, 113, 59, 32768, 8781, 105, 108, 100, 101, 33024, 227, 59, 32768, 227, 109, 108, 33024, 228, 59, 32768, 228, 512, 99, 105, 6551, 6559, 111, 110, 105, 110, 116, 59, 32768, 8755, 110, 116, 59, 32768, 10769, 4096, 78, 97, 98, 99, 100, 101, 102, 105, 107, 108, 110, 111, 112, 114, 115, 117, 6597, 6602, 6673, 6688, 6701, 6707, 6768, 6773, 6891, 6898, 6999, 7023, 7309, 7316, 7334, 7383, 111, 116, 59, 32768, 10989, 512, 99, 114, 6607, 6652, 107, 1024, 99, 101, 112, 115, 6617, 6623, 6632, 6639, 111, 110, 103, 59, 32768, 8780, 112, 115, 105, 108, 111, 110, 59, 32768, 1014, 114, 105, 109, 101, 59, 32768, 8245, 105, 109, 512, 59, 101, 6646, 6648, 32768, 8765, 113, 59, 32768, 8909, 583, 6656, 6661, 101, 101, 59, 32768, 8893, 101, 100, 512, 59, 103, 6667, 6669, 32768, 8965, 101, 59, 32768, 8965, 114, 107, 512, 59, 116, 6680, 6682, 32768, 9141, 98, 114, 107, 59, 32768, 9142, 512, 111, 121, 6693, 6698, 110, 103, 59, 32768, 8780, 59, 32768, 1073, 113, 117, 111, 59, 32768, 8222, 1280, 99, 109, 112, 114, 116, 6718, 6731, 6738, 6743, 6749, 97, 117, 115, 512, 59, 101, 6726, 6728, 32768, 8757, 59, 32768, 8757, 112, 116, 121, 118, 59, 32768, 10672, 115, 105, 59, 32768, 1014, 110, 111, 117, 59, 32768, 8492, 768, 97, 104, 119, 6756, 6759, 6762, 59, 32768, 946, 59, 32768, 8502, 101, 101, 110, 59, 32768, 8812, 114, 59, 32896, 55349, 56607, 103, 1792, 99, 111, 115, 116, 117, 118, 119, 6789, 6809, 6834, 6850, 6872, 6879, 6884, 768, 97, 105, 117, 6796, 6800, 6805, 112, 59, 32768, 8898, 114, 99, 59, 32768, 9711, 112, 59, 32768, 8899, 768, 100, 112, 116, 6816, 6821, 6827, 111, 116, 59, 32768, 10752, 108, 117, 115, 59, 32768, 10753, 105, 109, 101, 115, 59, 32768, 10754, 1090, 6840, 0, 0, 6846, 99, 117, 112, 59, 32768, 10758, 97, 114, 59, 32768, 9733, 114, 105, 97, 110, 103, 108, 101, 512, 100, 117, 6862, 6868, 111, 119, 110, 59, 32768, 9661, 112, 59, 32768, 9651, 112, 108, 117, 115, 59, 32768, 10756, 101, 101, 59, 32768, 8897, 101, 100, 103, 101, 59, 32768, 8896, 97, 114, 111, 119, 59, 32768, 10509, 768, 97, 107, 111, 6905, 6976, 6994, 512, 99, 110, 6910, 6972, 107, 768, 108, 115, 116, 6918, 6927, 6935, 111, 122, 101, 110, 103, 101, 59, 32768, 10731, 113, 117, 97, 114, 101, 59, 32768, 9642, 114, 105, 97, 110, 103, 108, 101, 1024, 59, 100, 108, 114, 6951, 6953, 6959, 6965, 32768, 9652, 111, 119, 110, 59, 32768, 9662, 101, 102, 116, 59, 32768, 9666, 105, 103, 104, 116, 59, 32768, 9656, 107, 59, 32768, 9251, 770, 6981, 0, 6991, 771, 6985, 0, 6988, 59, 32768, 9618, 59, 32768, 9617, 52, 59, 32768, 9619, 99, 107, 59, 32768, 9608, 512, 101, 111, 7004, 7019, 512, 59, 113, 7009, 7012, 32896, 61, 8421, 117, 105, 118, 59, 32896, 8801, 8421, 116, 59, 32768, 8976, 1024, 112, 116, 119, 120, 7032, 7037, 7049, 7055, 102, 59, 32896, 55349, 56659, 512, 59, 116, 7042, 7044, 32768, 8869, 111, 109, 59, 32768, 8869, 116, 105, 101, 59, 32768, 8904, 3072, 68, 72, 85, 86, 98, 100, 104, 109, 112, 116, 117, 118, 7080, 7101, 7126, 7147, 7182, 7187, 7208, 7233, 7240, 7246, 7253, 7274, 1024, 76, 82, 108, 114, 7089, 7092, 7095, 7098, 59, 32768, 9559, 59, 32768, 9556, 59, 32768, 9558, 59, 32768, 9555, 1280, 59, 68, 85, 100, 117, 7112, 7114, 7117, 7120, 7123, 32768, 9552, 59, 32768, 9574, 59, 32768, 9577, 59, 32768, 9572, 59, 32768, 9575, 1024, 76, 82, 108, 114, 7135, 7138, 7141, 7144, 59, 32768, 9565, 59, 32768, 9562, 59, 32768, 9564, 59, 32768, 9561, 1792, 59, 72, 76, 82, 104, 108, 114, 7162, 7164, 7167, 7170, 7173, 7176, 7179, 32768, 9553, 59, 32768, 9580, 59, 32768, 9571, 59, 32768, 9568, 59, 32768, 9579, 59, 32768, 9570, 59, 32768, 9567, 111, 120, 59, 32768, 10697, 1024, 76, 82, 108, 114, 7196, 7199, 7202, 7205, 59, 32768, 9557, 59, 32768, 9554, 59, 32768, 9488, 59, 32768, 9484, 1280, 59, 68, 85, 100, 117, 7219, 7221, 7224, 7227, 7230, 32768, 9472, 59, 32768, 9573, 59, 32768, 9576, 59, 32768, 9516, 59, 32768, 9524, 105, 110, 117, 115, 59, 32768, 8863, 108, 117, 115, 59, 32768, 8862, 105, 109, 101, 115, 59, 32768, 8864, 1024, 76, 82, 108, 114, 7262, 7265, 7268, 7271, 59, 32768, 9563, 59, 32768, 9560, 59, 32768, 9496, 59, 32768, 9492, 1792, 59, 72, 76, 82, 104, 108, 114, 7289, 7291, 7294, 7297, 7300, 7303, 7306, 32768, 9474, 59, 32768, 9578, 59, 32768, 9569, 59, 32768, 9566, 59, 32768, 9532, 59, 32768, 9508, 59, 32768, 9500, 114, 105, 109, 101, 59, 32768, 8245, 512, 101, 118, 7321, 7326, 118, 101, 59, 32768, 728, 98, 97, 114, 33024, 166, 59, 32768, 166, 1024, 99, 101, 105, 111, 7343, 7348, 7353, 7364, 114, 59, 32896, 55349, 56503, 109, 105, 59, 32768, 8271, 109, 512, 59, 101, 7359, 7361, 32768, 8765, 59, 32768, 8909, 108, 768, 59, 98, 104, 7372, 7374, 7377, 32768, 92, 59, 32768, 10693, 115, 117, 98, 59, 32768, 10184, 573, 7387, 7399, 108, 512, 59, 101, 7392, 7394, 32768, 8226, 116, 59, 32768, 8226, 112, 768, 59, 69, 101, 7406, 7408, 7411, 32768, 8782, 59, 32768, 10926, 512, 59, 113, 7416, 7418, 32768, 8783, 59, 32768, 8783, 6450, 7448, 0, 7523, 7571, 7576, 7613, 0, 7618, 7647, 0, 0, 7764, 0, 0, 7779, 0, 0, 7899, 7914, 7949, 7955, 0, 8158, 0, 8176, 768, 99, 112, 114, 7454, 7460, 7509, 117, 116, 101, 59, 32768, 263, 1536, 59, 97, 98, 99, 100, 115, 7473, 7475, 7480, 7487, 7500, 7505, 32768, 8745, 110, 100, 59, 32768, 10820, 114, 99, 117, 112, 59, 32768, 10825, 512, 97, 117, 7492, 7496, 112, 59, 32768, 10827, 112, 59, 32768, 10823, 111, 116, 59, 32768, 10816, 59, 32896, 8745, 65024, 512, 101, 111, 7514, 7518, 116, 59, 32768, 8257, 110, 59, 32768, 711, 1024, 97, 101, 105, 117, 7531, 7544, 7552, 7557, 833, 7536, 0, 7540, 115, 59, 32768, 10829, 111, 110, 59, 32768, 269, 100, 105, 108, 33024, 231, 59, 32768, 231, 114, 99, 59, 32768, 265, 112, 115, 512, 59, 115, 7564, 7566, 32768, 10828, 109, 59, 32768, 10832, 111, 116, 59, 32768, 267, 768, 100, 109, 110, 7582, 7589, 7596, 105, 108, 33024, 184, 59, 32768, 184, 112, 116, 121, 118, 59, 32768, 10674, 116, 33280, 162, 59, 101, 7603, 7605, 32768, 162, 114, 100, 111, 116, 59, 32768, 183, 114, 59, 32896, 55349, 56608, 768, 99, 101, 105, 7624, 7628, 7643, 121, 59, 32768, 1095, 99, 107, 512, 59, 109, 7635, 7637, 32768, 10003, 97, 114, 107, 59, 32768, 10003, 59, 32768, 967, 114, 1792, 59, 69, 99, 101, 102, 109, 115, 7662, 7664, 7667, 7742, 7745, 7752, 7757, 32768, 9675, 59, 32768, 10691, 768, 59, 101, 108, 7674, 7676, 7680, 32768, 710, 113, 59, 32768, 8791, 101, 1074, 7687, 0, 0, 7709, 114, 114, 111, 119, 512, 108, 114, 7695, 7701, 101, 102, 116, 59, 32768, 8634, 105, 103, 104, 116, 59, 32768, 8635, 1280, 82, 83, 97, 99, 100, 7719, 7722, 7725, 7730, 7736, 59, 32768, 174, 59, 32768, 9416, 115, 116, 59, 32768, 8859, 105, 114, 99, 59, 32768, 8858, 97, 115, 104, 59, 32768, 8861, 59, 32768, 8791, 110, 105, 110, 116, 59, 32768, 10768, 105, 100, 59, 32768, 10991, 99, 105, 114, 59, 32768, 10690, 117, 98, 115, 512, 59, 117, 7771, 7773, 32768, 9827, 105, 116, 59, 32768, 9827, 1341, 7785, 7804, 7850, 0, 7871, 111, 110, 512, 59, 101, 7791, 7793, 32768, 58, 512, 59, 113, 7798, 7800, 32768, 8788, 59, 32768, 8788, 1086, 7809, 0, 0, 7820, 97, 512, 59, 116, 7814, 7816, 32768, 44, 59, 32768, 64, 768, 59, 102, 108, 7826, 7828, 7832, 32768, 8705, 110, 59, 32768, 8728, 101, 512, 109, 120, 7838, 7844, 101, 110, 116, 59, 32768, 8705, 101, 115, 59, 32768, 8450, 824, 7854, 0, 7866, 512, 59, 100, 7858, 7860, 32768, 8773, 111, 116, 59, 32768, 10861, 110, 116, 59, 32768, 8750, 768, 102, 114, 121, 7877, 7881, 7886, 59, 32896, 55349, 56660, 111, 100, 59, 32768, 8720, 33280, 169, 59, 115, 7892, 7894, 32768, 169, 114, 59, 32768, 8471, 512, 97, 111, 7903, 7908, 114, 114, 59, 32768, 8629, 115, 115, 59, 32768, 10007, 512, 99, 117, 7918, 7923, 114, 59, 32896, 55349, 56504, 512, 98, 112, 7928, 7938, 512, 59, 101, 7933, 7935, 32768, 10959, 59, 32768, 10961, 512, 59, 101, 7943, 7945, 32768, 10960, 59, 32768, 10962, 100, 111, 116, 59, 32768, 8943, 1792, 100, 101, 108, 112, 114, 118, 119, 7969, 7983, 7996, 8009, 8057, 8147, 8152, 97, 114, 114, 512, 108, 114, 7977, 7980, 59, 32768, 10552, 59, 32768, 10549, 1089, 7989, 0, 0, 7993, 114, 59, 32768, 8926, 99, 59, 32768, 8927, 97, 114, 114, 512, 59, 112, 8004, 8006, 32768, 8630, 59, 32768, 10557, 1536, 59, 98, 99, 100, 111, 115, 8022, 8024, 8031, 8044, 8049, 8053, 32768, 8746, 114, 99, 97, 112, 59, 32768, 10824, 512, 97, 117, 8036, 8040, 112, 59, 32768, 10822, 112, 59, 32768, 10826, 111, 116, 59, 32768, 8845, 114, 59, 32768, 10821, 59, 32896, 8746, 65024, 1024, 97, 108, 114, 118, 8066, 8078, 8116, 8123, 114, 114, 512, 59, 109, 8073, 8075, 32768, 8631, 59, 32768, 10556, 121, 768, 101, 118, 119, 8086, 8104, 8109, 113, 1089, 8093, 0, 0, 8099, 114, 101, 99, 59, 32768, 8926, 117, 99, 99, 59, 32768, 8927, 101, 101, 59, 32768, 8910, 101, 100, 103, 101, 59, 32768, 8911, 101, 110, 33024, 164, 59, 32768, 164, 101, 97, 114, 114, 111, 119, 512, 108, 114, 8134, 8140, 101, 102, 116, 59, 32768, 8630, 105, 103, 104, 116, 59, 32768, 8631, 101, 101, 59, 32768, 8910, 101, 100, 59, 32768, 8911, 512, 99, 105, 8162, 8170, 111, 110, 105, 110, 116, 59, 32768, 8754, 110, 116, 59, 32768, 8753, 108, 99, 116, 121, 59, 32768, 9005, 4864, 65, 72, 97, 98, 99, 100, 101, 102, 104, 105, 106, 108, 111, 114, 115, 116, 117, 119, 122, 8221, 8226, 8231, 8267, 8282, 8296, 8327, 8351, 8366, 8379, 8466, 8471, 8487, 8621, 8647, 8676, 8697, 8712, 8720, 114, 114, 59, 32768, 8659, 97, 114, 59, 32768, 10597, 1024, 103, 108, 114, 115, 8240, 8246, 8252, 8256, 103, 101, 114, 59, 32768, 8224, 101, 116, 104, 59, 32768, 8504, 114, 59, 32768, 8595, 104, 512, 59, 118, 8262, 8264, 32768, 8208, 59, 32768, 8867, 572, 8271, 8278, 97, 114, 111, 119, 59, 32768, 10511, 97, 99, 59, 32768, 733, 512, 97, 121, 8287, 8293, 114, 111, 110, 59, 32768, 271, 59, 32768, 1076, 768, 59, 97, 111, 8303, 8305, 8320, 32768, 8518, 512, 103, 114, 8310, 8316, 103, 101, 114, 59, 32768, 8225, 114, 59, 32768, 8650, 116, 115, 101, 113, 59, 32768, 10871, 768, 103, 108, 109, 8334, 8339, 8344, 33024, 176, 59, 32768, 176, 116, 97, 59, 32768, 948, 112, 116, 121, 118, 59, 32768, 10673, 512, 105, 114, 8356, 8362, 115, 104, 116, 59, 32768, 10623, 59, 32896, 55349, 56609, 97, 114, 512, 108, 114, 8373, 8376, 59, 32768, 8643, 59, 32768, 8642, 1280, 97, 101, 103, 115, 118, 8390, 8418, 8421, 8428, 8433, 109, 768, 59, 111, 115, 8398, 8400, 8415, 32768, 8900, 110, 100, 512, 59, 115, 8407, 8409, 32768, 8900, 117, 105, 116, 59, 32768, 9830, 59, 32768, 9830, 59, 32768, 168, 97, 109, 109, 97, 59, 32768, 989, 105, 110, 59, 32768, 8946, 768, 59, 105, 111, 8440, 8442, 8461, 32768, 247, 100, 101, 33280, 247, 59, 111, 8450, 8452, 32768, 247, 110, 116, 105, 109, 101, 115, 59, 32768, 8903, 110, 120, 59, 32768, 8903, 99, 121, 59, 32768, 1106, 99, 1088, 8478, 0, 0, 8483, 114, 110, 59, 32768, 8990, 111, 112, 59, 32768, 8973, 1280, 108, 112, 116, 117, 119, 8498, 8504, 8509, 8556, 8570, 108, 97, 114, 59, 32768, 36, 102, 59, 32896, 55349, 56661, 1280, 59, 101, 109, 112, 115, 8520, 8522, 8535, 8542, 8548, 32768, 729, 113, 512, 59, 100, 8528, 8530, 32768, 8784, 111, 116, 59, 32768, 8785, 105, 110, 117, 115, 59, 32768, 8760, 108, 117, 115, 59, 32768, 8724, 113, 117, 97, 114, 101, 59, 32768, 8865, 98, 108, 101, 98, 97, 114, 119, 101, 100, 103, 101, 59, 32768, 8966, 110, 768, 97, 100, 104, 8578, 8585, 8597, 114, 114, 111, 119, 59, 32768, 8595, 111, 119, 110, 97, 114, 114, 111, 119, 115, 59, 32768, 8650, 97, 114, 112, 111, 111, 110, 512, 108, 114, 8608, 8614, 101, 102, 116, 59, 32768, 8643, 105, 103, 104, 116, 59, 32768, 8642, 563, 8625, 8633, 107, 97, 114, 111, 119, 59, 32768, 10512, 1088, 8638, 0, 0, 8643, 114, 110, 59, 32768, 8991, 111, 112, 59, 32768, 8972, 768, 99, 111, 116, 8654, 8666, 8670, 512, 114, 121, 8659, 8663, 59, 32896, 55349, 56505, 59, 32768, 1109, 108, 59, 32768, 10742, 114, 111, 107, 59, 32768, 273, 512, 100, 114, 8681, 8686, 111, 116, 59, 32768, 8945, 105, 512, 59, 102, 8692, 8694, 32768, 9663, 59, 32768, 9662, 512, 97, 104, 8702, 8707, 114, 114, 59, 32768, 8693, 97, 114, 59, 32768, 10607, 97, 110, 103, 108, 101, 59, 32768, 10662, 512, 99, 105, 8725, 8729, 121, 59, 32768, 1119, 103, 114, 97, 114, 114, 59, 32768, 10239, 4608, 68, 97, 99, 100, 101, 102, 103, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 120, 8774, 8788, 8807, 8844, 8849, 8852, 8866, 8895, 8929, 8977, 8989, 9004, 9046, 9136, 9151, 9171, 9184, 9199, 512, 68, 111, 8779, 8784, 111, 116, 59, 32768, 10871, 116, 59, 32768, 8785, 512, 99, 115, 8793, 8801, 117, 116, 101, 33024, 233, 59, 32768, 233, 116, 101, 114, 59, 32768, 10862, 1024, 97, 105, 111, 121, 8816, 8822, 8835, 8841, 114, 111, 110, 59, 32768, 283, 114, 512, 59, 99, 8828, 8830, 32768, 8790, 33024, 234, 59, 32768, 234, 108, 111, 110, 59, 32768, 8789, 59, 32768, 1101, 111, 116, 59, 32768, 279, 59, 32768, 8519, 512, 68, 114, 8857, 8862, 111, 116, 59, 32768, 8786, 59, 32896, 55349, 56610, 768, 59, 114, 115, 8873, 8875, 8883, 32768, 10906, 97, 118, 101, 33024, 232, 59, 32768, 232, 512, 59, 100, 8888, 8890, 32768, 10902, 111, 116, 59, 32768, 10904, 1024, 59, 105, 108, 115, 8904, 8906, 8914, 8917, 32768, 10905, 110, 116, 101, 114, 115, 59, 32768, 9191, 59, 32768, 8467, 512, 59, 100, 8922, 8924, 32768, 10901, 111, 116, 59, 32768, 10903, 768, 97, 112, 115, 8936, 8941, 8960, 99, 114, 59, 32768, 275, 116, 121, 768, 59, 115, 118, 8950, 8952, 8957, 32768, 8709, 101, 116, 59, 32768, 8709, 59, 32768, 8709, 112, 512, 49, 59, 8966, 8975, 516, 8970, 8973, 59, 32768, 8196, 59, 32768, 8197, 32768, 8195, 512, 103, 115, 8982, 8985, 59, 32768, 331, 112, 59, 32768, 8194, 512, 103, 112, 8994, 8999, 111, 110, 59, 32768, 281, 102, 59, 32896, 55349, 56662, 768, 97, 108, 115, 9011, 9023, 9028, 114, 512, 59, 115, 9017, 9019, 32768, 8917, 108, 59, 32768, 10723, 117, 115, 59, 32768, 10865, 105, 768, 59, 108, 118, 9036, 9038, 9043, 32768, 949, 111, 110, 59, 32768, 949, 59, 32768, 1013, 1024, 99, 115, 117, 118, 9055, 9071, 9099, 9128, 512, 105, 111, 9060, 9065, 114, 99, 59, 32768, 8790, 108, 111, 110, 59, 32768, 8789, 1082, 9077, 0, 0, 9081, 109, 59, 32768, 8770, 97, 110, 116, 512, 103, 108, 9088, 9093, 116, 114, 59, 32768, 10902, 101, 115, 115, 59, 32768, 10901, 768, 97, 101, 105, 9106, 9111, 9116, 108, 115, 59, 32768, 61, 115, 116, 59, 32768, 8799, 118, 512, 59, 68, 9122, 9124, 32768, 8801, 68, 59, 32768, 10872, 112, 97, 114, 115, 108, 59, 32768, 10725, 512, 68, 97, 9141, 9146, 111, 116, 59, 32768, 8787, 114, 114, 59, 32768, 10609, 768, 99, 100, 105, 9158, 9162, 9167, 114, 59, 32768, 8495, 111, 116, 59, 32768, 8784, 109, 59, 32768, 8770, 512, 97, 104, 9176, 9179, 59, 32768, 951, 33024, 240, 59, 32768, 240, 512, 109, 114, 9189, 9195, 108, 33024, 235, 59, 32768, 235, 111, 59, 32768, 8364, 768, 99, 105, 112, 9206, 9210, 9215, 108, 59, 32768, 33, 115, 116, 59, 32768, 8707, 512, 101, 111, 9220, 9230, 99, 116, 97, 116, 105, 111, 110, 59, 32768, 8496, 110, 101, 110, 116, 105, 97, 108, 101, 59, 32768, 8519, 4914, 9262, 0, 9276, 0, 9280, 9287, 0, 0, 9318, 9324, 0, 9331, 0, 9352, 9357, 9386, 0, 9395, 9497, 108, 108, 105, 110, 103, 100, 111, 116, 115, 101, 113, 59, 32768, 8786, 121, 59, 32768, 1092, 109, 97, 108, 101, 59, 32768, 9792, 768, 105, 108, 114, 9293, 9299, 9313, 108, 105, 103, 59, 32768, 64259, 1082, 9305, 0, 0, 9309, 103, 59, 32768, 64256, 105, 103, 59, 32768, 64260, 59, 32896, 55349, 56611, 108, 105, 103, 59, 32768, 64257, 108, 105, 103, 59, 32896, 102, 106, 768, 97, 108, 116, 9337, 9341, 9346, 116, 59, 32768, 9837, 105, 103, 59, 32768, 64258, 110, 115, 59, 32768, 9649, 111, 102, 59, 32768, 402, 833, 9361, 0, 9366, 102, 59, 32896, 55349, 56663, 512, 97, 107, 9370, 9375, 108, 108, 59, 32768, 8704, 512, 59, 118, 9380, 9382, 32768, 8916, 59, 32768, 10969, 97, 114, 116, 105, 110, 116, 59, 32768, 10765, 512, 97, 111, 9399, 9491, 512, 99, 115, 9404, 9487, 1794, 9413, 9443, 9453, 9470, 9474, 0, 9484, 1795, 9421, 9426, 9429, 9434, 9437, 0, 9440, 33024, 189, 59, 32768, 189, 59, 32768, 8531, 33024, 188, 59, 32768, 188, 59, 32768, 8533, 59, 32768, 8537, 59, 32768, 8539, 772, 9447, 0, 9450, 59, 32768, 8532, 59, 32768, 8534, 1285, 9459, 9464, 0, 0, 9467, 33024, 190, 59, 32768, 190, 59, 32768, 8535, 59, 32768, 8540, 53, 59, 32768, 8536, 775, 9478, 0, 9481, 59, 32768, 8538, 59, 32768, 8541, 56, 59, 32768, 8542, 108, 59, 32768, 8260, 119, 110, 59, 32768, 8994, 99, 114, 59, 32896, 55349, 56507, 4352, 69, 97, 98, 99, 100, 101, 102, 103, 105, 106, 108, 110, 111, 114, 115, 116, 118, 9537, 9547, 9575, 9582, 9595, 9600, 9679, 9684, 9694, 9700, 9705, 9725, 9773, 9779, 9785, 9810, 9917, 512, 59, 108, 9542, 9544, 32768, 8807, 59, 32768, 10892, 768, 99, 109, 112, 9554, 9560, 9572, 117, 116, 101, 59, 32768, 501, 109, 97, 512, 59, 100, 9567, 9569, 32768, 947, 59, 32768, 989, 59, 32768, 10886, 114, 101, 118, 101, 59, 32768, 287, 512, 105, 121, 9587, 9592, 114, 99, 59, 32768, 285, 59, 32768, 1075, 111, 116, 59, 32768, 289, 1024, 59, 108, 113, 115, 9609, 9611, 9614, 9633, 32768, 8805, 59, 32768, 8923, 768, 59, 113, 115, 9621, 9623, 9626, 32768, 8805, 59, 32768, 8807, 108, 97, 110, 116, 59, 32768, 10878, 1024, 59, 99, 100, 108, 9642, 9644, 9648, 9667, 32768, 10878, 99, 59, 32768, 10921, 111, 116, 512, 59, 111, 9655, 9657, 32768, 10880, 512, 59, 108, 9662, 9664, 32768, 10882, 59, 32768, 10884, 512, 59, 101, 9672, 9675, 32896, 8923, 65024, 115, 59, 32768, 10900, 114, 59, 32896, 55349, 56612, 512, 59, 103, 9689, 9691, 32768, 8811, 59, 32768, 8921, 109, 101, 108, 59, 32768, 8503, 99, 121, 59, 32768, 1107, 1024, 59, 69, 97, 106, 9714, 9716, 9719, 9722, 32768, 8823, 59, 32768, 10898, 59, 32768, 10917, 59, 32768, 10916, 1024, 69, 97, 101, 115, 9734, 9737, 9751, 9768, 59, 32768, 8809, 112, 512, 59, 112, 9743, 9745, 32768, 10890, 114, 111, 120, 59, 32768, 10890, 512, 59, 113, 9756, 9758, 32768, 10888, 512, 59, 113, 9763, 9765, 32768, 10888, 59, 32768, 8809, 105, 109, 59, 32768, 8935, 112, 102, 59, 32896, 55349, 56664, 97, 118, 101, 59, 32768, 96, 512, 99, 105, 9790, 9794, 114, 59, 32768, 8458, 109, 768, 59, 101, 108, 9802, 9804, 9807, 32768, 8819, 59, 32768, 10894, 59, 32768, 10896, 34304, 62, 59, 99, 100, 108, 113, 114, 9824, 9826, 9838, 9843, 9849, 9856, 32768, 62, 512, 99, 105, 9831, 9834, 59, 32768, 10919, 114, 59, 32768, 10874, 111, 116, 59, 32768, 8919, 80, 97, 114, 59, 32768, 10645, 117, 101, 115, 116, 59, 32768, 10876, 1280, 97, 100, 101, 108, 115, 9867, 9882, 9887, 9906, 9912, 833, 9872, 0, 9879, 112, 114, 111, 120, 59, 32768, 10886, 114, 59, 32768, 10616, 111, 116, 59, 32768, 8919, 113, 512, 108, 113, 9893, 9899, 101, 115, 115, 59, 32768, 8923, 108, 101, 115, 115, 59, 32768, 10892, 101, 115, 115, 59, 32768, 8823, 105, 109, 59, 32768, 8819, 512, 101, 110, 9922, 9932, 114, 116, 110, 101, 113, 113, 59, 32896, 8809, 65024, 69, 59, 32896, 8809, 65024, 2560, 65, 97, 98, 99, 101, 102, 107, 111, 115, 121, 9958, 9963, 10015, 10020, 10026, 10060, 10065, 10085, 10147, 10171, 114, 114, 59, 32768, 8660, 1024, 105, 108, 109, 114, 9972, 9978, 9982, 9988, 114, 115, 112, 59, 32768, 8202, 102, 59, 32768, 189, 105, 108, 116, 59, 32768, 8459, 512, 100, 114, 9993, 9998, 99, 121, 59, 32768, 1098, 768, 59, 99, 119, 10005, 10007, 10012, 32768, 8596, 105, 114, 59, 32768, 10568, 59, 32768, 8621, 97, 114, 59, 32768, 8463, 105, 114, 99, 59, 32768, 293, 768, 97, 108, 114, 10033, 10048, 10054, 114, 116, 115, 512, 59, 117, 10041, 10043, 32768, 9829, 105, 116, 59, 32768, 9829, 108, 105, 112, 59, 32768, 8230, 99, 111, 110, 59, 32768, 8889, 114, 59, 32896, 55349, 56613, 115, 512, 101, 119, 10071, 10078, 97, 114, 111, 119, 59, 32768, 10533, 97, 114, 111, 119, 59, 32768, 10534, 1280, 97, 109, 111, 112, 114, 10096, 10101, 10107, 10136, 10141, 114, 114, 59, 32768, 8703, 116, 104, 116, 59, 32768, 8763, 107, 512, 108, 114, 10113, 10124, 101, 102, 116, 97, 114, 114, 111, 119, 59, 32768, 8617, 105, 103, 104, 116, 97, 114, 114, 111, 119, 59, 32768, 8618, 102, 59, 32896, 55349, 56665, 98, 97, 114, 59, 32768, 8213, 768, 99, 108, 116, 10154, 10159, 10165, 114, 59, 32896, 55349, 56509, 97, 115, 104, 59, 32768, 8463, 114, 111, 107, 59, 32768, 295, 512, 98, 112, 10176, 10182, 117, 108, 108, 59, 32768, 8259, 104, 101, 110, 59, 32768, 8208, 5426, 10211, 0, 10220, 0, 10239, 10255, 10267, 0, 10276, 10312, 0, 0, 10318, 10371, 10458, 10485, 10491, 0, 10500, 10545, 10558, 99, 117, 116, 101, 33024, 237, 59, 32768, 237, 768, 59, 105, 121, 10226, 10228, 10235, 32768, 8291, 114, 99, 33024, 238, 59, 32768, 238, 59, 32768, 1080, 512, 99, 120, 10243, 10247, 121, 59, 32768, 1077, 99, 108, 33024, 161, 59, 32768, 161, 512, 102, 114, 10259, 10262, 59, 32768, 8660, 59, 32896, 55349, 56614, 114, 97, 118, 101, 33024, 236, 59, 32768, 236, 1024, 59, 105, 110, 111, 10284, 10286, 10300, 10306, 32768, 8520, 512, 105, 110, 10291, 10296, 110, 116, 59, 32768, 10764, 116, 59, 32768, 8749, 102, 105, 110, 59, 32768, 10716, 116, 97, 59, 32768, 8489, 108, 105, 103, 59, 32768, 307, 768, 97, 111, 112, 10324, 10361, 10365, 768, 99, 103, 116, 10331, 10335, 10357, 114, 59, 32768, 299, 768, 101, 108, 112, 10342, 10345, 10351, 59, 32768, 8465, 105, 110, 101, 59, 32768, 8464, 97, 114, 116, 59, 32768, 8465, 104, 59, 32768, 305, 102, 59, 32768, 8887, 101, 100, 59, 32768, 437, 1280, 59, 99, 102, 111, 116, 10381, 10383, 10389, 10403, 10409, 32768, 8712, 97, 114, 101, 59, 32768, 8453, 105, 110, 512, 59, 116, 10396, 10398, 32768, 8734, 105, 101, 59, 32768, 10717, 100, 111, 116, 59, 32768, 305, 1280, 59, 99, 101, 108, 112, 10420, 10422, 10427, 10444, 10451, 32768, 8747, 97, 108, 59, 32768, 8890, 512, 103, 114, 10432, 10438, 101, 114, 115, 59, 32768, 8484, 99, 97, 108, 59, 32768, 8890, 97, 114, 104, 107, 59, 32768, 10775, 114, 111, 100, 59, 32768, 10812, 1024, 99, 103, 112, 116, 10466, 10470, 10475, 10480, 121, 59, 32768, 1105, 111, 110, 59, 32768, 303, 102, 59, 32896, 55349, 56666, 97, 59, 32768, 953, 114, 111, 100, 59, 32768, 10812, 117, 101, 115, 116, 33024, 191, 59, 32768, 191, 512, 99, 105, 10504, 10509, 114, 59, 32896, 55349, 56510, 110, 1280, 59, 69, 100, 115, 118, 10521, 10523, 10526, 10531, 10541, 32768, 8712, 59, 32768, 8953, 111, 116, 59, 32768, 8949, 512, 59, 118, 10536, 10538, 32768, 8948, 59, 32768, 8947, 59, 32768, 8712, 512, 59, 105, 10549, 10551, 32768, 8290, 108, 100, 101, 59, 32768, 297, 828, 10562, 0, 10567, 99, 121, 59, 32768, 1110, 108, 33024, 239, 59, 32768, 239, 1536, 99, 102, 109, 111, 115, 117, 10585, 10598, 10603, 10609, 10615, 10630, 512, 105, 121, 10590, 10595, 114, 99, 59, 32768, 309, 59, 32768, 1081, 114, 59, 32896, 55349, 56615, 97, 116, 104, 59, 32768, 567, 112, 102, 59, 32896, 55349, 56667, 820, 10620, 0, 10625, 114, 59, 32896, 55349, 56511, 114, 99, 121, 59, 32768, 1112, 107, 99, 121, 59, 32768, 1108, 2048, 97, 99, 102, 103, 104, 106, 111, 115, 10653, 10666, 10680, 10685, 10692, 10697, 10702, 10708, 112, 112, 97, 512, 59, 118, 10661, 10663, 32768, 954, 59, 32768, 1008, 512, 101, 121, 10671, 10677, 100, 105, 108, 59, 32768, 311, 59, 32768, 1082, 114, 59, 32896, 55349, 56616, 114, 101, 101, 110, 59, 32768, 312, 99, 121, 59, 32768, 1093, 99, 121, 59, 32768, 1116, 112, 102, 59, 32896, 55349, 56668, 99, 114, 59, 32896, 55349, 56512, 5888, 65, 66, 69, 72, 97, 98, 99, 100, 101, 102, 103, 104, 106, 108, 109, 110, 111, 112, 114, 115, 116, 117, 118, 10761, 10783, 10789, 10799, 10804, 10957, 11011, 11047, 11094, 11349, 11372, 11382, 11409, 11414, 11451, 11478, 11526, 11698, 11711, 11755, 11823, 11910, 11929, 768, 97, 114, 116, 10768, 10773, 10777, 114, 114, 59, 32768, 8666, 114, 59, 32768, 8656, 97, 105, 108, 59, 32768, 10523, 97, 114, 114, 59, 32768, 10510, 512, 59, 103, 10794, 10796, 32768, 8806, 59, 32768, 10891, 97, 114, 59, 32768, 10594, 4660, 10824, 0, 10830, 0, 10838, 0, 0, 0, 0, 0, 10844, 10850, 0, 10867, 10870, 10877, 0, 10933, 117, 116, 101, 59, 32768, 314, 109, 112, 116, 121, 118, 59, 32768, 10676, 114, 97, 110, 59, 32768, 8466, 98, 100, 97, 59, 32768, 955, 103, 768, 59, 100, 108, 10857, 10859, 10862, 32768, 10216, 59, 32768, 10641, 101, 59, 32768, 10216, 59, 32768, 10885, 117, 111, 33024, 171, 59, 32768, 171, 114, 2048, 59, 98, 102, 104, 108, 112, 115, 116, 10894, 10896, 10907, 10911, 10915, 10919, 10923, 10928, 32768, 8592, 512, 59, 102, 10901, 10903, 32768, 8676, 115, 59, 32768, 10527, 115, 59, 32768, 10525, 107, 59, 32768, 8617, 112, 59, 32768, 8619, 108, 59, 32768, 10553, 105, 109, 59, 32768, 10611, 108, 59, 32768, 8610, 768, 59, 97, 101, 10939, 10941, 10946, 32768, 10923, 105, 108, 59, 32768, 10521, 512, 59, 115, 10951, 10953, 32768, 10925, 59, 32896, 10925, 65024, 768, 97, 98, 114, 10964, 10969, 10974, 114, 114, 59, 32768, 10508, 114, 107, 59, 32768, 10098, 512, 97, 107, 10979, 10991, 99, 512, 101, 107, 10985, 10988, 59, 32768, 123, 59, 32768, 91, 512, 101, 115, 10996, 10999, 59, 32768, 10635, 108, 512, 100, 117, 11005, 11008, 59, 32768, 10639, 59, 32768, 10637, 1024, 97, 101, 117, 121, 11020, 11026, 11040, 11044, 114, 111, 110, 59, 32768, 318, 512, 100, 105, 11031, 11036, 105, 108, 59, 32768, 316, 108, 59, 32768, 8968, 98, 59, 32768, 123, 59, 32768, 1083, 1024, 99, 113, 114, 115, 11056, 11060, 11072, 11090, 97, 59, 32768, 10550, 117, 111, 512, 59, 114, 11067, 11069, 32768, 8220, 59, 32768, 8222, 512, 100, 117, 11077, 11083, 104, 97, 114, 59, 32768, 10599, 115, 104, 97, 114, 59, 32768, 10571, 104, 59, 32768, 8626, 1280, 59, 102, 103, 113, 115, 11105, 11107, 11228, 11231, 11250, 32768, 8804, 116, 1280, 97, 104, 108, 114, 116, 11119, 11136, 11157, 11169, 11216, 114, 114, 111, 119, 512, 59, 116, 11128, 11130, 32768, 8592, 97, 105, 108, 59, 32768, 8610, 97, 114, 112, 111, 111, 110, 512, 100, 117, 11147, 11153, 111, 119, 110, 59, 32768, 8637, 112, 59, 32768, 8636, 101, 102, 116, 97, 114, 114, 111, 119, 115, 59, 32768, 8647, 105, 103, 104, 116, 768, 97, 104, 115, 11180, 11194, 11204, 114, 114, 111, 119, 512, 59, 115, 11189, 11191, 32768, 8596, 59, 32768, 8646, 97, 114, 112, 111, 111, 110, 115, 59, 32768, 8651, 113, 117, 105, 103, 97, 114, 114, 111, 119, 59, 32768, 8621, 104, 114, 101, 101, 116, 105, 109, 101, 115, 59, 32768, 8907, 59, 32768, 8922, 768, 59, 113, 115, 11238, 11240, 11243, 32768, 8804, 59, 32768, 8806, 108, 97, 110, 116, 59, 32768, 10877, 1280, 59, 99, 100, 103, 115, 11261, 11263, 11267, 11286, 11298, 32768, 10877, 99, 59, 32768, 10920, 111, 116, 512, 59, 111, 11274, 11276, 32768, 10879, 512, 59, 114, 11281, 11283, 32768, 10881, 59, 32768, 10883, 512, 59, 101, 11291, 11294, 32896, 8922, 65024, 115, 59, 32768, 10899, 1280, 97, 100, 101, 103, 115, 11309, 11317, 11322, 11339, 11344, 112, 112, 114, 111, 120, 59, 32768, 10885, 111, 116, 59, 32768, 8918, 113, 512, 103, 113, 11328, 11333, 116, 114, 59, 32768, 8922, 103, 116, 114, 59, 32768, 10891, 116, 114, 59, 32768, 8822, 105, 109, 59, 32768, 8818, 768, 105, 108, 114, 11356, 11362, 11368, 115, 104, 116, 59, 32768, 10620, 111, 111, 114, 59, 32768, 8970, 59, 32896, 55349, 56617, 512, 59, 69, 11377, 11379, 32768, 8822, 59, 32768, 10897, 562, 11386, 11405, 114, 512, 100, 117, 11391, 11394, 59, 32768, 8637, 512, 59, 108, 11399, 11401, 32768, 8636, 59, 32768, 10602, 108, 107, 59, 32768, 9604, 99, 121, 59, 32768, 1113, 1280, 59, 97, 99, 104, 116, 11425, 11427, 11432, 11440, 11446, 32768, 8810, 114, 114, 59, 32768, 8647, 111, 114, 110, 101, 114, 59, 32768, 8990, 97, 114, 100, 59, 32768, 10603, 114, 105, 59, 32768, 9722, 512, 105, 111, 11456, 11462, 100, 111, 116, 59, 32768, 320, 117, 115, 116, 512, 59, 97, 11470, 11472, 32768, 9136, 99, 104, 101, 59, 32768, 9136, 1024, 69, 97, 101, 115, 11487, 11490, 11504, 11521, 59, 32768, 8808, 112, 512, 59, 112, 11496, 11498, 32768, 10889, 114, 111, 120, 59, 32768, 10889, 512, 59, 113, 11509, 11511, 32768, 10887, 512, 59, 113, 11516, 11518, 32768, 10887, 59, 32768, 8808, 105, 109, 59, 32768, 8934, 2048, 97, 98, 110, 111, 112, 116, 119, 122, 11543, 11556, 11561, 11616, 11640, 11660, 11667, 11680, 512, 110, 114, 11548, 11552, 103, 59, 32768, 10220, 114, 59, 32768, 8701, 114, 107, 59, 32768, 10214, 103, 768, 108, 109, 114, 11569, 11596, 11604, 101, 102, 116, 512, 97, 114, 11577, 11584, 114, 114, 111, 119, 59, 32768, 10229, 105, 103, 104, 116, 97, 114, 114, 111, 119, 59, 32768, 10231, 97, 112, 115, 116, 111, 59, 32768, 10236, 105, 103, 104, 116, 97, 114, 114, 111, 119, 59, 32768, 10230, 112, 97, 114, 114, 111, 119, 512, 108, 114, 11627, 11633, 101, 102, 116, 59, 32768, 8619, 105, 103, 104, 116, 59, 32768, 8620, 768, 97, 102, 108, 11647, 11651, 11655, 114, 59, 32768, 10629, 59, 32896, 55349, 56669, 117, 115, 59, 32768, 10797, 105, 109, 101, 115, 59, 32768, 10804, 562, 11671, 11676, 115, 116, 59, 32768, 8727, 97, 114, 59, 32768, 95, 768, 59, 101, 102, 11687, 11689, 11695, 32768, 9674, 110, 103, 101, 59, 32768, 9674, 59, 32768, 10731, 97, 114, 512, 59, 108, 11705, 11707, 32768, 40, 116, 59, 32768, 10643, 1280, 97, 99, 104, 109, 116, 11722, 11727, 11735, 11747, 11750, 114, 114, 59, 32768, 8646, 111, 114, 110, 101, 114, 59, 32768, 8991, 97, 114, 512, 59, 100, 11742, 11744, 32768, 8651, 59, 32768, 10605, 59, 32768, 8206, 114, 105, 59, 32768, 8895, 1536, 97, 99, 104, 105, 113, 116, 11768, 11774, 11779, 11782, 11798, 11817, 113, 117, 111, 59, 32768, 8249, 114, 59, 32896, 55349, 56513, 59, 32768, 8624, 109, 768, 59, 101, 103, 11790, 11792, 11795, 32768, 8818, 59, 32768, 10893, 59, 32768, 10895, 512, 98, 117, 11803, 11806, 59, 32768, 91, 111, 512, 59, 114, 11812, 11814, 32768, 8216, 59, 32768, 8218, 114, 111, 107, 59, 32768, 322, 34816, 60, 59, 99, 100, 104, 105, 108, 113, 114, 11841, 11843, 11855, 11860, 11866, 11872, 11878, 11885, 32768, 60, 512, 99, 105, 11848, 11851, 59, 32768, 10918, 114, 59, 32768, 10873, 111, 116, 59, 32768, 8918, 114, 101, 101, 59, 32768, 8907, 109, 101, 115, 59, 32768, 8905, 97, 114, 114, 59, 32768, 10614, 117, 101, 115, 116, 59, 32768, 10875, 512, 80, 105, 11890, 11895, 97, 114, 59, 32768, 10646, 768, 59, 101, 102, 11902, 11904, 11907, 32768, 9667, 59, 32768, 8884, 59, 32768, 9666, 114, 512, 100, 117, 11916, 11923, 115, 104, 97, 114, 59, 32768, 10570, 104, 97, 114, 59, 32768, 10598, 512, 101, 110, 11934, 11944, 114, 116, 110, 101, 113, 113, 59, 32896, 8808, 65024, 69, 59, 32896, 8808, 65024, 3584, 68, 97, 99, 100, 101, 102, 104, 105, 108, 110, 111, 112, 115, 117, 11978, 11984, 12061, 12075, 12081, 12095, 12100, 12104, 12170, 12181, 12188, 12204, 12207, 12223, 68, 111, 116, 59, 32768, 8762, 1024, 99, 108, 112, 114, 11993, 11999, 12019, 12055, 114, 33024, 175, 59, 32768, 175, 512, 101, 116, 12004, 12007, 59, 32768, 9794, 512, 59, 101, 12012, 12014, 32768, 10016, 115, 101, 59, 32768, 10016, 512, 59, 115, 12024, 12026, 32768, 8614, 116, 111, 1024, 59, 100, 108, 117, 12037, 12039, 12045, 12051, 32768, 8614, 111, 119, 110, 59, 32768, 8615, 101, 102, 116, 59, 32768, 8612, 112, 59, 32768, 8613, 107, 101, 114, 59, 32768, 9646, 512, 111, 121, 12066, 12072, 109, 109, 97, 59, 32768, 10793, 59, 32768, 1084, 97, 115, 104, 59, 32768, 8212, 97, 115, 117, 114, 101, 100, 97, 110, 103, 108, 101, 59, 32768, 8737, 114, 59, 32896, 55349, 56618, 111, 59, 32768, 8487, 768, 99, 100, 110, 12111, 12118, 12146, 114, 111, 33024, 181, 59, 32768, 181, 1024, 59, 97, 99, 100, 12127, 12129, 12134, 12139, 32768, 8739, 115, 116, 59, 32768, 42, 105, 114, 59, 32768, 10992, 111, 116, 33024, 183, 59, 32768, 183, 117, 115, 768, 59, 98, 100, 12155, 12157, 12160, 32768, 8722, 59, 32768, 8863, 512, 59, 117, 12165, 12167, 32768, 8760, 59, 32768, 10794, 564, 12174, 12178, 112, 59, 32768, 10971, 114, 59, 32768, 8230, 112, 108, 117, 115, 59, 32768, 8723, 512, 100, 112, 12193, 12199, 101, 108, 115, 59, 32768, 8871, 102, 59, 32896, 55349, 56670, 59, 32768, 8723, 512, 99, 116, 12212, 12217, 114, 59, 32896, 55349, 56514, 112, 111, 115, 59, 32768, 8766, 768, 59, 108, 109, 12230, 12232, 12240, 32768, 956, 116, 105, 109, 97, 112, 59, 32768, 8888, 97, 112, 59, 32768, 8888, 6144, 71, 76, 82, 86, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 108, 109, 111, 112, 114, 115, 116, 117, 118, 119, 12294, 12315, 12364, 12376, 12393, 12472, 12496, 12547, 12553, 12636, 12641, 12703, 12725, 12747, 12752, 12876, 12881, 12957, 13033, 13089, 13294, 13359, 13384, 13499, 512, 103, 116, 12299, 12303, 59, 32896, 8921, 824, 512, 59, 118, 12308, 12311, 32896, 8811, 8402, 59, 32896, 8811, 824, 768, 101, 108, 116, 12322, 12348, 12352, 102, 116, 512, 97, 114, 12329, 12336, 114, 114, 111, 119, 59, 32768, 8653, 105, 103, 104, 116, 97, 114, 114, 111, 119, 59, 32768, 8654, 59, 32896, 8920, 824, 512, 59, 118, 12357, 12360, 32896, 8810, 8402, 59, 32896, 8810, 824, 105, 103, 104, 116, 97, 114, 114, 111, 119, 59, 32768, 8655, 512, 68, 100, 12381, 12387, 97, 115, 104, 59, 32768, 8879, 97, 115, 104, 59, 32768, 8878, 1280, 98, 99, 110, 112, 116, 12404, 12409, 12415, 12420, 12452, 108, 97, 59, 32768, 8711, 117, 116, 101, 59, 32768, 324, 103, 59, 32896, 8736, 8402, 1280, 59, 69, 105, 111, 112, 12431, 12433, 12437, 12442, 12446, 32768, 8777, 59, 32896, 10864, 824, 100, 59, 32896, 8779, 824, 115, 59, 32768, 329, 114, 111, 120, 59, 32768, 8777, 117, 114, 512, 59, 97, 12459, 12461, 32768, 9838, 108, 512, 59, 115, 12467, 12469, 32768, 9838, 59, 32768, 8469, 836, 12477, 0, 12483, 112, 33024, 160, 59, 32768, 160, 109, 112, 512, 59, 101, 12489, 12492, 32896, 8782, 824, 59, 32896, 8783, 824, 1280, 97, 101, 111, 117, 121, 12507, 12519, 12525, 12540, 12544, 833, 12512, 0, 12515, 59, 32768, 10819, 111, 110, 59, 32768, 328, 100, 105, 108, 59, 32768, 326, 110, 103, 512, 59, 100, 12532, 12534, 32768, 8775, 111, 116, 59, 32896, 10861, 824, 112, 59, 32768, 10818, 59, 32768, 1085, 97, 115, 104, 59, 32768, 8211, 1792, 59, 65, 97, 100, 113, 115, 120, 12568, 12570, 12575, 12596, 12602, 12608, 12623, 32768, 8800, 114, 114, 59, 32768, 8663, 114, 512, 104, 114, 12581, 12585, 107, 59, 32768, 10532, 512, 59, 111, 12590, 12592, 32768, 8599, 119, 59, 32768, 8599, 111, 116, 59, 32896, 8784, 824, 117, 105, 118, 59, 32768, 8802, 512, 101, 105, 12613, 12618, 97, 114, 59, 32768, 10536, 109, 59, 32896, 8770, 824, 105, 115, 116, 512, 59, 115, 12631, 12633, 32768, 8708, 59, 32768, 8708, 114, 59, 32896, 55349, 56619, 1024, 69, 101, 115, 116, 12650, 12654, 12688, 12693, 59, 32896, 8807, 824, 768, 59, 113, 115, 12661, 12663, 12684, 32768, 8817, 768, 59, 113, 115, 12670, 12672, 12676, 32768, 8817, 59, 32896, 8807, 824, 108, 97, 110, 116, 59, 32896, 10878, 824, 59, 32896, 10878, 824, 105, 109, 59, 32768, 8821, 512, 59, 114, 12698, 12700, 32768, 8815, 59, 32768, 8815, 768, 65, 97, 112, 12710, 12715, 12720, 114, 114, 59, 32768, 8654, 114, 114, 59, 32768, 8622, 97, 114, 59, 32768, 10994, 768, 59, 115, 118, 12732, 12734, 12744, 32768, 8715, 512, 59, 100, 12739, 12741, 32768, 8956, 59, 32768, 8954, 59, 32768, 8715, 99, 121, 59, 32768, 1114, 1792, 65, 69, 97, 100, 101, 115, 116, 12767, 12772, 12776, 12781, 12785, 12853, 12858, 114, 114, 59, 32768, 8653, 59, 32896, 8806, 824, 114, 114, 59, 32768, 8602, 114, 59, 32768, 8229, 1024, 59, 102, 113, 115, 12794, 12796, 12821, 12842, 32768, 8816, 116, 512, 97, 114, 12802, 12809, 114, 114, 111, 119, 59, 32768, 8602, 105, 103, 104, 116, 97, 114, 114, 111, 119, 59, 32768, 8622, 768, 59, 113, 115, 12828, 12830, 12834, 32768, 8816, 59, 32896, 8806, 824, 108, 97, 110, 116, 59, 32896, 10877, 824, 512, 59, 115, 12847, 12850, 32896, 10877, 824, 59, 32768, 8814, 105, 109, 59, 32768, 8820, 512, 59, 114, 12863, 12865, 32768, 8814, 105, 512, 59, 101, 12871, 12873, 32768, 8938, 59, 32768, 8940, 105, 100, 59, 32768, 8740, 512, 112, 116, 12886, 12891, 102, 59, 32896, 55349, 56671, 33536, 172, 59, 105, 110, 12899, 12901, 12936, 32768, 172, 110, 1024, 59, 69, 100, 118, 12911, 12913, 12917, 12923, 32768, 8713, 59, 32896, 8953, 824, 111, 116, 59, 32896, 8949, 824, 818, 12928, 12931, 12934, 59, 32768, 8713, 59, 32768, 8951, 59, 32768, 8950, 105, 512, 59, 118, 12942, 12944, 32768, 8716, 818, 12949, 12952, 12955, 59, 32768, 8716, 59, 32768, 8958, 59, 32768, 8957, 768, 97, 111, 114, 12964, 12992, 12999, 114, 1024, 59, 97, 115, 116, 12974, 12976, 12983, 12988, 32768, 8742, 108, 108, 101, 108, 59, 32768, 8742, 108, 59, 32896, 11005, 8421, 59, 32896, 8706, 824, 108, 105, 110, 116, 59, 32768, 10772, 768, 59, 99, 101, 13006, 13008, 13013, 32768, 8832, 117, 101, 59, 32768, 8928, 512, 59, 99, 13018, 13021, 32896, 10927, 824, 512, 59, 101, 13026, 13028, 32768, 8832, 113, 59, 32896, 10927, 824, 1024, 65, 97, 105, 116, 13042, 13047, 13066, 13077, 114, 114, 59, 32768, 8655, 114, 114, 768, 59, 99, 119, 13056, 13058, 13062, 32768, 8603, 59, 32896, 10547, 824, 59, 32896, 8605, 824, 103, 104, 116, 97, 114, 114, 111, 119, 59, 32768, 8603, 114, 105, 512, 59, 101, 13084, 13086, 32768, 8939, 59, 32768, 8941, 1792, 99, 104, 105, 109, 112, 113, 117, 13104, 13128, 13151, 13169, 13174, 13179, 13194, 1024, 59, 99, 101, 114, 13113, 13115, 13120, 13124, 32768, 8833, 117, 101, 59, 32768, 8929, 59, 32896, 10928, 824, 59, 32896, 55349, 56515, 111, 114, 116, 1086, 13137, 0, 0, 13142, 105, 100, 59, 32768, 8740, 97, 114, 97, 108, 108, 101, 108, 59, 32768, 8742, 109, 512, 59, 101, 13157, 13159, 32768, 8769, 512, 59, 113, 13164, 13166, 32768, 8772, 59, 32768, 8772, 105, 100, 59, 32768, 8740, 97, 114, 59, 32768, 8742, 115, 117, 512, 98, 112, 13186, 13190, 101, 59, 32768, 8930, 101, 59, 32768, 8931, 768, 98, 99, 112, 13201, 13241, 13254, 1024, 59, 69, 101, 115, 13210, 13212, 13216, 13219, 32768, 8836, 59, 32896, 10949, 824, 59, 32768, 8840, 101, 116, 512, 59, 101, 13226, 13229, 32896, 8834, 8402, 113, 512, 59, 113, 13235, 13237, 32768, 8840, 59, 32896, 10949, 824, 99, 512, 59, 101, 13247, 13249, 32768, 8833, 113, 59, 32896, 10928, 824, 1024, 59, 69, 101, 115, 13263, 13265, 13269, 13272, 32768, 8837, 59, 32896, 10950, 824, 59, 32768, 8841, 101, 116, 512, 59, 101, 13279, 13282, 32896, 8835, 8402, 113, 512, 59, 113, 13288, 13290, 32768, 8841, 59, 32896, 10950, 824, 1024, 103, 105, 108, 114, 13303, 13307, 13315, 13319, 108, 59, 32768, 8825, 108, 100, 101, 33024, 241, 59, 32768, 241, 103, 59, 32768, 8824, 105, 97, 110, 103, 108, 101, 512, 108, 114, 13330, 13344, 101, 102, 116, 512, 59, 101, 13338, 13340, 32768, 8938, 113, 59, 32768, 8940, 105, 103, 104, 116, 512, 59, 101, 13353, 13355, 32768, 8939, 113, 59, 32768, 8941, 512, 59, 109, 13364, 13366, 32768, 957, 768, 59, 101, 115, 13373, 13375, 13380, 32768, 35, 114, 111, 59, 32768, 8470, 112, 59, 32768, 8199, 2304, 68, 72, 97, 100, 103, 105, 108, 114, 115, 13403, 13409, 13415, 13420, 13426, 13439, 13446, 13476, 13493, 97, 115, 104, 59, 32768, 8877, 97, 114, 114, 59, 32768, 10500, 112, 59, 32896, 8781, 8402, 97, 115, 104, 59, 32768, 8876, 512, 101, 116, 13431, 13435, 59, 32896, 8805, 8402, 59, 32896, 62, 8402, 110, 102, 105, 110, 59, 32768, 10718, 768, 65, 101, 116, 13453, 13458, 13462, 114, 114, 59, 32768, 10498, 59, 32896, 8804, 8402, 512, 59, 114, 13467, 13470, 32896, 60, 8402, 105, 101, 59, 32896, 8884, 8402, 512, 65, 116, 13481, 13486, 114, 114, 59, 32768, 10499, 114, 105, 101, 59, 32896, 8885, 8402, 105, 109, 59, 32896, 8764, 8402, 768, 65, 97, 110, 13506, 13511, 13532, 114, 114, 59, 32768, 8662, 114, 512, 104, 114, 13517, 13521, 107, 59, 32768, 10531, 512, 59, 111, 13526, 13528, 32768, 8598, 119, 59, 32768, 8598, 101, 97, 114, 59, 32768, 10535, 9252, 13576, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 13579, 0, 13596, 13617, 13653, 13659, 13673, 13695, 13708, 0, 0, 13713, 13750, 0, 13788, 13794, 0, 13815, 13890, 13913, 13937, 13944, 59, 32768, 9416, 512, 99, 115, 13583, 13591, 117, 116, 101, 33024, 243, 59, 32768, 243, 116, 59, 32768, 8859, 512, 105, 121, 13600, 13613, 114, 512, 59, 99, 13606, 13608, 32768, 8858, 33024, 244, 59, 32768, 244, 59, 32768, 1086, 1280, 97, 98, 105, 111, 115, 13627, 13632, 13638, 13642, 13646, 115, 104, 59, 32768, 8861, 108, 97, 99, 59, 32768, 337, 118, 59, 32768, 10808, 116, 59, 32768, 8857, 111, 108, 100, 59, 32768, 10684, 108, 105, 103, 59, 32768, 339, 512, 99, 114, 13663, 13668, 105, 114, 59, 32768, 10687, 59, 32896, 55349, 56620, 1600, 13680, 0, 0, 13684, 0, 13692, 110, 59, 32768, 731, 97, 118, 101, 33024, 242, 59, 32768, 242, 59, 32768, 10689, 512, 98, 109, 13699, 13704, 97, 114, 59, 32768, 10677, 59, 32768, 937, 110, 116, 59, 32768, 8750, 1024, 97, 99, 105, 116, 13721, 13726, 13741, 13746, 114, 114, 59, 32768, 8634, 512, 105, 114, 13731, 13735, 114, 59, 32768, 10686, 111, 115, 115, 59, 32768, 10683, 110, 101, 59, 32768, 8254, 59, 32768, 10688, 768, 97, 101, 105, 13756, 13761, 13766, 99, 114, 59, 32768, 333, 103, 97, 59, 32768, 969, 768, 99, 100, 110, 13773, 13779, 13782, 114, 111, 110, 59, 32768, 959, 59, 32768, 10678, 117, 115, 59, 32768, 8854, 112, 102, 59, 32896, 55349, 56672, 768, 97, 101, 108, 13800, 13804, 13809, 114, 59, 32768, 10679, 114, 112, 59, 32768, 10681, 117, 115, 59, 32768, 8853, 1792, 59, 97, 100, 105, 111, 115, 118, 13829, 13831, 13836, 13869, 13875, 13879, 13886, 32768, 8744, 114, 114, 59, 32768, 8635, 1024, 59, 101, 102, 109, 13845, 13847, 13859, 13864, 32768, 10845, 114, 512, 59, 111, 13853, 13855, 32768, 8500, 102, 59, 32768, 8500, 33024, 170, 59, 32768, 170, 33024, 186, 59, 32768, 186, 103, 111, 102, 59, 32768, 8886, 114, 59, 32768, 10838, 108, 111, 112, 101, 59, 32768, 10839, 59, 32768, 10843, 768, 99, 108, 111, 13896, 13900, 13908, 114, 59, 32768, 8500, 97, 115, 104, 33024, 248, 59, 32768, 248, 108, 59, 32768, 8856, 105, 573, 13917, 13924, 100, 101, 33024, 245, 59, 32768, 245, 101, 115, 512, 59, 97, 13930, 13932, 32768, 8855, 115, 59, 32768, 10806, 109, 108, 33024, 246, 59, 32768, 246, 98, 97, 114, 59, 32768, 9021, 5426, 13972, 0, 14013, 0, 14017, 14053, 0, 14058, 14086, 0, 0, 14107, 14199, 0, 14202, 0, 0, 14229, 14425, 0, 14438, 114, 1024, 59, 97, 115, 116, 13981, 13983, 13997, 14009, 32768, 8741, 33280, 182, 59, 108, 13989, 13991, 32768, 182, 108, 101, 108, 59, 32768, 8741, 1082, 14003, 0, 0, 14007, 109, 59, 32768, 10995, 59, 32768, 11005, 59, 32768, 8706, 121, 59, 32768, 1087, 114, 1280, 99, 105, 109, 112, 116, 14028, 14033, 14038, 14043, 14046, 110, 116, 59, 32768, 37, 111, 100, 59, 32768, 46, 105, 108, 59, 32768, 8240, 59, 32768, 8869, 101, 110, 107, 59, 32768, 8241, 114, 59, 32896, 55349, 56621, 768, 105, 109, 111, 14064, 14074, 14080, 512, 59, 118, 14069, 14071, 32768, 966, 59, 32768, 981, 109, 97, 116, 59, 32768, 8499, 110, 101, 59, 32768, 9742, 768, 59, 116, 118, 14092, 14094, 14103, 32768, 960, 99, 104, 102, 111, 114, 107, 59, 32768, 8916, 59, 32768, 982, 512, 97, 117, 14111, 14132, 110, 512, 99, 107, 14117, 14128, 107, 512, 59, 104, 14123, 14125, 32768, 8463, 59, 32768, 8462, 118, 59, 32768, 8463, 115, 2304, 59, 97, 98, 99, 100, 101, 109, 115, 116, 14152, 14154, 14160, 14163, 14168, 14179, 14182, 14188, 14193, 32768, 43, 99, 105, 114, 59, 32768, 10787, 59, 32768, 8862, 105, 114, 59, 32768, 10786, 512, 111, 117, 14173, 14176, 59, 32768, 8724, 59, 32768, 10789, 59, 32768, 10866, 110, 33024, 177, 59, 32768, 177, 105, 109, 59, 32768, 10790, 119, 111, 59, 32768, 10791, 59, 32768, 177, 768, 105, 112, 117, 14208, 14216, 14221, 110, 116, 105, 110, 116, 59, 32768, 10773, 102, 59, 32896, 55349, 56673, 110, 100, 33024, 163, 59, 32768, 163, 2560, 59, 69, 97, 99, 101, 105, 110, 111, 115, 117, 14249, 14251, 14254, 14258, 14263, 14336, 14348, 14367, 14413, 14418, 32768, 8826, 59, 32768, 10931, 112, 59, 32768, 10935, 117, 101, 59, 32768, 8828, 512, 59, 99, 14268, 14270, 32768, 10927, 1536, 59, 97, 99, 101, 110, 115, 14283, 14285, 14293, 14302, 14306, 14331, 32768, 8826, 112, 112, 114, 111, 120, 59, 32768, 10935, 117, 114, 108, 121, 101, 113, 59, 32768, 8828, 113, 59, 32768, 10927, 768, 97, 101, 115, 14313, 14321, 14326, 112, 112, 114, 111, 120, 59, 32768, 10937, 113, 113, 59, 32768, 10933, 105, 109, 59, 32768, 8936, 105, 109, 59, 32768, 8830, 109, 101, 512, 59, 115, 14343, 14345, 32768, 8242, 59, 32768, 8473, 768, 69, 97, 115, 14355, 14358, 14362, 59, 32768, 10933, 112, 59, 32768, 10937, 105, 109, 59, 32768, 8936, 768, 100, 102, 112, 14374, 14377, 14402, 59, 32768, 8719, 768, 97, 108, 115, 14384, 14390, 14396, 108, 97, 114, 59, 32768, 9006, 105, 110, 101, 59, 32768, 8978, 117, 114, 102, 59, 32768, 8979, 512, 59, 116, 14407, 14409, 32768, 8733, 111, 59, 32768, 8733, 105, 109, 59, 32768, 8830, 114, 101, 108, 59, 32768, 8880, 512, 99, 105, 14429, 14434, 114, 59, 32896, 55349, 56517, 59, 32768, 968, 110, 99, 115, 112, 59, 32768, 8200, 1536, 102, 105, 111, 112, 115, 117, 14457, 14462, 14467, 14473, 14480, 14486, 114, 59, 32896, 55349, 56622, 110, 116, 59, 32768, 10764, 112, 102, 59, 32896, 55349, 56674, 114, 105, 109, 101, 59, 32768, 8279, 99, 114, 59, 32896, 55349, 56518, 768, 97, 101, 111, 14493, 14513, 14526, 116, 512, 101, 105, 14499, 14508, 114, 110, 105, 111, 110, 115, 59, 32768, 8461, 110, 116, 59, 32768, 10774, 115, 116, 512, 59, 101, 14520, 14522, 32768, 63, 113, 59, 32768, 8799, 116, 33024, 34, 59, 32768, 34, 5376, 65, 66, 72, 97, 98, 99, 100, 101, 102, 104, 105, 108, 109, 110, 111, 112, 114, 115, 116, 117, 120, 14575, 14597, 14603, 14608, 14775, 14829, 14865, 14901, 14943, 14966, 15000, 15139, 15159, 15176, 15182, 15236, 15261, 15267, 15309, 15352, 15360, 768, 97, 114, 116, 14582, 14587, 14591, 114, 114, 59, 32768, 8667, 114, 59, 32768, 8658, 97, 105, 108, 59, 32768, 10524, 97, 114, 114, 59, 32768, 10511, 97, 114, 59, 32768, 10596, 1792, 99, 100, 101, 110, 113, 114, 116, 14623, 14637, 14642, 14650, 14672, 14679, 14751, 512, 101, 117, 14628, 14632, 59, 32896, 8765, 817, 116, 101, 59, 32768, 341, 105, 99, 59, 32768, 8730, 109, 112, 116, 121, 118, 59, 32768, 10675, 103, 1024, 59, 100, 101, 108, 14660, 14662, 14665, 14668, 32768, 10217, 59, 32768, 10642, 59, 32768, 10661, 101, 59, 32768, 10217, 117, 111, 33024, 187, 59, 32768, 187, 114, 2816, 59, 97, 98, 99, 102, 104, 108, 112, 115, 116, 119, 14703, 14705, 14709, 14720, 14723, 14727, 14731, 14735, 14739, 14744, 14748, 32768, 8594, 112, 59, 32768, 10613, 512, 59, 102, 14714, 14716, 32768, 8677, 115, 59, 32768, 10528, 59, 32768, 10547, 115, 59, 32768, 10526, 107, 59, 32768, 8618, 112, 59, 32768, 8620, 108, 59, 32768, 10565, 105, 109, 59, 32768, 10612, 108, 59, 32768, 8611, 59, 32768, 8605, 512, 97, 105, 14756, 14761, 105, 108, 59, 32768, 10522, 111, 512, 59, 110, 14767, 14769, 32768, 8758, 97, 108, 115, 59, 32768, 8474, 768, 97, 98, 114, 14782, 14787, 14792, 114, 114, 59, 32768, 10509, 114, 107, 59, 32768, 10099, 512, 97, 107, 14797, 14809, 99, 512, 101, 107, 14803, 14806, 59, 32768, 125, 59, 32768, 93, 512, 101, 115, 14814, 14817, 59, 32768, 10636, 108, 512, 100, 117, 14823, 14826, 59, 32768, 10638, 59, 32768, 10640, 1024, 97, 101, 117, 121, 14838, 14844, 14858, 14862, 114, 111, 110, 59, 32768, 345, 512, 100, 105, 14849, 14854, 105, 108, 59, 32768, 343, 108, 59, 32768, 8969, 98, 59, 32768, 125, 59, 32768, 1088, 1024, 99, 108, 113, 115, 14874, 14878, 14885, 14897, 97, 59, 32768, 10551, 100, 104, 97, 114, 59, 32768, 10601, 117, 111, 512, 59, 114, 14892, 14894, 32768, 8221, 59, 32768, 8221, 104, 59, 32768, 8627, 768, 97, 99, 103, 14908, 14934, 14938, 108, 1024, 59, 105, 112, 115, 14918, 14920, 14925, 14931, 32768, 8476, 110, 101, 59, 32768, 8475, 97, 114, 116, 59, 32768, 8476, 59, 32768, 8477, 116, 59, 32768, 9645, 33024, 174, 59, 32768, 174, 768, 105, 108, 114, 14950, 14956, 14962, 115, 104, 116, 59, 32768, 10621, 111, 111, 114, 59, 32768, 8971, 59, 32896, 55349, 56623, 512, 97, 111, 14971, 14990, 114, 512, 100, 117, 14977, 14980, 59, 32768, 8641, 512, 59, 108, 14985, 14987, 32768, 8640, 59, 32768, 10604, 512, 59, 118, 14995, 14997, 32768, 961, 59, 32768, 1009, 768, 103, 110, 115, 15007, 15123, 15127, 104, 116, 1536, 97, 104, 108, 114, 115, 116, 15022, 15039, 15060, 15086, 15099, 15111, 114, 114, 111, 119, 512, 59, 116, 15031, 15033, 32768, 8594, 97, 105, 108, 59, 32768, 8611, 97, 114, 112, 111, 111, 110, 512, 100, 117, 15050, 15056, 111, 119, 110, 59, 32768, 8641, 112, 59, 32768, 8640, 101, 102, 116, 512, 97, 104, 15068, 15076, 114, 114, 111, 119, 115, 59, 32768, 8644, 97, 114, 112, 111, 111, 110, 115, 59, 32768, 8652, 105, 103, 104, 116, 97, 114, 114, 111, 119, 115, 59, 32768, 8649, 113, 117, 105, 103, 97, 114, 114, 111, 119, 59, 32768, 8605, 104, 114, 101, 101, 116, 105, 109, 101, 115, 59, 32768, 8908, 103, 59, 32768, 730, 105, 110, 103, 100, 111, 116, 115, 101, 113, 59, 32768, 8787, 768, 97, 104, 109, 15146, 15151, 15156, 114, 114, 59, 32768, 8644, 97, 114, 59, 32768, 8652, 59, 32768, 8207, 111, 117, 115, 116, 512, 59, 97, 15168, 15170, 32768, 9137, 99, 104, 101, 59, 32768, 9137, 109, 105, 100, 59, 32768, 10990, 1024, 97, 98, 112, 116, 15191, 15204, 15209, 15229, 512, 110, 114, 15196, 15200, 103, 59, 32768, 10221, 114, 59, 32768, 8702, 114, 107, 59, 32768, 10215, 768, 97, 102, 108, 15216, 15220, 15224, 114, 59, 32768, 10630, 59, 32896, 55349, 56675, 117, 115, 59, 32768, 10798, 105, 109, 101, 115, 59, 32768, 10805, 512, 97, 112, 15241, 15253, 114, 512, 59, 103, 15247, 15249, 32768, 41, 116, 59, 32768, 10644, 111, 108, 105, 110, 116, 59, 32768, 10770, 97, 114, 114, 59, 32768, 8649, 1024, 97, 99, 104, 113, 15276, 15282, 15287, 15290, 113, 117, 111, 59, 32768, 8250, 114, 59, 32896, 55349, 56519, 59, 32768, 8625, 512, 98, 117, 15295, 15298, 59, 32768, 93, 111, 512, 59, 114, 15304, 15306, 32768, 8217, 59, 32768, 8217, 768, 104, 105, 114, 15316, 15322, 15328, 114, 101, 101, 59, 32768, 8908, 109, 101, 115, 59, 32768, 8906, 105, 1024, 59, 101, 102, 108, 15338, 15340, 15343, 15346, 32768, 9657, 59, 32768, 8885, 59, 32768, 9656, 116, 114, 105, 59, 32768, 10702, 108, 117, 104, 97, 114, 59, 32768, 10600, 59, 32768, 8478, 6706, 15391, 15398, 15404, 15499, 15516, 15592, 0, 15606, 15660, 0, 0, 15752, 15758, 0, 15827, 15863, 15886, 16000, 16006, 16038, 16086, 0, 16467, 0, 0, 16506, 99, 117, 116, 101, 59, 32768, 347, 113, 117, 111, 59, 32768, 8218, 2560, 59, 69, 97, 99, 101, 105, 110, 112, 115, 121, 15424, 15426, 15429, 15441, 15446, 15458, 15463, 15482, 15490, 15495, 32768, 8827, 59, 32768, 10932, 833, 15434, 0, 15437, 59, 32768, 10936, 111, 110, 59, 32768, 353, 117, 101, 59, 32768, 8829, 512, 59, 100, 15451, 15453, 32768, 10928, 105, 108, 59, 32768, 351, 114, 99, 59, 32768, 349, 768, 69, 97, 115, 15470, 15473, 15477, 59, 32768, 10934, 112, 59, 32768, 10938, 105, 109, 59, 32768, 8937, 111, 108, 105, 110, 116, 59, 32768, 10771, 105, 109, 59, 32768, 8831, 59, 32768, 1089, 111, 116, 768, 59, 98, 101, 15507, 15509, 15512, 32768, 8901, 59, 32768, 8865, 59, 32768, 10854, 1792, 65, 97, 99, 109, 115, 116, 120, 15530, 15535, 15556, 15562, 15566, 15572, 15587, 114, 114, 59, 32768, 8664, 114, 512, 104, 114, 15541, 15545, 107, 59, 32768, 10533, 512, 59, 111, 15550, 15552, 32768, 8600, 119, 59, 32768, 8600, 116, 33024, 167, 59, 32768, 167, 105, 59, 32768, 59, 119, 97, 114, 59, 32768, 10537, 109, 512, 105, 110, 15578, 15584, 110, 117, 115, 59, 32768, 8726, 59, 32768, 8726, 116, 59, 32768, 10038, 114, 512, 59, 111, 15597, 15600, 32896, 55349, 56624, 119, 110, 59, 32768, 8994, 1024, 97, 99, 111, 121, 15614, 15619, 15632, 15654, 114, 112, 59, 32768, 9839, 512, 104, 121, 15624, 15629, 99, 121, 59, 32768, 1097, 59, 32768, 1096, 114, 116, 1086, 15640, 0, 0, 15645, 105, 100, 59, 32768, 8739, 97, 114, 97, 108, 108, 101, 108, 59, 32768, 8741, 33024, 173, 59, 32768, 173, 512, 103, 109, 15664, 15681, 109, 97, 768, 59, 102, 118, 15673, 15675, 15678, 32768, 963, 59, 32768, 962, 59, 32768, 962, 2048, 59, 100, 101, 103, 108, 110, 112, 114, 15698, 15700, 15705, 15715, 15725, 15735, 15739, 15745, 32768, 8764, 111, 116, 59, 32768, 10858, 512, 59, 113, 15710, 15712, 32768, 8771, 59, 32768, 8771, 512, 59, 69, 15720, 15722, 32768, 10910, 59, 32768, 10912, 512, 59, 69, 15730, 15732, 32768, 10909, 59, 32768, 10911, 101, 59, 32768, 8774, 108, 117, 115, 59, 32768, 10788, 97, 114, 114, 59, 32768, 10610, 97, 114, 114, 59, 32768, 8592, 1024, 97, 101, 105, 116, 15766, 15788, 15796, 15808, 512, 108, 115, 15771, 15783, 108, 115, 101, 116, 109, 105, 110, 117, 115, 59, 32768, 8726, 104, 112, 59, 32768, 10803, 112, 97, 114, 115, 108, 59, 32768, 10724, 512, 100, 108, 15801, 15804, 59, 32768, 8739, 101, 59, 32768, 8995, 512, 59, 101, 15813, 15815, 32768, 10922, 512, 59, 115, 15820, 15822, 32768, 10924, 59, 32896, 10924, 65024, 768, 102, 108, 112, 15833, 15839, 15857, 116, 99, 121, 59, 32768, 1100, 512, 59, 98, 15844, 15846, 32768, 47, 512, 59, 97, 15851, 15853, 32768, 10692, 114, 59, 32768, 9023, 102, 59, 32896, 55349, 56676, 97, 512, 100, 114, 15868, 15882, 101, 115, 512, 59, 117, 15875, 15877, 32768, 9824, 105, 116, 59, 32768, 9824, 59, 32768, 8741, 768, 99, 115, 117, 15892, 15921, 15977, 512, 97, 117, 15897, 15909, 112, 512, 59, 115, 15903, 15905, 32768, 8851, 59, 32896, 8851, 65024, 112, 512, 59, 115, 15915, 15917, 32768, 8852, 59, 32896, 8852, 65024, 117, 512, 98, 112, 15927, 15952, 768, 59, 101, 115, 15934, 15936, 15939, 32768, 8847, 59, 32768, 8849, 101, 116, 512, 59, 101, 15946, 15948, 32768, 8847, 113, 59, 32768, 8849, 768, 59, 101, 115, 15959, 15961, 15964, 32768, 8848, 59, 32768, 8850, 101, 116, 512, 59, 101, 15971, 15973, 32768, 8848, 113, 59, 32768, 8850, 768, 59, 97, 102, 15984, 15986, 15996, 32768, 9633, 114, 566, 15991, 15994, 59, 32768, 9633, 59, 32768, 9642, 59, 32768, 9642, 97, 114, 114, 59, 32768, 8594, 1024, 99, 101, 109, 116, 16014, 16019, 16025, 16031, 114, 59, 32896, 55349, 56520, 116, 109, 110, 59, 32768, 8726, 105, 108, 101, 59, 32768, 8995, 97, 114, 102, 59, 32768, 8902, 512, 97, 114, 16042, 16053, 114, 512, 59, 102, 16048, 16050, 32768, 9734, 59, 32768, 9733, 512, 97, 110, 16058, 16081, 105, 103, 104, 116, 512, 101, 112, 16067, 16076, 112, 115, 105, 108, 111, 110, 59, 32768, 1013, 104, 105, 59, 32768, 981, 115, 59, 32768, 175, 1280, 98, 99, 109, 110, 112, 16096, 16221, 16288, 16291, 16295, 2304, 59, 69, 100, 101, 109, 110, 112, 114, 115, 16115, 16117, 16120, 16125, 16137, 16143, 16154, 16160, 16166, 32768, 8834, 59, 32768, 10949, 111, 116, 59, 32768, 10941, 512, 59, 100, 16130, 16132, 32768, 8838, 111, 116, 59, 32768, 10947, 117, 108, 116, 59, 32768, 10945, 512, 69, 101, 16148, 16151, 59, 32768, 10955, 59, 32768, 8842, 108, 117, 115, 59, 32768, 10943, 97, 114, 114, 59, 32768, 10617, 768, 101, 105, 117, 16173, 16206, 16210, 116, 768, 59, 101, 110, 16181, 16183, 16194, 32768, 8834, 113, 512, 59, 113, 16189, 16191, 32768, 8838, 59, 32768, 10949, 101, 113, 512, 59, 113, 16201, 16203, 32768, 8842, 59, 32768, 10955, 109, 59, 32768, 10951, 512, 98, 112, 16215, 16218, 59, 32768, 10965, 59, 32768, 10963, 99, 1536, 59, 97, 99, 101, 110, 115, 16235, 16237, 16245, 16254, 16258, 16283, 32768, 8827, 112, 112, 114, 111, 120, 59, 32768, 10936, 117, 114, 108, 121, 101, 113, 59, 32768, 8829, 113, 59, 32768, 10928, 768, 97, 101, 115, 16265, 16273, 16278, 112, 112, 114, 111, 120, 59, 32768, 10938, 113, 113, 59, 32768, 10934, 105, 109, 59, 32768, 8937, 105, 109, 59, 32768, 8831, 59, 32768, 8721, 103, 59, 32768, 9834, 3328, 49, 50, 51, 59, 69, 100, 101, 104, 108, 109, 110, 112, 115, 16322, 16327, 16332, 16337, 16339, 16342, 16356, 16368, 16382, 16388, 16394, 16405, 16411, 33024, 185, 59, 32768, 185, 33024, 178, 59, 32768, 178, 33024, 179, 59, 32768, 179, 32768, 8835, 59, 32768, 10950, 512, 111, 115, 16347, 16351, 116, 59, 32768, 10942, 117, 98, 59, 32768, 10968, 512, 59, 100, 16361, 16363, 32768, 8839, 111, 116, 59, 32768, 10948, 115, 512, 111, 117, 16374, 16378, 108, 59, 32768, 10185, 98, 59, 32768, 10967, 97, 114, 114, 59, 32768, 10619, 117, 108, 116, 59, 32768, 10946, 512, 69, 101, 16399, 16402, 59, 32768, 10956, 59, 32768, 8843, 108, 117, 115, 59, 32768, 10944, 768, 101, 105, 117, 16418, 16451, 16455, 116, 768, 59, 101, 110, 16426, 16428, 16439, 32768, 8835, 113, 512, 59, 113, 16434, 16436, 32768, 8839, 59, 32768, 10950, 101, 113, 512, 59, 113, 16446, 16448, 32768, 8843, 59, 32768, 10956, 109, 59, 32768, 10952, 512, 98, 112, 16460, 16463, 59, 32768, 10964, 59, 32768, 10966, 768, 65, 97, 110, 16473, 16478, 16499, 114, 114, 59, 32768, 8665, 114, 512, 104, 114, 16484, 16488, 107, 59, 32768, 10534, 512, 59, 111, 16493, 16495, 32768, 8601, 119, 59, 32768, 8601, 119, 97, 114, 59, 32768, 10538, 108, 105, 103, 33024, 223, 59, 32768, 223, 5938, 16538, 16552, 16557, 16579, 16584, 16591, 0, 16596, 16692, 0, 0, 0, 0, 0, 16731, 16780, 0, 16787, 16908, 0, 0, 0, 16938, 1091, 16543, 0, 0, 16549, 103, 101, 116, 59, 32768, 8982, 59, 32768, 964, 114, 107, 59, 32768, 9140, 768, 97, 101, 121, 16563, 16569, 16575, 114, 111, 110, 59, 32768, 357, 100, 105, 108, 59, 32768, 355, 59, 32768, 1090, 111, 116, 59, 32768, 8411, 108, 114, 101, 99, 59, 32768, 8981, 114, 59, 32896, 55349, 56625, 1024, 101, 105, 107, 111, 16604, 16641, 16670, 16684, 835, 16609, 0, 16624, 101, 512, 52, 102, 16614, 16617, 59, 32768, 8756, 111, 114, 101, 59, 32768, 8756, 97, 768, 59, 115, 118, 16631, 16633, 16638, 32768, 952, 121, 109, 59, 32768, 977, 59, 32768, 977, 512, 99, 110, 16646, 16665, 107, 512, 97, 115, 16652, 16660, 112, 112, 114, 111, 120, 59, 32768, 8776, 105, 109, 59, 32768, 8764, 115, 112, 59, 32768, 8201, 512, 97, 115, 16675, 16679, 112, 59, 32768, 8776, 105, 109, 59, 32768, 8764, 114, 110, 33024, 254, 59, 32768, 254, 829, 16696, 16701, 16727, 100, 101, 59, 32768, 732, 101, 115, 33536, 215, 59, 98, 100, 16710, 16712, 16723, 32768, 215, 512, 59, 97, 16717, 16719, 32768, 8864, 114, 59, 32768, 10801, 59, 32768, 10800, 116, 59, 32768, 8749, 768, 101, 112, 115, 16737, 16741, 16775, 97, 59, 32768, 10536, 1024, 59, 98, 99, 102, 16750, 16752, 16757, 16762, 32768, 8868, 111, 116, 59, 32768, 9014, 105, 114, 59, 32768, 10993, 512, 59, 111, 16767, 16770, 32896, 55349, 56677, 114, 107, 59, 32768, 10970, 97, 59, 32768, 10537, 114, 105, 109, 101, 59, 32768, 8244, 768, 97, 105, 112, 16793, 16798, 16899, 100, 101, 59, 32768, 8482, 1792, 97, 100, 101, 109, 112, 115, 116, 16813, 16868, 16873, 16876, 16883, 16889, 16893, 110, 103, 108, 101, 1280, 59, 100, 108, 113, 114, 16828, 16830, 16836, 16850, 16853, 32768, 9653, 111, 119, 110, 59, 32768, 9663, 101, 102, 116, 512, 59, 101, 16844, 16846, 32768, 9667, 113, 59, 32768, 8884, 59, 32768, 8796, 105, 103, 104, 116, 512, 59, 101, 16862, 16864, 32768, 9657, 113, 59, 32768, 8885, 111, 116, 59, 32768, 9708, 59, 32768, 8796, 105, 110, 117, 115, 59, 32768, 10810, 108, 117, 115, 59, 32768, 10809, 98, 59, 32768, 10701, 105, 109, 101, 59, 32768, 10811, 101, 122, 105, 117, 109, 59, 32768, 9186, 768, 99, 104, 116, 16914, 16926, 16931, 512, 114, 121, 16919, 16923, 59, 32896, 55349, 56521, 59, 32768, 1094, 99, 121, 59, 32768, 1115, 114, 111, 107, 59, 32768, 359, 512, 105, 111, 16942, 16947, 120, 116, 59, 32768, 8812, 104, 101, 97, 100, 512, 108, 114, 16956, 16967, 101, 102, 116, 97, 114, 114, 111, 119, 59, 32768, 8606, 105, 103, 104, 116, 97, 114, 114, 111, 119, 59, 32768, 8608, 4608, 65, 72, 97, 98, 99, 100, 102, 103, 104, 108, 109, 111, 112, 114, 115, 116, 117, 119, 17016, 17021, 17026, 17043, 17057, 17072, 17095, 17110, 17119, 17139, 17172, 17187, 17202, 17290, 17330, 17336, 17365, 17381, 114, 114, 59, 32768, 8657, 97, 114, 59, 32768, 10595, 512, 99, 114, 17031, 17039, 117, 116, 101, 33024, 250, 59, 32768, 250, 114, 59, 32768, 8593, 114, 820, 17049, 0, 17053, 121, 59, 32768, 1118, 118, 101, 59, 32768, 365, 512, 105, 121, 17062, 17069, 114, 99, 33024, 251, 59, 32768, 251, 59, 32768, 1091, 768, 97, 98, 104, 17079, 17084, 17090, 114, 114, 59, 32768, 8645, 108, 97, 99, 59, 32768, 369, 97, 114, 59, 32768, 10606, 512, 105, 114, 17100, 17106, 115, 104, 116, 59, 32768, 10622, 59, 32896, 55349, 56626, 114, 97, 118, 101, 33024, 249, 59, 32768, 249, 562, 17123, 17135, 114, 512, 108, 114, 17128, 17131, 59, 32768, 8639, 59, 32768, 8638, 108, 107, 59, 32768, 9600, 512, 99, 116, 17144, 17167, 1088, 17150, 0, 0, 17163, 114, 110, 512, 59, 101, 17156, 17158, 32768, 8988, 114, 59, 32768, 8988, 111, 112, 59, 32768, 8975, 114, 105, 59, 32768, 9720, 512, 97, 108, 17177, 17182, 99, 114, 59, 32768, 363, 33024, 168, 59, 32768, 168, 512, 103, 112, 17192, 17197, 111, 110, 59, 32768, 371, 102, 59, 32896, 55349, 56678, 1536, 97, 100, 104, 108, 115, 117, 17215, 17222, 17233, 17257, 17262, 17280, 114, 114, 111, 119, 59, 32768, 8593, 111, 119, 110, 97, 114, 114, 111, 119, 59, 32768, 8597, 97, 114, 112, 111, 111, 110, 512, 108, 114, 17244, 17250, 101, 102, 116, 59, 32768, 8639, 105, 103, 104, 116, 59, 32768, 8638, 117, 115, 59, 32768, 8846, 105, 768, 59, 104, 108, 17270, 17272, 17275, 32768, 965, 59, 32768, 978, 111, 110, 59, 32768, 965, 112, 97, 114, 114, 111, 119, 115, 59, 32768, 8648, 768, 99, 105, 116, 17297, 17320, 17325, 1088, 17303, 0, 0, 17316, 114, 110, 512, 59, 101, 17309, 17311, 32768, 8989, 114, 59, 32768, 8989, 111, 112, 59, 32768, 8974, 110, 103, 59, 32768, 367, 114, 105, 59, 32768, 9721, 99, 114, 59, 32896, 55349, 56522, 768, 100, 105, 114, 17343, 17348, 17354, 111, 116, 59, 32768, 8944, 108, 100, 101, 59, 32768, 361, 105, 512, 59, 102, 17360, 17362, 32768, 9653, 59, 32768, 9652, 512, 97, 109, 17370, 17375, 114, 114, 59, 32768, 8648, 108, 33024, 252, 59, 32768, 252, 97, 110, 103, 108, 101, 59, 32768, 10663, 3840, 65, 66, 68, 97, 99, 100, 101, 102, 108, 110, 111, 112, 114, 115, 122, 17420, 17425, 17437, 17443, 17613, 17617, 17623, 17667, 17672, 17678, 17693, 17699, 17705, 17711, 17754, 114, 114, 59, 32768, 8661, 97, 114, 512, 59, 118, 17432, 17434, 32768, 10984, 59, 32768, 10985, 97, 115, 104, 59, 32768, 8872, 512, 110, 114, 17448, 17454, 103, 114, 116, 59, 32768, 10652, 1792, 101, 107, 110, 112, 114, 115, 116, 17469, 17478, 17485, 17494, 17515, 17526, 17578, 112, 115, 105, 108, 111, 110, 59, 32768, 1013, 97, 112, 112, 97, 59, 32768, 1008, 111, 116, 104, 105, 110, 103, 59, 32768, 8709, 768, 104, 105, 114, 17501, 17505, 17508, 105, 59, 32768, 981, 59, 32768, 982, 111, 112, 116, 111, 59, 32768, 8733, 512, 59, 104, 17520, 17522, 32768, 8597, 111, 59, 32768, 1009, 512, 105, 117, 17531, 17537, 103, 109, 97, 59, 32768, 962, 512, 98, 112, 17542, 17560, 115, 101, 116, 110, 101, 113, 512, 59, 113, 17553, 17556, 32896, 8842, 65024, 59, 32896, 10955, 65024, 115, 101, 116, 110, 101, 113, 512, 59, 113, 17571, 17574, 32896, 8843, 65024, 59, 32896, 10956, 65024, 512, 104, 114, 17583, 17589, 101, 116, 97, 59, 32768, 977, 105, 97, 110, 103, 108, 101, 512, 108, 114, 17600, 17606, 101, 102, 116, 59, 32768, 8882, 105, 103, 104, 116, 59, 32768, 8883, 121, 59, 32768, 1074, 97, 115, 104, 59, 32768, 8866, 768, 101, 108, 114, 17630, 17648, 17654, 768, 59, 98, 101, 17637, 17639, 17644, 32768, 8744, 97, 114, 59, 32768, 8891, 113, 59, 32768, 8794, 108, 105, 112, 59, 32768, 8942, 512, 98, 116, 17659, 17664, 97, 114, 59, 32768, 124, 59, 32768, 124, 114, 59, 32896, 55349, 56627, 116, 114, 105, 59, 32768, 8882, 115, 117, 512, 98, 112, 17685, 17689, 59, 32896, 8834, 8402, 59, 32896, 8835, 8402, 112, 102, 59, 32896, 55349, 56679, 114, 111, 112, 59, 32768, 8733, 116, 114, 105, 59, 32768, 8883, 512, 99, 117, 17716, 17721, 114, 59, 32896, 55349, 56523, 512, 98, 112, 17726, 17740, 110, 512, 69, 101, 17732, 17736, 59, 32896, 10955, 65024, 59, 32896, 8842, 65024, 110, 512, 69, 101, 17746, 17750, 59, 32896, 10956, 65024, 59, 32896, 8843, 65024, 105, 103, 122, 97, 103, 59, 32768, 10650, 1792, 99, 101, 102, 111, 112, 114, 115, 17777, 17783, 17815, 17820, 17826, 17829, 17842, 105, 114, 99, 59, 32768, 373, 512, 100, 105, 17788, 17809, 512, 98, 103, 17793, 17798, 97, 114, 59, 32768, 10847, 101, 512, 59, 113, 17804, 17806, 32768, 8743, 59, 32768, 8793, 101, 114, 112, 59, 32768, 8472, 114, 59, 32896, 55349, 56628, 112, 102, 59, 32896, 55349, 56680, 59, 32768, 8472, 512, 59, 101, 17834, 17836, 32768, 8768, 97, 116, 104, 59, 32768, 8768, 99, 114, 59, 32896, 55349, 56524, 5428, 17871, 17891, 0, 17897, 0, 17902, 17917, 0, 0, 17920, 17935, 17940, 17945, 0, 0, 17977, 17992, 0, 18008, 18024, 18029, 768, 97, 105, 117, 17877, 17881, 17886, 112, 59, 32768, 8898, 114, 99, 59, 32768, 9711, 112, 59, 32768, 8899, 116, 114, 105, 59, 32768, 9661, 114, 59, 32896, 55349, 56629, 512, 65, 97, 17906, 17911, 114, 114, 59, 32768, 10234, 114, 114, 59, 32768, 10231, 59, 32768, 958, 512, 65, 97, 17924, 17929, 114, 114, 59, 32768, 10232, 114, 114, 59, 32768, 10229, 97, 112, 59, 32768, 10236, 105, 115, 59, 32768, 8955, 768, 100, 112, 116, 17951, 17956, 17970, 111, 116, 59, 32768, 10752, 512, 102, 108, 17961, 17965, 59, 32896, 55349, 56681, 117, 115, 59, 32768, 10753, 105, 109, 101, 59, 32768, 10754, 512, 65, 97, 17981, 17986, 114, 114, 59, 32768, 10233, 114, 114, 59, 32768, 10230, 512, 99, 113, 17996, 18001, 114, 59, 32896, 55349, 56525, 99, 117, 112, 59, 32768, 10758, 512, 112, 116, 18012, 18018, 108, 117, 115, 59, 32768, 10756, 114, 105, 59, 32768, 9651, 101, 101, 59, 32768, 8897, 101, 100, 103, 101, 59, 32768, 8896, 2048, 97, 99, 101, 102, 105, 111, 115, 117, 18052, 18068, 18081, 18087, 18092, 18097, 18103, 18109, 99, 512, 117, 121, 18058, 18065, 116, 101, 33024, 253, 59, 32768, 253, 59, 32768, 1103, 512, 105, 121, 18073, 18078, 114, 99, 59, 32768, 375, 59, 32768, 1099, 110, 33024, 165, 59, 32768, 165, 114, 59, 32896, 55349, 56630, 99, 121, 59, 32768, 1111, 112, 102, 59, 32896, 55349, 56682, 99, 114, 59, 32896, 55349, 56526, 512, 99, 109, 18114, 18118, 121, 59, 32768, 1102, 108, 33024, 255, 59, 32768, 255, 2560, 97, 99, 100, 101, 102, 104, 105, 111, 115, 119, 18145, 18152, 18166, 18171, 18186, 18191, 18196, 18204, 18210, 18216, 99, 117, 116, 101, 59, 32768, 378, 512, 97, 121, 18157, 18163, 114, 111, 110, 59, 32768, 382, 59, 32768, 1079, 111, 116, 59, 32768, 380, 512, 101, 116, 18176, 18182, 116, 114, 102, 59, 32768, 8488, 97, 59, 32768, 950, 114, 59, 32896, 55349, 56631, 99, 121, 59, 32768, 1078, 103, 114, 97, 114, 114, 59, 32768, 8669, 112, 102, 59, 32896, 55349, 56683, 99, 114, 59, 32896, 55349, 56527, 512, 106, 110, 18221, 18224, 59, 32768, 8205, 106, 59, 32768, 8204]);\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n// Generated using scripts/write-decode-map.ts\n// prettier-ignore\nexports.default = new Uint16Array([1024, 97, 103, 108, 113, 9, 23, 27, 31, 1086, 15, 0, 0, 19, 112, 59, 32768, 38, 111, 115, 59, 32768, 39, 116, 59, 32768, 62, 116, 59, 32768, 60, 117, 111, 116, 59, 32768, 34]);\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.decodeXMLStrict = exports.decodeHTML5Strict = exports.decodeHTML4Strict = exports.decodeHTML5 = exports.decodeHTML4 = exports.decodeHTMLStrict = exports.decodeHTML = exports.decodeXML = exports.encodeHTML5 = exports.encodeHTML4 = exports.escapeUTF8 = exports.escape = exports.encodeNonAsciiHTML = exports.encodeHTML = exports.encodeXML = exports.encode = exports.decodeStrict = exports.decode = exports.EncodingMode = exports.DecodingMode = exports.EntityLevel = void 0;\nvar decode_1 = require(\"./decode\");\nvar encode_1 = require(\"./encode\");\n/** The level of entities to support. */\nvar EntityLevel;\n(function (EntityLevel) {\n    /** Support only XML entities. */\n    EntityLevel[EntityLevel[\"XML\"] = 0] = \"XML\";\n    /** Support HTML entities, which are a superset of XML entities. */\n    EntityLevel[EntityLevel[\"HTML\"] = 1] = \"HTML\";\n})(EntityLevel = exports.EntityLevel || (exports.EntityLevel = {}));\n/** Determines whether some entities are allowed to be written without a trailing `;`. */\nvar DecodingMode;\n(function (DecodingMode) {\n    /** Support legacy HTML entities. */\n    DecodingMode[DecodingMode[\"Legacy\"] = 0] = \"Legacy\";\n    /** Do not support legacy HTML entities. */\n    DecodingMode[DecodingMode[\"Strict\"] = 1] = \"Strict\";\n})(DecodingMode = exports.DecodingMode || (exports.DecodingMode = {}));\nvar EncodingMode;\n(function (EncodingMode) {\n    /**\n     * The output is UTF-8 encoded. Only characters that need escaping within\n     * HTML will be escaped.\n     */\n    EncodingMode[EncodingMode[\"UTF8\"] = 0] = \"UTF8\";\n    /**\n     * The output consists only of ASCII characters. Characters that need\n     * escaping within HTML, and characters that aren't ASCII characters will\n     * be escaped.\n     */\n    EncodingMode[EncodingMode[\"ASCII\"] = 1] = \"ASCII\";\n    /**\n     * Encode all characters that have an equivalent entity, as well as all\n     * characters that are not ASCII characters.\n     */\n    EncodingMode[EncodingMode[\"Extensive\"] = 2] = \"Extensive\";\n})(EncodingMode = exports.EncodingMode || (exports.EncodingMode = {}));\n/**\n * Decodes a string with entities.\n *\n * @param data String to decode.\n * @param options Decoding options.\n */\nfunction decode(data, options) {\n    if (options === void 0) { options = EntityLevel.XML; }\n    var opts = typeof options === \"number\" ? { level: options } : options;\n    if (opts.level === EntityLevel.HTML) {\n        if (opts.mode === DecodingMode.Strict) {\n            return decode_1.decodeHTMLStrict(data);\n        }\n        return decode_1.decodeHTML(data);\n    }\n    return decode_1.decodeXML(data);\n}\nexports.decode = decode;\n/**\n * Decodes a string with entities. Does not allow missing trailing semicolons for entities.\n *\n * @param data String to decode.\n * @param options Decoding options.\n * @deprecated Use `decode` with the `mode` set to `Strict`.\n */\nfunction decodeStrict(data, options) {\n    if (options === void 0) { options = EntityLevel.XML; }\n    var opts = typeof options === \"number\" ? { level: options } : options;\n    if (opts.level === EntityLevel.HTML) {\n        if (opts.mode === DecodingMode.Legacy) {\n            return decode_1.decodeHTML(data);\n        }\n        return decode_1.decodeHTMLStrict(data);\n    }\n    return decode_1.decodeXML(data);\n}\nexports.decodeStrict = decodeStrict;\n/**\n * Encodes a string with entities.\n *\n * @param data String to encode.\n * @param options Encoding options.\n */\nfunction encode(data, options) {\n    if (options === void 0) { options = EntityLevel.XML; }\n    var opts = typeof options === \"number\" ? { level: options } : options;\n    // Mode `UTF8` just escapes XML entities\n    if (opts.mode === EncodingMode.UTF8)\n        return encode_1.escapeUTF8(data);\n    if (opts.level === EntityLevel.HTML) {\n        if (opts.mode === EncodingMode.ASCII) {\n            return encode_1.encodeNonAsciiHTML(data);\n        }\n        return encode_1.encodeHTML(data);\n    }\n    // ASCII and Extensive are equivalent\n    return encode_1.encodeXML(data);\n}\nexports.encode = encode;\nvar encode_2 = require(\"./encode\");\nObject.defineProperty(exports, \"encodeXML\", { enumerable: true, get: function () { return encode_2.encodeXML; } });\nObject.defineProperty(exports, \"encodeHTML\", { enumerable: true, get: function () { return encode_2.encodeHTML; } });\nObject.defineProperty(exports, \"encodeNonAsciiHTML\", { enumerable: true, get: function () { return encode_2.encodeNonAsciiHTML; } });\nObject.defineProperty(exports, \"escape\", { enumerable: true, get: function () { return encode_2.escape; } });\nObject.defineProperty(exports, \"escapeUTF8\", { enumerable: true, get: function () { return encode_2.escapeUTF8; } });\n// Legacy aliases (deprecated)\nObject.defineProperty(exports, \"encodeHTML4\", { enumerable: true, get: function () { return encode_2.encodeHTML; } });\nObject.defineProperty(exports, \"encodeHTML5\", { enumerable: true, get: function () { return encode_2.encodeHTML; } });\nvar decode_2 = require(\"./decode\");\nObject.defineProperty(exports, \"decodeXML\", { enumerable: true, get: function () { return decode_2.decodeXML; } });\nObject.defineProperty(exports, \"decodeHTML\", { enumerable: true, get: function () { return decode_2.decodeHTML; } });\nObject.defineProperty(exports, \"decodeHTMLStrict\", { enumerable: true, get: function () { return decode_2.decodeHTMLStrict; } });\n// Legacy aliases (deprecated)\nObject.defineProperty(exports, \"decodeHTML4\", { enumerable: true, get: function () { return decode_2.decodeHTML; } });\nObject.defineProperty(exports, \"decodeHTML5\", { enumerable: true, get: function () { return decode_2.decodeHTML; } });\nObject.defineProperty(exports, \"decodeHTML4Strict\", { enumerable: true, get: function () { return decode_2.decodeHTMLStrict; } });\nObject.defineProperty(exports, \"decodeHTML5Strict\", { enumerable: true, get: function () { return decode_2.decodeHTMLStrict; } });\nObject.defineProperty(exports, \"decodeXMLStrict\", { enumerable: true, get: function () { return decode_2.decodeXML; } });\n","/*!\n * content-type\n * Copyright(c) 2015 Douglas Christopher Wilson\n * MIT Licensed\n */\n\n'use strict'\n\n/**\n * RegExp to match *( \";\" parameter ) in RFC 7231 sec 3.1.1.1\n *\n * parameter     = token \"=\" ( token / quoted-string )\n * token         = 1*tchar\n * tchar         = \"!\" / \"#\" / \"$\" / \"%\" / \"&\" / \"'\" / \"*\"\n *               / \"+\" / \"-\" / \".\" / \"^\" / \"_\" / \"`\" / \"|\" / \"~\"\n *               / DIGIT / ALPHA\n *               ; any VCHAR, except delimiters\n * quoted-string = DQUOTE *( qdtext / quoted-pair ) DQUOTE\n * qdtext        = HTAB / SP / %x21 / %x23-5B / %x5D-7E / obs-text\n * obs-text      = %x80-FF\n * quoted-pair   = \"\\\" ( HTAB / SP / VCHAR / obs-text )\n */\nvar PARAM_REGEXP = /; *([!#$%&'*+.^_`|~0-9A-Za-z-]+) *= *(\"(?:[\\u000b\\u0020\\u0021\\u0023-\\u005b\\u005d-\\u007e\\u0080-\\u00ff]|\\\\[\\u000b\\u0020-\\u00ff])*\"|[!#$%&'*+.^_`|~0-9A-Za-z-]+) */g // eslint-disable-line no-control-regex\nvar TEXT_REGEXP = /^[\\u000b\\u0020-\\u007e\\u0080-\\u00ff]+$/ // eslint-disable-line no-control-regex\nvar TOKEN_REGEXP = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/\n\n/**\n * RegExp to match quoted-pair in RFC 7230 sec 3.2.6\n *\n * quoted-pair = \"\\\" ( HTAB / SP / VCHAR / obs-text )\n * obs-text    = %x80-FF\n */\nvar QESC_REGEXP = /\\\\([\\u000b\\u0020-\\u00ff])/g // eslint-disable-line no-control-regex\n\n/**\n * RegExp to match chars that must be quoted-pair in RFC 7230 sec 3.2.6\n */\nvar QUOTE_REGEXP = /([\\\\\"])/g\n\n/**\n * RegExp to match type in RFC 7231 sec 3.1.1.1\n *\n * media-type = type \"/\" subtype\n * type       = token\n * subtype    = token\n */\nvar TYPE_REGEXP = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+\\/[!#$%&'*+.^_`|~0-9A-Za-z-]+$/\n\n/**\n * Module exports.\n * @public\n */\n\nexports.format = format\nexports.parse = parse\n\n/**\n * Format object to media type.\n *\n * @param {object} obj\n * @return {string}\n * @public\n */\n\nfunction format (obj) {\n  if (!obj || typeof obj !== 'object') {\n    throw new TypeError('argument obj is required')\n  }\n\n  var parameters = obj.parameters\n  var type = obj.type\n\n  if (!type || !TYPE_REGEXP.test(type)) {\n    throw new TypeError('invalid type')\n  }\n\n  var string = type\n\n  // append parameters\n  if (parameters && typeof parameters === 'object') {\n    var param\n    var params = Object.keys(parameters).sort()\n\n    for (var i = 0; i < params.length; i++) {\n      param = params[i]\n\n      if (!TOKEN_REGEXP.test(param)) {\n        throw new TypeError('invalid parameter name')\n      }\n\n      string += '; ' + param + '=' + qstring(parameters[param])\n    }\n  }\n\n  return string\n}\n\n/**\n * Parse media type to object.\n *\n * @param {string|object} string\n * @return {Object}\n * @public\n */\n\nfunction parse (string) {\n  if (!string) {\n    throw new TypeError('argument string is required')\n  }\n\n  // support req/res-like objects as argument\n  var header = typeof string === 'object'\n    ? getcontenttype(string)\n    : string\n\n  if (typeof header !== 'string') {\n    throw new TypeError('argument string is required to be a string')\n  }\n\n  var index = header.indexOf(';')\n  var type = index !== -1\n    ? header.slice(0, index).trim()\n    : header.trim()\n\n  if (!TYPE_REGEXP.test(type)) {\n    throw new TypeError('invalid media type')\n  }\n\n  var obj = new ContentType(type.toLowerCase())\n\n  // parse parameters\n  if (index !== -1) {\n    var key\n    var match\n    var value\n\n    PARAM_REGEXP.lastIndex = index\n\n    while ((match = PARAM_REGEXP.exec(header))) {\n      if (match.index !== index) {\n        throw new TypeError('invalid parameter format')\n      }\n\n      index += match[0].length\n      key = match[1].toLowerCase()\n      value = match[2]\n\n      if (value.charCodeAt(0) === 0x22 /* \" */) {\n        // remove quotes\n        value = value.slice(1, -1)\n\n        // remove escapes\n        if (value.indexOf('\\\\') !== -1) {\n          value = value.replace(QESC_REGEXP, '$1')\n        }\n      }\n\n      obj.parameters[key] = value\n    }\n\n    if (index !== header.length) {\n      throw new TypeError('invalid parameter format')\n    }\n  }\n\n  return obj\n}\n\n/**\n * Get content-type from req/res objects.\n *\n * @param {object}\n * @return {Object}\n * @private\n */\n\nfunction getcontenttype (obj) {\n  var header\n\n  if (typeof obj.getHeader === 'function') {\n    // res-like\n    header = obj.getHeader('content-type')\n  } else if (typeof obj.headers === 'object') {\n    // req-like\n    header = obj.headers && obj.headers['content-type']\n  }\n\n  if (typeof header !== 'string') {\n    throw new TypeError('content-type header is missing from object')\n  }\n\n  return header\n}\n\n/**\n * Quote a string if necessary.\n *\n * @param {string} val\n * @return {string}\n * @private\n */\n\nfunction qstring (val) {\n  var str = String(val)\n\n  // no need to quote tokens\n  if (TOKEN_REGEXP.test(str)) {\n    return str\n  }\n\n  if (str.length > 0 && !TEXT_REGEXP.test(str)) {\n    throw new TypeError('invalid parameter value')\n  }\n\n  return '\"' + str.replace(QUOTE_REGEXP, '\\\\$1') + '\"'\n}\n\n/**\n * Class to represent a content type.\n * @private\n */\nfunction ContentType (type) {\n  this.parameters = Object.create(null)\n  this.type = type\n}\n","'use strict';\n\nvar extend  = require('extend');\nvar isArray = require('util').isArray;\nvar isDate  = require('util').isDate;\nvar sprintf = require(\"sprintf-js\").sprintf;\nvar events  = require('events');\nvar except  = require('except');\n\nvar strftime = require('./strftime');\n\nvar translationScope = 'counterpart';\n\nfunction isString(val) {\n  return typeof val === 'string' || Object.prototype.toString.call(val) === '[object String]';\n}\n\nfunction isFunction(val) {\n  return typeof val === 'function' || Object.prototype.toString.call(val) === '[object Function]';\n}\n\nfunction isPlainObject(val) {\n  //Deal with older browsers (IE8) that don't return [object Null] in this case.\n  if (val === null) {\n    return false;\n  }\n  return Object.prototype.toString.call(val) === '[object Object]';\n}\n\nfunction isSymbol(key) {\n  return isString(key) && key[0] === ':';\n}\n\nfunction hasOwnProp(obj, key) {\n  return Object.prototype.hasOwnProperty.call(obj, key);\n}\n\nfunction getEntry(translations, keys) {\n  return keys.reduce(function(result, key) {\n    if (isPlainObject(result) && hasOwnProp(result, key)) {\n      return result[key];\n    } else {\n      return null;\n    }\n  }, translations);\n}\n\nfunction Counterpart() {\n  events.EventEmitter.apply(this);\n\n  this._registry = {\n    locale: 'en',\n    interpolate: true,\n    fallbackLocales: [],\n    scope: null,\n    translations: {},\n    interpolations: {},\n    normalizedKeys: {},\n    separator: '.',\n    keepTrailingDot: false,\n    keyTransformer: function(key) { return key; },\n    generateMissingEntry: function(key) { return 'missing translation: ' + key; }\n  };\n\n  this.registerTranslations('en', require('./locales/en'));\n  this.setMaxListeners(0);\n}\n\nCounterpart.prototype = events.EventEmitter.prototype;\nCounterpart.prototype.constructor = events.EventEmitter;\n\nCounterpart.prototype.getLocale = function() {\n  return this._registry.locale;\n};\n\nCounterpart.prototype.setLocale = function(value) {\n  var previous = this._registry.locale;\n\n  if (previous != value) {\n    this._registry.locale = value;\n    this.emit('localechange', value, previous);\n  }\n\n  return previous;\n};\n\nCounterpart.prototype.getFallbackLocale = function() {\n  return this._registry.fallbackLocales;\n};\n\nCounterpart.prototype.setFallbackLocale = function(value) {\n  var previous = this._registry.fallbackLocales;\n  this._registry.fallbackLocales = [].concat(value || []);\n  return previous;\n};\n\nCounterpart.prototype.getAvailableLocales = function() {\n  return this._registry.availableLocales || Object.keys(this._registry.translations);\n};\n\nCounterpart.prototype.setAvailableLocales = function(value) {\n  var previous = this.getAvailableLocales();\n  this._registry.availableLocales = value;\n  return previous;\n};\n\nCounterpart.prototype.getSeparator = function() {\n  return this._registry.separator;\n};\n\nCounterpart.prototype.setSeparator = function(value) {\n  var previous = this._registry.separator;\n  this._registry.separator = value;\n  return previous;\n};\n\nCounterpart.prototype.setInterpolate = function(value) {\n  var previous = this._registry.interpolate;\n  this._registry.interpolate = value;\n  return previous;\n};\n\nCounterpart.prototype.getInterpolate = function() {\n  return this._registry.interpolate;\n};\n\nCounterpart.prototype.setKeyTransformer = function(value) {\n  var previous = this._registry.keyTransformer;\n  this._registry.keyTransformer = value;\n  return previous;\n};\n\nCounterpart.prototype.getKeyTransformer = function() {\n  return this._registry.keyTransformer;\n};\n\nCounterpart.prototype.setMissingEntryGenerator = function(value) {\n  var previous = this._registry.generateMissingEntry;\n  this._registry.generateMissingEntry = value;\n  return previous;\n};\n\nCounterpart.prototype.getMissingEntryGenerator = function() {\n  return this._registry.generateMissingEntry;\n};\n\nCounterpart.prototype.registerTranslations = function(locale, data) {\n  var translations = {};\n  translations[locale] = data;\n  extend(true, this._registry.translations, translations);\n  return translations;\n};\n\nCounterpart.prototype.registerInterpolations = function(data) {\n  return extend(true, this._registry.interpolations, data);\n};\n\nCounterpart.prototype.onLocaleChange =\nCounterpart.prototype.addLocaleChangeListener = function(callback) {\n  this.addListener('localechange', callback);\n};\n\nCounterpart.prototype.offLocaleChange =\nCounterpart.prototype.removeLocaleChangeListener = function(callback) {\n  this.removeListener('localechange', callback);\n};\n\nCounterpart.prototype.onTranslationNotFound =\nCounterpart.prototype.addTranslationNotFoundListener = function(callback) {\n  this.addListener('translationnotfound', callback);\n};\n\nCounterpart.prototype.offTranslationNotFound =\nCounterpart.prototype.removeTranslationNotFoundListener = function(callback) {\n  this.removeListener('translationnotfound', callback);\n};\n\nCounterpart.prototype.onError =\nCounterpart.prototype.addErrorListener = function(callback) {\n  this.addListener('error', callback);\n};\n\nCounterpart.prototype.offError =\nCounterpart.prototype.removeErrorListener = function(callback) {\n  this.removeListener('error', callback);\n};\n\nCounterpart.prototype.translate = function(key, options) {\n  if (!isArray(key) && !isString(key) || !key.length) {\n    throw new Error('invalid argument: key');\n  }\n\n  if (isSymbol(key)) {\n    key = key.substr(1);\n  }\n\n  key = this._registry.keyTransformer(key, options);\n\n  options = extend(true, {}, options);\n\n  var locale = options.locale || this._registry.locale;\n  delete options.locale;\n\n  var scope = options.scope || this._registry.scope;\n  delete options.scope;\n\n  var separator = options.separator || this._registry.separator;\n  delete options.separator;\n\n  var fallbackLocales = [].concat(options.fallbackLocale || this._registry.fallbackLocales);\n  delete options.fallbackLocale;\n\n  var keys = this._normalizeKeys(locale, scope, key, separator);\n\n  var entry = getEntry(this._registry.translations, keys);\n\n  if (entry === null) {\n    this.emit('translationnotfound', locale, key, options.fallback, scope);\n\n    if (options.fallback) {\n      entry = this._fallback(locale, scope, key, options.fallback, options);\n    }\n  }\n\n  if (entry === null && fallbackLocales.length > 0 && fallbackLocales.indexOf(locale) === -1) {\n    for (var i = 0, ii = fallbackLocales.length; i < ii; i++) {\n      var fallbackLocale = fallbackLocales[i];\n      var fallbackKeys = this._normalizeKeys(fallbackLocale, scope, key, separator);\n      entry = getEntry(this._registry.translations, fallbackKeys);\n\n      if (entry) {\n        locale = fallbackLocale;\n        break;\n      }\n    }\n  }\n\n  if (entry === null) {\n    entry = this._registry.generateMissingEntry(keys.join(separator));\n  }\n\n  entry = this._pluralize(locale, entry, options.count);\n\n  if (this._registry.interpolate !== false && options.interpolate !== false) {\n    entry = this._interpolate(entry, options);\n  }\n\n  return entry;\n};\n\nCounterpart.prototype.localize = function(object, options) {\n  if (!isDate(object)) {\n    throw new Error('invalid argument: object must be a date');\n  }\n\n  options = extend(true, {}, options);\n\n  var locale  = options.locale  || this._registry.locale;\n  var scope   = options.scope   || translationScope;\n  var type    = options.type    || 'datetime';\n  var format  = options.format  || 'default';\n\n  options = { locale: locale, scope: scope, interpolate: false };\n  format  = this.translate(['formats', type, format], extend(true, {}, options));\n\n  return strftime(object, format, this.translate('names', options));\n};\n\nCounterpart.prototype._pluralize = function(locale, entry, count) {\n  if (typeof entry !== 'object' || entry === null || typeof count !== 'number') {\n    return entry;\n  }\n\n  var pluralizeFunc = this.translate('pluralize', { locale: locale, scope: translationScope });\n\n  if (Object.prototype.toString.call(pluralizeFunc) !== '[object Function]') {\n    return pluralizeFunc;\n  }\n\n  return pluralizeFunc(entry, count);\n};\n\nCounterpart.prototype.withLocale = function(locale, callback, context) {\n  var previous = this._registry.locale;\n  this._registry.locale = locale;\n  var result = callback.call(context);\n  this._registry.locale = previous;\n  return result;\n};\n\nCounterpart.prototype.withScope = function(scope, callback, context) {\n  var previous = this._registry.scope;\n  this._registry.scope = scope;\n  var result = callback.call(context);\n  this._registry.scope = previous;\n  return result;\n};\n\nCounterpart.prototype.withSeparator = function(separator, callback, context) {\n  var previous = this.setSeparator(separator);\n  var result = callback.call(context);\n  this.setSeparator(previous);\n  return result;\n};\n\nCounterpart.prototype._normalizeKeys = function(locale, scope, key, separator) {\n  var keys = [];\n\n  keys = keys.concat(this._normalizeKey(locale, separator));\n  keys = keys.concat(this._normalizeKey(scope, separator));\n  keys = keys.concat(this._normalizeKey(key, separator));\n\n  return keys;\n};\n\nCounterpart.prototype._normalizeKey = function(key, separator) {\n  this._registry.normalizedKeys[separator] = this._registry.normalizedKeys[separator] || {};\n\n  this._registry.normalizedKeys[separator][key] = this._registry.normalizedKeys[separator][key] || (function(key) {\n    if (isArray(key)) {\n      var normalizedKeyArray = key.map(function(k) { return this._normalizeKey(k, separator); }.bind(this));\n\n      return [].concat.apply([], normalizedKeyArray);\n    } else {\n      if (typeof key === 'undefined' || key === null) {\n        return [];\n      }\n\n      var keys = key.split(separator);\n\n      for (var i = keys.length - 1; i >= 0; i--) {\n        if (keys[i] === '') {\n          keys.splice(i, 1);\n\n          if (this._registry.keepTrailingDot === true && i == keys.length) {\n            keys[keys.length - 1] += '' + separator;\n          }\n        }\n      }\n\n      return keys;\n    }\n  }.bind(this))(key);\n\n  return this._registry.normalizedKeys[separator][key];\n};\n\nCounterpart.prototype._interpolate = function(entry, values) {\n  if (typeof entry !== 'string') {\n    return entry;\n  }\n\n  try {\n    return sprintf(entry, extend({}, this._registry.interpolations, values));\n  } catch (err) {\n    if (this.listenerCount('error') > 0) {\n      this.emit('error', err, entry, values);\n    } else {\n      throw err;\n    }\n    return null;\n  }\n};\n\nCounterpart.prototype._resolve = function(locale, scope, object, subject, options) {\n  options = options || {};\n\n  if (options.resolve === false) {\n    return subject;\n  }\n\n  var result;\n\n  if (isSymbol(subject)) {\n    result = this.translate(subject, extend({}, options, { locale: locale, scope: scope }));\n  } else if (isFunction(subject)) {\n    var dateOrTime;\n\n    if (options.object) {\n      dateOrTime = options.object;\n      delete options.object;\n    } else {\n      dateOrTime = object;\n    }\n\n    result = this._resolve(locale, scope, object, subject(dateOrTime, options));\n  } else {\n    result = subject;\n  }\n\n  return /^missing translation:/.test(result) ? null : result;\n};\n\nCounterpart.prototype._fallback = function(locale, scope, object, subject, options) {\n  options = except(options, 'fallback');\n\n  if (isArray(subject)) {\n    for (var i = 0, ii = subject.length; i < ii; i++) {\n      var result = this._resolve(locale, scope, object, subject[i], options);\n\n      if (result) {\n        return result;\n      }\n    }\n\n    return null;\n  } else {\n    return this._resolve(locale, scope, object, subject, options);\n  }\n};\n\nvar instance = new Counterpart();\n\nfunction translate() {\n  return instance.translate.apply(instance, arguments);\n}\n\nextend(translate, instance, {\n  Instance: Counterpart,\n  Translator: Counterpart\n});\n\nmodule.exports = translate;\n","// The translations in this file are added by default.\n\n'use strict';\n\nmodule.exports = {\n  counterpart: {\n    names: require('date-names/en'),\n    pluralize: require('pluralizers/en'),\n\n    formats: {\n      date: {\n        'default':  '%a, %e %b %Y',\n        long:       '%A, %B %o, %Y',\n        short:      '%b %e'\n      },\n\n      time: {\n        'default':  '%H:%M',\n        long:       '%H:%M:%S %z',\n        short:      '%H:%M'\n      },\n\n      datetime: {\n        'default':  '%a, %e %b %Y %H:%M',\n        long:       '%A, %B %o, %Y %H:%M:%S %z',\n        short:      '%e %b %H:%M'\n      }\n    }\n  }\n};\n","'use strict';\n\nvar dateNames = require('date-names');\n\nfunction strftime(date, format, names) {\n  var timestamp = date.getTime();\n\n  names = names || dateNames;\n\n  return format.replace(/%([-_0]?.)/g, function(_, c) {\n    var padding = null;\n\n    if (c.length == 2) {\n      switch (c[0]) {\n        case '-': padding = '';  break;\n        case '_': padding = ' '; break;\n        case '0': padding = '0'; break;\n        default: return _; // should never reach this one\n      }\n\n      c = c[1];\n    }\n\n    switch (c) {\n      case 'A': return names.days[date.getDay()];\n      case 'a': return names.abbreviated_days[date.getDay()];\n      case 'B': return names.months[date.getMonth()];\n      case 'b': return names.abbreviated_months[date.getMonth()];\n      case 'C': return pad(Math.floor(date.getFullYear() / 100), padding);\n      case 'D': return strftime(date, '%m/%d/%y');\n      case 'd': return pad(date.getDate(), padding);\n      case 'e': return date.getDate();\n      case 'F': return strftime(date, '%Y-%m-%d');\n      case 'H': return pad(date.getHours(), padding);\n      case 'h': return names.abbreviated_months[date.getMonth()];\n      case 'I': return pad(hours12(date), padding);\n      case 'j': return pad(Math.ceil((date.getTime() - (new Date(date.getFullYear(), 0, 1)).getTime()) / (1000 * 60 * 60 * 24)), 3);\n      case 'k': return pad(date.getHours(), padding === null ? ' ' : padding);\n      case 'L': return pad(Math.floor(timestamp % 1000), 3);\n      case 'l': return pad(hours12(date), padding === null ? ' ' : padding);\n      case 'M': return pad(date.getMinutes(), padding);\n      case 'm': return pad(date.getMonth() + 1, padding);\n      case 'n': return '\\n';\n      case 'o': return String(date.getDate()) + ordinal(date.getDate());\n      case 'P': return date.getHours() < 12 ? names.am.toLowerCase() : names.pm.toLowerCase();\n      case 'p': return date.getHours() < 12 ? names.am.toUpperCase() : names.pm.toUpperCase();\n      case 'R': return strftime(date, '%H:%M');\n      case 'r': return strftime(date, '%I:%M:%S %p');\n      case 'S': return pad(date.getSeconds(), padding);\n      case 's': return Math.floor(timestamp / 1000);\n      case 'T': return strftime(date, '%H:%M:%S');\n      case 't': return '\\t';\n      case 'U': return pad(weekNumber(date, 'sunday'), padding);\n      case 'u': return date.getDay() === 0 ? 7 : date.getDay();\n      case 'v': return strftime(date, '%e-%b-%Y');\n      case 'W': return pad(weekNumber(date, 'monday'), padding);\n      case 'w': return date.getDay();\n      case 'Y': return date.getFullYear();\n      case 'y': var y = String(date.getFullYear()); return y.slice(y.length - 2);\n      case 'Z': var tzString = date.toString().match(/\\((\\w+)\\)/); return tzString && tzString[1] || '';\n      case 'z': var off = date.getTimezoneOffset(); return (off > 0 ? '-' : '+') + pad(Math.round(Math.abs(off / 60)), 2) + ':' + pad(off % 60, 2);\n      default: return c;\n    }\n  });\n}\n\nfunction pad(n, padding, length) {\n  if (typeof padding === 'number') {\n    length = padding;\n    padding = '0';\n  }\n\n  if (padding === null) {\n    padding = '0';\n  }\n\n  length = length || 2;\n\n  var s = String(n);\n\n  if (padding) {\n    while (s.length < length) {\n      s = padding + s;\n    }\n  }\n\n  return s;\n}\n\nfunction hours12(date) {\n  var hour = date.getHours();\n\n  if (hour === 0) {\n    hour = 12;\n  } else if (hour > 12) {\n    hour -= 12;\n  }\n\n  return hour;\n}\n\nfunction ordinal(n) {\n  var i = n % 10, ii = n % 100;\n\n  if ((ii >= 11 && ii <= 13) || i === 0 || i >= 4) {\n    return 'th';\n  }\n\n  switch (i) {\n    case 1: return 'st';\n    case 2: return 'nd';\n    case 3: return 'rd';\n  }\n}\n\nfunction weekNumber(date, firstWeekday) {\n  firstWeekday = firstWeekday || 'sunday';\n\n  var wday = date.getDay();\n\n  if (firstWeekday == 'monday') {\n    if (wday === 0) { // Sunday\n      wday = 6;\n    } else {\n      wday--;\n    }\n  }\n\n  var\n    firstDayOfYear = new Date(date.getFullYear(), 0, 1),\n    yday = (date - firstDayOfYear) / 86400000,\n    weekNum = (yday + 7 - wday) / 7;\n\n  return Math.floor(weekNum);\n}\n\nmodule.exports = strftime;\n","\"use strict\";\n\nmodule.exports = {\n  __locale: \"en\",\n  days: ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'],\n  abbreviated_days: ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'],\n  months: ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'],\n  abbreviated_months: ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'],\n  am: 'AM',\n  pm: 'PM'\n};\n","\"use strict\";\nmodule.exports = require('./en');\n","'use strict';\n\nvar isMergeableObject = function isMergeableObject(value) {\n\treturn isNonNullObject(value)\n\t\t&& !isSpecial(value)\n};\n\nfunction isNonNullObject(value) {\n\treturn !!value && typeof value === 'object'\n}\n\nfunction isSpecial(value) {\n\tvar stringValue = Object.prototype.toString.call(value);\n\n\treturn stringValue === '[object RegExp]'\n\t\t|| stringValue === '[object Date]'\n\t\t|| isReactElement(value)\n}\n\n// see https://github.com/facebook/react/blob/b5ac963fb791d1298e7f396236383bc955f916c1/src/isomorphic/classic/element/ReactElement.js#L21-L25\nvar canUseSymbol = typeof Symbol === 'function' && Symbol.for;\nvar REACT_ELEMENT_TYPE = canUseSymbol ? Symbol.for('react.element') : 0xeac7;\n\nfunction isReactElement(value) {\n\treturn value.$$typeof === REACT_ELEMENT_TYPE\n}\n\nfunction emptyTarget(val) {\n\treturn Array.isArray(val) ? [] : {}\n}\n\nfunction cloneUnlessOtherwiseSpecified(value, options) {\n\treturn (options.clone !== false && options.isMergeableObject(value))\n\t\t? deepmerge(emptyTarget(value), value, options)\n\t\t: value\n}\n\nfunction defaultArrayMerge(target, source, options) {\n\treturn target.concat(source).map(function(element) {\n\t\treturn cloneUnlessOtherwiseSpecified(element, options)\n\t})\n}\n\nfunction getMergeFunction(key, options) {\n\tif (!options.customMerge) {\n\t\treturn deepmerge\n\t}\n\tvar customMerge = options.customMerge(key);\n\treturn typeof customMerge === 'function' ? customMerge : deepmerge\n}\n\nfunction getEnumerableOwnPropertySymbols(target) {\n\treturn Object.getOwnPropertySymbols\n\t\t? Object.getOwnPropertySymbols(target).filter(function(symbol) {\n\t\t\treturn Object.propertyIsEnumerable.call(target, symbol)\n\t\t})\n\t\t: []\n}\n\nfunction getKeys(target) {\n\treturn Object.keys(target).concat(getEnumerableOwnPropertySymbols(target))\n}\n\nfunction propertyIsOnObject(object, property) {\n\ttry {\n\t\treturn property in object\n\t} catch(_) {\n\t\treturn false\n\t}\n}\n\n// Protects from prototype poisoning and unexpected merging up the prototype chain.\nfunction propertyIsUnsafe(target, key) {\n\treturn propertyIsOnObject(target, key) // Properties are safe to merge if they don't exist in the target yet,\n\t\t&& !(Object.hasOwnProperty.call(target, key) // unsafe if they exist up the prototype chain,\n\t\t\t&& Object.propertyIsEnumerable.call(target, key)) // and also unsafe if they're nonenumerable.\n}\n\nfunction mergeObject(target, source, options) {\n\tvar destination = {};\n\tif (options.isMergeableObject(target)) {\n\t\tgetKeys(target).forEach(function(key) {\n\t\t\tdestination[key] = cloneUnlessOtherwiseSpecified(target[key], options);\n\t\t});\n\t}\n\tgetKeys(source).forEach(function(key) {\n\t\tif (propertyIsUnsafe(target, key)) {\n\t\t\treturn\n\t\t}\n\n\t\tif (propertyIsOnObject(target, key) && options.isMergeableObject(source[key])) {\n\t\t\tdestination[key] = getMergeFunction(key, options)(target[key], source[key], options);\n\t\t} else {\n\t\t\tdestination[key] = cloneUnlessOtherwiseSpecified(source[key], options);\n\t\t}\n\t});\n\treturn destination\n}\n\nfunction deepmerge(target, source, options) {\n\toptions = options || {};\n\toptions.arrayMerge = options.arrayMerge || defaultArrayMerge;\n\toptions.isMergeableObject = options.isMergeableObject || isMergeableObject;\n\t// cloneUnlessOtherwiseSpecified is added to `options` so that custom arrayMerge()\n\t// implementations can use it. The caller may not replace it.\n\toptions.cloneUnlessOtherwiseSpecified = cloneUnlessOtherwiseSpecified;\n\n\tvar sourceIsArray = Array.isArray(source);\n\tvar targetIsArray = Array.isArray(target);\n\tvar sourceAndTargetTypesMatch = sourceIsArray === targetIsArray;\n\n\tif (!sourceAndTargetTypesMatch) {\n\t\treturn cloneUnlessOtherwiseSpecified(source, options)\n\t} else if (sourceIsArray) {\n\t\treturn options.arrayMerge(target, source, options)\n\t} else {\n\t\treturn mergeObject(target, source, options)\n\t}\n}\n\ndeepmerge.all = function deepmergeAll(array, options) {\n\tif (!Array.isArray(array)) {\n\t\tthrow new Error('first argument should be an array')\n\t}\n\n\treturn array.reduce(function(prev, next) {\n\t\treturn deepmerge(prev, next, options)\n\t}, {})\n};\n\nvar deepmerge_1 = deepmerge;\n\nmodule.exports = deepmerge_1;\n","'use strict';\n\nvar $defineProperty = require('es-define-property');\n\nvar $SyntaxError = require('es-errors/syntax');\nvar $TypeError = require('es-errors/type');\n\nvar gopd = require('gopd');\n\n/** @type {import('.')} */\nmodule.exports = function defineDataProperty(\n\tobj,\n\tproperty,\n\tvalue\n) {\n\tif (!obj || (typeof obj !== 'object' && typeof obj !== 'function')) {\n\t\tthrow new $TypeError('`obj` must be an object or a function`');\n\t}\n\tif (typeof property !== 'string' && typeof property !== 'symbol') {\n\t\tthrow new $TypeError('`property` must be a string or a symbol`');\n\t}\n\tif (arguments.length > 3 && typeof arguments[3] !== 'boolean' && arguments[3] !== null) {\n\t\tthrow new $TypeError('`nonEnumerable`, if provided, must be a boolean or null');\n\t}\n\tif (arguments.length > 4 && typeof arguments[4] !== 'boolean' && arguments[4] !== null) {\n\t\tthrow new $TypeError('`nonWritable`, if provided, must be a boolean or null');\n\t}\n\tif (arguments.length > 5 && typeof arguments[5] !== 'boolean' && arguments[5] !== null) {\n\t\tthrow new $TypeError('`nonConfigurable`, if provided, must be a boolean or null');\n\t}\n\tif (arguments.length > 6 && typeof arguments[6] !== 'boolean') {\n\t\tthrow new $TypeError('`loose`, if provided, must be a boolean');\n\t}\n\n\tvar nonEnumerable = arguments.length > 3 ? arguments[3] : null;\n\tvar nonWritable = arguments.length > 4 ? arguments[4] : null;\n\tvar nonConfigurable = arguments.length > 5 ? arguments[5] : null;\n\tvar loose = arguments.length > 6 ? arguments[6] : false;\n\n\t/* @type {false | TypedPropertyDescriptor<unknown>} */\n\tvar desc = !!gopd && gopd(obj, property);\n\n\tif ($defineProperty) {\n\t\t$defineProperty(obj, property, {\n\t\t\tconfigurable: nonConfigurable === null && desc ? desc.configurable : !nonConfigurable,\n\t\t\tenumerable: nonEnumerable === null && desc ? desc.enumerable : !nonEnumerable,\n\t\t\tvalue: value,\n\t\t\twritable: nonWritable === null && desc ? desc.writable : !nonWritable\n\t\t});\n\t} else if (loose || (!nonEnumerable && !nonWritable && !nonConfigurable)) {\n\t\t// must fall back to [[Set]], and was not explicitly asked to make non-enumerable, non-writable, or non-configurable\n\t\tobj[property] = value; // eslint-disable-line no-param-reassign\n\t} else {\n\t\tthrow new $SyntaxError('This environment does not support defining a property as non-configurable, non-writable, or non-enumerable.');\n\t}\n};\n","/******************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise, SuppressedError, Symbol */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    if (typeof b !== \"function\" && b !== null)\r\n        throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {\r\n    function accept(f) { if (f !== void 0 && typeof f !== \"function\") throw new TypeError(\"Function expected\"); return f; }\r\n    var kind = contextIn.kind, key = kind === \"getter\" ? \"get\" : kind === \"setter\" ? \"set\" : \"value\";\r\n    var target = !descriptorIn && ctor ? contextIn[\"static\"] ? ctor : ctor.prototype : null;\r\n    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});\r\n    var _, done = false;\r\n    for (var i = decorators.length - 1; i >= 0; i--) {\r\n        var context = {};\r\n        for (var p in contextIn) context[p] = p === \"access\" ? {} : contextIn[p];\r\n        for (var p in contextIn.access) context.access[p] = contextIn.access[p];\r\n        context.addInitializer = function (f) { if (done) throw new TypeError(\"Cannot add initializers after decoration has completed\"); extraInitializers.push(accept(f || null)); };\r\n        var result = (0, decorators[i])(kind === \"accessor\" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);\r\n        if (kind === \"accessor\") {\r\n            if (result === void 0) continue;\r\n            if (result === null || typeof result !== \"object\") throw new TypeError(\"Object expected\");\r\n            if (_ = accept(result.get)) descriptor.get = _;\r\n            if (_ = accept(result.set)) descriptor.set = _;\r\n            if (_ = accept(result.init)) initializers.unshift(_);\r\n        }\r\n        else if (_ = accept(result)) {\r\n            if (kind === \"field\") initializers.unshift(_);\r\n            else descriptor[key] = _;\r\n        }\r\n    }\r\n    if (target) Object.defineProperty(target, contextIn.name, descriptor);\r\n    done = true;\r\n};\r\n\r\nexport function __runInitializers(thisArg, initializers, value) {\r\n    var useValue = arguments.length > 2;\r\n    for (var i = 0; i < initializers.length; i++) {\r\n        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);\r\n    }\r\n    return useValue ? value : void 0;\r\n};\r\n\r\nexport function __propKey(x) {\r\n    return typeof x === \"symbol\" ? x : \"\".concat(x);\r\n};\r\n\r\nexport function __setFunctionName(f, name, prefix) {\r\n    if (typeof name === \"symbol\") name = name.description ? \"[\".concat(name.description, \"]\") : \"\";\r\n    return Object.defineProperty(f, \"name\", { configurable: true, value: prefix ? \"\".concat(prefix, \" \", name) : name });\r\n};\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (g && (g = 0, op[0] && (_ = 0)), _) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    var desc = Object.getOwnPropertyDescriptor(m, k);\r\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\r\n        desc = { enumerable: true, get: function() { return m[k]; } };\r\n    }\r\n    Object.defineProperty(o, k2, desc);\r\n}) : (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n});\r\n\r\nexport function __exportStar(m, o) {\r\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n}\r\n\r\nexport function __spreadArray(to, from, pack) {\r\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\r\n        if (ar || !(i in from)) {\r\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\r\n            ar[i] = from[i];\r\n        }\r\n    }\r\n    return to.concat(ar || Array.prototype.slice.call(from));\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nvar __setModuleDefault = Object.create ? (function(o, v) {\r\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n}) : function(o, v) {\r\n    o[\"default\"] = v;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\r\n    __setModuleDefault(result, mod);\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, state, kind, f) {\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\r\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, state, value, kind, f) {\r\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\r\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\r\n}\r\n\r\nexport function __classPrivateFieldIn(state, receiver) {\r\n    if (receiver === null || (typeof receiver !== \"object\" && typeof receiver !== \"function\")) throw new TypeError(\"Cannot use 'in' operator on non-object\");\r\n    return typeof state === \"function\" ? receiver === state : state.has(receiver);\r\n}\r\n\r\nexport function __addDisposableResource(env, value, async) {\r\n    if (value !== null && value !== void 0) {\r\n        if (typeof value !== \"object\" && typeof value !== \"function\") throw new TypeError(\"Object expected.\");\r\n        var dispose;\r\n        if (async) {\r\n            if (!Symbol.asyncDispose) throw new TypeError(\"Symbol.asyncDispose is not defined.\");\r\n            dispose = value[Symbol.asyncDispose];\r\n        }\r\n        if (dispose === void 0) {\r\n            if (!Symbol.dispose) throw new TypeError(\"Symbol.dispose is not defined.\");\r\n            dispose = value[Symbol.dispose];\r\n        }\r\n        if (typeof dispose !== \"function\") throw new TypeError(\"Object not disposable.\");\r\n        env.stack.push({ value: value, dispose: dispose, async: async });\r\n    }\r\n    else if (async) {\r\n        env.stack.push({ async: true });\r\n    }\r\n    return value;\r\n}\r\n\r\nvar _SuppressedError = typeof SuppressedError === \"function\" ? SuppressedError : function (error, suppressed, message) {\r\n    var e = new Error(message);\r\n    return e.name = \"SuppressedError\", e.error = error, e.suppressed = suppressed, e;\r\n};\r\n\r\nexport function __disposeResources(env) {\r\n    function fail(e) {\r\n        env.error = env.hasError ? new _SuppressedError(e, env.error, \"An error was suppressed during disposal.\") : e;\r\n        env.hasError = true;\r\n    }\r\n    function next() {\r\n        while (env.stack.length) {\r\n            var rec = env.stack.pop();\r\n            try {\r\n                var result = rec.dispose && rec.dispose.call(rec.value);\r\n                if (rec.async) return Promise.resolve(result).then(next, function(e) { fail(e); return next(); });\r\n            }\r\n            catch (e) {\r\n                fail(e);\r\n            }\r\n        }\r\n        if (env.hasError) throw env.error;\r\n    }\r\n    return next();\r\n}\r\n\r\nexport default {\r\n    __extends: __extends,\r\n    __assign: __assign,\r\n    __rest: __rest,\r\n    __decorate: __decorate,\r\n    __param: __param,\r\n    __metadata: __metadata,\r\n    __awaiter: __awaiter,\r\n    __generator: __generator,\r\n    __createBinding: __createBinding,\r\n    __exportStar: __exportStar,\r\n    __values: __values,\r\n    __read: __read,\r\n    __spread: __spread,\r\n    __spreadArrays: __spreadArrays,\r\n    __spreadArray: __spreadArray,\r\n    __await: __await,\r\n    __asyncGenerator: __asyncGenerator,\r\n    __asyncDelegator: __asyncDelegator,\r\n    __asyncValues: __asyncValues,\r\n    __makeTemplateObject: __makeTemplateObject,\r\n    __importStar: __importStar,\r\n    __importDefault: __importDefault,\r\n    __classPrivateFieldGet: __classPrivateFieldGet,\r\n    __classPrivateFieldSet: __classPrivateFieldSet,\r\n    __classPrivateFieldIn: __classPrivateFieldIn,\r\n    __addDisposableResource: __addDisposableResource,\r\n    __disposeResources: __disposeResources,\r\n};\r\n","import { elementNodeType } from \"./types\"\n\nexport class Diff {\n    constructor(options = {}) {\n        Object.entries(options).forEach(([key, value]) => (this[key] = value))\n    }\n\n    toString() {\n        return JSON.stringify(this)\n    }\n\n    setValue(\n        aKey: string | number,\n        aValue:\n            | string\n            | number\n            | boolean\n            | number[]\n            | { [key: string]: string | { [key: string]: string } }\n            | elementNodeType,\n    ) {\n        this[aKey] = aValue\n        return this\n    }\n}\n\nexport function checkElementType(element, ...elementTypeNames: string[]) {\n    if (typeof element === \"undefined\" || element === null) {\n        return false\n    }\n    return elementTypeNames.some(\n        (elementTypeName) =>\n            // We need to check if the specified type is defined\n            // because otherwise instanceof throws an exception.\n            typeof element?.ownerDocument?.defaultView?.[elementTypeName] ===\n                \"function\" &&\n            element instanceof\n                element.ownerDocument.defaultView[elementTypeName],\n    )\n}\n","import { DiffDOMOptions, elementNodeType, textNodeType } from \"../types\"\nimport { checkElementType } from \"../helpers\"\n\nexport function objToNode(\n    objNode: elementNodeType,\n    insideSvg: boolean,\n    options: DiffDOMOptions,\n) {\n    let node: Element | Text | Comment\n    if (objNode.nodeName === \"#text\") {\n        node = options.document.createTextNode((objNode as textNodeType).data)\n    } else if (objNode.nodeName === \"#comment\") {\n        node = options.document.createComment((objNode as textNodeType).data)\n    } else {\n        if (insideSvg) {\n            node = options.document.createElementNS(\n                \"http://www.w3.org/2000/svg\",\n                objNode.nodeName,\n            )\n            if (objNode.nodeName === \"foreignObject\") {\n                insideSvg = false\n            }\n        } else if (objNode.nodeName.toLowerCase() === \"svg\") {\n            node = options.document.createElementNS(\n                \"http://www.w3.org/2000/svg\",\n                \"svg\",\n            )\n            insideSvg = true\n        } else {\n            node = options.document.createElement(objNode.nodeName)\n        }\n        if (objNode.attributes) {\n            Object.entries(objNode.attributes).forEach(([key, value]) =>\n                (node as Element).setAttribute(key, value),\n            )\n        }\n        if (objNode.childNodes) {\n            node = node as Element\n            objNode.childNodes.forEach(\n                (childNode: elementNodeType | textNodeType) =>\n                    node.appendChild(objToNode(childNode, insideSvg, options)),\n            )\n        }\n        if (options.valueDiffing) {\n            if (\n                objNode.value &&\n                checkElementType(\n                    node,\n                    \"HTMLButtonElement\",\n                    \"HTMLDataElement\",\n                    \"HTMLInputElement\",\n                    \"HTMLLIElement\",\n                    \"HTMLMeterElement\",\n                    \"HTMLOptionElement\",\n                    \"HTMLProgressElement\",\n                    \"HTMLParamElement\",\n                )\n            ) {\n                ;(\n                    node as\n                        | HTMLButtonElement\n                        | HTMLDataElement\n                        | HTMLInputElement\n                        | HTMLLIElement\n                        | HTMLMeterElement\n                        | HTMLOptionElement\n                        | HTMLProgressElement\n                        | HTMLParamElement\n                ).value = objNode.value\n            }\n            if (objNode.checked && checkElementType(node, \"HTMLInputElement\")) {\n                ;(node as HTMLInputElement).checked = objNode.checked\n            }\n            if (\n                objNode.selected &&\n                checkElementType(node, \"HTMLOptionElement\")\n            ) {\n                ;(node as HTMLOptionElement).selected = objNode.selected\n            }\n        }\n    }\n    return node\n}\n","import { DiffDOMOptions, diffType, nodeType } from \"../types\"\nimport { Diff, checkElementType } from \"../helpers\"\n\nimport { objToNode } from \"./fromVirtual\"\n\n// ===== Apply a diff =====\n\nconst getFromRoute = (\n    node: Element,\n    route: number[],\n): Element | Text | false => {\n    route = route.slice()\n    while (route.length > 0) {\n        const c = route.splice(0, 1)[0]\n        node = node.childNodes[c] as Element\n    }\n    return node\n}\n\nexport function applyDiff(\n    tree: Element,\n    diff: diffType,\n    options: DiffDOMOptions, // {preDiffApply, postDiffApply, textDiff, valueDiffing, _const}\n) {\n    const action = diff[options._const.action] as string | number\n    const route = diff[options._const.route] as number[]\n    let node\n\n    if (\n        ![options._const.addElement, options._const.addTextElement].includes(\n            action,\n        )\n    ) {\n        // For adding nodes, we calculate the route later on. It's different because it includes the position of the newly added item.\n        node = getFromRoute(tree, route)\n    }\n\n    let newNode\n    let reference: Element\n    let nodeArray\n\n    // pre-diff hook\n    const info = {\n        diff,\n        node,\n    }\n\n    if (options.preDiffApply(info)) {\n        return true\n    }\n\n    switch (action) {\n        case options._const.addAttribute:\n            if (!node || !checkElementType(node, \"Element\")) {\n                return false\n            }\n            node.setAttribute(\n                diff[options._const.name] as string,\n                diff[options._const.value] as string,\n            )\n            break\n        case options._const.modifyAttribute:\n            if (!node || !checkElementType(node, \"Element\")) {\n                return false\n            }\n            node.setAttribute(\n                diff[options._const.name] as string,\n                diff[options._const.newValue] as string,\n            )\n            if (\n                checkElementType(node, \"HTMLInputElement\") &&\n                diff[options._const.name] === \"value\"\n            ) {\n                node.value = diff[options._const.newValue] as string\n            }\n            break\n        case options._const.removeAttribute:\n            if (!node || !checkElementType(node, \"Element\")) {\n                return false\n            }\n            node.removeAttribute(diff[options._const.name] as string)\n            break\n        case options._const.modifyTextElement:\n            if (!node || !checkElementType(node, \"Text\")) {\n                return false\n            }\n            options.textDiff(\n                node,\n                node.data,\n                diff[options._const.oldValue] as string,\n                diff[options._const.newValue] as string,\n            )\n            if (checkElementType(node.parentNode, \"HTMLTextAreaElement\")) {\n                node.parentNode.value = diff[options._const.newValue] as string\n            }\n            break\n        case options._const.modifyValue:\n            if (!node || typeof node.value === \"undefined\") {\n                return false\n            }\n            node.value = diff[options._const.newValue]\n            break\n        case options._const.modifyComment:\n            if (!node || !checkElementType(node, \"Comment\")) {\n                return false\n            }\n            options.textDiff(\n                node,\n                node.data,\n                diff[options._const.oldValue] as string,\n                diff[options._const.newValue] as string,\n            )\n            break\n        case options._const.modifyChecked:\n            if (!node || typeof node.checked === \"undefined\") {\n                return false\n            }\n            node.checked = diff[options._const.newValue]\n            break\n        case options._const.modifySelected:\n            if (!node || typeof node.selected === \"undefined\") {\n                return false\n            }\n            node.selected = diff[options._const.newValue]\n            break\n        case options._const.replaceElement: {\n            const insideSvg =\n                (\n                    diff[options._const.newValue] as nodeType\n                ).nodeName.toLowerCase() === \"svg\" ||\n                node.parentNode.namespaceURI === \"http://www.w3.org/2000/svg\"\n            node.parentNode.replaceChild(\n                objToNode(\n                    diff[options._const.newValue] as nodeType,\n                    insideSvg,\n                    options,\n                ),\n                node,\n            )\n            break\n        }\n        case options._const.relocateGroup:\n            nodeArray = [...new Array(diff[options._const.groupLength])].map(\n                () =>\n                    node.removeChild(\n                        node.childNodes[diff[options._const.from] as number],\n                    ),\n            )\n            nodeArray.forEach((childNode, index) => {\n                if (index === 0) {\n                    reference =\n                        node.childNodes[diff[options._const.to] as number]\n                }\n                node.insertBefore(childNode, reference || null)\n            })\n            break\n        case options._const.removeElement:\n            node.parentNode.removeChild(node)\n            break\n        case options._const.addElement: {\n            const parentRoute = route.slice()\n            const c: number = parentRoute.splice(parentRoute.length - 1, 1)[0]\n            node = getFromRoute(tree, parentRoute)\n            if (!checkElementType(node, \"Element\")) {\n                return false\n            }\n            node.insertBefore(\n                objToNode(\n                    diff[options._const.element] as nodeType,\n                    node.namespaceURI === \"http://www.w3.org/2000/svg\",\n                    options,\n                ),\n                node.childNodes[c] || null,\n            )\n            break\n        }\n        case options._const.removeTextElement: {\n            if (!node || node.nodeType !== 3) {\n                return false\n            }\n            const parentNode = node.parentNode\n            parentNode.removeChild(node)\n            if (checkElementType(parentNode, \"HTMLTextAreaElement\")) {\n                parentNode.value = \"\"\n            }\n            break\n        }\n        case options._const.addTextElement: {\n            const parentRoute = route.slice()\n            const c: number = parentRoute.splice(parentRoute.length - 1, 1)[0]\n            newNode = options.document.createTextNode(\n                diff[options._const.value] as string,\n            )\n            node = getFromRoute(tree, parentRoute)\n            if (!node.childNodes) {\n                return false\n            }\n            node.insertBefore(newNode, node.childNodes[c] || null)\n            if (checkElementType(node.parentNode, \"HTMLTextAreaElement\")) {\n                node.parentNode.value = diff[options._const.value] as string\n            }\n            break\n        }\n        default:\n            console.log(\"unknown action\")\n    }\n\n    // if a new node was created, we might be interested in its\n    // post diff hook\n    options.postDiffApply({\n        diff: info.diff,\n        node: info.node,\n        newNode,\n    })\n\n    return true\n}\n\nexport function applyDOM(\n    tree: Element,\n    diffs: (Diff | diffType)[],\n    options: DiffDOMOptions,\n) {\n    return diffs.every((diff: Diff | diffType) =>\n        applyDiff(tree, diff as diffType, options),\n    )\n}\n","import { DiffDOMOptions, diffType } from \"../types\"\nimport { Diff } from \"../helpers\"\nimport { applyDiff } from \"./apply\"\n\n// ===== Undo a diff =====\n\nfunction swap(obj: object, p1: string | number, p2: string | number) {\n    const tmp = obj[p1]\n    obj[p1] = obj[p2]\n    obj[p2] = tmp\n}\n\nfunction undoDiff(\n    tree: Element,\n    diff: diffType,\n    options: DiffDOMOptions, // {preDiffApply, postDiffApply, textDiff, valueDiffing, _const}\n) {\n    switch (diff[options._const.action]) {\n        case options._const.addAttribute:\n            diff[options._const.action] = options._const.removeAttribute\n            applyDiff(tree, diff, options)\n            break\n        case options._const.modifyAttribute:\n            swap(diff, options._const.oldValue, options._const.newValue)\n            applyDiff(tree, diff, options)\n            break\n        case options._const.removeAttribute:\n            diff[options._const.action] = options._const.addAttribute\n            applyDiff(tree, diff, options)\n            break\n        case options._const.modifyTextElement:\n            swap(diff, options._const.oldValue, options._const.newValue)\n            applyDiff(tree, diff, options)\n            break\n        case options._const.modifyValue:\n            swap(diff, options._const.oldValue, options._const.newValue)\n            applyDiff(tree, diff, options)\n            break\n        case options._const.modifyComment:\n            swap(diff, options._const.oldValue, options._const.newValue)\n            applyDiff(tree, diff, options)\n            break\n        case options._const.modifyChecked:\n            swap(diff, options._const.oldValue, options._const.newValue)\n            applyDiff(tree, diff, options)\n            break\n        case options._const.modifySelected:\n            swap(diff, options._const.oldValue, options._const.newValue)\n            applyDiff(tree, diff, options)\n            break\n        case options._const.replaceElement:\n            swap(diff, options._const.oldValue, options._const.newValue)\n            applyDiff(tree, diff, options)\n            break\n        case options._const.relocateGroup:\n            swap(diff, options._const.from, options._const.to)\n            applyDiff(tree, diff, options)\n            break\n        case options._const.removeElement:\n            diff[options._const.action] = options._const.addElement\n            applyDiff(tree, diff, options)\n            break\n        case options._const.addElement:\n            diff[options._const.action] = options._const.removeElement\n            applyDiff(tree, diff, options)\n            break\n        case options._const.removeTextElement:\n            diff[options._const.action] = options._const.addTextElement\n            applyDiff(tree, diff, options)\n            break\n        case options._const.addTextElement:\n            diff[options._const.action] = options._const.removeTextElement\n            applyDiff(tree, diff, options)\n            break\n        default:\n            console.log(\"unknown action\")\n    }\n}\n\nexport function undoDOM(\n    tree: Element,\n    diffs: (diffType | Diff)[],\n    options: DiffDOMOptions,\n) {\n    diffs = diffs.slice()\n    diffs.reverse()\n    diffs.forEach((diff: diffType | Diff) => {\n        undoDiff(tree, diff as diffType, options)\n    })\n}\n","import {\n    diffNodeType,\n    elementDiffNodeType,\n    elementNodeType,\n    nodeType,\n    subsetType,\n    textDiffNodeType,\n    textNodeType,\n} from \"../types\"\nimport { Diff } from \"../helpers\"\nconst elementDescriptors = (el: diffNodeType) => {\n    const output = []\n    output.push(el.nodeName)\n    if (el.nodeName !== \"#text\" && el.nodeName !== \"#comment\") {\n        el = el as elementDiffNodeType\n        if (el.attributes) {\n            if (el.attributes[\"class\"]) {\n                output.push(\n                    `${el.nodeName}.${el.attributes[\"class\"].replace(\n                        / /g,\n                        \".\",\n                    )}`,\n                )\n            }\n            if (el.attributes.id) {\n                output.push(`${el.nodeName}#${el.attributes.id}`)\n            }\n        }\n    }\n    return output\n}\n\nconst findUniqueDescriptors = (li: diffNodeType[]) => {\n    const uniqueDescriptors = {}\n    const duplicateDescriptors = {}\n\n    li.forEach((node: nodeType) => {\n        elementDescriptors(node).forEach((descriptor) => {\n            const inUnique = descriptor in uniqueDescriptors\n            const inDupes = descriptor in duplicateDescriptors\n            if (!inUnique && !inDupes) {\n                uniqueDescriptors[descriptor] = true\n            } else if (inUnique) {\n                delete uniqueDescriptors[descriptor]\n                duplicateDescriptors[descriptor] = true\n            }\n        })\n    })\n\n    return uniqueDescriptors\n}\n\nexport const uniqueInBoth = (l1: diffNodeType[], l2: diffNodeType[]) => {\n    const l1Unique = findUniqueDescriptors(l1)\n    const l2Unique = findUniqueDescriptors(l2)\n    const inBoth = {}\n\n    Object.keys(l1Unique).forEach((key) => {\n        if (l2Unique[key]) {\n            inBoth[key] = true\n        }\n    })\n\n    return inBoth\n}\n\nexport const removeDone = (tree: elementDiffNodeType) => {\n    delete tree.outerDone\n    delete tree.innerDone\n    delete tree.valueDone\n    if (tree.childNodes) {\n        return tree.childNodes.every(removeDone)\n    } else {\n        return true\n    }\n}\n\nexport const cleanNode = (diffNode: diffNodeType) => {\n    if (Object.prototype.hasOwnProperty.call(diffNode, \"data\")) {\n        const textNode: textNodeType = {\n            nodeName: diffNode.nodeName === \"#text\" ? \"#text\" : \"#comment\",\n            data: (diffNode as textDiffNodeType).data,\n        }\n        return textNode\n    } else {\n        const elementNode: elementNodeType = {\n            nodeName: diffNode.nodeName,\n        }\n        diffNode = diffNode as elementDiffNodeType\n        if (Object.prototype.hasOwnProperty.call(diffNode, \"attributes\")) {\n            elementNode.attributes = { ...diffNode.attributes }\n        }\n        if (Object.prototype.hasOwnProperty.call(diffNode, \"checked\")) {\n            elementNode.checked = diffNode.checked\n        }\n        if (Object.prototype.hasOwnProperty.call(diffNode, \"value\")) {\n            elementNode.value = diffNode.value\n        }\n        if (Object.prototype.hasOwnProperty.call(diffNode, \"selected\")) {\n            elementNode.selected = diffNode.selected\n        }\n        if (Object.prototype.hasOwnProperty.call(diffNode, \"childNodes\")) {\n            elementNode.childNodes = diffNode.childNodes.map((diffChildNode) =>\n                cleanNode(diffChildNode),\n            )\n        }\n        return elementNode\n    }\n}\n\nexport const isEqual = (e1: diffNodeType, e2: diffNodeType) => {\n    if (\n        ![\"nodeName\", \"value\", \"checked\", \"selected\", \"data\"].every(\n            (element) => {\n                if (e1[element] !== e2[element]) {\n                    return false\n                }\n                return true\n            },\n        )\n    ) {\n        return false\n    }\n    if (Object.prototype.hasOwnProperty.call(e1, \"data\")) {\n        // Comment or Text\n        return true\n    }\n    e1 = e1 as elementDiffNodeType\n    e2 = e2 as elementDiffNodeType\n    if (Boolean(e1.attributes) !== Boolean(e2.attributes)) {\n        return false\n    }\n\n    if (Boolean(e1.childNodes) !== Boolean(e2.childNodes)) {\n        return false\n    }\n    if (e1.attributes) {\n        const e1Attributes = Object.keys(e1.attributes)\n        const e2Attributes = Object.keys(e2.attributes)\n\n        if (e1Attributes.length !== e2Attributes.length) {\n            return false\n        }\n        if (\n            !e1Attributes.every((attribute) => {\n                if (\n                    (e1 as elementDiffNodeType).attributes[attribute] !==\n                    (e2 as elementDiffNodeType).attributes[attribute]\n                ) {\n                    return false\n                }\n                return true\n            })\n        ) {\n            return false\n        }\n    }\n    if (e1.childNodes) {\n        if (e1.childNodes.length !== e2.childNodes.length) {\n            return false\n        }\n        if (\n            !e1.childNodes.every((childNode: nodeType, index: number) =>\n                isEqual(childNode, e2.childNodes[index]),\n            )\n        ) {\n            return false\n        }\n    }\n\n    return true\n}\n\nexport const roughlyEqual = (\n    e1: diffNodeType,\n    e2: diffNodeType,\n    uniqueDescriptors: { [key: string]: boolean },\n    sameSiblings: boolean,\n    preventRecursion = false,\n) => {\n    if (!e1 || !e2) {\n        return false\n    }\n\n    if (e1.nodeName !== e2.nodeName) {\n        return false\n    }\n\n    if ([\"#text\", \"#comment\"].includes(e1.nodeName)) {\n        // Note that we initially don't care what the text content of a node is,\n        // the mere fact that it's the same tag and \"has text\" means it's roughly\n        // equal, and then we can find out the true text difference later.\n        return preventRecursion\n            ? true\n            : (e1 as textDiffNodeType).data === (e2 as textDiffNodeType).data\n    }\n\n    e1 = e1 as elementDiffNodeType\n    e2 = e2 as elementDiffNodeType\n\n    if (e1.nodeName in uniqueDescriptors) {\n        return true\n    }\n\n    if (e1.attributes && e2.attributes) {\n        if (e1.attributes.id) {\n            if (e1.attributes.id !== e2.attributes.id) {\n                return false\n            } else {\n                const idDescriptor = `${e1.nodeName}#${e1.attributes.id}`\n                if (idDescriptor in uniqueDescriptors) {\n                    return true\n                }\n            }\n        }\n        if (\n            e1.attributes[\"class\"] &&\n            e1.attributes[\"class\"] === e2.attributes[\"class\"]\n        ) {\n            const classDescriptor = `${e1.nodeName}.${e1.attributes[\n                \"class\"\n            ].replace(/ /g, \".\")}`\n            if (classDescriptor in uniqueDescriptors) {\n                return true\n            }\n        }\n    }\n\n    if (sameSiblings) {\n        return true\n    }\n\n    const nodeList1 = e1.childNodes ? e1.childNodes.slice().reverse() : []\n    const nodeList2 = e2.childNodes ? e2.childNodes.slice().reverse() : []\n\n    if (nodeList1.length !== nodeList2.length) {\n        return false\n    }\n\n    if (preventRecursion) {\n        return nodeList1.every(\n            (element: nodeType, index: number) =>\n                element.nodeName === nodeList2[index].nodeName,\n        )\n    } else {\n        // note: we only allow one level of recursion at any depth. If 'preventRecursion'\n        // was not set, we must explicitly force it to true for child iterations.\n        const childUniqueDescriptors = uniqueInBoth(nodeList1, nodeList2)\n        return nodeList1.every((element: nodeType, index: number) =>\n            roughlyEqual(\n                element,\n                nodeList2[index],\n                childUniqueDescriptors,\n                true,\n                true,\n            ),\n        )\n    }\n}\n\n/**\n * based on https://en.wikibooks.org/wiki/Algorithm_implementation/Strings/Longest_common_substring#JavaScript\n */\nconst findCommonSubsets = (\n    c1: diffNodeType[],\n    c2: diffNodeType[],\n    marked1: boolean[],\n    marked2: boolean[],\n) => {\n    let lcsSize = 0\n    let index: number[] = []\n    const c1Length = c1.length\n    const c2Length = c2.length\n\n    const // set up the matching table\n        matches = [...new Array(c1Length + 1)].map(() => [])\n\n    const uniqueDescriptors = uniqueInBoth(c1, c2)\n\n    let // If all of the elements are the same tag, id and class, then we can\n        // consider them roughly the same even if they have a different number of\n        // children. This will reduce removing and re-adding similar elements.\n        subsetsSame = c1Length === c2Length\n\n    if (subsetsSame) {\n        c1.some((element: nodeType, i: number) => {\n            const c1Desc = elementDescriptors(element)\n            const c2Desc = elementDescriptors(c2[i])\n            if (c1Desc.length !== c2Desc.length) {\n                subsetsSame = false\n                return true\n            }\n            c1Desc.some((description, i) => {\n                if (description !== c2Desc[i]) {\n                    subsetsSame = false\n                    return true\n                }\n            })\n            if (!subsetsSame) {\n                return true\n            }\n        })\n    }\n\n    // fill the matches with distance values\n    for (let c1Index = 0; c1Index < c1Length; c1Index++) {\n        const c1Element = c1[c1Index]\n        for (let c2Index = 0; c2Index < c2Length; c2Index++) {\n            const c2Element = c2[c2Index]\n            if (\n                !marked1[c1Index] &&\n                !marked2[c2Index] &&\n                roughlyEqual(\n                    c1Element,\n                    c2Element,\n                    uniqueDescriptors,\n                    subsetsSame,\n                )\n            ) {\n                matches[c1Index + 1][c2Index + 1] = matches[c1Index][c2Index]\n                    ? matches[c1Index][c2Index] + 1\n                    : 1\n                if (matches[c1Index + 1][c2Index + 1] >= lcsSize) {\n                    lcsSize = matches[c1Index + 1][c2Index + 1]\n                    index = [c1Index + 1, c2Index + 1]\n                }\n            } else {\n                matches[c1Index + 1][c2Index + 1] = 0\n            }\n        }\n    }\n\n    if (lcsSize === 0) {\n        return false\n    }\n\n    return {\n        oldValue: index[0] - lcsSize,\n        newValue: index[1] - lcsSize,\n        length: lcsSize,\n    }\n}\n\nconst makeBooleanArray = (n: number, v: boolean) =>\n    [...new Array(n)].map(() => v)\n\n/**\n * Generate arrays that indicate which node belongs to which subset,\n * or whether it's actually an orphan node, existing in only one\n * of the two trees, rather than somewhere in both.\n *\n * So if t1 = <img><canvas><br>, t2 = <canvas><br><img>.\n * The longest subset is \"<canvas><br>\" (length 2), so it will group 0.\n * The second longest is \"<img>\" (length 1), so it will be group 1.\n * gaps1 will therefore be [1,0,0] and gaps2 [0,0,1].\n *\n * If an element is not part of any group, it will stay being 'true', which\n * is the initial value. For example:\n * t1 = <img><p></p><br><canvas>, t2 = <b></b><br><canvas><img>\n *\n * The \"<p></p>\" and \"<b></b>\" do only show up in one of the two and will\n * therefore be marked by \"true\". The remaining parts are parts of the\n * groups 0 and 1:\n * gaps1 = [1, true, 0, 0], gaps2 = [true, 0, 0, 1]\n *\n */\nexport const getGapInformation = (\n    t1: elementDiffNodeType,\n    t2: elementDiffNodeType,\n    stable: subsetType[],\n) => {\n    const gaps1: (true | number)[] = t1.childNodes\n        ? (makeBooleanArray(t1.childNodes.length, true) as true[])\n        : []\n    const gaps2: (true | number)[] = t2.childNodes\n        ? (makeBooleanArray(t2.childNodes.length, true) as true[])\n        : []\n    let group = 0\n\n    // give elements from the same subset the same group number\n    stable.forEach((subset: subsetType) => {\n        const endOld = subset.oldValue + subset.length\n        const endNew = subset.newValue + subset.length\n\n        for (let j = subset.oldValue; j < endOld; j += 1) {\n            gaps1[j] = group\n        }\n        for (let j = subset.newValue; j < endNew; j += 1) {\n            gaps2[j] = group\n        }\n        group += 1\n    })\n\n    return {\n        gaps1,\n        gaps2,\n    }\n}\n\n/**\n * Find all matching subsets, based on immediate child differences only.\n */\nconst markBoth = (marked1, marked2, subset: subsetType, i: number) => {\n    marked1[subset.oldValue + i] = true\n    marked2[subset.newValue + i] = true\n}\n\nexport const markSubTrees = (\n    oldTree: elementDiffNodeType,\n    newTree: elementDiffNodeType,\n) => {\n    // note: the child lists are views, and so update as we update old/newTree\n    const oldChildren = oldTree.childNodes ? oldTree.childNodes : []\n\n    const newChildren = newTree.childNodes ? newTree.childNodes : []\n    const marked1 = makeBooleanArray(oldChildren.length, false)\n    const marked2 = makeBooleanArray(newChildren.length, false)\n    const subsets = []\n\n    const returnIndex = function () {\n        return arguments[1]\n    }\n\n    let foundAllSubsets = false\n\n    while (!foundAllSubsets) {\n        const subset = findCommonSubsets(\n            oldChildren,\n            newChildren,\n            marked1,\n            marked2,\n        )\n        if (subset) {\n            subsets.push(subset)\n            const subsetArray = [...new Array(subset.length)].map(returnIndex)\n            subsetArray.forEach((item) =>\n                markBoth(marked1, marked2, subset, item),\n            )\n        } else {\n            foundAllSubsets = true\n        }\n    }\n\n    oldTree.subsets = subsets\n    oldTree.subsetsAge = 100\n    return subsets\n}\n\nexport class DiffTracker {\n    list: Diff[]\n    constructor() {\n        this.list = []\n    }\n\n    add(diffs: Diff[]) {\n        this.list.push(...diffs)\n    }\n    forEach(fn: (Diff) => void) {\n        this.list.forEach((li: Diff) => fn(li))\n    }\n}\n","import { DiffDOMOptions, elementNodeType, nodeType, subsetType } from \"../types\"\nimport { Diff } from \"../helpers\"\nimport { cleanNode } from \"./helpers\"\n// ===== Apply a virtual diff =====\n\nfunction getFromVirtualRoute(tree: elementNodeType, route: number[]) {\n    let node = tree\n    let parentNode\n    let nodeIndex\n\n    route = route.slice()\n    while (route.length > 0) {\n        nodeIndex = route.splice(0, 1)[0]\n        parentNode = node\n        node = node.childNodes ? node.childNodes[nodeIndex] : undefined\n    }\n    return {\n        node,\n        parentNode,\n        nodeIndex,\n    }\n}\n\nfunction applyVirtualDiff(\n    tree: elementNodeType,\n    diff: Diff,\n    options: DiffDOMOptions, // {preVirtualDiffApply, postVirtualDiffApply, _const}\n) {\n    let node, parentNode, nodeIndex\n\n    if (\n        ![options._const.addElement, options._const.addTextElement].includes(\n            diff[options._const.action],\n        )\n    ) {\n        // For adding nodes, we calculate the route later on. It's different because it includes the position of the newly added item.\n        const routeInfo = getFromVirtualRoute(tree, diff[options._const.route])\n        node = routeInfo.node\n        parentNode = routeInfo.parentNode\n        nodeIndex = routeInfo.nodeIndex\n    }\n\n    const newSubsets: subsetType[] = []\n\n    // pre-diff hook\n    const info = {\n        diff,\n        node,\n    }\n\n    if (options.preVirtualDiffApply(info)) {\n        return true\n    }\n\n    let newNode\n    let nodeArray\n    let route\n\n    switch (diff[options._const.action]) {\n        case options._const.addAttribute:\n            if (!node.attributes) {\n                node.attributes = {}\n            }\n\n            node.attributes[diff[options._const.name]] =\n                diff[options._const.value]\n\n            if (diff[options._const.name] === \"checked\") {\n                node.checked = true\n            } else if (diff[options._const.name] === \"selected\") {\n                node.selected = true\n            } else if (\n                node.nodeName === \"INPUT\" &&\n                diff[options._const.name] === \"value\"\n            ) {\n                node.value = diff[options._const.value]\n            }\n\n            break\n        case options._const.modifyAttribute:\n            node.attributes[diff[options._const.name]] =\n                diff[options._const.newValue]\n            break\n        case options._const.removeAttribute:\n            delete node.attributes[diff[options._const.name]]\n\n            if (Object.keys(node.attributes).length === 0) {\n                delete node.attributes\n            }\n\n            if (diff[options._const.name] === \"checked\") {\n                node.checked = false\n            } else if (diff[options._const.name] === \"selected\") {\n                delete node.selected\n            } else if (\n                node.nodeName === \"INPUT\" &&\n                diff[options._const.name] === \"value\"\n            ) {\n                delete node.value\n            }\n\n            break\n        case options._const.modifyTextElement:\n            node.data = diff[options._const.newValue]\n            if (parentNode.nodeName === \"TEXTAREA\") {\n                parentNode.value = diff[options._const.newValue]\n            }\n            break\n        case options._const.modifyValue:\n            node.value = diff[options._const.newValue]\n            break\n        case options._const.modifyComment:\n            node.data = diff[options._const.newValue]\n            break\n        case options._const.modifyChecked:\n            node.checked = diff[options._const.newValue]\n            break\n        case options._const.modifySelected:\n            node.selected = diff[options._const.newValue]\n            break\n        case options._const.replaceElement:\n            newNode = cleanNode(diff[options._const.newValue])\n            parentNode.childNodes[nodeIndex] = newNode\n            break\n        case options._const.relocateGroup:\n            nodeArray = node.childNodes\n                .splice(\n                    diff[options._const.from],\n                    diff[options._const.groupLength],\n                )\n                .reverse()\n            nodeArray.forEach((movedNode: nodeType) =>\n                node.childNodes.splice(diff[options._const.to], 0, movedNode),\n            )\n            if (node.subsets) {\n                node.subsets.forEach((map: subsetType) => {\n                    if (\n                        diff[options._const.from] < diff[options._const.to] &&\n                        map.oldValue <= diff[options._const.to] &&\n                        map.oldValue > diff[options._const.from]\n                    ) {\n                        map.oldValue -= diff[options._const.groupLength]\n                        const splitLength =\n                            map.oldValue + map.length - diff[options._const.to]\n                        if (splitLength > 0) {\n                            // new insertion splits map.\n                            newSubsets.push({\n                                oldValue:\n                                    diff[options._const.to] +\n                                    diff[options._const.groupLength],\n                                newValue:\n                                    map.newValue + map.length - splitLength,\n                                length: splitLength,\n                            })\n                            map.length -= splitLength\n                        }\n                    } else if (\n                        diff[options._const.from] > diff[options._const.to] &&\n                        map.oldValue > diff[options._const.to] &&\n                        map.oldValue < diff[options._const.from]\n                    ) {\n                        map.oldValue += diff[options._const.groupLength]\n                        const splitLength =\n                            map.oldValue + map.length - diff[options._const.to]\n                        if (splitLength > 0) {\n                            // new insertion splits map.\n                            newSubsets.push({\n                                oldValue:\n                                    diff[options._const.to] +\n                                    diff[options._const.groupLength],\n                                newValue:\n                                    map.newValue + map.length - splitLength,\n                                length: splitLength,\n                            })\n                            map.length -= splitLength\n                        }\n                    } else if (map.oldValue === diff[options._const.from]) {\n                        map.oldValue = diff[options._const.to]\n                    }\n                })\n            }\n\n            break\n        case options._const.removeElement:\n            parentNode.childNodes.splice(nodeIndex, 1)\n            if (parentNode.subsets) {\n                parentNode.subsets.forEach((map: subsetType) => {\n                    if (map.oldValue > nodeIndex) {\n                        map.oldValue -= 1\n                    } else if (map.oldValue === nodeIndex) {\n                        map.delete = true\n                    } else if (\n                        map.oldValue < nodeIndex &&\n                        map.oldValue + map.length > nodeIndex\n                    ) {\n                        if (map.oldValue + map.length - 1 === nodeIndex) {\n                            map.length--\n                        } else {\n                            newSubsets.push({\n                                newValue:\n                                    map.newValue + nodeIndex - map.oldValue,\n                                oldValue: nodeIndex,\n                                length:\n                                    map.length - nodeIndex + map.oldValue - 1,\n                            })\n                            map.length = nodeIndex - map.oldValue\n                        }\n                    }\n                })\n            }\n            node = parentNode\n            break\n        case options._const.addElement: {\n            route = diff[options._const.route].slice()\n            const c: number = route.splice(route.length - 1, 1)[0]\n            node = getFromVirtualRoute(tree, route)?.node\n            newNode = cleanNode(diff[options._const.element])\n\n            if (!node.childNodes) {\n                node.childNodes = []\n            }\n\n            if (c >= node.childNodes.length) {\n                node.childNodes.push(newNode)\n            } else {\n                node.childNodes.splice(c, 0, newNode)\n            }\n            if (node.subsets) {\n                node.subsets.forEach((map: subsetType) => {\n                    if (map.oldValue >= c) {\n                        map.oldValue += 1\n                    } else if (\n                        map.oldValue < c &&\n                        map.oldValue + map.length > c\n                    ) {\n                        const splitLength = map.oldValue + map.length - c\n                        newSubsets.push({\n                            newValue: map.newValue + map.length - splitLength,\n                            oldValue: c + 1,\n                            length: splitLength,\n                        })\n                        map.length -= splitLength\n                    }\n                })\n            }\n            break\n        }\n        case options._const.removeTextElement:\n            parentNode.childNodes.splice(nodeIndex, 1)\n            if (parentNode.nodeName === \"TEXTAREA\") {\n                delete parentNode.value\n            }\n            if (parentNode.subsets) {\n                parentNode.subsets.forEach((map: subsetType) => {\n                    if (map.oldValue > nodeIndex) {\n                        map.oldValue -= 1\n                    } else if (map.oldValue === nodeIndex) {\n                        map.delete = true\n                    } else if (\n                        map.oldValue < nodeIndex &&\n                        map.oldValue + map.length > nodeIndex\n                    ) {\n                        if (map.oldValue + map.length - 1 === nodeIndex) {\n                            map.length--\n                        } else {\n                            newSubsets.push({\n                                newValue:\n                                    map.newValue + nodeIndex - map.oldValue,\n                                oldValue: nodeIndex,\n                                length:\n                                    map.length - nodeIndex + map.oldValue - 1,\n                            })\n                            map.length = nodeIndex - map.oldValue\n                        }\n                    }\n                })\n            }\n            node = parentNode\n            break\n        case options._const.addTextElement: {\n            route = diff[options._const.route].slice()\n            const c: number = route.splice(route.length - 1, 1)[0]\n            newNode = {\n                nodeName: \"#text\",\n                data: diff[options._const.value],\n            }\n            node = getFromVirtualRoute(tree, route).node\n            if (!node.childNodes) {\n                node.childNodes = []\n            }\n\n            if (c >= node.childNodes.length) {\n                node.childNodes.push(newNode)\n            } else {\n                node.childNodes.splice(c, 0, newNode)\n            }\n            if (node.nodeName === \"TEXTAREA\") {\n                node.value = diff[options._const.newValue]\n            }\n            if (node.subsets) {\n                node.subsets.forEach((map: subsetType) => {\n                    if (map.oldValue >= c) {\n                        map.oldValue += 1\n                    }\n                    if (map.oldValue < c && map.oldValue + map.length > c) {\n                        const splitLength = map.oldValue + map.length - c\n                        newSubsets.push({\n                            newValue: map.newValue + map.length - splitLength,\n                            oldValue: c + 1,\n                            length: splitLength,\n                        })\n                        map.length -= splitLength\n                    }\n                })\n            }\n            break\n        }\n        default:\n            console.log(\"unknown action\")\n    }\n\n    if (node.subsets) {\n        node.subsets = node.subsets.filter(\n            (map: subsetType) => !map.delete && map.oldValue !== map.newValue,\n        )\n        if (newSubsets.length) {\n            node.subsets = node.subsets.concat(newSubsets)\n        }\n    }\n\n    options.postVirtualDiffApply({\n        node: info.node,\n        diff: info.diff,\n        newNode,\n    })\n\n    return\n}\n\nexport function applyVirtual(\n    tree: elementNodeType,\n    diffs: Diff[],\n    options: DiffDOMOptions,\n) {\n    diffs.forEach((diff: Diff) => {\n        applyVirtualDiff(tree, diff, options)\n    })\n    return true\n}\n","import { DiffDOMOptionsPartial, elementNodeType, textNodeType } from \"../types\"\nimport { checkElementType } from \"../helpers\"\n\nexport function nodeToObj(\n    aNode: Element,\n    options: DiffDOMOptionsPartial = { valueDiffing: true },\n) {\n    const objNode: elementNodeType | textNodeType = {\n        nodeName: aNode.nodeName,\n    }\n    if (checkElementType(aNode, \"Text\", \"Comment\")) {\n        ;(objNode as unknown as textNodeType).data = (\n            aNode as unknown as Text | Comment\n        ).data\n    } else {\n        if (aNode.attributes && aNode.attributes.length > 0) {\n            objNode.attributes = {}\n            const nodeArray = Array.prototype.slice.call(aNode.attributes)\n            nodeArray.forEach(\n                (attribute) =>\n                    (objNode.attributes[attribute.name] = attribute.value),\n            )\n        }\n        if (aNode.childNodes && aNode.childNodes.length > 0) {\n            objNode.childNodes = []\n            const nodeArray = Array.prototype.slice.call(aNode.childNodes)\n            nodeArray.forEach((childNode) =>\n                objNode.childNodes.push(nodeToObj(childNode, options)),\n            )\n        }\n        if (options.valueDiffing) {\n            if (checkElementType(aNode, \"HTMLTextAreaElement\")) {\n                objNode.value = (aNode as HTMLTextAreaElement).value\n            }\n            if (\n                checkElementType(aNode, \"HTMLInputElement\") &&\n                [\"radio\", \"checkbox\"].includes(\n                    (aNode as HTMLInputElement).type.toLowerCase(),\n                ) &&\n                (aNode as HTMLInputElement).checked !== undefined\n            ) {\n                objNode.checked = (aNode as HTMLInputElement).checked\n            } else if (\n                checkElementType(\n                    aNode,\n                    \"HTMLButtonElement\",\n                    \"HTMLDataElement\",\n                    \"HTMLInputElement\",\n                    \"HTMLLIElement\",\n                    \"HTMLMeterElement\",\n                    \"HTMLOptionElement\",\n                    \"HTMLProgressElement\",\n                    \"HTMLParamElement\",\n                )\n            ) {\n                objNode.value = (\n                    aNode as\n                        | HTMLButtonElement\n                        | HTMLDataElement\n                        | HTMLInputElement\n                        | HTMLLIElement\n                        | HTMLMeterElement\n                        | HTMLOptionElement\n                        | HTMLProgressElement\n                        | HTMLParamElement\n                ).value\n            }\n            if (checkElementType(aNode, \"HTMLOptionElement\")) {\n                objNode.selected = (aNode as HTMLOptionElement).selected\n            }\n        }\n    }\n    return objNode\n}\n","import { DiffDOMOptionsPartial, nodeType } from \"../types\"\n\n// from html-parse-stringify (MIT)\n\nconst tagRE =\n    /<\\s*\\/*[a-zA-Z:_][a-zA-Z0-9:_\\-.]*\\s*(?:\"[^\"]*\"['\"]*|'[^']*'['\"]*|[^'\"/>])*\\/*\\s*>|<!--(?:.|\\n|\\r)*?-->/g\n\nconst attrRE = /\\s([^'\"/\\s><]+?)[\\s/>]|([^\\s=]+)=\\s?(\".*?\"|'.*?')/g\n\nfunction unescape(string: string) {\n    return string\n        .replace(/&lt;/g, \"<\")\n        .replace(/&gt;/g, \">\")\n        .replace(/&amp;/g, \"&\")\n}\n\n// create optimized lookup object for\n// void elements as listed here:\n// https://www.w3.org/html/wg/drafts/html/master/syntax.html#void-elements\nconst lookup = {\n    area: true,\n    base: true,\n    br: true,\n    col: true,\n    embed: true,\n    hr: true,\n    img: true,\n    input: true,\n    keygen: true,\n    link: true,\n    menuItem: true,\n    meta: true,\n    param: true,\n    source: true,\n    track: true,\n    wbr: true,\n}\n\nconst parseTag = (tag: string, caseSensitive: boolean) => {\n    const res = {\n        nodeName: \"\",\n        attributes: {},\n    }\n    let voidElement = false\n    let type = \"tag\"\n\n    let tagMatch = tag.match(/<\\/?([^\\s]+?)[/\\s>]/)\n    if (tagMatch) {\n        res.nodeName =\n            caseSensitive || tagMatch[1] === \"svg\"\n                ? tagMatch[1]\n                : tagMatch[1].toUpperCase()\n        if (lookup[tagMatch[1]] || tag.charAt(tag.length - 2) === \"/\") {\n            voidElement = true\n        }\n\n        // handle comment tag\n        if (res.nodeName.startsWith(\"!--\")) {\n            const endIndex = tag.indexOf(\"-->\")\n            return {\n                type: \"comment\",\n                node: {\n                    nodeName: \"#comment\",\n                    data: endIndex !== -1 ? tag.slice(4, endIndex) : \"\",\n                },\n                voidElement,\n            }\n        }\n    }\n\n    let reg = new RegExp(attrRE)\n    let result = null\n    let done = false\n    while (!done) {\n        result = reg.exec(tag)\n\n        if (result === null) {\n            done = true\n        } else if (result[0].trim()) {\n            if (result[1]) {\n                let attr = result[1].trim()\n                let arr = [attr, \"\"]\n\n                if (attr.indexOf(\"=\") > -1) arr = attr.split(\"=\")\n                res.attributes[arr[0]] = arr[1]\n                reg.lastIndex--\n            } else if (result[2])\n                res.attributes[result[2]] = result[3]\n                    .trim()\n                    .substring(1, result[3].length - 1)\n        }\n    }\n\n    return {\n        type,\n        node: res,\n        voidElement,\n    }\n}\n\nexport const stringToObj = (\n    html: string,\n    options: DiffDOMOptionsPartial = {\n        valueDiffing: true,\n        caseSensitive: false,\n    },\n) => {\n    const result: nodeType[] = []\n    let current: { type: string; node: nodeType; voidElement: boolean }\n    let level = -1\n    const arr: { type: string; node: nodeType; voidElement: boolean }[] = []\n    let inComponent = false,\n        insideSvg = false\n\n    // handle text at top level\n    if (html.indexOf(\"<\") !== 0) {\n        const end = html.indexOf(\"<\")\n        result.push({\n            nodeName: \"#text\",\n            data: end === -1 ? html : html.substring(0, end),\n        })\n    }\n\n    html.replace(tagRE, (tag: string, index: number) => {\n        if (inComponent) {\n            if (tag !== `</${current.node.nodeName}>`) {\n                return \"\"\n            } else {\n                inComponent = false\n            }\n        }\n        const isOpen = tag.charAt(1) !== \"/\"\n        const isComment = tag.startsWith(\"<!--\")\n        const start = index + tag.length\n        const nextChar = html.charAt(start)\n\n        if (isComment) {\n            const comment = parseTag(tag, options.caseSensitive).node\n\n            // if we're at root, push new base node\n            if (level < 0) {\n                result.push(comment)\n                return \"\"\n            }\n            const parent = arr[level]\n            if (parent && comment.nodeName) {\n                if (!parent.node.childNodes) {\n                    parent.node.childNodes = []\n                }\n                parent.node.childNodes.push(comment)\n            }\n            return \"\"\n        }\n\n        if (isOpen) {\n            current = parseTag(tag, options.caseSensitive || insideSvg)\n            if (current.node.nodeName === \"svg\") {\n                insideSvg = true\n            }\n            level++\n            if (\n                !current.voidElement &&\n                !inComponent &&\n                nextChar &&\n                nextChar !== \"<\"\n            ) {\n                if (!current.node.childNodes) {\n                    current.node.childNodes = []\n                }\n                const data = unescape(\n                    html.slice(start, html.indexOf(\"<\", start)),\n                )\n                current.node.childNodes.push({\n                    nodeName: \"#text\",\n                    data,\n                })\n                if (\n                    options.valueDiffing &&\n                    current.node.nodeName === \"TEXTAREA\"\n                ) {\n                    current.node.value = data\n                }\n            }\n            // if we're at root, push new base node\n            if (level === 0 && current.node.nodeName) {\n                result.push(current.node)\n            }\n\n            const parent = arr[level - 1]\n            if (parent && current.node.nodeName) {\n                if (!parent.node.childNodes) {\n                    parent.node.childNodes = []\n                }\n                parent.node.childNodes.push(current.node)\n            }\n            arr[level] = current\n        }\n        if (!isOpen || current.voidElement) {\n            if (\n                level > -1 &&\n                (current.voidElement ||\n                    (options.caseSensitive &&\n                        current.node.nodeName === tag.slice(2, -1)) ||\n                    (!options.caseSensitive &&\n                        current.node.nodeName.toUpperCase() ===\n                            tag.slice(2, -1).toUpperCase()))\n            ) {\n                level--\n                // move current up a level to match the end tag\n                if (level > -1) {\n                    if (current.node.nodeName === \"svg\") {\n                        insideSvg = false\n                    }\n                    current = arr[level]\n                }\n            }\n            if (!inComponent && nextChar !== \"<\" && nextChar) {\n                // trailing text node\n                // if we're at the root, push a base text node. otherwise add as\n                // a child to the current node.\n                const childNodes =\n                    level === -1 ? result : arr[level].node.childNodes || []\n\n                // calculate correct end of the data slice in case there's\n                // no tag after the text node.\n                const end = html.indexOf(\"<\", start)\n                let data = unescape(\n                    html.slice(start, end === -1 ? undefined : end),\n                )\n                childNodes.push({\n                    nodeName: \"#text\",\n                    data,\n                })\n            }\n        }\n        return \"\"\n    })\n    return result[0]\n}\n","import {\n    DiffDOMOptions,\n    diffNodeType,\n    elementDiffNodeType,\n    elementNodeType,\n    subsetType,\n    textDiffNodeType,\n} from \"../types\"\nimport {\n    DiffTracker,\n    cleanNode,\n    getGapInformation,\n    isEqual,\n    markSubTrees,\n    removeDone,\n    roughlyEqual,\n} from \"./helpers\"\nimport { Diff, checkElementType } from \"../helpers\"\nimport { applyVirtual } from \"./apply\"\nimport { nodeToObj } from \"./fromDOM\"\nimport { stringToObj } from \"./fromString\"\n\n// ===== Create a diff =====\n\nexport class DiffFinder {\n    debug: boolean\n    diffcount: number\n    foundAll: boolean\n    options: DiffDOMOptions\n    t1: elementDiffNodeType\n    t1Orig: elementNodeType\n    t2: elementDiffNodeType\n    t2Orig: elementNodeType\n    tracker: DiffTracker\n    constructor(\n        t1Node: string | elementNodeType | Element,\n        t2Node: string | elementNodeType | Element,\n        options: DiffDOMOptions,\n    ) {\n        this.options = options\n        this.t1 = (\n            typeof Element !== \"undefined\" &&\n            checkElementType(t1Node, \"Element\")\n                ? nodeToObj(t1Node as Element, this.options)\n                : typeof t1Node === \"string\"\n                  ? stringToObj(t1Node, this.options)\n                  : JSON.parse(JSON.stringify(t1Node))\n        ) as elementDiffNodeType\n        this.t2 = (\n            typeof Element !== \"undefined\" &&\n            checkElementType(t2Node, \"Element\")\n                ? nodeToObj(t2Node as Element, this.options)\n                : typeof t2Node === \"string\"\n                  ? stringToObj(t2Node, this.options)\n                  : JSON.parse(JSON.stringify(t2Node))\n        ) as elementDiffNodeType\n        this.diffcount = 0\n        this.foundAll = false\n        if (this.debug) {\n            this.t1Orig =\n                typeof Element !== \"undefined\" &&\n                checkElementType(t1Node, \"Element\")\n                    ? nodeToObj(t1Node as Element, this.options)\n                    : typeof t1Node === \"string\"\n                      ? stringToObj(t1Node, this.options)\n                      : JSON.parse(JSON.stringify(t1Node))\n            this.t2Orig =\n                typeof Element !== \"undefined\" &&\n                checkElementType(t2Node, \"Element\")\n                    ? nodeToObj(t2Node as Element, this.options)\n                    : typeof t2Node === \"string\"\n                      ? stringToObj(t2Node, this.options)\n                      : JSON.parse(JSON.stringify(t2Node))\n        }\n\n        this.tracker = new DiffTracker()\n    }\n\n    init() {\n        return this.findDiffs(this.t1, this.t2)\n    }\n\n    findDiffs(t1: elementDiffNodeType, t2: elementDiffNodeType) {\n        let diffs\n        do {\n            if (this.options.debug) {\n                this.diffcount += 1\n                if (this.diffcount > this.options.diffcap) {\n                    throw new Error(\n                        `surpassed diffcap:${JSON.stringify(\n                            this.t1Orig,\n                        )} -> ${JSON.stringify(this.t2Orig)}`,\n                    )\n                }\n            }\n            diffs = this.findNextDiff(t1, t2, [])\n\n            if (diffs.length === 0) {\n                // Last check if the elements really are the same now.\n                // If not, remove all info about being done and start over.\n                // Sometimes a node can be marked as done, but the creation of subsequent diffs means that it has to be changed again.\n                if (!isEqual(t1, t2)) {\n                    if (this.foundAll) {\n                        console.error(\"Could not find remaining diffs!\")\n                    } else {\n                        this.foundAll = true\n                        removeDone(t1)\n                        diffs = this.findNextDiff(t1, t2, [])\n                    }\n                }\n            }\n            if (diffs.length > 0) {\n                this.foundAll = false\n                this.tracker.add(diffs)\n                applyVirtual(t1, diffs, this.options)\n            }\n        } while (diffs.length > 0)\n\n        return this.tracker.list\n    }\n\n    findNextDiff(t1: diffNodeType, t2: diffNodeType, route: number[]) {\n        let diffs\n        let fdiffs\n\n        if (this.options.maxDepth && route.length > this.options.maxDepth) {\n            return []\n        }\n        // outer differences?\n        if (!t1.outerDone) {\n            diffs = this.findOuterDiff(t1, t2, route)\n            if (this.options.filterOuterDiff) {\n                fdiffs = this.options.filterOuterDiff(t1, t2, diffs)\n                if (fdiffs) diffs = fdiffs\n            }\n            if (diffs.length > 0) {\n                t1.outerDone = true\n                return diffs\n            } else {\n                t1.outerDone = true\n            }\n        }\n        if (Object.prototype.hasOwnProperty.call(t1, \"data\")) {\n            // Comment or Text\n            return []\n        }\n        t1 = t1 as elementDiffNodeType\n        t2 = t2 as elementDiffNodeType\n\n        // inner differences?\n        if (!t1.innerDone) {\n            diffs = this.findInnerDiff(t1, t2, route)\n            if (diffs.length > 0) {\n                return diffs\n            } else {\n                t1.innerDone = true\n            }\n        }\n\n        if (this.options.valueDiffing && !t1.valueDone) {\n            // value differences?\n            diffs = this.findValueDiff(t1, t2, route)\n\n            if (diffs.length > 0) {\n                t1.valueDone = true\n                return diffs\n            } else {\n                t1.valueDone = true\n            }\n        }\n\n        // no differences\n        return []\n    }\n\n    findOuterDiff(t1: diffNodeType, t2: diffNodeType, route: number[]) {\n        const diffs = []\n        let attr\n        let attr1\n        let attr2\n        let attrLength\n        let pos\n        let i\n        if (t1.nodeName !== t2.nodeName) {\n            if (!route.length) {\n                throw new Error(\"Top level nodes have to be of the same kind.\")\n            }\n            return [\n                new Diff()\n                    .setValue(\n                        this.options._const.action,\n                        this.options._const.replaceElement,\n                    )\n                    .setValue(this.options._const.oldValue, cleanNode(t1))\n                    .setValue(this.options._const.newValue, cleanNode(t2))\n                    .setValue(this.options._const.route, route),\n            ]\n        }\n        if (\n            route.length &&\n            this.options.diffcap <\n                Math.abs(\n                    (t1.childNodes || []).length - (t2.childNodes || []).length,\n                )\n        ) {\n            return [\n                new Diff()\n                    .setValue(\n                        this.options._const.action,\n                        this.options._const.replaceElement,\n                    )\n                    .setValue(this.options._const.oldValue, cleanNode(t1))\n                    .setValue(this.options._const.newValue, cleanNode(t2))\n                    .setValue(this.options._const.route, route),\n            ]\n        }\n\n        if (\n            Object.prototype.hasOwnProperty.call(t1, \"data\") &&\n            (t1 as textDiffNodeType).data !== (t2 as textDiffNodeType).data\n        ) {\n            // Comment or text node.\n            if (t1.nodeName === \"#text\") {\n                return [\n                    new Diff()\n                        .setValue(\n                            this.options._const.action,\n                            this.options._const.modifyTextElement,\n                        )\n                        .setValue(this.options._const.route, route)\n                        .setValue(\n                            this.options._const.oldValue,\n                            (t1 as textDiffNodeType).data,\n                        )\n                        .setValue(\n                            this.options._const.newValue,\n                            (t2 as textDiffNodeType).data,\n                        ),\n                ]\n            } else {\n                return [\n                    new Diff()\n                        .setValue(\n                            this.options._const.action,\n                            this.options._const.modifyComment,\n                        )\n                        .setValue(this.options._const.route, route)\n                        .setValue(\n                            this.options._const.oldValue,\n                            (t1 as textDiffNodeType).data,\n                        )\n                        .setValue(\n                            this.options._const.newValue,\n                            (t2 as textDiffNodeType).data,\n                        ),\n                ]\n            }\n        }\n\n        t1 = t1 as elementDiffNodeType\n        t2 = t2 as elementDiffNodeType\n\n        attr1 = t1.attributes ? Object.keys(t1.attributes).sort() : []\n        attr2 = t2.attributes ? Object.keys(t2.attributes).sort() : []\n\n        attrLength = attr1.length\n        for (i = 0; i < attrLength; i++) {\n            attr = attr1[i]\n            pos = attr2.indexOf(attr)\n            if (pos === -1) {\n                diffs.push(\n                    new Diff()\n                        .setValue(\n                            this.options._const.action,\n                            this.options._const.removeAttribute,\n                        )\n                        .setValue(this.options._const.route, route)\n                        .setValue(this.options._const.name, attr)\n                        .setValue(\n                            this.options._const.value,\n                            t1.attributes[attr],\n                        ),\n                )\n            } else {\n                attr2.splice(pos, 1)\n                if (t1.attributes[attr] !== t2.attributes[attr]) {\n                    diffs.push(\n                        new Diff()\n                            .setValue(\n                                this.options._const.action,\n                                this.options._const.modifyAttribute,\n                            )\n                            .setValue(this.options._const.route, route)\n                            .setValue(this.options._const.name, attr)\n                            .setValue(\n                                this.options._const.oldValue,\n                                t1.attributes[attr],\n                            )\n                            .setValue(\n                                this.options._const.newValue,\n                                t2.attributes[attr],\n                            ),\n                    )\n                }\n            }\n        }\n\n        attrLength = attr2.length\n        for (i = 0; i < attrLength; i++) {\n            attr = attr2[i]\n            diffs.push(\n                new Diff()\n                    .setValue(\n                        this.options._const.action,\n                        this.options._const.addAttribute,\n                    )\n                    .setValue(this.options._const.route, route)\n                    .setValue(this.options._const.name, attr)\n                    .setValue(this.options._const.value, t2.attributes[attr]),\n            )\n        }\n\n        return diffs\n    }\n\n    findInnerDiff(\n        t1: elementDiffNodeType,\n        t2: elementDiffNodeType,\n        route: number[],\n    ) {\n        const t1ChildNodes = t1.childNodes ? t1.childNodes.slice() : []\n        const t2ChildNodes = t2.childNodes ? t2.childNodes.slice() : []\n        const last = Math.max(t1ChildNodes.length, t2ChildNodes.length)\n        let childNodesLengthDifference = Math.abs(\n            t1ChildNodes.length - t2ChildNodes.length,\n        )\n        let diffs: Diff[] = []\n        let index = 0\n        if (!this.options.maxChildCount || last < this.options.maxChildCount) {\n            const cachedSubtrees = Boolean(t1.subsets && t1.subsetsAge--)\n            const subtrees = cachedSubtrees\n                ? t1.subsets\n                : t1.childNodes && t2.childNodes\n                  ? markSubTrees(t1, t2)\n                  : []\n            if (subtrees.length > 0) {\n                /* One or more groups have been identified among the childnodes of t1\n                 * and t2.\n                 */\n                diffs = this.attemptGroupRelocation(\n                    t1,\n                    t2,\n                    subtrees,\n                    route,\n                    cachedSubtrees,\n                )\n                if (diffs.length > 0) {\n                    return diffs\n                }\n            }\n        }\n\n        /* 0 or 1 groups of similar child nodes have been found\n         * for t1 and t2. 1 If there is 1, it could be a sign that the\n         * contents are the same. When the number of groups is below 2,\n         * t1 and t2 are made to have the same length and each of the\n         * pairs of child nodes are diffed.\n         */\n\n        for (let i = 0; i < last; i += 1) {\n            const e1 = t1ChildNodes[i]\n            const e2 = t2ChildNodes[i]\n\n            if (childNodesLengthDifference) {\n                /* t1 and t2 have different amounts of childNodes. Add\n                 * and remove as necessary to obtain the same length */\n                if (e1 && !e2) {\n                    if (e1.nodeName === \"#text\") {\n                        diffs.push(\n                            new Diff()\n                                .setValue(\n                                    this.options._const.action,\n                                    this.options._const.removeTextElement,\n                                )\n                                .setValue(\n                                    this.options._const.route,\n                                    route.concat(index),\n                                )\n                                .setValue(\n                                    this.options._const.value,\n                                    (e1 as textDiffNodeType).data,\n                                ),\n                        )\n                        index -= 1\n                    } else {\n                        diffs.push(\n                            new Diff()\n                                .setValue(\n                                    this.options._const.action,\n                                    this.options._const.removeElement,\n                                )\n                                .setValue(\n                                    this.options._const.route,\n                                    route.concat(index),\n                                )\n                                .setValue(\n                                    this.options._const.element,\n                                    cleanNode(e1),\n                                ),\n                        )\n                        index -= 1\n                    }\n                } else if (e2 && !e1) {\n                    if (e2.nodeName === \"#text\") {\n                        diffs.push(\n                            new Diff()\n                                .setValue(\n                                    this.options._const.action,\n                                    this.options._const.addTextElement,\n                                )\n                                .setValue(\n                                    this.options._const.route,\n                                    route.concat(index),\n                                )\n                                .setValue(\n                                    this.options._const.value,\n                                    (e2 as textDiffNodeType).data,\n                                ),\n                        )\n                    } else {\n                        diffs.push(\n                            new Diff()\n                                .setValue(\n                                    this.options._const.action,\n                                    this.options._const.addElement,\n                                )\n                                .setValue(\n                                    this.options._const.route,\n                                    route.concat(index),\n                                )\n                                .setValue(\n                                    this.options._const.element,\n                                    cleanNode(e2),\n                                ),\n                        )\n                    }\n                }\n            }\n            /* We are now guaranteed that childNodes e1 and e2 exist,\n             * and that they can be diffed.\n             */\n            /* Diffs in child nodes should not affect the parent node,\n             * so we let these diffs be submitted together with other\n             * diffs.\n             */\n\n            if (e1 && e2) {\n                if (\n                    !this.options.maxChildCount ||\n                    last < this.options.maxChildCount\n                ) {\n                    diffs = diffs.concat(\n                        this.findNextDiff(e1, e2, route.concat(index)),\n                    )\n                } else if (!isEqual(e1, e2)) {\n                    if (t1ChildNodes.length > t2ChildNodes.length) {\n                        if (e1.nodeName === \"#text\") {\n                            diffs.push(\n                                new Diff()\n                                    .setValue(\n                                        this.options._const.action,\n                                        this.options._const.removeTextElement,\n                                    )\n                                    .setValue(\n                                        this.options._const.route,\n                                        route.concat(index),\n                                    )\n                                    .setValue(\n                                        this.options._const.value,\n                                        (e1 as textDiffNodeType).data,\n                                    ),\n                            )\n                        } else {\n                            diffs.push(\n                                new Diff()\n                                    .setValue(\n                                        this.options._const.action,\n                                        this.options._const.removeElement,\n                                    )\n                                    .setValue(\n                                        this.options._const.element,\n                                        cleanNode(e1),\n                                    )\n                                    .setValue(\n                                        this.options._const.route,\n                                        route.concat(index),\n                                    ),\n                            )\n                        }\n                        t1ChildNodes.splice(i, 1)\n                        i -= 1\n                        index -= 1\n\n                        childNodesLengthDifference -= 1\n                    } else if (t1ChildNodes.length < t2ChildNodes.length) {\n                        diffs = diffs.concat([\n                            new Diff()\n                                .setValue(\n                                    this.options._const.action,\n                                    this.options._const.addElement,\n                                )\n                                .setValue(\n                                    this.options._const.element,\n                                    cleanNode(e2),\n                                )\n                                .setValue(\n                                    this.options._const.route,\n                                    route.concat(index),\n                                ),\n                        ])\n                        t1ChildNodes.splice(i, 0, cleanNode(e2))\n                        childNodesLengthDifference -= 1\n                    } else {\n                        diffs = diffs.concat([\n                            new Diff()\n                                .setValue(\n                                    this.options._const.action,\n                                    this.options._const.replaceElement,\n                                )\n                                .setValue(\n                                    this.options._const.oldValue,\n                                    cleanNode(e1),\n                                )\n                                .setValue(\n                                    this.options._const.newValue,\n                                    cleanNode(e2),\n                                )\n                                .setValue(\n                                    this.options._const.route,\n                                    route.concat(index),\n                                ),\n                        ])\n                    }\n                }\n            }\n            index += 1\n        }\n        t1.innerDone = true\n        return diffs\n    }\n\n    attemptGroupRelocation(\n        t1: elementDiffNodeType,\n        t2: elementDiffNodeType,\n        subtrees: subsetType[],\n        route: number[],\n        cachedSubtrees: boolean,\n    ) {\n        /* Either t1.childNodes and t2.childNodes have the same length, or\n         * there are at least two groups of similar elements can be found.\n         * attempts are made at equalizing t1 with t2. First all initial\n         * elements with no group affiliation (gaps=true) are removed (if\n         * only in t1) or added (if only in t2). Then the creation of a group\n         * relocation diff is attempted.\n         */\n        const gapInformation = getGapInformation(t1, t2, subtrees)\n        const gaps1 = gapInformation.gaps1\n        const gaps2 = gapInformation.gaps2\n        const t1ChildNodes = t1.childNodes.slice()\n        const t2ChildNodes = t2.childNodes.slice()\n        let shortest = Math.min(gaps1.length, gaps2.length)\n        let destinationDifferent\n        let toGroup\n        let group\n        let node\n        let similarNode\n        const diffs = []\n        for (\n            let index2 = 0, index1 = 0;\n            index2 < shortest;\n            index1 += 1, index2 += 1\n        ) {\n            if (\n                cachedSubtrees &&\n                (gaps1[index2] === true || gaps2[index2] === true)\n            ) {\n                // pass\n            } else if (gaps1[index1] === true) {\n                node = t1ChildNodes[index1]\n                if (node.nodeName === \"#text\") {\n                    if (t2ChildNodes[index2].nodeName === \"#text\") {\n                        if (\n                            (node as textDiffNodeType).data !==\n                            (t2ChildNodes[index2] as textDiffNodeType).data\n                        ) {\n                            // Check whether a text node with the same value follows later on.\n                            let testI = index1\n                            while (\n                                t1ChildNodes.length > testI + 1 &&\n                                t1ChildNodes[testI + 1].nodeName === \"#text\"\n                            ) {\n                                testI += 1\n                                if (\n                                    (t2ChildNodes[index2] as textDiffNodeType)\n                                        .data ===\n                                    (t1ChildNodes[testI] as textDiffNodeType)\n                                        .data\n                                ) {\n                                    similarNode = true\n                                    break\n                                }\n                            }\n                            if (!similarNode) {\n                                diffs.push(\n                                    new Diff()\n                                        .setValue(\n                                            this.options._const.action,\n                                            this.options._const\n                                                .modifyTextElement,\n                                        )\n                                        .setValue(\n                                            this.options._const.route,\n                                            route.concat(index1),\n                                        )\n                                        .setValue(\n                                            this.options._const.oldValue,\n                                            node.data,\n                                        )\n                                        .setValue(\n                                            this.options._const.newValue,\n                                            (\n                                                t2ChildNodes[\n                                                    index2\n                                                ] as textDiffNodeType\n                                            ).data,\n                                        ),\n                                    // t1ChildNodes at position index1 is not up-to-date, but that does not matter as\n                                    // index1 will increase +1\n                                )\n                            }\n                        }\n                    } else {\n                        diffs.push(\n                            new Diff()\n                                .setValue(\n                                    this.options._const.action,\n                                    this.options._const.removeTextElement,\n                                )\n                                .setValue(\n                                    this.options._const.route,\n                                    route.concat(index1),\n                                )\n                                .setValue(this.options._const.value, node.data),\n                        )\n                        gaps1.splice(index1, 1)\n                        t1ChildNodes.splice(index1, 1)\n                        shortest = Math.min(gaps1.length, gaps2.length)\n                        index1 -= 1\n                        index2 -= 1\n                    }\n                } else if (gaps2[index2] === true) {\n                    // both gaps1[index1] and gaps2[index2]  are true.\n                    // We replace one element with another.\n                    diffs.push(\n                        new Diff()\n                            .setValue(\n                                this.options._const.action,\n                                this.options._const.replaceElement,\n                            )\n                            .setValue(\n                                this.options._const.oldValue,\n                                cleanNode(node),\n                            )\n                            .setValue(\n                                this.options._const.newValue,\n                                cleanNode(t2ChildNodes[index2]),\n                            )\n                            .setValue(\n                                this.options._const.route,\n                                route.concat(index1),\n                            ),\n                    )\n                    // t1ChildNodes at position index1 is not up-to-date, but that does not matter as\n                    // index1 will increase +1\n                } else {\n                    diffs.push(\n                        new Diff()\n                            .setValue(\n                                this.options._const.action,\n                                this.options._const.removeElement,\n                            )\n                            .setValue(\n                                this.options._const.route,\n                                route.concat(index1),\n                            )\n                            .setValue(\n                                this.options._const.element,\n                                cleanNode(node),\n                            ),\n                    )\n                    gaps1.splice(index1, 1)\n                    t1ChildNodes.splice(index1, 1)\n                    shortest = Math.min(gaps1.length, gaps2.length)\n                    index1 -= 1\n                    index2 -= 1\n                }\n            } else if (gaps2[index2] === true) {\n                node = t2ChildNodes[index2]\n                if (node.nodeName === \"#text\") {\n                    diffs.push(\n                        new Diff()\n                            .setValue(\n                                this.options._const.action,\n                                this.options._const.addTextElement,\n                            )\n                            .setValue(\n                                this.options._const.route,\n                                route.concat(index1),\n                            )\n                            .setValue(this.options._const.value, node.data),\n                    )\n                    gaps1.splice(index1, 0, true)\n                    t1ChildNodes.splice(index1, 0, {\n                        nodeName: \"#text\",\n                        data: node.data,\n                    })\n                    shortest = Math.min(gaps1.length, gaps2.length)\n                    //index1 += 1\n                } else {\n                    diffs.push(\n                        new Diff()\n                            .setValue(\n                                this.options._const.action,\n                                this.options._const.addElement,\n                            )\n                            .setValue(\n                                this.options._const.route,\n                                route.concat(index1),\n                            )\n                            .setValue(\n                                this.options._const.element,\n                                cleanNode(node),\n                            ),\n                    )\n                    gaps1.splice(index1, 0, true)\n                    t1ChildNodes.splice(index1, 0, cleanNode(node))\n                    shortest = Math.min(gaps1.length, gaps2.length)\n                    //index1 += 1\n                }\n            } else if (gaps1[index1] !== gaps2[index2]) {\n                if (diffs.length > 0) {\n                    return diffs\n                }\n                // group relocation\n                group = subtrees[gaps1[index1] as number]\n                toGroup = Math.min(\n                    group.newValue,\n                    t1ChildNodes.length - group.length,\n                )\n                if (toGroup !== group.oldValue && toGroup > -1) {\n                    // Check whether destination nodes are different than originating ones.\n                    destinationDifferent = false\n                    for (let j = 0; j < group.length; j += 1) {\n                        if (\n                            !roughlyEqual(\n                                t1ChildNodes[toGroup + j],\n                                t1ChildNodes[group.oldValue + j],\n                                {},\n                                false,\n                                true,\n                            )\n                        ) {\n                            destinationDifferent = true\n                        }\n                    }\n                    if (destinationDifferent) {\n                        return [\n                            new Diff()\n                                .setValue(\n                                    this.options._const.action,\n                                    this.options._const.relocateGroup,\n                                )\n                                .setValue(\n                                    this.options._const.groupLength,\n                                    group.length,\n                                )\n                                .setValue(\n                                    this.options._const.from,\n                                    group.oldValue,\n                                )\n                                .setValue(this.options._const.to, toGroup)\n                                .setValue(this.options._const.route, route),\n                        ]\n                    }\n                }\n            }\n        }\n        return diffs\n    }\n\n    findValueDiff(\n        t1: elementDiffNodeType,\n        t2: elementDiffNodeType,\n        route: number[],\n    ) {\n        // Differences of value. Only useful if the value/selection/checked value\n        // differs from what is represented in the DOM. For example in the case\n        // of filled out forms, etc.\n        const diffs = []\n\n        if (t1.selected !== t2.selected) {\n            diffs.push(\n                new Diff()\n                    .setValue(\n                        this.options._const.action,\n                        this.options._const.modifySelected,\n                    )\n                    .setValue(this.options._const.oldValue, t1.selected)\n                    .setValue(this.options._const.newValue, t2.selected)\n                    .setValue(this.options._const.route, route),\n            )\n        }\n\n        if (\n            (t1.value || t2.value) &&\n            t1.value !== t2.value &&\n            t1.nodeName !== \"OPTION\"\n        ) {\n            diffs.push(\n                new Diff()\n                    .setValue(\n                        this.options._const.action,\n                        this.options._const.modifyValue,\n                    )\n                    .setValue(this.options._const.oldValue, t1.value || \"\")\n                    .setValue(this.options._const.newValue, t2.value || \"\")\n                    .setValue(this.options._const.route, route),\n            )\n        }\n        if (t1.checked !== t2.checked) {\n            diffs.push(\n                new Diff()\n                    .setValue(\n                        this.options._const.action,\n                        this.options._const.modifyChecked,\n                    )\n                    .setValue(this.options._const.oldValue, t1.checked)\n                    .setValue(this.options._const.newValue, t2.checked)\n                    .setValue(this.options._const.route, route),\n            )\n        }\n\n        return diffs\n    }\n}\n","import {\n    ConstNames,\n    ConstNamesPartial,\n    DiffDOMOptions,\n    DiffDOMOptionsPartial,\n    diffType,\n    elementNodeType,\n    textNodeType,\n} from \"./types\"\nimport { applyDOM, undoDOM } from \"./dom/index\"\nimport { Diff } from \"./helpers\"\nimport { DiffFinder } from \"./virtual/index\"\nexport { nodeToObj, stringToObj } from \"./virtual/index\"\n\nconst DEFAULT_OPTIONS = {\n    debug: false,\n    diffcap: 10, // Limit for how many diffs are accepting when debugging. Inactive when debug is false.\n    maxDepth: false, // False or a numeral. If set to a numeral, limits the level of depth that the the diff mechanism looks for differences. If false, goes through the entire tree.\n    maxChildCount: 50, // False or a numeral. If set to a numeral, only does a simplified form of diffing of contents so that the number of diffs cannot be higher than the number of child nodes.\n    valueDiffing: true, // Whether to take into consideration the values of forms that differ from auto assigned values (when a user fills out a form).\n    // syntax: textDiff: function (node, currentValue, expectedValue, newValue)\n    textDiff(\n        node: textNodeType,\n        currentValue: string,\n        expectedValue: string,\n        newValue: string,\n    ) {\n        node.data = newValue\n        return\n    },\n    // empty functions were benchmarked as running faster than both\n    // `f && f()` and `if (f) { f(); }`\n    preVirtualDiffApply() {}, // eslint-disable-line @typescript-eslint/no-empty-function\n    postVirtualDiffApply() {}, // eslint-disable-line @typescript-eslint/no-empty-function\n    preDiffApply() {}, // eslint-disable-line @typescript-eslint/no-empty-function\n    postDiffApply() {}, // eslint-disable-line @typescript-eslint/no-empty-function\n    filterOuterDiff: null,\n    compress: false, // Whether to work with compressed diffs\n    _const: false, // object with strings for every change types to be used in diffs.\n    document:\n        typeof window !== \"undefined\" && window.document\n            ? window.document\n            : false,\n    components: [], // list of components used for converting from string\n}\n\nexport class DiffDOM {\n    options: DiffDOMOptions\n    constructor(options: DiffDOMOptionsPartial = {}) {\n        // IE11 doesn't have Object.assign and buble doesn't translate object spreaders\n        // by default, so this is the safest way of doing it currently.\n        Object.entries(DEFAULT_OPTIONS).forEach(([key, value]) => {\n            if (!Object.prototype.hasOwnProperty.call(options, key)) {\n                options[key] = value\n            }\n        })\n\n        if (!options._const) {\n            const varNames = [\n                \"addAttribute\",\n                \"modifyAttribute\",\n                \"removeAttribute\",\n                \"modifyTextElement\",\n                \"relocateGroup\",\n                \"removeElement\",\n                \"addElement\",\n                \"removeTextElement\",\n                \"addTextElement\",\n                \"replaceElement\",\n                \"modifyValue\",\n                \"modifyChecked\",\n                \"modifySelected\",\n                \"modifyComment\",\n                \"action\",\n                \"route\",\n                \"oldValue\",\n                \"newValue\",\n                \"element\",\n                \"group\",\n                \"groupLength\",\n                \"from\",\n                \"to\",\n                \"name\",\n                \"value\",\n                \"data\",\n                \"attributes\",\n                \"nodeName\",\n                \"childNodes\",\n                \"checked\",\n                \"selected\",\n            ]\n            const constNames: ConstNamesPartial = {}\n            if (options.compress) {\n                varNames.forEach(\n                    (varName, index) => (constNames[varName] = index),\n                )\n            } else {\n                varNames.forEach((varName) => (constNames[varName] = varName))\n            }\n            options._const = constNames as ConstNames\n        }\n\n        this.options = options as DiffDOMOptions\n    }\n\n    apply(tree: Element, diffs: (Diff | diffType)[]) {\n        return applyDOM(tree, diffs, this.options)\n    }\n\n    undo(tree: Element, diffs: (Diff | diffType)[]) {\n        return undoDOM(tree, diffs, this.options)\n    }\n\n    diff(\n        t1Node: string | elementNodeType | Element,\n        t2Node: string | elementNodeType | Element,\n    ) {\n        const finder = new DiffFinder(t1Node, t2Node, this.options)\n        return finder.init()\n    }\n}\n","import { checkElementType } from \"./diffDOM/helpers\"\n\n/**\n * Use TraceLogger to figure out function calls inside\n * JS objects by wrapping an object with a TraceLogger\n * instance.\n *\n * Pretty-prints the call trace (using unicode box code)\n * when tracelogger.toString() is called.\n */\n\n/**\n * Wrap an object by calling new TraceLogger(obj)\n *\n * If you're familiar with Python decorators, this\n * does roughly the same thing, adding pre/post\n * call hook logging calls so that you can see\n * what's going on.\n */\nexport class TraceLogger {\n    messages: string[]\n    pad: string\n    padding: string\n    tick: number\n    constructor(obj = {}) {\n        this.pad = \"│   \"\n        this.padding = \"\"\n        this.tick = 1\n        this.messages = []\n        const wrapkey = (obj: object, key: string) => {\n            // trace this function\n            const oldfn = obj[key]\n            obj[key] = (\n                ...args: ((\n                    ...args: (\n                        | string\n                        | HTMLElement\n                        | number\n                        | boolean\n                        | false\n                        | (string | HTMLElement | number | boolean | false)[]\n                    )[]\n                ) => void)[]\n            ) => {\n                this.fin(key, Array.prototype.slice.call(args))\n                const result = oldfn.apply(obj, args)\n                this.fout(key, result)\n                return result\n            }\n        }\n        // can't use Object.keys for prototype walking\n        for (let key in obj) {\n            if (typeof obj[key] === \"function\") {\n                wrapkey(obj, key)\n            }\n        }\n        this.log(\"┌ TRACELOG START\")\n    }\n    // called when entering a function\n    fin(\n        fn: string,\n        args:\n            | string\n            | HTMLElement\n            | number\n            | boolean\n            | false\n            | (string | HTMLElement | number | boolean | false)[],\n    ) {\n        this.padding += this.pad\n        this.log(`├─> entering ${fn}`, args)\n    }\n    // called when exiting a function\n    fout(\n        fn: string,\n        result:\n            | string\n            | HTMLElement\n            | number\n            | boolean\n            | false\n            | (string | HTMLElement | number | boolean | false)[],\n    ) {\n        this.log(\"│<──┘ generated return value\", result)\n        this.padding = this.padding.substring(\n            0,\n            this.padding.length - this.pad.length,\n        )\n    }\n    // log message formatting\n    format(s: string, tick: number) {\n        let nf = function (t: number) {\n            let tStr = `${t}`\n            while (tStr.length < 4) {\n                tStr = `0${t}`\n            }\n            return tStr\n        }\n        return `${nf(tick)}> ${this.padding}${s}`\n    }\n    // log a trace message\n    log(...args) {\n        const stringCollapse = function (\n            v:\n                | string\n                | HTMLElement\n                | number\n                | boolean\n                | false\n                | (string | HTMLElement | number | boolean | false)[],\n        ) {\n            if (!v) {\n                return \"<falsey>\"\n            }\n            if (typeof v === \"string\") {\n                return v\n            }\n            if (checkElementType(v, \"HTMLElement\")) {\n                return (v as HTMLElement).outerHTML || \"<empty>\"\n            }\n            if (v instanceof Array) {\n                return `[${v.map(stringCollapse).join(\",\")}]`\n            }\n            return v.toString() || v.valueOf() || \"<unknown>\"\n        }\n        const s = args.map(stringCollapse).join(\", \")\n        this.messages.push(this.format(s, this.tick++))\n    }\n    // turn the log into a structured string with\n    // unicode box codes to make it a sensible trace.\n    toString() {\n        let cap = \"×   \"\n        let terminator = \"└───\"\n        while (terminator.length <= this.padding.length + this.pad.length) {\n            terminator += cap\n        }\n        let _ = this.padding\n        this.padding = \"\"\n        terminator = this.format(terminator, this.tick)\n        this.padding = _\n        return `${this.messages.join(\"\\n\")}\\n${terminator}`\n    }\n}\n","/**\n * Diff Match and Patch\n * Copyright 2018 The diff-match-patch Authors.\n * https://github.com/google/diff-match-patch\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * @fileoverview Computes the difference between two texts to create a patch.\n * Applies the patch onto another text, allowing for errors.\n * @author fraser@google.com (Neil Fraser)\n */\n\n/**\n * Class containing the diff, match and patch methods.\n * @constructor\n */\nvar diff_match_patch = function() {\n\n  // Defaults.\n  // Redefine these in your program to override the defaults.\n\n  // Number of seconds to map a diff before giving up (0 for infinity).\n  this.Diff_Timeout = 1.0;\n  // Cost of an empty edit operation in terms of edit characters.\n  this.Diff_EditCost = 4;\n  // At what point is no match declared (0.0 = perfection, 1.0 = very loose).\n  this.Match_Threshold = 0.5;\n  // How far to search for a match (0 = exact location, 1000+ = broad match).\n  // A match this many characters away from the expected location will add\n  // 1.0 to the score (0.0 is a perfect match).\n  this.Match_Distance = 1000;\n  // When deleting a large block of text (over ~64 characters), how close do\n  // the contents have to be to match the expected contents. (0.0 = perfection,\n  // 1.0 = very loose).  Note that Match_Threshold controls how closely the\n  // end points of a delete need to match.\n  this.Patch_DeleteThreshold = 0.5;\n  // Chunk size for context length.\n  this.Patch_Margin = 4;\n\n  // The number of bits in an int.\n  this.Match_MaxBits = 32;\n};\n\n\n//  DIFF FUNCTIONS\n\n\n/**\n * The data structure representing a diff is an array of tuples:\n * [[DIFF_DELETE, 'Hello'], [DIFF_INSERT, 'Goodbye'], [DIFF_EQUAL, ' world.']]\n * which means: delete 'Hello', add 'Goodbye' and keep ' world.'\n */\nvar DIFF_DELETE = -1;\nvar DIFF_INSERT = 1;\nvar DIFF_EQUAL = 0;\n\n/**\n * Class representing one diff tuple.\n * ~Attempts to look like a two-element array (which is what this used to be).~\n * Constructor returns an actual two-element array, to allow destructing @JackuB\n * See https://github.com/JackuB/diff-match-patch/issues/14 for details\n * @param {number} op Operation, one of: DIFF_DELETE, DIFF_INSERT, DIFF_EQUAL.\n * @param {string} text Text to be deleted, inserted, or retained.\n * @constructor\n */\ndiff_match_patch.Diff = function(op, text) {\n  return [op, text];\n};\n\n/**\n * Find the differences between two texts.  Simplifies the problem by stripping\n * any common prefix or suffix off the texts before diffing.\n * @param {string} text1 Old string to be diffed.\n * @param {string} text2 New string to be diffed.\n * @param {boolean=} opt_checklines Optional speedup flag. If present and false,\n *     then don't run a line-level diff first to identify the changed areas.\n *     Defaults to true, which does a faster, slightly less optimal diff.\n * @param {number=} opt_deadline Optional time when the diff should be complete\n *     by.  Used internally for recursive calls.  Users should set DiffTimeout\n *     instead.\n * @return {!Array.<!diff_match_patch.Diff>} Array of diff tuples.\n */\ndiff_match_patch.prototype.diff_main = function(text1, text2, opt_checklines,\n    opt_deadline) {\n  // Set a deadline by which time the diff must be complete.\n  if (typeof opt_deadline == 'undefined') {\n    if (this.Diff_Timeout <= 0) {\n      opt_deadline = Number.MAX_VALUE;\n    } else {\n      opt_deadline = (new Date).getTime() + this.Diff_Timeout * 1000;\n    }\n  }\n  var deadline = opt_deadline;\n\n  // Check for null inputs.\n  if (text1 == null || text2 == null) {\n    throw new Error('Null input. (diff_main)');\n  }\n\n  // Check for equality (speedup).\n  if (text1 == text2) {\n    if (text1) {\n      return [new diff_match_patch.Diff(DIFF_EQUAL, text1)];\n    }\n    return [];\n  }\n\n  if (typeof opt_checklines == 'undefined') {\n    opt_checklines = true;\n  }\n  var checklines = opt_checklines;\n\n  // Trim off common prefix (speedup).\n  var commonlength = this.diff_commonPrefix(text1, text2);\n  var commonprefix = text1.substring(0, commonlength);\n  text1 = text1.substring(commonlength);\n  text2 = text2.substring(commonlength);\n\n  // Trim off common suffix (speedup).\n  commonlength = this.diff_commonSuffix(text1, text2);\n  var commonsuffix = text1.substring(text1.length - commonlength);\n  text1 = text1.substring(0, text1.length - commonlength);\n  text2 = text2.substring(0, text2.length - commonlength);\n\n  // Compute the diff on the middle block.\n  var diffs = this.diff_compute_(text1, text2, checklines, deadline);\n\n  // Restore the prefix and suffix.\n  if (commonprefix) {\n    diffs.unshift(new diff_match_patch.Diff(DIFF_EQUAL, commonprefix));\n  }\n  if (commonsuffix) {\n    diffs.push(new diff_match_patch.Diff(DIFF_EQUAL, commonsuffix));\n  }\n  this.diff_cleanupMerge(diffs);\n  return diffs;\n};\n\n\n/**\n * Find the differences between two texts.  Assumes that the texts do not\n * have any common prefix or suffix.\n * @param {string} text1 Old string to be diffed.\n * @param {string} text2 New string to be diffed.\n * @param {boolean} checklines Speedup flag.  If false, then don't run a\n *     line-level diff first to identify the changed areas.\n *     If true, then run a faster, slightly less optimal diff.\n * @param {number} deadline Time when the diff should be complete by.\n * @return {!Array.<!diff_match_patch.Diff>} Array of diff tuples.\n * @private\n */\ndiff_match_patch.prototype.diff_compute_ = function(text1, text2, checklines,\n    deadline) {\n  var diffs;\n\n  if (!text1) {\n    // Just add some text (speedup).\n    return [new diff_match_patch.Diff(DIFF_INSERT, text2)];\n  }\n\n  if (!text2) {\n    // Just delete some text (speedup).\n    return [new diff_match_patch.Diff(DIFF_DELETE, text1)];\n  }\n\n  var longtext = text1.length > text2.length ? text1 : text2;\n  var shorttext = text1.length > text2.length ? text2 : text1;\n  var i = longtext.indexOf(shorttext);\n  if (i != -1) {\n    // Shorter text is inside the longer text (speedup).\n    diffs = [new diff_match_patch.Diff(DIFF_INSERT, longtext.substring(0, i)),\n             new diff_match_patch.Diff(DIFF_EQUAL, shorttext),\n             new diff_match_patch.Diff(DIFF_INSERT,\n                 longtext.substring(i + shorttext.length))];\n    // Swap insertions for deletions if diff is reversed.\n    if (text1.length > text2.length) {\n      diffs[0][0] = diffs[2][0] = DIFF_DELETE;\n    }\n    return diffs;\n  }\n\n  if (shorttext.length == 1) {\n    // Single character string.\n    // After the previous speedup, the character can't be an equality.\n    return [new diff_match_patch.Diff(DIFF_DELETE, text1),\n            new diff_match_patch.Diff(DIFF_INSERT, text2)];\n  }\n\n  // Check to see if the problem can be split in two.\n  var hm = this.diff_halfMatch_(text1, text2);\n  if (hm) {\n    // A half-match was found, sort out the return data.\n    var text1_a = hm[0];\n    var text1_b = hm[1];\n    var text2_a = hm[2];\n    var text2_b = hm[3];\n    var mid_common = hm[4];\n    // Send both pairs off for separate processing.\n    var diffs_a = this.diff_main(text1_a, text2_a, checklines, deadline);\n    var diffs_b = this.diff_main(text1_b, text2_b, checklines, deadline);\n    // Merge the results.\n    return diffs_a.concat([new diff_match_patch.Diff(DIFF_EQUAL, mid_common)],\n                          diffs_b);\n  }\n\n  if (checklines && text1.length > 100 && text2.length > 100) {\n    return this.diff_lineMode_(text1, text2, deadline);\n  }\n\n  return this.diff_bisect_(text1, text2, deadline);\n};\n\n\n/**\n * Do a quick line-level diff on both strings, then rediff the parts for\n * greater accuracy.\n * This speedup can produce non-minimal diffs.\n * @param {string} text1 Old string to be diffed.\n * @param {string} text2 New string to be diffed.\n * @param {number} deadline Time when the diff should be complete by.\n * @return {!Array.<!diff_match_patch.Diff>} Array of diff tuples.\n * @private\n */\ndiff_match_patch.prototype.diff_lineMode_ = function(text1, text2, deadline) {\n  // Scan the text on a line-by-line basis first.\n  var a = this.diff_linesToChars_(text1, text2);\n  text1 = a.chars1;\n  text2 = a.chars2;\n  var linearray = a.lineArray;\n\n  var diffs = this.diff_main(text1, text2, false, deadline);\n\n  // Convert the diff back to original text.\n  this.diff_charsToLines_(diffs, linearray);\n  // Eliminate freak matches (e.g. blank lines)\n  this.diff_cleanupSemantic(diffs);\n\n  // Rediff any replacement blocks, this time character-by-character.\n  // Add a dummy entry at the end.\n  diffs.push(new diff_match_patch.Diff(DIFF_EQUAL, ''));\n  var pointer = 0;\n  var count_delete = 0;\n  var count_insert = 0;\n  var text_delete = '';\n  var text_insert = '';\n  while (pointer < diffs.length) {\n    switch (diffs[pointer][0]) {\n      case DIFF_INSERT:\n        count_insert++;\n        text_insert += diffs[pointer][1];\n        break;\n      case DIFF_DELETE:\n        count_delete++;\n        text_delete += diffs[pointer][1];\n        break;\n      case DIFF_EQUAL:\n        // Upon reaching an equality, check for prior redundancies.\n        if (count_delete >= 1 && count_insert >= 1) {\n          // Delete the offending records and add the merged ones.\n          diffs.splice(pointer - count_delete - count_insert,\n                       count_delete + count_insert);\n          pointer = pointer - count_delete - count_insert;\n          var subDiff =\n              this.diff_main(text_delete, text_insert, false, deadline);\n          for (var j = subDiff.length - 1; j >= 0; j--) {\n            diffs.splice(pointer, 0, subDiff[j]);\n          }\n          pointer = pointer + subDiff.length;\n        }\n        count_insert = 0;\n        count_delete = 0;\n        text_delete = '';\n        text_insert = '';\n        break;\n    }\n    pointer++;\n  }\n  diffs.pop();  // Remove the dummy entry at the end.\n\n  return diffs;\n};\n\n\n/**\n * Find the 'middle snake' of a diff, split the problem in two\n * and return the recursively constructed diff.\n * See Myers 1986 paper: An O(ND) Difference Algorithm and Its Variations.\n * @param {string} text1 Old string to be diffed.\n * @param {string} text2 New string to be diffed.\n * @param {number} deadline Time at which to bail if not yet complete.\n * @return {!Array.<!diff_match_patch.Diff>} Array of diff tuples.\n * @private\n */\ndiff_match_patch.prototype.diff_bisect_ = function(text1, text2, deadline) {\n  // Cache the text lengths to prevent multiple calls.\n  var text1_length = text1.length;\n  var text2_length = text2.length;\n  var max_d = Math.ceil((text1_length + text2_length) / 2);\n  var v_offset = max_d;\n  var v_length = 2 * max_d;\n  var v1 = new Array(v_length);\n  var v2 = new Array(v_length);\n  // Setting all elements to -1 is faster in Chrome & Firefox than mixing\n  // integers and undefined.\n  for (var x = 0; x < v_length; x++) {\n    v1[x] = -1;\n    v2[x] = -1;\n  }\n  v1[v_offset + 1] = 0;\n  v2[v_offset + 1] = 0;\n  var delta = text1_length - text2_length;\n  // If the total number of characters is odd, then the front path will collide\n  // with the reverse path.\n  var front = (delta % 2 != 0);\n  // Offsets for start and end of k loop.\n  // Prevents mapping of space beyond the grid.\n  var k1start = 0;\n  var k1end = 0;\n  var k2start = 0;\n  var k2end = 0;\n  for (var d = 0; d < max_d; d++) {\n    // Bail out if deadline is reached.\n    if ((new Date()).getTime() > deadline) {\n      break;\n    }\n\n    // Walk the front path one step.\n    for (var k1 = -d + k1start; k1 <= d - k1end; k1 += 2) {\n      var k1_offset = v_offset + k1;\n      var x1;\n      if (k1 == -d || (k1 != d && v1[k1_offset - 1] < v1[k1_offset + 1])) {\n        x1 = v1[k1_offset + 1];\n      } else {\n        x1 = v1[k1_offset - 1] + 1;\n      }\n      var y1 = x1 - k1;\n      while (x1 < text1_length && y1 < text2_length &&\n             text1.charAt(x1) == text2.charAt(y1)) {\n        x1++;\n        y1++;\n      }\n      v1[k1_offset] = x1;\n      if (x1 > text1_length) {\n        // Ran off the right of the graph.\n        k1end += 2;\n      } else if (y1 > text2_length) {\n        // Ran off the bottom of the graph.\n        k1start += 2;\n      } else if (front) {\n        var k2_offset = v_offset + delta - k1;\n        if (k2_offset >= 0 && k2_offset < v_length && v2[k2_offset] != -1) {\n          // Mirror x2 onto top-left coordinate system.\n          var x2 = text1_length - v2[k2_offset];\n          if (x1 >= x2) {\n            // Overlap detected.\n            return this.diff_bisectSplit_(text1, text2, x1, y1, deadline);\n          }\n        }\n      }\n    }\n\n    // Walk the reverse path one step.\n    for (var k2 = -d + k2start; k2 <= d - k2end; k2 += 2) {\n      var k2_offset = v_offset + k2;\n      var x2;\n      if (k2 == -d || (k2 != d && v2[k2_offset - 1] < v2[k2_offset + 1])) {\n        x2 = v2[k2_offset + 1];\n      } else {\n        x2 = v2[k2_offset - 1] + 1;\n      }\n      var y2 = x2 - k2;\n      while (x2 < text1_length && y2 < text2_length &&\n             text1.charAt(text1_length - x2 - 1) ==\n             text2.charAt(text2_length - y2 - 1)) {\n        x2++;\n        y2++;\n      }\n      v2[k2_offset] = x2;\n      if (x2 > text1_length) {\n        // Ran off the left of the graph.\n        k2end += 2;\n      } else if (y2 > text2_length) {\n        // Ran off the top of the graph.\n        k2start += 2;\n      } else if (!front) {\n        var k1_offset = v_offset + delta - k2;\n        if (k1_offset >= 0 && k1_offset < v_length && v1[k1_offset] != -1) {\n          var x1 = v1[k1_offset];\n          var y1 = v_offset + x1 - k1_offset;\n          // Mirror x2 onto top-left coordinate system.\n          x2 = text1_length - x2;\n          if (x1 >= x2) {\n            // Overlap detected.\n            return this.diff_bisectSplit_(text1, text2, x1, y1, deadline);\n          }\n        }\n      }\n    }\n  }\n  // Diff took too long and hit the deadline or\n  // number of diffs equals number of characters, no commonality at all.\n  return [new diff_match_patch.Diff(DIFF_DELETE, text1),\n          new diff_match_patch.Diff(DIFF_INSERT, text2)];\n};\n\n\n/**\n * Given the location of the 'middle snake', split the diff in two parts\n * and recurse.\n * @param {string} text1 Old string to be diffed.\n * @param {string} text2 New string to be diffed.\n * @param {number} x Index of split point in text1.\n * @param {number} y Index of split point in text2.\n * @param {number} deadline Time at which to bail if not yet complete.\n * @return {!Array.<!diff_match_patch.Diff>} Array of diff tuples.\n * @private\n */\ndiff_match_patch.prototype.diff_bisectSplit_ = function(text1, text2, x, y,\n    deadline) {\n  var text1a = text1.substring(0, x);\n  var text2a = text2.substring(0, y);\n  var text1b = text1.substring(x);\n  var text2b = text2.substring(y);\n\n  // Compute both diffs serially.\n  var diffs = this.diff_main(text1a, text2a, false, deadline);\n  var diffsb = this.diff_main(text1b, text2b, false, deadline);\n\n  return diffs.concat(diffsb);\n};\n\n\n/**\n * Split two texts into an array of strings.  Reduce the texts to a string of\n * hashes where each Unicode character represents one line.\n * @param {string} text1 First string.\n * @param {string} text2 Second string.\n * @return {{chars1: string, chars2: string, lineArray: !Array.<string>}}\n *     An object containing the encoded text1, the encoded text2 and\n *     the array of unique strings.\n *     The zeroth element of the array of unique strings is intentionally blank.\n * @private\n */\ndiff_match_patch.prototype.diff_linesToChars_ = function(text1, text2) {\n  var lineArray = [];  // e.g. lineArray[4] == 'Hello\\n'\n  var lineHash = {};   // e.g. lineHash['Hello\\n'] == 4\n\n  // '\\x00' is a valid character, but various debuggers don't like it.\n  // So we'll insert a junk entry to avoid generating a null character.\n  lineArray[0] = '';\n\n  /**\n   * Split a text into an array of strings.  Reduce the texts to a string of\n   * hashes where each Unicode character represents one line.\n   * Modifies linearray and linehash through being a closure.\n   * @param {string} text String to encode.\n   * @return {string} Encoded string.\n   * @private\n   */\n  function diff_linesToCharsMunge_(text) {\n    var chars = '';\n    // Walk the text, pulling out a substring for each line.\n    // text.split('\\n') would would temporarily double our memory footprint.\n    // Modifying text would create many large strings to garbage collect.\n    var lineStart = 0;\n    var lineEnd = -1;\n    // Keeping our own length variable is faster than looking it up.\n    var lineArrayLength = lineArray.length;\n    while (lineEnd < text.length - 1) {\n      lineEnd = text.indexOf('\\n', lineStart);\n      if (lineEnd == -1) {\n        lineEnd = text.length - 1;\n      }\n      var line = text.substring(lineStart, lineEnd + 1);\n\n      if (lineHash.hasOwnProperty ? lineHash.hasOwnProperty(line) :\n          (lineHash[line] !== undefined)) {\n        chars += String.fromCharCode(lineHash[line]);\n      } else {\n        if (lineArrayLength == maxLines) {\n          // Bail out at 65535 because\n          // String.fromCharCode(65536) == String.fromCharCode(0)\n          line = text.substring(lineStart);\n          lineEnd = text.length;\n        }\n        chars += String.fromCharCode(lineArrayLength);\n        lineHash[line] = lineArrayLength;\n        lineArray[lineArrayLength++] = line;\n      }\n      lineStart = lineEnd + 1;\n    }\n    return chars;\n  }\n  // Allocate 2/3rds of the space for text1, the rest for text2.\n  var maxLines = 40000;\n  var chars1 = diff_linesToCharsMunge_(text1);\n  maxLines = 65535;\n  var chars2 = diff_linesToCharsMunge_(text2);\n  return {chars1: chars1, chars2: chars2, lineArray: lineArray};\n};\n\n\n/**\n * Rehydrate the text in a diff from a string of line hashes to real lines of\n * text.\n * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.\n * @param {!Array.<string>} lineArray Array of unique strings.\n * @private\n */\ndiff_match_patch.prototype.diff_charsToLines_ = function(diffs, lineArray) {\n  for (var i = 0; i < diffs.length; i++) {\n    var chars = diffs[i][1];\n    var text = [];\n    for (var j = 0; j < chars.length; j++) {\n      text[j] = lineArray[chars.charCodeAt(j)];\n    }\n    diffs[i][1] = text.join('');\n  }\n};\n\n\n/**\n * Determine the common prefix of two strings.\n * @param {string} text1 First string.\n * @param {string} text2 Second string.\n * @return {number} The number of characters common to the start of each\n *     string.\n */\ndiff_match_patch.prototype.diff_commonPrefix = function(text1, text2) {\n  // Quick check for common null cases.\n  if (!text1 || !text2 || text1.charAt(0) != text2.charAt(0)) {\n    return 0;\n  }\n  // Binary search.\n  // Performance analysis: https://neil.fraser.name/news/2007/10/09/\n  var pointermin = 0;\n  var pointermax = Math.min(text1.length, text2.length);\n  var pointermid = pointermax;\n  var pointerstart = 0;\n  while (pointermin < pointermid) {\n    if (text1.substring(pointerstart, pointermid) ==\n        text2.substring(pointerstart, pointermid)) {\n      pointermin = pointermid;\n      pointerstart = pointermin;\n    } else {\n      pointermax = pointermid;\n    }\n    pointermid = Math.floor((pointermax - pointermin) / 2 + pointermin);\n  }\n  return pointermid;\n};\n\n\n/**\n * Determine the common suffix of two strings.\n * @param {string} text1 First string.\n * @param {string} text2 Second string.\n * @return {number} The number of characters common to the end of each string.\n */\ndiff_match_patch.prototype.diff_commonSuffix = function(text1, text2) {\n  // Quick check for common null cases.\n  if (!text1 || !text2 ||\n      text1.charAt(text1.length - 1) != text2.charAt(text2.length - 1)) {\n    return 0;\n  }\n  // Binary search.\n  // Performance analysis: https://neil.fraser.name/news/2007/10/09/\n  var pointermin = 0;\n  var pointermax = Math.min(text1.length, text2.length);\n  var pointermid = pointermax;\n  var pointerend = 0;\n  while (pointermin < pointermid) {\n    if (text1.substring(text1.length - pointermid, text1.length - pointerend) ==\n        text2.substring(text2.length - pointermid, text2.length - pointerend)) {\n      pointermin = pointermid;\n      pointerend = pointermin;\n    } else {\n      pointermax = pointermid;\n    }\n    pointermid = Math.floor((pointermax - pointermin) / 2 + pointermin);\n  }\n  return pointermid;\n};\n\n\n/**\n * Determine if the suffix of one string is the prefix of another.\n * @param {string} text1 First string.\n * @param {string} text2 Second string.\n * @return {number} The number of characters common to the end of the first\n *     string and the start of the second string.\n * @private\n */\ndiff_match_patch.prototype.diff_commonOverlap_ = function(text1, text2) {\n  // Cache the text lengths to prevent multiple calls.\n  var text1_length = text1.length;\n  var text2_length = text2.length;\n  // Eliminate the null case.\n  if (text1_length == 0 || text2_length == 0) {\n    return 0;\n  }\n  // Truncate the longer string.\n  if (text1_length > text2_length) {\n    text1 = text1.substring(text1_length - text2_length);\n  } else if (text1_length < text2_length) {\n    text2 = text2.substring(0, text1_length);\n  }\n  var text_length = Math.min(text1_length, text2_length);\n  // Quick check for the worst case.\n  if (text1 == text2) {\n    return text_length;\n  }\n\n  // Start by looking for a single character match\n  // and increase length until no match is found.\n  // Performance analysis: https://neil.fraser.name/news/2010/11/04/\n  var best = 0;\n  var length = 1;\n  while (true) {\n    var pattern = text1.substring(text_length - length);\n    var found = text2.indexOf(pattern);\n    if (found == -1) {\n      return best;\n    }\n    length += found;\n    if (found == 0 || text1.substring(text_length - length) ==\n        text2.substring(0, length)) {\n      best = length;\n      length++;\n    }\n  }\n};\n\n\n/**\n * Do the two texts share a substring which is at least half the length of the\n * longer text?\n * This speedup can produce non-minimal diffs.\n * @param {string} text1 First string.\n * @param {string} text2 Second string.\n * @return {Array.<string>} Five element Array, containing the prefix of\n *     text1, the suffix of text1, the prefix of text2, the suffix of\n *     text2 and the common middle.  Or null if there was no match.\n * @private\n */\ndiff_match_patch.prototype.diff_halfMatch_ = function(text1, text2) {\n  if (this.Diff_Timeout <= 0) {\n    // Don't risk returning a non-optimal diff if we have unlimited time.\n    return null;\n  }\n  var longtext = text1.length > text2.length ? text1 : text2;\n  var shorttext = text1.length > text2.length ? text2 : text1;\n  if (longtext.length < 4 || shorttext.length * 2 < longtext.length) {\n    return null;  // Pointless.\n  }\n  var dmp = this;  // 'this' becomes 'window' in a closure.\n\n  /**\n   * Does a substring of shorttext exist within longtext such that the substring\n   * is at least half the length of longtext?\n   * Closure, but does not reference any external variables.\n   * @param {string} longtext Longer string.\n   * @param {string} shorttext Shorter string.\n   * @param {number} i Start index of quarter length substring within longtext.\n   * @return {Array.<string>} Five element Array, containing the prefix of\n   *     longtext, the suffix of longtext, the prefix of shorttext, the suffix\n   *     of shorttext and the common middle.  Or null if there was no match.\n   * @private\n   */\n  function diff_halfMatchI_(longtext, shorttext, i) {\n    // Start with a 1/4 length substring at position i as a seed.\n    var seed = longtext.substring(i, i + Math.floor(longtext.length / 4));\n    var j = -1;\n    var best_common = '';\n    var best_longtext_a, best_longtext_b, best_shorttext_a, best_shorttext_b;\n    while ((j = shorttext.indexOf(seed, j + 1)) != -1) {\n      var prefixLength = dmp.diff_commonPrefix(longtext.substring(i),\n                                               shorttext.substring(j));\n      var suffixLength = dmp.diff_commonSuffix(longtext.substring(0, i),\n                                               shorttext.substring(0, j));\n      if (best_common.length < suffixLength + prefixLength) {\n        best_common = shorttext.substring(j - suffixLength, j) +\n            shorttext.substring(j, j + prefixLength);\n        best_longtext_a = longtext.substring(0, i - suffixLength);\n        best_longtext_b = longtext.substring(i + prefixLength);\n        best_shorttext_a = shorttext.substring(0, j - suffixLength);\n        best_shorttext_b = shorttext.substring(j + prefixLength);\n      }\n    }\n    if (best_common.length * 2 >= longtext.length) {\n      return [best_longtext_a, best_longtext_b,\n              best_shorttext_a, best_shorttext_b, best_common];\n    } else {\n      return null;\n    }\n  }\n\n  // First check if the second quarter is the seed for a half-match.\n  var hm1 = diff_halfMatchI_(longtext, shorttext,\n                             Math.ceil(longtext.length / 4));\n  // Check again based on the third quarter.\n  var hm2 = diff_halfMatchI_(longtext, shorttext,\n                             Math.ceil(longtext.length / 2));\n  var hm;\n  if (!hm1 && !hm2) {\n    return null;\n  } else if (!hm2) {\n    hm = hm1;\n  } else if (!hm1) {\n    hm = hm2;\n  } else {\n    // Both matched.  Select the longest.\n    hm = hm1[4].length > hm2[4].length ? hm1 : hm2;\n  }\n\n  // A half-match was found, sort out the return data.\n  var text1_a, text1_b, text2_a, text2_b;\n  if (text1.length > text2.length) {\n    text1_a = hm[0];\n    text1_b = hm[1];\n    text2_a = hm[2];\n    text2_b = hm[3];\n  } else {\n    text2_a = hm[0];\n    text2_b = hm[1];\n    text1_a = hm[2];\n    text1_b = hm[3];\n  }\n  var mid_common = hm[4];\n  return [text1_a, text1_b, text2_a, text2_b, mid_common];\n};\n\n\n/**\n * Reduce the number of edits by eliminating semantically trivial equalities.\n * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.\n */\ndiff_match_patch.prototype.diff_cleanupSemantic = function(diffs) {\n  var changes = false;\n  var equalities = [];  // Stack of indices where equalities are found.\n  var equalitiesLength = 0;  // Keeping our own length var is faster in JS.\n  /** @type {?string} */\n  var lastEquality = null;\n  // Always equal to diffs[equalities[equalitiesLength - 1]][1]\n  var pointer = 0;  // Index of current position.\n  // Number of characters that changed prior to the equality.\n  var length_insertions1 = 0;\n  var length_deletions1 = 0;\n  // Number of characters that changed after the equality.\n  var length_insertions2 = 0;\n  var length_deletions2 = 0;\n  while (pointer < diffs.length) {\n    if (diffs[pointer][0] == DIFF_EQUAL) {  // Equality found.\n      equalities[equalitiesLength++] = pointer;\n      length_insertions1 = length_insertions2;\n      length_deletions1 = length_deletions2;\n      length_insertions2 = 0;\n      length_deletions2 = 0;\n      lastEquality = diffs[pointer][1];\n    } else {  // An insertion or deletion.\n      if (diffs[pointer][0] == DIFF_INSERT) {\n        length_insertions2 += diffs[pointer][1].length;\n      } else {\n        length_deletions2 += diffs[pointer][1].length;\n      }\n      // Eliminate an equality that is smaller or equal to the edits on both\n      // sides of it.\n      if (lastEquality && (lastEquality.length <=\n          Math.max(length_insertions1, length_deletions1)) &&\n          (lastEquality.length <= Math.max(length_insertions2,\n                                           length_deletions2))) {\n        // Duplicate record.\n        diffs.splice(equalities[equalitiesLength - 1], 0,\n                     new diff_match_patch.Diff(DIFF_DELETE, lastEquality));\n        // Change second copy to insert.\n        diffs[equalities[equalitiesLength - 1] + 1][0] = DIFF_INSERT;\n        // Throw away the equality we just deleted.\n        equalitiesLength--;\n        // Throw away the previous equality (it needs to be reevaluated).\n        equalitiesLength--;\n        pointer = equalitiesLength > 0 ? equalities[equalitiesLength - 1] : -1;\n        length_insertions1 = 0;  // Reset the counters.\n        length_deletions1 = 0;\n        length_insertions2 = 0;\n        length_deletions2 = 0;\n        lastEquality = null;\n        changes = true;\n      }\n    }\n    pointer++;\n  }\n\n  // Normalize the diff.\n  if (changes) {\n    this.diff_cleanupMerge(diffs);\n  }\n  this.diff_cleanupSemanticLossless(diffs);\n\n  // Find any overlaps between deletions and insertions.\n  // e.g: <del>abcxxx</del><ins>xxxdef</ins>\n  //   -> <del>abc</del>xxx<ins>def</ins>\n  // e.g: <del>xxxabc</del><ins>defxxx</ins>\n  //   -> <ins>def</ins>xxx<del>abc</del>\n  // Only extract an overlap if it is as big as the edit ahead or behind it.\n  pointer = 1;\n  while (pointer < diffs.length) {\n    if (diffs[pointer - 1][0] == DIFF_DELETE &&\n        diffs[pointer][0] == DIFF_INSERT) {\n      var deletion = diffs[pointer - 1][1];\n      var insertion = diffs[pointer][1];\n      var overlap_length1 = this.diff_commonOverlap_(deletion, insertion);\n      var overlap_length2 = this.diff_commonOverlap_(insertion, deletion);\n      if (overlap_length1 >= overlap_length2) {\n        if (overlap_length1 >= deletion.length / 2 ||\n            overlap_length1 >= insertion.length / 2) {\n          // Overlap found.  Insert an equality and trim the surrounding edits.\n          diffs.splice(pointer, 0, new diff_match_patch.Diff(DIFF_EQUAL,\n              insertion.substring(0, overlap_length1)));\n          diffs[pointer - 1][1] =\n              deletion.substring(0, deletion.length - overlap_length1);\n          diffs[pointer + 1][1] = insertion.substring(overlap_length1);\n          pointer++;\n        }\n      } else {\n        if (overlap_length2 >= deletion.length / 2 ||\n            overlap_length2 >= insertion.length / 2) {\n          // Reverse overlap found.\n          // Insert an equality and swap and trim the surrounding edits.\n          diffs.splice(pointer, 0, new diff_match_patch.Diff(DIFF_EQUAL,\n              deletion.substring(0, overlap_length2)));\n          diffs[pointer - 1][0] = DIFF_INSERT;\n          diffs[pointer - 1][1] =\n              insertion.substring(0, insertion.length - overlap_length2);\n          diffs[pointer + 1][0] = DIFF_DELETE;\n          diffs[pointer + 1][1] =\n              deletion.substring(overlap_length2);\n          pointer++;\n        }\n      }\n      pointer++;\n    }\n    pointer++;\n  }\n};\n\n\n/**\n * Look for single edits surrounded on both sides by equalities\n * which can be shifted sideways to align the edit to a word boundary.\n * e.g: The c<ins>at c</ins>ame. -> The <ins>cat </ins>came.\n * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.\n */\ndiff_match_patch.prototype.diff_cleanupSemanticLossless = function(diffs) {\n  /**\n   * Given two strings, compute a score representing whether the internal\n   * boundary falls on logical boundaries.\n   * Scores range from 6 (best) to 0 (worst).\n   * Closure, but does not reference any external variables.\n   * @param {string} one First string.\n   * @param {string} two Second string.\n   * @return {number} The score.\n   * @private\n   */\n  function diff_cleanupSemanticScore_(one, two) {\n    if (!one || !two) {\n      // Edges are the best.\n      return 6;\n    }\n\n    // Each port of this function behaves slightly differently due to\n    // subtle differences in each language's definition of things like\n    // 'whitespace'.  Since this function's purpose is largely cosmetic,\n    // the choice has been made to use each language's native features\n    // rather than force total conformity.\n    var char1 = one.charAt(one.length - 1);\n    var char2 = two.charAt(0);\n    var nonAlphaNumeric1 = char1.match(diff_match_patch.nonAlphaNumericRegex_);\n    var nonAlphaNumeric2 = char2.match(diff_match_patch.nonAlphaNumericRegex_);\n    var whitespace1 = nonAlphaNumeric1 &&\n        char1.match(diff_match_patch.whitespaceRegex_);\n    var whitespace2 = nonAlphaNumeric2 &&\n        char2.match(diff_match_patch.whitespaceRegex_);\n    var lineBreak1 = whitespace1 &&\n        char1.match(diff_match_patch.linebreakRegex_);\n    var lineBreak2 = whitespace2 &&\n        char2.match(diff_match_patch.linebreakRegex_);\n    var blankLine1 = lineBreak1 &&\n        one.match(diff_match_patch.blanklineEndRegex_);\n    var blankLine2 = lineBreak2 &&\n        two.match(diff_match_patch.blanklineStartRegex_);\n\n    if (blankLine1 || blankLine2) {\n      // Five points for blank lines.\n      return 5;\n    } else if (lineBreak1 || lineBreak2) {\n      // Four points for line breaks.\n      return 4;\n    } else if (nonAlphaNumeric1 && !whitespace1 && whitespace2) {\n      // Three points for end of sentences.\n      return 3;\n    } else if (whitespace1 || whitespace2) {\n      // Two points for whitespace.\n      return 2;\n    } else if (nonAlphaNumeric1 || nonAlphaNumeric2) {\n      // One point for non-alphanumeric.\n      return 1;\n    }\n    return 0;\n  }\n\n  var pointer = 1;\n  // Intentionally ignore the first and last element (don't need checking).\n  while (pointer < diffs.length - 1) {\n    if (diffs[pointer - 1][0] == DIFF_EQUAL &&\n        diffs[pointer + 1][0] == DIFF_EQUAL) {\n      // This is a single edit surrounded by equalities.\n      var equality1 = diffs[pointer - 1][1];\n      var edit = diffs[pointer][1];\n      var equality2 = diffs[pointer + 1][1];\n\n      // First, shift the edit as far left as possible.\n      var commonOffset = this.diff_commonSuffix(equality1, edit);\n      if (commonOffset) {\n        var commonString = edit.substring(edit.length - commonOffset);\n        equality1 = equality1.substring(0, equality1.length - commonOffset);\n        edit = commonString + edit.substring(0, edit.length - commonOffset);\n        equality2 = commonString + equality2;\n      }\n\n      // Second, step character by character right, looking for the best fit.\n      var bestEquality1 = equality1;\n      var bestEdit = edit;\n      var bestEquality2 = equality2;\n      var bestScore = diff_cleanupSemanticScore_(equality1, edit) +\n          diff_cleanupSemanticScore_(edit, equality2);\n      while (edit.charAt(0) === equality2.charAt(0)) {\n        equality1 += edit.charAt(0);\n        edit = edit.substring(1) + equality2.charAt(0);\n        equality2 = equality2.substring(1);\n        var score = diff_cleanupSemanticScore_(equality1, edit) +\n            diff_cleanupSemanticScore_(edit, equality2);\n        // The >= encourages trailing rather than leading whitespace on edits.\n        if (score >= bestScore) {\n          bestScore = score;\n          bestEquality1 = equality1;\n          bestEdit = edit;\n          bestEquality2 = equality2;\n        }\n      }\n\n      if (diffs[pointer - 1][1] != bestEquality1) {\n        // We have an improvement, save it back to the diff.\n        if (bestEquality1) {\n          diffs[pointer - 1][1] = bestEquality1;\n        } else {\n          diffs.splice(pointer - 1, 1);\n          pointer--;\n        }\n        diffs[pointer][1] = bestEdit;\n        if (bestEquality2) {\n          diffs[pointer + 1][1] = bestEquality2;\n        } else {\n          diffs.splice(pointer + 1, 1);\n          pointer--;\n        }\n      }\n    }\n    pointer++;\n  }\n};\n\n// Define some regex patterns for matching boundaries.\ndiff_match_patch.nonAlphaNumericRegex_ = /[^a-zA-Z0-9]/;\ndiff_match_patch.whitespaceRegex_ = /\\s/;\ndiff_match_patch.linebreakRegex_ = /[\\r\\n]/;\ndiff_match_patch.blanklineEndRegex_ = /\\n\\r?\\n$/;\ndiff_match_patch.blanklineStartRegex_ = /^\\r?\\n\\r?\\n/;\n\n/**\n * Reduce the number of edits by eliminating operationally trivial equalities.\n * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.\n */\ndiff_match_patch.prototype.diff_cleanupEfficiency = function(diffs) {\n  var changes = false;\n  var equalities = [];  // Stack of indices where equalities are found.\n  var equalitiesLength = 0;  // Keeping our own length var is faster in JS.\n  /** @type {?string} */\n  var lastEquality = null;\n  // Always equal to diffs[equalities[equalitiesLength - 1]][1]\n  var pointer = 0;  // Index of current position.\n  // Is there an insertion operation before the last equality.\n  var pre_ins = false;\n  // Is there a deletion operation before the last equality.\n  var pre_del = false;\n  // Is there an insertion operation after the last equality.\n  var post_ins = false;\n  // Is there a deletion operation after the last equality.\n  var post_del = false;\n  while (pointer < diffs.length) {\n    if (diffs[pointer][0] == DIFF_EQUAL) {  // Equality found.\n      if (diffs[pointer][1].length < this.Diff_EditCost &&\n          (post_ins || post_del)) {\n        // Candidate found.\n        equalities[equalitiesLength++] = pointer;\n        pre_ins = post_ins;\n        pre_del = post_del;\n        lastEquality = diffs[pointer][1];\n      } else {\n        // Not a candidate, and can never become one.\n        equalitiesLength = 0;\n        lastEquality = null;\n      }\n      post_ins = post_del = false;\n    } else {  // An insertion or deletion.\n      if (diffs[pointer][0] == DIFF_DELETE) {\n        post_del = true;\n      } else {\n        post_ins = true;\n      }\n      /*\n       * Five types to be split:\n       * <ins>A</ins><del>B</del>XY<ins>C</ins><del>D</del>\n       * <ins>A</ins>X<ins>C</ins><del>D</del>\n       * <ins>A</ins><del>B</del>X<ins>C</ins>\n       * <ins>A</del>X<ins>C</ins><del>D</del>\n       * <ins>A</ins><del>B</del>X<del>C</del>\n       */\n      if (lastEquality && ((pre_ins && pre_del && post_ins && post_del) ||\n                           ((lastEquality.length < this.Diff_EditCost / 2) &&\n                            (pre_ins + pre_del + post_ins + post_del) == 3))) {\n        // Duplicate record.\n        diffs.splice(equalities[equalitiesLength - 1], 0,\n                     new diff_match_patch.Diff(DIFF_DELETE, lastEquality));\n        // Change second copy to insert.\n        diffs[equalities[equalitiesLength - 1] + 1][0] = DIFF_INSERT;\n        equalitiesLength--;  // Throw away the equality we just deleted;\n        lastEquality = null;\n        if (pre_ins && pre_del) {\n          // No changes made which could affect previous entry, keep going.\n          post_ins = post_del = true;\n          equalitiesLength = 0;\n        } else {\n          equalitiesLength--;  // Throw away the previous equality.\n          pointer = equalitiesLength > 0 ?\n              equalities[equalitiesLength - 1] : -1;\n          post_ins = post_del = false;\n        }\n        changes = true;\n      }\n    }\n    pointer++;\n  }\n\n  if (changes) {\n    this.diff_cleanupMerge(diffs);\n  }\n};\n\n\n/**\n * Reorder and merge like edit sections.  Merge equalities.\n * Any edit section can move as long as it doesn't cross an equality.\n * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.\n */\ndiff_match_patch.prototype.diff_cleanupMerge = function(diffs) {\n  // Add a dummy entry at the end.\n  diffs.push(new diff_match_patch.Diff(DIFF_EQUAL, ''));\n  var pointer = 0;\n  var count_delete = 0;\n  var count_insert = 0;\n  var text_delete = '';\n  var text_insert = '';\n  var commonlength;\n  while (pointer < diffs.length) {\n    switch (diffs[pointer][0]) {\n      case DIFF_INSERT:\n        count_insert++;\n        text_insert += diffs[pointer][1];\n        pointer++;\n        break;\n      case DIFF_DELETE:\n        count_delete++;\n        text_delete += diffs[pointer][1];\n        pointer++;\n        break;\n      case DIFF_EQUAL:\n        // Upon reaching an equality, check for prior redundancies.\n        if (count_delete + count_insert > 1) {\n          if (count_delete !== 0 && count_insert !== 0) {\n            // Factor out any common prefixies.\n            commonlength = this.diff_commonPrefix(text_insert, text_delete);\n            if (commonlength !== 0) {\n              if ((pointer - count_delete - count_insert) > 0 &&\n                  diffs[pointer - count_delete - count_insert - 1][0] ==\n                  DIFF_EQUAL) {\n                diffs[pointer - count_delete - count_insert - 1][1] +=\n                    text_insert.substring(0, commonlength);\n              } else {\n                diffs.splice(0, 0, new diff_match_patch.Diff(DIFF_EQUAL,\n                    text_insert.substring(0, commonlength)));\n                pointer++;\n              }\n              text_insert = text_insert.substring(commonlength);\n              text_delete = text_delete.substring(commonlength);\n            }\n            // Factor out any common suffixies.\n            commonlength = this.diff_commonSuffix(text_insert, text_delete);\n            if (commonlength !== 0) {\n              diffs[pointer][1] = text_insert.substring(text_insert.length -\n                  commonlength) + diffs[pointer][1];\n              text_insert = text_insert.substring(0, text_insert.length -\n                  commonlength);\n              text_delete = text_delete.substring(0, text_delete.length -\n                  commonlength);\n            }\n          }\n          // Delete the offending records and add the merged ones.\n          pointer -= count_delete + count_insert;\n          diffs.splice(pointer, count_delete + count_insert);\n          if (text_delete.length) {\n            diffs.splice(pointer, 0,\n                new diff_match_patch.Diff(DIFF_DELETE, text_delete));\n            pointer++;\n          }\n          if (text_insert.length) {\n            diffs.splice(pointer, 0,\n                new diff_match_patch.Diff(DIFF_INSERT, text_insert));\n            pointer++;\n          }\n          pointer++;\n        } else if (pointer !== 0 && diffs[pointer - 1][0] == DIFF_EQUAL) {\n          // Merge this equality with the previous one.\n          diffs[pointer - 1][1] += diffs[pointer][1];\n          diffs.splice(pointer, 1);\n        } else {\n          pointer++;\n        }\n        count_insert = 0;\n        count_delete = 0;\n        text_delete = '';\n        text_insert = '';\n        break;\n    }\n  }\n  if (diffs[diffs.length - 1][1] === '') {\n    diffs.pop();  // Remove the dummy entry at the end.\n  }\n\n  // Second pass: look for single edits surrounded on both sides by equalities\n  // which can be shifted sideways to eliminate an equality.\n  // e.g: A<ins>BA</ins>C -> <ins>AB</ins>AC\n  var changes = false;\n  pointer = 1;\n  // Intentionally ignore the first and last element (don't need checking).\n  while (pointer < diffs.length - 1) {\n    if (diffs[pointer - 1][0] == DIFF_EQUAL &&\n        diffs[pointer + 1][0] == DIFF_EQUAL) {\n      // This is a single edit surrounded by equalities.\n      if (diffs[pointer][1].substring(diffs[pointer][1].length -\n          diffs[pointer - 1][1].length) == diffs[pointer - 1][1]) {\n        // Shift the edit over the previous equality.\n        diffs[pointer][1] = diffs[pointer - 1][1] +\n            diffs[pointer][1].substring(0, diffs[pointer][1].length -\n                                        diffs[pointer - 1][1].length);\n        diffs[pointer + 1][1] = diffs[pointer - 1][1] + diffs[pointer + 1][1];\n        diffs.splice(pointer - 1, 1);\n        changes = true;\n      } else if (diffs[pointer][1].substring(0, diffs[pointer + 1][1].length) ==\n          diffs[pointer + 1][1]) {\n        // Shift the edit over the next equality.\n        diffs[pointer - 1][1] += diffs[pointer + 1][1];\n        diffs[pointer][1] =\n            diffs[pointer][1].substring(diffs[pointer + 1][1].length) +\n            diffs[pointer + 1][1];\n        diffs.splice(pointer + 1, 1);\n        changes = true;\n      }\n    }\n    pointer++;\n  }\n  // If shifts were made, the diff needs reordering and another shift sweep.\n  if (changes) {\n    this.diff_cleanupMerge(diffs);\n  }\n};\n\n\n/**\n * loc is a location in text1, compute and return the equivalent location in\n * text2.\n * e.g. 'The cat' vs 'The big cat', 1->1, 5->8\n * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.\n * @param {number} loc Location within text1.\n * @return {number} Location within text2.\n */\ndiff_match_patch.prototype.diff_xIndex = function(diffs, loc) {\n  var chars1 = 0;\n  var chars2 = 0;\n  var last_chars1 = 0;\n  var last_chars2 = 0;\n  var x;\n  for (x = 0; x < diffs.length; x++) {\n    if (diffs[x][0] !== DIFF_INSERT) {  // Equality or deletion.\n      chars1 += diffs[x][1].length;\n    }\n    if (diffs[x][0] !== DIFF_DELETE) {  // Equality or insertion.\n      chars2 += diffs[x][1].length;\n    }\n    if (chars1 > loc) {  // Overshot the location.\n      break;\n    }\n    last_chars1 = chars1;\n    last_chars2 = chars2;\n  }\n  // Was the location was deleted?\n  if (diffs.length != x && diffs[x][0] === DIFF_DELETE) {\n    return last_chars2;\n  }\n  // Add the remaining character length.\n  return last_chars2 + (loc - last_chars1);\n};\n\n\n/**\n * Convert a diff array into a pretty HTML report.\n * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.\n * @return {string} HTML representation.\n */\ndiff_match_patch.prototype.diff_prettyHtml = function(diffs) {\n  var html = [];\n  var pattern_amp = /&/g;\n  var pattern_lt = /</g;\n  var pattern_gt = />/g;\n  var pattern_para = /\\n/g;\n  for (var x = 0; x < diffs.length; x++) {\n    var op = diffs[x][0];    // Operation (insert, delete, equal)\n    var data = diffs[x][1];  // Text of change.\n    var text = data.replace(pattern_amp, '&amp;').replace(pattern_lt, '&lt;')\n        .replace(pattern_gt, '&gt;').replace(pattern_para, '&para;<br>');\n    switch (op) {\n      case DIFF_INSERT:\n        html[x] = '<ins style=\"background:#e6ffe6;\">' + text + '</ins>';\n        break;\n      case DIFF_DELETE:\n        html[x] = '<del style=\"background:#ffe6e6;\">' + text + '</del>';\n        break;\n      case DIFF_EQUAL:\n        html[x] = '<span>' + text + '</span>';\n        break;\n    }\n  }\n  return html.join('');\n};\n\n\n/**\n * Compute and return the source text (all equalities and deletions).\n * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.\n * @return {string} Source text.\n */\ndiff_match_patch.prototype.diff_text1 = function(diffs) {\n  var text = [];\n  for (var x = 0; x < diffs.length; x++) {\n    if (diffs[x][0] !== DIFF_INSERT) {\n      text[x] = diffs[x][1];\n    }\n  }\n  return text.join('');\n};\n\n\n/**\n * Compute and return the destination text (all equalities and insertions).\n * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.\n * @return {string} Destination text.\n */\ndiff_match_patch.prototype.diff_text2 = function(diffs) {\n  var text = [];\n  for (var x = 0; x < diffs.length; x++) {\n    if (diffs[x][0] !== DIFF_DELETE) {\n      text[x] = diffs[x][1];\n    }\n  }\n  return text.join('');\n};\n\n\n/**\n * Compute the Levenshtein distance; the number of inserted, deleted or\n * substituted characters.\n * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.\n * @return {number} Number of changes.\n */\ndiff_match_patch.prototype.diff_levenshtein = function(diffs) {\n  var levenshtein = 0;\n  var insertions = 0;\n  var deletions = 0;\n  for (var x = 0; x < diffs.length; x++) {\n    var op = diffs[x][0];\n    var data = diffs[x][1];\n    switch (op) {\n      case DIFF_INSERT:\n        insertions += data.length;\n        break;\n      case DIFF_DELETE:\n        deletions += data.length;\n        break;\n      case DIFF_EQUAL:\n        // A deletion and an insertion is one substitution.\n        levenshtein += Math.max(insertions, deletions);\n        insertions = 0;\n        deletions = 0;\n        break;\n    }\n  }\n  levenshtein += Math.max(insertions, deletions);\n  return levenshtein;\n};\n\n\n/**\n * Crush the diff into an encoded string which describes the operations\n * required to transform text1 into text2.\n * E.g. =3\\t-2\\t+ing  -> Keep 3 chars, delete 2 chars, insert 'ing'.\n * Operations are tab-separated.  Inserted text is escaped using %xx notation.\n * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.\n * @return {string} Delta text.\n */\ndiff_match_patch.prototype.diff_toDelta = function(diffs) {\n  var text = [];\n  for (var x = 0; x < diffs.length; x++) {\n    switch (diffs[x][0]) {\n      case DIFF_INSERT:\n        text[x] = '+' + encodeURI(diffs[x][1]);\n        break;\n      case DIFF_DELETE:\n        text[x] = '-' + diffs[x][1].length;\n        break;\n      case DIFF_EQUAL:\n        text[x] = '=' + diffs[x][1].length;\n        break;\n    }\n  }\n  return text.join('\\t').replace(/%20/g, ' ');\n};\n\n\n/**\n * Given the original text1, and an encoded string which describes the\n * operations required to transform text1 into text2, compute the full diff.\n * @param {string} text1 Source string for the diff.\n * @param {string} delta Delta text.\n * @return {!Array.<!diff_match_patch.Diff>} Array of diff tuples.\n * @throws {!Error} If invalid input.\n */\ndiff_match_patch.prototype.diff_fromDelta = function(text1, delta) {\n  var diffs = [];\n  var diffsLength = 0;  // Keeping our own length var is faster in JS.\n  var pointer = 0;  // Cursor in text1\n  var tokens = delta.split(/\\t/g);\n  for (var x = 0; x < tokens.length; x++) {\n    // Each token begins with a one character parameter which specifies the\n    // operation of this token (delete, insert, equality).\n    var param = tokens[x].substring(1);\n    switch (tokens[x].charAt(0)) {\n      case '+':\n        try {\n          diffs[diffsLength++] =\n              new diff_match_patch.Diff(DIFF_INSERT, decodeURI(param));\n        } catch (ex) {\n          // Malformed URI sequence.\n          throw new Error('Illegal escape in diff_fromDelta: ' + param);\n        }\n        break;\n      case '-':\n        // Fall through.\n      case '=':\n        var n = parseInt(param, 10);\n        if (isNaN(n) || n < 0) {\n          throw new Error('Invalid number in diff_fromDelta: ' + param);\n        }\n        var text = text1.substring(pointer, pointer += n);\n        if (tokens[x].charAt(0) == '=') {\n          diffs[diffsLength++] = new diff_match_patch.Diff(DIFF_EQUAL, text);\n        } else {\n          diffs[diffsLength++] = new diff_match_patch.Diff(DIFF_DELETE, text);\n        }\n        break;\n      default:\n        // Blank tokens are ok (from a trailing \\t).\n        // Anything else is an error.\n        if (tokens[x]) {\n          throw new Error('Invalid diff operation in diff_fromDelta: ' +\n                          tokens[x]);\n        }\n    }\n  }\n  if (pointer != text1.length) {\n    throw new Error('Delta length (' + pointer +\n        ') does not equal source text length (' + text1.length + ').');\n  }\n  return diffs;\n};\n\n\n//  MATCH FUNCTIONS\n\n\n/**\n * Locate the best instance of 'pattern' in 'text' near 'loc'.\n * @param {string} text The text to search.\n * @param {string} pattern The pattern to search for.\n * @param {number} loc The location to search around.\n * @return {number} Best match index or -1.\n */\ndiff_match_patch.prototype.match_main = function(text, pattern, loc) {\n  // Check for null inputs.\n  if (text == null || pattern == null || loc == null) {\n    throw new Error('Null input. (match_main)');\n  }\n\n  loc = Math.max(0, Math.min(loc, text.length));\n  if (text == pattern) {\n    // Shortcut (potentially not guaranteed by the algorithm)\n    return 0;\n  } else if (!text.length) {\n    // Nothing to match.\n    return -1;\n  } else if (text.substring(loc, loc + pattern.length) == pattern) {\n    // Perfect match at the perfect spot!  (Includes case of null pattern)\n    return loc;\n  } else {\n    // Do a fuzzy compare.\n    return this.match_bitap_(text, pattern, loc);\n  }\n};\n\n\n/**\n * Locate the best instance of 'pattern' in 'text' near 'loc' using the\n * Bitap algorithm.\n * @param {string} text The text to search.\n * @param {string} pattern The pattern to search for.\n * @param {number} loc The location to search around.\n * @return {number} Best match index or -1.\n * @private\n */\ndiff_match_patch.prototype.match_bitap_ = function(text, pattern, loc) {\n  if (pattern.length > this.Match_MaxBits) {\n    throw new Error('Pattern too long for this browser.');\n  }\n\n  // Initialise the alphabet.\n  var s = this.match_alphabet_(pattern);\n\n  var dmp = this;  // 'this' becomes 'window' in a closure.\n\n  /**\n   * Compute and return the score for a match with e errors and x location.\n   * Accesses loc and pattern through being a closure.\n   * @param {number} e Number of errors in match.\n   * @param {number} x Location of match.\n   * @return {number} Overall score for match (0.0 = good, 1.0 = bad).\n   * @private\n   */\n  function match_bitapScore_(e, x) {\n    var accuracy = e / pattern.length;\n    var proximity = Math.abs(loc - x);\n    if (!dmp.Match_Distance) {\n      // Dodge divide by zero error.\n      return proximity ? 1.0 : accuracy;\n    }\n    return accuracy + (proximity / dmp.Match_Distance);\n  }\n\n  // Highest score beyond which we give up.\n  var score_threshold = this.Match_Threshold;\n  // Is there a nearby exact match? (speedup)\n  var best_loc = text.indexOf(pattern, loc);\n  if (best_loc != -1) {\n    score_threshold = Math.min(match_bitapScore_(0, best_loc), score_threshold);\n    // What about in the other direction? (speedup)\n    best_loc = text.lastIndexOf(pattern, loc + pattern.length);\n    if (best_loc != -1) {\n      score_threshold =\n          Math.min(match_bitapScore_(0, best_loc), score_threshold);\n    }\n  }\n\n  // Initialise the bit arrays.\n  var matchmask = 1 << (pattern.length - 1);\n  best_loc = -1;\n\n  var bin_min, bin_mid;\n  var bin_max = pattern.length + text.length;\n  var last_rd;\n  for (var d = 0; d < pattern.length; d++) {\n    // Scan for the best match; each iteration allows for one more error.\n    // Run a binary search to determine how far from 'loc' we can stray at this\n    // error level.\n    bin_min = 0;\n    bin_mid = bin_max;\n    while (bin_min < bin_mid) {\n      if (match_bitapScore_(d, loc + bin_mid) <= score_threshold) {\n        bin_min = bin_mid;\n      } else {\n        bin_max = bin_mid;\n      }\n      bin_mid = Math.floor((bin_max - bin_min) / 2 + bin_min);\n    }\n    // Use the result from this iteration as the maximum for the next.\n    bin_max = bin_mid;\n    var start = Math.max(1, loc - bin_mid + 1);\n    var finish = Math.min(loc + bin_mid, text.length) + pattern.length;\n\n    var rd = Array(finish + 2);\n    rd[finish + 1] = (1 << d) - 1;\n    for (var j = finish; j >= start; j--) {\n      // The alphabet (s) is a sparse hash, so the following line generates\n      // warnings.\n      var charMatch = s[text.charAt(j - 1)];\n      if (d === 0) {  // First pass: exact match.\n        rd[j] = ((rd[j + 1] << 1) | 1) & charMatch;\n      } else {  // Subsequent passes: fuzzy match.\n        rd[j] = (((rd[j + 1] << 1) | 1) & charMatch) |\n                (((last_rd[j + 1] | last_rd[j]) << 1) | 1) |\n                last_rd[j + 1];\n      }\n      if (rd[j] & matchmask) {\n        var score = match_bitapScore_(d, j - 1);\n        // This match will almost certainly be better than any existing match.\n        // But check anyway.\n        if (score <= score_threshold) {\n          // Told you so.\n          score_threshold = score;\n          best_loc = j - 1;\n          if (best_loc > loc) {\n            // When passing loc, don't exceed our current distance from loc.\n            start = Math.max(1, 2 * loc - best_loc);\n          } else {\n            // Already passed loc, downhill from here on in.\n            break;\n          }\n        }\n      }\n    }\n    // No hope for a (better) match at greater error levels.\n    if (match_bitapScore_(d + 1, loc) > score_threshold) {\n      break;\n    }\n    last_rd = rd;\n  }\n  return best_loc;\n};\n\n\n/**\n * Initialise the alphabet for the Bitap algorithm.\n * @param {string} pattern The text to encode.\n * @return {!Object} Hash of character locations.\n * @private\n */\ndiff_match_patch.prototype.match_alphabet_ = function(pattern) {\n  var s = {};\n  for (var i = 0; i < pattern.length; i++) {\n    s[pattern.charAt(i)] = 0;\n  }\n  for (var i = 0; i < pattern.length; i++) {\n    s[pattern.charAt(i)] |= 1 << (pattern.length - i - 1);\n  }\n  return s;\n};\n\n\n//  PATCH FUNCTIONS\n\n\n/**\n * Increase the context until it is unique,\n * but don't let the pattern expand beyond Match_MaxBits.\n * @param {!diff_match_patch.patch_obj} patch The patch to grow.\n * @param {string} text Source text.\n * @private\n */\ndiff_match_patch.prototype.patch_addContext_ = function(patch, text) {\n  if (text.length == 0) {\n    return;\n  }\n  if (patch.start2 === null) {\n    throw Error('patch not initialized');\n  }\n  var pattern = text.substring(patch.start2, patch.start2 + patch.length1);\n  var padding = 0;\n\n  // Look for the first and last matches of pattern in text.  If two different\n  // matches are found, increase the pattern length.\n  while (text.indexOf(pattern) != text.lastIndexOf(pattern) &&\n         pattern.length < this.Match_MaxBits - this.Patch_Margin -\n         this.Patch_Margin) {\n    padding += this.Patch_Margin;\n    pattern = text.substring(patch.start2 - padding,\n                             patch.start2 + patch.length1 + padding);\n  }\n  // Add one chunk for good luck.\n  padding += this.Patch_Margin;\n\n  // Add the prefix.\n  var prefix = text.substring(patch.start2 - padding, patch.start2);\n  if (prefix) {\n    patch.diffs.unshift(new diff_match_patch.Diff(DIFF_EQUAL, prefix));\n  }\n  // Add the suffix.\n  var suffix = text.substring(patch.start2 + patch.length1,\n                              patch.start2 + patch.length1 + padding);\n  if (suffix) {\n    patch.diffs.push(new diff_match_patch.Diff(DIFF_EQUAL, suffix));\n  }\n\n  // Roll back the start points.\n  patch.start1 -= prefix.length;\n  patch.start2 -= prefix.length;\n  // Extend the lengths.\n  patch.length1 += prefix.length + suffix.length;\n  patch.length2 += prefix.length + suffix.length;\n};\n\n\n/**\n * Compute a list of patches to turn text1 into text2.\n * Use diffs if provided, otherwise compute it ourselves.\n * There are four ways to call this function, depending on what data is\n * available to the caller:\n * Method 1:\n * a = text1, b = text2\n * Method 2:\n * a = diffs\n * Method 3 (optimal):\n * a = text1, b = diffs\n * Method 4 (deprecated, use method 3):\n * a = text1, b = text2, c = diffs\n *\n * @param {string|!Array.<!diff_match_patch.Diff>} a text1 (methods 1,3,4) or\n * Array of diff tuples for text1 to text2 (method 2).\n * @param {string|!Array.<!diff_match_patch.Diff>=} opt_b text2 (methods 1,4) or\n * Array of diff tuples for text1 to text2 (method 3) or undefined (method 2).\n * @param {string|!Array.<!diff_match_patch.Diff>=} opt_c Array of diff tuples\n * for text1 to text2 (method 4) or undefined (methods 1,2,3).\n * @return {!Array.<!diff_match_patch.patch_obj>} Array of Patch objects.\n */\ndiff_match_patch.prototype.patch_make = function(a, opt_b, opt_c) {\n  var text1, diffs;\n  if (typeof a == 'string' && typeof opt_b == 'string' &&\n      typeof opt_c == 'undefined') {\n    // Method 1: text1, text2\n    // Compute diffs from text1 and text2.\n    text1 = /** @type {string} */(a);\n    diffs = this.diff_main(text1, /** @type {string} */(opt_b), true);\n    if (diffs.length > 2) {\n      this.diff_cleanupSemantic(diffs);\n      this.diff_cleanupEfficiency(diffs);\n    }\n  } else if (a && typeof a == 'object' && typeof opt_b == 'undefined' &&\n      typeof opt_c == 'undefined') {\n    // Method 2: diffs\n    // Compute text1 from diffs.\n    diffs = /** @type {!Array.<!diff_match_patch.Diff>} */(a);\n    text1 = this.diff_text1(diffs);\n  } else if (typeof a == 'string' && opt_b && typeof opt_b == 'object' &&\n      typeof opt_c == 'undefined') {\n    // Method 3: text1, diffs\n    text1 = /** @type {string} */(a);\n    diffs = /** @type {!Array.<!diff_match_patch.Diff>} */(opt_b);\n  } else if (typeof a == 'string' && typeof opt_b == 'string' &&\n      opt_c && typeof opt_c == 'object') {\n    // Method 4: text1, text2, diffs\n    // text2 is not used.\n    text1 = /** @type {string} */(a);\n    diffs = /** @type {!Array.<!diff_match_patch.Diff>} */(opt_c);\n  } else {\n    throw new Error('Unknown call format to patch_make.');\n  }\n\n  if (diffs.length === 0) {\n    return [];  // Get rid of the null case.\n  }\n  var patches = [];\n  var patch = new diff_match_patch.patch_obj();\n  var patchDiffLength = 0;  // Keeping our own length var is faster in JS.\n  var char_count1 = 0;  // Number of characters into the text1 string.\n  var char_count2 = 0;  // Number of characters into the text2 string.\n  // Start with text1 (prepatch_text) and apply the diffs until we arrive at\n  // text2 (postpatch_text).  We recreate the patches one by one to determine\n  // context info.\n  var prepatch_text = text1;\n  var postpatch_text = text1;\n  for (var x = 0; x < diffs.length; x++) {\n    var diff_type = diffs[x][0];\n    var diff_text = diffs[x][1];\n\n    if (!patchDiffLength && diff_type !== DIFF_EQUAL) {\n      // A new patch starts here.\n      patch.start1 = char_count1;\n      patch.start2 = char_count2;\n    }\n\n    switch (diff_type) {\n      case DIFF_INSERT:\n        patch.diffs[patchDiffLength++] = diffs[x];\n        patch.length2 += diff_text.length;\n        postpatch_text = postpatch_text.substring(0, char_count2) + diff_text +\n                         postpatch_text.substring(char_count2);\n        break;\n      case DIFF_DELETE:\n        patch.length1 += diff_text.length;\n        patch.diffs[patchDiffLength++] = diffs[x];\n        postpatch_text = postpatch_text.substring(0, char_count2) +\n                         postpatch_text.substring(char_count2 +\n                             diff_text.length);\n        break;\n      case DIFF_EQUAL:\n        if (diff_text.length <= 2 * this.Patch_Margin &&\n            patchDiffLength && diffs.length != x + 1) {\n          // Small equality inside a patch.\n          patch.diffs[patchDiffLength++] = diffs[x];\n          patch.length1 += diff_text.length;\n          patch.length2 += diff_text.length;\n        } else if (diff_text.length >= 2 * this.Patch_Margin) {\n          // Time for a new patch.\n          if (patchDiffLength) {\n            this.patch_addContext_(patch, prepatch_text);\n            patches.push(patch);\n            patch = new diff_match_patch.patch_obj();\n            patchDiffLength = 0;\n            // Unlike Unidiff, our patch lists have a rolling context.\n            // https://github.com/google/diff-match-patch/wiki/Unidiff\n            // Update prepatch text & pos to reflect the application of the\n            // just completed patch.\n            prepatch_text = postpatch_text;\n            char_count1 = char_count2;\n          }\n        }\n        break;\n    }\n\n    // Update the current character count.\n    if (diff_type !== DIFF_INSERT) {\n      char_count1 += diff_text.length;\n    }\n    if (diff_type !== DIFF_DELETE) {\n      char_count2 += diff_text.length;\n    }\n  }\n  // Pick up the leftover patch if not empty.\n  if (patchDiffLength) {\n    this.patch_addContext_(patch, prepatch_text);\n    patches.push(patch);\n  }\n\n  return patches;\n};\n\n\n/**\n * Given an array of patches, return another array that is identical.\n * @param {!Array.<!diff_match_patch.patch_obj>} patches Array of Patch objects.\n * @return {!Array.<!diff_match_patch.patch_obj>} Array of Patch objects.\n */\ndiff_match_patch.prototype.patch_deepCopy = function(patches) {\n  // Making deep copies is hard in JavaScript.\n  var patchesCopy = [];\n  for (var x = 0; x < patches.length; x++) {\n    var patch = patches[x];\n    var patchCopy = new diff_match_patch.patch_obj();\n    patchCopy.diffs = [];\n    for (var y = 0; y < patch.diffs.length; y++) {\n      patchCopy.diffs[y] =\n          new diff_match_patch.Diff(patch.diffs[y][0], patch.diffs[y][1]);\n    }\n    patchCopy.start1 = patch.start1;\n    patchCopy.start2 = patch.start2;\n    patchCopy.length1 = patch.length1;\n    patchCopy.length2 = patch.length2;\n    patchesCopy[x] = patchCopy;\n  }\n  return patchesCopy;\n};\n\n\n/**\n * Merge a set of patches onto the text.  Return a patched text, as well\n * as a list of true/false values indicating which patches were applied.\n * @param {!Array.<!diff_match_patch.patch_obj>} patches Array of Patch objects.\n * @param {string} text Old text.\n * @return {!Array.<string|!Array.<boolean>>} Two element Array, containing the\n *      new text and an array of boolean values.\n */\ndiff_match_patch.prototype.patch_apply = function(patches, text) {\n  if (patches.length == 0) {\n    return [text, []];\n  }\n\n  // Deep copy the patches so that no changes are made to originals.\n  patches = this.patch_deepCopy(patches);\n\n  var nullPadding = this.patch_addPadding(patches);\n  text = nullPadding + text + nullPadding;\n\n  this.patch_splitMax(patches);\n  // delta keeps track of the offset between the expected and actual location\n  // of the previous patch.  If there are patches expected at positions 10 and\n  // 20, but the first patch was found at 12, delta is 2 and the second patch\n  // has an effective expected position of 22.\n  var delta = 0;\n  var results = [];\n  for (var x = 0; x < patches.length; x++) {\n    var expected_loc = patches[x].start2 + delta;\n    var text1 = this.diff_text1(patches[x].diffs);\n    var start_loc;\n    var end_loc = -1;\n    if (text1.length > this.Match_MaxBits) {\n      // patch_splitMax will only provide an oversized pattern in the case of\n      // a monster delete.\n      start_loc = this.match_main(text, text1.substring(0, this.Match_MaxBits),\n                                  expected_loc);\n      if (start_loc != -1) {\n        end_loc = this.match_main(text,\n            text1.substring(text1.length - this.Match_MaxBits),\n            expected_loc + text1.length - this.Match_MaxBits);\n        if (end_loc == -1 || start_loc >= end_loc) {\n          // Can't find valid trailing context.  Drop this patch.\n          start_loc = -1;\n        }\n      }\n    } else {\n      start_loc = this.match_main(text, text1, expected_loc);\n    }\n    if (start_loc == -1) {\n      // No match found.  :(\n      results[x] = false;\n      // Subtract the delta for this failed patch from subsequent patches.\n      delta -= patches[x].length2 - patches[x].length1;\n    } else {\n      // Found a match.  :)\n      results[x] = true;\n      delta = start_loc - expected_loc;\n      var text2;\n      if (end_loc == -1) {\n        text2 = text.substring(start_loc, start_loc + text1.length);\n      } else {\n        text2 = text.substring(start_loc, end_loc + this.Match_MaxBits);\n      }\n      if (text1 == text2) {\n        // Perfect match, just shove the replacement text in.\n        text = text.substring(0, start_loc) +\n               this.diff_text2(patches[x].diffs) +\n               text.substring(start_loc + text1.length);\n      } else {\n        // Imperfect match.  Run a diff to get a framework of equivalent\n        // indices.\n        var diffs = this.diff_main(text1, text2, false);\n        if (text1.length > this.Match_MaxBits &&\n            this.diff_levenshtein(diffs) / text1.length >\n            this.Patch_DeleteThreshold) {\n          // The end points match, but the content is unacceptably bad.\n          results[x] = false;\n        } else {\n          this.diff_cleanupSemanticLossless(diffs);\n          var index1 = 0;\n          var index2;\n          for (var y = 0; y < patches[x].diffs.length; y++) {\n            var mod = patches[x].diffs[y];\n            if (mod[0] !== DIFF_EQUAL) {\n              index2 = this.diff_xIndex(diffs, index1);\n            }\n            if (mod[0] === DIFF_INSERT) {  // Insertion\n              text = text.substring(0, start_loc + index2) + mod[1] +\n                     text.substring(start_loc + index2);\n            } else if (mod[0] === DIFF_DELETE) {  // Deletion\n              text = text.substring(0, start_loc + index2) +\n                     text.substring(start_loc + this.diff_xIndex(diffs,\n                         index1 + mod[1].length));\n            }\n            if (mod[0] !== DIFF_DELETE) {\n              index1 += mod[1].length;\n            }\n          }\n        }\n      }\n    }\n  }\n  // Strip the padding off.\n  text = text.substring(nullPadding.length, text.length - nullPadding.length);\n  return [text, results];\n};\n\n\n/**\n * Add some padding on text start and end so that edges can match something.\n * Intended to be called only from within patch_apply.\n * @param {!Array.<!diff_match_patch.patch_obj>} patches Array of Patch objects.\n * @return {string} The padding string added to each side.\n */\ndiff_match_patch.prototype.patch_addPadding = function(patches) {\n  var paddingLength = this.Patch_Margin;\n  var nullPadding = '';\n  for (var x = 1; x <= paddingLength; x++) {\n    nullPadding += String.fromCharCode(x);\n  }\n\n  // Bump all the patches forward.\n  for (var x = 0; x < patches.length; x++) {\n    patches[x].start1 += paddingLength;\n    patches[x].start2 += paddingLength;\n  }\n\n  // Add some padding on start of first diff.\n  var patch = patches[0];\n  var diffs = patch.diffs;\n  if (diffs.length == 0 || diffs[0][0] != DIFF_EQUAL) {\n    // Add nullPadding equality.\n    diffs.unshift(new diff_match_patch.Diff(DIFF_EQUAL, nullPadding));\n    patch.start1 -= paddingLength;  // Should be 0.\n    patch.start2 -= paddingLength;  // Should be 0.\n    patch.length1 += paddingLength;\n    patch.length2 += paddingLength;\n  } else if (paddingLength > diffs[0][1].length) {\n    // Grow first equality.\n    var extraLength = paddingLength - diffs[0][1].length;\n    diffs[0][1] = nullPadding.substring(diffs[0][1].length) + diffs[0][1];\n    patch.start1 -= extraLength;\n    patch.start2 -= extraLength;\n    patch.length1 += extraLength;\n    patch.length2 += extraLength;\n  }\n\n  // Add some padding on end of last diff.\n  patch = patches[patches.length - 1];\n  diffs = patch.diffs;\n  if (diffs.length == 0 || diffs[diffs.length - 1][0] != DIFF_EQUAL) {\n    // Add nullPadding equality.\n    diffs.push(new diff_match_patch.Diff(DIFF_EQUAL, nullPadding));\n    patch.length1 += paddingLength;\n    patch.length2 += paddingLength;\n  } else if (paddingLength > diffs[diffs.length - 1][1].length) {\n    // Grow last equality.\n    var extraLength = paddingLength - diffs[diffs.length - 1][1].length;\n    diffs[diffs.length - 1][1] += nullPadding.substring(0, extraLength);\n    patch.length1 += extraLength;\n    patch.length2 += extraLength;\n  }\n\n  return nullPadding;\n};\n\n\n/**\n * Look through the patches and break up any which are longer than the maximum\n * limit of the match algorithm.\n * Intended to be called only from within patch_apply.\n * @param {!Array.<!diff_match_patch.patch_obj>} patches Array of Patch objects.\n */\ndiff_match_patch.prototype.patch_splitMax = function(patches) {\n  var patch_size = this.Match_MaxBits;\n  for (var x = 0; x < patches.length; x++) {\n    if (patches[x].length1 <= patch_size) {\n      continue;\n    }\n    var bigpatch = patches[x];\n    // Remove the big old patch.\n    patches.splice(x--, 1);\n    var start1 = bigpatch.start1;\n    var start2 = bigpatch.start2;\n    var precontext = '';\n    while (bigpatch.diffs.length !== 0) {\n      // Create one of several smaller patches.\n      var patch = new diff_match_patch.patch_obj();\n      var empty = true;\n      patch.start1 = start1 - precontext.length;\n      patch.start2 = start2 - precontext.length;\n      if (precontext !== '') {\n        patch.length1 = patch.length2 = precontext.length;\n        patch.diffs.push(new diff_match_patch.Diff(DIFF_EQUAL, precontext));\n      }\n      while (bigpatch.diffs.length !== 0 &&\n             patch.length1 < patch_size - this.Patch_Margin) {\n        var diff_type = bigpatch.diffs[0][0];\n        var diff_text = bigpatch.diffs[0][1];\n        if (diff_type === DIFF_INSERT) {\n          // Insertions are harmless.\n          patch.length2 += diff_text.length;\n          start2 += diff_text.length;\n          patch.diffs.push(bigpatch.diffs.shift());\n          empty = false;\n        } else if (diff_type === DIFF_DELETE && patch.diffs.length == 1 &&\n                   patch.diffs[0][0] == DIFF_EQUAL &&\n                   diff_text.length > 2 * patch_size) {\n          // This is a large deletion.  Let it pass in one chunk.\n          patch.length1 += diff_text.length;\n          start1 += diff_text.length;\n          empty = false;\n          patch.diffs.push(new diff_match_patch.Diff(diff_type, diff_text));\n          bigpatch.diffs.shift();\n        } else {\n          // Deletion or equality.  Only take as much as we can stomach.\n          diff_text = diff_text.substring(0,\n              patch_size - patch.length1 - this.Patch_Margin);\n          patch.length1 += diff_text.length;\n          start1 += diff_text.length;\n          if (diff_type === DIFF_EQUAL) {\n            patch.length2 += diff_text.length;\n            start2 += diff_text.length;\n          } else {\n            empty = false;\n          }\n          patch.diffs.push(new diff_match_patch.Diff(diff_type, diff_text));\n          if (diff_text == bigpatch.diffs[0][1]) {\n            bigpatch.diffs.shift();\n          } else {\n            bigpatch.diffs[0][1] =\n                bigpatch.diffs[0][1].substring(diff_text.length);\n          }\n        }\n      }\n      // Compute the head context for the next patch.\n      precontext = this.diff_text2(patch.diffs);\n      precontext =\n          precontext.substring(precontext.length - this.Patch_Margin);\n      // Append the end context for this patch.\n      var postcontext = this.diff_text1(bigpatch.diffs)\n                            .substring(0, this.Patch_Margin);\n      if (postcontext !== '') {\n        patch.length1 += postcontext.length;\n        patch.length2 += postcontext.length;\n        if (patch.diffs.length !== 0 &&\n            patch.diffs[patch.diffs.length - 1][0] === DIFF_EQUAL) {\n          patch.diffs[patch.diffs.length - 1][1] += postcontext;\n        } else {\n          patch.diffs.push(new diff_match_patch.Diff(DIFF_EQUAL, postcontext));\n        }\n      }\n      if (!empty) {\n        patches.splice(++x, 0, patch);\n      }\n    }\n  }\n};\n\n\n/**\n * Take a list of patches and return a textual representation.\n * @param {!Array.<!diff_match_patch.patch_obj>} patches Array of Patch objects.\n * @return {string} Text representation of patches.\n */\ndiff_match_patch.prototype.patch_toText = function(patches) {\n  var text = [];\n  for (var x = 0; x < patches.length; x++) {\n    text[x] = patches[x];\n  }\n  return text.join('');\n};\n\n\n/**\n * Parse a textual representation of patches and return a list of Patch objects.\n * @param {string} textline Text representation of patches.\n * @return {!Array.<!diff_match_patch.patch_obj>} Array of Patch objects.\n * @throws {!Error} If invalid input.\n */\ndiff_match_patch.prototype.patch_fromText = function(textline) {\n  var patches = [];\n  if (!textline) {\n    return patches;\n  }\n  var text = textline.split('\\n');\n  var textPointer = 0;\n  var patchHeader = /^@@ -(\\d+),?(\\d*) \\+(\\d+),?(\\d*) @@$/;\n  while (textPointer < text.length) {\n    var m = text[textPointer].match(patchHeader);\n    if (!m) {\n      throw new Error('Invalid patch string: ' + text[textPointer]);\n    }\n    var patch = new diff_match_patch.patch_obj();\n    patches.push(patch);\n    patch.start1 = parseInt(m[1], 10);\n    if (m[2] === '') {\n      patch.start1--;\n      patch.length1 = 1;\n    } else if (m[2] == '0') {\n      patch.length1 = 0;\n    } else {\n      patch.start1--;\n      patch.length1 = parseInt(m[2], 10);\n    }\n\n    patch.start2 = parseInt(m[3], 10);\n    if (m[4] === '') {\n      patch.start2--;\n      patch.length2 = 1;\n    } else if (m[4] == '0') {\n      patch.length2 = 0;\n    } else {\n      patch.start2--;\n      patch.length2 = parseInt(m[4], 10);\n    }\n    textPointer++;\n\n    while (textPointer < text.length) {\n      var sign = text[textPointer].charAt(0);\n      try {\n        var line = decodeURI(text[textPointer].substring(1));\n      } catch (ex) {\n        // Malformed URI sequence.\n        throw new Error('Illegal escape in patch_fromText: ' + line);\n      }\n      if (sign == '-') {\n        // Deletion.\n        patch.diffs.push(new diff_match_patch.Diff(DIFF_DELETE, line));\n      } else if (sign == '+') {\n        // Insertion.\n        patch.diffs.push(new diff_match_patch.Diff(DIFF_INSERT, line));\n      } else if (sign == ' ') {\n        // Minor equality.\n        patch.diffs.push(new diff_match_patch.Diff(DIFF_EQUAL, line));\n      } else if (sign == '@') {\n        // Start of next patch.\n        break;\n      } else if (sign === '') {\n        // Blank line?  Whatever.\n      } else {\n        // WTF?\n        throw new Error('Invalid patch mode \"' + sign + '\" in: ' + line);\n      }\n      textPointer++;\n    }\n  }\n  return patches;\n};\n\n\n/**\n * Class representing one patch operation.\n * @constructor\n */\ndiff_match_patch.patch_obj = function() {\n  /** @type {!Array.<!diff_match_patch.Diff>} */\n  this.diffs = [];\n  /** @type {?number} */\n  this.start1 = null;\n  /** @type {?number} */\n  this.start2 = null;\n  /** @type {number} */\n  this.length1 = 0;\n  /** @type {number} */\n  this.length2 = 0;\n};\n\n\n/**\n * Emulate GNU diff's format.\n * Header: @@ -382,8 +481,9 @@\n * Indices are printed as 1-based, not 0-based.\n * @return {string} The GNU diff string.\n */\ndiff_match_patch.patch_obj.prototype.toString = function() {\n  var coords1, coords2;\n  if (this.length1 === 0) {\n    coords1 = this.start1 + ',0';\n  } else if (this.length1 == 1) {\n    coords1 = this.start1 + 1;\n  } else {\n    coords1 = (this.start1 + 1) + ',' + this.length1;\n  }\n  if (this.length2 === 0) {\n    coords2 = this.start2 + ',0';\n  } else if (this.length2 == 1) {\n    coords2 = this.start2 + 1;\n  } else {\n    coords2 = (this.start2 + 1) + ',' + this.length2;\n  }\n  var text = ['@@ -' + coords1 + ' +' + coords2 + ' @@\\n'];\n  var op;\n  // Escape the body of the patch with %xx notation.\n  for (var x = 0; x < this.diffs.length; x++) {\n    switch (this.diffs[x][0]) {\n      case DIFF_INSERT:\n        op = '+';\n        break;\n      case DIFF_DELETE:\n        op = '-';\n        break;\n      case DIFF_EQUAL:\n        op = ' ';\n        break;\n    }\n    text[x + 1] = op + encodeURI(this.diffs[x][1]) + '\\n';\n  }\n  return text.join('').replace(/%20/g, ' ');\n};\n\n\n// The following export code was added by @ForbesLindesay\nmodule.exports = diff_match_patch;\nmodule.exports['diff_match_patch'] = diff_match_patch;\nmodule.exports['DIFF_DELETE'] = DIFF_DELETE;\nmodule.exports['DIFF_INSERT'] = DIFF_INSERT;\nmodule.exports['DIFF_EQUAL'] = DIFF_EQUAL;","'use strict';\n\n/******************************************************************************\n * Created 2008-08-19.\n *\n * Dijkstra path-finding functions. Adapted from the Dijkstar Python project.\n *\n * Copyright (C) 2008\n *   Wyatt Baldwin <self@wyattbaldwin.com>\n *   All rights reserved\n *\n * Licensed under the MIT license.\n *\n *   http://www.opensource.org/licenses/mit-license.php\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n *****************************************************************************/\nvar dijkstra = {\n  single_source_shortest_paths: function(graph, s, d) {\n    // Predecessor map for each node that has been encountered.\n    // node ID => predecessor node ID\n    var predecessors = {};\n\n    // Costs of shortest paths from s to all nodes encountered.\n    // node ID => cost\n    var costs = {};\n    costs[s] = 0;\n\n    // Costs of shortest paths from s to all nodes encountered; differs from\n    // `costs` in that it provides easy access to the node that currently has\n    // the known shortest path from s.\n    // XXX: Do we actually need both `costs` and `open`?\n    var open = dijkstra.PriorityQueue.make();\n    open.push(s, 0);\n\n    var closest,\n        u, v,\n        cost_of_s_to_u,\n        adjacent_nodes,\n        cost_of_e,\n        cost_of_s_to_u_plus_cost_of_e,\n        cost_of_s_to_v,\n        first_visit;\n    while (!open.empty()) {\n      // In the nodes remaining in graph that have a known cost from s,\n      // find the node, u, that currently has the shortest path from s.\n      closest = open.pop();\n      u = closest.value;\n      cost_of_s_to_u = closest.cost;\n\n      // Get nodes adjacent to u...\n      adjacent_nodes = graph[u] || {};\n\n      // ...and explore the edges that connect u to those nodes, updating\n      // the cost of the shortest paths to any or all of those nodes as\n      // necessary. v is the node across the current edge from u.\n      for (v in adjacent_nodes) {\n        if (adjacent_nodes.hasOwnProperty(v)) {\n          // Get the cost of the edge running from u to v.\n          cost_of_e = adjacent_nodes[v];\n\n          // Cost of s to u plus the cost of u to v across e--this is *a*\n          // cost from s to v that may or may not be less than the current\n          // known cost to v.\n          cost_of_s_to_u_plus_cost_of_e = cost_of_s_to_u + cost_of_e;\n\n          // If we haven't visited v yet OR if the current known cost from s to\n          // v is greater than the new cost we just found (cost of s to u plus\n          // cost of u to v across e), update v's cost in the cost list and\n          // update v's predecessor in the predecessor list (it's now u).\n          cost_of_s_to_v = costs[v];\n          first_visit = (typeof costs[v] === 'undefined');\n          if (first_visit || cost_of_s_to_v > cost_of_s_to_u_plus_cost_of_e) {\n            costs[v] = cost_of_s_to_u_plus_cost_of_e;\n            open.push(v, cost_of_s_to_u_plus_cost_of_e);\n            predecessors[v] = u;\n          }\n        }\n      }\n    }\n\n    if (typeof d !== 'undefined' && typeof costs[d] === 'undefined') {\n      var msg = ['Could not find a path from ', s, ' to ', d, '.'].join('');\n      throw new Error(msg);\n    }\n\n    return predecessors;\n  },\n\n  extract_shortest_path_from_predecessor_list: function(predecessors, d) {\n    var nodes = [];\n    var u = d;\n    var predecessor;\n    while (u) {\n      nodes.push(u);\n      predecessor = predecessors[u];\n      u = predecessors[u];\n    }\n    nodes.reverse();\n    return nodes;\n  },\n\n  find_path: function(graph, s, d) {\n    var predecessors = dijkstra.single_source_shortest_paths(graph, s, d);\n    return dijkstra.extract_shortest_path_from_predecessor_list(\n      predecessors, d);\n  },\n\n  /**\n   * A very naive priority queue implementation.\n   */\n  PriorityQueue: {\n    make: function (opts) {\n      var T = dijkstra.PriorityQueue,\n          t = {},\n          key;\n      opts = opts || {};\n      for (key in T) {\n        if (T.hasOwnProperty(key)) {\n          t[key] = T[key];\n        }\n      }\n      t.queue = [];\n      t.sorter = opts.sorter || T.default_sorter;\n      return t;\n    },\n\n    default_sorter: function (a, b) {\n      return a.cost - b.cost;\n    },\n\n    /**\n     * Add a new item to the queue and ensure the highest priority element\n     * is at the front of the queue.\n     */\n    push: function (value, cost) {\n      var item = {value: value, cost: cost};\n      this.queue.push(item);\n      this.queue.sort(this.sorter);\n    },\n\n    /**\n     * Return the highest priority element in the queue.\n     */\n    pop: function () {\n      return this.queue.shift();\n    },\n\n    empty: function () {\n      return this.queue.length === 0;\n    }\n  }\n};\n\n\n// node.js module exports\nif (typeof module !== 'undefined') {\n  module.exports = dijkstra;\n}\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.Doctype = exports.CDATA = exports.Tag = exports.Style = exports.Script = exports.Comment = exports.Directive = exports.Text = exports.Root = exports.isTag = exports.ElementType = void 0;\n/** Types of elements found in htmlparser2's DOM */\nvar ElementType;\n(function (ElementType) {\n    /** Type for the root element of a document */\n    ElementType[\"Root\"] = \"root\";\n    /** Type for Text */\n    ElementType[\"Text\"] = \"text\";\n    /** Type for <? ... ?> */\n    ElementType[\"Directive\"] = \"directive\";\n    /** Type for <!-- ... --> */\n    ElementType[\"Comment\"] = \"comment\";\n    /** Type for <script> tags */\n    ElementType[\"Script\"] = \"script\";\n    /** Type for <style> tags */\n    ElementType[\"Style\"] = \"style\";\n    /** Type for Any tag */\n    ElementType[\"Tag\"] = \"tag\";\n    /** Type for <![CDATA[ ... ]]> */\n    ElementType[\"CDATA\"] = \"cdata\";\n    /** Type for <!doctype ...> */\n    ElementType[\"Doctype\"] = \"doctype\";\n})(ElementType = exports.ElementType || (exports.ElementType = {}));\n/**\n * Tests whether an element is a tag or not.\n *\n * @param elem Element to test\n */\nfunction isTag(elem) {\n    return (elem.type === ElementType.Tag ||\n        elem.type === ElementType.Script ||\n        elem.type === ElementType.Style);\n}\nexports.isTag = isTag;\n// Exports for backwards compatibility\n/** Type for the root element of a document */\nexports.Root = ElementType.Root;\n/** Type for Text */\nexports.Text = ElementType.Text;\n/** Type for <? ... ?> */\nexports.Directive = ElementType.Directive;\n/** Type for <!-- ... --> */\nexports.Comment = ElementType.Comment;\n/** Type for <script> tags */\nexports.Script = ElementType.Script;\n/** Type for <style> tags */\nexports.Style = ElementType.Style;\n/** Type for Any tag */\nexports.Tag = ElementType.Tag;\n/** Type for <![CDATA[ ... ]]> */\nexports.CDATA = ElementType.CDATA;\n/** Type for <!doctype ...> */\nexports.Doctype = ElementType.Doctype;\n","'use strict';\n\nvar callBind = require('call-bind-apply-helpers');\nvar gOPD = require('gopd');\n\nvar hasProtoAccessor;\ntry {\n\t// eslint-disable-next-line no-extra-parens, no-proto\n\thasProtoAccessor = /** @type {{ __proto__?: typeof Array.prototype }} */ ([]).__proto__ === Array.prototype;\n} catch (e) {\n\tif (!e || typeof e !== 'object' || !('code' in e) || e.code !== 'ERR_PROTO_ACCESS') {\n\t\tthrow e;\n\t}\n}\n\n// eslint-disable-next-line no-extra-parens\nvar desc = !!hasProtoAccessor && gOPD && gOPD(Object.prototype, /** @type {keyof typeof Object.prototype} */ ('__proto__'));\n\nvar $Object = Object;\nvar $getPrototypeOf = $Object.getPrototypeOf;\n\n/** @type {import('./get')} */\nmodule.exports = desc && typeof desc.get === 'function'\n\t? callBind([desc.get])\n\t: typeof $getPrototypeOf === 'function'\n\t\t? /** @type {import('./get')} */ function getDunder(value) {\n\t\t\t// eslint-disable-next-line eqeqeq\n\t\t\treturn $getPrototypeOf(value == null ? value : $Object(value));\n\t\t}\n\t\t: false;\n","module.exports = {\n\t\"0.20\": \"39\",\n\t\"0.21\": \"41\",\n\t\"0.22\": \"41\",\n\t\"0.23\": \"41\",\n\t\"0.24\": \"41\",\n\t\"0.25\": \"42\",\n\t\"0.26\": \"42\",\n\t\"0.27\": \"43\",\n\t\"0.28\": \"43\",\n\t\"0.29\": \"43\",\n\t\"0.30\": \"44\",\n\t\"0.31\": \"45\",\n\t\"0.32\": \"45\",\n\t\"0.33\": \"45\",\n\t\"0.34\": \"45\",\n\t\"0.35\": \"45\",\n\t\"0.36\": \"47\",\n\t\"0.37\": \"49\",\n\t\"1.0\": \"49\",\n\t\"1.1\": \"50\",\n\t\"1.2\": \"51\",\n\t\"1.3\": \"52\",\n\t\"1.4\": \"53\",\n\t\"1.5\": \"54\",\n\t\"1.6\": \"56\",\n\t\"1.7\": \"58\",\n\t\"1.8\": \"59\",\n\t\"2.0\": \"61\",\n\t\"2.1\": \"61\",\n\t\"3.0\": \"66\",\n\t\"3.1\": \"66\",\n\t\"4.0\": \"69\",\n\t\"4.1\": \"69\",\n\t\"4.2\": \"69\",\n\t\"5.0\": \"73\",\n\t\"6.0\": \"76\",\n\t\"6.1\": \"76\",\n\t\"7.0\": \"78\",\n\t\"7.1\": \"78\",\n\t\"7.2\": \"78\",\n\t\"7.3\": \"78\",\n\t\"8.0\": \"80\",\n\t\"8.1\": \"80\",\n\t\"8.2\": \"80\",\n\t\"8.3\": \"80\",\n\t\"8.4\": \"80\",\n\t\"8.5\": \"80\",\n\t\"9.0\": \"83\",\n\t\"9.1\": \"83\",\n\t\"9.2\": \"83\",\n\t\"9.3\": \"83\",\n\t\"9.4\": \"83\",\n\t\"10.0\": \"85\",\n\t\"10.1\": \"85\",\n\t\"10.2\": \"85\",\n\t\"10.3\": \"85\",\n\t\"10.4\": \"85\",\n\t\"11.0\": \"87\",\n\t\"11.1\": \"87\",\n\t\"11.2\": \"87\",\n\t\"11.3\": \"87\",\n\t\"11.4\": \"87\",\n\t\"11.5\": \"87\",\n\t\"12.0\": \"89\",\n\t\"12.1\": \"89\",\n\t\"12.2\": \"89\",\n\t\"13.0\": \"91\",\n\t\"13.1\": \"91\",\n\t\"13.2\": \"91\",\n\t\"13.3\": \"91\",\n\t\"13.4\": \"91\",\n\t\"13.5\": \"91\",\n\t\"13.6\": \"91\",\n\t\"14.0\": \"93\",\n\t\"14.1\": \"93\",\n\t\"14.2\": \"93\",\n\t\"15.0\": \"94\",\n\t\"15.1\": \"94\",\n\t\"15.2\": \"94\",\n\t\"15.3\": \"94\",\n\t\"15.4\": \"94\",\n\t\"15.5\": \"94\",\n\t\"16.0\": \"96\",\n\t\"16.1\": \"96\",\n\t\"16.2\": \"96\",\n\t\"17.0\": \"98\",\n\t\"17.1\": \"98\",\n\t\"17.2\": \"98\",\n\t\"17.3\": \"98\",\n\t\"17.4\": \"98\",\n\t\"18.0\": \"100\",\n\t\"18.1\": \"100\",\n\t\"18.2\": \"100\",\n\t\"18.3\": \"100\",\n\t\"19.0\": \"102\",\n\t\"19.1\": \"102\",\n\t\"20.0\": \"104\",\n\t\"20.1\": \"104\",\n\t\"20.2\": \"104\",\n\t\"20.3\": \"104\",\n\t\"21.0\": \"106\",\n\t\"21.1\": \"106\",\n\t\"21.2\": \"106\",\n\t\"21.3\": \"106\",\n\t\"21.4\": \"106\",\n\t\"22.0\": \"108\",\n\t\"22.1\": \"108\",\n\t\"22.2\": \"108\",\n\t\"22.3\": \"108\",\n\t\"23.0\": \"110\",\n\t\"23.1\": \"110\",\n\t\"23.2\": \"110\",\n\t\"23.3\": \"110\",\n\t\"24.0\": \"112\",\n\t\"24.1\": \"112\",\n\t\"24.2\": \"112\",\n\t\"24.3\": \"112\",\n\t\"24.4\": \"112\",\n\t\"24.5\": \"112\",\n\t\"24.6\": \"112\",\n\t\"24.7\": \"112\",\n\t\"24.8\": \"112\",\n\t\"25.0\": \"114\",\n\t\"25.1\": \"114\",\n\t\"25.2\": \"114\",\n\t\"25.3\": \"114\",\n\t\"25.4\": \"114\",\n\t\"25.5\": \"114\",\n\t\"25.6\": \"114\",\n\t\"25.7\": \"114\",\n\t\"25.8\": \"114\",\n\t\"25.9\": \"114\",\n\t\"26.0\": \"116\",\n\t\"26.1\": \"116\",\n\t\"26.2\": \"116\",\n\t\"26.3\": \"116\",\n\t\"26.4\": \"116\",\n\t\"26.5\": \"116\",\n\t\"26.6\": \"116\",\n\t\"27.0\": \"118\",\n\t\"27.1\": \"118\",\n\t\"27.2\": \"118\",\n\t\"27.3\": \"118\",\n\t\"28.0\": \"120\",\n\t\"28.1\": \"120\",\n\t\"28.2\": \"120\",\n\t\"28.3\": \"120\",\n\t\"29.0\": \"122\",\n\t\"29.1\": \"122\",\n\t\"29.2\": \"122\",\n\t\"29.3\": \"122\",\n\t\"29.4\": \"122\",\n\t\"30.0\": \"124\",\n\t\"30.1\": \"124\",\n\t\"30.2\": \"124\",\n\t\"30.3\": \"124\",\n\t\"30.4\": \"124\",\n\t\"30.5\": \"124\",\n\t\"31.0\": \"126\",\n\t\"31.1\": \"126\",\n\t\"31.2\": \"126\",\n\t\"31.3\": \"126\",\n\t\"31.4\": \"126\",\n\t\"31.5\": \"126\",\n\t\"31.6\": \"126\",\n\t\"31.7\": \"126\",\n\t\"32.0\": \"128\",\n\t\"32.1\": \"128\",\n\t\"32.2\": \"128\",\n\t\"32.3\": \"128\",\n\t\"33.0\": \"130\",\n\t\"33.1\": \"130\",\n\t\"33.2\": \"130\",\n\t\"33.3\": \"130\",\n\t\"33.4\": \"130\",\n\t\"34.0\": \"132\",\n\t\"34.1\": \"132\",\n\t\"34.2\": \"132\",\n\t\"34.3\": \"132\",\n\t\"35.0\": \"134\"\n};","module.exports = /[:=](?:\\'(?:\\-[\\(\\)DO\\[\\]o\\{\\}]|[\\(\\)DO\\[\\]o\\{\\}])|\\{>|\\-[#\\$&\\(-\\*\\/3<>-@B-EJLOPSXZ-\\]cjlopsxz-\\}]|[#\\$&\\(-\\*\\/3<>-@B-EJLOPSXZ-\\]cjlopsxz\\|\\}])|[Oo][:=](?:\\-[\\)\\]\\}]|[\\)\\]\\}])|>(?:[:=](?:\\-[\\(\\)\\/\\[-\\]\\{\\}]|[\\(\\)\\/\\[-\\]\\{\\}])|0(?:\\-[\\)\\]\\}]|[\\)\\]\\}]))|%(?:\\-[\\(\\[\\{]|[\\(\\[\\{])|\\\\[Mm]\\/|D(?:\\-[:=Xx]|[:=Xx])|8(?:\\-[#\\)D\\]\\}]|[#\\)D\\]\\}])|;(?:\\-[\\)P\\]p\\}]|[\\)P\\]p\\}])|x(?:\\-[\\(DP\\[op\\{]|[\\(DP\\[op\\{])|X(?:\\-[\\(DOP\\[\\{]|[\\(DOP\\[\\{])|<\\/?3|[:=]\\{/;\n","import type { SkinTone } from './types';\n\n/**\n * Append a skin tone index (number) to the end of a shortcode.\n */\nexport function appendSkinToneIndex(\n\tshortcode: string,\n\temoji: { tone?: SkinTone | SkinTone[] },\n\tprefix: string = '',\n): string {\n\treturn `${shortcode}_${prefix}${Array.isArray(emoji.tone) ? emoji.tone.join('-') : emoji.tone}`;\n}\n","import type {\n\tGender,\n\tGroupKey,\n\tLocale,\n\tPermutationOptions,\n\tPresentation,\n\tQualifier,\n\tSkinTone,\n\tSkinToneKey,\n} from './types';\n\nexport const SEQUENCE_REMOVAL_PATTERN = /200D|FE0E|FE0F/g;\n\n// Use numbers instead of string values, as the filesize is greatly reduced.\n\nexport const TEXT: Presentation = 0;\nexport const EMOJI: Presentation = 1;\n\nexport const FEMALE: Gender = 0;\nexport const MALE: Gender = 1;\n\nexport const FULLY_QUALIFIED: Qualifier = 0;\nexport const MINIMALLY_QUALIFIED: Qualifier = 1;\nexport const UNQUALIFIED: Qualifier = 2;\n\nexport const LIGHT_SKIN: SkinTone = 1;\nexport const MEDIUM_LIGHT_SKIN: SkinTone = 2;\nexport const MEDIUM_SKIN: SkinTone = 3;\nexport const MEDIUM_DARK_SKIN: SkinTone = 4;\nexport const DARK_SKIN: SkinTone = 5;\n\nexport const GROUP_KEY_SMILEYS_EMOTION: GroupKey = 'smileys-emotion';\nexport const GROUP_KEY_PEOPLE_BODY: GroupKey = 'people-body';\nexport const GROUP_KEY_ANIMALS_NATURE: GroupKey = 'animals-nature';\nexport const GROUP_KEY_FOOD_DRINK: GroupKey = 'food-drink';\nexport const GROUP_KEY_TRAVEL_PLACES: GroupKey = 'travel-places';\nexport const GROUP_KEY_ACTIVITIES: GroupKey = 'activities';\nexport const GROUP_KEY_OBJECTS: GroupKey = 'objects';\nexport const GROUP_KEY_SYMBOLS: GroupKey = 'symbols';\nexport const GROUP_KEY_FLAGS: GroupKey = 'flags';\nexport const GROUP_KEY_COMPONENT: GroupKey = 'component';\n\nexport const SKIN_KEY_LIGHT: SkinToneKey = 'light';\nexport const SKIN_KEY_MEDIUM_LIGHT: SkinToneKey = 'medium-light';\nexport const SKIN_KEY_MEDIUM: SkinToneKey = 'medium';\nexport const SKIN_KEY_MEDIUM_DARK: SkinToneKey = 'medium-dark';\nexport const SKIN_KEY_DARK: SkinToneKey = 'dark';\n\n// Important release versions and locales in generating accurate data.\n\nexport const LATEST_EMOJI_VERSION = '15.1';\nexport const LATEST_UNICODE_VERSION = '15.1.0';\nexport const LATEST_CLDR_VERSION = '45';\n\nexport const FIRST_UNICODE_EMOJI_VERSION = '6.0.0';\nexport const EMOJI_VERSIONS = [\n\t'1.0',\n\t'2.0',\n\t'3.0',\n\t'4.0',\n\t'5.0',\n\t'11.0',\n\t'12.0',\n\t'12.1',\n\t'13.0',\n\t'13.1',\n\t'14.0',\n\t'15.0',\n\t'15.1',\n];\nexport const UNICODE_VERSIONS = [\n\t'6.0',\n\t'6.1',\n\t'6.2',\n\t'6.3',\n\t'7.0',\n\t'8.0',\n\t'9.0',\n\t'10.0',\n\t'11.0',\n\t'12.0',\n\t'12.1',\n\t'13.0',\n\t'14.0',\n\t'15.0',\n\t'15.1',\n];\n\nexport const SUPPORTED_LOCALES: Locale[] = [\n\t'bn', // Bangla\n\t'da', // Danish\n\t'de', // German\n\t'en', // English\n\t'en-gb', // English (Great Britain)\n\t'es', // Spanish\n\t'es-mx', // Spanish (Mexico)\n\t'et', // Estonian\n\t'fi', // Finnish\n\t'fr', // French\n\t'hi', // Hindi\n\t'hu', // Hungarian\n\t'it', // Italian\n\t'ja', // Japanese\n\t'ko', // Korean\n\t'lt', // Lithuanian\n\t'ms', // Malay\n\t'nb', // Norwegian\n\t'nl', // Dutch\n\t'pl', // Polish\n\t'pt', // Portuguese\n\t'ru', // Russian\n\t'sv', // Swedish\n\t'th', // Thai\n\t'uk', // Ukrainian\n\t'zh', // Chinese\n\t'zh-hant', // Chinese (Traditional)\n];\n\n// Special options for emoticon permutations.\n\nexport const EMOTICON_OPTIONS: Record<string, PermutationOptions> = {\n\t// 🧙‍♂️ man mage\n\t':{>': { withNose: false },\n\t// 💔 broken heart\n\t'</3': { isFace: false },\n\t// ❤️ red heart\n\t'<3': { isFace: false },\n\t// 🤘 sign of the horns\n\t'\\\\m/': { isFace: false },\n\t'\\\\M/': { isFace: false },\n\t// 👹 ogre\n\t'0)': { withNose: false },\n};\n","import type { CDNUrlFn, FetchFromCDNOptions } from './types';\n\nfunction getFetchUrl(path: string, version: string, cdnUrl?: CDNUrlFn | string): string {\n\tlet fetchUrl = `https://cdn.jsdelivr.net/npm/emojibase-data@${version}/${path}`;\n\n\tif (typeof cdnUrl === 'function') {\n\t\tfetchUrl = cdnUrl(path, version);\n\t} else if (typeof cdnUrl === 'string') {\n\t\tfetchUrl = `${cdnUrl}/${path}`;\n\t}\n\n\tif (__DEV__) {\n\t\tif (!path?.endsWith('.json')) {\n\t\t\tthrow new Error('A valid JSON dataset is required to fetch.');\n\t\t}\n\n\t\tif (!fetchUrl || !/^https?:\\/\\//.test(fetchUrl) || !fetchUrl.endsWith('.json')) {\n\t\t\tthrow new Error('A valid CDN url is required to fetch.');\n\t\t}\n\n\t\tif (!version) {\n\t\t\tthrow new Error('A valid release version is required.');\n\t\t}\n\t}\n\n\treturn fetchUrl;\n}\n\n/**\n * This function will fetch `emojibase-data` JSON files from our CDN, parse them,\n * and return the response. It requires a file path relative to the `emojibase-data` package\n * as the 1st argument and an optional object of options as the 2rd argument.\n *\n * ```ts\n * import { fetchFromCDN } from 'emojibase';\n *\n * await fetchFromCDN('ja/compact.json', { version: '2.1.3' });\n * await fetchFromCDN('ja/compact.json', { cdnUrl: 'https://example.com/cdn/emojidata/latest' });\n * await fetchFromCDN('ja/compact.json', {\n *     cdnUrl: (path: string, version: string) => {\n *         return `https://example.com/cdn/emojidata/${version}/${path}`;\n *     }\n * });\n * ```\n */\nexport async function fetchFromCDN<T>(path: string, options: FetchFromCDNOptions = {}): Promise<T> {\n\tconst { local = false, version = 'latest', cdnUrl, ...opts } = options;\n\n\tconst fetchUrl = getFetchUrl(path, version, cdnUrl);\n\n\tconst storage = local ? localStorage : sessionStorage;\n\tconst cacheKey = `emojibase/${version}/${path}`;\n\tconst cachedData = storage.getItem(cacheKey);\n\n\t// Check the cache first\n\tif (cachedData) {\n\t\treturn JSON.parse(cachedData) as T;\n\t}\n\n\t// eslint-disable-next-line compat/compat\n\tconst response = await fetch(fetchUrl, {\n\t\tcredentials: 'omit',\n\t\tmode: 'cors',\n\t\tredirect: 'error',\n\t\t...opts,\n\t});\n\n\tif (!response.ok) {\n\t\tthrow new Error('Failed to load Emojibase dataset.');\n\t}\n\n\tconst data = (await response.json()) as T;\n\n\ttry {\n\t\tstorage.setItem(cacheKey, JSON.stringify(data));\n\t} catch {\n\t\t// Do not allow quota errors to break the app\n\t}\n\n\treturn data;\n}\n","import { fetchFromCDN } from './fetchFromCDN';\nimport type { FetchFromCDNOptions, Locale, ShortcodePreset, ShortcodesDataset } from './types';\n\nconst ALIASES: Partial<Record<ShortcodePreset, string>> = {\n\tdiscord: 'joypixels',\n\tslack: 'iamcal',\n};\n\n/**\n * Fetches and returns localized shortcodes for the defined preset from our CDN.\n * The response is a mapping of emoji hexcodes to shortcodes (either a string or array of strings).\n * Uses `fetchFromCDN` under the hood.\n *\n * ```ts\n * import { fetchShortcodes } from 'emojibase';\n *\n * await fetchShortcodes('ja', 'cldr', { version: '2.1.3' });\n * ```\n */\nexport async function fetchShortcodes(\n\tlocale: Locale,\n\tpreset: ShortcodePreset,\n\toptions?: FetchFromCDNOptions,\n): Promise<ShortcodesDataset> {\n\treturn fetchFromCDN(`${locale}/shortcodes/${ALIASES[preset] ?? preset}.json`, options);\n}\n","import type { CompactEmoji, Emoji, EmojiLike, ShortcodesDataset } from './types';\n\n/**\n * Will join shortcodes from multiple shortcode datasets into a single emoji object\n * using its hexcode. Will remove duplicates in the process.\n */\nfunction joinShortcodesToEmoji(emoji: Emoji, shortcodeDatasets: ShortcodesDataset[]): Emoji;\n\nfunction joinShortcodesToEmoji(\n\temoji: CompactEmoji,\n\tshortcodeDatasets: ShortcodesDataset[],\n): CompactEmoji;\n\nfunction joinShortcodesToEmoji(\n\temoji: EmojiLike,\n\tshortcodeDatasets: ShortcodesDataset[],\n): EmojiLike {\n\tif (shortcodeDatasets.length === 0) {\n\t\treturn emoji;\n\t}\n\n\tconst list = new Set(emoji.shortcodes);\n\n\tshortcodeDatasets.forEach((dataset) => {\n\t\tconst shortcodes = dataset[emoji.hexcode];\n\n\t\tif (Array.isArray(shortcodes)) {\n\t\t\tshortcodes.forEach((code) => list.add(code));\n\t\t} else if (shortcodes) {\n\t\t\tlist.add(shortcodes);\n\t\t}\n\t});\n\n\t// eslint-disable-next-line no-param-reassign\n\temoji.shortcodes = [...list];\n\n\tif (emoji.skins) {\n\t\temoji.skins.forEach((skin) => {\n\t\t\tjoinShortcodesToEmoji(skin as Emoji, shortcodeDatasets);\n\t\t});\n\t}\n\n\treturn emoji;\n}\n\nexport { joinShortcodesToEmoji };\n","import { joinShortcodesToEmoji } from './joinShortcodesToEmoji';\nimport type { CompactEmoji, Emoji, EmojiLike, ShortcodesDataset } from './types';\n\n/**\n * By default, emoji skin modifications are nested under the base neutral skin tone emoji.\n * To flatten the data into a single dimension array, use the `flattenEmojiData` function.\n *\n * If `shortcodeDatasets` is defined, it will join the shortcodes to the emoji object using\n * `joinShortcodesToEmoji`.\n *\n * > Tags from the parent emoji will be passed down to the skin modifications.\n */\nfunction flattenEmojiData(data: Emoji[], shortcodeDatasets?: ShortcodesDataset[]): Emoji[];\n\nfunction flattenEmojiData(\n\tdata: CompactEmoji[],\n\tshortcodeDatasets?: ShortcodesDataset[],\n): CompactEmoji[];\n\nfunction flattenEmojiData(\n\tdata: EmojiLike[],\n\tshortcodeDatasets: ShortcodesDataset[] = [],\n): EmojiLike[] {\n\tconst emojis: Emoji[] = [];\n\n\t(data as Emoji[]).forEach((emoji) => {\n\t\tif (emoji.skins) {\n\t\t\t// Dont include nested skins array\n\t\t\tconst { skins, ...baseEmoji } = emoji;\n\n\t\t\temojis.push(joinShortcodesToEmoji(baseEmoji, shortcodeDatasets));\n\n\t\t\t// Push each skin modification into the root list\n\t\t\tskins.forEach((skin) => {\n\t\t\t\tconst skinEmoji = { ...skin };\n\n\t\t\t\t// Inherit tags from parent if they exist\n\t\t\t\tif (baseEmoji.tags) {\n\t\t\t\t\tskinEmoji.tags = [...baseEmoji.tags];\n\t\t\t\t}\n\n\t\t\t\temojis.push(joinShortcodesToEmoji(skinEmoji, shortcodeDatasets));\n\t\t\t});\n\t\t} else {\n\t\t\temojis.push(joinShortcodesToEmoji(emoji, shortcodeDatasets));\n\t\t}\n\t});\n\n\treturn emojis;\n}\n\nexport { flattenEmojiData };\n","import { joinShortcodesToEmoji } from './joinShortcodesToEmoji';\nimport type { CompactEmoji, Emoji, EmojiLike, ShortcodesDataset } from './types';\n\n/**\n * Like `joinShortcodesToEmoji` but joins shortcodes to a list of emoji objects.\n */\nfunction joinShortcodes(emojis: Emoji[], shortcodeDatasets: ShortcodesDataset[]): Emoji[];\n\nfunction joinShortcodes(\n\temojis: CompactEmoji[],\n\tshortcodeDatasets: ShortcodesDataset[],\n): CompactEmoji[];\n\nfunction joinShortcodes(emojis: EmojiLike[], shortcodeDatasets: ShortcodesDataset[]): EmojiLike[] {\n\tif (shortcodeDatasets.length === 0) {\n\t\treturn emojis;\n\t}\n\n\temojis.forEach((emoji) => {\n\t\tjoinShortcodesToEmoji(emoji as Emoji, shortcodeDatasets);\n\t});\n\n\treturn emojis;\n}\n\nexport { joinShortcodes };\n","import { fetchFromCDN } from './fetchFromCDN';\nimport { fetchShortcodes } from './fetchShortcodes';\nimport { flattenEmojiData } from './flattenEmojiData';\nimport { joinShortcodes } from './joinShortcodes';\nimport type {\n\tCompactEmoji,\n\tEmoji,\n\tFetchEmojisExpandedOptions,\n\tFetchEmojisOptions,\n\tFlatCompactEmoji,\n\tFlatEmoji,\n\tLocale,\n\tShortcodePreset,\n\tShortcodesDataset,\n} from './types';\n\n/**\n * Fetches and returns a localized list of emojis (and optional shortcodes) from our CDN.\n * Uses `fetchFromCDN` and `fetchShortcodes` under the hood.\n *\n * ```ts\n * import { fetchEmojis } from 'emojibase';\n *\n * await fetchEmojis('ja', {\n * \tcompact: true,\n * \tshortcodes: ['cldr'],\n * \tversion: '2.1.3',\n * });\n * ```\n *\n * It's also possible to load shortcodes from other languages by prefixing the shortcode preset with\n * the chosen locale. This is useful if you want to support English and Japanese in parallel, for\n * example.\n *\n * ```ts\n * await fetchEmojis('ja', {\n * \tshortcodes: ['cldr', 'en/cldr'],\n * });\n * ```\n */\n\nasync function fetchEmojis(\n\tlocale: Locale,\n\toptions: FetchEmojisOptions & { compact: true; flat: true },\n): Promise<FlatCompactEmoji[]>;\n\nasync function fetchEmojis(\n\tlocale: Locale,\n\toptions: FetchEmojisOptions & { compact: true; flat?: false },\n): Promise<CompactEmoji[]>;\n\nasync function fetchEmojis(\n\tlocale: Locale,\n\toptions: FetchEmojisOptions & { compact?: false; flat: true },\n): Promise<FlatEmoji[]>;\n\nasync function fetchEmojis(\n\tlocale: Locale,\n\toptions?: FetchEmojisOptions & { compact?: false; flat?: false },\n): Promise<Emoji[]>;\n\nasync function fetchEmojis(\n\tlocale: Locale,\n\toptions: FetchEmojisExpandedOptions = {},\n): Promise<unknown[]> {\n\tconst { compact = false, flat = false, shortcodes: presets = [], ...opts } = options;\n\tconst emojis = await fetchFromCDN<Emoji[]>(\n\t\t`${locale}/${compact ? 'compact' : 'data'}.json`,\n\t\topts,\n\t);\n\tlet shortcodes: ShortcodesDataset[] = [];\n\n\tif (presets.length > 0) {\n\t\tshortcodes = await Promise.all(\n\t\t\tpresets.map((preset) => {\n\t\t\t\tlet promise: Promise<ShortcodesDataset>;\n\n\t\t\t\tif (preset.includes('/')) {\n\t\t\t\t\tconst [customLocale, customPreset] = preset.split('/');\n\n\t\t\t\t\tpromise = fetchShortcodes(customLocale as Locale, customPreset as ShortcodePreset, opts);\n\t\t\t\t} else {\n\t\t\t\t\tpromise = fetchShortcodes(locale, preset as ShortcodePreset, opts);\n\t\t\t\t}\n\n\t\t\t\t// Ignore as the primary dataset should still load\n\t\t\t\treturn promise.catch(() => ({}));\n\t\t\t}),\n\t\t);\n\t}\n\n\treturn flat ? flattenEmojiData(emojis, shortcodes) : joinShortcodes(emojis, shortcodes);\n}\n\nexport { fetchEmojis };\n","import { fetchFromCDN } from './fetchFromCDN';\nimport type { FetchFromCDNOptions, Locale, MessagesDataset } from './types';\n\n/**\n * Fetches and returns localized messages for emoji related information like groups and sub-groups.\n * Uses `fetchFromCDN` under the hood.\n *\n * ```ts\n * import { fetchMessages } from 'emojibase';\n *\n * await fetchMessages('zh', { version: '2.1.3' });\n * ```\n */\nexport async function fetchMessages(\n\tlocale: Locale,\n\toptions?: FetchFromCDNOptions,\n): Promise<MessagesDataset> {\n\treturn fetchFromCDN(`${locale}/messages.json`, options);\n}\n","import type { CodePoint, Unicode } from './types';\n\n/**\n * This function will convert an array of numerical codepoints to a literal emoji Unicode character.\n *\n * ```ts\n * import { fromCodepointToUnicode } from 'emojibase';\n *\n * fromCodepointToUnicode([128104, 8205, 128105, 8205, 128103, 8205, 128102]); // 👨‍👩‍👧‍👦\n * ```\n */\nexport function fromCodepointToUnicode(codepoint: CodePoint[]): Unicode {\n\treturn String.fromCodePoint(...codepoint);\n}\n","import type { CodePoint, Hexcode } from './types';\n\n/**\n * This function will convert a hexadecimal codepoint to an array of numerical codepoints.\n * By default, it will split the hexcode using a dash, but can be customized with the 2nd argument.\n *\n * ```ts\n * import { fromHexcodeToCodepoint } from 'emojibase';\n *\n * fromHexcodeToCodepoint('270A-1F3FC'); // [9994, 127996]\n * fromHexcodeToCodepoint('270A 1F3FC', ' '); // [9994, 127996]\n * ```\n */\nexport function fromHexcodeToCodepoint(code: Hexcode, joiner: string = '-'): CodePoint[] {\n\treturn code.split(joiner).map((point) => Number.parseInt(point, 16));\n}\n","import { SEQUENCE_REMOVAL_PATTERN } from './constants';\nimport type { Hexcode, Unicode } from './types';\n\n/**\n * This function will convert a literal emoji Unicode character into a dash separated\n * hexadecimal codepoint. Unless `false` is passed as the 2nd argument, zero width\n * joiner's and variation selectors are removed.\n *\n * ```ts\n * import { fromUnicodeToHexcode } from 'emojibase';\n *\n * fromUnicodeToHexcode('👨‍👩‍👧‍👦'); // 1F468-1F469-1F467-1F466\n * fromUnicodeToHexcode('👨‍👩‍👧‍👦', false); // 1F468-200D-1F469-200D-1F467-200D-1F466\n * ```\n */\nexport function fromUnicodeToHexcode(unicode: Unicode, strip: boolean = true): Hexcode {\n\tconst hexcode: string[] = [];\n\n\t[...unicode].forEach((codepoint) => {\n\t\tlet hex = codepoint.codePointAt(0)?.toString(16).toUpperCase() ?? '';\n\n\t\twhile (hex.length < 4) {\n\t\t\thex = `0${hex}`;\n\t\t}\n\n\t\tif (!strip || (strip && !hex.match(SEQUENCE_REMOVAL_PATTERN))) {\n\t\t\thexcode.push(hex);\n\t\t}\n\t});\n\n\treturn hexcode.join('-');\n}\n","import type { Emoticon, PermutationOptions } from './types';\n\n/**\n * This function will generate multiple permutations of a base emoticon character.\n * The following permutations will occur:\n *\n * - `)` mouth will be replaced with `]` and `}`. The same applies to sad/frowning mouths.\n * - `/` mouth will be replaced with `\\`.\n * - `:` eyes will be replaced with `=`.\n * - Supports a `-` nose, by injecting between the eyes and mouth.\n * - Supports both uppercase and lowercase variants.\n *\n * ```ts\n * import { generateEmoticonPermutations } from 'emojibase';\n *\n * generateEmoticonPermutations(':)'); // =-), =-}, :-], =-], :-}, :-), =}, =], =), :}, :], :)\n * ```\n *\n * > The base emoticon must follow a set of naming guidelines to work properly.\n *\n * Furthermore, this function accepts an options object as the 2nd argument, as a means to customize\n * the output.\n *\n * - `isFace` (bool) - Toggles face permutations (mouth and eye variants). Defaults to `true`.\n * - `withNose` (bool) - Toggles nose inclusion. Defaults to `true`.\n *\n * ```ts\n * generateEmoticonPermutations(':)', { withNose: false }); // =}, =], =), :}, :], :)\n * generateEmoticonPermutations('\\\\m/', { isFace: false }); // \\m/, \\M/\n * ```\n */\nexport function generateEmoticonPermutations(\n\temoticon: Emoticon,\n\toptions: PermutationOptions = {},\n): Emoticon[] {\n\tconst { isFace = true, withNose = true } = options;\n\tconst list = [emoticon];\n\n\t// Uppercase variant\n\tif (emoticon.toUpperCase() !== emoticon) {\n\t\tlist.push(...generateEmoticonPermutations(emoticon.toUpperCase(), options));\n\t}\n\n\tif (isFace) {\n\t\t// Backwards slash mouth variant\n\t\tif (emoticon.includes('/')) {\n\t\t\tlist.push(...generateEmoticonPermutations(emoticon.replace('/', '\\\\'), options));\n\t\t}\n\n\t\t// Bracket and curly brace mouth variants\n\t\tif (emoticon.includes(')')) {\n\t\t\tlist.push(\n\t\t\t\t...generateEmoticonPermutations(emoticon.replace(')', ']'), options),\n\t\t\t\t...generateEmoticonPermutations(emoticon.replace(')', '}'), options),\n\t\t\t);\n\t\t}\n\n\t\tif (emoticon.includes('(')) {\n\t\t\tlist.push(\n\t\t\t\t...generateEmoticonPermutations(emoticon.replace('(', '['), options),\n\t\t\t\t...generateEmoticonPermutations(emoticon.replace('(', '{'), options),\n\t\t\t);\n\t\t}\n\n\t\t// Eye variant\n\t\tif (emoticon.includes(':')) {\n\t\t\tlist.push(...generateEmoticonPermutations(emoticon.replace(':', '='), options));\n\t\t}\n\n\t\t// Nose variant for ALL\n\t\tif (withNose) {\n\t\t\tlist.forEach((emo) => {\n\t\t\t\tif (!emo.includes('-')) {\n\t\t\t\t\tlist.push(`${emo.slice(0, -1)}-${emo.slice(-1)}`);\n\t\t\t\t}\n\t\t\t});\n\t\t}\n\t}\n\n\t// Sort from longest to shortest\n\tlist.sort((a, b) => b.length - a.length);\n\n\treturn [...new Set(list)];\n}\n","import { SEQUENCE_REMOVAL_PATTERN } from './constants';\nimport type { Hexcode } from './types';\n\nconst STRIP_PATTERN = new RegExp(`(-| )?(${SEQUENCE_REMOVAL_PATTERN.source})`, 'g');\n\n/**\n * This function will strip zero width joiners (`200D`) and variation selectors\n * (`FE0E`, `FE0F`) from a hexadecimal codepoint.\n *\n * ```ts\n * import { stripHexcode } from 'emojibase';\n *\n * stripHexcode('1F468-200D-2695-FE0F'); // 1F468-2695\n * ```\n */\nexport function stripHexcode(hexcode: Hexcode): Hexcode {\n\treturn hexcode.replace(STRIP_PATTERN, '');\n}\n",null,null,null,null,null,null,null,null,"'use strict';\n\n/** @type {import('.')} */\nvar $defineProperty = Object.defineProperty || false;\nif ($defineProperty) {\n\ttry {\n\t\t$defineProperty({}, 'a', { value: 1 });\n\t} catch (e) {\n\t\t// IE 8 has a broken defineProperty\n\t\t$defineProperty = false;\n\t}\n}\n\nmodule.exports = $defineProperty;\n","'use strict';\n\n/** @type {import('./eval')} */\nmodule.exports = EvalError;\n","'use strict';\n\n/** @type {import('.')} */\nmodule.exports = Error;\n","'use strict';\n\n/** @type {import('./range')} */\nmodule.exports = RangeError;\n","'use strict';\n\n/** @type {import('./ref')} */\nmodule.exports = ReferenceError;\n","'use strict';\n\n/** @type {import('./syntax')} */\nmodule.exports = SyntaxError;\n","'use strict';\n\n/** @type {import('./type')} */\nmodule.exports = TypeError;\n","'use strict';\n\n/** @type {import('./uri')} */\nmodule.exports = URIError;\n","'use strict';\n\n/** @type {import('.')} */\nmodule.exports = Object;\n","/*!\n * escape-html\n * Copyright(c) 2012-2013 TJ Holowaychuk\n * Copyright(c) 2015 Andreas Lubbe\n * Copyright(c) 2015 Tiancheng \"Timothy\" Gu\n * MIT Licensed\n */\n\n'use strict';\n\n/**\n * Module variables.\n * @private\n */\n\nvar matchHtmlRegExp = /[\"'&<>]/;\n\n/**\n * Module exports.\n * @public\n */\n\nmodule.exports = escapeHtml;\n\n/**\n * Escape special characters in the given string of html.\n *\n * @param  {string} string The string to escape for inserting into HTML\n * @return {string}\n * @public\n */\n\nfunction escapeHtml(string) {\n  var str = '' + string;\n  var match = matchHtmlRegExp.exec(str);\n\n  if (!match) {\n    return str;\n  }\n\n  var escape;\n  var html = '';\n  var index = 0;\n  var lastIndex = 0;\n\n  for (index = match.index; index < str.length; index++) {\n    switch (str.charCodeAt(index)) {\n      case 34: // \"\n        escape = '&quot;';\n        break;\n      case 38: // &\n        escape = '&amp;';\n        break;\n      case 39: // '\n        escape = '&#39;';\n        break;\n      case 60: // <\n        escape = '&lt;';\n        break;\n      case 62: // >\n        escape = '&gt;';\n        break;\n      default:\n        continue;\n    }\n\n    if (lastIndex !== index) {\n      html += str.substring(lastIndex, index);\n    }\n\n    lastIndex = index + 1;\n    html += escape;\n  }\n\n  return lastIndex !== index\n    ? html + str.substring(lastIndex, index)\n    : html;\n}\n","'use strict';\n\nmodule.exports = string => {\n\tif (typeof string !== 'string') {\n\t\tthrow new TypeError('Expected a string');\n\t}\n\n\t// Escape characters with special meaning either inside or outside character sets.\n\t// Use a simple backslash escape when it’s always valid, and a \\unnnn escape when the simpler form would be disallowed by Unicode patterns’ stricter grammar.\n\treturn string\n\t\t.replace(/[|\\\\{}()[\\]^$+*?.]/g, '\\\\$&')\n\t\t.replace(/-/g, '\\\\x2d');\n};\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\nvar R = typeof Reflect === 'object' ? Reflect : null\nvar ReflectApply = R && typeof R.apply === 'function'\n  ? R.apply\n  : function ReflectApply(target, receiver, args) {\n    return Function.prototype.apply.call(target, receiver, args);\n  }\n\nvar ReflectOwnKeys\nif (R && typeof R.ownKeys === 'function') {\n  ReflectOwnKeys = R.ownKeys\n} else if (Object.getOwnPropertySymbols) {\n  ReflectOwnKeys = function ReflectOwnKeys(target) {\n    return Object.getOwnPropertyNames(target)\n      .concat(Object.getOwnPropertySymbols(target));\n  };\n} else {\n  ReflectOwnKeys = function ReflectOwnKeys(target) {\n    return Object.getOwnPropertyNames(target);\n  };\n}\n\nfunction ProcessEmitWarning(warning) {\n  if (console && console.warn) console.warn(warning);\n}\n\nvar NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {\n  return value !== value;\n}\n\nfunction EventEmitter() {\n  EventEmitter.init.call(this);\n}\nmodule.exports = EventEmitter;\nmodule.exports.once = once;\n\n// Backwards-compat with node 0.10.x\nEventEmitter.EventEmitter = EventEmitter;\n\nEventEmitter.prototype._events = undefined;\nEventEmitter.prototype._eventsCount = 0;\nEventEmitter.prototype._maxListeners = undefined;\n\n// By default EventEmitters will print a warning if more than 10 listeners are\n// added to it. This is a useful default which helps finding memory leaks.\nvar defaultMaxListeners = 10;\n\nfunction checkListener(listener) {\n  if (typeof listener !== 'function') {\n    throw new TypeError('The \"listener\" argument must be of type Function. Received type ' + typeof listener);\n  }\n}\n\nObject.defineProperty(EventEmitter, 'defaultMaxListeners', {\n  enumerable: true,\n  get: function() {\n    return defaultMaxListeners;\n  },\n  set: function(arg) {\n    if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {\n      throw new RangeError('The value of \"defaultMaxListeners\" is out of range. It must be a non-negative number. Received ' + arg + '.');\n    }\n    defaultMaxListeners = arg;\n  }\n});\n\nEventEmitter.init = function() {\n\n  if (this._events === undefined ||\n      this._events === Object.getPrototypeOf(this)._events) {\n    this._events = Object.create(null);\n    this._eventsCount = 0;\n  }\n\n  this._maxListeners = this._maxListeners || undefined;\n};\n\n// Obviously not all Emitters should be limited to 10. This function allows\n// that to be increased. Set to zero for unlimited.\nEventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {\n  if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {\n    throw new RangeError('The value of \"n\" is out of range. It must be a non-negative number. Received ' + n + '.');\n  }\n  this._maxListeners = n;\n  return this;\n};\n\nfunction _getMaxListeners(that) {\n  if (that._maxListeners === undefined)\n    return EventEmitter.defaultMaxListeners;\n  return that._maxListeners;\n}\n\nEventEmitter.prototype.getMaxListeners = function getMaxListeners() {\n  return _getMaxListeners(this);\n};\n\nEventEmitter.prototype.emit = function emit(type) {\n  var args = [];\n  for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);\n  var doError = (type === 'error');\n\n  var events = this._events;\n  if (events !== undefined)\n    doError = (doError && events.error === undefined);\n  else if (!doError)\n    return false;\n\n  // If there is no 'error' event listener then throw.\n  if (doError) {\n    var er;\n    if (args.length > 0)\n      er = args[0];\n    if (er instanceof Error) {\n      // Note: The comments on the `throw` lines are intentional, they show\n      // up in Node's output if this results in an unhandled exception.\n      throw er; // Unhandled 'error' event\n    }\n    // At least give some kind of context to the user\n    var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));\n    err.context = er;\n    throw err; // Unhandled 'error' event\n  }\n\n  var handler = events[type];\n\n  if (handler === undefined)\n    return false;\n\n  if (typeof handler === 'function') {\n    ReflectApply(handler, this, args);\n  } else {\n    var len = handler.length;\n    var listeners = arrayClone(handler, len);\n    for (var i = 0; i < len; ++i)\n      ReflectApply(listeners[i], this, args);\n  }\n\n  return true;\n};\n\nfunction _addListener(target, type, listener, prepend) {\n  var m;\n  var events;\n  var existing;\n\n  checkListener(listener);\n\n  events = target._events;\n  if (events === undefined) {\n    events = target._events = Object.create(null);\n    target._eventsCount = 0;\n  } else {\n    // To avoid recursion in the case that type === \"newListener\"! Before\n    // adding it to the listeners, first emit \"newListener\".\n    if (events.newListener !== undefined) {\n      target.emit('newListener', type,\n                  listener.listener ? listener.listener : listener);\n\n      // Re-assign `events` because a newListener handler could have caused the\n      // this._events to be assigned to a new object\n      events = target._events;\n    }\n    existing = events[type];\n  }\n\n  if (existing === undefined) {\n    // Optimize the case of one listener. Don't need the extra array object.\n    existing = events[type] = listener;\n    ++target._eventsCount;\n  } else {\n    if (typeof existing === 'function') {\n      // Adding the second element, need to change to array.\n      existing = events[type] =\n        prepend ? [listener, existing] : [existing, listener];\n      // If we've already got an array, just append.\n    } else if (prepend) {\n      existing.unshift(listener);\n    } else {\n      existing.push(listener);\n    }\n\n    // Check for listener leak\n    m = _getMaxListeners(target);\n    if (m > 0 && existing.length > m && !existing.warned) {\n      existing.warned = true;\n      // No error code for this since it is a Warning\n      // eslint-disable-next-line no-restricted-syntax\n      var w = new Error('Possible EventEmitter memory leak detected. ' +\n                          existing.length + ' ' + String(type) + ' listeners ' +\n                          'added. Use emitter.setMaxListeners() to ' +\n                          'increase limit');\n      w.name = 'MaxListenersExceededWarning';\n      w.emitter = target;\n      w.type = type;\n      w.count = existing.length;\n      ProcessEmitWarning(w);\n    }\n  }\n\n  return target;\n}\n\nEventEmitter.prototype.addListener = function addListener(type, listener) {\n  return _addListener(this, type, listener, false);\n};\n\nEventEmitter.prototype.on = EventEmitter.prototype.addListener;\n\nEventEmitter.prototype.prependListener =\n    function prependListener(type, listener) {\n      return _addListener(this, type, listener, true);\n    };\n\nfunction onceWrapper() {\n  if (!this.fired) {\n    this.target.removeListener(this.type, this.wrapFn);\n    this.fired = true;\n    if (arguments.length === 0)\n      return this.listener.call(this.target);\n    return this.listener.apply(this.target, arguments);\n  }\n}\n\nfunction _onceWrap(target, type, listener) {\n  var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };\n  var wrapped = onceWrapper.bind(state);\n  wrapped.listener = listener;\n  state.wrapFn = wrapped;\n  return wrapped;\n}\n\nEventEmitter.prototype.once = function once(type, listener) {\n  checkListener(listener);\n  this.on(type, _onceWrap(this, type, listener));\n  return this;\n};\n\nEventEmitter.prototype.prependOnceListener =\n    function prependOnceListener(type, listener) {\n      checkListener(listener);\n      this.prependListener(type, _onceWrap(this, type, listener));\n      return this;\n    };\n\n// Emits a 'removeListener' event if and only if the listener was removed.\nEventEmitter.prototype.removeListener =\n    function removeListener(type, listener) {\n      var list, events, position, i, originalListener;\n\n      checkListener(listener);\n\n      events = this._events;\n      if (events === undefined)\n        return this;\n\n      list = events[type];\n      if (list === undefined)\n        return this;\n\n      if (list === listener || list.listener === listener) {\n        if (--this._eventsCount === 0)\n          this._events = Object.create(null);\n        else {\n          delete events[type];\n          if (events.removeListener)\n            this.emit('removeListener', type, list.listener || listener);\n        }\n      } else if (typeof list !== 'function') {\n        position = -1;\n\n        for (i = list.length - 1; i >= 0; i--) {\n          if (list[i] === listener || list[i].listener === listener) {\n            originalListener = list[i].listener;\n            position = i;\n            break;\n          }\n        }\n\n        if (position < 0)\n          return this;\n\n        if (position === 0)\n          list.shift();\n        else {\n          spliceOne(list, position);\n        }\n\n        if (list.length === 1)\n          events[type] = list[0];\n\n        if (events.removeListener !== undefined)\n          this.emit('removeListener', type, originalListener || listener);\n      }\n\n      return this;\n    };\n\nEventEmitter.prototype.off = EventEmitter.prototype.removeListener;\n\nEventEmitter.prototype.removeAllListeners =\n    function removeAllListeners(type) {\n      var listeners, events, i;\n\n      events = this._events;\n      if (events === undefined)\n        return this;\n\n      // not listening for removeListener, no need to emit\n      if (events.removeListener === undefined) {\n        if (arguments.length === 0) {\n          this._events = Object.create(null);\n          this._eventsCount = 0;\n        } else if (events[type] !== undefined) {\n          if (--this._eventsCount === 0)\n            this._events = Object.create(null);\n          else\n            delete events[type];\n        }\n        return this;\n      }\n\n      // emit removeListener for all listeners on all events\n      if (arguments.length === 0) {\n        var keys = Object.keys(events);\n        var key;\n        for (i = 0; i < keys.length; ++i) {\n          key = keys[i];\n          if (key === 'removeListener') continue;\n          this.removeAllListeners(key);\n        }\n        this.removeAllListeners('removeListener');\n        this._events = Object.create(null);\n        this._eventsCount = 0;\n        return this;\n      }\n\n      listeners = events[type];\n\n      if (typeof listeners === 'function') {\n        this.removeListener(type, listeners);\n      } else if (listeners !== undefined) {\n        // LIFO order\n        for (i = listeners.length - 1; i >= 0; i--) {\n          this.removeListener(type, listeners[i]);\n        }\n      }\n\n      return this;\n    };\n\nfunction _listeners(target, type, unwrap) {\n  var events = target._events;\n\n  if (events === undefined)\n    return [];\n\n  var evlistener = events[type];\n  if (evlistener === undefined)\n    return [];\n\n  if (typeof evlistener === 'function')\n    return unwrap ? [evlistener.listener || evlistener] : [evlistener];\n\n  return unwrap ?\n    unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);\n}\n\nEventEmitter.prototype.listeners = function listeners(type) {\n  return _listeners(this, type, true);\n};\n\nEventEmitter.prototype.rawListeners = function rawListeners(type) {\n  return _listeners(this, type, false);\n};\n\nEventEmitter.listenerCount = function(emitter, type) {\n  if (typeof emitter.listenerCount === 'function') {\n    return emitter.listenerCount(type);\n  } else {\n    return listenerCount.call(emitter, type);\n  }\n};\n\nEventEmitter.prototype.listenerCount = listenerCount;\nfunction listenerCount(type) {\n  var events = this._events;\n\n  if (events !== undefined) {\n    var evlistener = events[type];\n\n    if (typeof evlistener === 'function') {\n      return 1;\n    } else if (evlistener !== undefined) {\n      return evlistener.length;\n    }\n  }\n\n  return 0;\n}\n\nEventEmitter.prototype.eventNames = function eventNames() {\n  return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];\n};\n\nfunction arrayClone(arr, n) {\n  var copy = new Array(n);\n  for (var i = 0; i < n; ++i)\n    copy[i] = arr[i];\n  return copy;\n}\n\nfunction spliceOne(list, index) {\n  for (; index + 1 < list.length; index++)\n    list[index] = list[index + 1];\n  list.pop();\n}\n\nfunction unwrapListeners(arr) {\n  var ret = new Array(arr.length);\n  for (var i = 0; i < ret.length; ++i) {\n    ret[i] = arr[i].listener || arr[i];\n  }\n  return ret;\n}\n\nfunction once(emitter, name) {\n  return new Promise(function (resolve, reject) {\n    function errorListener(err) {\n      emitter.removeListener(name, resolver);\n      reject(err);\n    }\n\n    function resolver() {\n      if (typeof emitter.removeListener === 'function') {\n        emitter.removeListener('error', errorListener);\n      }\n      resolve([].slice.call(arguments));\n    };\n\n    eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });\n    if (name !== 'error') {\n      addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });\n    }\n  });\n}\n\nfunction addErrorHandlerIfEventEmitter(emitter, handler, flags) {\n  if (typeof emitter.on === 'function') {\n    eventTargetAgnosticAddListener(emitter, 'error', handler, flags);\n  }\n}\n\nfunction eventTargetAgnosticAddListener(emitter, name, listener, flags) {\n  if (typeof emitter.on === 'function') {\n    if (flags.once) {\n      emitter.once(name, listener);\n    } else {\n      emitter.on(name, listener);\n    }\n  } else if (typeof emitter.addEventListener === 'function') {\n    // EventTarget does not have `error` event semantics like Node\n    // EventEmitters, we do not listen for `error` events here.\n    emitter.addEventListener(name, function wrapListener(arg) {\n      // IE does not have builtin `{ once: true }` support so we\n      // have to do it manually.\n      if (flags.once) {\n        emitter.removeEventListener(name, wrapListener);\n      }\n      listener(arg);\n    });\n  } else {\n    throw new TypeError('The \"emitter\" argument must be of type EventEmitter. Received type ' + typeof emitter);\n  }\n}\n","'use strict';\n\nvar ap      = Array.prototype;\nvar concat  = ap.concat;\nvar slice   = ap.slice;\nvar indexOf = require('indexof');\n\nfunction except(object) {\n  var result = {};\n  var keys = concat.apply(ap, slice.call(arguments, 1));\n\n  for (var key in object) {\n    if (indexOf(keys, key) === -1) {\n      result[key] = object[key];\n    }\n  }\n\n  return result;\n}\n\nmodule.exports = except;\n","'use strict';\n\nvar hasOwn = Object.prototype.hasOwnProperty;\nvar toStr = Object.prototype.toString;\nvar defineProperty = Object.defineProperty;\nvar gOPD = Object.getOwnPropertyDescriptor;\n\nvar isArray = function isArray(arr) {\n\tif (typeof Array.isArray === 'function') {\n\t\treturn Array.isArray(arr);\n\t}\n\n\treturn toStr.call(arr) === '[object Array]';\n};\n\nvar isPlainObject = function isPlainObject(obj) {\n\tif (!obj || toStr.call(obj) !== '[object Object]') {\n\t\treturn false;\n\t}\n\n\tvar hasOwnConstructor = hasOwn.call(obj, 'constructor');\n\tvar hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, 'isPrototypeOf');\n\t// Not own constructor property must be Object\n\tif (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) {\n\t\treturn false;\n\t}\n\n\t// Own properties are enumerated firstly, so to speed up,\n\t// if last one is own, then all properties are own.\n\tvar key;\n\tfor (key in obj) { /**/ }\n\n\treturn typeof key === 'undefined' || hasOwn.call(obj, key);\n};\n\n// If name is '__proto__', and Object.defineProperty is available, define __proto__ as an own property on target\nvar setProperty = function setProperty(target, options) {\n\tif (defineProperty && options.name === '__proto__') {\n\t\tdefineProperty(target, options.name, {\n\t\t\tenumerable: true,\n\t\t\tconfigurable: true,\n\t\t\tvalue: options.newValue,\n\t\t\twritable: true\n\t\t});\n\t} else {\n\t\ttarget[options.name] = options.newValue;\n\t}\n};\n\n// Return undefined instead of __proto__ if '__proto__' is not an own property\nvar getProperty = function getProperty(obj, name) {\n\tif (name === '__proto__') {\n\t\tif (!hasOwn.call(obj, name)) {\n\t\t\treturn void 0;\n\t\t} else if (gOPD) {\n\t\t\t// In early versions of node, obj['__proto__'] is buggy when obj has\n\t\t\t// __proto__ as an own property. Object.getOwnPropertyDescriptor() works.\n\t\t\treturn gOPD(obj, name).value;\n\t\t}\n\t}\n\n\treturn obj[name];\n};\n\nmodule.exports = function extend() {\n\tvar options, name, src, copy, copyIsArray, clone;\n\tvar target = arguments[0];\n\tvar i = 1;\n\tvar length = arguments.length;\n\tvar deep = false;\n\n\t// Handle a deep copy situation\n\tif (typeof target === 'boolean') {\n\t\tdeep = target;\n\t\ttarget = arguments[1] || {};\n\t\t// skip the boolean and the target\n\t\ti = 2;\n\t}\n\tif (target == null || (typeof target !== 'object' && typeof target !== 'function')) {\n\t\ttarget = {};\n\t}\n\n\tfor (; i < length; ++i) {\n\t\toptions = arguments[i];\n\t\t// Only deal with non-null/undefined values\n\t\tif (options != null) {\n\t\t\t// Extend the base object\n\t\t\tfor (name in options) {\n\t\t\t\tsrc = getProperty(target, name);\n\t\t\t\tcopy = getProperty(options, name);\n\n\t\t\t\t// Prevent never-ending loop\n\t\t\t\tif (target !== copy) {\n\t\t\t\t\t// Recurse if we're merging plain objects or arrays\n\t\t\t\t\tif (deep && copy && (isPlainObject(copy) || (copyIsArray = isArray(copy)))) {\n\t\t\t\t\t\tif (copyIsArray) {\n\t\t\t\t\t\t\tcopyIsArray = false;\n\t\t\t\t\t\t\tclone = src && isArray(src) ? src : [];\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tclone = src && isPlainObject(src) ? src : {};\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Never move original objects, clone them\n\t\t\t\t\t\tsetProperty(target, { name: name, newValue: extend(deep, clone, copy) });\n\n\t\t\t\t\t// Don't bring in undefined values\n\t\t\t\t\t} else if (typeof copy !== 'undefined') {\n\t\t\t\t\t\tsetProperty(target, { name: name, newValue: copy });\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// Return the modified object\n\treturn target;\n};\n","/**\n * filesize\n *\n * @copyright 2024 Jason Mulligan <jason.mulligan@avoidwork.com>\n * @license BSD-3-Clause\n * @version 10.1.6\n */\nconst ARRAY = \"array\";\r\nconst BIT = \"bit\";\r\nconst BITS = \"bits\";\r\nconst BYTE = \"byte\";\r\nconst BYTES = \"bytes\";\r\nconst EMPTY = \"\";\r\nconst EXPONENT = \"exponent\";\r\nconst FUNCTION = \"function\";\r\nconst IEC = \"iec\";\r\nconst INVALID_NUMBER = \"Invalid number\";\r\nconst INVALID_ROUND = \"Invalid rounding method\";\r\nconst JEDEC = \"jedec\";\r\nconst OBJECT = \"object\";\r\nconst PERIOD = \".\";\r\nconst ROUND = \"round\";\r\nconst S = \"s\";\r\nconst SI = \"si\";\r\nconst SI_KBIT = \"kbit\";\r\nconst SI_KBYTE = \"kB\";\r\nconst SPACE = \" \";\r\nconst STRING = \"string\";\r\nconst ZERO = \"0\";\r\nconst STRINGS = {\r\n\tsymbol: {\r\n\t\tiec: {\r\n\t\t\tbits: [\"bit\", \"Kibit\", \"Mibit\", \"Gibit\", \"Tibit\", \"Pibit\", \"Eibit\", \"Zibit\", \"Yibit\"],\r\n\t\t\tbytes: [\"B\", \"KiB\", \"MiB\", \"GiB\", \"TiB\", \"PiB\", \"EiB\", \"ZiB\", \"YiB\"]\r\n\t\t},\r\n\t\tjedec: {\r\n\t\t\tbits: [\"bit\", \"Kbit\", \"Mbit\", \"Gbit\", \"Tbit\", \"Pbit\", \"Ebit\", \"Zbit\", \"Ybit\"],\r\n\t\t\tbytes: [\"B\", \"KB\", \"MB\", \"GB\", \"TB\", \"PB\", \"EB\", \"ZB\", \"YB\"]\r\n\t\t}\r\n\t},\r\n\tfullform: {\r\n\t\tiec: [\"\", \"kibi\", \"mebi\", \"gibi\", \"tebi\", \"pebi\", \"exbi\", \"zebi\", \"yobi\"],\r\n\t\tjedec: [\"\", \"kilo\", \"mega\", \"giga\", \"tera\", \"peta\", \"exa\", \"zetta\", \"yotta\"]\r\n\t}\r\n};function filesize (arg, {\r\n\tbits = false,\r\n\tpad = false,\r\n\tbase = -1,\r\n\tround = 2,\r\n\tlocale = EMPTY,\r\n\tlocaleOptions = {},\r\n\tseparator = EMPTY,\r\n\tspacer = SPACE,\r\n\tsymbols = {},\r\n\tstandard = EMPTY,\r\n\toutput = STRING,\r\n\tfullform = false,\r\n\tfullforms = [],\r\n\texponent = -1,\r\n\troundingMethod = ROUND,\r\n\tprecision = 0\r\n} = {}) {\r\n\tlet e = exponent,\r\n\t\tnum = Number(arg),\r\n\t\tresult = [],\r\n\t\tval = 0,\r\n\t\tu = EMPTY;\r\n\r\n\t// Sync base & standard\r\n\tif (standard === SI) {\r\n\t\tbase = 10;\r\n\t\tstandard = JEDEC;\r\n\t} else if (standard === IEC || standard === JEDEC) {\r\n\t\tbase = 2;\r\n\t} else if (base === 2) {\r\n\t\tstandard = IEC;\r\n\t} else {\r\n\t\tbase = 10;\r\n\t\tstandard = JEDEC;\r\n\t}\r\n\r\n\tconst ceil = base === 10 ? 1000 : 1024,\r\n\t\tfull = fullform === true,\r\n\t\tneg = num < 0,\r\n\t\troundingFunc = Math[roundingMethod];\r\n\r\n\tif (typeof arg !== \"bigint\" && isNaN(arg)) {\r\n\t\tthrow new TypeError(INVALID_NUMBER);\r\n\t}\r\n\r\n\tif (typeof roundingFunc !== FUNCTION) {\r\n\t\tthrow new TypeError(INVALID_ROUND);\r\n\t}\r\n\r\n\t// Flipping a negative number to determine the size\r\n\tif (neg) {\r\n\t\tnum = -num;\r\n\t}\r\n\r\n\t// Determining the exponent\r\n\tif (e === -1 || isNaN(e)) {\r\n\t\te = Math.floor(Math.log(num) / Math.log(ceil));\r\n\r\n\t\tif (e < 0) {\r\n\t\t\te = 0;\r\n\t\t}\r\n\t}\r\n\r\n\t// Exceeding supported length, time to reduce & multiply\r\n\tif (e > 8) {\r\n\t\tif (precision > 0) {\r\n\t\t\tprecision += 8 - e;\r\n\t\t}\r\n\r\n\t\te = 8;\r\n\t}\r\n\r\n\tif (output === EXPONENT) {\r\n\t\treturn e;\r\n\t}\r\n\r\n\t// Zero is now a special case because bytes divide by 1\r\n\tif (num === 0) {\r\n\t\tresult[0] = 0;\r\n\t\tu = result[1] = STRINGS.symbol[standard][bits ? BITS : BYTES][e];\r\n\t} else {\r\n\t\tval = num / (base === 2 ? Math.pow(2, e * 10) : Math.pow(1000, e));\r\n\r\n\t\tif (bits) {\r\n\t\t\tval = val * 8;\r\n\r\n\t\t\tif (val >= ceil && e < 8) {\r\n\t\t\t\tval = val / ceil;\r\n\t\t\t\te++;\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\tconst p = Math.pow(10, e > 0 ? round : 0);\r\n\t\tresult[0] = roundingFunc(val * p) / p;\r\n\r\n\t\tif (result[0] === ceil && e < 8 && exponent === -1) {\r\n\t\t\tresult[0] = 1;\r\n\t\t\te++;\r\n\t\t}\r\n\r\n\t\tu = result[1] = base === 10 && e === 1 ? bits ? SI_KBIT : SI_KBYTE : STRINGS.symbol[standard][bits ? BITS : BYTES][e];\r\n\t}\r\n\r\n\t// Decorating a 'diff'\r\n\tif (neg) {\r\n\t\tresult[0] = -result[0];\r\n\t}\r\n\r\n\t// Setting optional precision\r\n\tif (precision > 0) {\r\n\t\tresult[0] = result[0].toPrecision(precision);\r\n\t}\r\n\r\n\t// Applying custom symbol\r\n\tresult[1] = symbols[result[1]] || result[1];\r\n\r\n\tif (locale === true) {\r\n\t\tresult[0] = result[0].toLocaleString();\r\n\t} else if (locale.length > 0) {\r\n\t\tresult[0] = result[0].toLocaleString(locale, localeOptions);\r\n\t} else if (separator.length > 0) {\r\n\t\tresult[0] = result[0].toString().replace(PERIOD, separator);\r\n\t}\r\n\r\n\tif (pad && round > 0) {\r\n\t\tconst i =  result[0].toString(),\r\n\t\t\tx = separator || ((i.match(/(\\D)/g) || []).pop() || PERIOD),\r\n\t\t\ttmp = i.toString().split(x),\r\n\t\t\ts = tmp[1] || EMPTY,\r\n\t\t\tl = s.length,\r\n\t\t\tn = round - l;\r\n\r\n\t\tresult[0] = `${tmp[0]}${x}${s.padEnd(l + n, ZERO)}`;\r\n\t}\r\n\r\n\tif (full) {\r\n\t\tresult[1] = fullforms[e] ? fullforms[e] : STRINGS.fullform[standard][e] + (bits ? BIT : BYTE) + (result[0] === 1 ? EMPTY : S);\r\n\t}\r\n\r\n\t// Returning Array, Object, or String (default)\r\n\treturn output === ARRAY ? result : output === OBJECT ? {\r\n\t\tvalue: result[0],\r\n\t\tsymbol: result[1],\r\n\t\texponent: e,\r\n\t\tunit: u\r\n\t} : result.join(spacer);\r\n}\r\n\r\n// Partial application for functional programming\r\nfunction partial ({\r\n\tbits = false,\r\n\tpad = false,\r\n\tbase = -1,\r\n\tround = 2,\r\n\tlocale = EMPTY,\r\n\tlocaleOptions = {},\r\n\tseparator = EMPTY,\r\n\tspacer = SPACE,\r\n\tsymbols = {},\r\n\tstandard = EMPTY,\r\n\toutput = STRING,\r\n\tfullform = false,\r\n\tfullforms = [],\r\n\texponent = -1,\r\n\troundingMethod = ROUND,\r\n\tprecision = 0\r\n} = {}) {\r\n\treturn arg => filesize(arg, {\r\n\t\tbits,\r\n\t\tpad,\r\n\t\tbase,\r\n\t\tround,\r\n\t\tlocale,\r\n\t\tlocaleOptions,\r\n\t\tseparator,\r\n\t\tspacer,\r\n\t\tsymbols,\r\n\t\tstandard,\r\n\t\toutput,\r\n\t\tfullform,\r\n\t\tfullforms,\r\n\t\texponent,\r\n\t\troundingMethod,\r\n\t\tprecision\r\n\t});\r\n}export{filesize,partial};","'use strict';\n\nvar isCallable = require('is-callable');\n\nvar toStr = Object.prototype.toString;\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n\nvar forEachArray = function forEachArray(array, iterator, receiver) {\n    for (var i = 0, len = array.length; i < len; i++) {\n        if (hasOwnProperty.call(array, i)) {\n            if (receiver == null) {\n                iterator(array[i], i, array);\n            } else {\n                iterator.call(receiver, array[i], i, array);\n            }\n        }\n    }\n};\n\nvar forEachString = function forEachString(string, iterator, receiver) {\n    for (var i = 0, len = string.length; i < len; i++) {\n        // no such thing as a sparse string.\n        if (receiver == null) {\n            iterator(string.charAt(i), i, string);\n        } else {\n            iterator.call(receiver, string.charAt(i), i, string);\n        }\n    }\n};\n\nvar forEachObject = function forEachObject(object, iterator, receiver) {\n    for (var k in object) {\n        if (hasOwnProperty.call(object, k)) {\n            if (receiver == null) {\n                iterator(object[k], k, object);\n            } else {\n                iterator.call(receiver, object[k], k, object);\n            }\n        }\n    }\n};\n\nvar forEach = function forEach(list, iterator, thisArg) {\n    if (!isCallable(iterator)) {\n        throw new TypeError('iterator must be a function');\n    }\n\n    var receiver;\n    if (arguments.length >= 3) {\n        receiver = thisArg;\n    }\n\n    if (toStr.call(list) === '[object Array]') {\n        forEachArray(list, iterator, receiver);\n    } else if (typeof list === 'string') {\n        forEachString(list, iterator, receiver);\n    } else {\n        forEachObject(list, iterator, receiver);\n    }\n};\n\nmodule.exports = forEach;\n","'use strict';\n\n/* eslint no-invalid-this: 1 */\n\nvar ERROR_MESSAGE = 'Function.prototype.bind called on incompatible ';\nvar toStr = Object.prototype.toString;\nvar max = Math.max;\nvar funcType = '[object Function]';\n\nvar concatty = function concatty(a, b) {\n    var arr = [];\n\n    for (var i = 0; i < a.length; i += 1) {\n        arr[i] = a[i];\n    }\n    for (var j = 0; j < b.length; j += 1) {\n        arr[j + a.length] = b[j];\n    }\n\n    return arr;\n};\n\nvar slicy = function slicy(arrLike, offset) {\n    var arr = [];\n    for (var i = offset || 0, j = 0; i < arrLike.length; i += 1, j += 1) {\n        arr[j] = arrLike[i];\n    }\n    return arr;\n};\n\nvar joiny = function (arr, joiner) {\n    var str = '';\n    for (var i = 0; i < arr.length; i += 1) {\n        str += arr[i];\n        if (i + 1 < arr.length) {\n            str += joiner;\n        }\n    }\n    return str;\n};\n\nmodule.exports = function bind(that) {\n    var target = this;\n    if (typeof target !== 'function' || toStr.apply(target) !== funcType) {\n        throw new TypeError(ERROR_MESSAGE + target);\n    }\n    var args = slicy(arguments, 1);\n\n    var bound;\n    var binder = function () {\n        if (this instanceof bound) {\n            var result = target.apply(\n                this,\n                concatty(args, arguments)\n            );\n            if (Object(result) === result) {\n                return result;\n            }\n            return this;\n        }\n        return target.apply(\n            that,\n            concatty(args, arguments)\n        );\n\n    };\n\n    var boundLength = max(0, target.length - args.length);\n    var boundArgs = [];\n    for (var i = 0; i < boundLength; i++) {\n        boundArgs[i] = '$' + i;\n    }\n\n    bound = Function('binder', 'return function (' + joiny(boundArgs, ',') + '){ return binder.apply(this,arguments); }')(binder);\n\n    if (target.prototype) {\n        var Empty = function Empty() {};\n        Empty.prototype = target.prototype;\n        bound.prototype = new Empty();\n        Empty.prototype = null;\n    }\n\n    return bound;\n};\n","'use strict';\n\nvar implementation = require('./implementation');\n\nmodule.exports = Function.prototype.bind || implementation;\n","'use strict';\n\nvar undefined;\n\nvar $Object = require('es-object-atoms');\n\nvar $Error = require('es-errors');\nvar $EvalError = require('es-errors/eval');\nvar $RangeError = require('es-errors/range');\nvar $ReferenceError = require('es-errors/ref');\nvar $SyntaxError = require('es-errors/syntax');\nvar $TypeError = require('es-errors/type');\nvar $URIError = require('es-errors/uri');\n\nvar abs = require('math-intrinsics/abs');\nvar floor = require('math-intrinsics/floor');\nvar max = require('math-intrinsics/max');\nvar min = require('math-intrinsics/min');\nvar pow = require('math-intrinsics/pow');\nvar round = require('math-intrinsics/round');\nvar sign = require('math-intrinsics/sign');\n\nvar $Function = Function;\n\n// eslint-disable-next-line consistent-return\nvar getEvalledConstructor = function (expressionSyntax) {\n\ttry {\n\t\treturn $Function('\"use strict\"; return (' + expressionSyntax + ').constructor;')();\n\t} catch (e) {}\n};\n\nvar $gOPD = require('gopd');\nvar $defineProperty = require('es-define-property');\n\nvar throwTypeError = function () {\n\tthrow new $TypeError();\n};\nvar ThrowTypeError = $gOPD\n\t? (function () {\n\t\ttry {\n\t\t\t// eslint-disable-next-line no-unused-expressions, no-caller, no-restricted-properties\n\t\t\targuments.callee; // IE 8 does not throw here\n\t\t\treturn throwTypeError;\n\t\t} catch (calleeThrows) {\n\t\t\ttry {\n\t\t\t\t// IE 8 throws on Object.getOwnPropertyDescriptor(arguments, '')\n\t\t\t\treturn $gOPD(arguments, 'callee').get;\n\t\t\t} catch (gOPDthrows) {\n\t\t\t\treturn throwTypeError;\n\t\t\t}\n\t\t}\n\t}())\n\t: throwTypeError;\n\nvar hasSymbols = require('has-symbols')();\n\nvar getProto = require('get-proto');\nvar $ObjectGPO = require('get-proto/Object.getPrototypeOf');\nvar $ReflectGPO = require('get-proto/Reflect.getPrototypeOf');\n\nvar $apply = require('call-bind-apply-helpers/functionApply');\nvar $call = require('call-bind-apply-helpers/functionCall');\n\nvar needsEval = {};\n\nvar TypedArray = typeof Uint8Array === 'undefined' || !getProto ? undefined : getProto(Uint8Array);\n\nvar INTRINSICS = {\n\t__proto__: null,\n\t'%AggregateError%': typeof AggregateError === 'undefined' ? undefined : AggregateError,\n\t'%Array%': Array,\n\t'%ArrayBuffer%': typeof ArrayBuffer === 'undefined' ? undefined : ArrayBuffer,\n\t'%ArrayIteratorPrototype%': hasSymbols && getProto ? getProto([][Symbol.iterator]()) : undefined,\n\t'%AsyncFromSyncIteratorPrototype%': undefined,\n\t'%AsyncFunction%': needsEval,\n\t'%AsyncGenerator%': needsEval,\n\t'%AsyncGeneratorFunction%': needsEval,\n\t'%AsyncIteratorPrototype%': needsEval,\n\t'%Atomics%': typeof Atomics === 'undefined' ? undefined : Atomics,\n\t'%BigInt%': typeof BigInt === 'undefined' ? undefined : BigInt,\n\t'%BigInt64Array%': typeof BigInt64Array === 'undefined' ? undefined : BigInt64Array,\n\t'%BigUint64Array%': typeof BigUint64Array === 'undefined' ? undefined : BigUint64Array,\n\t'%Boolean%': Boolean,\n\t'%DataView%': typeof DataView === 'undefined' ? undefined : DataView,\n\t'%Date%': Date,\n\t'%decodeURI%': decodeURI,\n\t'%decodeURIComponent%': decodeURIComponent,\n\t'%encodeURI%': encodeURI,\n\t'%encodeURIComponent%': encodeURIComponent,\n\t'%Error%': $Error,\n\t'%eval%': eval, // eslint-disable-line no-eval\n\t'%EvalError%': $EvalError,\n\t'%Float32Array%': typeof Float32Array === 'undefined' ? undefined : Float32Array,\n\t'%Float64Array%': typeof Float64Array === 'undefined' ? undefined : Float64Array,\n\t'%FinalizationRegistry%': typeof FinalizationRegistry === 'undefined' ? undefined : FinalizationRegistry,\n\t'%Function%': $Function,\n\t'%GeneratorFunction%': needsEval,\n\t'%Int8Array%': typeof Int8Array === 'undefined' ? undefined : Int8Array,\n\t'%Int16Array%': typeof Int16Array === 'undefined' ? undefined : Int16Array,\n\t'%Int32Array%': typeof Int32Array === 'undefined' ? undefined : Int32Array,\n\t'%isFinite%': isFinite,\n\t'%isNaN%': isNaN,\n\t'%IteratorPrototype%': hasSymbols && getProto ? getProto(getProto([][Symbol.iterator]())) : undefined,\n\t'%JSON%': typeof JSON === 'object' ? JSON : undefined,\n\t'%Map%': typeof Map === 'undefined' ? undefined : Map,\n\t'%MapIteratorPrototype%': typeof Map === 'undefined' || !hasSymbols || !getProto ? undefined : getProto(new Map()[Symbol.iterator]()),\n\t'%Math%': Math,\n\t'%Number%': Number,\n\t'%Object%': $Object,\n\t'%Object.getOwnPropertyDescriptor%': $gOPD,\n\t'%parseFloat%': parseFloat,\n\t'%parseInt%': parseInt,\n\t'%Promise%': typeof Promise === 'undefined' ? undefined : Promise,\n\t'%Proxy%': typeof Proxy === 'undefined' ? undefined : Proxy,\n\t'%RangeError%': $RangeError,\n\t'%ReferenceError%': $ReferenceError,\n\t'%Reflect%': typeof Reflect === 'undefined' ? undefined : Reflect,\n\t'%RegExp%': RegExp,\n\t'%Set%': typeof Set === 'undefined' ? undefined : Set,\n\t'%SetIteratorPrototype%': typeof Set === 'undefined' || !hasSymbols || !getProto ? undefined : getProto(new Set()[Symbol.iterator]()),\n\t'%SharedArrayBuffer%': typeof SharedArrayBuffer === 'undefined' ? undefined : SharedArrayBuffer,\n\t'%String%': String,\n\t'%StringIteratorPrototype%': hasSymbols && getProto ? getProto(''[Symbol.iterator]()) : undefined,\n\t'%Symbol%': hasSymbols ? Symbol : undefined,\n\t'%SyntaxError%': $SyntaxError,\n\t'%ThrowTypeError%': ThrowTypeError,\n\t'%TypedArray%': TypedArray,\n\t'%TypeError%': $TypeError,\n\t'%Uint8Array%': typeof Uint8Array === 'undefined' ? undefined : Uint8Array,\n\t'%Uint8ClampedArray%': typeof Uint8ClampedArray === 'undefined' ? undefined : Uint8ClampedArray,\n\t'%Uint16Array%': typeof Uint16Array === 'undefined' ? undefined : Uint16Array,\n\t'%Uint32Array%': typeof Uint32Array === 'undefined' ? undefined : Uint32Array,\n\t'%URIError%': $URIError,\n\t'%WeakMap%': typeof WeakMap === 'undefined' ? undefined : WeakMap,\n\t'%WeakRef%': typeof WeakRef === 'undefined' ? undefined : WeakRef,\n\t'%WeakSet%': typeof WeakSet === 'undefined' ? undefined : WeakSet,\n\n\t'%Function.prototype.call%': $call,\n\t'%Function.prototype.apply%': $apply,\n\t'%Object.defineProperty%': $defineProperty,\n\t'%Object.getPrototypeOf%': $ObjectGPO,\n\t'%Math.abs%': abs,\n\t'%Math.floor%': floor,\n\t'%Math.max%': max,\n\t'%Math.min%': min,\n\t'%Math.pow%': pow,\n\t'%Math.round%': round,\n\t'%Math.sign%': sign,\n\t'%Reflect.getPrototypeOf%': $ReflectGPO\n};\n\nif (getProto) {\n\ttry {\n\t\tnull.error; // eslint-disable-line no-unused-expressions\n\t} catch (e) {\n\t\t// https://github.com/tc39/proposal-shadowrealm/pull/384#issuecomment-1364264229\n\t\tvar errorProto = getProto(getProto(e));\n\t\tINTRINSICS['%Error.prototype%'] = errorProto;\n\t}\n}\n\nvar doEval = function doEval(name) {\n\tvar value;\n\tif (name === '%AsyncFunction%') {\n\t\tvalue = getEvalledConstructor('async function () {}');\n\t} else if (name === '%GeneratorFunction%') {\n\t\tvalue = getEvalledConstructor('function* () {}');\n\t} else if (name === '%AsyncGeneratorFunction%') {\n\t\tvalue = getEvalledConstructor('async function* () {}');\n\t} else if (name === '%AsyncGenerator%') {\n\t\tvar fn = doEval('%AsyncGeneratorFunction%');\n\t\tif (fn) {\n\t\t\tvalue = fn.prototype;\n\t\t}\n\t} else if (name === '%AsyncIteratorPrototype%') {\n\t\tvar gen = doEval('%AsyncGenerator%');\n\t\tif (gen && getProto) {\n\t\t\tvalue = getProto(gen.prototype);\n\t\t}\n\t}\n\n\tINTRINSICS[name] = value;\n\n\treturn value;\n};\n\nvar LEGACY_ALIASES = {\n\t__proto__: null,\n\t'%ArrayBufferPrototype%': ['ArrayBuffer', 'prototype'],\n\t'%ArrayPrototype%': ['Array', 'prototype'],\n\t'%ArrayProto_entries%': ['Array', 'prototype', 'entries'],\n\t'%ArrayProto_forEach%': ['Array', 'prototype', 'forEach'],\n\t'%ArrayProto_keys%': ['Array', 'prototype', 'keys'],\n\t'%ArrayProto_values%': ['Array', 'prototype', 'values'],\n\t'%AsyncFunctionPrototype%': ['AsyncFunction', 'prototype'],\n\t'%AsyncGenerator%': ['AsyncGeneratorFunction', 'prototype'],\n\t'%AsyncGeneratorPrototype%': ['AsyncGeneratorFunction', 'prototype', 'prototype'],\n\t'%BooleanPrototype%': ['Boolean', 'prototype'],\n\t'%DataViewPrototype%': ['DataView', 'prototype'],\n\t'%DatePrototype%': ['Date', 'prototype'],\n\t'%ErrorPrototype%': ['Error', 'prototype'],\n\t'%EvalErrorPrototype%': ['EvalError', 'prototype'],\n\t'%Float32ArrayPrototype%': ['Float32Array', 'prototype'],\n\t'%Float64ArrayPrototype%': ['Float64Array', 'prototype'],\n\t'%FunctionPrototype%': ['Function', 'prototype'],\n\t'%Generator%': ['GeneratorFunction', 'prototype'],\n\t'%GeneratorPrototype%': ['GeneratorFunction', 'prototype', 'prototype'],\n\t'%Int8ArrayPrototype%': ['Int8Array', 'prototype'],\n\t'%Int16ArrayPrototype%': ['Int16Array', 'prototype'],\n\t'%Int32ArrayPrototype%': ['Int32Array', 'prototype'],\n\t'%JSONParse%': ['JSON', 'parse'],\n\t'%JSONStringify%': ['JSON', 'stringify'],\n\t'%MapPrototype%': ['Map', 'prototype'],\n\t'%NumberPrototype%': ['Number', 'prototype'],\n\t'%ObjectPrototype%': ['Object', 'prototype'],\n\t'%ObjProto_toString%': ['Object', 'prototype', 'toString'],\n\t'%ObjProto_valueOf%': ['Object', 'prototype', 'valueOf'],\n\t'%PromisePrototype%': ['Promise', 'prototype'],\n\t'%PromiseProto_then%': ['Promise', 'prototype', 'then'],\n\t'%Promise_all%': ['Promise', 'all'],\n\t'%Promise_reject%': ['Promise', 'reject'],\n\t'%Promise_resolve%': ['Promise', 'resolve'],\n\t'%RangeErrorPrototype%': ['RangeError', 'prototype'],\n\t'%ReferenceErrorPrototype%': ['ReferenceError', 'prototype'],\n\t'%RegExpPrototype%': ['RegExp', 'prototype'],\n\t'%SetPrototype%': ['Set', 'prototype'],\n\t'%SharedArrayBufferPrototype%': ['SharedArrayBuffer', 'prototype'],\n\t'%StringPrototype%': ['String', 'prototype'],\n\t'%SymbolPrototype%': ['Symbol', 'prototype'],\n\t'%SyntaxErrorPrototype%': ['SyntaxError', 'prototype'],\n\t'%TypedArrayPrototype%': ['TypedArray', 'prototype'],\n\t'%TypeErrorPrototype%': ['TypeError', 'prototype'],\n\t'%Uint8ArrayPrototype%': ['Uint8Array', 'prototype'],\n\t'%Uint8ClampedArrayPrototype%': ['Uint8ClampedArray', 'prototype'],\n\t'%Uint16ArrayPrototype%': ['Uint16Array', 'prototype'],\n\t'%Uint32ArrayPrototype%': ['Uint32Array', 'prototype'],\n\t'%URIErrorPrototype%': ['URIError', 'prototype'],\n\t'%WeakMapPrototype%': ['WeakMap', 'prototype'],\n\t'%WeakSetPrototype%': ['WeakSet', 'prototype']\n};\n\nvar bind = require('function-bind');\nvar hasOwn = require('hasown');\nvar $concat = bind.call($call, Array.prototype.concat);\nvar $spliceApply = bind.call($apply, Array.prototype.splice);\nvar $replace = bind.call($call, String.prototype.replace);\nvar $strSlice = bind.call($call, String.prototype.slice);\nvar $exec = bind.call($call, RegExp.prototype.exec);\n\n/* adapted from https://github.com/lodash/lodash/blob/4.17.15/dist/lodash.js#L6735-L6744 */\nvar rePropName = /[^%.[\\]]+|\\[(?:(-?\\d+(?:\\.\\d+)?)|([\"'])((?:(?!\\2)[^\\\\]|\\\\.)*?)\\2)\\]|(?=(?:\\.|\\[\\])(?:\\.|\\[\\]|%$))/g;\nvar reEscapeChar = /\\\\(\\\\)?/g; /** Used to match backslashes in property paths. */\nvar stringToPath = function stringToPath(string) {\n\tvar first = $strSlice(string, 0, 1);\n\tvar last = $strSlice(string, -1);\n\tif (first === '%' && last !== '%') {\n\t\tthrow new $SyntaxError('invalid intrinsic syntax, expected closing `%`');\n\t} else if (last === '%' && first !== '%') {\n\t\tthrow new $SyntaxError('invalid intrinsic syntax, expected opening `%`');\n\t}\n\tvar result = [];\n\t$replace(string, rePropName, function (match, number, quote, subString) {\n\t\tresult[result.length] = quote ? $replace(subString, reEscapeChar, '$1') : number || match;\n\t});\n\treturn result;\n};\n/* end adaptation */\n\nvar getBaseIntrinsic = function getBaseIntrinsic(name, allowMissing) {\n\tvar intrinsicName = name;\n\tvar alias;\n\tif (hasOwn(LEGACY_ALIASES, intrinsicName)) {\n\t\talias = LEGACY_ALIASES[intrinsicName];\n\t\tintrinsicName = '%' + alias[0] + '%';\n\t}\n\n\tif (hasOwn(INTRINSICS, intrinsicName)) {\n\t\tvar value = INTRINSICS[intrinsicName];\n\t\tif (value === needsEval) {\n\t\t\tvalue = doEval(intrinsicName);\n\t\t}\n\t\tif (typeof value === 'undefined' && !allowMissing) {\n\t\t\tthrow new $TypeError('intrinsic ' + name + ' exists, but is not available. Please file an issue!');\n\t\t}\n\n\t\treturn {\n\t\t\talias: alias,\n\t\t\tname: intrinsicName,\n\t\t\tvalue: value\n\t\t};\n\t}\n\n\tthrow new $SyntaxError('intrinsic ' + name + ' does not exist!');\n};\n\nmodule.exports = function GetIntrinsic(name, allowMissing) {\n\tif (typeof name !== 'string' || name.length === 0) {\n\t\tthrow new $TypeError('intrinsic name must be a non-empty string');\n\t}\n\tif (arguments.length > 1 && typeof allowMissing !== 'boolean') {\n\t\tthrow new $TypeError('\"allowMissing\" argument must be a boolean');\n\t}\n\n\tif ($exec(/^%?[^%]*%?$/, name) === null) {\n\t\tthrow new $SyntaxError('`%` may not be present anywhere but at the beginning and end of the intrinsic name');\n\t}\n\tvar parts = stringToPath(name);\n\tvar intrinsicBaseName = parts.length > 0 ? parts[0] : '';\n\n\tvar intrinsic = getBaseIntrinsic('%' + intrinsicBaseName + '%', allowMissing);\n\tvar intrinsicRealName = intrinsic.name;\n\tvar value = intrinsic.value;\n\tvar skipFurtherCaching = false;\n\n\tvar alias = intrinsic.alias;\n\tif (alias) {\n\t\tintrinsicBaseName = alias[0];\n\t\t$spliceApply(parts, $concat([0, 1], alias));\n\t}\n\n\tfor (var i = 1, isOwn = true; i < parts.length; i += 1) {\n\t\tvar part = parts[i];\n\t\tvar first = $strSlice(part, 0, 1);\n\t\tvar last = $strSlice(part, -1);\n\t\tif (\n\t\t\t(\n\t\t\t\t(first === '\"' || first === \"'\" || first === '`')\n\t\t\t\t|| (last === '\"' || last === \"'\" || last === '`')\n\t\t\t)\n\t\t\t&& first !== last\n\t\t) {\n\t\t\tthrow new $SyntaxError('property names with quotes must have matching quotes');\n\t\t}\n\t\tif (part === 'constructor' || !isOwn) {\n\t\t\tskipFurtherCaching = true;\n\t\t}\n\n\t\tintrinsicBaseName += '.' + part;\n\t\tintrinsicRealName = '%' + intrinsicBaseName + '%';\n\n\t\tif (hasOwn(INTRINSICS, intrinsicRealName)) {\n\t\t\tvalue = INTRINSICS[intrinsicRealName];\n\t\t} else if (value != null) {\n\t\t\tif (!(part in value)) {\n\t\t\t\tif (!allowMissing) {\n\t\t\t\t\tthrow new $TypeError('base intrinsic for ' + name + ' exists, but the property is not available.');\n\t\t\t\t}\n\t\t\t\treturn void undefined;\n\t\t\t}\n\t\t\tif ($gOPD && (i + 1) >= parts.length) {\n\t\t\t\tvar desc = $gOPD(value, part);\n\t\t\t\tisOwn = !!desc;\n\n\t\t\t\t// By convention, when a data property is converted to an accessor\n\t\t\t\t// property to emulate a data property that does not suffer from\n\t\t\t\t// the override mistake, that accessor's getter is marked with\n\t\t\t\t// an `originalValue` property. Here, when we detect this, we\n\t\t\t\t// uphold the illusion by pretending to see that original data\n\t\t\t\t// property, i.e., returning the value rather than the getter\n\t\t\t\t// itself.\n\t\t\t\tif (isOwn && 'get' in desc && !('originalValue' in desc.get)) {\n\t\t\t\t\tvalue = desc.get;\n\t\t\t\t} else {\n\t\t\t\t\tvalue = value[part];\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tisOwn = hasOwn(value, part);\n\t\t\t\tvalue = value[part];\n\t\t\t}\n\n\t\t\tif (isOwn && !skipFurtherCaching) {\n\t\t\t\tINTRINSICS[intrinsicRealName] = value;\n\t\t\t}\n\t\t}\n\t}\n\treturn value;\n};\n","'use strict';\n\nvar $Object = require('es-object-atoms');\n\n/** @type {import('./Object.getPrototypeOf')} */\nmodule.exports = $Object.getPrototypeOf || null;\n","'use strict';\n\n/** @type {import('./Reflect.getPrototypeOf')} */\nmodule.exports = (typeof Reflect !== 'undefined' && Reflect.getPrototypeOf) || null;\n","'use strict';\n\nvar reflectGetProto = require('./Reflect.getPrototypeOf');\nvar originalGetProto = require('./Object.getPrototypeOf');\n\nvar getDunderProto = require('dunder-proto/get');\n\n/** @type {import('.')} */\nmodule.exports = reflectGetProto\n\t? function getProto(O) {\n\t\t// @ts-expect-error TS can't narrow inside a closure, for some reason\n\t\treturn reflectGetProto(O);\n\t}\n\t: originalGetProto\n\t\t? function getProto(O) {\n\t\t\tif (!O || (typeof O !== 'object' && typeof O !== 'function')) {\n\t\t\t\tthrow new TypeError('getProto: not an object');\n\t\t\t}\n\t\t\t// @ts-expect-error TS can't narrow inside a closure, for some reason\n\t\t\treturn originalGetProto(O);\n\t\t}\n\t\t: getDunderProto\n\t\t\t? function getProto(O) {\n\t\t\t\t// @ts-expect-error TS can't narrow inside a closure, for some reason\n\t\t\t\treturn getDunderProto(O);\n\t\t\t}\n\t\t\t: null;\n","module.exports = function (glob, opts) {\n  if (typeof glob !== 'string') {\n    throw new TypeError('Expected a string');\n  }\n\n  var str = String(glob);\n\n  // The regexp we are building, as a string.\n  var reStr = \"\";\n\n  // Whether we are matching so called \"extended\" globs (like bash) and should\n  // support single character matching, matching ranges of characters, group\n  // matching, etc.\n  var extended = opts ? !!opts.extended : false;\n\n  // When globstar is _false_ (default), '/foo/*' is translated a regexp like\n  // '^\\/foo\\/.*$' which will match any string beginning with '/foo/'\n  // When globstar is _true_, '/foo/*' is translated to regexp like\n  // '^\\/foo\\/[^/]*$' which will match any string beginning with '/foo/' BUT\n  // which does not have a '/' to the right of it.\n  // E.g. with '/foo/*' these will match: '/foo/bar', '/foo/bar.txt' but\n  // these will not '/foo/bar/baz', '/foo/bar/baz.txt'\n  // Lastely, when globstar is _true_, '/foo/**' is equivelant to '/foo/*' when\n  // globstar is _false_\n  var globstar = opts ? !!opts.globstar : false;\n\n  // If we are doing extended matching, this boolean is true when we are inside\n  // a group (eg {*.html,*.js}), and false otherwise.\n  var inGroup = false;\n\n  // RegExp flags (eg \"i\" ) to pass in to RegExp constructor.\n  var flags = opts && typeof( opts.flags ) === \"string\" ? opts.flags : \"\";\n\n  var c;\n  for (var i = 0, len = str.length; i < len; i++) {\n    c = str[i];\n\n    switch (c) {\n    case \"/\":\n    case \"$\":\n    case \"^\":\n    case \"+\":\n    case \".\":\n    case \"(\":\n    case \")\":\n    case \"=\":\n    case \"!\":\n    case \"|\":\n      reStr += \"\\\\\" + c;\n      break;\n\n    case \"?\":\n      if (extended) {\n        reStr += \".\";\n\t    break;\n      }\n\n    case \"[\":\n    case \"]\":\n      if (extended) {\n        reStr += c;\n\t    break;\n      }\n\n    case \"{\":\n      if (extended) {\n        inGroup = true;\n\t    reStr += \"(\";\n\t    break;\n      }\n\n    case \"}\":\n      if (extended) {\n        inGroup = false;\n\t    reStr += \")\";\n\t    break;\n      }\n\n    case \",\":\n      if (inGroup) {\n        reStr += \"|\";\n\t    break;\n      }\n      reStr += \"\\\\\" + c;\n      break;\n\n    case \"*\":\n      // Move over all consecutive \"*\"'s.\n      // Also store the previous and next characters\n      var prevChar = str[i - 1];\n      var starCount = 1;\n      while(str[i + 1] === \"*\") {\n        starCount++;\n        i++;\n      }\n      var nextChar = str[i + 1];\n\n      if (!globstar) {\n        // globstar is disabled, so treat any number of \"*\" as one\n        reStr += \".*\";\n      } else {\n        // globstar is enabled, so determine if this is a globstar segment\n        var isGlobstar = starCount > 1                      // multiple \"*\"'s\n          && (prevChar === \"/\" || prevChar === undefined)   // from the start of the segment\n          && (nextChar === \"/\" || nextChar === undefined)   // to the end of the segment\n\n        if (isGlobstar) {\n          // it's a globstar, so match zero or more path segments\n          reStr += \"((?:[^/]*(?:\\/|$))*)\";\n          i++; // move over the \"/\"\n        } else {\n          // it's not a globstar, so only match one path segment\n          reStr += \"([^/]*)\";\n        }\n      }\n      break;\n\n    default:\n      reStr += c;\n    }\n  }\n\n  // When regexp 'g' flag is specified don't\n  // constrain the regular expression with ^ & $\n  if (!flags || !~flags.indexOf('g')) {\n    reStr = \"^\" + reStr + \"$\";\n  }\n\n  return new RegExp(reStr, flags);\n};\n","'use strict';\n\n/** @type {import('./gOPD')} */\nmodule.exports = Object.getOwnPropertyDescriptor;\n","'use strict';\n\n/** @type {import('.')} */\nvar $gOPD = require('./gOPD');\n\nif ($gOPD) {\n\ttry {\n\t\t$gOPD([], 'length');\n\t} catch (e) {\n\t\t// IE 8 has a broken gOPD\n\t\t$gOPD = null;\n\t}\n}\n\nmodule.exports = $gOPD;\n","'use strict';\n\nvar $defineProperty = require('es-define-property');\n\nvar hasPropertyDescriptors = function hasPropertyDescriptors() {\n\treturn !!$defineProperty;\n};\n\nhasPropertyDescriptors.hasArrayLengthDefineBug = function hasArrayLengthDefineBug() {\n\t// node v0.6 has a bug where array lengths can be Set but not Defined\n\tif (!$defineProperty) {\n\t\treturn null;\n\t}\n\ttry {\n\t\treturn $defineProperty([], 'length', { value: 1 }).length !== 1;\n\t} catch (e) {\n\t\t// In Firefox 4-22, defining length on an array throws an exception.\n\t\treturn true;\n\t}\n};\n\nmodule.exports = hasPropertyDescriptors;\n","'use strict';\n\nvar origSymbol = typeof Symbol !== 'undefined' && Symbol;\nvar hasSymbolSham = require('./shams');\n\n/** @type {import('.')} */\nmodule.exports = function hasNativeSymbols() {\n\tif (typeof origSymbol !== 'function') { return false; }\n\tif (typeof Symbol !== 'function') { return false; }\n\tif (typeof origSymbol('foo') !== 'symbol') { return false; }\n\tif (typeof Symbol('bar') !== 'symbol') { return false; }\n\n\treturn hasSymbolSham();\n};\n","'use strict';\n\n/** @type {import('./shams')} */\n/* eslint complexity: [2, 18], max-statements: [2, 33] */\nmodule.exports = function hasSymbols() {\n\tif (typeof Symbol !== 'function' || typeof Object.getOwnPropertySymbols !== 'function') { return false; }\n\tif (typeof Symbol.iterator === 'symbol') { return true; }\n\n\t/** @type {{ [k in symbol]?: unknown }} */\n\tvar obj = {};\n\tvar sym = Symbol('test');\n\tvar symObj = Object(sym);\n\tif (typeof sym === 'string') { return false; }\n\n\tif (Object.prototype.toString.call(sym) !== '[object Symbol]') { return false; }\n\tif (Object.prototype.toString.call(symObj) !== '[object Symbol]') { return false; }\n\n\t// temp disabled per https://github.com/ljharb/object.assign/issues/17\n\t// if (sym instanceof Symbol) { return false; }\n\t// temp disabled per https://github.com/WebReflection/get-own-property-symbols/issues/4\n\t// if (!(symObj instanceof Symbol)) { return false; }\n\n\t// if (typeof Symbol.prototype.toString !== 'function') { return false; }\n\t// if (String(sym) !== Symbol.prototype.toString.call(sym)) { return false; }\n\n\tvar symVal = 42;\n\tobj[sym] = symVal;\n\tfor (var _ in obj) { return false; } // eslint-disable-line no-restricted-syntax, no-unreachable-loop\n\tif (typeof Object.keys === 'function' && Object.keys(obj).length !== 0) { return false; }\n\n\tif (typeof Object.getOwnPropertyNames === 'function' && Object.getOwnPropertyNames(obj).length !== 0) { return false; }\n\n\tvar syms = Object.getOwnPropertySymbols(obj);\n\tif (syms.length !== 1 || syms[0] !== sym) { return false; }\n\n\tif (!Object.prototype.propertyIsEnumerable.call(obj, sym)) { return false; }\n\n\tif (typeof Object.getOwnPropertyDescriptor === 'function') {\n\t\t// eslint-disable-next-line no-extra-parens\n\t\tvar descriptor = /** @type {PropertyDescriptor} */ (Object.getOwnPropertyDescriptor(obj, sym));\n\t\tif (descriptor.value !== symVal || descriptor.enumerable !== true) { return false; }\n\t}\n\n\treturn true;\n};\n","'use strict';\n\nvar hasSymbols = require('has-symbols/shams');\n\n/** @type {import('.')} */\nmodule.exports = function hasToStringTagShams() {\n\treturn hasSymbols() && !!Symbol.toStringTag;\n};\n","'use strict';\n\nvar call = Function.prototype.call;\nvar $hasOwn = Object.prototype.hasOwnProperty;\nvar bind = require('function-bind');\n\n/** @type {import('.')} */\nmodule.exports = bind.call(call, $hasOwn);\n","import {bodyRegExps, namedReferences} from './named-references';\nimport {numericUnicodeMap} from './numeric-unicode-map';\nimport {fromCodePoint, getCodePoint} from './surrogate-pairs';\n\nconst allNamedReferences = {\n    ...namedReferences,\n    all: namedReferences.html5\n};\n\nfunction replaceUsingRegExp(macroText: string, macroRegExp: RegExp, macroReplacer: (input: string) => string): string {\n    macroRegExp.lastIndex = 0;\n    let replaceMatch = macroRegExp.exec(macroText);\n    let replaceResult;\n    if (replaceMatch) {\n        replaceResult = '';\n        let replaceLastIndex = 0;\n        do {\n            if (replaceLastIndex !== replaceMatch.index) {\n                replaceResult += macroText.substring(replaceLastIndex, replaceMatch.index);\n            }\n            const replaceInput = replaceMatch[0];\n            replaceResult += macroReplacer(replaceInput);\n            replaceLastIndex = replaceMatch.index + replaceInput.length;\n        } while ((replaceMatch = macroRegExp.exec(macroText)));\n\n        if (replaceLastIndex !== macroText.length) {\n            replaceResult += macroText.substring(replaceLastIndex);\n        }\n    } else {\n        replaceResult = macroText;\n    }\n    return replaceResult;\n}\n\nexport type Level = 'xml' | 'html4' | 'html5' | 'all';\n\ninterface CommonOptions {\n    level?: Level;\n}\n\nexport type EncodeMode = 'specialChars' | 'nonAscii' | 'nonAsciiPrintable' | 'nonAsciiPrintableOnly' | 'extensive';\n\nexport interface EncodeOptions extends CommonOptions {\n    mode?: EncodeMode;\n    numeric?: 'decimal' | 'hexadecimal';\n}\n\nexport type DecodeScope = 'strict' | 'body' | 'attribute';\n\nexport interface DecodeOptions extends CommonOptions {\n    scope?: DecodeScope;\n}\n\nconst encodeRegExps: Record<EncodeMode, RegExp> = {\n    specialChars: /[<>'\"&]/g,\n    nonAscii: /[<>'\"&\\u0080-\\uD7FF\\uE000-\\uFFFF]|[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF]/g,\n    nonAsciiPrintable: /[<>'\"&\\x01-\\x08\\x11-\\x15\\x17-\\x1F\\x7f-\\uD7FF\\uE000-\\uFFFF]|[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF]/g,\n    nonAsciiPrintableOnly: /[\\x01-\\x08\\x11-\\x15\\x17-\\x1F\\x7f-\\uD7FF\\uE000-\\uFFFF]|[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF]/g,\n    extensive: /[\\x01-\\x0c\\x0e-\\x1f\\x21-\\x2c\\x2e-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\x7d\\x7f-\\uD7FF\\uE000-\\uFFFF]|[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF]/g\n};\n\nconst defaultEncodeOptions: EncodeOptions = {\n    mode: 'specialChars',\n    level: 'all',\n    numeric: 'decimal'\n};\n\n/** Encodes all the necessary (specified by `level`) characters in the text */\nexport function encode(\n    text: string | undefined | null,\n    {mode = 'specialChars', numeric = 'decimal', level = 'all'}: EncodeOptions = defaultEncodeOptions\n) {\n    if (!text) {\n        return '';\n    }\n\n    const encodeRegExp = encodeRegExps[mode];\n    const references = allNamedReferences[level].characters;\n    const isHex = numeric === 'hexadecimal';\n\n    return replaceUsingRegExp(text, encodeRegExp, (input) => {\n        let result = references[input];\n        if (!result) {\n            const code = input.length > 1 ? getCodePoint(input, 0)! : input.charCodeAt(0);\n            result = (isHex ? '&#x' + code.toString(16) : '&#' + code) + ';';\n        }\n        return result;\n    });\n}\n\nconst defaultDecodeOptions: DecodeOptions = {\n    scope: 'body',\n    level: 'all'\n};\n\nconst strict = /&(?:#\\d+|#[xX][\\da-fA-F]+|[0-9a-zA-Z]+);/g;\nconst attribute = /&(?:#\\d+|#[xX][\\da-fA-F]+|[0-9a-zA-Z]+)[;=]?/g;\n\nconst baseDecodeRegExps: Record<Exclude<Level, 'all'>, Record<DecodeScope, RegExp>> = {\n    xml: {\n        strict,\n        attribute,\n        body: bodyRegExps.xml\n    },\n    html4: {\n        strict,\n        attribute,\n        body: bodyRegExps.html4\n    },\n    html5: {\n        strict,\n        attribute,\n        body: bodyRegExps.html5\n    }\n};\n\nconst decodeRegExps: Record<Level, Record<DecodeScope, RegExp>> = {\n    ...baseDecodeRegExps,\n    all: baseDecodeRegExps.html5\n};\n\nconst fromCharCode = String.fromCharCode;\nconst outOfBoundsChar = fromCharCode(65533);\n\nconst defaultDecodeEntityOptions: CommonOptions = {\n    level: 'all'\n};\n\nfunction getDecodedEntity(\n    entity: string,\n    references: Record<string, string>,\n    isAttribute: boolean,\n    isStrict: boolean\n): string {\n    let decodeResult = entity;\n    const decodeEntityLastChar = entity[entity.length - 1];\n    if (isAttribute && decodeEntityLastChar === '=') {\n        decodeResult = entity;\n    } else if (isStrict && decodeEntityLastChar !== ';') {\n        decodeResult = entity;\n    } else {\n        const decodeResultByReference = references[entity];\n        if (decodeResultByReference) {\n            decodeResult = decodeResultByReference;\n        } else if (entity[0] === '&' && entity[1] === '#') {\n            const decodeSecondChar = entity[2];\n            const decodeCode =\n                decodeSecondChar == 'x' || decodeSecondChar == 'X'\n                    ? parseInt(entity.substr(3), 16)\n                    : parseInt(entity.substr(2));\n\n            decodeResult =\n                decodeCode >= 0x10ffff\n                    ? outOfBoundsChar\n                    : decodeCode > 65535\n                    ? fromCodePoint(decodeCode)\n                    : fromCharCode(numericUnicodeMap[decodeCode] || decodeCode);\n        }\n    }\n    return decodeResult;\n}\n\n/** Decodes a single entity */\nexport function decodeEntity(\n    entity: string | undefined | null,\n    {level = 'all'}: CommonOptions = defaultDecodeEntityOptions\n): string {\n    if (!entity) {\n        return '';\n    }\n    return getDecodedEntity(entity, allNamedReferences[level].entities, false, false);\n}\n\n/** Decodes all entities in the text */\nexport function decode(\n    text: string | undefined | null,\n    {level = 'all', scope = level === 'xml' ? 'strict' : 'body'}: DecodeOptions = defaultDecodeOptions\n) {\n    if (!text) {\n        return '';\n    }\n\n    const decodeRegExp = decodeRegExps[level][scope];\n    const references = allNamedReferences[level].entities;\n    const isAttribute = scope === 'attribute';\n    const isStrict = scope === 'strict';\n\n    return replaceUsingRegExp(text, decodeRegExp, (entity) =>\n        getDecodedEntity(entity, references, isAttribute, isStrict)\n    );\n}\n","// This file is autogenerated by tools/process-named-references.ts\n/* eslint-disable */\n\nexport type NamedReferences = {\n    [K in 'xml' | 'html4' | 'html5']: {\n        entities: Record<string, string>;\n        characters: Record<string, string>;\n    }\n};\nexport const bodyRegExps = {\n    xml: /&(?:#\\d+|#[xX][\\da-fA-F]+|[0-9a-zA-Z]+);?/g,\n    html4: /&notin;|&(?:nbsp|iexcl|cent|pound|curren|yen|brvbar|sect|uml|copy|ordf|laquo|not|shy|reg|macr|deg|plusmn|sup2|sup3|acute|micro|para|middot|cedil|sup1|ordm|raquo|frac14|frac12|frac34|iquest|Agrave|Aacute|Acirc|Atilde|Auml|Aring|AElig|Ccedil|Egrave|Eacute|Ecirc|Euml|Igrave|Iacute|Icirc|Iuml|ETH|Ntilde|Ograve|Oacute|Ocirc|Otilde|Ouml|times|Oslash|Ugrave|Uacute|Ucirc|Uuml|Yacute|THORN|szlig|agrave|aacute|acirc|atilde|auml|aring|aelig|ccedil|egrave|eacute|ecirc|euml|igrave|iacute|icirc|iuml|eth|ntilde|ograve|oacute|ocirc|otilde|ouml|divide|oslash|ugrave|uacute|ucirc|uuml|yacute|thorn|yuml|quot|amp|lt|gt|#\\d+|#[xX][\\da-fA-F]+|[0-9a-zA-Z]+);?/g,\n    html5: /&centerdot;|&copysr;|&divideontimes;|&gtcc;|&gtcir;|&gtdot;|&gtlPar;|&gtquest;|&gtrapprox;|&gtrarr;|&gtrdot;|&gtreqless;|&gtreqqless;|&gtrless;|&gtrsim;|&ltcc;|&ltcir;|&ltdot;|&lthree;|&ltimes;|&ltlarr;|&ltquest;|&ltrPar;|&ltri;|&ltrie;|&ltrif;|&notin;|&notinE;|&notindot;|&notinva;|&notinvb;|&notinvc;|&notni;|&notniva;|&notnivb;|&notnivc;|&parallel;|&timesb;|&timesbar;|&timesd;|&(?:AElig|AMP|Aacute|Acirc|Agrave|Aring|Atilde|Auml|COPY|Ccedil|ETH|Eacute|Ecirc|Egrave|Euml|GT|Iacute|Icirc|Igrave|Iuml|LT|Ntilde|Oacute|Ocirc|Ograve|Oslash|Otilde|Ouml|QUOT|REG|THORN|Uacute|Ucirc|Ugrave|Uuml|Yacute|aacute|acirc|acute|aelig|agrave|amp|aring|atilde|auml|brvbar|ccedil|cedil|cent|copy|curren|deg|divide|eacute|ecirc|egrave|eth|euml|frac12|frac14|frac34|gt|iacute|icirc|iexcl|igrave|iquest|iuml|laquo|lt|macr|micro|middot|nbsp|not|ntilde|oacute|ocirc|ograve|ordf|ordm|oslash|otilde|ouml|para|plusmn|pound|quot|raquo|reg|sect|shy|sup1|sup2|sup3|szlig|thorn|times|uacute|ucirc|ugrave|uml|uuml|yacute|yen|yuml|#\\d+|#[xX][\\da-fA-F]+|[0-9a-zA-Z]+);?/g\n};\nexport const namedReferences: NamedReferences = {\n    \"xml\": {\n        \"entities\": {\n            \"&lt;\": \"<\",\n            \"&gt;\": \">\",\n            \"&quot;\": \"\\\"\",\n            \"&apos;\": \"'\",\n            \"&amp;\": \"&\"\n        },\n        \"characters\": {\n            \"<\": \"&lt;\",\n            \">\": \"&gt;\",\n            \"\\\"\": \"&quot;\",\n            \"'\": \"&apos;\",\n            \"&\": \"&amp;\"\n        }\n    },\n    \"html4\": {\n        \"entities\": {\n            \"&apos;\": \"'\",\n            \"&nbsp\": \" \",\n            \"&nbsp;\": \" \",\n            \"&iexcl\": \"¡\",\n            \"&iexcl;\": \"¡\",\n            \"&cent\": \"¢\",\n            \"&cent;\": \"¢\",\n            \"&pound\": \"£\",\n            \"&pound;\": \"£\",\n            \"&curren\": \"¤\",\n            \"&curren;\": \"¤\",\n            \"&yen\": \"¥\",\n            \"&yen;\": \"¥\",\n            \"&brvbar\": \"¦\",\n            \"&brvbar;\": \"¦\",\n            \"&sect\": \"§\",\n            \"&sect;\": \"§\",\n            \"&uml\": \"¨\",\n            \"&uml;\": \"¨\",\n            \"&copy\": \"©\",\n            \"&copy;\": \"©\",\n            \"&ordf\": \"ª\",\n            \"&ordf;\": \"ª\",\n            \"&laquo\": \"«\",\n            \"&laquo;\": \"«\",\n            \"&not\": \"¬\",\n            \"&not;\": \"¬\",\n            \"&shy\": \"­\",\n            \"&shy;\": \"­\",\n            \"&reg\": \"®\",\n            \"&reg;\": \"®\",\n            \"&macr\": \"¯\",\n            \"&macr;\": \"¯\",\n            \"&deg\": \"°\",\n            \"&deg;\": \"°\",\n            \"&plusmn\": \"±\",\n            \"&plusmn;\": \"±\",\n            \"&sup2\": \"²\",\n            \"&sup2;\": \"²\",\n            \"&sup3\": \"³\",\n            \"&sup3;\": \"³\",\n            \"&acute\": \"´\",\n            \"&acute;\": \"´\",\n            \"&micro\": \"µ\",\n            \"&micro;\": \"µ\",\n            \"&para\": \"¶\",\n            \"&para;\": \"¶\",\n            \"&middot\": \"·\",\n            \"&middot;\": \"·\",\n            \"&cedil\": \"¸\",\n            \"&cedil;\": \"¸\",\n            \"&sup1\": \"¹\",\n            \"&sup1;\": \"¹\",\n            \"&ordm\": \"º\",\n            \"&ordm;\": \"º\",\n            \"&raquo\": \"»\",\n            \"&raquo;\": \"»\",\n            \"&frac14\": \"¼\",\n            \"&frac14;\": \"¼\",\n            \"&frac12\": \"½\",\n            \"&frac12;\": \"½\",\n            \"&frac34\": \"¾\",\n            \"&frac34;\": \"¾\",\n            \"&iquest\": \"¿\",\n            \"&iquest;\": \"¿\",\n            \"&Agrave\": \"À\",\n            \"&Agrave;\": \"À\",\n            \"&Aacute\": \"Á\",\n            \"&Aacute;\": \"Á\",\n            \"&Acirc\": \"Â\",\n            \"&Acirc;\": \"Â\",\n            \"&Atilde\": \"Ã\",\n            \"&Atilde;\": \"Ã\",\n            \"&Auml\": \"Ä\",\n            \"&Auml;\": \"Ä\",\n            \"&Aring\": \"Å\",\n            \"&Aring;\": \"Å\",\n            \"&AElig\": \"Æ\",\n            \"&AElig;\": \"Æ\",\n            \"&Ccedil\": \"Ç\",\n            \"&Ccedil;\": \"Ç\",\n            \"&Egrave\": \"È\",\n            \"&Egrave;\": \"È\",\n            \"&Eacute\": \"É\",\n            \"&Eacute;\": \"É\",\n            \"&Ecirc\": \"Ê\",\n            \"&Ecirc;\": \"Ê\",\n            \"&Euml\": \"Ë\",\n            \"&Euml;\": \"Ë\",\n            \"&Igrave\": \"Ì\",\n            \"&Igrave;\": \"Ì\",\n            \"&Iacute\": \"Í\",\n            \"&Iacute;\": \"Í\",\n            \"&Icirc\": \"Î\",\n            \"&Icirc;\": \"Î\",\n            \"&Iuml\": \"Ï\",\n            \"&Iuml;\": \"Ï\",\n            \"&ETH\": \"Ð\",\n            \"&ETH;\": \"Ð\",\n            \"&Ntilde\": \"Ñ\",\n            \"&Ntilde;\": \"Ñ\",\n            \"&Ograve\": \"Ò\",\n            \"&Ograve;\": \"Ò\",\n            \"&Oacute\": \"Ó\",\n            \"&Oacute;\": \"Ó\",\n            \"&Ocirc\": \"Ô\",\n            \"&Ocirc;\": \"Ô\",\n            \"&Otilde\": \"Õ\",\n            \"&Otilde;\": \"Õ\",\n            \"&Ouml\": \"Ö\",\n            \"&Ouml;\": \"Ö\",\n            \"&times\": \"×\",\n            \"&times;\": \"×\",\n            \"&Oslash\": \"Ø\",\n            \"&Oslash;\": \"Ø\",\n            \"&Ugrave\": \"Ù\",\n            \"&Ugrave;\": \"Ù\",\n            \"&Uacute\": \"Ú\",\n            \"&Uacute;\": \"Ú\",\n            \"&Ucirc\": \"Û\",\n            \"&Ucirc;\": \"Û\",\n            \"&Uuml\": \"Ü\",\n            \"&Uuml;\": \"Ü\",\n            \"&Yacute\": \"Ý\",\n            \"&Yacute;\": \"Ý\",\n            \"&THORN\": \"Þ\",\n            \"&THORN;\": \"Þ\",\n            \"&szlig\": \"ß\",\n            \"&szlig;\": \"ß\",\n            \"&agrave\": \"à\",\n            \"&agrave;\": \"à\",\n            \"&aacute\": \"á\",\n            \"&aacute;\": \"á\",\n            \"&acirc\": \"â\",\n            \"&acirc;\": \"â\",\n            \"&atilde\": \"ã\",\n            \"&atilde;\": \"ã\",\n            \"&auml\": \"ä\",\n            \"&auml;\": \"ä\",\n            \"&aring\": \"å\",\n            \"&aring;\": \"å\",\n            \"&aelig\": \"æ\",\n            \"&aelig;\": \"æ\",\n            \"&ccedil\": \"ç\",\n            \"&ccedil;\": \"ç\",\n            \"&egrave\": \"è\",\n            \"&egrave;\": \"è\",\n            \"&eacute\": \"é\",\n            \"&eacute;\": \"é\",\n            \"&ecirc\": \"ê\",\n            \"&ecirc;\": \"ê\",\n            \"&euml\": \"ë\",\n            \"&euml;\": \"ë\",\n            \"&igrave\": \"ì\",\n            \"&igrave;\": \"ì\",\n            \"&iacute\": \"í\",\n            \"&iacute;\": \"í\",\n            \"&icirc\": \"î\",\n            \"&icirc;\": \"î\",\n            \"&iuml\": \"ï\",\n            \"&iuml;\": \"ï\",\n            \"&eth\": \"ð\",\n            \"&eth;\": \"ð\",\n            \"&ntilde\": \"ñ\",\n            \"&ntilde;\": \"ñ\",\n            \"&ograve\": \"ò\",\n            \"&ograve;\": \"ò\",\n            \"&oacute\": \"ó\",\n            \"&oacute;\": \"ó\",\n            \"&ocirc\": \"ô\",\n            \"&ocirc;\": \"ô\",\n            \"&otilde\": \"õ\",\n            \"&otilde;\": \"õ\",\n            \"&ouml\": \"ö\",\n            \"&ouml;\": \"ö\",\n            \"&divide\": \"÷\",\n            \"&divide;\": \"÷\",\n            \"&oslash\": \"ø\",\n            \"&oslash;\": \"ø\",\n            \"&ugrave\": \"ù\",\n            \"&ugrave;\": \"ù\",\n            \"&uacute\": \"ú\",\n            \"&uacute;\": \"ú\",\n            \"&ucirc\": \"û\",\n            \"&ucirc;\": \"û\",\n            \"&uuml\": \"ü\",\n            \"&uuml;\": \"ü\",\n            \"&yacute\": \"ý\",\n            \"&yacute;\": \"ý\",\n            \"&thorn\": \"þ\",\n            \"&thorn;\": \"þ\",\n            \"&yuml\": \"ÿ\",\n            \"&yuml;\": \"ÿ\",\n            \"&quot\": \"\\\"\",\n            \"&quot;\": \"\\\"\",\n            \"&amp\": \"&\",\n            \"&amp;\": \"&\",\n            \"&lt\": \"<\",\n            \"&lt;\": \"<\",\n            \"&gt\": \">\",\n            \"&gt;\": \">\",\n            \"&OElig;\": \"Œ\",\n            \"&oelig;\": \"œ\",\n            \"&Scaron;\": \"Š\",\n            \"&scaron;\": \"š\",\n            \"&Yuml;\": \"Ÿ\",\n            \"&circ;\": \"ˆ\",\n            \"&tilde;\": \"˜\",\n            \"&ensp;\": \" \",\n            \"&emsp;\": \" \",\n            \"&thinsp;\": \" \",\n            \"&zwnj;\": \"‌\",\n            \"&zwj;\": \"‍\",\n            \"&lrm;\": \"‎\",\n            \"&rlm;\": \"‏\",\n            \"&ndash;\": \"–\",\n            \"&mdash;\": \"—\",\n            \"&lsquo;\": \"‘\",\n            \"&rsquo;\": \"’\",\n            \"&sbquo;\": \"‚\",\n            \"&ldquo;\": \"“\",\n            \"&rdquo;\": \"”\",\n            \"&bdquo;\": \"„\",\n            \"&dagger;\": \"†\",\n            \"&Dagger;\": \"‡\",\n            \"&permil;\": \"‰\",\n            \"&lsaquo;\": \"‹\",\n            \"&rsaquo;\": \"›\",\n            \"&euro;\": \"€\",\n            \"&fnof;\": \"ƒ\",\n            \"&Alpha;\": \"Α\",\n            \"&Beta;\": \"Β\",\n            \"&Gamma;\": \"Γ\",\n            \"&Delta;\": \"Δ\",\n            \"&Epsilon;\": \"Ε\",\n            \"&Zeta;\": \"Ζ\",\n            \"&Eta;\": \"Η\",\n            \"&Theta;\": \"Θ\",\n            \"&Iota;\": \"Ι\",\n            \"&Kappa;\": \"Κ\",\n            \"&Lambda;\": \"Λ\",\n            \"&Mu;\": \"Μ\",\n            \"&Nu;\": \"Ν\",\n            \"&Xi;\": \"Ξ\",\n            \"&Omicron;\": \"Ο\",\n            \"&Pi;\": \"Π\",\n            \"&Rho;\": \"Ρ\",\n            \"&Sigma;\": \"Σ\",\n            \"&Tau;\": \"Τ\",\n            \"&Upsilon;\": \"Υ\",\n            \"&Phi;\": \"Φ\",\n            \"&Chi;\": \"Χ\",\n            \"&Psi;\": \"Ψ\",\n            \"&Omega;\": \"Ω\",\n            \"&alpha;\": \"α\",\n            \"&beta;\": \"β\",\n            \"&gamma;\": \"γ\",\n            \"&delta;\": \"δ\",\n            \"&epsilon;\": \"ε\",\n            \"&zeta;\": \"ζ\",\n            \"&eta;\": \"η\",\n            \"&theta;\": \"θ\",\n            \"&iota;\": \"ι\",\n            \"&kappa;\": \"κ\",\n            \"&lambda;\": \"λ\",\n            \"&mu;\": \"μ\",\n            \"&nu;\": \"ν\",\n            \"&xi;\": \"ξ\",\n            \"&omicron;\": \"ο\",\n            \"&pi;\": \"π\",\n            \"&rho;\": \"ρ\",\n            \"&sigmaf;\": \"ς\",\n            \"&sigma;\": \"σ\",\n            \"&tau;\": \"τ\",\n            \"&upsilon;\": \"υ\",\n            \"&phi;\": \"φ\",\n            \"&chi;\": \"χ\",\n            \"&psi;\": \"ψ\",\n            \"&omega;\": \"ω\",\n            \"&thetasym;\": \"ϑ\",\n            \"&upsih;\": \"ϒ\",\n            \"&piv;\": \"ϖ\",\n            \"&bull;\": \"•\",\n            \"&hellip;\": \"…\",\n            \"&prime;\": \"′\",\n            \"&Prime;\": \"″\",\n            \"&oline;\": \"‾\",\n            \"&frasl;\": \"⁄\",\n            \"&weierp;\": \"℘\",\n            \"&image;\": \"ℑ\",\n            \"&real;\": \"ℜ\",\n            \"&trade;\": \"™\",\n            \"&alefsym;\": \"ℵ\",\n            \"&larr;\": \"←\",\n            \"&uarr;\": \"↑\",\n            \"&rarr;\": \"→\",\n            \"&darr;\": \"↓\",\n            \"&harr;\": \"↔\",\n            \"&crarr;\": \"↵\",\n            \"&lArr;\": \"⇐\",\n            \"&uArr;\": \"⇑\",\n            \"&rArr;\": \"⇒\",\n            \"&dArr;\": \"⇓\",\n            \"&hArr;\": \"⇔\",\n            \"&forall;\": \"∀\",\n            \"&part;\": \"∂\",\n            \"&exist;\": \"∃\",\n            \"&empty;\": \"∅\",\n            \"&nabla;\": \"∇\",\n            \"&isin;\": \"∈\",\n            \"&notin;\": \"∉\",\n            \"&ni;\": \"∋\",\n            \"&prod;\": \"∏\",\n            \"&sum;\": \"∑\",\n            \"&minus;\": \"−\",\n            \"&lowast;\": \"∗\",\n            \"&radic;\": \"√\",\n            \"&prop;\": \"∝\",\n            \"&infin;\": \"∞\",\n            \"&ang;\": \"∠\",\n            \"&and;\": \"∧\",\n            \"&or;\": \"∨\",\n            \"&cap;\": \"∩\",\n            \"&cup;\": \"∪\",\n            \"&int;\": \"∫\",\n            \"&there4;\": \"∴\",\n            \"&sim;\": \"∼\",\n            \"&cong;\": \"≅\",\n            \"&asymp;\": \"≈\",\n            \"&ne;\": \"≠\",\n            \"&equiv;\": \"≡\",\n            \"&le;\": \"≤\",\n            \"&ge;\": \"≥\",\n            \"&sub;\": \"⊂\",\n            \"&sup;\": \"⊃\",\n            \"&nsub;\": \"⊄\",\n            \"&sube;\": \"⊆\",\n            \"&supe;\": \"⊇\",\n            \"&oplus;\": \"⊕\",\n            \"&otimes;\": \"⊗\",\n            \"&perp;\": \"⊥\",\n            \"&sdot;\": \"⋅\",\n            \"&lceil;\": \"⌈\",\n            \"&rceil;\": \"⌉\",\n            \"&lfloor;\": \"⌊\",\n            \"&rfloor;\": \"⌋\",\n            \"&lang;\": \"〈\",\n            \"&rang;\": \"〉\",\n            \"&loz;\": \"◊\",\n            \"&spades;\": \"♠\",\n            \"&clubs;\": \"♣\",\n            \"&hearts;\": \"♥\",\n            \"&diams;\": \"♦\"\n        },\n        \"characters\": {\n            \"'\": \"&apos;\",\n            \" \": \"&nbsp;\",\n            \"¡\": \"&iexcl;\",\n            \"¢\": \"&cent;\",\n            \"£\": \"&pound;\",\n            \"¤\": \"&curren;\",\n            \"¥\": \"&yen;\",\n            \"¦\": \"&brvbar;\",\n            \"§\": \"&sect;\",\n            \"¨\": \"&uml;\",\n            \"©\": \"&copy;\",\n            \"ª\": \"&ordf;\",\n            \"«\": \"&laquo;\",\n            \"¬\": \"&not;\",\n            \"­\": \"&shy;\",\n            \"®\": \"&reg;\",\n            \"¯\": \"&macr;\",\n            \"°\": \"&deg;\",\n            \"±\": \"&plusmn;\",\n            \"²\": \"&sup2;\",\n            \"³\": \"&sup3;\",\n            \"´\": \"&acute;\",\n            \"µ\": \"&micro;\",\n            \"¶\": \"&para;\",\n            \"·\": \"&middot;\",\n            \"¸\": \"&cedil;\",\n            \"¹\": \"&sup1;\",\n            \"º\": \"&ordm;\",\n            \"»\": \"&raquo;\",\n            \"¼\": \"&frac14;\",\n            \"½\": \"&frac12;\",\n            \"¾\": \"&frac34;\",\n            \"¿\": \"&iquest;\",\n            \"À\": \"&Agrave;\",\n            \"Á\": \"&Aacute;\",\n            \"Â\": \"&Acirc;\",\n            \"Ã\": \"&Atilde;\",\n            \"Ä\": \"&Auml;\",\n            \"Å\": \"&Aring;\",\n            \"Æ\": \"&AElig;\",\n            \"Ç\": \"&Ccedil;\",\n            \"È\": \"&Egrave;\",\n            \"É\": \"&Eacute;\",\n            \"Ê\": \"&Ecirc;\",\n            \"Ë\": \"&Euml;\",\n            \"Ì\": \"&Igrave;\",\n            \"Í\": \"&Iacute;\",\n            \"Î\": \"&Icirc;\",\n            \"Ï\": \"&Iuml;\",\n            \"Ð\": \"&ETH;\",\n            \"Ñ\": \"&Ntilde;\",\n            \"Ò\": \"&Ograve;\",\n            \"Ó\": \"&Oacute;\",\n            \"Ô\": \"&Ocirc;\",\n            \"Õ\": \"&Otilde;\",\n            \"Ö\": \"&Ouml;\",\n            \"×\": \"&times;\",\n            \"Ø\": \"&Oslash;\",\n            \"Ù\": \"&Ugrave;\",\n            \"Ú\": \"&Uacute;\",\n            \"Û\": \"&Ucirc;\",\n            \"Ü\": \"&Uuml;\",\n            \"Ý\": \"&Yacute;\",\n            \"Þ\": \"&THORN;\",\n            \"ß\": \"&szlig;\",\n            \"à\": \"&agrave;\",\n            \"á\": \"&aacute;\",\n            \"â\": \"&acirc;\",\n            \"ã\": \"&atilde;\",\n            \"ä\": \"&auml;\",\n            \"å\": \"&aring;\",\n            \"æ\": \"&aelig;\",\n            \"ç\": \"&ccedil;\",\n            \"è\": \"&egrave;\",\n            \"é\": \"&eacute;\",\n            \"ê\": \"&ecirc;\",\n            \"ë\": \"&euml;\",\n            \"ì\": \"&igrave;\",\n            \"í\": \"&iacute;\",\n            \"î\": \"&icirc;\",\n            \"ï\": \"&iuml;\",\n            \"ð\": \"&eth;\",\n            \"ñ\": \"&ntilde;\",\n            \"ò\": \"&ograve;\",\n            \"ó\": \"&oacute;\",\n            \"ô\": \"&ocirc;\",\n            \"õ\": \"&otilde;\",\n            \"ö\": \"&ouml;\",\n            \"÷\": \"&divide;\",\n            \"ø\": \"&oslash;\",\n            \"ù\": \"&ugrave;\",\n            \"ú\": \"&uacute;\",\n            \"û\": \"&ucirc;\",\n            \"ü\": \"&uuml;\",\n            \"ý\": \"&yacute;\",\n            \"þ\": \"&thorn;\",\n            \"ÿ\": \"&yuml;\",\n            \"\\\"\": \"&quot;\",\n            \"&\": \"&amp;\",\n            \"<\": \"&lt;\",\n            \">\": \"&gt;\",\n            \"Œ\": \"&OElig;\",\n            \"œ\": \"&oelig;\",\n            \"Š\": \"&Scaron;\",\n            \"š\": \"&scaron;\",\n            \"Ÿ\": \"&Yuml;\",\n            \"ˆ\": \"&circ;\",\n            \"˜\": \"&tilde;\",\n            \" \": \"&ensp;\",\n            \" \": \"&emsp;\",\n            \" \": \"&thinsp;\",\n            \"‌\": \"&zwnj;\",\n            \"‍\": \"&zwj;\",\n            \"‎\": \"&lrm;\",\n            \"‏\": \"&rlm;\",\n            \"–\": \"&ndash;\",\n            \"—\": \"&mdash;\",\n            \"‘\": \"&lsquo;\",\n            \"’\": \"&rsquo;\",\n            \"‚\": \"&sbquo;\",\n            \"“\": \"&ldquo;\",\n            \"”\": \"&rdquo;\",\n            \"„\": \"&bdquo;\",\n            \"†\": \"&dagger;\",\n            \"‡\": \"&Dagger;\",\n            \"‰\": \"&permil;\",\n            \"‹\": \"&lsaquo;\",\n            \"›\": \"&rsaquo;\",\n            \"€\": \"&euro;\",\n            \"ƒ\": \"&fnof;\",\n            \"Α\": \"&Alpha;\",\n            \"Β\": \"&Beta;\",\n            \"Γ\": \"&Gamma;\",\n            \"Δ\": \"&Delta;\",\n            \"Ε\": \"&Epsilon;\",\n            \"Ζ\": \"&Zeta;\",\n            \"Η\": \"&Eta;\",\n            \"Θ\": \"&Theta;\",\n            \"Ι\": \"&Iota;\",\n            \"Κ\": \"&Kappa;\",\n            \"Λ\": \"&Lambda;\",\n            \"Μ\": \"&Mu;\",\n            \"Ν\": \"&Nu;\",\n            \"Ξ\": \"&Xi;\",\n            \"Ο\": \"&Omicron;\",\n            \"Π\": \"&Pi;\",\n            \"Ρ\": \"&Rho;\",\n            \"Σ\": \"&Sigma;\",\n            \"Τ\": \"&Tau;\",\n            \"Υ\": \"&Upsilon;\",\n            \"Φ\": \"&Phi;\",\n            \"Χ\": \"&Chi;\",\n            \"Ψ\": \"&Psi;\",\n            \"Ω\": \"&Omega;\",\n            \"α\": \"&alpha;\",\n            \"β\": \"&beta;\",\n            \"γ\": \"&gamma;\",\n            \"δ\": \"&delta;\",\n            \"ε\": \"&epsilon;\",\n            \"ζ\": \"&zeta;\",\n            \"η\": \"&eta;\",\n            \"θ\": \"&theta;\",\n            \"ι\": \"&iota;\",\n            \"κ\": \"&kappa;\",\n            \"λ\": \"&lambda;\",\n            \"μ\": \"&mu;\",\n            \"ν\": \"&nu;\",\n            \"ξ\": \"&xi;\",\n            \"ο\": \"&omicron;\",\n            \"π\": \"&pi;\",\n            \"ρ\": \"&rho;\",\n            \"ς\": \"&sigmaf;\",\n            \"σ\": \"&sigma;\",\n            \"τ\": \"&tau;\",\n            \"υ\": \"&upsilon;\",\n            \"φ\": \"&phi;\",\n            \"χ\": \"&chi;\",\n            \"ψ\": \"&psi;\",\n            \"ω\": \"&omega;\",\n            \"ϑ\": \"&thetasym;\",\n            \"ϒ\": \"&upsih;\",\n            \"ϖ\": \"&piv;\",\n            \"•\": \"&bull;\",\n            \"…\": \"&hellip;\",\n            \"′\": \"&prime;\",\n            \"″\": \"&Prime;\",\n            \"‾\": \"&oline;\",\n            \"⁄\": \"&frasl;\",\n            \"℘\": \"&weierp;\",\n            \"ℑ\": \"&image;\",\n            \"ℜ\": \"&real;\",\n            \"™\": \"&trade;\",\n            \"ℵ\": \"&alefsym;\",\n            \"←\": \"&larr;\",\n            \"↑\": \"&uarr;\",\n            \"→\": \"&rarr;\",\n            \"↓\": \"&darr;\",\n            \"↔\": \"&harr;\",\n            \"↵\": \"&crarr;\",\n            \"⇐\": \"&lArr;\",\n            \"⇑\": \"&uArr;\",\n            \"⇒\": \"&rArr;\",\n            \"⇓\": \"&dArr;\",\n            \"⇔\": \"&hArr;\",\n            \"∀\": \"&forall;\",\n            \"∂\": \"&part;\",\n            \"∃\": \"&exist;\",\n            \"∅\": \"&empty;\",\n            \"∇\": \"&nabla;\",\n            \"∈\": \"&isin;\",\n            \"∉\": \"&notin;\",\n            \"∋\": \"&ni;\",\n            \"∏\": \"&prod;\",\n            \"∑\": \"&sum;\",\n            \"−\": \"&minus;\",\n            \"∗\": \"&lowast;\",\n            \"√\": \"&radic;\",\n            \"∝\": \"&prop;\",\n            \"∞\": \"&infin;\",\n            \"∠\": \"&ang;\",\n            \"∧\": \"&and;\",\n            \"∨\": \"&or;\",\n            \"∩\": \"&cap;\",\n            \"∪\": \"&cup;\",\n            \"∫\": \"&int;\",\n            \"∴\": \"&there4;\",\n            \"∼\": \"&sim;\",\n            \"≅\": \"&cong;\",\n            \"≈\": \"&asymp;\",\n            \"≠\": \"&ne;\",\n            \"≡\": \"&equiv;\",\n            \"≤\": \"&le;\",\n            \"≥\": \"&ge;\",\n            \"⊂\": \"&sub;\",\n            \"⊃\": \"&sup;\",\n            \"⊄\": \"&nsub;\",\n            \"⊆\": \"&sube;\",\n            \"⊇\": \"&supe;\",\n            \"⊕\": \"&oplus;\",\n            \"⊗\": \"&otimes;\",\n            \"⊥\": \"&perp;\",\n            \"⋅\": \"&sdot;\",\n            \"⌈\": \"&lceil;\",\n            \"⌉\": \"&rceil;\",\n            \"⌊\": \"&lfloor;\",\n            \"⌋\": \"&rfloor;\",\n            \"〈\": \"&lang;\",\n            \"〉\": \"&rang;\",\n            \"◊\": \"&loz;\",\n            \"♠\": \"&spades;\",\n            \"♣\": \"&clubs;\",\n            \"♥\": \"&hearts;\",\n            \"♦\": \"&diams;\"\n        }\n    },\n    \"html5\": {\n        \"entities\": {\n            \"&AElig\": \"Æ\",\n            \"&AElig;\": \"Æ\",\n            \"&AMP\": \"&\",\n            \"&AMP;\": \"&\",\n            \"&Aacute\": \"Á\",\n            \"&Aacute;\": \"Á\",\n            \"&Abreve;\": \"Ă\",\n            \"&Acirc\": \"Â\",\n            \"&Acirc;\": \"Â\",\n            \"&Acy;\": \"А\",\n            \"&Afr;\": \"𝔄\",\n            \"&Agrave\": \"À\",\n            \"&Agrave;\": \"À\",\n            \"&Alpha;\": \"Α\",\n            \"&Amacr;\": \"Ā\",\n            \"&And;\": \"⩓\",\n            \"&Aogon;\": \"Ą\",\n            \"&Aopf;\": \"𝔸\",\n            \"&ApplyFunction;\": \"⁡\",\n            \"&Aring\": \"Å\",\n            \"&Aring;\": \"Å\",\n            \"&Ascr;\": \"𝒜\",\n            \"&Assign;\": \"≔\",\n            \"&Atilde\": \"Ã\",\n            \"&Atilde;\": \"Ã\",\n            \"&Auml\": \"Ä\",\n            \"&Auml;\": \"Ä\",\n            \"&Backslash;\": \"∖\",\n            \"&Barv;\": \"⫧\",\n            \"&Barwed;\": \"⌆\",\n            \"&Bcy;\": \"Б\",\n            \"&Because;\": \"∵\",\n            \"&Bernoullis;\": \"ℬ\",\n            \"&Beta;\": \"Β\",\n            \"&Bfr;\": \"𝔅\",\n            \"&Bopf;\": \"𝔹\",\n            \"&Breve;\": \"˘\",\n            \"&Bscr;\": \"ℬ\",\n            \"&Bumpeq;\": \"≎\",\n            \"&CHcy;\": \"Ч\",\n            \"&COPY\": \"©\",\n            \"&COPY;\": \"©\",\n            \"&Cacute;\": \"Ć\",\n            \"&Cap;\": \"⋒\",\n            \"&CapitalDifferentialD;\": \"ⅅ\",\n            \"&Cayleys;\": \"ℭ\",\n            \"&Ccaron;\": \"Č\",\n            \"&Ccedil\": \"Ç\",\n            \"&Ccedil;\": \"Ç\",\n            \"&Ccirc;\": \"Ĉ\",\n            \"&Cconint;\": \"∰\",\n            \"&Cdot;\": \"Ċ\",\n            \"&Cedilla;\": \"¸\",\n            \"&CenterDot;\": \"·\",\n            \"&Cfr;\": \"ℭ\",\n            \"&Chi;\": \"Χ\",\n            \"&CircleDot;\": \"⊙\",\n            \"&CircleMinus;\": \"⊖\",\n            \"&CirclePlus;\": \"⊕\",\n            \"&CircleTimes;\": \"⊗\",\n            \"&ClockwiseContourIntegral;\": \"∲\",\n            \"&CloseCurlyDoubleQuote;\": \"”\",\n            \"&CloseCurlyQuote;\": \"’\",\n            \"&Colon;\": \"∷\",\n            \"&Colone;\": \"⩴\",\n            \"&Congruent;\": \"≡\",\n            \"&Conint;\": \"∯\",\n            \"&ContourIntegral;\": \"∮\",\n            \"&Copf;\": \"ℂ\",\n            \"&Coproduct;\": \"∐\",\n            \"&CounterClockwiseContourIntegral;\": \"∳\",\n            \"&Cross;\": \"⨯\",\n            \"&Cscr;\": \"𝒞\",\n            \"&Cup;\": \"⋓\",\n            \"&CupCap;\": \"≍\",\n            \"&DD;\": \"ⅅ\",\n            \"&DDotrahd;\": \"⤑\",\n            \"&DJcy;\": \"Ђ\",\n            \"&DScy;\": \"Ѕ\",\n            \"&DZcy;\": \"Џ\",\n            \"&Dagger;\": \"‡\",\n            \"&Darr;\": \"↡\",\n            \"&Dashv;\": \"⫤\",\n            \"&Dcaron;\": \"Ď\",\n            \"&Dcy;\": \"Д\",\n            \"&Del;\": \"∇\",\n            \"&Delta;\": \"Δ\",\n            \"&Dfr;\": \"𝔇\",\n            \"&DiacriticalAcute;\": \"´\",\n            \"&DiacriticalDot;\": \"˙\",\n            \"&DiacriticalDoubleAcute;\": \"˝\",\n            \"&DiacriticalGrave;\": \"`\",\n            \"&DiacriticalTilde;\": \"˜\",\n            \"&Diamond;\": \"⋄\",\n            \"&DifferentialD;\": \"ⅆ\",\n            \"&Dopf;\": \"𝔻\",\n            \"&Dot;\": \"¨\",\n            \"&DotDot;\": \"⃜\",\n            \"&DotEqual;\": \"≐\",\n            \"&DoubleContourIntegral;\": \"∯\",\n            \"&DoubleDot;\": \"¨\",\n            \"&DoubleDownArrow;\": \"⇓\",\n            \"&DoubleLeftArrow;\": \"⇐\",\n            \"&DoubleLeftRightArrow;\": \"⇔\",\n            \"&DoubleLeftTee;\": \"⫤\",\n            \"&DoubleLongLeftArrow;\": \"⟸\",\n            \"&DoubleLongLeftRightArrow;\": \"⟺\",\n            \"&DoubleLongRightArrow;\": \"⟹\",\n            \"&DoubleRightArrow;\": \"⇒\",\n            \"&DoubleRightTee;\": \"⊨\",\n            \"&DoubleUpArrow;\": \"⇑\",\n            \"&DoubleUpDownArrow;\": \"⇕\",\n            \"&DoubleVerticalBar;\": \"∥\",\n            \"&DownArrow;\": \"↓\",\n            \"&DownArrowBar;\": \"⤓\",\n            \"&DownArrowUpArrow;\": \"⇵\",\n            \"&DownBreve;\": \"̑\",\n            \"&DownLeftRightVector;\": \"⥐\",\n            \"&DownLeftTeeVector;\": \"⥞\",\n            \"&DownLeftVector;\": \"↽\",\n            \"&DownLeftVectorBar;\": \"⥖\",\n            \"&DownRightTeeVector;\": \"⥟\",\n            \"&DownRightVector;\": \"⇁\",\n            \"&DownRightVectorBar;\": \"⥗\",\n            \"&DownTee;\": \"⊤\",\n            \"&DownTeeArrow;\": \"↧\",\n            \"&Downarrow;\": \"⇓\",\n            \"&Dscr;\": \"𝒟\",\n            \"&Dstrok;\": \"Đ\",\n            \"&ENG;\": \"Ŋ\",\n            \"&ETH\": \"Ð\",\n            \"&ETH;\": \"Ð\",\n            \"&Eacute\": \"É\",\n            \"&Eacute;\": \"É\",\n            \"&Ecaron;\": \"Ě\",\n            \"&Ecirc\": \"Ê\",\n            \"&Ecirc;\": \"Ê\",\n            \"&Ecy;\": \"Э\",\n            \"&Edot;\": \"Ė\",\n            \"&Efr;\": \"𝔈\",\n            \"&Egrave\": \"È\",\n            \"&Egrave;\": \"È\",\n            \"&Element;\": \"∈\",\n            \"&Emacr;\": \"Ē\",\n            \"&EmptySmallSquare;\": \"◻\",\n            \"&EmptyVerySmallSquare;\": \"▫\",\n            \"&Eogon;\": \"Ę\",\n            \"&Eopf;\": \"𝔼\",\n            \"&Epsilon;\": \"Ε\",\n            \"&Equal;\": \"⩵\",\n            \"&EqualTilde;\": \"≂\",\n            \"&Equilibrium;\": \"⇌\",\n            \"&Escr;\": \"ℰ\",\n            \"&Esim;\": \"⩳\",\n            \"&Eta;\": \"Η\",\n            \"&Euml\": \"Ë\",\n            \"&Euml;\": \"Ë\",\n            \"&Exists;\": \"∃\",\n            \"&ExponentialE;\": \"ⅇ\",\n            \"&Fcy;\": \"Ф\",\n            \"&Ffr;\": \"𝔉\",\n            \"&FilledSmallSquare;\": \"◼\",\n            \"&FilledVerySmallSquare;\": \"▪\",\n            \"&Fopf;\": \"𝔽\",\n            \"&ForAll;\": \"∀\",\n            \"&Fouriertrf;\": \"ℱ\",\n            \"&Fscr;\": \"ℱ\",\n            \"&GJcy;\": \"Ѓ\",\n            \"&GT\": \">\",\n            \"&GT;\": \">\",\n            \"&Gamma;\": \"Γ\",\n            \"&Gammad;\": \"Ϝ\",\n            \"&Gbreve;\": \"Ğ\",\n            \"&Gcedil;\": \"Ģ\",\n            \"&Gcirc;\": \"Ĝ\",\n            \"&Gcy;\": \"Г\",\n            \"&Gdot;\": \"Ġ\",\n            \"&Gfr;\": \"𝔊\",\n            \"&Gg;\": \"⋙\",\n            \"&Gopf;\": \"𝔾\",\n            \"&GreaterEqual;\": \"≥\",\n            \"&GreaterEqualLess;\": \"⋛\",\n            \"&GreaterFullEqual;\": \"≧\",\n            \"&GreaterGreater;\": \"⪢\",\n            \"&GreaterLess;\": \"≷\",\n            \"&GreaterSlantEqual;\": \"⩾\",\n            \"&GreaterTilde;\": \"≳\",\n            \"&Gscr;\": \"𝒢\",\n            \"&Gt;\": \"≫\",\n            \"&HARDcy;\": \"Ъ\",\n            \"&Hacek;\": \"ˇ\",\n            \"&Hat;\": \"^\",\n            \"&Hcirc;\": \"Ĥ\",\n            \"&Hfr;\": \"ℌ\",\n            \"&HilbertSpace;\": \"ℋ\",\n            \"&Hopf;\": \"ℍ\",\n            \"&HorizontalLine;\": \"─\",\n            \"&Hscr;\": \"ℋ\",\n            \"&Hstrok;\": \"Ħ\",\n            \"&HumpDownHump;\": \"≎\",\n            \"&HumpEqual;\": \"≏\",\n            \"&IEcy;\": \"Е\",\n            \"&IJlig;\": \"IJ\",\n            \"&IOcy;\": \"Ё\",\n            \"&Iacute\": \"Í\",\n            \"&Iacute;\": \"Í\",\n            \"&Icirc\": \"Î\",\n            \"&Icirc;\": \"Î\",\n            \"&Icy;\": \"И\",\n            \"&Idot;\": \"İ\",\n            \"&Ifr;\": \"ℑ\",\n            \"&Igrave\": \"Ì\",\n            \"&Igrave;\": \"Ì\",\n            \"&Im;\": \"ℑ\",\n            \"&Imacr;\": \"Ī\",\n            \"&ImaginaryI;\": \"ⅈ\",\n            \"&Implies;\": \"⇒\",\n            \"&Int;\": \"∬\",\n            \"&Integral;\": \"∫\",\n            \"&Intersection;\": \"⋂\",\n            \"&InvisibleComma;\": \"⁣\",\n            \"&InvisibleTimes;\": \"⁢\",\n            \"&Iogon;\": \"Į\",\n            \"&Iopf;\": \"𝕀\",\n            \"&Iota;\": \"Ι\",\n            \"&Iscr;\": \"ℐ\",\n            \"&Itilde;\": \"Ĩ\",\n            \"&Iukcy;\": \"І\",\n            \"&Iuml\": \"Ï\",\n            \"&Iuml;\": \"Ï\",\n            \"&Jcirc;\": \"Ĵ\",\n            \"&Jcy;\": \"Й\",\n            \"&Jfr;\": \"𝔍\",\n            \"&Jopf;\": \"𝕁\",\n            \"&Jscr;\": \"𝒥\",\n            \"&Jsercy;\": \"Ј\",\n            \"&Jukcy;\": \"Є\",\n            \"&KHcy;\": \"Х\",\n            \"&KJcy;\": \"Ќ\",\n            \"&Kappa;\": \"Κ\",\n            \"&Kcedil;\": \"Ķ\",\n            \"&Kcy;\": \"К\",\n            \"&Kfr;\": \"𝔎\",\n            \"&Kopf;\": \"𝕂\",\n            \"&Kscr;\": \"𝒦\",\n            \"&LJcy;\": \"Љ\",\n            \"&LT\": \"<\",\n            \"&LT;\": \"<\",\n            \"&Lacute;\": \"Ĺ\",\n            \"&Lambda;\": \"Λ\",\n            \"&Lang;\": \"⟪\",\n            \"&Laplacetrf;\": \"ℒ\",\n            \"&Larr;\": \"↞\",\n            \"&Lcaron;\": \"Ľ\",\n            \"&Lcedil;\": \"Ļ\",\n            \"&Lcy;\": \"Л\",\n            \"&LeftAngleBracket;\": \"⟨\",\n            \"&LeftArrow;\": \"←\",\n            \"&LeftArrowBar;\": \"⇤\",\n            \"&LeftArrowRightArrow;\": \"⇆\",\n            \"&LeftCeiling;\": \"⌈\",\n            \"&LeftDoubleBracket;\": \"⟦\",\n            \"&LeftDownTeeVector;\": \"⥡\",\n            \"&LeftDownVector;\": \"⇃\",\n            \"&LeftDownVectorBar;\": \"⥙\",\n            \"&LeftFloor;\": \"⌊\",\n            \"&LeftRightArrow;\": \"↔\",\n            \"&LeftRightVector;\": \"⥎\",\n            \"&LeftTee;\": \"⊣\",\n            \"&LeftTeeArrow;\": \"↤\",\n            \"&LeftTeeVector;\": \"⥚\",\n            \"&LeftTriangle;\": \"⊲\",\n            \"&LeftTriangleBar;\": \"⧏\",\n            \"&LeftTriangleEqual;\": \"⊴\",\n            \"&LeftUpDownVector;\": \"⥑\",\n            \"&LeftUpTeeVector;\": \"⥠\",\n            \"&LeftUpVector;\": \"↿\",\n            \"&LeftUpVectorBar;\": \"⥘\",\n            \"&LeftVector;\": \"↼\",\n            \"&LeftVectorBar;\": \"⥒\",\n            \"&Leftarrow;\": \"⇐\",\n            \"&Leftrightarrow;\": \"⇔\",\n            \"&LessEqualGreater;\": \"⋚\",\n            \"&LessFullEqual;\": \"≦\",\n            \"&LessGreater;\": \"≶\",\n            \"&LessLess;\": \"⪡\",\n            \"&LessSlantEqual;\": \"⩽\",\n            \"&LessTilde;\": \"≲\",\n            \"&Lfr;\": \"𝔏\",\n            \"&Ll;\": \"⋘\",\n            \"&Lleftarrow;\": \"⇚\",\n            \"&Lmidot;\": \"Ŀ\",\n            \"&LongLeftArrow;\": \"⟵\",\n            \"&LongLeftRightArrow;\": \"⟷\",\n            \"&LongRightArrow;\": \"⟶\",\n            \"&Longleftarrow;\": \"⟸\",\n            \"&Longleftrightarrow;\": \"⟺\",\n            \"&Longrightarrow;\": \"⟹\",\n            \"&Lopf;\": \"𝕃\",\n            \"&LowerLeftArrow;\": \"↙\",\n            \"&LowerRightArrow;\": \"↘\",\n            \"&Lscr;\": \"ℒ\",\n            \"&Lsh;\": \"↰\",\n            \"&Lstrok;\": \"Ł\",\n            \"&Lt;\": \"≪\",\n            \"&Map;\": \"⤅\",\n            \"&Mcy;\": \"М\",\n            \"&MediumSpace;\": \" \",\n            \"&Mellintrf;\": \"ℳ\",\n            \"&Mfr;\": \"𝔐\",\n            \"&MinusPlus;\": \"∓\",\n            \"&Mopf;\": \"𝕄\",\n            \"&Mscr;\": \"ℳ\",\n            \"&Mu;\": \"Μ\",\n            \"&NJcy;\": \"Њ\",\n            \"&Nacute;\": \"Ń\",\n            \"&Ncaron;\": \"Ň\",\n            \"&Ncedil;\": \"Ņ\",\n            \"&Ncy;\": \"Н\",\n            \"&NegativeMediumSpace;\": \"​\",\n            \"&NegativeThickSpace;\": \"​\",\n            \"&NegativeThinSpace;\": \"​\",\n            \"&NegativeVeryThinSpace;\": \"​\",\n            \"&NestedGreaterGreater;\": \"≫\",\n            \"&NestedLessLess;\": \"≪\",\n            \"&NewLine;\": \"\\n\",\n            \"&Nfr;\": \"𝔑\",\n            \"&NoBreak;\": \"⁠\",\n            \"&NonBreakingSpace;\": \" \",\n            \"&Nopf;\": \"ℕ\",\n            \"&Not;\": \"⫬\",\n            \"&NotCongruent;\": \"≢\",\n            \"&NotCupCap;\": \"≭\",\n            \"&NotDoubleVerticalBar;\": \"∦\",\n            \"&NotElement;\": \"∉\",\n            \"&NotEqual;\": \"≠\",\n            \"&NotEqualTilde;\": \"≂̸\",\n            \"&NotExists;\": \"∄\",\n            \"&NotGreater;\": \"≯\",\n            \"&NotGreaterEqual;\": \"≱\",\n            \"&NotGreaterFullEqual;\": \"≧̸\",\n            \"&NotGreaterGreater;\": \"≫̸\",\n            \"&NotGreaterLess;\": \"≹\",\n            \"&NotGreaterSlantEqual;\": \"⩾̸\",\n            \"&NotGreaterTilde;\": \"≵\",\n            \"&NotHumpDownHump;\": \"≎̸\",\n            \"&NotHumpEqual;\": \"≏̸\",\n            \"&NotLeftTriangle;\": \"⋪\",\n            \"&NotLeftTriangleBar;\": \"⧏̸\",\n            \"&NotLeftTriangleEqual;\": \"⋬\",\n            \"&NotLess;\": \"≮\",\n            \"&NotLessEqual;\": \"≰\",\n            \"&NotLessGreater;\": \"≸\",\n            \"&NotLessLess;\": \"≪̸\",\n            \"&NotLessSlantEqual;\": \"⩽̸\",\n            \"&NotLessTilde;\": \"≴\",\n            \"&NotNestedGreaterGreater;\": \"⪢̸\",\n            \"&NotNestedLessLess;\": \"⪡̸\",\n            \"&NotPrecedes;\": \"⊀\",\n            \"&NotPrecedesEqual;\": \"⪯̸\",\n            \"&NotPrecedesSlantEqual;\": \"⋠\",\n            \"&NotReverseElement;\": \"∌\",\n            \"&NotRightTriangle;\": \"⋫\",\n            \"&NotRightTriangleBar;\": \"⧐̸\",\n            \"&NotRightTriangleEqual;\": \"⋭\",\n            \"&NotSquareSubset;\": \"⊏̸\",\n            \"&NotSquareSubsetEqual;\": \"⋢\",\n            \"&NotSquareSuperset;\": \"⊐̸\",\n            \"&NotSquareSupersetEqual;\": \"⋣\",\n            \"&NotSubset;\": \"⊂⃒\",\n            \"&NotSubsetEqual;\": \"⊈\",\n            \"&NotSucceeds;\": \"⊁\",\n            \"&NotSucceedsEqual;\": \"⪰̸\",\n            \"&NotSucceedsSlantEqual;\": \"⋡\",\n            \"&NotSucceedsTilde;\": \"≿̸\",\n            \"&NotSuperset;\": \"⊃⃒\",\n            \"&NotSupersetEqual;\": \"⊉\",\n            \"&NotTilde;\": \"≁\",\n            \"&NotTildeEqual;\": \"≄\",\n            \"&NotTildeFullEqual;\": \"≇\",\n            \"&NotTildeTilde;\": \"≉\",\n            \"&NotVerticalBar;\": \"∤\",\n            \"&Nscr;\": \"𝒩\",\n            \"&Ntilde\": \"Ñ\",\n            \"&Ntilde;\": \"Ñ\",\n            \"&Nu;\": \"Ν\",\n            \"&OElig;\": \"Œ\",\n            \"&Oacute\": \"Ó\",\n            \"&Oacute;\": \"Ó\",\n            \"&Ocirc\": \"Ô\",\n            \"&Ocirc;\": \"Ô\",\n            \"&Ocy;\": \"О\",\n            \"&Odblac;\": \"Ő\",\n            \"&Ofr;\": \"𝔒\",\n            \"&Ograve\": \"Ò\",\n            \"&Ograve;\": \"Ò\",\n            \"&Omacr;\": \"Ō\",\n            \"&Omega;\": \"Ω\",\n            \"&Omicron;\": \"Ο\",\n            \"&Oopf;\": \"𝕆\",\n            \"&OpenCurlyDoubleQuote;\": \"“\",\n            \"&OpenCurlyQuote;\": \"‘\",\n            \"&Or;\": \"⩔\",\n            \"&Oscr;\": \"𝒪\",\n            \"&Oslash\": \"Ø\",\n            \"&Oslash;\": \"Ø\",\n            \"&Otilde\": \"Õ\",\n            \"&Otilde;\": \"Õ\",\n            \"&Otimes;\": \"⨷\",\n            \"&Ouml\": \"Ö\",\n            \"&Ouml;\": \"Ö\",\n            \"&OverBar;\": \"‾\",\n            \"&OverBrace;\": \"⏞\",\n            \"&OverBracket;\": \"⎴\",\n            \"&OverParenthesis;\": \"⏜\",\n            \"&PartialD;\": \"∂\",\n            \"&Pcy;\": \"П\",\n            \"&Pfr;\": \"𝔓\",\n            \"&Phi;\": \"Φ\",\n            \"&Pi;\": \"Π\",\n            \"&PlusMinus;\": \"±\",\n            \"&Poincareplane;\": \"ℌ\",\n            \"&Popf;\": \"ℙ\",\n            \"&Pr;\": \"⪻\",\n            \"&Precedes;\": \"≺\",\n            \"&PrecedesEqual;\": \"⪯\",\n            \"&PrecedesSlantEqual;\": \"≼\",\n            \"&PrecedesTilde;\": \"≾\",\n            \"&Prime;\": \"″\",\n            \"&Product;\": \"∏\",\n            \"&Proportion;\": \"∷\",\n            \"&Proportional;\": \"∝\",\n            \"&Pscr;\": \"𝒫\",\n            \"&Psi;\": \"Ψ\",\n            \"&QUOT\": \"\\\"\",\n            \"&QUOT;\": \"\\\"\",\n            \"&Qfr;\": \"𝔔\",\n            \"&Qopf;\": \"ℚ\",\n            \"&Qscr;\": \"𝒬\",\n            \"&RBarr;\": \"⤐\",\n            \"&REG\": \"®\",\n            \"&REG;\": \"®\",\n            \"&Racute;\": \"Ŕ\",\n            \"&Rang;\": \"⟫\",\n            \"&Rarr;\": \"↠\",\n            \"&Rarrtl;\": \"⤖\",\n            \"&Rcaron;\": \"Ř\",\n            \"&Rcedil;\": \"Ŗ\",\n            \"&Rcy;\": \"Р\",\n            \"&Re;\": \"ℜ\",\n            \"&ReverseElement;\": \"∋\",\n            \"&ReverseEquilibrium;\": \"⇋\",\n            \"&ReverseUpEquilibrium;\": \"⥯\",\n            \"&Rfr;\": \"ℜ\",\n            \"&Rho;\": \"Ρ\",\n            \"&RightAngleBracket;\": \"⟩\",\n            \"&RightArrow;\": \"→\",\n            \"&RightArrowBar;\": \"⇥\",\n            \"&RightArrowLeftArrow;\": \"⇄\",\n            \"&RightCeiling;\": \"⌉\",\n            \"&RightDoubleBracket;\": \"⟧\",\n            \"&RightDownTeeVector;\": \"⥝\",\n            \"&RightDownVector;\": \"⇂\",\n            \"&RightDownVectorBar;\": \"⥕\",\n            \"&RightFloor;\": \"⌋\",\n            \"&RightTee;\": \"⊢\",\n            \"&RightTeeArrow;\": \"↦\",\n            \"&RightTeeVector;\": \"⥛\",\n            \"&RightTriangle;\": \"⊳\",\n            \"&RightTriangleBar;\": \"⧐\",\n            \"&RightTriangleEqual;\": \"⊵\",\n            \"&RightUpDownVector;\": \"⥏\",\n            \"&RightUpTeeVector;\": \"⥜\",\n            \"&RightUpVector;\": \"↾\",\n            \"&RightUpVectorBar;\": \"⥔\",\n            \"&RightVector;\": \"⇀\",\n            \"&RightVectorBar;\": \"⥓\",\n            \"&Rightarrow;\": \"⇒\",\n            \"&Ropf;\": \"ℝ\",\n            \"&RoundImplies;\": \"⥰\",\n            \"&Rrightarrow;\": \"⇛\",\n            \"&Rscr;\": \"ℛ\",\n            \"&Rsh;\": \"↱\",\n            \"&RuleDelayed;\": \"⧴\",\n            \"&SHCHcy;\": \"Щ\",\n            \"&SHcy;\": \"Ш\",\n            \"&SOFTcy;\": \"Ь\",\n            \"&Sacute;\": \"Ś\",\n            \"&Sc;\": \"⪼\",\n            \"&Scaron;\": \"Š\",\n            \"&Scedil;\": \"Ş\",\n            \"&Scirc;\": \"Ŝ\",\n            \"&Scy;\": \"С\",\n            \"&Sfr;\": \"𝔖\",\n            \"&ShortDownArrow;\": \"↓\",\n            \"&ShortLeftArrow;\": \"←\",\n            \"&ShortRightArrow;\": \"→\",\n            \"&ShortUpArrow;\": \"↑\",\n            \"&Sigma;\": \"Σ\",\n            \"&SmallCircle;\": \"∘\",\n            \"&Sopf;\": \"𝕊\",\n            \"&Sqrt;\": \"√\",\n            \"&Square;\": \"□\",\n            \"&SquareIntersection;\": \"⊓\",\n            \"&SquareSubset;\": \"⊏\",\n            \"&SquareSubsetEqual;\": \"⊑\",\n            \"&SquareSuperset;\": \"⊐\",\n            \"&SquareSupersetEqual;\": \"⊒\",\n            \"&SquareUnion;\": \"⊔\",\n            \"&Sscr;\": \"𝒮\",\n            \"&Star;\": \"⋆\",\n            \"&Sub;\": \"⋐\",\n            \"&Subset;\": \"⋐\",\n            \"&SubsetEqual;\": \"⊆\",\n            \"&Succeeds;\": \"≻\",\n            \"&SucceedsEqual;\": \"⪰\",\n            \"&SucceedsSlantEqual;\": \"≽\",\n            \"&SucceedsTilde;\": \"≿\",\n            \"&SuchThat;\": \"∋\",\n            \"&Sum;\": \"∑\",\n            \"&Sup;\": \"⋑\",\n            \"&Superset;\": \"⊃\",\n            \"&SupersetEqual;\": \"⊇\",\n            \"&Supset;\": \"⋑\",\n            \"&THORN\": \"Þ\",\n            \"&THORN;\": \"Þ\",\n            \"&TRADE;\": \"™\",\n            \"&TSHcy;\": \"Ћ\",\n            \"&TScy;\": \"Ц\",\n            \"&Tab;\": \"\\t\",\n            \"&Tau;\": \"Τ\",\n            \"&Tcaron;\": \"Ť\",\n            \"&Tcedil;\": \"Ţ\",\n            \"&Tcy;\": \"Т\",\n            \"&Tfr;\": \"𝔗\",\n            \"&Therefore;\": \"∴\",\n            \"&Theta;\": \"Θ\",\n            \"&ThickSpace;\": \"  \",\n            \"&ThinSpace;\": \" \",\n            \"&Tilde;\": \"∼\",\n            \"&TildeEqual;\": \"≃\",\n            \"&TildeFullEqual;\": \"≅\",\n            \"&TildeTilde;\": \"≈\",\n            \"&Topf;\": \"𝕋\",\n            \"&TripleDot;\": \"⃛\",\n            \"&Tscr;\": \"𝒯\",\n            \"&Tstrok;\": \"Ŧ\",\n            \"&Uacute\": \"Ú\",\n            \"&Uacute;\": \"Ú\",\n            \"&Uarr;\": \"↟\",\n            \"&Uarrocir;\": \"⥉\",\n            \"&Ubrcy;\": \"Ў\",\n            \"&Ubreve;\": \"Ŭ\",\n            \"&Ucirc\": \"Û\",\n            \"&Ucirc;\": \"Û\",\n            \"&Ucy;\": \"У\",\n            \"&Udblac;\": \"Ű\",\n            \"&Ufr;\": \"𝔘\",\n            \"&Ugrave\": \"Ù\",\n            \"&Ugrave;\": \"Ù\",\n            \"&Umacr;\": \"Ū\",\n            \"&UnderBar;\": \"_\",\n            \"&UnderBrace;\": \"⏟\",\n            \"&UnderBracket;\": \"⎵\",\n            \"&UnderParenthesis;\": \"⏝\",\n            \"&Union;\": \"⋃\",\n            \"&UnionPlus;\": \"⊎\",\n            \"&Uogon;\": \"Ų\",\n            \"&Uopf;\": \"𝕌\",\n            \"&UpArrow;\": \"↑\",\n            \"&UpArrowBar;\": \"⤒\",\n            \"&UpArrowDownArrow;\": \"⇅\",\n            \"&UpDownArrow;\": \"↕\",\n            \"&UpEquilibrium;\": \"⥮\",\n            \"&UpTee;\": \"⊥\",\n            \"&UpTeeArrow;\": \"↥\",\n            \"&Uparrow;\": \"⇑\",\n            \"&Updownarrow;\": \"⇕\",\n            \"&UpperLeftArrow;\": \"↖\",\n            \"&UpperRightArrow;\": \"↗\",\n            \"&Upsi;\": \"ϒ\",\n            \"&Upsilon;\": \"Υ\",\n            \"&Uring;\": \"Ů\",\n            \"&Uscr;\": \"𝒰\",\n            \"&Utilde;\": \"Ũ\",\n            \"&Uuml\": \"Ü\",\n            \"&Uuml;\": \"Ü\",\n            \"&VDash;\": \"⊫\",\n            \"&Vbar;\": \"⫫\",\n            \"&Vcy;\": \"В\",\n            \"&Vdash;\": \"⊩\",\n            \"&Vdashl;\": \"⫦\",\n            \"&Vee;\": \"⋁\",\n            \"&Verbar;\": \"‖\",\n            \"&Vert;\": \"‖\",\n            \"&VerticalBar;\": \"∣\",\n            \"&VerticalLine;\": \"|\",\n            \"&VerticalSeparator;\": \"❘\",\n            \"&VerticalTilde;\": \"≀\",\n            \"&VeryThinSpace;\": \" \",\n            \"&Vfr;\": \"𝔙\",\n            \"&Vopf;\": \"𝕍\",\n            \"&Vscr;\": \"𝒱\",\n            \"&Vvdash;\": \"⊪\",\n            \"&Wcirc;\": \"Ŵ\",\n            \"&Wedge;\": \"⋀\",\n            \"&Wfr;\": \"𝔚\",\n            \"&Wopf;\": \"𝕎\",\n            \"&Wscr;\": \"𝒲\",\n            \"&Xfr;\": \"𝔛\",\n            \"&Xi;\": \"Ξ\",\n            \"&Xopf;\": \"𝕏\",\n            \"&Xscr;\": \"𝒳\",\n            \"&YAcy;\": \"Я\",\n            \"&YIcy;\": \"Ї\",\n            \"&YUcy;\": \"Ю\",\n            \"&Yacute\": \"Ý\",\n            \"&Yacute;\": \"Ý\",\n            \"&Ycirc;\": \"Ŷ\",\n            \"&Ycy;\": \"Ы\",\n            \"&Yfr;\": \"𝔜\",\n            \"&Yopf;\": \"𝕐\",\n            \"&Yscr;\": \"𝒴\",\n            \"&Yuml;\": \"Ÿ\",\n            \"&ZHcy;\": \"Ж\",\n            \"&Zacute;\": \"Ź\",\n            \"&Zcaron;\": \"Ž\",\n            \"&Zcy;\": \"З\",\n            \"&Zdot;\": \"Ż\",\n            \"&ZeroWidthSpace;\": \"​\",\n            \"&Zeta;\": \"Ζ\",\n            \"&Zfr;\": \"ℨ\",\n            \"&Zopf;\": \"ℤ\",\n            \"&Zscr;\": \"𝒵\",\n            \"&aacute\": \"á\",\n            \"&aacute;\": \"á\",\n            \"&abreve;\": \"ă\",\n            \"&ac;\": \"∾\",\n            \"&acE;\": \"∾̳\",\n            \"&acd;\": \"∿\",\n            \"&acirc\": \"â\",\n            \"&acirc;\": \"â\",\n            \"&acute\": \"´\",\n            \"&acute;\": \"´\",\n            \"&acy;\": \"а\",\n            \"&aelig\": \"æ\",\n            \"&aelig;\": \"æ\",\n            \"&af;\": \"⁡\",\n            \"&afr;\": \"𝔞\",\n            \"&agrave\": \"à\",\n            \"&agrave;\": \"à\",\n            \"&alefsym;\": \"ℵ\",\n            \"&aleph;\": \"ℵ\",\n            \"&alpha;\": \"α\",\n            \"&amacr;\": \"ā\",\n            \"&amalg;\": \"⨿\",\n            \"&amp\": \"&\",\n            \"&amp;\": \"&\",\n            \"&and;\": \"∧\",\n            \"&andand;\": \"⩕\",\n            \"&andd;\": \"⩜\",\n            \"&andslope;\": \"⩘\",\n            \"&andv;\": \"⩚\",\n            \"&ang;\": \"∠\",\n            \"&ange;\": \"⦤\",\n            \"&angle;\": \"∠\",\n            \"&angmsd;\": \"∡\",\n            \"&angmsdaa;\": \"⦨\",\n            \"&angmsdab;\": \"⦩\",\n            \"&angmsdac;\": \"⦪\",\n            \"&angmsdad;\": \"⦫\",\n            \"&angmsdae;\": \"⦬\",\n            \"&angmsdaf;\": \"⦭\",\n            \"&angmsdag;\": \"⦮\",\n            \"&angmsdah;\": \"⦯\",\n            \"&angrt;\": \"∟\",\n            \"&angrtvb;\": \"⊾\",\n            \"&angrtvbd;\": \"⦝\",\n            \"&angsph;\": \"∢\",\n            \"&angst;\": \"Å\",\n            \"&angzarr;\": \"⍼\",\n            \"&aogon;\": \"ą\",\n            \"&aopf;\": \"𝕒\",\n            \"&ap;\": \"≈\",\n            \"&apE;\": \"⩰\",\n            \"&apacir;\": \"⩯\",\n            \"&ape;\": \"≊\",\n            \"&apid;\": \"≋\",\n            \"&apos;\": \"'\",\n            \"&approx;\": \"≈\",\n            \"&approxeq;\": \"≊\",\n            \"&aring\": \"å\",\n            \"&aring;\": \"å\",\n            \"&ascr;\": \"𝒶\",\n            \"&ast;\": \"*\",\n            \"&asymp;\": \"≈\",\n            \"&asympeq;\": \"≍\",\n            \"&atilde\": \"ã\",\n            \"&atilde;\": \"ã\",\n            \"&auml\": \"ä\",\n            \"&auml;\": \"ä\",\n            \"&awconint;\": \"∳\",\n            \"&awint;\": \"⨑\",\n            \"&bNot;\": \"⫭\",\n            \"&backcong;\": \"≌\",\n            \"&backepsilon;\": \"϶\",\n            \"&backprime;\": \"‵\",\n            \"&backsim;\": \"∽\",\n            \"&backsimeq;\": \"⋍\",\n            \"&barvee;\": \"⊽\",\n            \"&barwed;\": \"⌅\",\n            \"&barwedge;\": \"⌅\",\n            \"&bbrk;\": \"⎵\",\n            \"&bbrktbrk;\": \"⎶\",\n            \"&bcong;\": \"≌\",\n            \"&bcy;\": \"б\",\n            \"&bdquo;\": \"„\",\n            \"&becaus;\": \"∵\",\n            \"&because;\": \"∵\",\n            \"&bemptyv;\": \"⦰\",\n            \"&bepsi;\": \"϶\",\n            \"&bernou;\": \"ℬ\",\n            \"&beta;\": \"β\",\n            \"&beth;\": \"ℶ\",\n            \"&between;\": \"≬\",\n            \"&bfr;\": \"𝔟\",\n            \"&bigcap;\": \"⋂\",\n            \"&bigcirc;\": \"◯\",\n            \"&bigcup;\": \"⋃\",\n            \"&bigodot;\": \"⨀\",\n            \"&bigoplus;\": \"⨁\",\n            \"&bigotimes;\": \"⨂\",\n            \"&bigsqcup;\": \"⨆\",\n            \"&bigstar;\": \"★\",\n            \"&bigtriangledown;\": \"▽\",\n            \"&bigtriangleup;\": \"△\",\n            \"&biguplus;\": \"⨄\",\n            \"&bigvee;\": \"⋁\",\n            \"&bigwedge;\": \"⋀\",\n            \"&bkarow;\": \"⤍\",\n            \"&blacklozenge;\": \"⧫\",\n            \"&blacksquare;\": \"▪\",\n            \"&blacktriangle;\": \"▴\",\n            \"&blacktriangledown;\": \"▾\",\n            \"&blacktriangleleft;\": \"◂\",\n            \"&blacktriangleright;\": \"▸\",\n            \"&blank;\": \"␣\",\n            \"&blk12;\": \"▒\",\n            \"&blk14;\": \"░\",\n            \"&blk34;\": \"▓\",\n            \"&block;\": \"█\",\n            \"&bne;\": \"=⃥\",\n            \"&bnequiv;\": \"≡⃥\",\n            \"&bnot;\": \"⌐\",\n            \"&bopf;\": \"𝕓\",\n            \"&bot;\": \"⊥\",\n            \"&bottom;\": \"⊥\",\n            \"&bowtie;\": \"⋈\",\n            \"&boxDL;\": \"╗\",\n            \"&boxDR;\": \"╔\",\n            \"&boxDl;\": \"╖\",\n            \"&boxDr;\": \"╓\",\n            \"&boxH;\": \"═\",\n            \"&boxHD;\": \"╦\",\n            \"&boxHU;\": \"╩\",\n            \"&boxHd;\": \"╤\",\n            \"&boxHu;\": \"╧\",\n            \"&boxUL;\": \"╝\",\n            \"&boxUR;\": \"╚\",\n            \"&boxUl;\": \"╜\",\n            \"&boxUr;\": \"╙\",\n            \"&boxV;\": \"║\",\n            \"&boxVH;\": \"╬\",\n            \"&boxVL;\": \"╣\",\n            \"&boxVR;\": \"╠\",\n            \"&boxVh;\": \"╫\",\n            \"&boxVl;\": \"╢\",\n            \"&boxVr;\": \"╟\",\n            \"&boxbox;\": \"⧉\",\n            \"&boxdL;\": \"╕\",\n            \"&boxdR;\": \"╒\",\n            \"&boxdl;\": \"┐\",\n            \"&boxdr;\": \"┌\",\n            \"&boxh;\": \"─\",\n            \"&boxhD;\": \"╥\",\n            \"&boxhU;\": \"╨\",\n            \"&boxhd;\": \"┬\",\n            \"&boxhu;\": \"┴\",\n            \"&boxminus;\": \"⊟\",\n            \"&boxplus;\": \"⊞\",\n            \"&boxtimes;\": \"⊠\",\n            \"&boxuL;\": \"╛\",\n            \"&boxuR;\": \"╘\",\n            \"&boxul;\": \"┘\",\n            \"&boxur;\": \"└\",\n            \"&boxv;\": \"│\",\n            \"&boxvH;\": \"╪\",\n            \"&boxvL;\": \"╡\",\n            \"&boxvR;\": \"╞\",\n            \"&boxvh;\": \"┼\",\n            \"&boxvl;\": \"┤\",\n            \"&boxvr;\": \"├\",\n            \"&bprime;\": \"‵\",\n            \"&breve;\": \"˘\",\n            \"&brvbar\": \"¦\",\n            \"&brvbar;\": \"¦\",\n            \"&bscr;\": \"𝒷\",\n            \"&bsemi;\": \"⁏\",\n            \"&bsim;\": \"∽\",\n            \"&bsime;\": \"⋍\",\n            \"&bsol;\": \"\\\\\",\n            \"&bsolb;\": \"⧅\",\n            \"&bsolhsub;\": \"⟈\",\n            \"&bull;\": \"•\",\n            \"&bullet;\": \"•\",\n            \"&bump;\": \"≎\",\n            \"&bumpE;\": \"⪮\",\n            \"&bumpe;\": \"≏\",\n            \"&bumpeq;\": \"≏\",\n            \"&cacute;\": \"ć\",\n            \"&cap;\": \"∩\",\n            \"&capand;\": \"⩄\",\n            \"&capbrcup;\": \"⩉\",\n            \"&capcap;\": \"⩋\",\n            \"&capcup;\": \"⩇\",\n            \"&capdot;\": \"⩀\",\n            \"&caps;\": \"∩︀\",\n            \"&caret;\": \"⁁\",\n            \"&caron;\": \"ˇ\",\n            \"&ccaps;\": \"⩍\",\n            \"&ccaron;\": \"č\",\n            \"&ccedil\": \"ç\",\n            \"&ccedil;\": \"ç\",\n            \"&ccirc;\": \"ĉ\",\n            \"&ccups;\": \"⩌\",\n            \"&ccupssm;\": \"⩐\",\n            \"&cdot;\": \"ċ\",\n            \"&cedil\": \"¸\",\n            \"&cedil;\": \"¸\",\n            \"&cemptyv;\": \"⦲\",\n            \"&cent\": \"¢\",\n            \"&cent;\": \"¢\",\n            \"&centerdot;\": \"·\",\n            \"&cfr;\": \"𝔠\",\n            \"&chcy;\": \"ч\",\n            \"&check;\": \"✓\",\n            \"&checkmark;\": \"✓\",\n            \"&chi;\": \"χ\",\n            \"&cir;\": \"○\",\n            \"&cirE;\": \"⧃\",\n            \"&circ;\": \"ˆ\",\n            \"&circeq;\": \"≗\",\n            \"&circlearrowleft;\": \"↺\",\n            \"&circlearrowright;\": \"↻\",\n            \"&circledR;\": \"®\",\n            \"&circledS;\": \"Ⓢ\",\n            \"&circledast;\": \"⊛\",\n            \"&circledcirc;\": \"⊚\",\n            \"&circleddash;\": \"⊝\",\n            \"&cire;\": \"≗\",\n            \"&cirfnint;\": \"⨐\",\n            \"&cirmid;\": \"⫯\",\n            \"&cirscir;\": \"⧂\",\n            \"&clubs;\": \"♣\",\n            \"&clubsuit;\": \"♣\",\n            \"&colon;\": \":\",\n            \"&colone;\": \"≔\",\n            \"&coloneq;\": \"≔\",\n            \"&comma;\": \",\",\n            \"&commat;\": \"@\",\n            \"&comp;\": \"∁\",\n            \"&compfn;\": \"∘\",\n            \"&complement;\": \"∁\",\n            \"&complexes;\": \"ℂ\",\n            \"&cong;\": \"≅\",\n            \"&congdot;\": \"⩭\",\n            \"&conint;\": \"∮\",\n            \"&copf;\": \"𝕔\",\n            \"&coprod;\": \"∐\",\n            \"&copy\": \"©\",\n            \"&copy;\": \"©\",\n            \"&copysr;\": \"℗\",\n            \"&crarr;\": \"↵\",\n            \"&cross;\": \"✗\",\n            \"&cscr;\": \"𝒸\",\n            \"&csub;\": \"⫏\",\n            \"&csube;\": \"⫑\",\n            \"&csup;\": \"⫐\",\n            \"&csupe;\": \"⫒\",\n            \"&ctdot;\": \"⋯\",\n            \"&cudarrl;\": \"⤸\",\n            \"&cudarrr;\": \"⤵\",\n            \"&cuepr;\": \"⋞\",\n            \"&cuesc;\": \"⋟\",\n            \"&cularr;\": \"↶\",\n            \"&cularrp;\": \"⤽\",\n            \"&cup;\": \"∪\",\n            \"&cupbrcap;\": \"⩈\",\n            \"&cupcap;\": \"⩆\",\n            \"&cupcup;\": \"⩊\",\n            \"&cupdot;\": \"⊍\",\n            \"&cupor;\": \"⩅\",\n            \"&cups;\": \"∪︀\",\n            \"&curarr;\": \"↷\",\n            \"&curarrm;\": \"⤼\",\n            \"&curlyeqprec;\": \"⋞\",\n            \"&curlyeqsucc;\": \"⋟\",\n            \"&curlyvee;\": \"⋎\",\n            \"&curlywedge;\": \"⋏\",\n            \"&curren\": \"¤\",\n            \"&curren;\": \"¤\",\n            \"&curvearrowleft;\": \"↶\",\n            \"&curvearrowright;\": \"↷\",\n            \"&cuvee;\": \"⋎\",\n            \"&cuwed;\": \"⋏\",\n            \"&cwconint;\": \"∲\",\n            \"&cwint;\": \"∱\",\n            \"&cylcty;\": \"⌭\",\n            \"&dArr;\": \"⇓\",\n            \"&dHar;\": \"⥥\",\n            \"&dagger;\": \"†\",\n            \"&daleth;\": \"ℸ\",\n            \"&darr;\": \"↓\",\n            \"&dash;\": \"‐\",\n            \"&dashv;\": \"⊣\",\n            \"&dbkarow;\": \"⤏\",\n            \"&dblac;\": \"˝\",\n            \"&dcaron;\": \"ď\",\n            \"&dcy;\": \"д\",\n            \"&dd;\": \"ⅆ\",\n            \"&ddagger;\": \"‡\",\n            \"&ddarr;\": \"⇊\",\n            \"&ddotseq;\": \"⩷\",\n            \"&deg\": \"°\",\n            \"&deg;\": \"°\",\n            \"&delta;\": \"δ\",\n            \"&demptyv;\": \"⦱\",\n            \"&dfisht;\": \"⥿\",\n            \"&dfr;\": \"𝔡\",\n            \"&dharl;\": \"⇃\",\n            \"&dharr;\": \"⇂\",\n            \"&diam;\": \"⋄\",\n            \"&diamond;\": \"⋄\",\n            \"&diamondsuit;\": \"♦\",\n            \"&diams;\": \"♦\",\n            \"&die;\": \"¨\",\n            \"&digamma;\": \"ϝ\",\n            \"&disin;\": \"⋲\",\n            \"&div;\": \"÷\",\n            \"&divide\": \"÷\",\n            \"&divide;\": \"÷\",\n            \"&divideontimes;\": \"⋇\",\n            \"&divonx;\": \"⋇\",\n            \"&djcy;\": \"ђ\",\n            \"&dlcorn;\": \"⌞\",\n            \"&dlcrop;\": \"⌍\",\n            \"&dollar;\": \"$\",\n            \"&dopf;\": \"𝕕\",\n            \"&dot;\": \"˙\",\n            \"&doteq;\": \"≐\",\n            \"&doteqdot;\": \"≑\",\n            \"&dotminus;\": \"∸\",\n            \"&dotplus;\": \"∔\",\n            \"&dotsquare;\": \"⊡\",\n            \"&doublebarwedge;\": \"⌆\",\n            \"&downarrow;\": \"↓\",\n            \"&downdownarrows;\": \"⇊\",\n            \"&downharpoonleft;\": \"⇃\",\n            \"&downharpoonright;\": \"⇂\",\n            \"&drbkarow;\": \"⤐\",\n            \"&drcorn;\": \"⌟\",\n            \"&drcrop;\": \"⌌\",\n            \"&dscr;\": \"𝒹\",\n            \"&dscy;\": \"ѕ\",\n            \"&dsol;\": \"⧶\",\n            \"&dstrok;\": \"đ\",\n            \"&dtdot;\": \"⋱\",\n            \"&dtri;\": \"▿\",\n            \"&dtrif;\": \"▾\",\n            \"&duarr;\": \"⇵\",\n            \"&duhar;\": \"⥯\",\n            \"&dwangle;\": \"⦦\",\n            \"&dzcy;\": \"џ\",\n            \"&dzigrarr;\": \"⟿\",\n            \"&eDDot;\": \"⩷\",\n            \"&eDot;\": \"≑\",\n            \"&eacute\": \"é\",\n            \"&eacute;\": \"é\",\n            \"&easter;\": \"⩮\",\n            \"&ecaron;\": \"ě\",\n            \"&ecir;\": \"≖\",\n            \"&ecirc\": \"ê\",\n            \"&ecirc;\": \"ê\",\n            \"&ecolon;\": \"≕\",\n            \"&ecy;\": \"э\",\n            \"&edot;\": \"ė\",\n            \"&ee;\": \"ⅇ\",\n            \"&efDot;\": \"≒\",\n            \"&efr;\": \"𝔢\",\n            \"&eg;\": \"⪚\",\n            \"&egrave\": \"è\",\n            \"&egrave;\": \"è\",\n            \"&egs;\": \"⪖\",\n            \"&egsdot;\": \"⪘\",\n            \"&el;\": \"⪙\",\n            \"&elinters;\": \"⏧\",\n            \"&ell;\": \"ℓ\",\n            \"&els;\": \"⪕\",\n            \"&elsdot;\": \"⪗\",\n            \"&emacr;\": \"ē\",\n            \"&empty;\": \"∅\",\n            \"&emptyset;\": \"∅\",\n            \"&emptyv;\": \"∅\",\n            \"&emsp13;\": \" \",\n            \"&emsp14;\": \" \",\n            \"&emsp;\": \" \",\n            \"&eng;\": \"ŋ\",\n            \"&ensp;\": \" \",\n            \"&eogon;\": \"ę\",\n            \"&eopf;\": \"𝕖\",\n            \"&epar;\": \"⋕\",\n            \"&eparsl;\": \"⧣\",\n            \"&eplus;\": \"⩱\",\n            \"&epsi;\": \"ε\",\n            \"&epsilon;\": \"ε\",\n            \"&epsiv;\": \"ϵ\",\n            \"&eqcirc;\": \"≖\",\n            \"&eqcolon;\": \"≕\",\n            \"&eqsim;\": \"≂\",\n            \"&eqslantgtr;\": \"⪖\",\n            \"&eqslantless;\": \"⪕\",\n            \"&equals;\": \"=\",\n            \"&equest;\": \"≟\",\n            \"&equiv;\": \"≡\",\n            \"&equivDD;\": \"⩸\",\n            \"&eqvparsl;\": \"⧥\",\n            \"&erDot;\": \"≓\",\n            \"&erarr;\": \"⥱\",\n            \"&escr;\": \"ℯ\",\n            \"&esdot;\": \"≐\",\n            \"&esim;\": \"≂\",\n            \"&eta;\": \"η\",\n            \"&eth\": \"ð\",\n            \"&eth;\": \"ð\",\n            \"&euml\": \"ë\",\n            \"&euml;\": \"ë\",\n            \"&euro;\": \"€\",\n            \"&excl;\": \"!\",\n            \"&exist;\": \"∃\",\n            \"&expectation;\": \"ℰ\",\n            \"&exponentiale;\": \"ⅇ\",\n            \"&fallingdotseq;\": \"≒\",\n            \"&fcy;\": \"ф\",\n            \"&female;\": \"♀\",\n            \"&ffilig;\": \"ffi\",\n            \"&fflig;\": \"ff\",\n            \"&ffllig;\": \"ffl\",\n            \"&ffr;\": \"𝔣\",\n            \"&filig;\": \"fi\",\n            \"&fjlig;\": \"fj\",\n            \"&flat;\": \"♭\",\n            \"&fllig;\": \"fl\",\n            \"&fltns;\": \"▱\",\n            \"&fnof;\": \"ƒ\",\n            \"&fopf;\": \"𝕗\",\n            \"&forall;\": \"∀\",\n            \"&fork;\": \"⋔\",\n            \"&forkv;\": \"⫙\",\n            \"&fpartint;\": \"⨍\",\n            \"&frac12\": \"½\",\n            \"&frac12;\": \"½\",\n            \"&frac13;\": \"⅓\",\n            \"&frac14\": \"¼\",\n            \"&frac14;\": \"¼\",\n            \"&frac15;\": \"⅕\",\n            \"&frac16;\": \"⅙\",\n            \"&frac18;\": \"⅛\",\n            \"&frac23;\": \"⅔\",\n            \"&frac25;\": \"⅖\",\n            \"&frac34\": \"¾\",\n            \"&frac34;\": \"¾\",\n            \"&frac35;\": \"⅗\",\n            \"&frac38;\": \"⅜\",\n            \"&frac45;\": \"⅘\",\n            \"&frac56;\": \"⅚\",\n            \"&frac58;\": \"⅝\",\n            \"&frac78;\": \"⅞\",\n            \"&frasl;\": \"⁄\",\n            \"&frown;\": \"⌢\",\n            \"&fscr;\": \"𝒻\",\n            \"&gE;\": \"≧\",\n            \"&gEl;\": \"⪌\",\n            \"&gacute;\": \"ǵ\",\n            \"&gamma;\": \"γ\",\n            \"&gammad;\": \"ϝ\",\n            \"&gap;\": \"⪆\",\n            \"&gbreve;\": \"ğ\",\n            \"&gcirc;\": \"ĝ\",\n            \"&gcy;\": \"г\",\n            \"&gdot;\": \"ġ\",\n            \"&ge;\": \"≥\",\n            \"&gel;\": \"⋛\",\n            \"&geq;\": \"≥\",\n            \"&geqq;\": \"≧\",\n            \"&geqslant;\": \"⩾\",\n            \"&ges;\": \"⩾\",\n            \"&gescc;\": \"⪩\",\n            \"&gesdot;\": \"⪀\",\n            \"&gesdoto;\": \"⪂\",\n            \"&gesdotol;\": \"⪄\",\n            \"&gesl;\": \"⋛︀\",\n            \"&gesles;\": \"⪔\",\n            \"&gfr;\": \"𝔤\",\n            \"&gg;\": \"≫\",\n            \"&ggg;\": \"⋙\",\n            \"&gimel;\": \"ℷ\",\n            \"&gjcy;\": \"ѓ\",\n            \"&gl;\": \"≷\",\n            \"&glE;\": \"⪒\",\n            \"&gla;\": \"⪥\",\n            \"&glj;\": \"⪤\",\n            \"&gnE;\": \"≩\",\n            \"&gnap;\": \"⪊\",\n            \"&gnapprox;\": \"⪊\",\n            \"&gne;\": \"⪈\",\n            \"&gneq;\": \"⪈\",\n            \"&gneqq;\": \"≩\",\n            \"&gnsim;\": \"⋧\",\n            \"&gopf;\": \"𝕘\",\n            \"&grave;\": \"`\",\n            \"&gscr;\": \"ℊ\",\n            \"&gsim;\": \"≳\",\n            \"&gsime;\": \"⪎\",\n            \"&gsiml;\": \"⪐\",\n            \"&gt\": \">\",\n            \"&gt;\": \">\",\n            \"&gtcc;\": \"⪧\",\n            \"&gtcir;\": \"⩺\",\n            \"&gtdot;\": \"⋗\",\n            \"&gtlPar;\": \"⦕\",\n            \"&gtquest;\": \"⩼\",\n            \"&gtrapprox;\": \"⪆\",\n            \"&gtrarr;\": \"⥸\",\n            \"&gtrdot;\": \"⋗\",\n            \"&gtreqless;\": \"⋛\",\n            \"&gtreqqless;\": \"⪌\",\n            \"&gtrless;\": \"≷\",\n            \"&gtrsim;\": \"≳\",\n            \"&gvertneqq;\": \"≩︀\",\n            \"&gvnE;\": \"≩︀\",\n            \"&hArr;\": \"⇔\",\n            \"&hairsp;\": \" \",\n            \"&half;\": \"½\",\n            \"&hamilt;\": \"ℋ\",\n            \"&hardcy;\": \"ъ\",\n            \"&harr;\": \"↔\",\n            \"&harrcir;\": \"⥈\",\n            \"&harrw;\": \"↭\",\n            \"&hbar;\": \"ℏ\",\n            \"&hcirc;\": \"ĥ\",\n            \"&hearts;\": \"♥\",\n            \"&heartsuit;\": \"♥\",\n            \"&hellip;\": \"…\",\n            \"&hercon;\": \"⊹\",\n            \"&hfr;\": \"𝔥\",\n            \"&hksearow;\": \"⤥\",\n            \"&hkswarow;\": \"⤦\",\n            \"&hoarr;\": \"⇿\",\n            \"&homtht;\": \"∻\",\n            \"&hookleftarrow;\": \"↩\",\n            \"&hookrightarrow;\": \"↪\",\n            \"&hopf;\": \"𝕙\",\n            \"&horbar;\": \"―\",\n            \"&hscr;\": \"𝒽\",\n            \"&hslash;\": \"ℏ\",\n            \"&hstrok;\": \"ħ\",\n            \"&hybull;\": \"⁃\",\n            \"&hyphen;\": \"‐\",\n            \"&iacute\": \"í\",\n            \"&iacute;\": \"í\",\n            \"&ic;\": \"⁣\",\n            \"&icirc\": \"î\",\n            \"&icirc;\": \"î\",\n            \"&icy;\": \"и\",\n            \"&iecy;\": \"е\",\n            \"&iexcl\": \"¡\",\n            \"&iexcl;\": \"¡\",\n            \"&iff;\": \"⇔\",\n            \"&ifr;\": \"𝔦\",\n            \"&igrave\": \"ì\",\n            \"&igrave;\": \"ì\",\n            \"&ii;\": \"ⅈ\",\n            \"&iiiint;\": \"⨌\",\n            \"&iiint;\": \"∭\",\n            \"&iinfin;\": \"⧜\",\n            \"&iiota;\": \"℩\",\n            \"&ijlig;\": \"ij\",\n            \"&imacr;\": \"ī\",\n            \"&image;\": \"ℑ\",\n            \"&imagline;\": \"ℐ\",\n            \"&imagpart;\": \"ℑ\",\n            \"&imath;\": \"ı\",\n            \"&imof;\": \"⊷\",\n            \"&imped;\": \"Ƶ\",\n            \"&in;\": \"∈\",\n            \"&incare;\": \"℅\",\n            \"&infin;\": \"∞\",\n            \"&infintie;\": \"⧝\",\n            \"&inodot;\": \"ı\",\n            \"&int;\": \"∫\",\n            \"&intcal;\": \"⊺\",\n            \"&integers;\": \"ℤ\",\n            \"&intercal;\": \"⊺\",\n            \"&intlarhk;\": \"⨗\",\n            \"&intprod;\": \"⨼\",\n            \"&iocy;\": \"ё\",\n            \"&iogon;\": \"į\",\n            \"&iopf;\": \"𝕚\",\n            \"&iota;\": \"ι\",\n            \"&iprod;\": \"⨼\",\n            \"&iquest\": \"¿\",\n            \"&iquest;\": \"¿\",\n            \"&iscr;\": \"𝒾\",\n            \"&isin;\": \"∈\",\n            \"&isinE;\": \"⋹\",\n            \"&isindot;\": \"⋵\",\n            \"&isins;\": \"⋴\",\n            \"&isinsv;\": \"⋳\",\n            \"&isinv;\": \"∈\",\n            \"&it;\": \"⁢\",\n            \"&itilde;\": \"ĩ\",\n            \"&iukcy;\": \"і\",\n            \"&iuml\": \"ï\",\n            \"&iuml;\": \"ï\",\n            \"&jcirc;\": \"ĵ\",\n            \"&jcy;\": \"й\",\n            \"&jfr;\": \"𝔧\",\n            \"&jmath;\": \"ȷ\",\n            \"&jopf;\": \"𝕛\",\n            \"&jscr;\": \"𝒿\",\n            \"&jsercy;\": \"ј\",\n            \"&jukcy;\": \"є\",\n            \"&kappa;\": \"κ\",\n            \"&kappav;\": \"ϰ\",\n            \"&kcedil;\": \"ķ\",\n            \"&kcy;\": \"к\",\n            \"&kfr;\": \"𝔨\",\n            \"&kgreen;\": \"ĸ\",\n            \"&khcy;\": \"х\",\n            \"&kjcy;\": \"ќ\",\n            \"&kopf;\": \"𝕜\",\n            \"&kscr;\": \"𝓀\",\n            \"&lAarr;\": \"⇚\",\n            \"&lArr;\": \"⇐\",\n            \"&lAtail;\": \"⤛\",\n            \"&lBarr;\": \"⤎\",\n            \"&lE;\": \"≦\",\n            \"&lEg;\": \"⪋\",\n            \"&lHar;\": \"⥢\",\n            \"&lacute;\": \"ĺ\",\n            \"&laemptyv;\": \"⦴\",\n            \"&lagran;\": \"ℒ\",\n            \"&lambda;\": \"λ\",\n            \"&lang;\": \"⟨\",\n            \"&langd;\": \"⦑\",\n            \"&langle;\": \"⟨\",\n            \"&lap;\": \"⪅\",\n            \"&laquo\": \"«\",\n            \"&laquo;\": \"«\",\n            \"&larr;\": \"←\",\n            \"&larrb;\": \"⇤\",\n            \"&larrbfs;\": \"⤟\",\n            \"&larrfs;\": \"⤝\",\n            \"&larrhk;\": \"↩\",\n            \"&larrlp;\": \"↫\",\n            \"&larrpl;\": \"⤹\",\n            \"&larrsim;\": \"⥳\",\n            \"&larrtl;\": \"↢\",\n            \"&lat;\": \"⪫\",\n            \"&latail;\": \"⤙\",\n            \"&late;\": \"⪭\",\n            \"&lates;\": \"⪭︀\",\n            \"&lbarr;\": \"⤌\",\n            \"&lbbrk;\": \"❲\",\n            \"&lbrace;\": \"{\",\n            \"&lbrack;\": \"[\",\n            \"&lbrke;\": \"⦋\",\n            \"&lbrksld;\": \"⦏\",\n            \"&lbrkslu;\": \"⦍\",\n            \"&lcaron;\": \"ľ\",\n            \"&lcedil;\": \"ļ\",\n            \"&lceil;\": \"⌈\",\n            \"&lcub;\": \"{\",\n            \"&lcy;\": \"л\",\n            \"&ldca;\": \"⤶\",\n            \"&ldquo;\": \"“\",\n            \"&ldquor;\": \"„\",\n            \"&ldrdhar;\": \"⥧\",\n            \"&ldrushar;\": \"⥋\",\n            \"&ldsh;\": \"↲\",\n            \"&le;\": \"≤\",\n            \"&leftarrow;\": \"←\",\n            \"&leftarrowtail;\": \"↢\",\n            \"&leftharpoondown;\": \"↽\",\n            \"&leftharpoonup;\": \"↼\",\n            \"&leftleftarrows;\": \"⇇\",\n            \"&leftrightarrow;\": \"↔\",\n            \"&leftrightarrows;\": \"⇆\",\n            \"&leftrightharpoons;\": \"⇋\",\n            \"&leftrightsquigarrow;\": \"↭\",\n            \"&leftthreetimes;\": \"⋋\",\n            \"&leg;\": \"⋚\",\n            \"&leq;\": \"≤\",\n            \"&leqq;\": \"≦\",\n            \"&leqslant;\": \"⩽\",\n            \"&les;\": \"⩽\",\n            \"&lescc;\": \"⪨\",\n            \"&lesdot;\": \"⩿\",\n            \"&lesdoto;\": \"⪁\",\n            \"&lesdotor;\": \"⪃\",\n            \"&lesg;\": \"⋚︀\",\n            \"&lesges;\": \"⪓\",\n            \"&lessapprox;\": \"⪅\",\n            \"&lessdot;\": \"⋖\",\n            \"&lesseqgtr;\": \"⋚\",\n            \"&lesseqqgtr;\": \"⪋\",\n            \"&lessgtr;\": \"≶\",\n            \"&lesssim;\": \"≲\",\n            \"&lfisht;\": \"⥼\",\n            \"&lfloor;\": \"⌊\",\n            \"&lfr;\": \"𝔩\",\n            \"&lg;\": \"≶\",\n            \"&lgE;\": \"⪑\",\n            \"&lhard;\": \"↽\",\n            \"&lharu;\": \"↼\",\n            \"&lharul;\": \"⥪\",\n            \"&lhblk;\": \"▄\",\n            \"&ljcy;\": \"љ\",\n            \"&ll;\": \"≪\",\n            \"&llarr;\": \"⇇\",\n            \"&llcorner;\": \"⌞\",\n            \"&llhard;\": \"⥫\",\n            \"&lltri;\": \"◺\",\n            \"&lmidot;\": \"ŀ\",\n            \"&lmoust;\": \"⎰\",\n            \"&lmoustache;\": \"⎰\",\n            \"&lnE;\": \"≨\",\n            \"&lnap;\": \"⪉\",\n            \"&lnapprox;\": \"⪉\",\n            \"&lne;\": \"⪇\",\n            \"&lneq;\": \"⪇\",\n            \"&lneqq;\": \"≨\",\n            \"&lnsim;\": \"⋦\",\n            \"&loang;\": \"⟬\",\n            \"&loarr;\": \"⇽\",\n            \"&lobrk;\": \"⟦\",\n            \"&longleftarrow;\": \"⟵\",\n            \"&longleftrightarrow;\": \"⟷\",\n            \"&longmapsto;\": \"⟼\",\n            \"&longrightarrow;\": \"⟶\",\n            \"&looparrowleft;\": \"↫\",\n            \"&looparrowright;\": \"↬\",\n            \"&lopar;\": \"⦅\",\n            \"&lopf;\": \"𝕝\",\n            \"&loplus;\": \"⨭\",\n            \"&lotimes;\": \"⨴\",\n            \"&lowast;\": \"∗\",\n            \"&lowbar;\": \"_\",\n            \"&loz;\": \"◊\",\n            \"&lozenge;\": \"◊\",\n            \"&lozf;\": \"⧫\",\n            \"&lpar;\": \"(\",\n            \"&lparlt;\": \"⦓\",\n            \"&lrarr;\": \"⇆\",\n            \"&lrcorner;\": \"⌟\",\n            \"&lrhar;\": \"⇋\",\n            \"&lrhard;\": \"⥭\",\n            \"&lrm;\": \"‎\",\n            \"&lrtri;\": \"⊿\",\n            \"&lsaquo;\": \"‹\",\n            \"&lscr;\": \"𝓁\",\n            \"&lsh;\": \"↰\",\n            \"&lsim;\": \"≲\",\n            \"&lsime;\": \"⪍\",\n            \"&lsimg;\": \"⪏\",\n            \"&lsqb;\": \"[\",\n            \"&lsquo;\": \"‘\",\n            \"&lsquor;\": \"‚\",\n            \"&lstrok;\": \"ł\",\n            \"&lt\": \"<\",\n            \"&lt;\": \"<\",\n            \"&ltcc;\": \"⪦\",\n            \"&ltcir;\": \"⩹\",\n            \"&ltdot;\": \"⋖\",\n            \"&lthree;\": \"⋋\",\n            \"&ltimes;\": \"⋉\",\n            \"&ltlarr;\": \"⥶\",\n            \"&ltquest;\": \"⩻\",\n            \"&ltrPar;\": \"⦖\",\n            \"&ltri;\": \"◃\",\n            \"&ltrie;\": \"⊴\",\n            \"&ltrif;\": \"◂\",\n            \"&lurdshar;\": \"⥊\",\n            \"&luruhar;\": \"⥦\",\n            \"&lvertneqq;\": \"≨︀\",\n            \"&lvnE;\": \"≨︀\",\n            \"&mDDot;\": \"∺\",\n            \"&macr\": \"¯\",\n            \"&macr;\": \"¯\",\n            \"&male;\": \"♂\",\n            \"&malt;\": \"✠\",\n            \"&maltese;\": \"✠\",\n            \"&map;\": \"↦\",\n            \"&mapsto;\": \"↦\",\n            \"&mapstodown;\": \"↧\",\n            \"&mapstoleft;\": \"↤\",\n            \"&mapstoup;\": \"↥\",\n            \"&marker;\": \"▮\",\n            \"&mcomma;\": \"⨩\",\n            \"&mcy;\": \"м\",\n            \"&mdash;\": \"—\",\n            \"&measuredangle;\": \"∡\",\n            \"&mfr;\": \"𝔪\",\n            \"&mho;\": \"℧\",\n            \"&micro\": \"µ\",\n            \"&micro;\": \"µ\",\n            \"&mid;\": \"∣\",\n            \"&midast;\": \"*\",\n            \"&midcir;\": \"⫰\",\n            \"&middot\": \"·\",\n            \"&middot;\": \"·\",\n            \"&minus;\": \"−\",\n            \"&minusb;\": \"⊟\",\n            \"&minusd;\": \"∸\",\n            \"&minusdu;\": \"⨪\",\n            \"&mlcp;\": \"⫛\",\n            \"&mldr;\": \"…\",\n            \"&mnplus;\": \"∓\",\n            \"&models;\": \"⊧\",\n            \"&mopf;\": \"𝕞\",\n            \"&mp;\": \"∓\",\n            \"&mscr;\": \"𝓂\",\n            \"&mstpos;\": \"∾\",\n            \"&mu;\": \"μ\",\n            \"&multimap;\": \"⊸\",\n            \"&mumap;\": \"⊸\",\n            \"&nGg;\": \"⋙̸\",\n            \"&nGt;\": \"≫⃒\",\n            \"&nGtv;\": \"≫̸\",\n            \"&nLeftarrow;\": \"⇍\",\n            \"&nLeftrightarrow;\": \"⇎\",\n            \"&nLl;\": \"⋘̸\",\n            \"&nLt;\": \"≪⃒\",\n            \"&nLtv;\": \"≪̸\",\n            \"&nRightarrow;\": \"⇏\",\n            \"&nVDash;\": \"⊯\",\n            \"&nVdash;\": \"⊮\",\n            \"&nabla;\": \"∇\",\n            \"&nacute;\": \"ń\",\n            \"&nang;\": \"∠⃒\",\n            \"&nap;\": \"≉\",\n            \"&napE;\": \"⩰̸\",\n            \"&napid;\": \"≋̸\",\n            \"&napos;\": \"ʼn\",\n            \"&napprox;\": \"≉\",\n            \"&natur;\": \"♮\",\n            \"&natural;\": \"♮\",\n            \"&naturals;\": \"ℕ\",\n            \"&nbsp\": \" \",\n            \"&nbsp;\": \" \",\n            \"&nbump;\": \"≎̸\",\n            \"&nbumpe;\": \"≏̸\",\n            \"&ncap;\": \"⩃\",\n            \"&ncaron;\": \"ň\",\n            \"&ncedil;\": \"ņ\",\n            \"&ncong;\": \"≇\",\n            \"&ncongdot;\": \"⩭̸\",\n            \"&ncup;\": \"⩂\",\n            \"&ncy;\": \"н\",\n            \"&ndash;\": \"–\",\n            \"&ne;\": \"≠\",\n            \"&neArr;\": \"⇗\",\n            \"&nearhk;\": \"⤤\",\n            \"&nearr;\": \"↗\",\n            \"&nearrow;\": \"↗\",\n            \"&nedot;\": \"≐̸\",\n            \"&nequiv;\": \"≢\",\n            \"&nesear;\": \"⤨\",\n            \"&nesim;\": \"≂̸\",\n            \"&nexist;\": \"∄\",\n            \"&nexists;\": \"∄\",\n            \"&nfr;\": \"𝔫\",\n            \"&ngE;\": \"≧̸\",\n            \"&nge;\": \"≱\",\n            \"&ngeq;\": \"≱\",\n            \"&ngeqq;\": \"≧̸\",\n            \"&ngeqslant;\": \"⩾̸\",\n            \"&nges;\": \"⩾̸\",\n            \"&ngsim;\": \"≵\",\n            \"&ngt;\": \"≯\",\n            \"&ngtr;\": \"≯\",\n            \"&nhArr;\": \"⇎\",\n            \"&nharr;\": \"↮\",\n            \"&nhpar;\": \"⫲\",\n            \"&ni;\": \"∋\",\n            \"&nis;\": \"⋼\",\n            \"&nisd;\": \"⋺\",\n            \"&niv;\": \"∋\",\n            \"&njcy;\": \"њ\",\n            \"&nlArr;\": \"⇍\",\n            \"&nlE;\": \"≦̸\",\n            \"&nlarr;\": \"↚\",\n            \"&nldr;\": \"‥\",\n            \"&nle;\": \"≰\",\n            \"&nleftarrow;\": \"↚\",\n            \"&nleftrightarrow;\": \"↮\",\n            \"&nleq;\": \"≰\",\n            \"&nleqq;\": \"≦̸\",\n            \"&nleqslant;\": \"⩽̸\",\n            \"&nles;\": \"⩽̸\",\n            \"&nless;\": \"≮\",\n            \"&nlsim;\": \"≴\",\n            \"&nlt;\": \"≮\",\n            \"&nltri;\": \"⋪\",\n            \"&nltrie;\": \"⋬\",\n            \"&nmid;\": \"∤\",\n            \"&nopf;\": \"𝕟\",\n            \"&not\": \"¬\",\n            \"&not;\": \"¬\",\n            \"&notin;\": \"∉\",\n            \"&notinE;\": \"⋹̸\",\n            \"&notindot;\": \"⋵̸\",\n            \"&notinva;\": \"∉\",\n            \"&notinvb;\": \"⋷\",\n            \"&notinvc;\": \"⋶\",\n            \"&notni;\": \"∌\",\n            \"&notniva;\": \"∌\",\n            \"&notnivb;\": \"⋾\",\n            \"&notnivc;\": \"⋽\",\n            \"&npar;\": \"∦\",\n            \"&nparallel;\": \"∦\",\n            \"&nparsl;\": \"⫽⃥\",\n            \"&npart;\": \"∂̸\",\n            \"&npolint;\": \"⨔\",\n            \"&npr;\": \"⊀\",\n            \"&nprcue;\": \"⋠\",\n            \"&npre;\": \"⪯̸\",\n            \"&nprec;\": \"⊀\",\n            \"&npreceq;\": \"⪯̸\",\n            \"&nrArr;\": \"⇏\",\n            \"&nrarr;\": \"↛\",\n            \"&nrarrc;\": \"⤳̸\",\n            \"&nrarrw;\": \"↝̸\",\n            \"&nrightarrow;\": \"↛\",\n            \"&nrtri;\": \"⋫\",\n            \"&nrtrie;\": \"⋭\",\n            \"&nsc;\": \"⊁\",\n            \"&nsccue;\": \"⋡\",\n            \"&nsce;\": \"⪰̸\",\n            \"&nscr;\": \"𝓃\",\n            \"&nshortmid;\": \"∤\",\n            \"&nshortparallel;\": \"∦\",\n            \"&nsim;\": \"≁\",\n            \"&nsime;\": \"≄\",\n            \"&nsimeq;\": \"≄\",\n            \"&nsmid;\": \"∤\",\n            \"&nspar;\": \"∦\",\n            \"&nsqsube;\": \"⋢\",\n            \"&nsqsupe;\": \"⋣\",\n            \"&nsub;\": \"⊄\",\n            \"&nsubE;\": \"⫅̸\",\n            \"&nsube;\": \"⊈\",\n            \"&nsubset;\": \"⊂⃒\",\n            \"&nsubseteq;\": \"⊈\",\n            \"&nsubseteqq;\": \"⫅̸\",\n            \"&nsucc;\": \"⊁\",\n            \"&nsucceq;\": \"⪰̸\",\n            \"&nsup;\": \"⊅\",\n            \"&nsupE;\": \"⫆̸\",\n            \"&nsupe;\": \"⊉\",\n            \"&nsupset;\": \"⊃⃒\",\n            \"&nsupseteq;\": \"⊉\",\n            \"&nsupseteqq;\": \"⫆̸\",\n            \"&ntgl;\": \"≹\",\n            \"&ntilde\": \"ñ\",\n            \"&ntilde;\": \"ñ\",\n            \"&ntlg;\": \"≸\",\n            \"&ntriangleleft;\": \"⋪\",\n            \"&ntrianglelefteq;\": \"⋬\",\n            \"&ntriangleright;\": \"⋫\",\n            \"&ntrianglerighteq;\": \"⋭\",\n            \"&nu;\": \"ν\",\n            \"&num;\": \"#\",\n            \"&numero;\": \"№\",\n            \"&numsp;\": \" \",\n            \"&nvDash;\": \"⊭\",\n            \"&nvHarr;\": \"⤄\",\n            \"&nvap;\": \"≍⃒\",\n            \"&nvdash;\": \"⊬\",\n            \"&nvge;\": \"≥⃒\",\n            \"&nvgt;\": \">⃒\",\n            \"&nvinfin;\": \"⧞\",\n            \"&nvlArr;\": \"⤂\",\n            \"&nvle;\": \"≤⃒\",\n            \"&nvlt;\": \"<⃒\",\n            \"&nvltrie;\": \"⊴⃒\",\n            \"&nvrArr;\": \"⤃\",\n            \"&nvrtrie;\": \"⊵⃒\",\n            \"&nvsim;\": \"∼⃒\",\n            \"&nwArr;\": \"⇖\",\n            \"&nwarhk;\": \"⤣\",\n            \"&nwarr;\": \"↖\",\n            \"&nwarrow;\": \"↖\",\n            \"&nwnear;\": \"⤧\",\n            \"&oS;\": \"Ⓢ\",\n            \"&oacute\": \"ó\",\n            \"&oacute;\": \"ó\",\n            \"&oast;\": \"⊛\",\n            \"&ocir;\": \"⊚\",\n            \"&ocirc\": \"ô\",\n            \"&ocirc;\": \"ô\",\n            \"&ocy;\": \"о\",\n            \"&odash;\": \"⊝\",\n            \"&odblac;\": \"ő\",\n            \"&odiv;\": \"⨸\",\n            \"&odot;\": \"⊙\",\n            \"&odsold;\": \"⦼\",\n            \"&oelig;\": \"œ\",\n            \"&ofcir;\": \"⦿\",\n            \"&ofr;\": \"𝔬\",\n            \"&ogon;\": \"˛\",\n            \"&ograve\": \"ò\",\n            \"&ograve;\": \"ò\",\n            \"&ogt;\": \"⧁\",\n            \"&ohbar;\": \"⦵\",\n            \"&ohm;\": \"Ω\",\n            \"&oint;\": \"∮\",\n            \"&olarr;\": \"↺\",\n            \"&olcir;\": \"⦾\",\n            \"&olcross;\": \"⦻\",\n            \"&oline;\": \"‾\",\n            \"&olt;\": \"⧀\",\n            \"&omacr;\": \"ō\",\n            \"&omega;\": \"ω\",\n            \"&omicron;\": \"ο\",\n            \"&omid;\": \"⦶\",\n            \"&ominus;\": \"⊖\",\n            \"&oopf;\": \"𝕠\",\n            \"&opar;\": \"⦷\",\n            \"&operp;\": \"⦹\",\n            \"&oplus;\": \"⊕\",\n            \"&or;\": \"∨\",\n            \"&orarr;\": \"↻\",\n            \"&ord;\": \"⩝\",\n            \"&order;\": \"ℴ\",\n            \"&orderof;\": \"ℴ\",\n            \"&ordf\": \"ª\",\n            \"&ordf;\": \"ª\",\n            \"&ordm\": \"º\",\n            \"&ordm;\": \"º\",\n            \"&origof;\": \"⊶\",\n            \"&oror;\": \"⩖\",\n            \"&orslope;\": \"⩗\",\n            \"&orv;\": \"⩛\",\n            \"&oscr;\": \"ℴ\",\n            \"&oslash\": \"ø\",\n            \"&oslash;\": \"ø\",\n            \"&osol;\": \"⊘\",\n            \"&otilde\": \"õ\",\n            \"&otilde;\": \"õ\",\n            \"&otimes;\": \"⊗\",\n            \"&otimesas;\": \"⨶\",\n            \"&ouml\": \"ö\",\n            \"&ouml;\": \"ö\",\n            \"&ovbar;\": \"⌽\",\n            \"&par;\": \"∥\",\n            \"&para\": \"¶\",\n            \"&para;\": \"¶\",\n            \"&parallel;\": \"∥\",\n            \"&parsim;\": \"⫳\",\n            \"&parsl;\": \"⫽\",\n            \"&part;\": \"∂\",\n            \"&pcy;\": \"п\",\n            \"&percnt;\": \"%\",\n            \"&period;\": \".\",\n            \"&permil;\": \"‰\",\n            \"&perp;\": \"⊥\",\n            \"&pertenk;\": \"‱\",\n            \"&pfr;\": \"𝔭\",\n            \"&phi;\": \"φ\",\n            \"&phiv;\": \"ϕ\",\n            \"&phmmat;\": \"ℳ\",\n            \"&phone;\": \"☎\",\n            \"&pi;\": \"π\",\n            \"&pitchfork;\": \"⋔\",\n            \"&piv;\": \"ϖ\",\n            \"&planck;\": \"ℏ\",\n            \"&planckh;\": \"ℎ\",\n            \"&plankv;\": \"ℏ\",\n            \"&plus;\": \"+\",\n            \"&plusacir;\": \"⨣\",\n            \"&plusb;\": \"⊞\",\n            \"&pluscir;\": \"⨢\",\n            \"&plusdo;\": \"∔\",\n            \"&plusdu;\": \"⨥\",\n            \"&pluse;\": \"⩲\",\n            \"&plusmn\": \"±\",\n            \"&plusmn;\": \"±\",\n            \"&plussim;\": \"⨦\",\n            \"&plustwo;\": \"⨧\",\n            \"&pm;\": \"±\",\n            \"&pointint;\": \"⨕\",\n            \"&popf;\": \"𝕡\",\n            \"&pound\": \"£\",\n            \"&pound;\": \"£\",\n            \"&pr;\": \"≺\",\n            \"&prE;\": \"⪳\",\n            \"&prap;\": \"⪷\",\n            \"&prcue;\": \"≼\",\n            \"&pre;\": \"⪯\",\n            \"&prec;\": \"≺\",\n            \"&precapprox;\": \"⪷\",\n            \"&preccurlyeq;\": \"≼\",\n            \"&preceq;\": \"⪯\",\n            \"&precnapprox;\": \"⪹\",\n            \"&precneqq;\": \"⪵\",\n            \"&precnsim;\": \"⋨\",\n            \"&precsim;\": \"≾\",\n            \"&prime;\": \"′\",\n            \"&primes;\": \"ℙ\",\n            \"&prnE;\": \"⪵\",\n            \"&prnap;\": \"⪹\",\n            \"&prnsim;\": \"⋨\",\n            \"&prod;\": \"∏\",\n            \"&profalar;\": \"⌮\",\n            \"&profline;\": \"⌒\",\n            \"&profsurf;\": \"⌓\",\n            \"&prop;\": \"∝\",\n            \"&propto;\": \"∝\",\n            \"&prsim;\": \"≾\",\n            \"&prurel;\": \"⊰\",\n            \"&pscr;\": \"𝓅\",\n            \"&psi;\": \"ψ\",\n            \"&puncsp;\": \" \",\n            \"&qfr;\": \"𝔮\",\n            \"&qint;\": \"⨌\",\n            \"&qopf;\": \"𝕢\",\n            \"&qprime;\": \"⁗\",\n            \"&qscr;\": \"𝓆\",\n            \"&quaternions;\": \"ℍ\",\n            \"&quatint;\": \"⨖\",\n            \"&quest;\": \"?\",\n            \"&questeq;\": \"≟\",\n            \"&quot\": \"\\\"\",\n            \"&quot;\": \"\\\"\",\n            \"&rAarr;\": \"⇛\",\n            \"&rArr;\": \"⇒\",\n            \"&rAtail;\": \"⤜\",\n            \"&rBarr;\": \"⤏\",\n            \"&rHar;\": \"⥤\",\n            \"&race;\": \"∽̱\",\n            \"&racute;\": \"ŕ\",\n            \"&radic;\": \"√\",\n            \"&raemptyv;\": \"⦳\",\n            \"&rang;\": \"⟩\",\n            \"&rangd;\": \"⦒\",\n            \"&range;\": \"⦥\",\n            \"&rangle;\": \"⟩\",\n            \"&raquo\": \"»\",\n            \"&raquo;\": \"»\",\n            \"&rarr;\": \"→\",\n            \"&rarrap;\": \"⥵\",\n            \"&rarrb;\": \"⇥\",\n            \"&rarrbfs;\": \"⤠\",\n            \"&rarrc;\": \"⤳\",\n            \"&rarrfs;\": \"⤞\",\n            \"&rarrhk;\": \"↪\",\n            \"&rarrlp;\": \"↬\",\n            \"&rarrpl;\": \"⥅\",\n            \"&rarrsim;\": \"⥴\",\n            \"&rarrtl;\": \"↣\",\n            \"&rarrw;\": \"↝\",\n            \"&ratail;\": \"⤚\",\n            \"&ratio;\": \"∶\",\n            \"&rationals;\": \"ℚ\",\n            \"&rbarr;\": \"⤍\",\n            \"&rbbrk;\": \"❳\",\n            \"&rbrace;\": \"}\",\n            \"&rbrack;\": \"]\",\n            \"&rbrke;\": \"⦌\",\n            \"&rbrksld;\": \"⦎\",\n            \"&rbrkslu;\": \"⦐\",\n            \"&rcaron;\": \"ř\",\n            \"&rcedil;\": \"ŗ\",\n            \"&rceil;\": \"⌉\",\n            \"&rcub;\": \"}\",\n            \"&rcy;\": \"р\",\n            \"&rdca;\": \"⤷\",\n            \"&rdldhar;\": \"⥩\",\n            \"&rdquo;\": \"”\",\n            \"&rdquor;\": \"”\",\n            \"&rdsh;\": \"↳\",\n            \"&real;\": \"ℜ\",\n            \"&realine;\": \"ℛ\",\n            \"&realpart;\": \"ℜ\",\n            \"&reals;\": \"ℝ\",\n            \"&rect;\": \"▭\",\n            \"&reg\": \"®\",\n            \"&reg;\": \"®\",\n            \"&rfisht;\": \"⥽\",\n            \"&rfloor;\": \"⌋\",\n            \"&rfr;\": \"𝔯\",\n            \"&rhard;\": \"⇁\",\n            \"&rharu;\": \"⇀\",\n            \"&rharul;\": \"⥬\",\n            \"&rho;\": \"ρ\",\n            \"&rhov;\": \"ϱ\",\n            \"&rightarrow;\": \"→\",\n            \"&rightarrowtail;\": \"↣\",\n            \"&rightharpoondown;\": \"⇁\",\n            \"&rightharpoonup;\": \"⇀\",\n            \"&rightleftarrows;\": \"⇄\",\n            \"&rightleftharpoons;\": \"⇌\",\n            \"&rightrightarrows;\": \"⇉\",\n            \"&rightsquigarrow;\": \"↝\",\n            \"&rightthreetimes;\": \"⋌\",\n            \"&ring;\": \"˚\",\n            \"&risingdotseq;\": \"≓\",\n            \"&rlarr;\": \"⇄\",\n            \"&rlhar;\": \"⇌\",\n            \"&rlm;\": \"‏\",\n            \"&rmoust;\": \"⎱\",\n            \"&rmoustache;\": \"⎱\",\n            \"&rnmid;\": \"⫮\",\n            \"&roang;\": \"⟭\",\n            \"&roarr;\": \"⇾\",\n            \"&robrk;\": \"⟧\",\n            \"&ropar;\": \"⦆\",\n            \"&ropf;\": \"𝕣\",\n            \"&roplus;\": \"⨮\",\n            \"&rotimes;\": \"⨵\",\n            \"&rpar;\": \")\",\n            \"&rpargt;\": \"⦔\",\n            \"&rppolint;\": \"⨒\",\n            \"&rrarr;\": \"⇉\",\n            \"&rsaquo;\": \"›\",\n            \"&rscr;\": \"𝓇\",\n            \"&rsh;\": \"↱\",\n            \"&rsqb;\": \"]\",\n            \"&rsquo;\": \"’\",\n            \"&rsquor;\": \"’\",\n            \"&rthree;\": \"⋌\",\n            \"&rtimes;\": \"⋊\",\n            \"&rtri;\": \"▹\",\n            \"&rtrie;\": \"⊵\",\n            \"&rtrif;\": \"▸\",\n            \"&rtriltri;\": \"⧎\",\n            \"&ruluhar;\": \"⥨\",\n            \"&rx;\": \"℞\",\n            \"&sacute;\": \"ś\",\n            \"&sbquo;\": \"‚\",\n            \"&sc;\": \"≻\",\n            \"&scE;\": \"⪴\",\n            \"&scap;\": \"⪸\",\n            \"&scaron;\": \"š\",\n            \"&sccue;\": \"≽\",\n            \"&sce;\": \"⪰\",\n            \"&scedil;\": \"ş\",\n            \"&scirc;\": \"ŝ\",\n            \"&scnE;\": \"⪶\",\n            \"&scnap;\": \"⪺\",\n            \"&scnsim;\": \"⋩\",\n            \"&scpolint;\": \"⨓\",\n            \"&scsim;\": \"≿\",\n            \"&scy;\": \"с\",\n            \"&sdot;\": \"⋅\",\n            \"&sdotb;\": \"⊡\",\n            \"&sdote;\": \"⩦\",\n            \"&seArr;\": \"⇘\",\n            \"&searhk;\": \"⤥\",\n            \"&searr;\": \"↘\",\n            \"&searrow;\": \"↘\",\n            \"&sect\": \"§\",\n            \"&sect;\": \"§\",\n            \"&semi;\": \";\",\n            \"&seswar;\": \"⤩\",\n            \"&setminus;\": \"∖\",\n            \"&setmn;\": \"∖\",\n            \"&sext;\": \"✶\",\n            \"&sfr;\": \"𝔰\",\n            \"&sfrown;\": \"⌢\",\n            \"&sharp;\": \"♯\",\n            \"&shchcy;\": \"щ\",\n            \"&shcy;\": \"ш\",\n            \"&shortmid;\": \"∣\",\n            \"&shortparallel;\": \"∥\",\n            \"&shy\": \"­\",\n            \"&shy;\": \"­\",\n            \"&sigma;\": \"σ\",\n            \"&sigmaf;\": \"ς\",\n            \"&sigmav;\": \"ς\",\n            \"&sim;\": \"∼\",\n            \"&simdot;\": \"⩪\",\n            \"&sime;\": \"≃\",\n            \"&simeq;\": \"≃\",\n            \"&simg;\": \"⪞\",\n            \"&simgE;\": \"⪠\",\n            \"&siml;\": \"⪝\",\n            \"&simlE;\": \"⪟\",\n            \"&simne;\": \"≆\",\n            \"&simplus;\": \"⨤\",\n            \"&simrarr;\": \"⥲\",\n            \"&slarr;\": \"←\",\n            \"&smallsetminus;\": \"∖\",\n            \"&smashp;\": \"⨳\",\n            \"&smeparsl;\": \"⧤\",\n            \"&smid;\": \"∣\",\n            \"&smile;\": \"⌣\",\n            \"&smt;\": \"⪪\",\n            \"&smte;\": \"⪬\",\n            \"&smtes;\": \"⪬︀\",\n            \"&softcy;\": \"ь\",\n            \"&sol;\": \"/\",\n            \"&solb;\": \"⧄\",\n            \"&solbar;\": \"⌿\",\n            \"&sopf;\": \"𝕤\",\n            \"&spades;\": \"♠\",\n            \"&spadesuit;\": \"♠\",\n            \"&spar;\": \"∥\",\n            \"&sqcap;\": \"⊓\",\n            \"&sqcaps;\": \"⊓︀\",\n            \"&sqcup;\": \"⊔\",\n            \"&sqcups;\": \"⊔︀\",\n            \"&sqsub;\": \"⊏\",\n            \"&sqsube;\": \"⊑\",\n            \"&sqsubset;\": \"⊏\",\n            \"&sqsubseteq;\": \"⊑\",\n            \"&sqsup;\": \"⊐\",\n            \"&sqsupe;\": \"⊒\",\n            \"&sqsupset;\": \"⊐\",\n            \"&sqsupseteq;\": \"⊒\",\n            \"&squ;\": \"□\",\n            \"&square;\": \"□\",\n            \"&squarf;\": \"▪\",\n            \"&squf;\": \"▪\",\n            \"&srarr;\": \"→\",\n            \"&sscr;\": \"𝓈\",\n            \"&ssetmn;\": \"∖\",\n            \"&ssmile;\": \"⌣\",\n            \"&sstarf;\": \"⋆\",\n            \"&star;\": \"☆\",\n            \"&starf;\": \"★\",\n            \"&straightepsilon;\": \"ϵ\",\n            \"&straightphi;\": \"ϕ\",\n            \"&strns;\": \"¯\",\n            \"&sub;\": \"⊂\",\n            \"&subE;\": \"⫅\",\n            \"&subdot;\": \"⪽\",\n            \"&sube;\": \"⊆\",\n            \"&subedot;\": \"⫃\",\n            \"&submult;\": \"⫁\",\n            \"&subnE;\": \"⫋\",\n            \"&subne;\": \"⊊\",\n            \"&subplus;\": \"⪿\",\n            \"&subrarr;\": \"⥹\",\n            \"&subset;\": \"⊂\",\n            \"&subseteq;\": \"⊆\",\n            \"&subseteqq;\": \"⫅\",\n            \"&subsetneq;\": \"⊊\",\n            \"&subsetneqq;\": \"⫋\",\n            \"&subsim;\": \"⫇\",\n            \"&subsub;\": \"⫕\",\n            \"&subsup;\": \"⫓\",\n            \"&succ;\": \"≻\",\n            \"&succapprox;\": \"⪸\",\n            \"&succcurlyeq;\": \"≽\",\n            \"&succeq;\": \"⪰\",\n            \"&succnapprox;\": \"⪺\",\n            \"&succneqq;\": \"⪶\",\n            \"&succnsim;\": \"⋩\",\n            \"&succsim;\": \"≿\",\n            \"&sum;\": \"∑\",\n            \"&sung;\": \"♪\",\n            \"&sup1\": \"¹\",\n            \"&sup1;\": \"¹\",\n            \"&sup2\": \"²\",\n            \"&sup2;\": \"²\",\n            \"&sup3\": \"³\",\n            \"&sup3;\": \"³\",\n            \"&sup;\": \"⊃\",\n            \"&supE;\": \"⫆\",\n            \"&supdot;\": \"⪾\",\n            \"&supdsub;\": \"⫘\",\n            \"&supe;\": \"⊇\",\n            \"&supedot;\": \"⫄\",\n            \"&suphsol;\": \"⟉\",\n            \"&suphsub;\": \"⫗\",\n            \"&suplarr;\": \"⥻\",\n            \"&supmult;\": \"⫂\",\n            \"&supnE;\": \"⫌\",\n            \"&supne;\": \"⊋\",\n            \"&supplus;\": \"⫀\",\n            \"&supset;\": \"⊃\",\n            \"&supseteq;\": \"⊇\",\n            \"&supseteqq;\": \"⫆\",\n            \"&supsetneq;\": \"⊋\",\n            \"&supsetneqq;\": \"⫌\",\n            \"&supsim;\": \"⫈\",\n            \"&supsub;\": \"⫔\",\n            \"&supsup;\": \"⫖\",\n            \"&swArr;\": \"⇙\",\n            \"&swarhk;\": \"⤦\",\n            \"&swarr;\": \"↙\",\n            \"&swarrow;\": \"↙\",\n            \"&swnwar;\": \"⤪\",\n            \"&szlig\": \"ß\",\n            \"&szlig;\": \"ß\",\n            \"&target;\": \"⌖\",\n            \"&tau;\": \"τ\",\n            \"&tbrk;\": \"⎴\",\n            \"&tcaron;\": \"ť\",\n            \"&tcedil;\": \"ţ\",\n            \"&tcy;\": \"т\",\n            \"&tdot;\": \"⃛\",\n            \"&telrec;\": \"⌕\",\n            \"&tfr;\": \"𝔱\",\n            \"&there4;\": \"∴\",\n            \"&therefore;\": \"∴\",\n            \"&theta;\": \"θ\",\n            \"&thetasym;\": \"ϑ\",\n            \"&thetav;\": \"ϑ\",\n            \"&thickapprox;\": \"≈\",\n            \"&thicksim;\": \"∼\",\n            \"&thinsp;\": \" \",\n            \"&thkap;\": \"≈\",\n            \"&thksim;\": \"∼\",\n            \"&thorn\": \"þ\",\n            \"&thorn;\": \"þ\",\n            \"&tilde;\": \"˜\",\n            \"&times\": \"×\",\n            \"&times;\": \"×\",\n            \"&timesb;\": \"⊠\",\n            \"&timesbar;\": \"⨱\",\n            \"&timesd;\": \"⨰\",\n            \"&tint;\": \"∭\",\n            \"&toea;\": \"⤨\",\n            \"&top;\": \"⊤\",\n            \"&topbot;\": \"⌶\",\n            \"&topcir;\": \"⫱\",\n            \"&topf;\": \"𝕥\",\n            \"&topfork;\": \"⫚\",\n            \"&tosa;\": \"⤩\",\n            \"&tprime;\": \"‴\",\n            \"&trade;\": \"™\",\n            \"&triangle;\": \"▵\",\n            \"&triangledown;\": \"▿\",\n            \"&triangleleft;\": \"◃\",\n            \"&trianglelefteq;\": \"⊴\",\n            \"&triangleq;\": \"≜\",\n            \"&triangleright;\": \"▹\",\n            \"&trianglerighteq;\": \"⊵\",\n            \"&tridot;\": \"◬\",\n            \"&trie;\": \"≜\",\n            \"&triminus;\": \"⨺\",\n            \"&triplus;\": \"⨹\",\n            \"&trisb;\": \"⧍\",\n            \"&tritime;\": \"⨻\",\n            \"&trpezium;\": \"⏢\",\n            \"&tscr;\": \"𝓉\",\n            \"&tscy;\": \"ц\",\n            \"&tshcy;\": \"ћ\",\n            \"&tstrok;\": \"ŧ\",\n            \"&twixt;\": \"≬\",\n            \"&twoheadleftarrow;\": \"↞\",\n            \"&twoheadrightarrow;\": \"↠\",\n            \"&uArr;\": \"⇑\",\n            \"&uHar;\": \"⥣\",\n            \"&uacute\": \"ú\",\n            \"&uacute;\": \"ú\",\n            \"&uarr;\": \"↑\",\n            \"&ubrcy;\": \"ў\",\n            \"&ubreve;\": \"ŭ\",\n            \"&ucirc\": \"û\",\n            \"&ucirc;\": \"û\",\n            \"&ucy;\": \"у\",\n            \"&udarr;\": \"⇅\",\n            \"&udblac;\": \"ű\",\n            \"&udhar;\": \"⥮\",\n            \"&ufisht;\": \"⥾\",\n            \"&ufr;\": \"𝔲\",\n            \"&ugrave\": \"ù\",\n            \"&ugrave;\": \"ù\",\n            \"&uharl;\": \"↿\",\n            \"&uharr;\": \"↾\",\n            \"&uhblk;\": \"▀\",\n            \"&ulcorn;\": \"⌜\",\n            \"&ulcorner;\": \"⌜\",\n            \"&ulcrop;\": \"⌏\",\n            \"&ultri;\": \"◸\",\n            \"&umacr;\": \"ū\",\n            \"&uml\": \"¨\",\n            \"&uml;\": \"¨\",\n            \"&uogon;\": \"ų\",\n            \"&uopf;\": \"𝕦\",\n            \"&uparrow;\": \"↑\",\n            \"&updownarrow;\": \"↕\",\n            \"&upharpoonleft;\": \"↿\",\n            \"&upharpoonright;\": \"↾\",\n            \"&uplus;\": \"⊎\",\n            \"&upsi;\": \"υ\",\n            \"&upsih;\": \"ϒ\",\n            \"&upsilon;\": \"υ\",\n            \"&upuparrows;\": \"⇈\",\n            \"&urcorn;\": \"⌝\",\n            \"&urcorner;\": \"⌝\",\n            \"&urcrop;\": \"⌎\",\n            \"&uring;\": \"ů\",\n            \"&urtri;\": \"◹\",\n            \"&uscr;\": \"𝓊\",\n            \"&utdot;\": \"⋰\",\n            \"&utilde;\": \"ũ\",\n            \"&utri;\": \"▵\",\n            \"&utrif;\": \"▴\",\n            \"&uuarr;\": \"⇈\",\n            \"&uuml\": \"ü\",\n            \"&uuml;\": \"ü\",\n            \"&uwangle;\": \"⦧\",\n            \"&vArr;\": \"⇕\",\n            \"&vBar;\": \"⫨\",\n            \"&vBarv;\": \"⫩\",\n            \"&vDash;\": \"⊨\",\n            \"&vangrt;\": \"⦜\",\n            \"&varepsilon;\": \"ϵ\",\n            \"&varkappa;\": \"ϰ\",\n            \"&varnothing;\": \"∅\",\n            \"&varphi;\": \"ϕ\",\n            \"&varpi;\": \"ϖ\",\n            \"&varpropto;\": \"∝\",\n            \"&varr;\": \"↕\",\n            \"&varrho;\": \"ϱ\",\n            \"&varsigma;\": \"ς\",\n            \"&varsubsetneq;\": \"⊊︀\",\n            \"&varsubsetneqq;\": \"⫋︀\",\n            \"&varsupsetneq;\": \"⊋︀\",\n            \"&varsupsetneqq;\": \"⫌︀\",\n            \"&vartheta;\": \"ϑ\",\n            \"&vartriangleleft;\": \"⊲\",\n            \"&vartriangleright;\": \"⊳\",\n            \"&vcy;\": \"в\",\n            \"&vdash;\": \"⊢\",\n            \"&vee;\": \"∨\",\n            \"&veebar;\": \"⊻\",\n            \"&veeeq;\": \"≚\",\n            \"&vellip;\": \"⋮\",\n            \"&verbar;\": \"|\",\n            \"&vert;\": \"|\",\n            \"&vfr;\": \"𝔳\",\n            \"&vltri;\": \"⊲\",\n            \"&vnsub;\": \"⊂⃒\",\n            \"&vnsup;\": \"⊃⃒\",\n            \"&vopf;\": \"𝕧\",\n            \"&vprop;\": \"∝\",\n            \"&vrtri;\": \"⊳\",\n            \"&vscr;\": \"𝓋\",\n            \"&vsubnE;\": \"⫋︀\",\n            \"&vsubne;\": \"⊊︀\",\n            \"&vsupnE;\": \"⫌︀\",\n            \"&vsupne;\": \"⊋︀\",\n            \"&vzigzag;\": \"⦚\",\n            \"&wcirc;\": \"ŵ\",\n            \"&wedbar;\": \"⩟\",\n            \"&wedge;\": \"∧\",\n            \"&wedgeq;\": \"≙\",\n            \"&weierp;\": \"℘\",\n            \"&wfr;\": \"𝔴\",\n            \"&wopf;\": \"𝕨\",\n            \"&wp;\": \"℘\",\n            \"&wr;\": \"≀\",\n            \"&wreath;\": \"≀\",\n            \"&wscr;\": \"𝓌\",\n            \"&xcap;\": \"⋂\",\n            \"&xcirc;\": \"◯\",\n            \"&xcup;\": \"⋃\",\n            \"&xdtri;\": \"▽\",\n            \"&xfr;\": \"𝔵\",\n            \"&xhArr;\": \"⟺\",\n            \"&xharr;\": \"⟷\",\n            \"&xi;\": \"ξ\",\n            \"&xlArr;\": \"⟸\",\n            \"&xlarr;\": \"⟵\",\n            \"&xmap;\": \"⟼\",\n            \"&xnis;\": \"⋻\",\n            \"&xodot;\": \"⨀\",\n            \"&xopf;\": \"𝕩\",\n            \"&xoplus;\": \"⨁\",\n            \"&xotime;\": \"⨂\",\n            \"&xrArr;\": \"⟹\",\n            \"&xrarr;\": \"⟶\",\n            \"&xscr;\": \"𝓍\",\n            \"&xsqcup;\": \"⨆\",\n            \"&xuplus;\": \"⨄\",\n            \"&xutri;\": \"△\",\n            \"&xvee;\": \"⋁\",\n            \"&xwedge;\": \"⋀\",\n            \"&yacute\": \"ý\",\n            \"&yacute;\": \"ý\",\n            \"&yacy;\": \"я\",\n            \"&ycirc;\": \"ŷ\",\n            \"&ycy;\": \"ы\",\n            \"&yen\": \"¥\",\n            \"&yen;\": \"¥\",\n            \"&yfr;\": \"𝔶\",\n            \"&yicy;\": \"ї\",\n            \"&yopf;\": \"𝕪\",\n            \"&yscr;\": \"𝓎\",\n            \"&yucy;\": \"ю\",\n            \"&yuml\": \"ÿ\",\n            \"&yuml;\": \"ÿ\",\n            \"&zacute;\": \"ź\",\n            \"&zcaron;\": \"ž\",\n            \"&zcy;\": \"з\",\n            \"&zdot;\": \"ż\",\n            \"&zeetrf;\": \"ℨ\",\n            \"&zeta;\": \"ζ\",\n            \"&zfr;\": \"𝔷\",\n            \"&zhcy;\": \"ж\",\n            \"&zigrarr;\": \"⇝\",\n            \"&zopf;\": \"𝕫\",\n            \"&zscr;\": \"𝓏\",\n            \"&zwj;\": \"‍\",\n            \"&zwnj;\": \"‌\"\n        },\n        \"characters\": {\n            \"Æ\": \"&AElig;\",\n            \"&\": \"&amp;\",\n            \"Á\": \"&Aacute;\",\n            \"Ă\": \"&Abreve;\",\n            \"Â\": \"&Acirc;\",\n            \"А\": \"&Acy;\",\n            \"𝔄\": \"&Afr;\",\n            \"À\": \"&Agrave;\",\n            \"Α\": \"&Alpha;\",\n            \"Ā\": \"&Amacr;\",\n            \"⩓\": \"&And;\",\n            \"Ą\": \"&Aogon;\",\n            \"𝔸\": \"&Aopf;\",\n            \"⁡\": \"&af;\",\n            \"Å\": \"&angst;\",\n            \"𝒜\": \"&Ascr;\",\n            \"≔\": \"&coloneq;\",\n            \"Ã\": \"&Atilde;\",\n            \"Ä\": \"&Auml;\",\n            \"∖\": \"&ssetmn;\",\n            \"⫧\": \"&Barv;\",\n            \"⌆\": \"&doublebarwedge;\",\n            \"Б\": \"&Bcy;\",\n            \"∵\": \"&because;\",\n            \"ℬ\": \"&bernou;\",\n            \"Β\": \"&Beta;\",\n            \"𝔅\": \"&Bfr;\",\n            \"𝔹\": \"&Bopf;\",\n            \"˘\": \"&breve;\",\n            \"≎\": \"&bump;\",\n            \"Ч\": \"&CHcy;\",\n            \"©\": \"&copy;\",\n            \"Ć\": \"&Cacute;\",\n            \"⋒\": \"&Cap;\",\n            \"ⅅ\": \"&DD;\",\n            \"ℭ\": \"&Cfr;\",\n            \"Č\": \"&Ccaron;\",\n            \"Ç\": \"&Ccedil;\",\n            \"Ĉ\": \"&Ccirc;\",\n            \"∰\": \"&Cconint;\",\n            \"Ċ\": \"&Cdot;\",\n            \"¸\": \"&cedil;\",\n            \"·\": \"&middot;\",\n            \"Χ\": \"&Chi;\",\n            \"⊙\": \"&odot;\",\n            \"⊖\": \"&ominus;\",\n            \"⊕\": \"&oplus;\",\n            \"⊗\": \"&otimes;\",\n            \"∲\": \"&cwconint;\",\n            \"”\": \"&rdquor;\",\n            \"’\": \"&rsquor;\",\n            \"∷\": \"&Proportion;\",\n            \"⩴\": \"&Colone;\",\n            \"≡\": \"&equiv;\",\n            \"∯\": \"&DoubleContourIntegral;\",\n            \"∮\": \"&oint;\",\n            \"ℂ\": \"&complexes;\",\n            \"∐\": \"&coprod;\",\n            \"∳\": \"&awconint;\",\n            \"⨯\": \"&Cross;\",\n            \"𝒞\": \"&Cscr;\",\n            \"⋓\": \"&Cup;\",\n            \"≍\": \"&asympeq;\",\n            \"⤑\": \"&DDotrahd;\",\n            \"Ђ\": \"&DJcy;\",\n            \"Ѕ\": \"&DScy;\",\n            \"Џ\": \"&DZcy;\",\n            \"‡\": \"&ddagger;\",\n            \"↡\": \"&Darr;\",\n            \"⫤\": \"&DoubleLeftTee;\",\n            \"Ď\": \"&Dcaron;\",\n            \"Д\": \"&Dcy;\",\n            \"∇\": \"&nabla;\",\n            \"Δ\": \"&Delta;\",\n            \"𝔇\": \"&Dfr;\",\n            \"´\": \"&acute;\",\n            \"˙\": \"&dot;\",\n            \"˝\": \"&dblac;\",\n            \"`\": \"&grave;\",\n            \"˜\": \"&tilde;\",\n            \"⋄\": \"&diamond;\",\n            \"ⅆ\": \"&dd;\",\n            \"𝔻\": \"&Dopf;\",\n            \"¨\": \"&uml;\",\n            \"⃜\": \"&DotDot;\",\n            \"≐\": \"&esdot;\",\n            \"⇓\": \"&dArr;\",\n            \"⇐\": \"&lArr;\",\n            \"⇔\": \"&iff;\",\n            \"⟸\": \"&xlArr;\",\n            \"⟺\": \"&xhArr;\",\n            \"⟹\": \"&xrArr;\",\n            \"⇒\": \"&rArr;\",\n            \"⊨\": \"&vDash;\",\n            \"⇑\": \"&uArr;\",\n            \"⇕\": \"&vArr;\",\n            \"∥\": \"&spar;\",\n            \"↓\": \"&downarrow;\",\n            \"⤓\": \"&DownArrowBar;\",\n            \"⇵\": \"&duarr;\",\n            \"̑\": \"&DownBreve;\",\n            \"⥐\": \"&DownLeftRightVector;\",\n            \"⥞\": \"&DownLeftTeeVector;\",\n            \"↽\": \"&lhard;\",\n            \"⥖\": \"&DownLeftVectorBar;\",\n            \"⥟\": \"&DownRightTeeVector;\",\n            \"⇁\": \"&rightharpoondown;\",\n            \"⥗\": \"&DownRightVectorBar;\",\n            \"⊤\": \"&top;\",\n            \"↧\": \"&mapstodown;\",\n            \"𝒟\": \"&Dscr;\",\n            \"Đ\": \"&Dstrok;\",\n            \"Ŋ\": \"&ENG;\",\n            \"Ð\": \"&ETH;\",\n            \"É\": \"&Eacute;\",\n            \"Ě\": \"&Ecaron;\",\n            \"Ê\": \"&Ecirc;\",\n            \"Э\": \"&Ecy;\",\n            \"Ė\": \"&Edot;\",\n            \"𝔈\": \"&Efr;\",\n            \"È\": \"&Egrave;\",\n            \"∈\": \"&isinv;\",\n            \"Ē\": \"&Emacr;\",\n            \"◻\": \"&EmptySmallSquare;\",\n            \"▫\": \"&EmptyVerySmallSquare;\",\n            \"Ę\": \"&Eogon;\",\n            \"𝔼\": \"&Eopf;\",\n            \"Ε\": \"&Epsilon;\",\n            \"⩵\": \"&Equal;\",\n            \"≂\": \"&esim;\",\n            \"⇌\": \"&rlhar;\",\n            \"ℰ\": \"&expectation;\",\n            \"⩳\": \"&Esim;\",\n            \"Η\": \"&Eta;\",\n            \"Ë\": \"&Euml;\",\n            \"∃\": \"&exist;\",\n            \"ⅇ\": \"&exponentiale;\",\n            \"Ф\": \"&Fcy;\",\n            \"𝔉\": \"&Ffr;\",\n            \"◼\": \"&FilledSmallSquare;\",\n            \"▪\": \"&squf;\",\n            \"𝔽\": \"&Fopf;\",\n            \"∀\": \"&forall;\",\n            \"ℱ\": \"&Fscr;\",\n            \"Ѓ\": \"&GJcy;\",\n            \">\": \"&gt;\",\n            \"Γ\": \"&Gamma;\",\n            \"Ϝ\": \"&Gammad;\",\n            \"Ğ\": \"&Gbreve;\",\n            \"Ģ\": \"&Gcedil;\",\n            \"Ĝ\": \"&Gcirc;\",\n            \"Г\": \"&Gcy;\",\n            \"Ġ\": \"&Gdot;\",\n            \"𝔊\": \"&Gfr;\",\n            \"⋙\": \"&ggg;\",\n            \"𝔾\": \"&Gopf;\",\n            \"≥\": \"&geq;\",\n            \"⋛\": \"&gtreqless;\",\n            \"≧\": \"&geqq;\",\n            \"⪢\": \"&GreaterGreater;\",\n            \"≷\": \"&gtrless;\",\n            \"⩾\": \"&ges;\",\n            \"≳\": \"&gtrsim;\",\n            \"𝒢\": \"&Gscr;\",\n            \"≫\": \"&gg;\",\n            \"Ъ\": \"&HARDcy;\",\n            \"ˇ\": \"&caron;\",\n            \"^\": \"&Hat;\",\n            \"Ĥ\": \"&Hcirc;\",\n            \"ℌ\": \"&Poincareplane;\",\n            \"ℋ\": \"&hamilt;\",\n            \"ℍ\": \"&quaternions;\",\n            \"─\": \"&boxh;\",\n            \"Ħ\": \"&Hstrok;\",\n            \"≏\": \"&bumpeq;\",\n            \"Е\": \"&IEcy;\",\n            \"IJ\": \"&IJlig;\",\n            \"Ё\": \"&IOcy;\",\n            \"Í\": \"&Iacute;\",\n            \"Î\": \"&Icirc;\",\n            \"И\": \"&Icy;\",\n            \"İ\": \"&Idot;\",\n            \"ℑ\": \"&imagpart;\",\n            \"Ì\": \"&Igrave;\",\n            \"Ī\": \"&Imacr;\",\n            \"ⅈ\": \"&ii;\",\n            \"∬\": \"&Int;\",\n            \"∫\": \"&int;\",\n            \"⋂\": \"&xcap;\",\n            \"⁣\": \"&ic;\",\n            \"⁢\": \"&it;\",\n            \"Į\": \"&Iogon;\",\n            \"𝕀\": \"&Iopf;\",\n            \"Ι\": \"&Iota;\",\n            \"ℐ\": \"&imagline;\",\n            \"Ĩ\": \"&Itilde;\",\n            \"І\": \"&Iukcy;\",\n            \"Ï\": \"&Iuml;\",\n            \"Ĵ\": \"&Jcirc;\",\n            \"Й\": \"&Jcy;\",\n            \"𝔍\": \"&Jfr;\",\n            \"𝕁\": \"&Jopf;\",\n            \"𝒥\": \"&Jscr;\",\n            \"Ј\": \"&Jsercy;\",\n            \"Є\": \"&Jukcy;\",\n            \"Х\": \"&KHcy;\",\n            \"Ќ\": \"&KJcy;\",\n            \"Κ\": \"&Kappa;\",\n            \"Ķ\": \"&Kcedil;\",\n            \"К\": \"&Kcy;\",\n            \"𝔎\": \"&Kfr;\",\n            \"𝕂\": \"&Kopf;\",\n            \"𝒦\": \"&Kscr;\",\n            \"Љ\": \"&LJcy;\",\n            \"<\": \"&lt;\",\n            \"Ĺ\": \"&Lacute;\",\n            \"Λ\": \"&Lambda;\",\n            \"⟪\": \"&Lang;\",\n            \"ℒ\": \"&lagran;\",\n            \"↞\": \"&twoheadleftarrow;\",\n            \"Ľ\": \"&Lcaron;\",\n            \"Ļ\": \"&Lcedil;\",\n            \"Л\": \"&Lcy;\",\n            \"⟨\": \"&langle;\",\n            \"←\": \"&slarr;\",\n            \"⇤\": \"&larrb;\",\n            \"⇆\": \"&lrarr;\",\n            \"⌈\": \"&lceil;\",\n            \"⟦\": \"&lobrk;\",\n            \"⥡\": \"&LeftDownTeeVector;\",\n            \"⇃\": \"&downharpoonleft;\",\n            \"⥙\": \"&LeftDownVectorBar;\",\n            \"⌊\": \"&lfloor;\",\n            \"↔\": \"&leftrightarrow;\",\n            \"⥎\": \"&LeftRightVector;\",\n            \"⊣\": \"&dashv;\",\n            \"↤\": \"&mapstoleft;\",\n            \"⥚\": \"&LeftTeeVector;\",\n            \"⊲\": \"&vltri;\",\n            \"⧏\": \"&LeftTriangleBar;\",\n            \"⊴\": \"&trianglelefteq;\",\n            \"⥑\": \"&LeftUpDownVector;\",\n            \"⥠\": \"&LeftUpTeeVector;\",\n            \"↿\": \"&upharpoonleft;\",\n            \"⥘\": \"&LeftUpVectorBar;\",\n            \"↼\": \"&lharu;\",\n            \"⥒\": \"&LeftVectorBar;\",\n            \"⋚\": \"&lesseqgtr;\",\n            \"≦\": \"&leqq;\",\n            \"≶\": \"&lg;\",\n            \"⪡\": \"&LessLess;\",\n            \"⩽\": \"&les;\",\n            \"≲\": \"&lsim;\",\n            \"𝔏\": \"&Lfr;\",\n            \"⋘\": \"&Ll;\",\n            \"⇚\": \"&lAarr;\",\n            \"Ŀ\": \"&Lmidot;\",\n            \"⟵\": \"&xlarr;\",\n            \"⟷\": \"&xharr;\",\n            \"⟶\": \"&xrarr;\",\n            \"𝕃\": \"&Lopf;\",\n            \"↙\": \"&swarrow;\",\n            \"↘\": \"&searrow;\",\n            \"↰\": \"&lsh;\",\n            \"Ł\": \"&Lstrok;\",\n            \"≪\": \"&ll;\",\n            \"⤅\": \"&Map;\",\n            \"М\": \"&Mcy;\",\n            \" \": \"&MediumSpace;\",\n            \"ℳ\": \"&phmmat;\",\n            \"𝔐\": \"&Mfr;\",\n            \"∓\": \"&mp;\",\n            \"𝕄\": \"&Mopf;\",\n            \"Μ\": \"&Mu;\",\n            \"Њ\": \"&NJcy;\",\n            \"Ń\": \"&Nacute;\",\n            \"Ň\": \"&Ncaron;\",\n            \"Ņ\": \"&Ncedil;\",\n            \"Н\": \"&Ncy;\",\n            \"​\": \"&ZeroWidthSpace;\",\n            \"\\n\": \"&NewLine;\",\n            \"𝔑\": \"&Nfr;\",\n            \"⁠\": \"&NoBreak;\",\n            \" \": \"&nbsp;\",\n            \"ℕ\": \"&naturals;\",\n            \"⫬\": \"&Not;\",\n            \"≢\": \"&nequiv;\",\n            \"≭\": \"&NotCupCap;\",\n            \"∦\": \"&nspar;\",\n            \"∉\": \"&notinva;\",\n            \"≠\": \"&ne;\",\n            \"≂̸\": \"&nesim;\",\n            \"∄\": \"&nexists;\",\n            \"≯\": \"&ngtr;\",\n            \"≱\": \"&ngeq;\",\n            \"≧̸\": \"&ngeqq;\",\n            \"≫̸\": \"&nGtv;\",\n            \"≹\": \"&ntgl;\",\n            \"⩾̸\": \"&nges;\",\n            \"≵\": \"&ngsim;\",\n            \"≎̸\": \"&nbump;\",\n            \"≏̸\": \"&nbumpe;\",\n            \"⋪\": \"&ntriangleleft;\",\n            \"⧏̸\": \"&NotLeftTriangleBar;\",\n            \"⋬\": \"&ntrianglelefteq;\",\n            \"≮\": \"&nlt;\",\n            \"≰\": \"&nleq;\",\n            \"≸\": \"&ntlg;\",\n            \"≪̸\": \"&nLtv;\",\n            \"⩽̸\": \"&nles;\",\n            \"≴\": \"&nlsim;\",\n            \"⪢̸\": \"&NotNestedGreaterGreater;\",\n            \"⪡̸\": \"&NotNestedLessLess;\",\n            \"⊀\": \"&nprec;\",\n            \"⪯̸\": \"&npreceq;\",\n            \"⋠\": \"&nprcue;\",\n            \"∌\": \"&notniva;\",\n            \"⋫\": \"&ntriangleright;\",\n            \"⧐̸\": \"&NotRightTriangleBar;\",\n            \"⋭\": \"&ntrianglerighteq;\",\n            \"⊏̸\": \"&NotSquareSubset;\",\n            \"⋢\": \"&nsqsube;\",\n            \"⊐̸\": \"&NotSquareSuperset;\",\n            \"⋣\": \"&nsqsupe;\",\n            \"⊂⃒\": \"&vnsub;\",\n            \"⊈\": \"&nsubseteq;\",\n            \"⊁\": \"&nsucc;\",\n            \"⪰̸\": \"&nsucceq;\",\n            \"⋡\": \"&nsccue;\",\n            \"≿̸\": \"&NotSucceedsTilde;\",\n            \"⊃⃒\": \"&vnsup;\",\n            \"⊉\": \"&nsupseteq;\",\n            \"≁\": \"&nsim;\",\n            \"≄\": \"&nsimeq;\",\n            \"≇\": \"&ncong;\",\n            \"≉\": \"&napprox;\",\n            \"∤\": \"&nsmid;\",\n            \"𝒩\": \"&Nscr;\",\n            \"Ñ\": \"&Ntilde;\",\n            \"Ν\": \"&Nu;\",\n            \"Œ\": \"&OElig;\",\n            \"Ó\": \"&Oacute;\",\n            \"Ô\": \"&Ocirc;\",\n            \"О\": \"&Ocy;\",\n            \"Ő\": \"&Odblac;\",\n            \"𝔒\": \"&Ofr;\",\n            \"Ò\": \"&Ograve;\",\n            \"Ō\": \"&Omacr;\",\n            \"Ω\": \"&ohm;\",\n            \"Ο\": \"&Omicron;\",\n            \"𝕆\": \"&Oopf;\",\n            \"“\": \"&ldquo;\",\n            \"‘\": \"&lsquo;\",\n            \"⩔\": \"&Or;\",\n            \"𝒪\": \"&Oscr;\",\n            \"Ø\": \"&Oslash;\",\n            \"Õ\": \"&Otilde;\",\n            \"⨷\": \"&Otimes;\",\n            \"Ö\": \"&Ouml;\",\n            \"‾\": \"&oline;\",\n            \"⏞\": \"&OverBrace;\",\n            \"⎴\": \"&tbrk;\",\n            \"⏜\": \"&OverParenthesis;\",\n            \"∂\": \"&part;\",\n            \"П\": \"&Pcy;\",\n            \"𝔓\": \"&Pfr;\",\n            \"Φ\": \"&Phi;\",\n            \"Π\": \"&Pi;\",\n            \"±\": \"&pm;\",\n            \"ℙ\": \"&primes;\",\n            \"⪻\": \"&Pr;\",\n            \"≺\": \"&prec;\",\n            \"⪯\": \"&preceq;\",\n            \"≼\": \"&preccurlyeq;\",\n            \"≾\": \"&prsim;\",\n            \"″\": \"&Prime;\",\n            \"∏\": \"&prod;\",\n            \"∝\": \"&vprop;\",\n            \"𝒫\": \"&Pscr;\",\n            \"Ψ\": \"&Psi;\",\n            \"\\\"\": \"&quot;\",\n            \"𝔔\": \"&Qfr;\",\n            \"ℚ\": \"&rationals;\",\n            \"𝒬\": \"&Qscr;\",\n            \"⤐\": \"&drbkarow;\",\n            \"®\": \"&reg;\",\n            \"Ŕ\": \"&Racute;\",\n            \"⟫\": \"&Rang;\",\n            \"↠\": \"&twoheadrightarrow;\",\n            \"⤖\": \"&Rarrtl;\",\n            \"Ř\": \"&Rcaron;\",\n            \"Ŗ\": \"&Rcedil;\",\n            \"Р\": \"&Rcy;\",\n            \"ℜ\": \"&realpart;\",\n            \"∋\": \"&niv;\",\n            \"⇋\": \"&lrhar;\",\n            \"⥯\": \"&duhar;\",\n            \"Ρ\": \"&Rho;\",\n            \"⟩\": \"&rangle;\",\n            \"→\": \"&srarr;\",\n            \"⇥\": \"&rarrb;\",\n            \"⇄\": \"&rlarr;\",\n            \"⌉\": \"&rceil;\",\n            \"⟧\": \"&robrk;\",\n            \"⥝\": \"&RightDownTeeVector;\",\n            \"⇂\": \"&downharpoonright;\",\n            \"⥕\": \"&RightDownVectorBar;\",\n            \"⌋\": \"&rfloor;\",\n            \"⊢\": \"&vdash;\",\n            \"↦\": \"&mapsto;\",\n            \"⥛\": \"&RightTeeVector;\",\n            \"⊳\": \"&vrtri;\",\n            \"⧐\": \"&RightTriangleBar;\",\n            \"⊵\": \"&trianglerighteq;\",\n            \"⥏\": \"&RightUpDownVector;\",\n            \"⥜\": \"&RightUpTeeVector;\",\n            \"↾\": \"&upharpoonright;\",\n            \"⥔\": \"&RightUpVectorBar;\",\n            \"⇀\": \"&rightharpoonup;\",\n            \"⥓\": \"&RightVectorBar;\",\n            \"ℝ\": \"&reals;\",\n            \"⥰\": \"&RoundImplies;\",\n            \"⇛\": \"&rAarr;\",\n            \"ℛ\": \"&realine;\",\n            \"↱\": \"&rsh;\",\n            \"⧴\": \"&RuleDelayed;\",\n            \"Щ\": \"&SHCHcy;\",\n            \"Ш\": \"&SHcy;\",\n            \"Ь\": \"&SOFTcy;\",\n            \"Ś\": \"&Sacute;\",\n            \"⪼\": \"&Sc;\",\n            \"Š\": \"&Scaron;\",\n            \"Ş\": \"&Scedil;\",\n            \"Ŝ\": \"&Scirc;\",\n            \"С\": \"&Scy;\",\n            \"𝔖\": \"&Sfr;\",\n            \"↑\": \"&uparrow;\",\n            \"Σ\": \"&Sigma;\",\n            \"∘\": \"&compfn;\",\n            \"𝕊\": \"&Sopf;\",\n            \"√\": \"&radic;\",\n            \"□\": \"&square;\",\n            \"⊓\": \"&sqcap;\",\n            \"⊏\": \"&sqsubset;\",\n            \"⊑\": \"&sqsubseteq;\",\n            \"⊐\": \"&sqsupset;\",\n            \"⊒\": \"&sqsupseteq;\",\n            \"⊔\": \"&sqcup;\",\n            \"𝒮\": \"&Sscr;\",\n            \"⋆\": \"&sstarf;\",\n            \"⋐\": \"&Subset;\",\n            \"⊆\": \"&subseteq;\",\n            \"≻\": \"&succ;\",\n            \"⪰\": \"&succeq;\",\n            \"≽\": \"&succcurlyeq;\",\n            \"≿\": \"&succsim;\",\n            \"∑\": \"&sum;\",\n            \"⋑\": \"&Supset;\",\n            \"⊃\": \"&supset;\",\n            \"⊇\": \"&supseteq;\",\n            \"Þ\": \"&THORN;\",\n            \"™\": \"&trade;\",\n            \"Ћ\": \"&TSHcy;\",\n            \"Ц\": \"&TScy;\",\n            \"\\t\": \"&Tab;\",\n            \"Τ\": \"&Tau;\",\n            \"Ť\": \"&Tcaron;\",\n            \"Ţ\": \"&Tcedil;\",\n            \"Т\": \"&Tcy;\",\n            \"𝔗\": \"&Tfr;\",\n            \"∴\": \"&therefore;\",\n            \"Θ\": \"&Theta;\",\n            \"  \": \"&ThickSpace;\",\n            \" \": \"&thinsp;\",\n            \"∼\": \"&thksim;\",\n            \"≃\": \"&simeq;\",\n            \"≅\": \"&cong;\",\n            \"≈\": \"&thkap;\",\n            \"𝕋\": \"&Topf;\",\n            \"⃛\": \"&tdot;\",\n            \"𝒯\": \"&Tscr;\",\n            \"Ŧ\": \"&Tstrok;\",\n            \"Ú\": \"&Uacute;\",\n            \"↟\": \"&Uarr;\",\n            \"⥉\": \"&Uarrocir;\",\n            \"Ў\": \"&Ubrcy;\",\n            \"Ŭ\": \"&Ubreve;\",\n            \"Û\": \"&Ucirc;\",\n            \"У\": \"&Ucy;\",\n            \"Ű\": \"&Udblac;\",\n            \"𝔘\": \"&Ufr;\",\n            \"Ù\": \"&Ugrave;\",\n            \"Ū\": \"&Umacr;\",\n            \"_\": \"&lowbar;\",\n            \"⏟\": \"&UnderBrace;\",\n            \"⎵\": \"&bbrk;\",\n            \"⏝\": \"&UnderParenthesis;\",\n            \"⋃\": \"&xcup;\",\n            \"⊎\": \"&uplus;\",\n            \"Ų\": \"&Uogon;\",\n            \"𝕌\": \"&Uopf;\",\n            \"⤒\": \"&UpArrowBar;\",\n            \"⇅\": \"&udarr;\",\n            \"↕\": \"&varr;\",\n            \"⥮\": \"&udhar;\",\n            \"⊥\": \"&perp;\",\n            \"↥\": \"&mapstoup;\",\n            \"↖\": \"&nwarrow;\",\n            \"↗\": \"&nearrow;\",\n            \"ϒ\": \"&upsih;\",\n            \"Υ\": \"&Upsilon;\",\n            \"Ů\": \"&Uring;\",\n            \"𝒰\": \"&Uscr;\",\n            \"Ũ\": \"&Utilde;\",\n            \"Ü\": \"&Uuml;\",\n            \"⊫\": \"&VDash;\",\n            \"⫫\": \"&Vbar;\",\n            \"В\": \"&Vcy;\",\n            \"⊩\": \"&Vdash;\",\n            \"⫦\": \"&Vdashl;\",\n            \"⋁\": \"&xvee;\",\n            \"‖\": \"&Vert;\",\n            \"∣\": \"&smid;\",\n            \"|\": \"&vert;\",\n            \"❘\": \"&VerticalSeparator;\",\n            \"≀\": \"&wreath;\",\n            \" \": \"&hairsp;\",\n            \"𝔙\": \"&Vfr;\",\n            \"𝕍\": \"&Vopf;\",\n            \"𝒱\": \"&Vscr;\",\n            \"⊪\": \"&Vvdash;\",\n            \"Ŵ\": \"&Wcirc;\",\n            \"⋀\": \"&xwedge;\",\n            \"𝔚\": \"&Wfr;\",\n            \"𝕎\": \"&Wopf;\",\n            \"𝒲\": \"&Wscr;\",\n            \"𝔛\": \"&Xfr;\",\n            \"Ξ\": \"&Xi;\",\n            \"𝕏\": \"&Xopf;\",\n            \"𝒳\": \"&Xscr;\",\n            \"Я\": \"&YAcy;\",\n            \"Ї\": \"&YIcy;\",\n            \"Ю\": \"&YUcy;\",\n            \"Ý\": \"&Yacute;\",\n            \"Ŷ\": \"&Ycirc;\",\n            \"Ы\": \"&Ycy;\",\n            \"𝔜\": \"&Yfr;\",\n            \"𝕐\": \"&Yopf;\",\n            \"𝒴\": \"&Yscr;\",\n            \"Ÿ\": \"&Yuml;\",\n            \"Ж\": \"&ZHcy;\",\n            \"Ź\": \"&Zacute;\",\n            \"Ž\": \"&Zcaron;\",\n            \"З\": \"&Zcy;\",\n            \"Ż\": \"&Zdot;\",\n            \"Ζ\": \"&Zeta;\",\n            \"ℨ\": \"&zeetrf;\",\n            \"ℤ\": \"&integers;\",\n            \"𝒵\": \"&Zscr;\",\n            \"á\": \"&aacute;\",\n            \"ă\": \"&abreve;\",\n            \"∾\": \"&mstpos;\",\n            \"∾̳\": \"&acE;\",\n            \"∿\": \"&acd;\",\n            \"â\": \"&acirc;\",\n            \"а\": \"&acy;\",\n            \"æ\": \"&aelig;\",\n            \"𝔞\": \"&afr;\",\n            \"à\": \"&agrave;\",\n            \"ℵ\": \"&aleph;\",\n            \"α\": \"&alpha;\",\n            \"ā\": \"&amacr;\",\n            \"⨿\": \"&amalg;\",\n            \"∧\": \"&wedge;\",\n            \"⩕\": \"&andand;\",\n            \"⩜\": \"&andd;\",\n            \"⩘\": \"&andslope;\",\n            \"⩚\": \"&andv;\",\n            \"∠\": \"&angle;\",\n            \"⦤\": \"&ange;\",\n            \"∡\": \"&measuredangle;\",\n            \"⦨\": \"&angmsdaa;\",\n            \"⦩\": \"&angmsdab;\",\n            \"⦪\": \"&angmsdac;\",\n            \"⦫\": \"&angmsdad;\",\n            \"⦬\": \"&angmsdae;\",\n            \"⦭\": \"&angmsdaf;\",\n            \"⦮\": \"&angmsdag;\",\n            \"⦯\": \"&angmsdah;\",\n            \"∟\": \"&angrt;\",\n            \"⊾\": \"&angrtvb;\",\n            \"⦝\": \"&angrtvbd;\",\n            \"∢\": \"&angsph;\",\n            \"⍼\": \"&angzarr;\",\n            \"ą\": \"&aogon;\",\n            \"𝕒\": \"&aopf;\",\n            \"⩰\": \"&apE;\",\n            \"⩯\": \"&apacir;\",\n            \"≊\": \"&approxeq;\",\n            \"≋\": \"&apid;\",\n            \"'\": \"&apos;\",\n            \"å\": \"&aring;\",\n            \"𝒶\": \"&ascr;\",\n            \"*\": \"&midast;\",\n            \"ã\": \"&atilde;\",\n            \"ä\": \"&auml;\",\n            \"⨑\": \"&awint;\",\n            \"⫭\": \"&bNot;\",\n            \"≌\": \"&bcong;\",\n            \"϶\": \"&bepsi;\",\n            \"‵\": \"&bprime;\",\n            \"∽\": \"&bsim;\",\n            \"⋍\": \"&bsime;\",\n            \"⊽\": \"&barvee;\",\n            \"⌅\": \"&barwedge;\",\n            \"⎶\": \"&bbrktbrk;\",\n            \"б\": \"&bcy;\",\n            \"„\": \"&ldquor;\",\n            \"⦰\": \"&bemptyv;\",\n            \"β\": \"&beta;\",\n            \"ℶ\": \"&beth;\",\n            \"≬\": \"&twixt;\",\n            \"𝔟\": \"&bfr;\",\n            \"◯\": \"&xcirc;\",\n            \"⨀\": \"&xodot;\",\n            \"⨁\": \"&xoplus;\",\n            \"⨂\": \"&xotime;\",\n            \"⨆\": \"&xsqcup;\",\n            \"★\": \"&starf;\",\n            \"▽\": \"&xdtri;\",\n            \"△\": \"&xutri;\",\n            \"⨄\": \"&xuplus;\",\n            \"⤍\": \"&rbarr;\",\n            \"⧫\": \"&lozf;\",\n            \"▴\": \"&utrif;\",\n            \"▾\": \"&dtrif;\",\n            \"◂\": \"&ltrif;\",\n            \"▸\": \"&rtrif;\",\n            \"␣\": \"&blank;\",\n            \"▒\": \"&blk12;\",\n            \"░\": \"&blk14;\",\n            \"▓\": \"&blk34;\",\n            \"█\": \"&block;\",\n            \"=⃥\": \"&bne;\",\n            \"≡⃥\": \"&bnequiv;\",\n            \"⌐\": \"&bnot;\",\n            \"𝕓\": \"&bopf;\",\n            \"⋈\": \"&bowtie;\",\n            \"╗\": \"&boxDL;\",\n            \"╔\": \"&boxDR;\",\n            \"╖\": \"&boxDl;\",\n            \"╓\": \"&boxDr;\",\n            \"═\": \"&boxH;\",\n            \"╦\": \"&boxHD;\",\n            \"╩\": \"&boxHU;\",\n            \"╤\": \"&boxHd;\",\n            \"╧\": \"&boxHu;\",\n            \"╝\": \"&boxUL;\",\n            \"╚\": \"&boxUR;\",\n            \"╜\": \"&boxUl;\",\n            \"╙\": \"&boxUr;\",\n            \"║\": \"&boxV;\",\n            \"╬\": \"&boxVH;\",\n            \"╣\": \"&boxVL;\",\n            \"╠\": \"&boxVR;\",\n            \"╫\": \"&boxVh;\",\n            \"╢\": \"&boxVl;\",\n            \"╟\": \"&boxVr;\",\n            \"⧉\": \"&boxbox;\",\n            \"╕\": \"&boxdL;\",\n            \"╒\": \"&boxdR;\",\n            \"┐\": \"&boxdl;\",\n            \"┌\": \"&boxdr;\",\n            \"╥\": \"&boxhD;\",\n            \"╨\": \"&boxhU;\",\n            \"┬\": \"&boxhd;\",\n            \"┴\": \"&boxhu;\",\n            \"⊟\": \"&minusb;\",\n            \"⊞\": \"&plusb;\",\n            \"⊠\": \"&timesb;\",\n            \"╛\": \"&boxuL;\",\n            \"╘\": \"&boxuR;\",\n            \"┘\": \"&boxul;\",\n            \"└\": \"&boxur;\",\n            \"│\": \"&boxv;\",\n            \"╪\": \"&boxvH;\",\n            \"╡\": \"&boxvL;\",\n            \"╞\": \"&boxvR;\",\n            \"┼\": \"&boxvh;\",\n            \"┤\": \"&boxvl;\",\n            \"├\": \"&boxvr;\",\n            \"¦\": \"&brvbar;\",\n            \"𝒷\": \"&bscr;\",\n            \"⁏\": \"&bsemi;\",\n            \"\\\\\": \"&bsol;\",\n            \"⧅\": \"&bsolb;\",\n            \"⟈\": \"&bsolhsub;\",\n            \"•\": \"&bullet;\",\n            \"⪮\": \"&bumpE;\",\n            \"ć\": \"&cacute;\",\n            \"∩\": \"&cap;\",\n            \"⩄\": \"&capand;\",\n            \"⩉\": \"&capbrcup;\",\n            \"⩋\": \"&capcap;\",\n            \"⩇\": \"&capcup;\",\n            \"⩀\": \"&capdot;\",\n            \"∩︀\": \"&caps;\",\n            \"⁁\": \"&caret;\",\n            \"⩍\": \"&ccaps;\",\n            \"č\": \"&ccaron;\",\n            \"ç\": \"&ccedil;\",\n            \"ĉ\": \"&ccirc;\",\n            \"⩌\": \"&ccups;\",\n            \"⩐\": \"&ccupssm;\",\n            \"ċ\": \"&cdot;\",\n            \"⦲\": \"&cemptyv;\",\n            \"¢\": \"&cent;\",\n            \"𝔠\": \"&cfr;\",\n            \"ч\": \"&chcy;\",\n            \"✓\": \"&checkmark;\",\n            \"χ\": \"&chi;\",\n            \"○\": \"&cir;\",\n            \"⧃\": \"&cirE;\",\n            \"ˆ\": \"&circ;\",\n            \"≗\": \"&cire;\",\n            \"↺\": \"&olarr;\",\n            \"↻\": \"&orarr;\",\n            \"Ⓢ\": \"&oS;\",\n            \"⊛\": \"&oast;\",\n            \"⊚\": \"&ocir;\",\n            \"⊝\": \"&odash;\",\n            \"⨐\": \"&cirfnint;\",\n            \"⫯\": \"&cirmid;\",\n            \"⧂\": \"&cirscir;\",\n            \"♣\": \"&clubsuit;\",\n            \":\": \"&colon;\",\n            \",\": \"&comma;\",\n            \"@\": \"&commat;\",\n            \"∁\": \"&complement;\",\n            \"⩭\": \"&congdot;\",\n            \"𝕔\": \"&copf;\",\n            \"℗\": \"&copysr;\",\n            \"↵\": \"&crarr;\",\n            \"✗\": \"&cross;\",\n            \"𝒸\": \"&cscr;\",\n            \"⫏\": \"&csub;\",\n            \"⫑\": \"&csube;\",\n            \"⫐\": \"&csup;\",\n            \"⫒\": \"&csupe;\",\n            \"⋯\": \"&ctdot;\",\n            \"⤸\": \"&cudarrl;\",\n            \"⤵\": \"&cudarrr;\",\n            \"⋞\": \"&curlyeqprec;\",\n            \"⋟\": \"&curlyeqsucc;\",\n            \"↶\": \"&curvearrowleft;\",\n            \"⤽\": \"&cularrp;\",\n            \"∪\": \"&cup;\",\n            \"⩈\": \"&cupbrcap;\",\n            \"⩆\": \"&cupcap;\",\n            \"⩊\": \"&cupcup;\",\n            \"⊍\": \"&cupdot;\",\n            \"⩅\": \"&cupor;\",\n            \"∪︀\": \"&cups;\",\n            \"↷\": \"&curvearrowright;\",\n            \"⤼\": \"&curarrm;\",\n            \"⋎\": \"&cuvee;\",\n            \"⋏\": \"&cuwed;\",\n            \"¤\": \"&curren;\",\n            \"∱\": \"&cwint;\",\n            \"⌭\": \"&cylcty;\",\n            \"⥥\": \"&dHar;\",\n            \"†\": \"&dagger;\",\n            \"ℸ\": \"&daleth;\",\n            \"‐\": \"&hyphen;\",\n            \"⤏\": \"&rBarr;\",\n            \"ď\": \"&dcaron;\",\n            \"д\": \"&dcy;\",\n            \"⇊\": \"&downdownarrows;\",\n            \"⩷\": \"&eDDot;\",\n            \"°\": \"&deg;\",\n            \"δ\": \"&delta;\",\n            \"⦱\": \"&demptyv;\",\n            \"⥿\": \"&dfisht;\",\n            \"𝔡\": \"&dfr;\",\n            \"♦\": \"&diams;\",\n            \"ϝ\": \"&gammad;\",\n            \"⋲\": \"&disin;\",\n            \"÷\": \"&divide;\",\n            \"⋇\": \"&divonx;\",\n            \"ђ\": \"&djcy;\",\n            \"⌞\": \"&llcorner;\",\n            \"⌍\": \"&dlcrop;\",\n            \"$\": \"&dollar;\",\n            \"𝕕\": \"&dopf;\",\n            \"≑\": \"&eDot;\",\n            \"∸\": \"&minusd;\",\n            \"∔\": \"&plusdo;\",\n            \"⊡\": \"&sdotb;\",\n            \"⌟\": \"&lrcorner;\",\n            \"⌌\": \"&drcrop;\",\n            \"𝒹\": \"&dscr;\",\n            \"ѕ\": \"&dscy;\",\n            \"⧶\": \"&dsol;\",\n            \"đ\": \"&dstrok;\",\n            \"⋱\": \"&dtdot;\",\n            \"▿\": \"&triangledown;\",\n            \"⦦\": \"&dwangle;\",\n            \"џ\": \"&dzcy;\",\n            \"⟿\": \"&dzigrarr;\",\n            \"é\": \"&eacute;\",\n            \"⩮\": \"&easter;\",\n            \"ě\": \"&ecaron;\",\n            \"≖\": \"&eqcirc;\",\n            \"ê\": \"&ecirc;\",\n            \"≕\": \"&eqcolon;\",\n            \"э\": \"&ecy;\",\n            \"ė\": \"&edot;\",\n            \"≒\": \"&fallingdotseq;\",\n            \"𝔢\": \"&efr;\",\n            \"⪚\": \"&eg;\",\n            \"è\": \"&egrave;\",\n            \"⪖\": \"&eqslantgtr;\",\n            \"⪘\": \"&egsdot;\",\n            \"⪙\": \"&el;\",\n            \"⏧\": \"&elinters;\",\n            \"ℓ\": \"&ell;\",\n            \"⪕\": \"&eqslantless;\",\n            \"⪗\": \"&elsdot;\",\n            \"ē\": \"&emacr;\",\n            \"∅\": \"&varnothing;\",\n            \" \": \"&emsp13;\",\n            \" \": \"&emsp14;\",\n            \" \": \"&emsp;\",\n            \"ŋ\": \"&eng;\",\n            \" \": \"&ensp;\",\n            \"ę\": \"&eogon;\",\n            \"𝕖\": \"&eopf;\",\n            \"⋕\": \"&epar;\",\n            \"⧣\": \"&eparsl;\",\n            \"⩱\": \"&eplus;\",\n            \"ε\": \"&epsilon;\",\n            \"ϵ\": \"&varepsilon;\",\n            \"=\": \"&equals;\",\n            \"≟\": \"&questeq;\",\n            \"⩸\": \"&equivDD;\",\n            \"⧥\": \"&eqvparsl;\",\n            \"≓\": \"&risingdotseq;\",\n            \"⥱\": \"&erarr;\",\n            \"ℯ\": \"&escr;\",\n            \"η\": \"&eta;\",\n            \"ð\": \"&eth;\",\n            \"ë\": \"&euml;\",\n            \"€\": \"&euro;\",\n            \"!\": \"&excl;\",\n            \"ф\": \"&fcy;\",\n            \"♀\": \"&female;\",\n            \"ffi\": \"&ffilig;\",\n            \"ff\": \"&fflig;\",\n            \"ffl\": \"&ffllig;\",\n            \"𝔣\": \"&ffr;\",\n            \"fi\": \"&filig;\",\n            \"fj\": \"&fjlig;\",\n            \"♭\": \"&flat;\",\n            \"fl\": \"&fllig;\",\n            \"▱\": \"&fltns;\",\n            \"ƒ\": \"&fnof;\",\n            \"𝕗\": \"&fopf;\",\n            \"⋔\": \"&pitchfork;\",\n            \"⫙\": \"&forkv;\",\n            \"⨍\": \"&fpartint;\",\n            \"½\": \"&half;\",\n            \"⅓\": \"&frac13;\",\n            \"¼\": \"&frac14;\",\n            \"⅕\": \"&frac15;\",\n            \"⅙\": \"&frac16;\",\n            \"⅛\": \"&frac18;\",\n            \"⅔\": \"&frac23;\",\n            \"⅖\": \"&frac25;\",\n            \"¾\": \"&frac34;\",\n            \"⅗\": \"&frac35;\",\n            \"⅜\": \"&frac38;\",\n            \"⅘\": \"&frac45;\",\n            \"⅚\": \"&frac56;\",\n            \"⅝\": \"&frac58;\",\n            \"⅞\": \"&frac78;\",\n            \"⁄\": \"&frasl;\",\n            \"⌢\": \"&sfrown;\",\n            \"𝒻\": \"&fscr;\",\n            \"⪌\": \"&gtreqqless;\",\n            \"ǵ\": \"&gacute;\",\n            \"γ\": \"&gamma;\",\n            \"⪆\": \"&gtrapprox;\",\n            \"ğ\": \"&gbreve;\",\n            \"ĝ\": \"&gcirc;\",\n            \"г\": \"&gcy;\",\n            \"ġ\": \"&gdot;\",\n            \"⪩\": \"&gescc;\",\n            \"⪀\": \"&gesdot;\",\n            \"⪂\": \"&gesdoto;\",\n            \"⪄\": \"&gesdotol;\",\n            \"⋛︀\": \"&gesl;\",\n            \"⪔\": \"&gesles;\",\n            \"𝔤\": \"&gfr;\",\n            \"ℷ\": \"&gimel;\",\n            \"ѓ\": \"&gjcy;\",\n            \"⪒\": \"&glE;\",\n            \"⪥\": \"&gla;\",\n            \"⪤\": \"&glj;\",\n            \"≩\": \"&gneqq;\",\n            \"⪊\": \"&gnapprox;\",\n            \"⪈\": \"&gneq;\",\n            \"⋧\": \"&gnsim;\",\n            \"𝕘\": \"&gopf;\",\n            \"ℊ\": \"&gscr;\",\n            \"⪎\": \"&gsime;\",\n            \"⪐\": \"&gsiml;\",\n            \"⪧\": \"&gtcc;\",\n            \"⩺\": \"&gtcir;\",\n            \"⋗\": \"&gtrdot;\",\n            \"⦕\": \"&gtlPar;\",\n            \"⩼\": \"&gtquest;\",\n            \"⥸\": \"&gtrarr;\",\n            \"≩︀\": \"&gvnE;\",\n            \"ъ\": \"&hardcy;\",\n            \"⥈\": \"&harrcir;\",\n            \"↭\": \"&leftrightsquigarrow;\",\n            \"ℏ\": \"&plankv;\",\n            \"ĥ\": \"&hcirc;\",\n            \"♥\": \"&heartsuit;\",\n            \"…\": \"&mldr;\",\n            \"⊹\": \"&hercon;\",\n            \"𝔥\": \"&hfr;\",\n            \"⤥\": \"&searhk;\",\n            \"⤦\": \"&swarhk;\",\n            \"⇿\": \"&hoarr;\",\n            \"∻\": \"&homtht;\",\n            \"↩\": \"&larrhk;\",\n            \"↪\": \"&rarrhk;\",\n            \"𝕙\": \"&hopf;\",\n            \"―\": \"&horbar;\",\n            \"𝒽\": \"&hscr;\",\n            \"ħ\": \"&hstrok;\",\n            \"⁃\": \"&hybull;\",\n            \"í\": \"&iacute;\",\n            \"î\": \"&icirc;\",\n            \"и\": \"&icy;\",\n            \"е\": \"&iecy;\",\n            \"¡\": \"&iexcl;\",\n            \"𝔦\": \"&ifr;\",\n            \"ì\": \"&igrave;\",\n            \"⨌\": \"&qint;\",\n            \"∭\": \"&tint;\",\n            \"⧜\": \"&iinfin;\",\n            \"℩\": \"&iiota;\",\n            \"ij\": \"&ijlig;\",\n            \"ī\": \"&imacr;\",\n            \"ı\": \"&inodot;\",\n            \"⊷\": \"&imof;\",\n            \"Ƶ\": \"&imped;\",\n            \"℅\": \"&incare;\",\n            \"∞\": \"&infin;\",\n            \"⧝\": \"&infintie;\",\n            \"⊺\": \"&intercal;\",\n            \"⨗\": \"&intlarhk;\",\n            \"⨼\": \"&iprod;\",\n            \"ё\": \"&iocy;\",\n            \"į\": \"&iogon;\",\n            \"𝕚\": \"&iopf;\",\n            \"ι\": \"&iota;\",\n            \"¿\": \"&iquest;\",\n            \"𝒾\": \"&iscr;\",\n            \"⋹\": \"&isinE;\",\n            \"⋵\": \"&isindot;\",\n            \"⋴\": \"&isins;\",\n            \"⋳\": \"&isinsv;\",\n            \"ĩ\": \"&itilde;\",\n            \"і\": \"&iukcy;\",\n            \"ï\": \"&iuml;\",\n            \"ĵ\": \"&jcirc;\",\n            \"й\": \"&jcy;\",\n            \"𝔧\": \"&jfr;\",\n            \"ȷ\": \"&jmath;\",\n            \"𝕛\": \"&jopf;\",\n            \"𝒿\": \"&jscr;\",\n            \"ј\": \"&jsercy;\",\n            \"є\": \"&jukcy;\",\n            \"κ\": \"&kappa;\",\n            \"ϰ\": \"&varkappa;\",\n            \"ķ\": \"&kcedil;\",\n            \"к\": \"&kcy;\",\n            \"𝔨\": \"&kfr;\",\n            \"ĸ\": \"&kgreen;\",\n            \"х\": \"&khcy;\",\n            \"ќ\": \"&kjcy;\",\n            \"𝕜\": \"&kopf;\",\n            \"𝓀\": \"&kscr;\",\n            \"⤛\": \"&lAtail;\",\n            \"⤎\": \"&lBarr;\",\n            \"⪋\": \"&lesseqqgtr;\",\n            \"⥢\": \"&lHar;\",\n            \"ĺ\": \"&lacute;\",\n            \"⦴\": \"&laemptyv;\",\n            \"λ\": \"&lambda;\",\n            \"⦑\": \"&langd;\",\n            \"⪅\": \"&lessapprox;\",\n            \"«\": \"&laquo;\",\n            \"⤟\": \"&larrbfs;\",\n            \"⤝\": \"&larrfs;\",\n            \"↫\": \"&looparrowleft;\",\n            \"⤹\": \"&larrpl;\",\n            \"⥳\": \"&larrsim;\",\n            \"↢\": \"&leftarrowtail;\",\n            \"⪫\": \"&lat;\",\n            \"⤙\": \"&latail;\",\n            \"⪭\": \"&late;\",\n            \"⪭︀\": \"&lates;\",\n            \"⤌\": \"&lbarr;\",\n            \"❲\": \"&lbbrk;\",\n            \"{\": \"&lcub;\",\n            \"[\": \"&lsqb;\",\n            \"⦋\": \"&lbrke;\",\n            \"⦏\": \"&lbrksld;\",\n            \"⦍\": \"&lbrkslu;\",\n            \"ľ\": \"&lcaron;\",\n            \"ļ\": \"&lcedil;\",\n            \"л\": \"&lcy;\",\n            \"⤶\": \"&ldca;\",\n            \"⥧\": \"&ldrdhar;\",\n            \"⥋\": \"&ldrushar;\",\n            \"↲\": \"&ldsh;\",\n            \"≤\": \"&leq;\",\n            \"⇇\": \"&llarr;\",\n            \"⋋\": \"&lthree;\",\n            \"⪨\": \"&lescc;\",\n            \"⩿\": \"&lesdot;\",\n            \"⪁\": \"&lesdoto;\",\n            \"⪃\": \"&lesdotor;\",\n            \"⋚︀\": \"&lesg;\",\n            \"⪓\": \"&lesges;\",\n            \"⋖\": \"&ltdot;\",\n            \"⥼\": \"&lfisht;\",\n            \"𝔩\": \"&lfr;\",\n            \"⪑\": \"&lgE;\",\n            \"⥪\": \"&lharul;\",\n            \"▄\": \"&lhblk;\",\n            \"љ\": \"&ljcy;\",\n            \"⥫\": \"&llhard;\",\n            \"◺\": \"&lltri;\",\n            \"ŀ\": \"&lmidot;\",\n            \"⎰\": \"&lmoustache;\",\n            \"≨\": \"&lneqq;\",\n            \"⪉\": \"&lnapprox;\",\n            \"⪇\": \"&lneq;\",\n            \"⋦\": \"&lnsim;\",\n            \"⟬\": \"&loang;\",\n            \"⇽\": \"&loarr;\",\n            \"⟼\": \"&xmap;\",\n            \"↬\": \"&rarrlp;\",\n            \"⦅\": \"&lopar;\",\n            \"𝕝\": \"&lopf;\",\n            \"⨭\": \"&loplus;\",\n            \"⨴\": \"&lotimes;\",\n            \"∗\": \"&lowast;\",\n            \"◊\": \"&lozenge;\",\n            \"(\": \"&lpar;\",\n            \"⦓\": \"&lparlt;\",\n            \"⥭\": \"&lrhard;\",\n            \"‎\": \"&lrm;\",\n            \"⊿\": \"&lrtri;\",\n            \"‹\": \"&lsaquo;\",\n            \"𝓁\": \"&lscr;\",\n            \"⪍\": \"&lsime;\",\n            \"⪏\": \"&lsimg;\",\n            \"‚\": \"&sbquo;\",\n            \"ł\": \"&lstrok;\",\n            \"⪦\": \"&ltcc;\",\n            \"⩹\": \"&ltcir;\",\n            \"⋉\": \"&ltimes;\",\n            \"⥶\": \"&ltlarr;\",\n            \"⩻\": \"&ltquest;\",\n            \"⦖\": \"&ltrPar;\",\n            \"◃\": \"&triangleleft;\",\n            \"⥊\": \"&lurdshar;\",\n            \"⥦\": \"&luruhar;\",\n            \"≨︀\": \"&lvnE;\",\n            \"∺\": \"&mDDot;\",\n            \"¯\": \"&strns;\",\n            \"♂\": \"&male;\",\n            \"✠\": \"&maltese;\",\n            \"▮\": \"&marker;\",\n            \"⨩\": \"&mcomma;\",\n            \"м\": \"&mcy;\",\n            \"—\": \"&mdash;\",\n            \"𝔪\": \"&mfr;\",\n            \"℧\": \"&mho;\",\n            \"µ\": \"&micro;\",\n            \"⫰\": \"&midcir;\",\n            \"−\": \"&minus;\",\n            \"⨪\": \"&minusdu;\",\n            \"⫛\": \"&mlcp;\",\n            \"⊧\": \"&models;\",\n            \"𝕞\": \"&mopf;\",\n            \"𝓂\": \"&mscr;\",\n            \"μ\": \"&mu;\",\n            \"⊸\": \"&mumap;\",\n            \"⋙̸\": \"&nGg;\",\n            \"≫⃒\": \"&nGt;\",\n            \"⇍\": \"&nlArr;\",\n            \"⇎\": \"&nhArr;\",\n            \"⋘̸\": \"&nLl;\",\n            \"≪⃒\": \"&nLt;\",\n            \"⇏\": \"&nrArr;\",\n            \"⊯\": \"&nVDash;\",\n            \"⊮\": \"&nVdash;\",\n            \"ń\": \"&nacute;\",\n            \"∠⃒\": \"&nang;\",\n            \"⩰̸\": \"&napE;\",\n            \"≋̸\": \"&napid;\",\n            \"ʼn\": \"&napos;\",\n            \"♮\": \"&natural;\",\n            \"⩃\": \"&ncap;\",\n            \"ň\": \"&ncaron;\",\n            \"ņ\": \"&ncedil;\",\n            \"⩭̸\": \"&ncongdot;\",\n            \"⩂\": \"&ncup;\",\n            \"н\": \"&ncy;\",\n            \"–\": \"&ndash;\",\n            \"⇗\": \"&neArr;\",\n            \"⤤\": \"&nearhk;\",\n            \"≐̸\": \"&nedot;\",\n            \"⤨\": \"&toea;\",\n            \"𝔫\": \"&nfr;\",\n            \"↮\": \"&nleftrightarrow;\",\n            \"⫲\": \"&nhpar;\",\n            \"⋼\": \"&nis;\",\n            \"⋺\": \"&nisd;\",\n            \"њ\": \"&njcy;\",\n            \"≦̸\": \"&nleqq;\",\n            \"↚\": \"&nleftarrow;\",\n            \"‥\": \"&nldr;\",\n            \"𝕟\": \"&nopf;\",\n            \"¬\": \"&not;\",\n            \"⋹̸\": \"&notinE;\",\n            \"⋵̸\": \"&notindot;\",\n            \"⋷\": \"&notinvb;\",\n            \"⋶\": \"&notinvc;\",\n            \"⋾\": \"&notnivb;\",\n            \"⋽\": \"&notnivc;\",\n            \"⫽⃥\": \"&nparsl;\",\n            \"∂̸\": \"&npart;\",\n            \"⨔\": \"&npolint;\",\n            \"↛\": \"&nrightarrow;\",\n            \"⤳̸\": \"&nrarrc;\",\n            \"↝̸\": \"&nrarrw;\",\n            \"𝓃\": \"&nscr;\",\n            \"⊄\": \"&nsub;\",\n            \"⫅̸\": \"&nsubseteqq;\",\n            \"⊅\": \"&nsup;\",\n            \"⫆̸\": \"&nsupseteqq;\",\n            \"ñ\": \"&ntilde;\",\n            \"ν\": \"&nu;\",\n            \"#\": \"&num;\",\n            \"№\": \"&numero;\",\n            \" \": \"&numsp;\",\n            \"⊭\": \"&nvDash;\",\n            \"⤄\": \"&nvHarr;\",\n            \"≍⃒\": \"&nvap;\",\n            \"⊬\": \"&nvdash;\",\n            \"≥⃒\": \"&nvge;\",\n            \">⃒\": \"&nvgt;\",\n            \"⧞\": \"&nvinfin;\",\n            \"⤂\": \"&nvlArr;\",\n            \"≤⃒\": \"&nvle;\",\n            \"<⃒\": \"&nvlt;\",\n            \"⊴⃒\": \"&nvltrie;\",\n            \"⤃\": \"&nvrArr;\",\n            \"⊵⃒\": \"&nvrtrie;\",\n            \"∼⃒\": \"&nvsim;\",\n            \"⇖\": \"&nwArr;\",\n            \"⤣\": \"&nwarhk;\",\n            \"⤧\": \"&nwnear;\",\n            \"ó\": \"&oacute;\",\n            \"ô\": \"&ocirc;\",\n            \"о\": \"&ocy;\",\n            \"ő\": \"&odblac;\",\n            \"⨸\": \"&odiv;\",\n            \"⦼\": \"&odsold;\",\n            \"œ\": \"&oelig;\",\n            \"⦿\": \"&ofcir;\",\n            \"𝔬\": \"&ofr;\",\n            \"˛\": \"&ogon;\",\n            \"ò\": \"&ograve;\",\n            \"⧁\": \"&ogt;\",\n            \"⦵\": \"&ohbar;\",\n            \"⦾\": \"&olcir;\",\n            \"⦻\": \"&olcross;\",\n            \"⧀\": \"&olt;\",\n            \"ō\": \"&omacr;\",\n            \"ω\": \"&omega;\",\n            \"ο\": \"&omicron;\",\n            \"⦶\": \"&omid;\",\n            \"𝕠\": \"&oopf;\",\n            \"⦷\": \"&opar;\",\n            \"⦹\": \"&operp;\",\n            \"∨\": \"&vee;\",\n            \"⩝\": \"&ord;\",\n            \"ℴ\": \"&oscr;\",\n            \"ª\": \"&ordf;\",\n            \"º\": \"&ordm;\",\n            \"⊶\": \"&origof;\",\n            \"⩖\": \"&oror;\",\n            \"⩗\": \"&orslope;\",\n            \"⩛\": \"&orv;\",\n            \"ø\": \"&oslash;\",\n            \"⊘\": \"&osol;\",\n            \"õ\": \"&otilde;\",\n            \"⨶\": \"&otimesas;\",\n            \"ö\": \"&ouml;\",\n            \"⌽\": \"&ovbar;\",\n            \"¶\": \"&para;\",\n            \"⫳\": \"&parsim;\",\n            \"⫽\": \"&parsl;\",\n            \"п\": \"&pcy;\",\n            \"%\": \"&percnt;\",\n            \".\": \"&period;\",\n            \"‰\": \"&permil;\",\n            \"‱\": \"&pertenk;\",\n            \"𝔭\": \"&pfr;\",\n            \"φ\": \"&phi;\",\n            \"ϕ\": \"&varphi;\",\n            \"☎\": \"&phone;\",\n            \"π\": \"&pi;\",\n            \"ϖ\": \"&varpi;\",\n            \"ℎ\": \"&planckh;\",\n            \"+\": \"&plus;\",\n            \"⨣\": \"&plusacir;\",\n            \"⨢\": \"&pluscir;\",\n            \"⨥\": \"&plusdu;\",\n            \"⩲\": \"&pluse;\",\n            \"⨦\": \"&plussim;\",\n            \"⨧\": \"&plustwo;\",\n            \"⨕\": \"&pointint;\",\n            \"𝕡\": \"&popf;\",\n            \"£\": \"&pound;\",\n            \"⪳\": \"&prE;\",\n            \"⪷\": \"&precapprox;\",\n            \"⪹\": \"&prnap;\",\n            \"⪵\": \"&prnE;\",\n            \"⋨\": \"&prnsim;\",\n            \"′\": \"&prime;\",\n            \"⌮\": \"&profalar;\",\n            \"⌒\": \"&profline;\",\n            \"⌓\": \"&profsurf;\",\n            \"⊰\": \"&prurel;\",\n            \"𝓅\": \"&pscr;\",\n            \"ψ\": \"&psi;\",\n            \" \": \"&puncsp;\",\n            \"𝔮\": \"&qfr;\",\n            \"𝕢\": \"&qopf;\",\n            \"⁗\": \"&qprime;\",\n            \"𝓆\": \"&qscr;\",\n            \"⨖\": \"&quatint;\",\n            \"?\": \"&quest;\",\n            \"⤜\": \"&rAtail;\",\n            \"⥤\": \"&rHar;\",\n            \"∽̱\": \"&race;\",\n            \"ŕ\": \"&racute;\",\n            \"⦳\": \"&raemptyv;\",\n            \"⦒\": \"&rangd;\",\n            \"⦥\": \"&range;\",\n            \"»\": \"&raquo;\",\n            \"⥵\": \"&rarrap;\",\n            \"⤠\": \"&rarrbfs;\",\n            \"⤳\": \"&rarrc;\",\n            \"⤞\": \"&rarrfs;\",\n            \"⥅\": \"&rarrpl;\",\n            \"⥴\": \"&rarrsim;\",\n            \"↣\": \"&rightarrowtail;\",\n            \"↝\": \"&rightsquigarrow;\",\n            \"⤚\": \"&ratail;\",\n            \"∶\": \"&ratio;\",\n            \"❳\": \"&rbbrk;\",\n            \"}\": \"&rcub;\",\n            \"]\": \"&rsqb;\",\n            \"⦌\": \"&rbrke;\",\n            \"⦎\": \"&rbrksld;\",\n            \"⦐\": \"&rbrkslu;\",\n            \"ř\": \"&rcaron;\",\n            \"ŗ\": \"&rcedil;\",\n            \"р\": \"&rcy;\",\n            \"⤷\": \"&rdca;\",\n            \"⥩\": \"&rdldhar;\",\n            \"↳\": \"&rdsh;\",\n            \"▭\": \"&rect;\",\n            \"⥽\": \"&rfisht;\",\n            \"𝔯\": \"&rfr;\",\n            \"⥬\": \"&rharul;\",\n            \"ρ\": \"&rho;\",\n            \"ϱ\": \"&varrho;\",\n            \"⇉\": \"&rrarr;\",\n            \"⋌\": \"&rthree;\",\n            \"˚\": \"&ring;\",\n            \"‏\": \"&rlm;\",\n            \"⎱\": \"&rmoustache;\",\n            \"⫮\": \"&rnmid;\",\n            \"⟭\": \"&roang;\",\n            \"⇾\": \"&roarr;\",\n            \"⦆\": \"&ropar;\",\n            \"𝕣\": \"&ropf;\",\n            \"⨮\": \"&roplus;\",\n            \"⨵\": \"&rotimes;\",\n            \")\": \"&rpar;\",\n            \"⦔\": \"&rpargt;\",\n            \"⨒\": \"&rppolint;\",\n            \"›\": \"&rsaquo;\",\n            \"𝓇\": \"&rscr;\",\n            \"⋊\": \"&rtimes;\",\n            \"▹\": \"&triangleright;\",\n            \"⧎\": \"&rtriltri;\",\n            \"⥨\": \"&ruluhar;\",\n            \"℞\": \"&rx;\",\n            \"ś\": \"&sacute;\",\n            \"⪴\": \"&scE;\",\n            \"⪸\": \"&succapprox;\",\n            \"š\": \"&scaron;\",\n            \"ş\": \"&scedil;\",\n            \"ŝ\": \"&scirc;\",\n            \"⪶\": \"&succneqq;\",\n            \"⪺\": \"&succnapprox;\",\n            \"⋩\": \"&succnsim;\",\n            \"⨓\": \"&scpolint;\",\n            \"с\": \"&scy;\",\n            \"⋅\": \"&sdot;\",\n            \"⩦\": \"&sdote;\",\n            \"⇘\": \"&seArr;\",\n            \"§\": \"&sect;\",\n            \";\": \"&semi;\",\n            \"⤩\": \"&tosa;\",\n            \"✶\": \"&sext;\",\n            \"𝔰\": \"&sfr;\",\n            \"♯\": \"&sharp;\",\n            \"щ\": \"&shchcy;\",\n            \"ш\": \"&shcy;\",\n            \"­\": \"&shy;\",\n            \"σ\": \"&sigma;\",\n            \"ς\": \"&varsigma;\",\n            \"⩪\": \"&simdot;\",\n            \"⪞\": \"&simg;\",\n            \"⪠\": \"&simgE;\",\n            \"⪝\": \"&siml;\",\n            \"⪟\": \"&simlE;\",\n            \"≆\": \"&simne;\",\n            \"⨤\": \"&simplus;\",\n            \"⥲\": \"&simrarr;\",\n            \"⨳\": \"&smashp;\",\n            \"⧤\": \"&smeparsl;\",\n            \"⌣\": \"&ssmile;\",\n            \"⪪\": \"&smt;\",\n            \"⪬\": \"&smte;\",\n            \"⪬︀\": \"&smtes;\",\n            \"ь\": \"&softcy;\",\n            \"/\": \"&sol;\",\n            \"⧄\": \"&solb;\",\n            \"⌿\": \"&solbar;\",\n            \"𝕤\": \"&sopf;\",\n            \"♠\": \"&spadesuit;\",\n            \"⊓︀\": \"&sqcaps;\",\n            \"⊔︀\": \"&sqcups;\",\n            \"𝓈\": \"&sscr;\",\n            \"☆\": \"&star;\",\n            \"⊂\": \"&subset;\",\n            \"⫅\": \"&subseteqq;\",\n            \"⪽\": \"&subdot;\",\n            \"⫃\": \"&subedot;\",\n            \"⫁\": \"&submult;\",\n            \"⫋\": \"&subsetneqq;\",\n            \"⊊\": \"&subsetneq;\",\n            \"⪿\": \"&subplus;\",\n            \"⥹\": \"&subrarr;\",\n            \"⫇\": \"&subsim;\",\n            \"⫕\": \"&subsub;\",\n            \"⫓\": \"&subsup;\",\n            \"♪\": \"&sung;\",\n            \"¹\": \"&sup1;\",\n            \"²\": \"&sup2;\",\n            \"³\": \"&sup3;\",\n            \"⫆\": \"&supseteqq;\",\n            \"⪾\": \"&supdot;\",\n            \"⫘\": \"&supdsub;\",\n            \"⫄\": \"&supedot;\",\n            \"⟉\": \"&suphsol;\",\n            \"⫗\": \"&suphsub;\",\n            \"⥻\": \"&suplarr;\",\n            \"⫂\": \"&supmult;\",\n            \"⫌\": \"&supsetneqq;\",\n            \"⊋\": \"&supsetneq;\",\n            \"⫀\": \"&supplus;\",\n            \"⫈\": \"&supsim;\",\n            \"⫔\": \"&supsub;\",\n            \"⫖\": \"&supsup;\",\n            \"⇙\": \"&swArr;\",\n            \"⤪\": \"&swnwar;\",\n            \"ß\": \"&szlig;\",\n            \"⌖\": \"&target;\",\n            \"τ\": \"&tau;\",\n            \"ť\": \"&tcaron;\",\n            \"ţ\": \"&tcedil;\",\n            \"т\": \"&tcy;\",\n            \"⌕\": \"&telrec;\",\n            \"𝔱\": \"&tfr;\",\n            \"θ\": \"&theta;\",\n            \"ϑ\": \"&vartheta;\",\n            \"þ\": \"&thorn;\",\n            \"×\": \"&times;\",\n            \"⨱\": \"&timesbar;\",\n            \"⨰\": \"&timesd;\",\n            \"⌶\": \"&topbot;\",\n            \"⫱\": \"&topcir;\",\n            \"𝕥\": \"&topf;\",\n            \"⫚\": \"&topfork;\",\n            \"‴\": \"&tprime;\",\n            \"▵\": \"&utri;\",\n            \"≜\": \"&trie;\",\n            \"◬\": \"&tridot;\",\n            \"⨺\": \"&triminus;\",\n            \"⨹\": \"&triplus;\",\n            \"⧍\": \"&trisb;\",\n            \"⨻\": \"&tritime;\",\n            \"⏢\": \"&trpezium;\",\n            \"𝓉\": \"&tscr;\",\n            \"ц\": \"&tscy;\",\n            \"ћ\": \"&tshcy;\",\n            \"ŧ\": \"&tstrok;\",\n            \"⥣\": \"&uHar;\",\n            \"ú\": \"&uacute;\",\n            \"ў\": \"&ubrcy;\",\n            \"ŭ\": \"&ubreve;\",\n            \"û\": \"&ucirc;\",\n            \"у\": \"&ucy;\",\n            \"ű\": \"&udblac;\",\n            \"⥾\": \"&ufisht;\",\n            \"𝔲\": \"&ufr;\",\n            \"ù\": \"&ugrave;\",\n            \"▀\": \"&uhblk;\",\n            \"⌜\": \"&ulcorner;\",\n            \"⌏\": \"&ulcrop;\",\n            \"◸\": \"&ultri;\",\n            \"ū\": \"&umacr;\",\n            \"ų\": \"&uogon;\",\n            \"𝕦\": \"&uopf;\",\n            \"υ\": \"&upsilon;\",\n            \"⇈\": \"&uuarr;\",\n            \"⌝\": \"&urcorner;\",\n            \"⌎\": \"&urcrop;\",\n            \"ů\": \"&uring;\",\n            \"◹\": \"&urtri;\",\n            \"𝓊\": \"&uscr;\",\n            \"⋰\": \"&utdot;\",\n            \"ũ\": \"&utilde;\",\n            \"ü\": \"&uuml;\",\n            \"⦧\": \"&uwangle;\",\n            \"⫨\": \"&vBar;\",\n            \"⫩\": \"&vBarv;\",\n            \"⦜\": \"&vangrt;\",\n            \"⊊︀\": \"&vsubne;\",\n            \"⫋︀\": \"&vsubnE;\",\n            \"⊋︀\": \"&vsupne;\",\n            \"⫌︀\": \"&vsupnE;\",\n            \"в\": \"&vcy;\",\n            \"⊻\": \"&veebar;\",\n            \"≚\": \"&veeeq;\",\n            \"⋮\": \"&vellip;\",\n            \"𝔳\": \"&vfr;\",\n            \"𝕧\": \"&vopf;\",\n            \"𝓋\": \"&vscr;\",\n            \"⦚\": \"&vzigzag;\",\n            \"ŵ\": \"&wcirc;\",\n            \"⩟\": \"&wedbar;\",\n            \"≙\": \"&wedgeq;\",\n            \"℘\": \"&wp;\",\n            \"𝔴\": \"&wfr;\",\n            \"𝕨\": \"&wopf;\",\n            \"𝓌\": \"&wscr;\",\n            \"𝔵\": \"&xfr;\",\n            \"ξ\": \"&xi;\",\n            \"⋻\": \"&xnis;\",\n            \"𝕩\": \"&xopf;\",\n            \"𝓍\": \"&xscr;\",\n            \"ý\": \"&yacute;\",\n            \"я\": \"&yacy;\",\n            \"ŷ\": \"&ycirc;\",\n            \"ы\": \"&ycy;\",\n            \"¥\": \"&yen;\",\n            \"𝔶\": \"&yfr;\",\n            \"ї\": \"&yicy;\",\n            \"𝕪\": \"&yopf;\",\n            \"𝓎\": \"&yscr;\",\n            \"ю\": \"&yucy;\",\n            \"ÿ\": \"&yuml;\",\n            \"ź\": \"&zacute;\",\n            \"ž\": \"&zcaron;\",\n            \"з\": \"&zcy;\",\n            \"ż\": \"&zdot;\",\n            \"ζ\": \"&zeta;\",\n            \"𝔷\": \"&zfr;\",\n            \"ж\": \"&zhcy;\",\n            \"⇝\": \"&zigrarr;\",\n            \"𝕫\": \"&zopf;\",\n            \"𝓏\": \"&zscr;\",\n            \"‍\": \"&zwj;\",\n            \"‌\": \"&zwnj;\"\n        }\n    }\n};\n","export const numericUnicodeMap: Record<number, number> = {\n    0: 65533,\n    128: 8364,\n    130: 8218,\n    131: 402,\n    132: 8222,\n    133: 8230,\n    134: 8224,\n    135: 8225,\n    136: 710,\n    137: 8240,\n    138: 352,\n    139: 8249,\n    140: 338,\n    142: 381,\n    145: 8216,\n    146: 8217,\n    147: 8220,\n    148: 8221,\n    149: 8226,\n    150: 8211,\n    151: 8212,\n    152: 732,\n    153: 8482,\n    154: 353,\n    155: 8250,\n    156: 339,\n    158: 382,\n    159: 376\n};\n","export const fromCodePoint =\n    String.fromCodePoint ||\n    function (astralCodePoint: number) {\n        return String.fromCharCode(\n            Math.floor((astralCodePoint - 0x10000) / 0x400) + 0xd800,\n            ((astralCodePoint - 0x10000) % 0x400) + 0xdc00\n        );\n    };\n\nexport const getCodePoint = String.prototype.codePointAt\n    ? function (input: string, position: number) {\n          return input.codePointAt(position);\n      }\n    : function (input: string, position: number) {\n          return (input.charCodeAt(position) - 0xd800) * 0x400 + input.charCodeAt(position + 1) - 0xdc00 + 0x10000;\n      };\n\nexport const highSurrogateFrom = 0xd800;\nexport const highSurrogateTo = 0xdbff;\n",null,null,null,"\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.attributeNames = exports.elementNames = void 0;\nexports.elementNames = new Map([\n    \"altGlyph\",\n    \"altGlyphDef\",\n    \"altGlyphItem\",\n    \"animateColor\",\n    \"animateMotion\",\n    \"animateTransform\",\n    \"clipPath\",\n    \"feBlend\",\n    \"feColorMatrix\",\n    \"feComponentTransfer\",\n    \"feComposite\",\n    \"feConvolveMatrix\",\n    \"feDiffuseLighting\",\n    \"feDisplacementMap\",\n    \"feDistantLight\",\n    \"feDropShadow\",\n    \"feFlood\",\n    \"feFuncA\",\n    \"feFuncB\",\n    \"feFuncG\",\n    \"feFuncR\",\n    \"feGaussianBlur\",\n    \"feImage\",\n    \"feMerge\",\n    \"feMergeNode\",\n    \"feMorphology\",\n    \"feOffset\",\n    \"fePointLight\",\n    \"feSpecularLighting\",\n    \"feSpotLight\",\n    \"feTile\",\n    \"feTurbulence\",\n    \"foreignObject\",\n    \"glyphRef\",\n    \"linearGradient\",\n    \"radialGradient\",\n    \"textPath\",\n].map(function (val) { return [val.toLowerCase(), val]; }));\nexports.attributeNames = new Map([\n    \"definitionURL\",\n    \"attributeName\",\n    \"attributeType\",\n    \"baseFrequency\",\n    \"baseProfile\",\n    \"calcMode\",\n    \"clipPathUnits\",\n    \"diffuseConstant\",\n    \"edgeMode\",\n    \"filterUnits\",\n    \"glyphRef\",\n    \"gradientTransform\",\n    \"gradientUnits\",\n    \"kernelMatrix\",\n    \"kernelUnitLength\",\n    \"keyPoints\",\n    \"keySplines\",\n    \"keyTimes\",\n    \"lengthAdjust\",\n    \"limitingConeAngle\",\n    \"markerHeight\",\n    \"markerUnits\",\n    \"markerWidth\",\n    \"maskContentUnits\",\n    \"maskUnits\",\n    \"numOctaves\",\n    \"pathLength\",\n    \"patternContentUnits\",\n    \"patternTransform\",\n    \"patternUnits\",\n    \"pointsAtX\",\n    \"pointsAtY\",\n    \"pointsAtZ\",\n    \"preserveAlpha\",\n    \"preserveAspectRatio\",\n    \"primitiveUnits\",\n    \"refX\",\n    \"refY\",\n    \"repeatCount\",\n    \"repeatDur\",\n    \"requiredExtensions\",\n    \"requiredFeatures\",\n    \"specularConstant\",\n    \"specularExponent\",\n    \"spreadMethod\",\n    \"startOffset\",\n    \"stdDeviation\",\n    \"stitchTiles\",\n    \"surfaceScale\",\n    \"systemLanguage\",\n    \"tableValues\",\n    \"targetX\",\n    \"targetY\",\n    \"textLength\",\n    \"viewBox\",\n    \"viewTarget\",\n    \"xChannelSelector\",\n    \"yChannelSelector\",\n    \"zoomAndPan\",\n].map(function (val) { return [val.toLowerCase(), val]; }));\n","\"use strict\";\nvar __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n    o[\"default\"] = v;\n});\nvar __importStar = (this && this.__importStar) || function (mod) {\n    if (mod && mod.__esModule) return mod;\n    var result = {};\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n    __setModuleDefault(result, mod);\n    return result;\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.render = void 0;\n/*\n * Module dependencies\n */\nvar ElementType = __importStar(require(\"domelementtype\"));\nvar entities_1 = require(\"entities\");\n/**\n * Mixed-case SVG and MathML tags & attributes\n * recognized by the HTML parser.\n *\n * @see https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-inforeign\n */\nvar foreignNames_js_1 = require(\"./foreignNames.js\");\nvar unencodedElements = new Set([\n    \"style\",\n    \"script\",\n    \"xmp\",\n    \"iframe\",\n    \"noembed\",\n    \"noframes\",\n    \"plaintext\",\n    \"noscript\",\n]);\nfunction replaceQuotes(value) {\n    return value.replace(/\"/g, \"&quot;\");\n}\n/**\n * Format attributes\n */\nfunction formatAttributes(attributes, opts) {\n    var _a;\n    if (!attributes)\n        return;\n    var encode = ((_a = opts.encodeEntities) !== null && _a !== void 0 ? _a : opts.decodeEntities) === false\n        ? replaceQuotes\n        : opts.xmlMode || opts.encodeEntities !== \"utf8\"\n            ? entities_1.encodeXML\n            : entities_1.escapeAttribute;\n    return Object.keys(attributes)\n        .map(function (key) {\n        var _a, _b;\n        var value = (_a = attributes[key]) !== null && _a !== void 0 ? _a : \"\";\n        if (opts.xmlMode === \"foreign\") {\n            /* Fix up mixed-case attribute names */\n            key = (_b = foreignNames_js_1.attributeNames.get(key)) !== null && _b !== void 0 ? _b : key;\n        }\n        if (!opts.emptyAttrs && !opts.xmlMode && value === \"\") {\n            return key;\n        }\n        return \"\".concat(key, \"=\\\"\").concat(encode(value), \"\\\"\");\n    })\n        .join(\" \");\n}\n/**\n * Self-enclosing tags\n */\nvar singleTag = new Set([\n    \"area\",\n    \"base\",\n    \"basefont\",\n    \"br\",\n    \"col\",\n    \"command\",\n    \"embed\",\n    \"frame\",\n    \"hr\",\n    \"img\",\n    \"input\",\n    \"isindex\",\n    \"keygen\",\n    \"link\",\n    \"meta\",\n    \"param\",\n    \"source\",\n    \"track\",\n    \"wbr\",\n]);\n/**\n * Renders a DOM node or an array of DOM nodes to a string.\n *\n * Can be thought of as the equivalent of the `outerHTML` of the passed node(s).\n *\n * @param node Node to be rendered.\n * @param options Changes serialization behavior\n */\nfunction render(node, options) {\n    if (options === void 0) { options = {}; }\n    var nodes = \"length\" in node ? node : [node];\n    var output = \"\";\n    for (var i = 0; i < nodes.length; i++) {\n        output += renderNode(nodes[i], options);\n    }\n    return output;\n}\nexports.render = render;\nexports.default = render;\nfunction renderNode(node, options) {\n    switch (node.type) {\n        case ElementType.Root:\n            return render(node.children, options);\n        // @ts-expect-error We don't use `Doctype` yet\n        case ElementType.Doctype:\n        case ElementType.Directive:\n            return renderDirective(node);\n        case ElementType.Comment:\n            return renderComment(node);\n        case ElementType.CDATA:\n            return renderCdata(node);\n        case ElementType.Script:\n        case ElementType.Style:\n        case ElementType.Tag:\n            return renderTag(node, options);\n        case ElementType.Text:\n            return renderText(node, options);\n    }\n}\nvar foreignModeIntegrationPoints = new Set([\n    \"mi\",\n    \"mo\",\n    \"mn\",\n    \"ms\",\n    \"mtext\",\n    \"annotation-xml\",\n    \"foreignObject\",\n    \"desc\",\n    \"title\",\n]);\nvar foreignElements = new Set([\"svg\", \"math\"]);\nfunction renderTag(elem, opts) {\n    var _a;\n    // Handle SVG / MathML in HTML\n    if (opts.xmlMode === \"foreign\") {\n        /* Fix up mixed-case element names */\n        elem.name = (_a = foreignNames_js_1.elementNames.get(elem.name)) !== null && _a !== void 0 ? _a : elem.name;\n        /* Exit foreign mode at integration points */\n        if (elem.parent &&\n            foreignModeIntegrationPoints.has(elem.parent.name)) {\n            opts = __assign(__assign({}, opts), { xmlMode: false });\n        }\n    }\n    if (!opts.xmlMode && foreignElements.has(elem.name)) {\n        opts = __assign(__assign({}, opts), { xmlMode: \"foreign\" });\n    }\n    var tag = \"<\".concat(elem.name);\n    var attribs = formatAttributes(elem.attribs, opts);\n    if (attribs) {\n        tag += \" \".concat(attribs);\n    }\n    if (elem.children.length === 0 &&\n        (opts.xmlMode\n            ? // In XML mode or foreign mode, and user hasn't explicitly turned off self-closing tags\n                opts.selfClosingTags !== false\n            : // User explicitly asked for self-closing tags, even in HTML mode\n                opts.selfClosingTags && singleTag.has(elem.name))) {\n        if (!opts.xmlMode)\n            tag += \" \";\n        tag += \"/>\";\n    }\n    else {\n        tag += \">\";\n        if (elem.children.length > 0) {\n            tag += render(elem.children, opts);\n        }\n        if (opts.xmlMode || !singleTag.has(elem.name)) {\n            tag += \"</\".concat(elem.name, \">\");\n        }\n    }\n    return tag;\n}\nfunction renderDirective(elem) {\n    return \"<\".concat(elem.data, \">\");\n}\nfunction renderText(elem, opts) {\n    var _a;\n    var data = elem.data || \"\";\n    // If entities weren't decoded, no need to encode them back\n    if (((_a = opts.encodeEntities) !== null && _a !== void 0 ? _a : opts.decodeEntities) !== false &&\n        !(!opts.xmlMode &&\n            elem.parent &&\n            unencodedElements.has(elem.parent.name))) {\n        data =\n            opts.xmlMode || opts.encodeEntities !== \"utf8\"\n                ? (0, entities_1.encodeXML)(data)\n                : (0, entities_1.escapeText)(data);\n    }\n    return data;\n}\nfunction renderCdata(elem) {\n    return \"<![CDATA[\".concat(elem.children[0].data, \"]]>\");\n}\nfunction renderComment(elem) {\n    return \"<!--\".concat(elem.data, \"-->\");\n}\n","\"use strict\";\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __exportStar = (this && this.__exportStar) || function(m, exports) {\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.DomHandler = void 0;\nvar domelementtype_1 = require(\"domelementtype\");\nvar node_js_1 = require(\"./node.js\");\n__exportStar(require(\"./node.js\"), exports);\n// Default options\nvar defaultOpts = {\n    withStartIndices: false,\n    withEndIndices: false,\n    xmlMode: false,\n};\nvar DomHandler = /** @class */ (function () {\n    /**\n     * @param callback Called once parsing has completed.\n     * @param options Settings for the handler.\n     * @param elementCB Callback whenever a tag is closed.\n     */\n    function DomHandler(callback, options, elementCB) {\n        /** The elements of the DOM */\n        this.dom = [];\n        /** The root element for the DOM */\n        this.root = new node_js_1.Document(this.dom);\n        /** Indicated whether parsing has been completed. */\n        this.done = false;\n        /** Stack of open tags. */\n        this.tagStack = [this.root];\n        /** A data node that is still being written to. */\n        this.lastNode = null;\n        /** Reference to the parser instance. Used for location information. */\n        this.parser = null;\n        // Make it possible to skip arguments, for backwards-compatibility\n        if (typeof options === \"function\") {\n            elementCB = options;\n            options = defaultOpts;\n        }\n        if (typeof callback === \"object\") {\n            options = callback;\n            callback = undefined;\n        }\n        this.callback = callback !== null && callback !== void 0 ? callback : null;\n        this.options = options !== null && options !== void 0 ? options : defaultOpts;\n        this.elementCB = elementCB !== null && elementCB !== void 0 ? elementCB : null;\n    }\n    DomHandler.prototype.onparserinit = function (parser) {\n        this.parser = parser;\n    };\n    // Resets the handler back to starting state\n    DomHandler.prototype.onreset = function () {\n        this.dom = [];\n        this.root = new node_js_1.Document(this.dom);\n        this.done = false;\n        this.tagStack = [this.root];\n        this.lastNode = null;\n        this.parser = null;\n    };\n    // Signals the handler that parsing is done\n    DomHandler.prototype.onend = function () {\n        if (this.done)\n            return;\n        this.done = true;\n        this.parser = null;\n        this.handleCallback(null);\n    };\n    DomHandler.prototype.onerror = function (error) {\n        this.handleCallback(error);\n    };\n    DomHandler.prototype.onclosetag = function () {\n        this.lastNode = null;\n        var elem = this.tagStack.pop();\n        if (this.options.withEndIndices) {\n            elem.endIndex = this.parser.endIndex;\n        }\n        if (this.elementCB)\n            this.elementCB(elem);\n    };\n    DomHandler.prototype.onopentag = function (name, attribs) {\n        var type = this.options.xmlMode ? domelementtype_1.ElementType.Tag : undefined;\n        var element = new node_js_1.Element(name, attribs, undefined, type);\n        this.addNode(element);\n        this.tagStack.push(element);\n    };\n    DomHandler.prototype.ontext = function (data) {\n        var lastNode = this.lastNode;\n        if (lastNode && lastNode.type === domelementtype_1.ElementType.Text) {\n            lastNode.data += data;\n            if (this.options.withEndIndices) {\n                lastNode.endIndex = this.parser.endIndex;\n            }\n        }\n        else {\n            var node = new node_js_1.Text(data);\n            this.addNode(node);\n            this.lastNode = node;\n        }\n    };\n    DomHandler.prototype.oncomment = function (data) {\n        if (this.lastNode && this.lastNode.type === domelementtype_1.ElementType.Comment) {\n            this.lastNode.data += data;\n            return;\n        }\n        var node = new node_js_1.Comment(data);\n        this.addNode(node);\n        this.lastNode = node;\n    };\n    DomHandler.prototype.oncommentend = function () {\n        this.lastNode = null;\n    };\n    DomHandler.prototype.oncdatastart = function () {\n        var text = new node_js_1.Text(\"\");\n        var node = new node_js_1.CDATA([text]);\n        this.addNode(node);\n        text.parent = node;\n        this.lastNode = text;\n    };\n    DomHandler.prototype.oncdataend = function () {\n        this.lastNode = null;\n    };\n    DomHandler.prototype.onprocessinginstruction = function (name, data) {\n        var node = new node_js_1.ProcessingInstruction(name, data);\n        this.addNode(node);\n    };\n    DomHandler.prototype.handleCallback = function (error) {\n        if (typeof this.callback === \"function\") {\n            this.callback(error, this.dom);\n        }\n        else if (error) {\n            throw error;\n        }\n    };\n    DomHandler.prototype.addNode = function (node) {\n        var parent = this.tagStack[this.tagStack.length - 1];\n        var previousSibling = parent.children[parent.children.length - 1];\n        if (this.options.withStartIndices) {\n            node.startIndex = this.parser.startIndex;\n        }\n        if (this.options.withEndIndices) {\n            node.endIndex = this.parser.endIndex;\n        }\n        parent.children.push(node);\n        if (previousSibling) {\n            node.prev = previousSibling;\n            previousSibling.next = node;\n        }\n        node.parent = parent;\n        this.lastNode = null;\n    };\n    return DomHandler;\n}());\nexports.DomHandler = DomHandler;\nexports.default = DomHandler;\n","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n    var extendStatics = function (d, b) {\n        extendStatics = Object.setPrototypeOf ||\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        if (typeof b !== \"function\" && b !== null)\n            throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nvar __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.cloneNode = exports.hasChildren = exports.isDocument = exports.isDirective = exports.isComment = exports.isText = exports.isCDATA = exports.isTag = exports.Element = exports.Document = exports.CDATA = exports.NodeWithChildren = exports.ProcessingInstruction = exports.Comment = exports.Text = exports.DataNode = exports.Node = void 0;\nvar domelementtype_1 = require(\"domelementtype\");\n/**\n * This object will be used as the prototype for Nodes when creating a\n * DOM-Level-1-compliant structure.\n */\nvar Node = /** @class */ (function () {\n    function Node() {\n        /** Parent of the node */\n        this.parent = null;\n        /** Previous sibling */\n        this.prev = null;\n        /** Next sibling */\n        this.next = null;\n        /** The start index of the node. Requires `withStartIndices` on the handler to be `true. */\n        this.startIndex = null;\n        /** The end index of the node. Requires `withEndIndices` on the handler to be `true. */\n        this.endIndex = null;\n    }\n    Object.defineProperty(Node.prototype, \"parentNode\", {\n        // Read-write aliases for properties\n        /**\n         * Same as {@link parent}.\n         * [DOM spec](https://dom.spec.whatwg.org)-compatible alias.\n         */\n        get: function () {\n            return this.parent;\n        },\n        set: function (parent) {\n            this.parent = parent;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Object.defineProperty(Node.prototype, \"previousSibling\", {\n        /**\n         * Same as {@link prev}.\n         * [DOM spec](https://dom.spec.whatwg.org)-compatible alias.\n         */\n        get: function () {\n            return this.prev;\n        },\n        set: function (prev) {\n            this.prev = prev;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Object.defineProperty(Node.prototype, \"nextSibling\", {\n        /**\n         * Same as {@link next}.\n         * [DOM spec](https://dom.spec.whatwg.org)-compatible alias.\n         */\n        get: function () {\n            return this.next;\n        },\n        set: function (next) {\n            this.next = next;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    /**\n     * Clone this node, and optionally its children.\n     *\n     * @param recursive Clone child nodes as well.\n     * @returns A clone of the node.\n     */\n    Node.prototype.cloneNode = function (recursive) {\n        if (recursive === void 0) { recursive = false; }\n        return cloneNode(this, recursive);\n    };\n    return Node;\n}());\nexports.Node = Node;\n/**\n * A node that contains some data.\n */\nvar DataNode = /** @class */ (function (_super) {\n    __extends(DataNode, _super);\n    /**\n     * @param data The content of the data node\n     */\n    function DataNode(data) {\n        var _this = _super.call(this) || this;\n        _this.data = data;\n        return _this;\n    }\n    Object.defineProperty(DataNode.prototype, \"nodeValue\", {\n        /**\n         * Same as {@link data}.\n         * [DOM spec](https://dom.spec.whatwg.org)-compatible alias.\n         */\n        get: function () {\n            return this.data;\n        },\n        set: function (data) {\n            this.data = data;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    return DataNode;\n}(Node));\nexports.DataNode = DataNode;\n/**\n * Text within the document.\n */\nvar Text = /** @class */ (function (_super) {\n    __extends(Text, _super);\n    function Text() {\n        var _this = _super !== null && _super.apply(this, arguments) || this;\n        _this.type = domelementtype_1.ElementType.Text;\n        return _this;\n    }\n    Object.defineProperty(Text.prototype, \"nodeType\", {\n        get: function () {\n            return 3;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    return Text;\n}(DataNode));\nexports.Text = Text;\n/**\n * Comments within the document.\n */\nvar Comment = /** @class */ (function (_super) {\n    __extends(Comment, _super);\n    function Comment() {\n        var _this = _super !== null && _super.apply(this, arguments) || this;\n        _this.type = domelementtype_1.ElementType.Comment;\n        return _this;\n    }\n    Object.defineProperty(Comment.prototype, \"nodeType\", {\n        get: function () {\n            return 8;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    return Comment;\n}(DataNode));\nexports.Comment = Comment;\n/**\n * Processing instructions, including doc types.\n */\nvar ProcessingInstruction = /** @class */ (function (_super) {\n    __extends(ProcessingInstruction, _super);\n    function ProcessingInstruction(name, data) {\n        var _this = _super.call(this, data) || this;\n        _this.name = name;\n        _this.type = domelementtype_1.ElementType.Directive;\n        return _this;\n    }\n    Object.defineProperty(ProcessingInstruction.prototype, \"nodeType\", {\n        get: function () {\n            return 1;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    return ProcessingInstruction;\n}(DataNode));\nexports.ProcessingInstruction = ProcessingInstruction;\n/**\n * A `Node` that can have children.\n */\nvar NodeWithChildren = /** @class */ (function (_super) {\n    __extends(NodeWithChildren, _super);\n    /**\n     * @param children Children of the node. Only certain node types can have children.\n     */\n    function NodeWithChildren(children) {\n        var _this = _super.call(this) || this;\n        _this.children = children;\n        return _this;\n    }\n    Object.defineProperty(NodeWithChildren.prototype, \"firstChild\", {\n        // Aliases\n        /** First child of the node. */\n        get: function () {\n            var _a;\n            return (_a = this.children[0]) !== null && _a !== void 0 ? _a : null;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Object.defineProperty(NodeWithChildren.prototype, \"lastChild\", {\n        /** Last child of the node. */\n        get: function () {\n            return this.children.length > 0\n                ? this.children[this.children.length - 1]\n                : null;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Object.defineProperty(NodeWithChildren.prototype, \"childNodes\", {\n        /**\n         * Same as {@link children}.\n         * [DOM spec](https://dom.spec.whatwg.org)-compatible alias.\n         */\n        get: function () {\n            return this.children;\n        },\n        set: function (children) {\n            this.children = children;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    return NodeWithChildren;\n}(Node));\nexports.NodeWithChildren = NodeWithChildren;\nvar CDATA = /** @class */ (function (_super) {\n    __extends(CDATA, _super);\n    function CDATA() {\n        var _this = _super !== null && _super.apply(this, arguments) || this;\n        _this.type = domelementtype_1.ElementType.CDATA;\n        return _this;\n    }\n    Object.defineProperty(CDATA.prototype, \"nodeType\", {\n        get: function () {\n            return 4;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    return CDATA;\n}(NodeWithChildren));\nexports.CDATA = CDATA;\n/**\n * The root node of the document.\n */\nvar Document = /** @class */ (function (_super) {\n    __extends(Document, _super);\n    function Document() {\n        var _this = _super !== null && _super.apply(this, arguments) || this;\n        _this.type = domelementtype_1.ElementType.Root;\n        return _this;\n    }\n    Object.defineProperty(Document.prototype, \"nodeType\", {\n        get: function () {\n            return 9;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    return Document;\n}(NodeWithChildren));\nexports.Document = Document;\n/**\n * An element within the DOM.\n */\nvar Element = /** @class */ (function (_super) {\n    __extends(Element, _super);\n    /**\n     * @param name Name of the tag, eg. `div`, `span`.\n     * @param attribs Object mapping attribute names to attribute values.\n     * @param children Children of the node.\n     */\n    function Element(name, attribs, children, type) {\n        if (children === void 0) { children = []; }\n        if (type === void 0) { type = name === \"script\"\n            ? domelementtype_1.ElementType.Script\n            : name === \"style\"\n                ? domelementtype_1.ElementType.Style\n                : domelementtype_1.ElementType.Tag; }\n        var _this = _super.call(this, children) || this;\n        _this.name = name;\n        _this.attribs = attribs;\n        _this.type = type;\n        return _this;\n    }\n    Object.defineProperty(Element.prototype, \"nodeType\", {\n        get: function () {\n            return 1;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Object.defineProperty(Element.prototype, \"tagName\", {\n        // DOM Level 1 aliases\n        /**\n         * Same as {@link name}.\n         * [DOM spec](https://dom.spec.whatwg.org)-compatible alias.\n         */\n        get: function () {\n            return this.name;\n        },\n        set: function (name) {\n            this.name = name;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Object.defineProperty(Element.prototype, \"attributes\", {\n        get: function () {\n            var _this = this;\n            return Object.keys(this.attribs).map(function (name) {\n                var _a, _b;\n                return ({\n                    name: name,\n                    value: _this.attribs[name],\n                    namespace: (_a = _this[\"x-attribsNamespace\"]) === null || _a === void 0 ? void 0 : _a[name],\n                    prefix: (_b = _this[\"x-attribsPrefix\"]) === null || _b === void 0 ? void 0 : _b[name],\n                });\n            });\n        },\n        enumerable: false,\n        configurable: true\n    });\n    return Element;\n}(NodeWithChildren));\nexports.Element = Element;\n/**\n * @param node Node to check.\n * @returns `true` if the node is a `Element`, `false` otherwise.\n */\nfunction isTag(node) {\n    return (0, domelementtype_1.isTag)(node);\n}\nexports.isTag = isTag;\n/**\n * @param node Node to check.\n * @returns `true` if the node has the type `CDATA`, `false` otherwise.\n */\nfunction isCDATA(node) {\n    return node.type === domelementtype_1.ElementType.CDATA;\n}\nexports.isCDATA = isCDATA;\n/**\n * @param node Node to check.\n * @returns `true` if the node has the type `Text`, `false` otherwise.\n */\nfunction isText(node) {\n    return node.type === domelementtype_1.ElementType.Text;\n}\nexports.isText = isText;\n/**\n * @param node Node to check.\n * @returns `true` if the node has the type `Comment`, `false` otherwise.\n */\nfunction isComment(node) {\n    return node.type === domelementtype_1.ElementType.Comment;\n}\nexports.isComment = isComment;\n/**\n * @param node Node to check.\n * @returns `true` if the node has the type `ProcessingInstruction`, `false` otherwise.\n */\nfunction isDirective(node) {\n    return node.type === domelementtype_1.ElementType.Directive;\n}\nexports.isDirective = isDirective;\n/**\n * @param node Node to check.\n * @returns `true` if the node has the type `ProcessingInstruction`, `false` otherwise.\n */\nfunction isDocument(node) {\n    return node.type === domelementtype_1.ElementType.Root;\n}\nexports.isDocument = isDocument;\n/**\n * @param node Node to check.\n * @returns `true` if the node has children, `false` otherwise.\n */\nfunction hasChildren(node) {\n    return Object.prototype.hasOwnProperty.call(node, \"children\");\n}\nexports.hasChildren = hasChildren;\n/**\n * Clone a node, and optionally its children.\n *\n * @param recursive Clone child nodes as well.\n * @returns A clone of the node.\n */\nfunction cloneNode(node, recursive) {\n    if (recursive === void 0) { recursive = false; }\n    var result;\n    if (isText(node)) {\n        result = new Text(node.data);\n    }\n    else if (isComment(node)) {\n        result = new Comment(node.data);\n    }\n    else if (isTag(node)) {\n        var children = recursive ? cloneChildren(node.children) : [];\n        var clone_1 = new Element(node.name, __assign({}, node.attribs), children);\n        children.forEach(function (child) { return (child.parent = clone_1); });\n        if (node.namespace != null) {\n            clone_1.namespace = node.namespace;\n        }\n        if (node[\"x-attribsNamespace\"]) {\n            clone_1[\"x-attribsNamespace\"] = __assign({}, node[\"x-attribsNamespace\"]);\n        }\n        if (node[\"x-attribsPrefix\"]) {\n            clone_1[\"x-attribsPrefix\"] = __assign({}, node[\"x-attribsPrefix\"]);\n        }\n        result = clone_1;\n    }\n    else if (isCDATA(node)) {\n        var children = recursive ? cloneChildren(node.children) : [];\n        var clone_2 = new CDATA(children);\n        children.forEach(function (child) { return (child.parent = clone_2); });\n        result = clone_2;\n    }\n    else if (isDocument(node)) {\n        var children = recursive ? cloneChildren(node.children) : [];\n        var clone_3 = new Document(children);\n        children.forEach(function (child) { return (child.parent = clone_3); });\n        if (node[\"x-mode\"]) {\n            clone_3[\"x-mode\"] = node[\"x-mode\"];\n        }\n        result = clone_3;\n    }\n    else if (isDirective(node)) {\n        var instruction = new ProcessingInstruction(node.name, node.data);\n        if (node[\"x-name\"] != null) {\n            instruction[\"x-name\"] = node[\"x-name\"];\n            instruction[\"x-publicId\"] = node[\"x-publicId\"];\n            instruction[\"x-systemId\"] = node[\"x-systemId\"];\n        }\n        result = instruction;\n    }\n    else {\n        throw new Error(\"Not implemented yet: \".concat(node.type));\n    }\n    result.startIndex = node.startIndex;\n    result.endIndex = node.endIndex;\n    if (node.sourceCodeLocation != null) {\n        result.sourceCodeLocation = node.sourceCodeLocation;\n    }\n    return result;\n}\nexports.cloneNode = cloneNode;\nfunction cloneChildren(childs) {\n    var children = childs.map(function (child) { return cloneNode(child, true); });\n    for (var i = 1; i < children.length; i++) {\n        children[i].prev = children[i - 1];\n        children[i - 1].next = children[i];\n    }\n    return children;\n}\n",null,null,null,null,null,null,null,null,"\nvar indexOf = [].indexOf;\n\nmodule.exports = function(arr, obj){\n  if (indexOf) return arr.indexOf(obj);\n  for (var i = 0; i < arr.length; ++i) {\n    if (arr[i] === obj) return i;\n  }\n  return -1;\n};","if (typeof Object.create === 'function') {\n  // implementation from standard node.js 'util' module\n  module.exports = function inherits(ctor, superCtor) {\n    if (superCtor) {\n      ctor.super_ = superCtor\n      ctor.prototype = Object.create(superCtor.prototype, {\n        constructor: {\n          value: ctor,\n          enumerable: false,\n          writable: true,\n          configurable: true\n        }\n      })\n    }\n  };\n} else {\n  // old school shim for old browsers\n  module.exports = function inherits(ctor, superCtor) {\n    if (superCtor) {\n      ctor.super_ = superCtor\n      var TempCtor = function () {}\n      TempCtor.prototype = superCtor.prototype\n      ctor.prototype = new TempCtor()\n      ctor.prototype.constructor = ctor\n    }\n  }\n}\n","'use strict';\n\nconst word = '[a-fA-F\\\\d:]';\nconst b = options => options && options.includeBoundaries ?\n\t`(?:(?<=\\\\s|^)(?=${word})|(?<=${word})(?=\\\\s|$))` :\n\t'';\n\nconst v4 = '(?:25[0-5]|2[0-4]\\\\d|1\\\\d\\\\d|[1-9]\\\\d|\\\\d)(?:\\\\.(?:25[0-5]|2[0-4]\\\\d|1\\\\d\\\\d|[1-9]\\\\d|\\\\d)){3}';\n\nconst v6seg = '[a-fA-F\\\\d]{1,4}';\nconst v6 = `\n(?:\n(?:${v6seg}:){7}(?:${v6seg}|:)|                                    // 1:2:3:4:5:6:7::  1:2:3:4:5:6:7:8\n(?:${v6seg}:){6}(?:${v4}|:${v6seg}|:)|                             // 1:2:3:4:5:6::    1:2:3:4:5:6::8   1:2:3:4:5:6::8  1:2:3:4:5:6::1.2.3.4\n(?:${v6seg}:){5}(?::${v4}|(?::${v6seg}){1,2}|:)|                   // 1:2:3:4:5::      1:2:3:4:5::7:8   1:2:3:4:5::8    1:2:3:4:5::7:1.2.3.4\n(?:${v6seg}:){4}(?:(?::${v6seg}){0,1}:${v4}|(?::${v6seg}){1,3}|:)| // 1:2:3:4::        1:2:3:4::6:7:8   1:2:3:4::8      1:2:3:4::6:7:1.2.3.4\n(?:${v6seg}:){3}(?:(?::${v6seg}){0,2}:${v4}|(?::${v6seg}){1,4}|:)| // 1:2:3::          1:2:3::5:6:7:8   1:2:3::8        1:2:3::5:6:7:1.2.3.4\n(?:${v6seg}:){2}(?:(?::${v6seg}){0,3}:${v4}|(?::${v6seg}){1,5}|:)| // 1:2::            1:2::4:5:6:7:8   1:2::8          1:2::4:5:6:7:1.2.3.4\n(?:${v6seg}:){1}(?:(?::${v6seg}){0,4}:${v4}|(?::${v6seg}){1,6}|:)| // 1::              1::3:4:5:6:7:8   1::8            1::3:4:5:6:7:1.2.3.4\n(?::(?:(?::${v6seg}){0,5}:${v4}|(?::${v6seg}){1,7}|:))             // ::2:3:4:5:6:7:8  ::2:3:4:5:6:7:8  ::8             ::1.2.3.4\n)(?:%[0-9a-zA-Z]{1,})?                                             // %eth0            %1\n`.replace(/\\s*\\/\\/.*$/gm, '').replace(/\\n/g, '').trim();\n\n// Pre-compile only the exact regexes because adding a global flag make regexes stateful\nconst v46Exact = new RegExp(`(?:^${v4}$)|(?:^${v6}$)`);\nconst v4exact = new RegExp(`^${v4}$`);\nconst v6exact = new RegExp(`^${v6}$`);\n\nconst ip = options => options && options.exact ?\n\tv46Exact :\n\tnew RegExp(`(?:${b(options)}${v4}${b(options)})|(?:${b(options)}${v6}${b(options)})`, 'g');\n\nip.v4 = options => options && options.exact ? v4exact : new RegExp(`${b(options)}${v4}${b(options)}`, 'g');\nip.v6 = options => options && options.exact ? v6exact : new RegExp(`${b(options)}${v6}${b(options)}`, 'g');\n\nmodule.exports = ip;\n","'use strict';\n\nvar hasToStringTag = require('has-tostringtag/shams')();\nvar callBound = require('call-bind/callBound');\n\nvar $toString = callBound('Object.prototype.toString');\n\nvar isStandardArguments = function isArguments(value) {\n\tif (hasToStringTag && value && typeof value === 'object' && Symbol.toStringTag in value) {\n\t\treturn false;\n\t}\n\treturn $toString(value) === '[object Arguments]';\n};\n\nvar isLegacyArguments = function isArguments(value) {\n\tif (isStandardArguments(value)) {\n\t\treturn true;\n\t}\n\treturn value !== null &&\n\t\ttypeof value === 'object' &&\n\t\ttypeof value.length === 'number' &&\n\t\tvalue.length >= 0 &&\n\t\t$toString(value) !== '[object Array]' &&\n\t\t$toString(value.callee) === '[object Function]';\n};\n\nvar supportsStandardArguments = (function () {\n\treturn isStandardArguments(arguments);\n}());\n\nisStandardArguments.isLegacyArguments = isLegacyArguments; // for tests\n\nmodule.exports = supportsStandardArguments ? isStandardArguments : isLegacyArguments;\n","'use strict';\n\nvar fnToStr = Function.prototype.toString;\nvar reflectApply = typeof Reflect === 'object' && Reflect !== null && Reflect.apply;\nvar badArrayLike;\nvar isCallableMarker;\nif (typeof reflectApply === 'function' && typeof Object.defineProperty === 'function') {\n\ttry {\n\t\tbadArrayLike = Object.defineProperty({}, 'length', {\n\t\t\tget: function () {\n\t\t\t\tthrow isCallableMarker;\n\t\t\t}\n\t\t});\n\t\tisCallableMarker = {};\n\t\t// eslint-disable-next-line no-throw-literal\n\t\treflectApply(function () { throw 42; }, null, badArrayLike);\n\t} catch (_) {\n\t\tif (_ !== isCallableMarker) {\n\t\t\treflectApply = null;\n\t\t}\n\t}\n} else {\n\treflectApply = null;\n}\n\nvar constructorRegex = /^\\s*class\\b/;\nvar isES6ClassFn = function isES6ClassFunction(value) {\n\ttry {\n\t\tvar fnStr = fnToStr.call(value);\n\t\treturn constructorRegex.test(fnStr);\n\t} catch (e) {\n\t\treturn false; // not a function\n\t}\n};\n\nvar tryFunctionObject = function tryFunctionToStr(value) {\n\ttry {\n\t\tif (isES6ClassFn(value)) { return false; }\n\t\tfnToStr.call(value);\n\t\treturn true;\n\t} catch (e) {\n\t\treturn false;\n\t}\n};\nvar toStr = Object.prototype.toString;\nvar objectClass = '[object Object]';\nvar fnClass = '[object Function]';\nvar genClass = '[object GeneratorFunction]';\nvar ddaClass = '[object HTMLAllCollection]'; // IE 11\nvar ddaClass2 = '[object HTML document.all class]';\nvar ddaClass3 = '[object HTMLCollection]'; // IE 9-10\nvar hasToStringTag = typeof Symbol === 'function' && !!Symbol.toStringTag; // better: use `has-tostringtag`\n\nvar isIE68 = !(0 in [,]); // eslint-disable-line no-sparse-arrays, comma-spacing\n\nvar isDDA = function isDocumentDotAll() { return false; };\nif (typeof document === 'object') {\n\t// Firefox 3 canonicalizes DDA to undefined when it's not accessed directly\n\tvar all = document.all;\n\tif (toStr.call(all) === toStr.call(document.all)) {\n\t\tisDDA = function isDocumentDotAll(value) {\n\t\t\t/* globals document: false */\n\t\t\t// in IE 6-8, typeof document.all is \"object\" and it's truthy\n\t\t\tif ((isIE68 || !value) && (typeof value === 'undefined' || typeof value === 'object')) {\n\t\t\t\ttry {\n\t\t\t\t\tvar str = toStr.call(value);\n\t\t\t\t\treturn (\n\t\t\t\t\t\tstr === ddaClass\n\t\t\t\t\t\t|| str === ddaClass2\n\t\t\t\t\t\t|| str === ddaClass3 // opera 12.16\n\t\t\t\t\t\t|| str === objectClass // IE 6-8\n\t\t\t\t\t) && value('') == null; // eslint-disable-line eqeqeq\n\t\t\t\t} catch (e) { /**/ }\n\t\t\t}\n\t\t\treturn false;\n\t\t};\n\t}\n}\n\nmodule.exports = reflectApply\n\t? function isCallable(value) {\n\t\tif (isDDA(value)) { return true; }\n\t\tif (!value) { return false; }\n\t\tif (typeof value !== 'function' && typeof value !== 'object') { return false; }\n\t\ttry {\n\t\t\treflectApply(value, null, badArrayLike);\n\t\t} catch (e) {\n\t\t\tif (e !== isCallableMarker) { return false; }\n\t\t}\n\t\treturn !isES6ClassFn(value) && tryFunctionObject(value);\n\t}\n\t: function isCallable(value) {\n\t\tif (isDDA(value)) { return true; }\n\t\tif (!value) { return false; }\n\t\tif (typeof value !== 'function' && typeof value !== 'object') { return false; }\n\t\tif (hasToStringTag) { return tryFunctionObject(value); }\n\t\tif (isES6ClassFn(value)) { return false; }\n\t\tvar strClass = toStr.call(value);\n\t\tif (strClass !== fnClass && strClass !== genClass && !(/^\\[object HTML/).test(strClass)) { return false; }\n\t\treturn tryFunctionObject(value);\n\t};\n","'use strict';\n\nvar toStr = Object.prototype.toString;\nvar fnToStr = Function.prototype.toString;\nvar isFnRegex = /^\\s*(?:function)?\\*/;\nvar hasToStringTag = require('has-tostringtag/shams')();\nvar getProto = Object.getPrototypeOf;\nvar getGeneratorFunc = function () { // eslint-disable-line consistent-return\n\tif (!hasToStringTag) {\n\t\treturn false;\n\t}\n\ttry {\n\t\treturn Function('return function*() {}')();\n\t} catch (e) {\n\t}\n};\nvar GeneratorFunction;\n\nmodule.exports = function isGeneratorFunction(fn) {\n\tif (typeof fn !== 'function') {\n\t\treturn false;\n\t}\n\tif (isFnRegex.test(fnToStr.call(fn))) {\n\t\treturn true;\n\t}\n\tif (!hasToStringTag) {\n\t\tvar str = toStr.call(fn);\n\t\treturn str === '[object GeneratorFunction]';\n\t}\n\tif (!getProto) {\n\t\treturn false;\n\t}\n\tif (typeof GeneratorFunction === 'undefined') {\n\t\tvar generatorFunc = getGeneratorFunc();\n\t\tGeneratorFunction = generatorFunc ? getProto(generatorFunc) : false;\n\t}\n\treturn getProto(fn) === GeneratorFunction;\n};\n","'use strict';\nconst ipRegex = require('ip-regex');\n\nconst isIp = string => ipRegex({exact: true}).test(string);\nisIp.v4 = string => ipRegex.v4({exact: true}).test(string);\nisIp.v6 = string => ipRegex.v6({exact: true}).test(string);\nisIp.version = string => isIp(string) ? (isIp.v4(string) ? 4 : 6) : undefined;\n\nmodule.exports = isIp;\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\n/*!\n * is-plain-object <https://github.com/jonschlinkert/is-plain-object>\n *\n * Copyright (c) 2014-2017, Jon Schlinkert.\n * Released under the MIT License.\n */\n\nfunction isObject(o) {\n  return Object.prototype.toString.call(o) === '[object Object]';\n}\n\nfunction isPlainObject(o) {\n  var ctor,prot;\n\n  if (isObject(o) === false) return false;\n\n  // If has modified constructor\n  ctor = o.constructor;\n  if (ctor === undefined) return true;\n\n  // If has modified prototype\n  prot = ctor.prototype;\n  if (isObject(prot) === false) return false;\n\n  // If constructor does not have an Object-specific method\n  if (prot.hasOwnProperty('isPrototypeOf') === false) {\n    return false;\n  }\n\n  // Most likely a plain Object\n  return true;\n}\n\nexports.isPlainObject = isPlainObject;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.jwtDecode = exports.InvalidTokenError = void 0;\nclass InvalidTokenError extends Error {\n}\nexports.InvalidTokenError = InvalidTokenError;\nInvalidTokenError.prototype.name = \"InvalidTokenError\";\nfunction b64DecodeUnicode(str) {\n    return decodeURIComponent(atob(str).replace(/(.)/g, (m, p) => {\n        let code = p.charCodeAt(0).toString(16).toUpperCase();\n        if (code.length < 2) {\n            code = \"0\" + code;\n        }\n        return \"%\" + code;\n    }));\n}\nfunction base64UrlDecode(str) {\n    let output = str.replace(/-/g, \"+\").replace(/_/g, \"/\");\n    switch (output.length % 4) {\n        case 0:\n            break;\n        case 2:\n            output += \"==\";\n            break;\n        case 3:\n            output += \"=\";\n            break;\n        default:\n            throw new Error(\"base64 string is not of the correct length\");\n    }\n    try {\n        return b64DecodeUnicode(output);\n    }\n    catch (err) {\n        return atob(output);\n    }\n}\nfunction jwtDecode(token, options) {\n    if (typeof token !== \"string\") {\n        throw new InvalidTokenError(\"Invalid token specified: must be a string\");\n    }\n    options || (options = {});\n    const pos = options.header === true ? 0 : 1;\n    const part = token.split(\".\")[pos];\n    if (typeof part !== \"string\") {\n        throw new InvalidTokenError(`Invalid token specified: missing part #${pos + 1}`);\n    }\n    let decoded;\n    try {\n        decoded = base64UrlDecode(part);\n    }\n    catch (e) {\n        throw new InvalidTokenError(`Invalid token specified: invalid base64 for part #${pos + 1} (${e.message})`);\n    }\n    try {\n        return JSON.parse(decoded);\n    }\n    catch (e) {\n        throw new InvalidTokenError(`Invalid token specified: invalid json for part #${pos + 1} (${e.message})`);\n    }\n}\nexports.jwtDecode = jwtDecode;\n","/**\n * Lexing or parsing positional information for error reporting.\n * This object is immutable.\n */\nclass SourceLocation {\n  // The + prefix indicates that these fields aren't writeable\n  // Lexer holding the input string.\n  // Start offset, zero-based inclusive.\n  // End offset, zero-based exclusive.\n  constructor(lexer, start, end) {\n    this.lexer = void 0;\n    this.start = void 0;\n    this.end = void 0;\n    this.lexer = lexer;\n    this.start = start;\n    this.end = end;\n  }\n  /**\n   * Merges two `SourceLocation`s from location providers, given they are\n   * provided in order of appearance.\n   * - Returns the first one's location if only the first is provided.\n   * - Returns a merged range of the first and the last if both are provided\n   *   and their lexers match.\n   * - Otherwise, returns null.\n   */\n\n\n  static range(first, second) {\n    if (!second) {\n      return first && first.loc;\n    } else if (!first || !first.loc || !second.loc || first.loc.lexer !== second.loc.lexer) {\n      return null;\n    } else {\n      return new SourceLocation(first.loc.lexer, first.loc.start, second.loc.end);\n    }\n  }\n\n}\n\n/**\n * Interface required to break circular dependency between Token, Lexer, and\n * ParseError.\n */\n\n/**\n * The resulting token returned from `lex`.\n *\n * It consists of the token text plus some position information.\n * The position information is essentially a range in an input string,\n * but instead of referencing the bare input string, we refer to the lexer.\n * That way it is possible to attach extra metadata to the input string,\n * like for example a file name or similar.\n *\n * The position information is optional, so it is OK to construct synthetic\n * tokens if appropriate. Not providing available position information may\n * lead to degraded error reporting, though.\n */\nclass Token {\n  // don't expand the token\n  // used in \\noexpand\n  constructor(text, // the text of this token\n  loc) {\n    this.text = void 0;\n    this.loc = void 0;\n    this.noexpand = void 0;\n    this.treatAsRelax = void 0;\n    this.text = text;\n    this.loc = loc;\n  }\n  /**\n   * Given a pair of tokens (this and endToken), compute a `Token` encompassing\n   * the whole input range enclosed by these two.\n   */\n\n\n  range(endToken, // last token of the range, inclusive\n  text // the text of the newly constructed token\n  ) {\n    return new Token(text, SourceLocation.range(this, endToken));\n  }\n\n}\n\n/**\n * This is the ParseError class, which is the main error thrown by KaTeX\n * functions when something has gone wrong. This is used to distinguish internal\n * errors from errors in the expression that the user provided.\n *\n * If possible, a caller should provide a Token or ParseNode with information\n * about where in the source string the problem occurred.\n */\nclass ParseError {\n  // Error start position based on passed-in Token or ParseNode.\n  // Length of affected text based on passed-in Token or ParseNode.\n  // The underlying error message without any context added.\n  constructor(message, // The error message\n  token // An object providing position information\n  ) {\n    this.name = void 0;\n    this.position = void 0;\n    this.length = void 0;\n    this.rawMessage = void 0;\n    var error = \"KaTeX parse error: \" + message;\n    var start;\n    var end;\n    var loc = token && token.loc;\n\n    if (loc && loc.start <= loc.end) {\n      // If we have the input and a position, make the error a bit fancier\n      // Get the input\n      var input = loc.lexer.input; // Prepend some information\n\n      start = loc.start;\n      end = loc.end;\n\n      if (start === input.length) {\n        error += \" at end of input: \";\n      } else {\n        error += \" at position \" + (start + 1) + \": \";\n      } // Underline token in question using combining underscores\n\n\n      var underlined = input.slice(start, end).replace(/[^]/g, \"$&\\u0332\"); // Extract some context from the input and add it to the error\n\n      var left;\n\n      if (start > 15) {\n        left = \"…\" + input.slice(start - 15, start);\n      } else {\n        left = input.slice(0, start);\n      }\n\n      var right;\n\n      if (end + 15 < input.length) {\n        right = input.slice(end, end + 15) + \"…\";\n      } else {\n        right = input.slice(end);\n      }\n\n      error += left + underlined + right;\n    } // Some hackery to make ParseError a prototype of Error\n    // See http://stackoverflow.com/a/8460753\n    // $FlowFixMe\n\n\n    var self = new Error(error);\n    self.name = \"ParseError\"; // $FlowFixMe\n\n    self.__proto__ = ParseError.prototype;\n    self.position = start;\n\n    if (start != null && end != null) {\n      self.length = end - start;\n    }\n\n    self.rawMessage = message;\n    return self;\n  }\n\n} // $FlowFixMe More hackery\n\n\nParseError.prototype.__proto__ = Error.prototype;\n\n/**\n * This file contains a list of utility functions which are useful in other\n * files.\n */\n\n/**\n * Return whether an element is contained in a list\n */\nvar contains = function contains(list, elem) {\n  return list.indexOf(elem) !== -1;\n};\n/**\n * Provide a default value if a setting is undefined\n * NOTE: Couldn't use `T` as the output type due to facebook/flow#5022.\n */\n\n\nvar deflt = function deflt(setting, defaultIfUndefined) {\n  return setting === undefined ? defaultIfUndefined : setting;\n}; // hyphenate and escape adapted from Facebook's React under Apache 2 license\n\n\nvar uppercase = /([A-Z])/g;\n\nvar hyphenate = function hyphenate(str) {\n  return str.replace(uppercase, \"-$1\").toLowerCase();\n};\n\nvar ESCAPE_LOOKUP = {\n  \"&\": \"&amp;\",\n  \">\": \"&gt;\",\n  \"<\": \"&lt;\",\n  \"\\\"\": \"&quot;\",\n  \"'\": \"&#x27;\"\n};\nvar ESCAPE_REGEX = /[&><\"']/g;\n/**\n * Escapes text to prevent scripting attacks.\n */\n\nfunction escape(text) {\n  return String(text).replace(ESCAPE_REGEX, match => ESCAPE_LOOKUP[match]);\n}\n/**\n * Sometimes we want to pull out the innermost element of a group. In most\n * cases, this will just be the group itself, but when ordgroups and colors have\n * a single element, we want to pull that out.\n */\n\n\nvar getBaseElem = function getBaseElem(group) {\n  if (group.type === \"ordgroup\") {\n    if (group.body.length === 1) {\n      return getBaseElem(group.body[0]);\n    } else {\n      return group;\n    }\n  } else if (group.type === \"color\") {\n    if (group.body.length === 1) {\n      return getBaseElem(group.body[0]);\n    } else {\n      return group;\n    }\n  } else if (group.type === \"font\") {\n    return getBaseElem(group.body);\n  } else {\n    return group;\n  }\n};\n/**\n * TeXbook algorithms often reference \"character boxes\", which are simply groups\n * with a single character in them. To decide if something is a character box,\n * we find its innermost group, and see if it is a single character.\n */\n\n\nvar isCharacterBox = function isCharacterBox(group) {\n  var baseElem = getBaseElem(group); // These are all they types of groups which hold single characters\n\n  return baseElem.type === \"mathord\" || baseElem.type === \"textord\" || baseElem.type === \"atom\";\n};\n\nvar assert = function assert(value) {\n  if (!value) {\n    throw new Error('Expected non-null, but got ' + String(value));\n  }\n\n  return value;\n};\n/**\n * Return the protocol of a URL, or \"_relative\" if the URL does not specify a\n * protocol (and thus is relative), or `null` if URL has invalid protocol\n * (so should be outright rejected).\n */\n\nvar protocolFromUrl = function protocolFromUrl(url) {\n  // Check for possible leading protocol.\n  // https://url.spec.whatwg.org/#url-parsing strips leading whitespace\n  // (U+20) or C0 control (U+00-U+1F) characters.\n  // eslint-disable-next-line no-control-regex\n  var protocol = /^[\\x00-\\x20]*([^\\\\/#?]*?)(:|&#0*58|&#x0*3a|&colon)/i.exec(url);\n\n  if (!protocol) {\n    return \"_relative\";\n  } // Reject weird colons\n\n\n  if (protocol[2] !== \":\") {\n    return null;\n  } // Reject invalid characters in scheme according to\n  // https://datatracker.ietf.org/doc/html/rfc3986#section-3.1\n\n\n  if (!/^[a-zA-Z][a-zA-Z0-9+\\-.]*$/.test(protocol[1])) {\n    return null;\n  } // Lowercase the protocol\n\n\n  return protocol[1].toLowerCase();\n};\nvar utils = {\n  contains,\n  deflt,\n  escape,\n  hyphenate,\n  getBaseElem,\n  isCharacterBox,\n  protocolFromUrl\n};\n\n/* eslint no-console:0 */\n// TODO: automatically generate documentation\n// TODO: check all properties on Settings exist\n// TODO: check the type of a property on Settings matches\nvar SETTINGS_SCHEMA = {\n  displayMode: {\n    type: \"boolean\",\n    description: \"Render math in display mode, which puts the math in \" + \"display style (so \\\\int and \\\\sum are large, for example), and \" + \"centers the math on the page on its own line.\",\n    cli: \"-d, --display-mode\"\n  },\n  output: {\n    type: {\n      enum: [\"htmlAndMathml\", \"html\", \"mathml\"]\n    },\n    description: \"Determines the markup language of the output.\",\n    cli: \"-F, --format <type>\"\n  },\n  leqno: {\n    type: \"boolean\",\n    description: \"Render display math in leqno style (left-justified tags).\"\n  },\n  fleqn: {\n    type: \"boolean\",\n    description: \"Render display math flush left.\"\n  },\n  throwOnError: {\n    type: \"boolean\",\n    default: true,\n    cli: \"-t, --no-throw-on-error\",\n    cliDescription: \"Render errors (in the color given by --error-color) ins\" + \"tead of throwing a ParseError exception when encountering an error.\"\n  },\n  errorColor: {\n    type: \"string\",\n    default: \"#cc0000\",\n    cli: \"-c, --error-color <color>\",\n    cliDescription: \"A color string given in the format 'rgb' or 'rrggbb' \" + \"(no #). This option determines the color of errors rendered by the \" + \"-t option.\",\n    cliProcessor: color => \"#\" + color\n  },\n  macros: {\n    type: \"object\",\n    cli: \"-m, --macro <def>\",\n    cliDescription: \"Define custom macro of the form '\\\\foo:expansion' (use \" + \"multiple -m arguments for multiple macros).\",\n    cliDefault: [],\n    cliProcessor: (def, defs) => {\n      defs.push(def);\n      return defs;\n    }\n  },\n  minRuleThickness: {\n    type: \"number\",\n    description: \"Specifies a minimum thickness, in ems, for fraction lines,\" + \" `\\\\sqrt` top lines, `{array}` vertical lines, `\\\\hline`, \" + \"`\\\\hdashline`, `\\\\underline`, `\\\\overline`, and the borders of \" + \"`\\\\fbox`, `\\\\boxed`, and `\\\\fcolorbox`.\",\n    processor: t => Math.max(0, t),\n    cli: \"--min-rule-thickness <size>\",\n    cliProcessor: parseFloat\n  },\n  colorIsTextColor: {\n    type: \"boolean\",\n    description: \"Makes \\\\color behave like LaTeX's 2-argument \\\\textcolor, \" + \"instead of LaTeX's one-argument \\\\color mode change.\",\n    cli: \"-b, --color-is-text-color\"\n  },\n  strict: {\n    type: [{\n      enum: [\"warn\", \"ignore\", \"error\"]\n    }, \"boolean\", \"function\"],\n    description: \"Turn on strict / LaTeX faithfulness mode, which throws an \" + \"error if the input uses features that are not supported by LaTeX.\",\n    cli: \"-S, --strict\",\n    cliDefault: false\n  },\n  trust: {\n    type: [\"boolean\", \"function\"],\n    description: \"Trust the input, enabling all HTML features such as \\\\url.\",\n    cli: \"-T, --trust\"\n  },\n  maxSize: {\n    type: \"number\",\n    default: Infinity,\n    description: \"If non-zero, all user-specified sizes, e.g. in \" + \"\\\\rule{500em}{500em}, will be capped to maxSize ems. Otherwise, \" + \"elements and spaces can be arbitrarily large\",\n    processor: s => Math.max(0, s),\n    cli: \"-s, --max-size <n>\",\n    cliProcessor: parseInt\n  },\n  maxExpand: {\n    type: \"number\",\n    default: 1000,\n    description: \"Limit the number of macro expansions to the specified \" + \"number, to prevent e.g. infinite macro loops. If set to Infinity, \" + \"the macro expander will try to fully expand as in LaTeX.\",\n    processor: n => Math.max(0, n),\n    cli: \"-e, --max-expand <n>\",\n    cliProcessor: n => n === \"Infinity\" ? Infinity : parseInt(n)\n  },\n  globalGroup: {\n    type: \"boolean\",\n    cli: false\n  }\n};\n\nfunction getDefaultValue(schema) {\n  if (schema.default) {\n    return schema.default;\n  }\n\n  var type = schema.type;\n  var defaultType = Array.isArray(type) ? type[0] : type;\n\n  if (typeof defaultType !== 'string') {\n    return defaultType.enum[0];\n  }\n\n  switch (defaultType) {\n    case 'boolean':\n      return false;\n\n    case 'string':\n      return '';\n\n    case 'number':\n      return 0;\n\n    case 'object':\n      return {};\n  }\n}\n/**\n * The main Settings object\n *\n * The current options stored are:\n *  - displayMode: Whether the expression should be typeset as inline math\n *                 (false, the default), meaning that the math starts in\n *                 \\textstyle and is placed in an inline-block); or as display\n *                 math (true), meaning that the math starts in \\displaystyle\n *                 and is placed in a block with vertical margin.\n */\n\n\nclass Settings {\n  constructor(options) {\n    this.displayMode = void 0;\n    this.output = void 0;\n    this.leqno = void 0;\n    this.fleqn = void 0;\n    this.throwOnError = void 0;\n    this.errorColor = void 0;\n    this.macros = void 0;\n    this.minRuleThickness = void 0;\n    this.colorIsTextColor = void 0;\n    this.strict = void 0;\n    this.trust = void 0;\n    this.maxSize = void 0;\n    this.maxExpand = void 0;\n    this.globalGroup = void 0;\n    // allow null options\n    options = options || {};\n\n    for (var prop in SETTINGS_SCHEMA) {\n      if (SETTINGS_SCHEMA.hasOwnProperty(prop)) {\n        // $FlowFixMe\n        var schema = SETTINGS_SCHEMA[prop]; // TODO: validate options\n        // $FlowFixMe\n\n        this[prop] = options[prop] !== undefined ? schema.processor ? schema.processor(options[prop]) : options[prop] : getDefaultValue(schema);\n      }\n    }\n  }\n  /**\n   * Report nonstrict (non-LaTeX-compatible) input.\n   * Can safely not be called if `this.strict` is false in JavaScript.\n   */\n\n\n  reportNonstrict(errorCode, errorMsg, token) {\n    var strict = this.strict;\n\n    if (typeof strict === \"function\") {\n      // Allow return value of strict function to be boolean or string\n      // (or null/undefined, meaning no further processing).\n      strict = strict(errorCode, errorMsg, token);\n    }\n\n    if (!strict || strict === \"ignore\") {\n      return;\n    } else if (strict === true || strict === \"error\") {\n      throw new ParseError(\"LaTeX-incompatible input and strict mode is set to 'error': \" + (errorMsg + \" [\" + errorCode + \"]\"), token);\n    } else if (strict === \"warn\") {\n      typeof console !== \"undefined\" && console.warn(\"LaTeX-incompatible input and strict mode is set to 'warn': \" + (errorMsg + \" [\" + errorCode + \"]\"));\n    } else {\n      // won't happen in type-safe code\n      typeof console !== \"undefined\" && console.warn(\"LaTeX-incompatible input and strict mode is set to \" + (\"unrecognized '\" + strict + \"': \" + errorMsg + \" [\" + errorCode + \"]\"));\n    }\n  }\n  /**\n   * Check whether to apply strict (LaTeX-adhering) behavior for unusual\n   * input (like `\\\\`).  Unlike `nonstrict`, will not throw an error;\n   * instead, \"error\" translates to a return value of `true`, while \"ignore\"\n   * translates to a return value of `false`.  May still print a warning:\n   * \"warn\" prints a warning and returns `false`.\n   * This is for the second category of `errorCode`s listed in the README.\n   */\n\n\n  useStrictBehavior(errorCode, errorMsg, token) {\n    var strict = this.strict;\n\n    if (typeof strict === \"function\") {\n      // Allow return value of strict function to be boolean or string\n      // (or null/undefined, meaning no further processing).\n      // But catch any exceptions thrown by function, treating them\n      // like \"error\".\n      try {\n        strict = strict(errorCode, errorMsg, token);\n      } catch (error) {\n        strict = \"error\";\n      }\n    }\n\n    if (!strict || strict === \"ignore\") {\n      return false;\n    } else if (strict === true || strict === \"error\") {\n      return true;\n    } else if (strict === \"warn\") {\n      typeof console !== \"undefined\" && console.warn(\"LaTeX-incompatible input and strict mode is set to 'warn': \" + (errorMsg + \" [\" + errorCode + \"]\"));\n      return false;\n    } else {\n      // won't happen in type-safe code\n      typeof console !== \"undefined\" && console.warn(\"LaTeX-incompatible input and strict mode is set to \" + (\"unrecognized '\" + strict + \"': \" + errorMsg + \" [\" + errorCode + \"]\"));\n      return false;\n    }\n  }\n  /**\n   * Check whether to test potentially dangerous input, and return\n   * `true` (trusted) or `false` (untrusted).  The sole argument `context`\n   * should be an object with `command` field specifying the relevant LaTeX\n   * command (as a string starting with `\\`), and any other arguments, etc.\n   * If `context` has a `url` field, a `protocol` field will automatically\n   * get added by this function (changing the specified object).\n   */\n\n\n  isTrusted(context) {\n    if (context.url && !context.protocol) {\n      var protocol = utils.protocolFromUrl(context.url);\n\n      if (protocol == null) {\n        return false;\n      }\n\n      context.protocol = protocol;\n    }\n\n    var trust = typeof this.trust === \"function\" ? this.trust(context) : this.trust;\n    return Boolean(trust);\n  }\n\n}\n\n/**\n * This file contains information and classes for the various kinds of styles\n * used in TeX. It provides a generic `Style` class, which holds information\n * about a specific style. It then provides instances of all the different kinds\n * of styles possible, and provides functions to move between them and get\n * information about them.\n */\n\n/**\n * The main style class. Contains a unique id for the style, a size (which is\n * the same for cramped and uncramped version of a style), and a cramped flag.\n */\nclass Style {\n  constructor(id, size, cramped) {\n    this.id = void 0;\n    this.size = void 0;\n    this.cramped = void 0;\n    this.id = id;\n    this.size = size;\n    this.cramped = cramped;\n  }\n  /**\n   * Get the style of a superscript given a base in the current style.\n   */\n\n\n  sup() {\n    return styles[sup[this.id]];\n  }\n  /**\n   * Get the style of a subscript given a base in the current style.\n   */\n\n\n  sub() {\n    return styles[sub[this.id]];\n  }\n  /**\n   * Get the style of a fraction numerator given the fraction in the current\n   * style.\n   */\n\n\n  fracNum() {\n    return styles[fracNum[this.id]];\n  }\n  /**\n   * Get the style of a fraction denominator given the fraction in the current\n   * style.\n   */\n\n\n  fracDen() {\n    return styles[fracDen[this.id]];\n  }\n  /**\n   * Get the cramped version of a style (in particular, cramping a cramped style\n   * doesn't change the style).\n   */\n\n\n  cramp() {\n    return styles[cramp[this.id]];\n  }\n  /**\n   * Get a text or display version of this style.\n   */\n\n\n  text() {\n    return styles[text$1[this.id]];\n  }\n  /**\n   * Return true if this style is tightly spaced (scriptstyle/scriptscriptstyle)\n   */\n\n\n  isTight() {\n    return this.size >= 2;\n  }\n\n} // Export an interface for type checking, but don't expose the implementation.\n// This way, no more styles can be generated.\n\n\n// IDs of the different styles\nvar D = 0;\nvar Dc = 1;\nvar T = 2;\nvar Tc = 3;\nvar S = 4;\nvar Sc = 5;\nvar SS = 6;\nvar SSc = 7; // Instances of the different styles\n\nvar styles = [new Style(D, 0, false), new Style(Dc, 0, true), new Style(T, 1, false), new Style(Tc, 1, true), new Style(S, 2, false), new Style(Sc, 2, true), new Style(SS, 3, false), new Style(SSc, 3, true)]; // Lookup tables for switching from one style to another\n\nvar sup = [S, Sc, S, Sc, SS, SSc, SS, SSc];\nvar sub = [Sc, Sc, Sc, Sc, SSc, SSc, SSc, SSc];\nvar fracNum = [T, Tc, S, Sc, SS, SSc, SS, SSc];\nvar fracDen = [Tc, Tc, Sc, Sc, SSc, SSc, SSc, SSc];\nvar cramp = [Dc, Dc, Tc, Tc, Sc, Sc, SSc, SSc];\nvar text$1 = [D, Dc, T, Tc, T, Tc, T, Tc]; // We only export some of the styles.\n\nvar Style$1 = {\n  DISPLAY: styles[D],\n  TEXT: styles[T],\n  SCRIPT: styles[S],\n  SCRIPTSCRIPT: styles[SS]\n};\n\n/*\n * This file defines the Unicode scripts and script families that we\n * support. To add new scripts or families, just add a new entry to the\n * scriptData array below. Adding scripts to the scriptData array allows\n * characters from that script to appear in \\text{} environments.\n */\n\n/**\n * Each script or script family has a name and an array of blocks.\n * Each block is an array of two numbers which specify the start and\n * end points (inclusive) of a block of Unicode codepoints.\n */\n\n/**\n * Unicode block data for the families of scripts we support in \\text{}.\n * Scripts only need to appear here if they do not have font metrics.\n */\nvar scriptData = [{\n  // Latin characters beyond the Latin-1 characters we have metrics for.\n  // Needed for Czech, Hungarian and Turkish text, for example.\n  name: 'latin',\n  blocks: [[0x0100, 0x024f], // Latin Extended-A and Latin Extended-B\n  [0x0300, 0x036f] // Combining Diacritical marks\n  ]\n}, {\n  // The Cyrillic script used by Russian and related languages.\n  // A Cyrillic subset used to be supported as explicitly defined\n  // symbols in symbols.js\n  name: 'cyrillic',\n  blocks: [[0x0400, 0x04ff]]\n}, {\n  // Armenian\n  name: 'armenian',\n  blocks: [[0x0530, 0x058F]]\n}, {\n  // The Brahmic scripts of South and Southeast Asia\n  // Devanagari (0900–097F)\n  // Bengali (0980–09FF)\n  // Gurmukhi (0A00–0A7F)\n  // Gujarati (0A80–0AFF)\n  // Oriya (0B00–0B7F)\n  // Tamil (0B80–0BFF)\n  // Telugu (0C00–0C7F)\n  // Kannada (0C80–0CFF)\n  // Malayalam (0D00–0D7F)\n  // Sinhala (0D80–0DFF)\n  // Thai (0E00–0E7F)\n  // Lao (0E80–0EFF)\n  // Tibetan (0F00–0FFF)\n  // Myanmar (1000–109F)\n  name: 'brahmic',\n  blocks: [[0x0900, 0x109F]]\n}, {\n  name: 'georgian',\n  blocks: [[0x10A0, 0x10ff]]\n}, {\n  // Chinese and Japanese.\n  // The \"k\" in cjk is for Korean, but we've separated Korean out\n  name: \"cjk\",\n  blocks: [[0x3000, 0x30FF], // CJK symbols and punctuation, Hiragana, Katakana\n  [0x4E00, 0x9FAF], // CJK ideograms\n  [0xFF00, 0xFF60] // Fullwidth punctuation\n  // TODO: add halfwidth Katakana and Romanji glyphs\n  ]\n}, {\n  // Korean\n  name: 'hangul',\n  blocks: [[0xAC00, 0xD7AF]]\n}];\n/**\n * Given a codepoint, return the name of the script or script family\n * it is from, or null if it is not part of a known block\n */\n\nfunction scriptFromCodepoint(codepoint) {\n  for (var i = 0; i < scriptData.length; i++) {\n    var script = scriptData[i];\n\n    for (var _i = 0; _i < script.blocks.length; _i++) {\n      var block = script.blocks[_i];\n\n      if (codepoint >= block[0] && codepoint <= block[1]) {\n        return script.name;\n      }\n    }\n  }\n\n  return null;\n}\n/**\n * A flattened version of all the supported blocks in a single array.\n * This is an optimization to make supportedCodepoint() fast.\n */\n\nvar allBlocks = [];\nscriptData.forEach(s => s.blocks.forEach(b => allBlocks.push(...b)));\n/**\n * Given a codepoint, return true if it falls within one of the\n * scripts or script families defined above and false otherwise.\n *\n * Micro benchmarks shows that this is faster than\n * /[\\u3000-\\u30FF\\u4E00-\\u9FAF\\uFF00-\\uFF60\\uAC00-\\uD7AF\\u0900-\\u109F]/.test()\n * in Firefox, Chrome and Node.\n */\n\nfunction supportedCodepoint(codepoint) {\n  for (var i = 0; i < allBlocks.length; i += 2) {\n    if (codepoint >= allBlocks[i] && codepoint <= allBlocks[i + 1]) {\n      return true;\n    }\n  }\n\n  return false;\n}\n\n/**\n * This file provides support to domTree.js and delimiter.js.\n * It's a storehouse of path geometry for SVG images.\n */\n// In all paths below, the viewBox-to-em scale is 1000:1.\nvar hLinePad = 80; // padding above a sqrt vinculum. Prevents image cropping.\n// The vinculum of a \\sqrt can be made thicker by a KaTeX rendering option.\n// Think of variable extraVinculum as two detours in the SVG path.\n// The detour begins at the lower left of the area labeled extraVinculum below.\n// The detour proceeds one extraVinculum distance up and slightly to the right,\n// displacing the radiused corner between surd and vinculum. The radius is\n// traversed as usual, then the detour resumes. It goes right, to the end of\n// the very long vinculum, then down one extraVinculum distance,\n// after which it resumes regular path geometry for the radical.\n\n/*                                                  vinculum\n                                                   /\n         /▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒←extraVinculum\n        / █████████████████████←0.04em (40 unit) std vinculum thickness\n       / /\n      / /\n     / /\\\n    / / surd\n*/\n\nvar sqrtMain = function sqrtMain(extraVinculum, hLinePad) {\n  // sqrtMain path geometry is from glyph U221A in the font KaTeX Main\n  return \"M95,\" + (622 + extraVinculum + hLinePad) + \"\\nc-2.7,0,-7.17,-2.7,-13.5,-8c-5.8,-5.3,-9.5,-10,-9.5,-14\\nc0,-2,0.3,-3.3,1,-4c1.3,-2.7,23.83,-20.7,67.5,-54\\nc44.2,-33.3,65.8,-50.3,66.5,-51c1.3,-1.3,3,-2,5,-2c4.7,0,8.7,3.3,12,10\\ns173,378,173,378c0.7,0,35.3,-71,104,-213c68.7,-142,137.5,-285,206.5,-429\\nc69,-144,104.5,-217.7,106.5,-221\\nl\" + extraVinculum / 2.075 + \" -\" + extraVinculum + \"\\nc5.3,-9.3,12,-14,20,-14\\nH400000v\" + (40 + extraVinculum) + \"H845.2724\\ns-225.272,467,-225.272,467s-235,486,-235,486c-2.7,4.7,-9,7,-19,7\\nc-6,0,-10,-1,-12,-3s-194,-422,-194,-422s-65,47,-65,47z\\nM\" + (834 + extraVinculum) + \" \" + hLinePad + \"h400000v\" + (40 + extraVinculum) + \"h-400000z\";\n};\n\nvar sqrtSize1 = function sqrtSize1(extraVinculum, hLinePad) {\n  // size1 is from glyph U221A in the font KaTeX_Size1-Regular\n  return \"M263,\" + (601 + extraVinculum + hLinePad) + \"c0.7,0,18,39.7,52,119\\nc34,79.3,68.167,158.7,102.5,238c34.3,79.3,51.8,119.3,52.5,120\\nc340,-704.7,510.7,-1060.3,512,-1067\\nl\" + extraVinculum / 2.084 + \" -\" + extraVinculum + \"\\nc4.7,-7.3,11,-11,19,-11\\nH40000v\" + (40 + extraVinculum) + \"H1012.3\\ns-271.3,567,-271.3,567c-38.7,80.7,-84,175,-136,283c-52,108,-89.167,185.3,-111.5,232\\nc-22.3,46.7,-33.8,70.3,-34.5,71c-4.7,4.7,-12.3,7,-23,7s-12,-1,-12,-1\\ns-109,-253,-109,-253c-72.7,-168,-109.3,-252,-110,-252c-10.7,8,-22,16.7,-34,26\\nc-22,17.3,-33.3,26,-34,26s-26,-26,-26,-26s76,-59,76,-59s76,-60,76,-60z\\nM\" + (1001 + extraVinculum) + \" \" + hLinePad + \"h400000v\" + (40 + extraVinculum) + \"h-400000z\";\n};\n\nvar sqrtSize2 = function sqrtSize2(extraVinculum, hLinePad) {\n  // size2 is from glyph U221A in the font KaTeX_Size2-Regular\n  return \"M983 \" + (10 + extraVinculum + hLinePad) + \"\\nl\" + extraVinculum / 3.13 + \" -\" + extraVinculum + \"\\nc4,-6.7,10,-10,18,-10 H400000v\" + (40 + extraVinculum) + \"\\nH1013.1s-83.4,268,-264.1,840c-180.7,572,-277,876.3,-289,913c-4.7,4.7,-12.7,7,-24,7\\ns-12,0,-12,0c-1.3,-3.3,-3.7,-11.7,-7,-25c-35.3,-125.3,-106.7,-373.3,-214,-744\\nc-10,12,-21,25,-33,39s-32,39,-32,39c-6,-5.3,-15,-14,-27,-26s25,-30,25,-30\\nc26.7,-32.7,52,-63,76,-91s52,-60,52,-60s208,722,208,722\\nc56,-175.3,126.3,-397.3,211,-666c84.7,-268.7,153.8,-488.2,207.5,-658.5\\nc53.7,-170.3,84.5,-266.8,92.5,-289.5z\\nM\" + (1001 + extraVinculum) + \" \" + hLinePad + \"h400000v\" + (40 + extraVinculum) + \"h-400000z\";\n};\n\nvar sqrtSize3 = function sqrtSize3(extraVinculum, hLinePad) {\n  // size3 is from glyph U221A in the font KaTeX_Size3-Regular\n  return \"M424,\" + (2398 + extraVinculum + hLinePad) + \"\\nc-1.3,-0.7,-38.5,-172,-111.5,-514c-73,-342,-109.8,-513.3,-110.5,-514\\nc0,-2,-10.7,14.3,-32,49c-4.7,7.3,-9.8,15.7,-15.5,25c-5.7,9.3,-9.8,16,-12.5,20\\ns-5,7,-5,7c-4,-3.3,-8.3,-7.7,-13,-13s-13,-13,-13,-13s76,-122,76,-122s77,-121,77,-121\\ns209,968,209,968c0,-2,84.7,-361.7,254,-1079c169.3,-717.3,254.7,-1077.7,256,-1081\\nl\" + extraVinculum / 4.223 + \" -\" + extraVinculum + \"c4,-6.7,10,-10,18,-10 H400000\\nv\" + (40 + extraVinculum) + \"H1014.6\\ns-87.3,378.7,-272.6,1166c-185.3,787.3,-279.3,1182.3,-282,1185\\nc-2,6,-10,9,-24,9\\nc-8,0,-12,-0.7,-12,-2z M\" + (1001 + extraVinculum) + \" \" + hLinePad + \"\\nh400000v\" + (40 + extraVinculum) + \"h-400000z\";\n};\n\nvar sqrtSize4 = function sqrtSize4(extraVinculum, hLinePad) {\n  // size4 is from glyph U221A in the font KaTeX_Size4-Regular\n  return \"M473,\" + (2713 + extraVinculum + hLinePad) + \"\\nc339.3,-1799.3,509.3,-2700,510,-2702 l\" + extraVinculum / 5.298 + \" -\" + extraVinculum + \"\\nc3.3,-7.3,9.3,-11,18,-11 H400000v\" + (40 + extraVinculum) + \"H1017.7\\ns-90.5,478,-276.2,1466c-185.7,988,-279.5,1483,-281.5,1485c-2,6,-10,9,-24,9\\nc-8,0,-12,-0.7,-12,-2c0,-1.3,-5.3,-32,-16,-92c-50.7,-293.3,-119.7,-693.3,-207,-1200\\nc0,-1.3,-5.3,8.7,-16,30c-10.7,21.3,-21.3,42.7,-32,64s-16,33,-16,33s-26,-26,-26,-26\\ns76,-153,76,-153s77,-151,77,-151c0.7,0.7,35.7,202,105,604c67.3,400.7,102,602.7,104,\\n606zM\" + (1001 + extraVinculum) + \" \" + hLinePad + \"h400000v\" + (40 + extraVinculum) + \"H1017.7z\";\n};\n\nvar phasePath = function phasePath(y) {\n  var x = y / 2; // x coordinate at top of angle\n\n  return \"M400000 \" + y + \" H0 L\" + x + \" 0 l65 45 L145 \" + (y - 80) + \" H400000z\";\n};\n\nvar sqrtTall = function sqrtTall(extraVinculum, hLinePad, viewBoxHeight) {\n  // sqrtTall is from glyph U23B7 in the font KaTeX_Size4-Regular\n  // One path edge has a variable length. It runs vertically from the vinculum\n  // to a point near (14 units) the bottom of the surd. The vinculum\n  // is normally 40 units thick. So the length of the line in question is:\n  var vertSegment = viewBoxHeight - 54 - hLinePad - extraVinculum;\n  return \"M702 \" + (extraVinculum + hLinePad) + \"H400000\" + (40 + extraVinculum) + \"\\nH742v\" + vertSegment + \"l-4 4-4 4c-.667.7 -2 1.5-4 2.5s-4.167 1.833-6.5 2.5-5.5 1-9.5 1\\nh-12l-28-84c-16.667-52-96.667 -294.333-240-727l-212 -643 -85 170\\nc-4-3.333-8.333-7.667-13 -13l-13-13l77-155 77-156c66 199.333 139 419.667\\n219 661 l218 661zM702 \" + hLinePad + \"H400000v\" + (40 + extraVinculum) + \"H742z\";\n};\n\nvar sqrtPath = function sqrtPath(size, extraVinculum, viewBoxHeight) {\n  extraVinculum = 1000 * extraVinculum; // Convert from document ems to viewBox.\n\n  var path = \"\";\n\n  switch (size) {\n    case \"sqrtMain\":\n      path = sqrtMain(extraVinculum, hLinePad);\n      break;\n\n    case \"sqrtSize1\":\n      path = sqrtSize1(extraVinculum, hLinePad);\n      break;\n\n    case \"sqrtSize2\":\n      path = sqrtSize2(extraVinculum, hLinePad);\n      break;\n\n    case \"sqrtSize3\":\n      path = sqrtSize3(extraVinculum, hLinePad);\n      break;\n\n    case \"sqrtSize4\":\n      path = sqrtSize4(extraVinculum, hLinePad);\n      break;\n\n    case \"sqrtTall\":\n      path = sqrtTall(extraVinculum, hLinePad, viewBoxHeight);\n  }\n\n  return path;\n};\nvar innerPath = function innerPath(name, height) {\n  // The inner part of stretchy tall delimiters\n  switch (name) {\n    case \"\\u239c\":\n      return \"M291 0 H417 V\" + height + \" H291z M291 0 H417 V\" + height + \" H291z\";\n\n    case \"\\u2223\":\n      return \"M145 0 H188 V\" + height + \" H145z M145 0 H188 V\" + height + \" H145z\";\n\n    case \"\\u2225\":\n      return \"M145 0 H188 V\" + height + \" H145z M145 0 H188 V\" + height + \" H145z\" + (\"M367 0 H410 V\" + height + \" H367z M367 0 H410 V\" + height + \" H367z\");\n\n    case \"\\u239f\":\n      return \"M457 0 H583 V\" + height + \" H457z M457 0 H583 V\" + height + \" H457z\";\n\n    case \"\\u23a2\":\n      return \"M319 0 H403 V\" + height + \" H319z M319 0 H403 V\" + height + \" H319z\";\n\n    case \"\\u23a5\":\n      return \"M263 0 H347 V\" + height + \" H263z M263 0 H347 V\" + height + \" H263z\";\n\n    case \"\\u23aa\":\n      return \"M384 0 H504 V\" + height + \" H384z M384 0 H504 V\" + height + \" H384z\";\n\n    case \"\\u23d0\":\n      return \"M312 0 H355 V\" + height + \" H312z M312 0 H355 V\" + height + \" H312z\";\n\n    case \"\\u2016\":\n      return \"M257 0 H300 V\" + height + \" H257z M257 0 H300 V\" + height + \" H257z\" + (\"M478 0 H521 V\" + height + \" H478z M478 0 H521 V\" + height + \" H478z\");\n\n    default:\n      return \"\";\n  }\n};\nvar path = {\n  // The doubleleftarrow geometry is from glyph U+21D0 in the font KaTeX Main\n  doubleleftarrow: \"M262 157\\nl10-10c34-36 62.7-77 86-123 3.3-8 5-13.3 5-16 0-5.3-6.7-8-20-8-7.3\\n 0-12.2.5-14.5 1.5-2.3 1-4.8 4.5-7.5 10.5-49.3 97.3-121.7 169.3-217 216-28\\n 14-57.3 25-88 33-6.7 2-11 3.8-13 5.5-2 1.7-3 4.2-3 7.5s1 5.8 3 7.5\\nc2 1.7 6.3 3.5 13 5.5 68 17.3 128.2 47.8 180.5 91.5 52.3 43.7 93.8 96.2 124.5\\n 157.5 9.3 8 15.3 12.3 18 13h6c12-.7 18-4 18-10 0-2-1.7-7-5-15-23.3-46-52-87\\n-86-123l-10-10h399738v-40H218c328 0 0 0 0 0l-10-8c-26.7-20-65.7-43-117-69 2.7\\n-2 6-3.7 10-5 36.7-16 72.3-37.3 107-64l10-8h399782v-40z\\nm8 0v40h399730v-40zm0 194v40h399730v-40z\",\n  // doublerightarrow is from glyph U+21D2 in font KaTeX Main\n  doublerightarrow: \"M399738 392l\\n-10 10c-34 36-62.7 77-86 123-3.3 8-5 13.3-5 16 0 5.3 6.7 8 20 8 7.3 0 12.2-.5\\n 14.5-1.5 2.3-1 4.8-4.5 7.5-10.5 49.3-97.3 121.7-169.3 217-216 28-14 57.3-25 88\\n-33 6.7-2 11-3.8 13-5.5 2-1.7 3-4.2 3-7.5s-1-5.8-3-7.5c-2-1.7-6.3-3.5-13-5.5-68\\n-17.3-128.2-47.8-180.5-91.5-52.3-43.7-93.8-96.2-124.5-157.5-9.3-8-15.3-12.3-18\\n-13h-6c-12 .7-18 4-18 10 0 2 1.7 7 5 15 23.3 46 52 87 86 123l10 10H0v40h399782\\nc-328 0 0 0 0 0l10 8c26.7 20 65.7 43 117 69-2.7 2-6 3.7-10 5-36.7 16-72.3 37.3\\n-107 64l-10 8H0v40zM0 157v40h399730v-40zm0 194v40h399730v-40z\",\n  // leftarrow is from glyph U+2190 in font KaTeX Main\n  leftarrow: \"M400000 241H110l3-3c68.7-52.7 113.7-120\\n 135-202 4-14.7 6-23 6-25 0-7.3-7-11-21-11-8 0-13.2.8-15.5 2.5-2.3 1.7-4.2 5.8\\n-5.5 12.5-1.3 4.7-2.7 10.3-4 17-12 48.7-34.8 92-68.5 130S65.3 228.3 18 247\\nc-10 4-16 7.7-18 11 0 8.7 6 14.3 18 17 47.3 18.7 87.8 47 121.5 85S196 441.3 208\\n 490c.7 2 1.3 5 2 9s1.2 6.7 1.5 8c.3 1.3 1 3.3 2 6s2.2 4.5 3.5 5.5c1.3 1 3.3\\n 1.8 6 2.5s6 1 10 1c14 0 21-3.7 21-11 0-2-2-10.3-6-25-20-79.3-65-146.7-135-202\\n l-3-3h399890zM100 241v40h399900v-40z\",\n  // overbrace is from glyphs U+23A9/23A8/23A7 in font KaTeX_Size4-Regular\n  leftbrace: \"M6 548l-6-6v-35l6-11c56-104 135.3-181.3 238-232 57.3-28.7 117\\n-45 179-50h399577v120H403c-43.3 7-81 15-113 26-100.7 33-179.7 91-237 174-2.7\\n 5-6 9-10 13-.7 1-7.3 1-20 1H6z\",\n  leftbraceunder: \"M0 6l6-6h17c12.688 0 19.313.3 20 1 4 4 7.313 8.3 10 13\\n 35.313 51.3 80.813 93.8 136.5 127.5 55.688 33.7 117.188 55.8 184.5 66.5.688\\n 0 2 .3 4 1 18.688 2.7 76 4.3 172 5h399450v120H429l-6-1c-124.688-8-235-61.7\\n-331-161C60.687 138.7 32.312 99.3 7 54L0 41V6z\",\n  // overgroup is from the MnSymbol package (public domain)\n  leftgroup: \"M400000 80\\nH435C64 80 168.3 229.4 21 260c-5.9 1.2-18 0-18 0-2 0-3-1-3-3v-38C76 61 257 0\\n 435 0h399565z\",\n  leftgroupunder: \"M400000 262\\nH435C64 262 168.3 112.6 21 82c-5.9-1.2-18 0-18 0-2 0-3 1-3 3v38c76 158 257 219\\n 435 219h399565z\",\n  // Harpoons are from glyph U+21BD in font KaTeX Main\n  leftharpoon: \"M0 267c.7 5.3 3 10 7 14h399993v-40H93c3.3\\n-3.3 10.2-9.5 20.5-18.5s17.8-15.8 22.5-20.5c50.7-52 88-110.3 112-175 4-11.3 5\\n-18.3 3-21-1.3-4-7.3-6-18-6-8 0-13 .7-15 2s-4.7 6.7-8 16c-42 98.7-107.3 174.7\\n-196 228-6.7 4.7-10.7 8-12 10-1.3 2-2 5.7-2 11zm100-26v40h399900v-40z\",\n  leftharpoonplus: \"M0 267c.7 5.3 3 10 7 14h399993v-40H93c3.3-3.3 10.2-9.5\\n 20.5-18.5s17.8-15.8 22.5-20.5c50.7-52 88-110.3 112-175 4-11.3 5-18.3 3-21-1.3\\n-4-7.3-6-18-6-8 0-13 .7-15 2s-4.7 6.7-8 16c-42 98.7-107.3 174.7-196 228-6.7 4.7\\n-10.7 8-12 10-1.3 2-2 5.7-2 11zm100-26v40h399900v-40zM0 435v40h400000v-40z\\nm0 0v40h400000v-40z\",\n  leftharpoondown: \"M7 241c-4 4-6.333 8.667-7 14 0 5.333.667 9 2 11s5.333\\n 5.333 12 10c90.667 54 156 130 196 228 3.333 10.667 6.333 16.333 9 17 2 .667 5\\n 1 9 1h5c10.667 0 16.667-2 18-6 2-2.667 1-9.667-3-21-32-87.333-82.667-157.667\\n-152-211l-3-3h399907v-40zM93 281 H400000 v-40L7 241z\",\n  leftharpoondownplus: \"M7 435c-4 4-6.3 8.7-7 14 0 5.3.7 9 2 11s5.3 5.3 12\\n 10c90.7 54 156 130 196 228 3.3 10.7 6.3 16.3 9 17 2 .7 5 1 9 1h5c10.7 0 16.7\\n-2 18-6 2-2.7 1-9.7-3-21-32-87.3-82.7-157.7-152-211l-3-3h399907v-40H7zm93 0\\nv40h399900v-40zM0 241v40h399900v-40zm0 0v40h399900v-40z\",\n  // hook is from glyph U+21A9 in font KaTeX Main\n  lefthook: \"M400000 281 H103s-33-11.2-61-33.5S0 197.3 0 164s14.2-61.2 42.5\\n-83.5C70.8 58.2 104 47 142 47 c16.7 0 25 6.7 25 20 0 12-8.7 18.7-26 20-40 3.3\\n-68.7 15.7-86 37-10 12-15 25.3-15 40 0 22.7 9.8 40.7 29.5 54 19.7 13.3 43.5 21\\n 71.5 23h399859zM103 281v-40h399897v40z\",\n  leftlinesegment: \"M40 281 V428 H0 V94 H40 V241 H400000 v40z\\nM40 281 V428 H0 V94 H40 V241 H400000 v40z\",\n  leftmapsto: \"M40 281 V448H0V74H40V241H400000v40z\\nM40 281 V448H0V74H40V241H400000v40z\",\n  // tofrom is from glyph U+21C4 in font KaTeX AMS Regular\n  leftToFrom: \"M0 147h400000v40H0zm0 214c68 40 115.7 95.7 143 167h22c15.3 0 23\\n-.3 23-1 0-1.3-5.3-13.7-16-37-18-35.3-41.3-69-70-101l-7-8h399905v-40H95l7-8\\nc28.7-32 52-65.7 70-101 10.7-23.3 16-35.7 16-37 0-.7-7.7-1-23-1h-22C115.7 265.3\\n 68 321 0 361zm0-174v-40h399900v40zm100 154v40h399900v-40z\",\n  longequal: \"M0 50 h400000 v40H0z m0 194h40000v40H0z\\nM0 50 h400000 v40H0z m0 194h40000v40H0z\",\n  midbrace: \"M200428 334\\nc-100.7-8.3-195.3-44-280-108-55.3-42-101.7-93-139-153l-9-14c-2.7 4-5.7 8.7-9 14\\n-53.3 86.7-123.7 153-211 199-66.7 36-137.3 56.3-212 62H0V214h199568c178.3-11.7\\n 311.7-78.3 403-201 6-8 9.7-12 11-12 .7-.7 6.7-1 18-1s17.3.3 18 1c1.3 0 5 4 11\\n 12 44.7 59.3 101.3 106.3 170 141s145.3 54.3 229 60h199572v120z\",\n  midbraceunder: \"M199572 214\\nc100.7 8.3 195.3 44 280 108 55.3 42 101.7 93 139 153l9 14c2.7-4 5.7-8.7 9-14\\n 53.3-86.7 123.7-153 211-199 66.7-36 137.3-56.3 212-62h199568v120H200432c-178.3\\n 11.7-311.7 78.3-403 201-6 8-9.7 12-11 12-.7.7-6.7 1-18 1s-17.3-.3-18-1c-1.3 0\\n-5-4-11-12-44.7-59.3-101.3-106.3-170-141s-145.3-54.3-229-60H0V214z\",\n  oiintSize1: \"M512.6 71.6c272.6 0 320.3 106.8 320.3 178.2 0 70.8-47.7 177.6\\n-320.3 177.6S193.1 320.6 193.1 249.8c0-71.4 46.9-178.2 319.5-178.2z\\nm368.1 178.2c0-86.4-60.9-215.4-368.1-215.4-306.4 0-367.3 129-367.3 215.4 0 85.8\\n60.9 214.8 367.3 214.8 307.2 0 368.1-129 368.1-214.8z\",\n  oiintSize2: \"M757.8 100.1c384.7 0 451.1 137.6 451.1 230 0 91.3-66.4 228.8\\n-451.1 228.8-386.3 0-452.7-137.5-452.7-228.8 0-92.4 66.4-230 452.7-230z\\nm502.4 230c0-111.2-82.4-277.2-502.4-277.2s-504 166-504 277.2\\nc0 110 84 276 504 276s502.4-166 502.4-276z\",\n  oiiintSize1: \"M681.4 71.6c408.9 0 480.5 106.8 480.5 178.2 0 70.8-71.6 177.6\\n-480.5 177.6S202.1 320.6 202.1 249.8c0-71.4 70.5-178.2 479.3-178.2z\\nm525.8 178.2c0-86.4-86.8-215.4-525.7-215.4-437.9 0-524.7 129-524.7 215.4 0\\n85.8 86.8 214.8 524.7 214.8 438.9 0 525.7-129 525.7-214.8z\",\n  oiiintSize2: \"M1021.2 53c603.6 0 707.8 165.8 707.8 277.2 0 110-104.2 275.8\\n-707.8 275.8-606 0-710.2-165.8-710.2-275.8C311 218.8 415.2 53 1021.2 53z\\nm770.4 277.1c0-131.2-126.4-327.6-770.5-327.6S248.4 198.9 248.4 330.1\\nc0 130 128.8 326.4 772.7 326.4s770.5-196.4 770.5-326.4z\",\n  rightarrow: \"M0 241v40h399891c-47.3 35.3-84 78-110 128\\n-16.7 32-27.7 63.7-33 95 0 1.3-.2 2.7-.5 4-.3 1.3-.5 2.3-.5 3 0 7.3 6.7 11 20\\n 11 8 0 13.2-.8 15.5-2.5 2.3-1.7 4.2-5.5 5.5-11.5 2-13.3 5.7-27 11-41 14.7-44.7\\n 39-84.5 73-119.5s73.7-60.2 119-75.5c6-2 9-5.7 9-11s-3-9-9-11c-45.3-15.3-85\\n-40.5-119-75.5s-58.3-74.8-73-119.5c-4.7-14-8.3-27.3-11-40-1.3-6.7-3.2-10.8-5.5\\n-12.5-2.3-1.7-7.5-2.5-15.5-2.5-14 0-21 3.7-21 11 0 2 2 10.3 6 25 20.7 83.3 67\\n 151.7 139 205zm0 0v40h399900v-40z\",\n  rightbrace: \"M400000 542l\\n-6 6h-17c-12.7 0-19.3-.3-20-1-4-4-7.3-8.3-10-13-35.3-51.3-80.8-93.8-136.5-127.5\\ns-117.2-55.8-184.5-66.5c-.7 0-2-.3-4-1-18.7-2.7-76-4.3-172-5H0V214h399571l6 1\\nc124.7 8 235 61.7 331 161 31.3 33.3 59.7 72.7 85 118l7 13v35z\",\n  rightbraceunder: \"M399994 0l6 6v35l-6 11c-56 104-135.3 181.3-238 232-57.3\\n 28.7-117 45-179 50H-300V214h399897c43.3-7 81-15 113-26 100.7-33 179.7-91 237\\n-174 2.7-5 6-9 10-13 .7-1 7.3-1 20-1h17z\",\n  rightgroup: \"M0 80h399565c371 0 266.7 149.4 414 180 5.9 1.2 18 0 18 0 2 0\\n 3-1 3-3v-38c-76-158-257-219-435-219H0z\",\n  rightgroupunder: \"M0 262h399565c371 0 266.7-149.4 414-180 5.9-1.2 18 0 18\\n 0 2 0 3 1 3 3v38c-76 158-257 219-435 219H0z\",\n  rightharpoon: \"M0 241v40h399993c4.7-4.7 7-9.3 7-14 0-9.3\\n-3.7-15.3-11-18-92.7-56.7-159-133.7-199-231-3.3-9.3-6-14.7-8-16-2-1.3-7-2-15-2\\n-10.7 0-16.7 2-18 6-2 2.7-1 9.7 3 21 15.3 42 36.7 81.8 64 119.5 27.3 37.7 58\\n 69.2 92 94.5zm0 0v40h399900v-40z\",\n  rightharpoonplus: \"M0 241v40h399993c4.7-4.7 7-9.3 7-14 0-9.3-3.7-15.3-11\\n-18-92.7-56.7-159-133.7-199-231-3.3-9.3-6-14.7-8-16-2-1.3-7-2-15-2-10.7 0-16.7\\n 2-18 6-2 2.7-1 9.7 3 21 15.3 42 36.7 81.8 64 119.5 27.3 37.7 58 69.2 92 94.5z\\nm0 0v40h399900v-40z m100 194v40h399900v-40zm0 0v40h399900v-40z\",\n  rightharpoondown: \"M399747 511c0 7.3 6.7 11 20 11 8 0 13-.8 15-2.5s4.7-6.8\\n 8-15.5c40-94 99.3-166.3 178-217 13.3-8 20.3-12.3 21-13 5.3-3.3 8.5-5.8 9.5\\n-7.5 1-1.7 1.5-5.2 1.5-10.5s-2.3-10.3-7-15H0v40h399908c-34 25.3-64.7 57-92 95\\n-27.3 38-48.7 77.7-64 119-3.3 8.7-5 14-5 16zM0 241v40h399900v-40z\",\n  rightharpoondownplus: \"M399747 705c0 7.3 6.7 11 20 11 8 0 13-.8\\n 15-2.5s4.7-6.8 8-15.5c40-94 99.3-166.3 178-217 13.3-8 20.3-12.3 21-13 5.3-3.3\\n 8.5-5.8 9.5-7.5 1-1.7 1.5-5.2 1.5-10.5s-2.3-10.3-7-15H0v40h399908c-34 25.3\\n-64.7 57-92 95-27.3 38-48.7 77.7-64 119-3.3 8.7-5 14-5 16zM0 435v40h399900v-40z\\nm0-194v40h400000v-40zm0 0v40h400000v-40z\",\n  righthook: \"M399859 241c-764 0 0 0 0 0 40-3.3 68.7-15.7 86-37 10-12 15-25.3\\n 15-40 0-22.7-9.8-40.7-29.5-54-19.7-13.3-43.5-21-71.5-23-17.3-1.3-26-8-26-20 0\\n-13.3 8.7-20 26-20 38 0 71 11.2 99 33.5 0 0 7 5.6 21 16.7 14 11.2 21 33.5 21\\n 66.8s-14 61.2-42 83.5c-28 22.3-61 33.5-99 33.5L0 241z M0 281v-40h399859v40z\",\n  rightlinesegment: \"M399960 241 V94 h40 V428 h-40 V281 H0 v-40z\\nM399960 241 V94 h40 V428 h-40 V281 H0 v-40z\",\n  rightToFrom: \"M400000 167c-70.7-42-118-97.7-142-167h-23c-15.3 0-23 .3-23\\n 1 0 1.3 5.3 13.7 16 37 18 35.3 41.3 69 70 101l7 8H0v40h399905l-7 8c-28.7 32\\n-52 65.7-70 101-10.7 23.3-16 35.7-16 37 0 .7 7.7 1 23 1h23c24-69.3 71.3-125 142\\n-167z M100 147v40h399900v-40zM0 341v40h399900v-40z\",\n  // twoheadleftarrow is from glyph U+219E in font KaTeX AMS Regular\n  twoheadleftarrow: \"M0 167c68 40\\n 115.7 95.7 143 167h22c15.3 0 23-.3 23-1 0-1.3-5.3-13.7-16-37-18-35.3-41.3-69\\n-70-101l-7-8h125l9 7c50.7 39.3 85 86 103 140h46c0-4.7-6.3-18.7-19-42-18-35.3\\n-40-67.3-66-96l-9-9h399716v-40H284l9-9c26-28.7 48-60.7 66-96 12.7-23.333 19\\n-37.333 19-42h-46c-18 54-52.3 100.7-103 140l-9 7H95l7-8c28.7-32 52-65.7 70-101\\n 10.7-23.333 16-35.7 16-37 0-.7-7.7-1-23-1h-22C115.7 71.3 68 127 0 167z\",\n  twoheadrightarrow: \"M400000 167\\nc-68-40-115.7-95.7-143-167h-22c-15.3 0-23 .3-23 1 0 1.3 5.3 13.7 16 37 18 35.3\\n 41.3 69 70 101l7 8h-125l-9-7c-50.7-39.3-85-86-103-140h-46c0 4.7 6.3 18.7 19 42\\n 18 35.3 40 67.3 66 96l9 9H0v40h399716l-9 9c-26 28.7-48 60.7-66 96-12.7 23.333\\n-19 37.333-19 42h46c18-54 52.3-100.7 103-140l9-7h125l-7 8c-28.7 32-52 65.7-70\\n 101-10.7 23.333-16 35.7-16 37 0 .7 7.7 1 23 1h22c27.3-71.3 75-127 143-167z\",\n  // tilde1 is a modified version of a glyph from the MnSymbol package\n  tilde1: \"M200 55.538c-77 0-168 73.953-177 73.953-3 0-7\\n-2.175-9-5.437L2 97c-1-2-2-4-2-6 0-4 2-7 5-9l20-12C116 12 171 0 207 0c86 0\\n 114 68 191 68 78 0 168-68 177-68 4 0 7 2 9 5l12 19c1 2.175 2 4.35 2 6.525 0\\n 4.35-2 7.613-5 9.788l-19 13.05c-92 63.077-116.937 75.308-183 76.128\\n-68.267.847-113-73.952-191-73.952z\",\n  // ditto tilde2, tilde3, & tilde4\n  tilde2: \"M344 55.266c-142 0-300.638 81.316-311.5 86.418\\n-8.01 3.762-22.5 10.91-23.5 5.562L1 120c-1-2-1-3-1-4 0-5 3-9 8-10l18.4-9C160.9\\n 31.9 283 0 358 0c148 0 188 122 331 122s314-97 326-97c4 0 8 2 10 7l7 21.114\\nc1 2.14 1 3.21 1 4.28 0 5.347-3 9.626-7 10.696l-22.3 12.622C852.6 158.372 751\\n 181.476 676 181.476c-149 0-189-126.21-332-126.21z\",\n  tilde3: \"M786 59C457 59 32 175.242 13 175.242c-6 0-10-3.457\\n-11-10.37L.15 138c-1-7 3-12 10-13l19.2-6.4C378.4 40.7 634.3 0 804.3 0c337 0\\n 411.8 157 746.8 157 328 0 754-112 773-112 5 0 10 3 11 9l1 14.075c1 8.066-.697\\n 16.595-6.697 17.492l-21.052 7.31c-367.9 98.146-609.15 122.696-778.15 122.696\\n -338 0-409-156.573-744-156.573z\",\n  tilde4: \"M786 58C457 58 32 177.487 13 177.487c-6 0-10-3.345\\n-11-10.035L.15 143c-1-7 3-12 10-13l22-6.7C381.2 35 637.15 0 807.15 0c337 0 409\\n 177 744 177 328 0 754-127 773-127 5 0 10 3 11 9l1 14.794c1 7.805-3 13.38-9\\n 14.495l-20.7 5.574c-366.85 99.79-607.3 139.372-776.3 139.372-338 0-409\\n -175.236-744-175.236z\",\n  // vec is from glyph U+20D7 in font KaTeX Main\n  vec: \"M377 20c0-5.333 1.833-10 5.5-14S391 0 397 0c4.667 0 8.667 1.667 12 5\\n3.333 2.667 6.667 9 10 19 6.667 24.667 20.333 43.667 41 57 7.333 4.667 11\\n10.667 11 18 0 6-1 10-3 12s-6.667 5-14 9c-28.667 14.667-53.667 35.667-75 63\\n-1.333 1.333-3.167 3.5-5.5 6.5s-4 4.833-5 5.5c-1 .667-2.5 1.333-4.5 2s-4.333 1\\n-7 1c-4.667 0-9.167-1.833-13.5-5.5S337 184 337 178c0-12.667 15.667-32.333 47-59\\nH213l-171-1c-8.667-6-13-12.333-13-19 0-4.667 4.333-11.333 13-20h359\\nc-16-25.333-24-45-24-59z\",\n  // widehat1 is a modified version of a glyph from the MnSymbol package\n  widehat1: \"M529 0h5l519 115c5 1 9 5 9 10 0 1-1 2-1 3l-4 22\\nc-1 5-5 9-11 9h-2L532 67 19 159h-2c-5 0-9-4-11-9l-5-22c-1-6 2-12 8-13z\",\n  // ditto widehat2, widehat3, & widehat4\n  widehat2: \"M1181 0h2l1171 176c6 0 10 5 10 11l-2 23c-1 6-5 10\\n-11 10h-1L1182 67 15 220h-1c-6 0-10-4-11-10l-2-23c-1-6 4-11 10-11z\",\n  widehat3: \"M1181 0h2l1171 236c6 0 10 5 10 11l-2 23c-1 6-5 10\\n-11 10h-1L1182 67 15 280h-1c-6 0-10-4-11-10l-2-23c-1-6 4-11 10-11z\",\n  widehat4: \"M1181 0h2l1171 296c6 0 10 5 10 11l-2 23c-1 6-5 10\\n-11 10h-1L1182 67 15 340h-1c-6 0-10-4-11-10l-2-23c-1-6 4-11 10-11z\",\n  // widecheck paths are all inverted versions of widehat\n  widecheck1: \"M529,159h5l519,-115c5,-1,9,-5,9,-10c0,-1,-1,-2,-1,-3l-4,-22c-1,\\n-5,-5,-9,-11,-9h-2l-512,92l-513,-92h-2c-5,0,-9,4,-11,9l-5,22c-1,6,2,12,8,13z\",\n  widecheck2: \"M1181,220h2l1171,-176c6,0,10,-5,10,-11l-2,-23c-1,-6,-5,-10,\\n-11,-10h-1l-1168,153l-1167,-153h-1c-6,0,-10,4,-11,10l-2,23c-1,6,4,11,10,11z\",\n  widecheck3: \"M1181,280h2l1171,-236c6,0,10,-5,10,-11l-2,-23c-1,-6,-5,-10,\\n-11,-10h-1l-1168,213l-1167,-213h-1c-6,0,-10,4,-11,10l-2,23c-1,6,4,11,10,11z\",\n  widecheck4: \"M1181,340h2l1171,-296c6,0,10,-5,10,-11l-2,-23c-1,-6,-5,-10,\\n-11,-10h-1l-1168,273l-1167,-273h-1c-6,0,-10,4,-11,10l-2,23c-1,6,4,11,10,11z\",\n  // The next ten paths support reaction arrows from the mhchem package.\n  // Arrows for \\ce{<-->} are offset from xAxis by 0.22ex, per mhchem in LaTeX\n  // baraboveleftarrow is mostly from glyph U+2190 in font KaTeX Main\n  baraboveleftarrow: \"M400000 620h-399890l3 -3c68.7 -52.7 113.7 -120 135 -202\\nc4 -14.7 6 -23 6 -25c0 -7.3 -7 -11 -21 -11c-8 0 -13.2 0.8 -15.5 2.5\\nc-2.3 1.7 -4.2 5.8 -5.5 12.5c-1.3 4.7 -2.7 10.3 -4 17c-12 48.7 -34.8 92 -68.5 130\\ns-74.2 66.3 -121.5 85c-10 4 -16 7.7 -18 11c0 8.7 6 14.3 18 17c47.3 18.7 87.8 47\\n121.5 85s56.5 81.3 68.5 130c0.7 2 1.3 5 2 9s1.2 6.7 1.5 8c0.3 1.3 1 3.3 2 6\\ns2.2 4.5 3.5 5.5c1.3 1 3.3 1.8 6 2.5s6 1 10 1c14 0 21 -3.7 21 -11\\nc0 -2 -2 -10.3 -6 -25c-20 -79.3 -65 -146.7 -135 -202l-3 -3h399890z\\nM100 620v40h399900v-40z M0 241v40h399900v-40zM0 241v40h399900v-40z\",\n  // rightarrowabovebar is mostly from glyph U+2192, KaTeX Main\n  rightarrowabovebar: \"M0 241v40h399891c-47.3 35.3-84 78-110 128-16.7 32\\n-27.7 63.7-33 95 0 1.3-.2 2.7-.5 4-.3 1.3-.5 2.3-.5 3 0 7.3 6.7 11 20 11 8 0\\n13.2-.8 15.5-2.5 2.3-1.7 4.2-5.5 5.5-11.5 2-13.3 5.7-27 11-41 14.7-44.7 39\\n-84.5 73-119.5s73.7-60.2 119-75.5c6-2 9-5.7 9-11s-3-9-9-11c-45.3-15.3-85-40.5\\n-119-75.5s-58.3-74.8-73-119.5c-4.7-14-8.3-27.3-11-40-1.3-6.7-3.2-10.8-5.5\\n-12.5-2.3-1.7-7.5-2.5-15.5-2.5-14 0-21 3.7-21 11 0 2 2 10.3 6 25 20.7 83.3 67\\n151.7 139 205zm96 379h399894v40H0zm0 0h399904v40H0z\",\n  // The short left harpoon has 0.5em (i.e. 500 units) kern on the left end.\n  // Ref from mhchem.sty: \\rlap{\\raisebox{-.22ex}{$\\kern0.5em\n  baraboveshortleftharpoon: \"M507,435c-4,4,-6.3,8.7,-7,14c0,5.3,0.7,9,2,11\\nc1.3,2,5.3,5.3,12,10c90.7,54,156,130,196,228c3.3,10.7,6.3,16.3,9,17\\nc2,0.7,5,1,9,1c0,0,5,0,5,0c10.7,0,16.7,-2,18,-6c2,-2.7,1,-9.7,-3,-21\\nc-32,-87.3,-82.7,-157.7,-152,-211c0,0,-3,-3,-3,-3l399351,0l0,-40\\nc-398570,0,-399437,0,-399437,0z M593 435 v40 H399500 v-40z\\nM0 281 v-40 H399908 v40z M0 281 v-40 H399908 v40z\",\n  rightharpoonaboveshortbar: \"M0,241 l0,40c399126,0,399993,0,399993,0\\nc4.7,-4.7,7,-9.3,7,-14c0,-9.3,-3.7,-15.3,-11,-18c-92.7,-56.7,-159,-133.7,-199,\\n-231c-3.3,-9.3,-6,-14.7,-8,-16c-2,-1.3,-7,-2,-15,-2c-10.7,0,-16.7,2,-18,6\\nc-2,2.7,-1,9.7,3,21c15.3,42,36.7,81.8,64,119.5c27.3,37.7,58,69.2,92,94.5z\\nM0 241 v40 H399908 v-40z M0 475 v-40 H399500 v40z M0 475 v-40 H399500 v40z\",\n  shortbaraboveleftharpoon: \"M7,435c-4,4,-6.3,8.7,-7,14c0,5.3,0.7,9,2,11\\nc1.3,2,5.3,5.3,12,10c90.7,54,156,130,196,228c3.3,10.7,6.3,16.3,9,17c2,0.7,5,1,9,\\n1c0,0,5,0,5,0c10.7,0,16.7,-2,18,-6c2,-2.7,1,-9.7,-3,-21c-32,-87.3,-82.7,-157.7,\\n-152,-211c0,0,-3,-3,-3,-3l399907,0l0,-40c-399126,0,-399993,0,-399993,0z\\nM93 435 v40 H400000 v-40z M500 241 v40 H400000 v-40z M500 241 v40 H400000 v-40z\",\n  shortrightharpoonabovebar: \"M53,241l0,40c398570,0,399437,0,399437,0\\nc4.7,-4.7,7,-9.3,7,-14c0,-9.3,-3.7,-15.3,-11,-18c-92.7,-56.7,-159,-133.7,-199,\\n-231c-3.3,-9.3,-6,-14.7,-8,-16c-2,-1.3,-7,-2,-15,-2c-10.7,0,-16.7,2,-18,6\\nc-2,2.7,-1,9.7,3,21c15.3,42,36.7,81.8,64,119.5c27.3,37.7,58,69.2,92,94.5z\\nM500 241 v40 H399408 v-40z M500 435 v40 H400000 v-40z\"\n};\nvar tallDelim = function tallDelim(label, midHeight) {\n  switch (label) {\n    case \"lbrack\":\n      return \"M403 1759 V84 H666 V0 H319 V1759 v\" + midHeight + \" v1759 h347 v-84\\nH403z M403 1759 V0 H319 V1759 v\" + midHeight + \" v1759 h84z\";\n\n    case \"rbrack\":\n      return \"M347 1759 V0 H0 V84 H263 V1759 v\" + midHeight + \" v1759 H0 v84 H347z\\nM347 1759 V0 H263 V1759 v\" + midHeight + \" v1759 h84z\";\n\n    case \"vert\":\n      return \"M145 15 v585 v\" + midHeight + \" v585 c2.667,10,9.667,15,21,15\\nc10,0,16.667,-5,20,-15 v-585 v\" + -midHeight + \" v-585 c-2.667,-10,-9.667,-15,-21,-15\\nc-10,0,-16.667,5,-20,15z M188 15 H145 v585 v\" + midHeight + \" v585 h43z\";\n\n    case \"doublevert\":\n      return \"M145 15 v585 v\" + midHeight + \" v585 c2.667,10,9.667,15,21,15\\nc10,0,16.667,-5,20,-15 v-585 v\" + -midHeight + \" v-585 c-2.667,-10,-9.667,-15,-21,-15\\nc-10,0,-16.667,5,-20,15z M188 15 H145 v585 v\" + midHeight + \" v585 h43z\\nM367 15 v585 v\" + midHeight + \" v585 c2.667,10,9.667,15,21,15\\nc10,0,16.667,-5,20,-15 v-585 v\" + -midHeight + \" v-585 c-2.667,-10,-9.667,-15,-21,-15\\nc-10,0,-16.667,5,-20,15z M410 15 H367 v585 v\" + midHeight + \" v585 h43z\";\n\n    case \"lfloor\":\n      return \"M319 602 V0 H403 V602 v\" + midHeight + \" v1715 h263 v84 H319z\\nMM319 602 V0 H403 V602 v\" + midHeight + \" v1715 H319z\";\n\n    case \"rfloor\":\n      return \"M319 602 V0 H403 V602 v\" + midHeight + \" v1799 H0 v-84 H319z\\nMM319 602 V0 H403 V602 v\" + midHeight + \" v1715 H319z\";\n\n    case \"lceil\":\n      return \"M403 1759 V84 H666 V0 H319 V1759 v\" + midHeight + \" v602 h84z\\nM403 1759 V0 H319 V1759 v\" + midHeight + \" v602 h84z\";\n\n    case \"rceil\":\n      return \"M347 1759 V0 H0 V84 H263 V1759 v\" + midHeight + \" v602 h84z\\nM347 1759 V0 h-84 V1759 v\" + midHeight + \" v602 h84z\";\n\n    case \"lparen\":\n      return \"M863,9c0,-2,-2,-5,-6,-9c0,0,-17,0,-17,0c-12.7,0,-19.3,0.3,-20,1\\nc-5.3,5.3,-10.3,11,-15,17c-242.7,294.7,-395.3,682,-458,1162c-21.3,163.3,-33.3,349,\\n-36,557 l0,\" + (midHeight + 84) + \"c0.2,6,0,26,0,60c2,159.3,10,310.7,24,454c53.3,528,210,\\n949.7,470,1265c4.7,6,9.7,11.7,15,17c0.7,0.7,7,1,19,1c0,0,18,0,18,0c4,-4,6,-7,6,-9\\nc0,-2.7,-3.3,-8.7,-10,-18c-135.3,-192.7,-235.5,-414.3,-300.5,-665c-65,-250.7,-102.5,\\n-544.7,-112.5,-882c-2,-104,-3,-167,-3,-189\\nl0,-\" + (midHeight + 92) + \"c0,-162.7,5.7,-314,17,-454c20.7,-272,63.7,-513,129,-723c65.3,\\n-210,155.3,-396.3,270,-559c6.7,-9.3,10,-15.3,10,-18z\";\n\n    case \"rparen\":\n      return \"M76,0c-16.7,0,-25,3,-25,9c0,2,2,6.3,6,13c21.3,28.7,42.3,60.3,\\n63,95c96.7,156.7,172.8,332.5,228.5,527.5c55.7,195,92.8,416.5,111.5,664.5\\nc11.3,139.3,17,290.7,17,454c0,28,1.7,43,3.3,45l0,\" + (midHeight + 9) + \"\\nc-3,4,-3.3,16.7,-3.3,38c0,162,-5.7,313.7,-17,455c-18.7,248,-55.8,469.3,-111.5,664\\nc-55.7,194.7,-131.8,370.3,-228.5,527c-20.7,34.7,-41.7,66.3,-63,95c-2,3.3,-4,7,-6,11\\nc0,7.3,5.7,11,17,11c0,0,11,0,11,0c9.3,0,14.3,-0.3,15,-1c5.3,-5.3,10.3,-11,15,-17\\nc242.7,-294.7,395.3,-681.7,458,-1161c21.3,-164.7,33.3,-350.7,36,-558\\nl0,-\" + (midHeight + 144) + \"c-2,-159.3,-10,-310.7,-24,-454c-53.3,-528,-210,-949.7,\\n-470,-1265c-4.7,-6,-9.7,-11.7,-15,-17c-0.7,-0.7,-6.7,-1,-18,-1z\";\n\n    default:\n      // We should not ever get here.\n      throw new Error(\"Unknown stretchy delimiter.\");\n  }\n};\n\n/**\n * This node represents a document fragment, which contains elements, but when\n * placed into the DOM doesn't have any representation itself. It only contains\n * children and doesn't have any DOM node properties.\n */\nclass DocumentFragment {\n  // HtmlDomNode\n  // Never used; needed for satisfying interface.\n  constructor(children) {\n    this.children = void 0;\n    this.classes = void 0;\n    this.height = void 0;\n    this.depth = void 0;\n    this.maxFontSize = void 0;\n    this.style = void 0;\n    this.children = children;\n    this.classes = [];\n    this.height = 0;\n    this.depth = 0;\n    this.maxFontSize = 0;\n    this.style = {};\n  }\n\n  hasClass(className) {\n    return utils.contains(this.classes, className);\n  }\n  /** Convert the fragment into a node. */\n\n\n  toNode() {\n    var frag = document.createDocumentFragment();\n\n    for (var i = 0; i < this.children.length; i++) {\n      frag.appendChild(this.children[i].toNode());\n    }\n\n    return frag;\n  }\n  /** Convert the fragment into HTML markup. */\n\n\n  toMarkup() {\n    var markup = \"\"; // Simply concatenate the markup for the children together.\n\n    for (var i = 0; i < this.children.length; i++) {\n      markup += this.children[i].toMarkup();\n    }\n\n    return markup;\n  }\n  /**\n   * Converts the math node into a string, similar to innerText. Applies to\n   * MathDomNode's only.\n   */\n\n\n  toText() {\n    // To avoid this, we would subclass documentFragment separately for\n    // MathML, but polyfills for subclassing is expensive per PR 1469.\n    // $FlowFixMe: Only works for ChildType = MathDomNode.\n    var toText = child => child.toText();\n\n    return this.children.map(toText).join(\"\");\n  }\n\n}\n\n// This file is GENERATED by buildMetrics.sh. DO NOT MODIFY.\nvar fontMetricsData = {\n  \"AMS-Regular\": {\n    \"32\": [0, 0, 0, 0, 0.25],\n    \"65\": [0, 0.68889, 0, 0, 0.72222],\n    \"66\": [0, 0.68889, 0, 0, 0.66667],\n    \"67\": [0, 0.68889, 0, 0, 0.72222],\n    \"68\": [0, 0.68889, 0, 0, 0.72222],\n    \"69\": [0, 0.68889, 0, 0, 0.66667],\n    \"70\": [0, 0.68889, 0, 0, 0.61111],\n    \"71\": [0, 0.68889, 0, 0, 0.77778],\n    \"72\": [0, 0.68889, 0, 0, 0.77778],\n    \"73\": [0, 0.68889, 0, 0, 0.38889],\n    \"74\": [0.16667, 0.68889, 0, 0, 0.5],\n    \"75\": [0, 0.68889, 0, 0, 0.77778],\n    \"76\": [0, 0.68889, 0, 0, 0.66667],\n    \"77\": [0, 0.68889, 0, 0, 0.94445],\n    \"78\": [0, 0.68889, 0, 0, 0.72222],\n    \"79\": [0.16667, 0.68889, 0, 0, 0.77778],\n    \"80\": [0, 0.68889, 0, 0, 0.61111],\n    \"81\": [0.16667, 0.68889, 0, 0, 0.77778],\n    \"82\": [0, 0.68889, 0, 0, 0.72222],\n    \"83\": [0, 0.68889, 0, 0, 0.55556],\n    \"84\": [0, 0.68889, 0, 0, 0.66667],\n    \"85\": [0, 0.68889, 0, 0, 0.72222],\n    \"86\": [0, 0.68889, 0, 0, 0.72222],\n    \"87\": [0, 0.68889, 0, 0, 1.0],\n    \"88\": [0, 0.68889, 0, 0, 0.72222],\n    \"89\": [0, 0.68889, 0, 0, 0.72222],\n    \"90\": [0, 0.68889, 0, 0, 0.66667],\n    \"107\": [0, 0.68889, 0, 0, 0.55556],\n    \"160\": [0, 0, 0, 0, 0.25],\n    \"165\": [0, 0.675, 0.025, 0, 0.75],\n    \"174\": [0.15559, 0.69224, 0, 0, 0.94666],\n    \"240\": [0, 0.68889, 0, 0, 0.55556],\n    \"295\": [0, 0.68889, 0, 0, 0.54028],\n    \"710\": [0, 0.825, 0, 0, 2.33334],\n    \"732\": [0, 0.9, 0, 0, 2.33334],\n    \"770\": [0, 0.825, 0, 0, 2.33334],\n    \"771\": [0, 0.9, 0, 0, 2.33334],\n    \"989\": [0.08167, 0.58167, 0, 0, 0.77778],\n    \"1008\": [0, 0.43056, 0.04028, 0, 0.66667],\n    \"8245\": [0, 0.54986, 0, 0, 0.275],\n    \"8463\": [0, 0.68889, 0, 0, 0.54028],\n    \"8487\": [0, 0.68889, 0, 0, 0.72222],\n    \"8498\": [0, 0.68889, 0, 0, 0.55556],\n    \"8502\": [0, 0.68889, 0, 0, 0.66667],\n    \"8503\": [0, 0.68889, 0, 0, 0.44445],\n    \"8504\": [0, 0.68889, 0, 0, 0.66667],\n    \"8513\": [0, 0.68889, 0, 0, 0.63889],\n    \"8592\": [-0.03598, 0.46402, 0, 0, 0.5],\n    \"8594\": [-0.03598, 0.46402, 0, 0, 0.5],\n    \"8602\": [-0.13313, 0.36687, 0, 0, 1.0],\n    \"8603\": [-0.13313, 0.36687, 0, 0, 1.0],\n    \"8606\": [0.01354, 0.52239, 0, 0, 1.0],\n    \"8608\": [0.01354, 0.52239, 0, 0, 1.0],\n    \"8610\": [0.01354, 0.52239, 0, 0, 1.11111],\n    \"8611\": [0.01354, 0.52239, 0, 0, 1.11111],\n    \"8619\": [0, 0.54986, 0, 0, 1.0],\n    \"8620\": [0, 0.54986, 0, 0, 1.0],\n    \"8621\": [-0.13313, 0.37788, 0, 0, 1.38889],\n    \"8622\": [-0.13313, 0.36687, 0, 0, 1.0],\n    \"8624\": [0, 0.69224, 0, 0, 0.5],\n    \"8625\": [0, 0.69224, 0, 0, 0.5],\n    \"8630\": [0, 0.43056, 0, 0, 1.0],\n    \"8631\": [0, 0.43056, 0, 0, 1.0],\n    \"8634\": [0.08198, 0.58198, 0, 0, 0.77778],\n    \"8635\": [0.08198, 0.58198, 0, 0, 0.77778],\n    \"8638\": [0.19444, 0.69224, 0, 0, 0.41667],\n    \"8639\": [0.19444, 0.69224, 0, 0, 0.41667],\n    \"8642\": [0.19444, 0.69224, 0, 0, 0.41667],\n    \"8643\": [0.19444, 0.69224, 0, 0, 0.41667],\n    \"8644\": [0.1808, 0.675, 0, 0, 1.0],\n    \"8646\": [0.1808, 0.675, 0, 0, 1.0],\n    \"8647\": [0.1808, 0.675, 0, 0, 1.0],\n    \"8648\": [0.19444, 0.69224, 0, 0, 0.83334],\n    \"8649\": [0.1808, 0.675, 0, 0, 1.0],\n    \"8650\": [0.19444, 0.69224, 0, 0, 0.83334],\n    \"8651\": [0.01354, 0.52239, 0, 0, 1.0],\n    \"8652\": [0.01354, 0.52239, 0, 0, 1.0],\n    \"8653\": [-0.13313, 0.36687, 0, 0, 1.0],\n    \"8654\": [-0.13313, 0.36687, 0, 0, 1.0],\n    \"8655\": [-0.13313, 0.36687, 0, 0, 1.0],\n    \"8666\": [0.13667, 0.63667, 0, 0, 1.0],\n    \"8667\": [0.13667, 0.63667, 0, 0, 1.0],\n    \"8669\": [-0.13313, 0.37788, 0, 0, 1.0],\n    \"8672\": [-0.064, 0.437, 0, 0, 1.334],\n    \"8674\": [-0.064, 0.437, 0, 0, 1.334],\n    \"8705\": [0, 0.825, 0, 0, 0.5],\n    \"8708\": [0, 0.68889, 0, 0, 0.55556],\n    \"8709\": [0.08167, 0.58167, 0, 0, 0.77778],\n    \"8717\": [0, 0.43056, 0, 0, 0.42917],\n    \"8722\": [-0.03598, 0.46402, 0, 0, 0.5],\n    \"8724\": [0.08198, 0.69224, 0, 0, 0.77778],\n    \"8726\": [0.08167, 0.58167, 0, 0, 0.77778],\n    \"8733\": [0, 0.69224, 0, 0, 0.77778],\n    \"8736\": [0, 0.69224, 0, 0, 0.72222],\n    \"8737\": [0, 0.69224, 0, 0, 0.72222],\n    \"8738\": [0.03517, 0.52239, 0, 0, 0.72222],\n    \"8739\": [0.08167, 0.58167, 0, 0, 0.22222],\n    \"8740\": [0.25142, 0.74111, 0, 0, 0.27778],\n    \"8741\": [0.08167, 0.58167, 0, 0, 0.38889],\n    \"8742\": [0.25142, 0.74111, 0, 0, 0.5],\n    \"8756\": [0, 0.69224, 0, 0, 0.66667],\n    \"8757\": [0, 0.69224, 0, 0, 0.66667],\n    \"8764\": [-0.13313, 0.36687, 0, 0, 0.77778],\n    \"8765\": [-0.13313, 0.37788, 0, 0, 0.77778],\n    \"8769\": [-0.13313, 0.36687, 0, 0, 0.77778],\n    \"8770\": [-0.03625, 0.46375, 0, 0, 0.77778],\n    \"8774\": [0.30274, 0.79383, 0, 0, 0.77778],\n    \"8776\": [-0.01688, 0.48312, 0, 0, 0.77778],\n    \"8778\": [0.08167, 0.58167, 0, 0, 0.77778],\n    \"8782\": [0.06062, 0.54986, 0, 0, 0.77778],\n    \"8783\": [0.06062, 0.54986, 0, 0, 0.77778],\n    \"8785\": [0.08198, 0.58198, 0, 0, 0.77778],\n    \"8786\": [0.08198, 0.58198, 0, 0, 0.77778],\n    \"8787\": [0.08198, 0.58198, 0, 0, 0.77778],\n    \"8790\": [0, 0.69224, 0, 0, 0.77778],\n    \"8791\": [0.22958, 0.72958, 0, 0, 0.77778],\n    \"8796\": [0.08198, 0.91667, 0, 0, 0.77778],\n    \"8806\": [0.25583, 0.75583, 0, 0, 0.77778],\n    \"8807\": [0.25583, 0.75583, 0, 0, 0.77778],\n    \"8808\": [0.25142, 0.75726, 0, 0, 0.77778],\n    \"8809\": [0.25142, 0.75726, 0, 0, 0.77778],\n    \"8812\": [0.25583, 0.75583, 0, 0, 0.5],\n    \"8814\": [0.20576, 0.70576, 0, 0, 0.77778],\n    \"8815\": [0.20576, 0.70576, 0, 0, 0.77778],\n    \"8816\": [0.30274, 0.79383, 0, 0, 0.77778],\n    \"8817\": [0.30274, 0.79383, 0, 0, 0.77778],\n    \"8818\": [0.22958, 0.72958, 0, 0, 0.77778],\n    \"8819\": [0.22958, 0.72958, 0, 0, 0.77778],\n    \"8822\": [0.1808, 0.675, 0, 0, 0.77778],\n    \"8823\": [0.1808, 0.675, 0, 0, 0.77778],\n    \"8828\": [0.13667, 0.63667, 0, 0, 0.77778],\n    \"8829\": [0.13667, 0.63667, 0, 0, 0.77778],\n    \"8830\": [0.22958, 0.72958, 0, 0, 0.77778],\n    \"8831\": [0.22958, 0.72958, 0, 0, 0.77778],\n    \"8832\": [0.20576, 0.70576, 0, 0, 0.77778],\n    \"8833\": [0.20576, 0.70576, 0, 0, 0.77778],\n    \"8840\": [0.30274, 0.79383, 0, 0, 0.77778],\n    \"8841\": [0.30274, 0.79383, 0, 0, 0.77778],\n    \"8842\": [0.13597, 0.63597, 0, 0, 0.77778],\n    \"8843\": [0.13597, 0.63597, 0, 0, 0.77778],\n    \"8847\": [0.03517, 0.54986, 0, 0, 0.77778],\n    \"8848\": [0.03517, 0.54986, 0, 0, 0.77778],\n    \"8858\": [0.08198, 0.58198, 0, 0, 0.77778],\n    \"8859\": [0.08198, 0.58198, 0, 0, 0.77778],\n    \"8861\": [0.08198, 0.58198, 0, 0, 0.77778],\n    \"8862\": [0, 0.675, 0, 0, 0.77778],\n    \"8863\": [0, 0.675, 0, 0, 0.77778],\n    \"8864\": [0, 0.675, 0, 0, 0.77778],\n    \"8865\": [0, 0.675, 0, 0, 0.77778],\n    \"8872\": [0, 0.69224, 0, 0, 0.61111],\n    \"8873\": [0, 0.69224, 0, 0, 0.72222],\n    \"8874\": [0, 0.69224, 0, 0, 0.88889],\n    \"8876\": [0, 0.68889, 0, 0, 0.61111],\n    \"8877\": [0, 0.68889, 0, 0, 0.61111],\n    \"8878\": [0, 0.68889, 0, 0, 0.72222],\n    \"8879\": [0, 0.68889, 0, 0, 0.72222],\n    \"8882\": [0.03517, 0.54986, 0, 0, 0.77778],\n    \"8883\": [0.03517, 0.54986, 0, 0, 0.77778],\n    \"8884\": [0.13667, 0.63667, 0, 0, 0.77778],\n    \"8885\": [0.13667, 0.63667, 0, 0, 0.77778],\n    \"8888\": [0, 0.54986, 0, 0, 1.11111],\n    \"8890\": [0.19444, 0.43056, 0, 0, 0.55556],\n    \"8891\": [0.19444, 0.69224, 0, 0, 0.61111],\n    \"8892\": [0.19444, 0.69224, 0, 0, 0.61111],\n    \"8901\": [0, 0.54986, 0, 0, 0.27778],\n    \"8903\": [0.08167, 0.58167, 0, 0, 0.77778],\n    \"8905\": [0.08167, 0.58167, 0, 0, 0.77778],\n    \"8906\": [0.08167, 0.58167, 0, 0, 0.77778],\n    \"8907\": [0, 0.69224, 0, 0, 0.77778],\n    \"8908\": [0, 0.69224, 0, 0, 0.77778],\n    \"8909\": [-0.03598, 0.46402, 0, 0, 0.77778],\n    \"8910\": [0, 0.54986, 0, 0, 0.76042],\n    \"8911\": [0, 0.54986, 0, 0, 0.76042],\n    \"8912\": [0.03517, 0.54986, 0, 0, 0.77778],\n    \"8913\": [0.03517, 0.54986, 0, 0, 0.77778],\n    \"8914\": [0, 0.54986, 0, 0, 0.66667],\n    \"8915\": [0, 0.54986, 0, 0, 0.66667],\n    \"8916\": [0, 0.69224, 0, 0, 0.66667],\n    \"8918\": [0.0391, 0.5391, 0, 0, 0.77778],\n    \"8919\": [0.0391, 0.5391, 0, 0, 0.77778],\n    \"8920\": [0.03517, 0.54986, 0, 0, 1.33334],\n    \"8921\": [0.03517, 0.54986, 0, 0, 1.33334],\n    \"8922\": [0.38569, 0.88569, 0, 0, 0.77778],\n    \"8923\": [0.38569, 0.88569, 0, 0, 0.77778],\n    \"8926\": [0.13667, 0.63667, 0, 0, 0.77778],\n    \"8927\": [0.13667, 0.63667, 0, 0, 0.77778],\n    \"8928\": [0.30274, 0.79383, 0, 0, 0.77778],\n    \"8929\": [0.30274, 0.79383, 0, 0, 0.77778],\n    \"8934\": [0.23222, 0.74111, 0, 0, 0.77778],\n    \"8935\": [0.23222, 0.74111, 0, 0, 0.77778],\n    \"8936\": [0.23222, 0.74111, 0, 0, 0.77778],\n    \"8937\": [0.23222, 0.74111, 0, 0, 0.77778],\n    \"8938\": [0.20576, 0.70576, 0, 0, 0.77778],\n    \"8939\": [0.20576, 0.70576, 0, 0, 0.77778],\n    \"8940\": [0.30274, 0.79383, 0, 0, 0.77778],\n    \"8941\": [0.30274, 0.79383, 0, 0, 0.77778],\n    \"8994\": [0.19444, 0.69224, 0, 0, 0.77778],\n    \"8995\": [0.19444, 0.69224, 0, 0, 0.77778],\n    \"9416\": [0.15559, 0.69224, 0, 0, 0.90222],\n    \"9484\": [0, 0.69224, 0, 0, 0.5],\n    \"9488\": [0, 0.69224, 0, 0, 0.5],\n    \"9492\": [0, 0.37788, 0, 0, 0.5],\n    \"9496\": [0, 0.37788, 0, 0, 0.5],\n    \"9585\": [0.19444, 0.68889, 0, 0, 0.88889],\n    \"9586\": [0.19444, 0.74111, 0, 0, 0.88889],\n    \"9632\": [0, 0.675, 0, 0, 0.77778],\n    \"9633\": [0, 0.675, 0, 0, 0.77778],\n    \"9650\": [0, 0.54986, 0, 0, 0.72222],\n    \"9651\": [0, 0.54986, 0, 0, 0.72222],\n    \"9654\": [0.03517, 0.54986, 0, 0, 0.77778],\n    \"9660\": [0, 0.54986, 0, 0, 0.72222],\n    \"9661\": [0, 0.54986, 0, 0, 0.72222],\n    \"9664\": [0.03517, 0.54986, 0, 0, 0.77778],\n    \"9674\": [0.11111, 0.69224, 0, 0, 0.66667],\n    \"9733\": [0.19444, 0.69224, 0, 0, 0.94445],\n    \"10003\": [0, 0.69224, 0, 0, 0.83334],\n    \"10016\": [0, 0.69224, 0, 0, 0.83334],\n    \"10731\": [0.11111, 0.69224, 0, 0, 0.66667],\n    \"10846\": [0.19444, 0.75583, 0, 0, 0.61111],\n    \"10877\": [0.13667, 0.63667, 0, 0, 0.77778],\n    \"10878\": [0.13667, 0.63667, 0, 0, 0.77778],\n    \"10885\": [0.25583, 0.75583, 0, 0, 0.77778],\n    \"10886\": [0.25583, 0.75583, 0, 0, 0.77778],\n    \"10887\": [0.13597, 0.63597, 0, 0, 0.77778],\n    \"10888\": [0.13597, 0.63597, 0, 0, 0.77778],\n    \"10889\": [0.26167, 0.75726, 0, 0, 0.77778],\n    \"10890\": [0.26167, 0.75726, 0, 0, 0.77778],\n    \"10891\": [0.48256, 0.98256, 0, 0, 0.77778],\n    \"10892\": [0.48256, 0.98256, 0, 0, 0.77778],\n    \"10901\": [0.13667, 0.63667, 0, 0, 0.77778],\n    \"10902\": [0.13667, 0.63667, 0, 0, 0.77778],\n    \"10933\": [0.25142, 0.75726, 0, 0, 0.77778],\n    \"10934\": [0.25142, 0.75726, 0, 0, 0.77778],\n    \"10935\": [0.26167, 0.75726, 0, 0, 0.77778],\n    \"10936\": [0.26167, 0.75726, 0, 0, 0.77778],\n    \"10937\": [0.26167, 0.75726, 0, 0, 0.77778],\n    \"10938\": [0.26167, 0.75726, 0, 0, 0.77778],\n    \"10949\": [0.25583, 0.75583, 0, 0, 0.77778],\n    \"10950\": [0.25583, 0.75583, 0, 0, 0.77778],\n    \"10955\": [0.28481, 0.79383, 0, 0, 0.77778],\n    \"10956\": [0.28481, 0.79383, 0, 0, 0.77778],\n    \"57350\": [0.08167, 0.58167, 0, 0, 0.22222],\n    \"57351\": [0.08167, 0.58167, 0, 0, 0.38889],\n    \"57352\": [0.08167, 0.58167, 0, 0, 0.77778],\n    \"57353\": [0, 0.43056, 0.04028, 0, 0.66667],\n    \"57356\": [0.25142, 0.75726, 0, 0, 0.77778],\n    \"57357\": [0.25142, 0.75726, 0, 0, 0.77778],\n    \"57358\": [0.41951, 0.91951, 0, 0, 0.77778],\n    \"57359\": [0.30274, 0.79383, 0, 0, 0.77778],\n    \"57360\": [0.30274, 0.79383, 0, 0, 0.77778],\n    \"57361\": [0.41951, 0.91951, 0, 0, 0.77778],\n    \"57366\": [0.25142, 0.75726, 0, 0, 0.77778],\n    \"57367\": [0.25142, 0.75726, 0, 0, 0.77778],\n    \"57368\": [0.25142, 0.75726, 0, 0, 0.77778],\n    \"57369\": [0.25142, 0.75726, 0, 0, 0.77778],\n    \"57370\": [0.13597, 0.63597, 0, 0, 0.77778],\n    \"57371\": [0.13597, 0.63597, 0, 0, 0.77778]\n  },\n  \"Caligraphic-Regular\": {\n    \"32\": [0, 0, 0, 0, 0.25],\n    \"65\": [0, 0.68333, 0, 0.19445, 0.79847],\n    \"66\": [0, 0.68333, 0.03041, 0.13889, 0.65681],\n    \"67\": [0, 0.68333, 0.05834, 0.13889, 0.52653],\n    \"68\": [0, 0.68333, 0.02778, 0.08334, 0.77139],\n    \"69\": [0, 0.68333, 0.08944, 0.11111, 0.52778],\n    \"70\": [0, 0.68333, 0.09931, 0.11111, 0.71875],\n    \"71\": [0.09722, 0.68333, 0.0593, 0.11111, 0.59487],\n    \"72\": [0, 0.68333, 0.00965, 0.11111, 0.84452],\n    \"73\": [0, 0.68333, 0.07382, 0, 0.54452],\n    \"74\": [0.09722, 0.68333, 0.18472, 0.16667, 0.67778],\n    \"75\": [0, 0.68333, 0.01445, 0.05556, 0.76195],\n    \"76\": [0, 0.68333, 0, 0.13889, 0.68972],\n    \"77\": [0, 0.68333, 0, 0.13889, 1.2009],\n    \"78\": [0, 0.68333, 0.14736, 0.08334, 0.82049],\n    \"79\": [0, 0.68333, 0.02778, 0.11111, 0.79611],\n    \"80\": [0, 0.68333, 0.08222, 0.08334, 0.69556],\n    \"81\": [0.09722, 0.68333, 0, 0.11111, 0.81667],\n    \"82\": [0, 0.68333, 0, 0.08334, 0.8475],\n    \"83\": [0, 0.68333, 0.075, 0.13889, 0.60556],\n    \"84\": [0, 0.68333, 0.25417, 0, 0.54464],\n    \"85\": [0, 0.68333, 0.09931, 0.08334, 0.62583],\n    \"86\": [0, 0.68333, 0.08222, 0, 0.61278],\n    \"87\": [0, 0.68333, 0.08222, 0.08334, 0.98778],\n    \"88\": [0, 0.68333, 0.14643, 0.13889, 0.7133],\n    \"89\": [0.09722, 0.68333, 0.08222, 0.08334, 0.66834],\n    \"90\": [0, 0.68333, 0.07944, 0.13889, 0.72473],\n    \"160\": [0, 0, 0, 0, 0.25]\n  },\n  \"Fraktur-Regular\": {\n    \"32\": [0, 0, 0, 0, 0.25],\n    \"33\": [0, 0.69141, 0, 0, 0.29574],\n    \"34\": [0, 0.69141, 0, 0, 0.21471],\n    \"38\": [0, 0.69141, 0, 0, 0.73786],\n    \"39\": [0, 0.69141, 0, 0, 0.21201],\n    \"40\": [0.24982, 0.74947, 0, 0, 0.38865],\n    \"41\": [0.24982, 0.74947, 0, 0, 0.38865],\n    \"42\": [0, 0.62119, 0, 0, 0.27764],\n    \"43\": [0.08319, 0.58283, 0, 0, 0.75623],\n    \"44\": [0, 0.10803, 0, 0, 0.27764],\n    \"45\": [0.08319, 0.58283, 0, 0, 0.75623],\n    \"46\": [0, 0.10803, 0, 0, 0.27764],\n    \"47\": [0.24982, 0.74947, 0, 0, 0.50181],\n    \"48\": [0, 0.47534, 0, 0, 0.50181],\n    \"49\": [0, 0.47534, 0, 0, 0.50181],\n    \"50\": [0, 0.47534, 0, 0, 0.50181],\n    \"51\": [0.18906, 0.47534, 0, 0, 0.50181],\n    \"52\": [0.18906, 0.47534, 0, 0, 0.50181],\n    \"53\": [0.18906, 0.47534, 0, 0, 0.50181],\n    \"54\": [0, 0.69141, 0, 0, 0.50181],\n    \"55\": [0.18906, 0.47534, 0, 0, 0.50181],\n    \"56\": [0, 0.69141, 0, 0, 0.50181],\n    \"57\": [0.18906, 0.47534, 0, 0, 0.50181],\n    \"58\": [0, 0.47534, 0, 0, 0.21606],\n    \"59\": [0.12604, 0.47534, 0, 0, 0.21606],\n    \"61\": [-0.13099, 0.36866, 0, 0, 0.75623],\n    \"63\": [0, 0.69141, 0, 0, 0.36245],\n    \"65\": [0, 0.69141, 0, 0, 0.7176],\n    \"66\": [0, 0.69141, 0, 0, 0.88397],\n    \"67\": [0, 0.69141, 0, 0, 0.61254],\n    \"68\": [0, 0.69141, 0, 0, 0.83158],\n    \"69\": [0, 0.69141, 0, 0, 0.66278],\n    \"70\": [0.12604, 0.69141, 0, 0, 0.61119],\n    \"71\": [0, 0.69141, 0, 0, 0.78539],\n    \"72\": [0.06302, 0.69141, 0, 0, 0.7203],\n    \"73\": [0, 0.69141, 0, 0, 0.55448],\n    \"74\": [0.12604, 0.69141, 0, 0, 0.55231],\n    \"75\": [0, 0.69141, 0, 0, 0.66845],\n    \"76\": [0, 0.69141, 0, 0, 0.66602],\n    \"77\": [0, 0.69141, 0, 0, 1.04953],\n    \"78\": [0, 0.69141, 0, 0, 0.83212],\n    \"79\": [0, 0.69141, 0, 0, 0.82699],\n    \"80\": [0.18906, 0.69141, 0, 0, 0.82753],\n    \"81\": [0.03781, 0.69141, 0, 0, 0.82699],\n    \"82\": [0, 0.69141, 0, 0, 0.82807],\n    \"83\": [0, 0.69141, 0, 0, 0.82861],\n    \"84\": [0, 0.69141, 0, 0, 0.66899],\n    \"85\": [0, 0.69141, 0, 0, 0.64576],\n    \"86\": [0, 0.69141, 0, 0, 0.83131],\n    \"87\": [0, 0.69141, 0, 0, 1.04602],\n    \"88\": [0, 0.69141, 0, 0, 0.71922],\n    \"89\": [0.18906, 0.69141, 0, 0, 0.83293],\n    \"90\": [0.12604, 0.69141, 0, 0, 0.60201],\n    \"91\": [0.24982, 0.74947, 0, 0, 0.27764],\n    \"93\": [0.24982, 0.74947, 0, 0, 0.27764],\n    \"94\": [0, 0.69141, 0, 0, 0.49965],\n    \"97\": [0, 0.47534, 0, 0, 0.50046],\n    \"98\": [0, 0.69141, 0, 0, 0.51315],\n    \"99\": [0, 0.47534, 0, 0, 0.38946],\n    \"100\": [0, 0.62119, 0, 0, 0.49857],\n    \"101\": [0, 0.47534, 0, 0, 0.40053],\n    \"102\": [0.18906, 0.69141, 0, 0, 0.32626],\n    \"103\": [0.18906, 0.47534, 0, 0, 0.5037],\n    \"104\": [0.18906, 0.69141, 0, 0, 0.52126],\n    \"105\": [0, 0.69141, 0, 0, 0.27899],\n    \"106\": [0, 0.69141, 0, 0, 0.28088],\n    \"107\": [0, 0.69141, 0, 0, 0.38946],\n    \"108\": [0, 0.69141, 0, 0, 0.27953],\n    \"109\": [0, 0.47534, 0, 0, 0.76676],\n    \"110\": [0, 0.47534, 0, 0, 0.52666],\n    \"111\": [0, 0.47534, 0, 0, 0.48885],\n    \"112\": [0.18906, 0.52396, 0, 0, 0.50046],\n    \"113\": [0.18906, 0.47534, 0, 0, 0.48912],\n    \"114\": [0, 0.47534, 0, 0, 0.38919],\n    \"115\": [0, 0.47534, 0, 0, 0.44266],\n    \"116\": [0, 0.62119, 0, 0, 0.33301],\n    \"117\": [0, 0.47534, 0, 0, 0.5172],\n    \"118\": [0, 0.52396, 0, 0, 0.5118],\n    \"119\": [0, 0.52396, 0, 0, 0.77351],\n    \"120\": [0.18906, 0.47534, 0, 0, 0.38865],\n    \"121\": [0.18906, 0.47534, 0, 0, 0.49884],\n    \"122\": [0.18906, 0.47534, 0, 0, 0.39054],\n    \"160\": [0, 0, 0, 0, 0.25],\n    \"8216\": [0, 0.69141, 0, 0, 0.21471],\n    \"8217\": [0, 0.69141, 0, 0, 0.21471],\n    \"58112\": [0, 0.62119, 0, 0, 0.49749],\n    \"58113\": [0, 0.62119, 0, 0, 0.4983],\n    \"58114\": [0.18906, 0.69141, 0, 0, 0.33328],\n    \"58115\": [0.18906, 0.69141, 0, 0, 0.32923],\n    \"58116\": [0.18906, 0.47534, 0, 0, 0.50343],\n    \"58117\": [0, 0.69141, 0, 0, 0.33301],\n    \"58118\": [0, 0.62119, 0, 0, 0.33409],\n    \"58119\": [0, 0.47534, 0, 0, 0.50073]\n  },\n  \"Main-Bold\": {\n    \"32\": [0, 0, 0, 0, 0.25],\n    \"33\": [0, 0.69444, 0, 0, 0.35],\n    \"34\": [0, 0.69444, 0, 0, 0.60278],\n    \"35\": [0.19444, 0.69444, 0, 0, 0.95833],\n    \"36\": [0.05556, 0.75, 0, 0, 0.575],\n    \"37\": [0.05556, 0.75, 0, 0, 0.95833],\n    \"38\": [0, 0.69444, 0, 0, 0.89444],\n    \"39\": [0, 0.69444, 0, 0, 0.31944],\n    \"40\": [0.25, 0.75, 0, 0, 0.44722],\n    \"41\": [0.25, 0.75, 0, 0, 0.44722],\n    \"42\": [0, 0.75, 0, 0, 0.575],\n    \"43\": [0.13333, 0.63333, 0, 0, 0.89444],\n    \"44\": [0.19444, 0.15556, 0, 0, 0.31944],\n    \"45\": [0, 0.44444, 0, 0, 0.38333],\n    \"46\": [0, 0.15556, 0, 0, 0.31944],\n    \"47\": [0.25, 0.75, 0, 0, 0.575],\n    \"48\": [0, 0.64444, 0, 0, 0.575],\n    \"49\": [0, 0.64444, 0, 0, 0.575],\n    \"50\": [0, 0.64444, 0, 0, 0.575],\n    \"51\": [0, 0.64444, 0, 0, 0.575],\n    \"52\": [0, 0.64444, 0, 0, 0.575],\n    \"53\": [0, 0.64444, 0, 0, 0.575],\n    \"54\": [0, 0.64444, 0, 0, 0.575],\n    \"55\": [0, 0.64444, 0, 0, 0.575],\n    \"56\": [0, 0.64444, 0, 0, 0.575],\n    \"57\": [0, 0.64444, 0, 0, 0.575],\n    \"58\": [0, 0.44444, 0, 0, 0.31944],\n    \"59\": [0.19444, 0.44444, 0, 0, 0.31944],\n    \"60\": [0.08556, 0.58556, 0, 0, 0.89444],\n    \"61\": [-0.10889, 0.39111, 0, 0, 0.89444],\n    \"62\": [0.08556, 0.58556, 0, 0, 0.89444],\n    \"63\": [0, 0.69444, 0, 0, 0.54305],\n    \"64\": [0, 0.69444, 0, 0, 0.89444],\n    \"65\": [0, 0.68611, 0, 0, 0.86944],\n    \"66\": [0, 0.68611, 0, 0, 0.81805],\n    \"67\": [0, 0.68611, 0, 0, 0.83055],\n    \"68\": [0, 0.68611, 0, 0, 0.88194],\n    \"69\": [0, 0.68611, 0, 0, 0.75555],\n    \"70\": [0, 0.68611, 0, 0, 0.72361],\n    \"71\": [0, 0.68611, 0, 0, 0.90416],\n    \"72\": [0, 0.68611, 0, 0, 0.9],\n    \"73\": [0, 0.68611, 0, 0, 0.43611],\n    \"74\": [0, 0.68611, 0, 0, 0.59444],\n    \"75\": [0, 0.68611, 0, 0, 0.90138],\n    \"76\": [0, 0.68611, 0, 0, 0.69166],\n    \"77\": [0, 0.68611, 0, 0, 1.09166],\n    \"78\": [0, 0.68611, 0, 0, 0.9],\n    \"79\": [0, 0.68611, 0, 0, 0.86388],\n    \"80\": [0, 0.68611, 0, 0, 0.78611],\n    \"81\": [0.19444, 0.68611, 0, 0, 0.86388],\n    \"82\": [0, 0.68611, 0, 0, 0.8625],\n    \"83\": [0, 0.68611, 0, 0, 0.63889],\n    \"84\": [0, 0.68611, 0, 0, 0.8],\n    \"85\": [0, 0.68611, 0, 0, 0.88472],\n    \"86\": [0, 0.68611, 0.01597, 0, 0.86944],\n    \"87\": [0, 0.68611, 0.01597, 0, 1.18888],\n    \"88\": [0, 0.68611, 0, 0, 0.86944],\n    \"89\": [0, 0.68611, 0.02875, 0, 0.86944],\n    \"90\": [0, 0.68611, 0, 0, 0.70277],\n    \"91\": [0.25, 0.75, 0, 0, 0.31944],\n    \"92\": [0.25, 0.75, 0, 0, 0.575],\n    \"93\": [0.25, 0.75, 0, 0, 0.31944],\n    \"94\": [0, 0.69444, 0, 0, 0.575],\n    \"95\": [0.31, 0.13444, 0.03194, 0, 0.575],\n    \"97\": [0, 0.44444, 0, 0, 0.55902],\n    \"98\": [0, 0.69444, 0, 0, 0.63889],\n    \"99\": [0, 0.44444, 0, 0, 0.51111],\n    \"100\": [0, 0.69444, 0, 0, 0.63889],\n    \"101\": [0, 0.44444, 0, 0, 0.52708],\n    \"102\": [0, 0.69444, 0.10903, 0, 0.35139],\n    \"103\": [0.19444, 0.44444, 0.01597, 0, 0.575],\n    \"104\": [0, 0.69444, 0, 0, 0.63889],\n    \"105\": [0, 0.69444, 0, 0, 0.31944],\n    \"106\": [0.19444, 0.69444, 0, 0, 0.35139],\n    \"107\": [0, 0.69444, 0, 0, 0.60694],\n    \"108\": [0, 0.69444, 0, 0, 0.31944],\n    \"109\": [0, 0.44444, 0, 0, 0.95833],\n    \"110\": [0, 0.44444, 0, 0, 0.63889],\n    \"111\": [0, 0.44444, 0, 0, 0.575],\n    \"112\": [0.19444, 0.44444, 0, 0, 0.63889],\n    \"113\": [0.19444, 0.44444, 0, 0, 0.60694],\n    \"114\": [0, 0.44444, 0, 0, 0.47361],\n    \"115\": [0, 0.44444, 0, 0, 0.45361],\n    \"116\": [0, 0.63492, 0, 0, 0.44722],\n    \"117\": [0, 0.44444, 0, 0, 0.63889],\n    \"118\": [0, 0.44444, 0.01597, 0, 0.60694],\n    \"119\": [0, 0.44444, 0.01597, 0, 0.83055],\n    \"120\": [0, 0.44444, 0, 0, 0.60694],\n    \"121\": [0.19444, 0.44444, 0.01597, 0, 0.60694],\n    \"122\": [0, 0.44444, 0, 0, 0.51111],\n    \"123\": [0.25, 0.75, 0, 0, 0.575],\n    \"124\": [0.25, 0.75, 0, 0, 0.31944],\n    \"125\": [0.25, 0.75, 0, 0, 0.575],\n    \"126\": [0.35, 0.34444, 0, 0, 0.575],\n    \"160\": [0, 0, 0, 0, 0.25],\n    \"163\": [0, 0.69444, 0, 0, 0.86853],\n    \"168\": [0, 0.69444, 0, 0, 0.575],\n    \"172\": [0, 0.44444, 0, 0, 0.76666],\n    \"176\": [0, 0.69444, 0, 0, 0.86944],\n    \"177\": [0.13333, 0.63333, 0, 0, 0.89444],\n    \"184\": [0.17014, 0, 0, 0, 0.51111],\n    \"198\": [0, 0.68611, 0, 0, 1.04166],\n    \"215\": [0.13333, 0.63333, 0, 0, 0.89444],\n    \"216\": [0.04861, 0.73472, 0, 0, 0.89444],\n    \"223\": [0, 0.69444, 0, 0, 0.59722],\n    \"230\": [0, 0.44444, 0, 0, 0.83055],\n    \"247\": [0.13333, 0.63333, 0, 0, 0.89444],\n    \"248\": [0.09722, 0.54167, 0, 0, 0.575],\n    \"305\": [0, 0.44444, 0, 0, 0.31944],\n    \"338\": [0, 0.68611, 0, 0, 1.16944],\n    \"339\": [0, 0.44444, 0, 0, 0.89444],\n    \"567\": [0.19444, 0.44444, 0, 0, 0.35139],\n    \"710\": [0, 0.69444, 0, 0, 0.575],\n    \"711\": [0, 0.63194, 0, 0, 0.575],\n    \"713\": [0, 0.59611, 0, 0, 0.575],\n    \"714\": [0, 0.69444, 0, 0, 0.575],\n    \"715\": [0, 0.69444, 0, 0, 0.575],\n    \"728\": [0, 0.69444, 0, 0, 0.575],\n    \"729\": [0, 0.69444, 0, 0, 0.31944],\n    \"730\": [0, 0.69444, 0, 0, 0.86944],\n    \"732\": [0, 0.69444, 0, 0, 0.575],\n    \"733\": [0, 0.69444, 0, 0, 0.575],\n    \"915\": [0, 0.68611, 0, 0, 0.69166],\n    \"916\": [0, 0.68611, 0, 0, 0.95833],\n    \"920\": [0, 0.68611, 0, 0, 0.89444],\n    \"923\": [0, 0.68611, 0, 0, 0.80555],\n    \"926\": [0, 0.68611, 0, 0, 0.76666],\n    \"928\": [0, 0.68611, 0, 0, 0.9],\n    \"931\": [0, 0.68611, 0, 0, 0.83055],\n    \"933\": [0, 0.68611, 0, 0, 0.89444],\n    \"934\": [0, 0.68611, 0, 0, 0.83055],\n    \"936\": [0, 0.68611, 0, 0, 0.89444],\n    \"937\": [0, 0.68611, 0, 0, 0.83055],\n    \"8211\": [0, 0.44444, 0.03194, 0, 0.575],\n    \"8212\": [0, 0.44444, 0.03194, 0, 1.14999],\n    \"8216\": [0, 0.69444, 0, 0, 0.31944],\n    \"8217\": [0, 0.69444, 0, 0, 0.31944],\n    \"8220\": [0, 0.69444, 0, 0, 0.60278],\n    \"8221\": [0, 0.69444, 0, 0, 0.60278],\n    \"8224\": [0.19444, 0.69444, 0, 0, 0.51111],\n    \"8225\": [0.19444, 0.69444, 0, 0, 0.51111],\n    \"8242\": [0, 0.55556, 0, 0, 0.34444],\n    \"8407\": [0, 0.72444, 0.15486, 0, 0.575],\n    \"8463\": [0, 0.69444, 0, 0, 0.66759],\n    \"8465\": [0, 0.69444, 0, 0, 0.83055],\n    \"8467\": [0, 0.69444, 0, 0, 0.47361],\n    \"8472\": [0.19444, 0.44444, 0, 0, 0.74027],\n    \"8476\": [0, 0.69444, 0, 0, 0.83055],\n    \"8501\": [0, 0.69444, 0, 0, 0.70277],\n    \"8592\": [-0.10889, 0.39111, 0, 0, 1.14999],\n    \"8593\": [0.19444, 0.69444, 0, 0, 0.575],\n    \"8594\": [-0.10889, 0.39111, 0, 0, 1.14999],\n    \"8595\": [0.19444, 0.69444, 0, 0, 0.575],\n    \"8596\": [-0.10889, 0.39111, 0, 0, 1.14999],\n    \"8597\": [0.25, 0.75, 0, 0, 0.575],\n    \"8598\": [0.19444, 0.69444, 0, 0, 1.14999],\n    \"8599\": [0.19444, 0.69444, 0, 0, 1.14999],\n    \"8600\": [0.19444, 0.69444, 0, 0, 1.14999],\n    \"8601\": [0.19444, 0.69444, 0, 0, 1.14999],\n    \"8636\": [-0.10889, 0.39111, 0, 0, 1.14999],\n    \"8637\": [-0.10889, 0.39111, 0, 0, 1.14999],\n    \"8640\": [-0.10889, 0.39111, 0, 0, 1.14999],\n    \"8641\": [-0.10889, 0.39111, 0, 0, 1.14999],\n    \"8656\": [-0.10889, 0.39111, 0, 0, 1.14999],\n    \"8657\": [0.19444, 0.69444, 0, 0, 0.70277],\n    \"8658\": [-0.10889, 0.39111, 0, 0, 1.14999],\n    \"8659\": [0.19444, 0.69444, 0, 0, 0.70277],\n    \"8660\": [-0.10889, 0.39111, 0, 0, 1.14999],\n    \"8661\": [0.25, 0.75, 0, 0, 0.70277],\n    \"8704\": [0, 0.69444, 0, 0, 0.63889],\n    \"8706\": [0, 0.69444, 0.06389, 0, 0.62847],\n    \"8707\": [0, 0.69444, 0, 0, 0.63889],\n    \"8709\": [0.05556, 0.75, 0, 0, 0.575],\n    \"8711\": [0, 0.68611, 0, 0, 0.95833],\n    \"8712\": [0.08556, 0.58556, 0, 0, 0.76666],\n    \"8715\": [0.08556, 0.58556, 0, 0, 0.76666],\n    \"8722\": [0.13333, 0.63333, 0, 0, 0.89444],\n    \"8723\": [0.13333, 0.63333, 0, 0, 0.89444],\n    \"8725\": [0.25, 0.75, 0, 0, 0.575],\n    \"8726\": [0.25, 0.75, 0, 0, 0.575],\n    \"8727\": [-0.02778, 0.47222, 0, 0, 0.575],\n    \"8728\": [-0.02639, 0.47361, 0, 0, 0.575],\n    \"8729\": [-0.02639, 0.47361, 0, 0, 0.575],\n    \"8730\": [0.18, 0.82, 0, 0, 0.95833],\n    \"8733\": [0, 0.44444, 0, 0, 0.89444],\n    \"8734\": [0, 0.44444, 0, 0, 1.14999],\n    \"8736\": [0, 0.69224, 0, 0, 0.72222],\n    \"8739\": [0.25, 0.75, 0, 0, 0.31944],\n    \"8741\": [0.25, 0.75, 0, 0, 0.575],\n    \"8743\": [0, 0.55556, 0, 0, 0.76666],\n    \"8744\": [0, 0.55556, 0, 0, 0.76666],\n    \"8745\": [0, 0.55556, 0, 0, 0.76666],\n    \"8746\": [0, 0.55556, 0, 0, 0.76666],\n    \"8747\": [0.19444, 0.69444, 0.12778, 0, 0.56875],\n    \"8764\": [-0.10889, 0.39111, 0, 0, 0.89444],\n    \"8768\": [0.19444, 0.69444, 0, 0, 0.31944],\n    \"8771\": [0.00222, 0.50222, 0, 0, 0.89444],\n    \"8773\": [0.027, 0.638, 0, 0, 0.894],\n    \"8776\": [0.02444, 0.52444, 0, 0, 0.89444],\n    \"8781\": [0.00222, 0.50222, 0, 0, 0.89444],\n    \"8801\": [0.00222, 0.50222, 0, 0, 0.89444],\n    \"8804\": [0.19667, 0.69667, 0, 0, 0.89444],\n    \"8805\": [0.19667, 0.69667, 0, 0, 0.89444],\n    \"8810\": [0.08556, 0.58556, 0, 0, 1.14999],\n    \"8811\": [0.08556, 0.58556, 0, 0, 1.14999],\n    \"8826\": [0.08556, 0.58556, 0, 0, 0.89444],\n    \"8827\": [0.08556, 0.58556, 0, 0, 0.89444],\n    \"8834\": [0.08556, 0.58556, 0, 0, 0.89444],\n    \"8835\": [0.08556, 0.58556, 0, 0, 0.89444],\n    \"8838\": [0.19667, 0.69667, 0, 0, 0.89444],\n    \"8839\": [0.19667, 0.69667, 0, 0, 0.89444],\n    \"8846\": [0, 0.55556, 0, 0, 0.76666],\n    \"8849\": [0.19667, 0.69667, 0, 0, 0.89444],\n    \"8850\": [0.19667, 0.69667, 0, 0, 0.89444],\n    \"8851\": [0, 0.55556, 0, 0, 0.76666],\n    \"8852\": [0, 0.55556, 0, 0, 0.76666],\n    \"8853\": [0.13333, 0.63333, 0, 0, 0.89444],\n    \"8854\": [0.13333, 0.63333, 0, 0, 0.89444],\n    \"8855\": [0.13333, 0.63333, 0, 0, 0.89444],\n    \"8856\": [0.13333, 0.63333, 0, 0, 0.89444],\n    \"8857\": [0.13333, 0.63333, 0, 0, 0.89444],\n    \"8866\": [0, 0.69444, 0, 0, 0.70277],\n    \"8867\": [0, 0.69444, 0, 0, 0.70277],\n    \"8868\": [0, 0.69444, 0, 0, 0.89444],\n    \"8869\": [0, 0.69444, 0, 0, 0.89444],\n    \"8900\": [-0.02639, 0.47361, 0, 0, 0.575],\n    \"8901\": [-0.02639, 0.47361, 0, 0, 0.31944],\n    \"8902\": [-0.02778, 0.47222, 0, 0, 0.575],\n    \"8968\": [0.25, 0.75, 0, 0, 0.51111],\n    \"8969\": [0.25, 0.75, 0, 0, 0.51111],\n    \"8970\": [0.25, 0.75, 0, 0, 0.51111],\n    \"8971\": [0.25, 0.75, 0, 0, 0.51111],\n    \"8994\": [-0.13889, 0.36111, 0, 0, 1.14999],\n    \"8995\": [-0.13889, 0.36111, 0, 0, 1.14999],\n    \"9651\": [0.19444, 0.69444, 0, 0, 1.02222],\n    \"9657\": [-0.02778, 0.47222, 0, 0, 0.575],\n    \"9661\": [0.19444, 0.69444, 0, 0, 1.02222],\n    \"9667\": [-0.02778, 0.47222, 0, 0, 0.575],\n    \"9711\": [0.19444, 0.69444, 0, 0, 1.14999],\n    \"9824\": [0.12963, 0.69444, 0, 0, 0.89444],\n    \"9825\": [0.12963, 0.69444, 0, 0, 0.89444],\n    \"9826\": [0.12963, 0.69444, 0, 0, 0.89444],\n    \"9827\": [0.12963, 0.69444, 0, 0, 0.89444],\n    \"9837\": [0, 0.75, 0, 0, 0.44722],\n    \"9838\": [0.19444, 0.69444, 0, 0, 0.44722],\n    \"9839\": [0.19444, 0.69444, 0, 0, 0.44722],\n    \"10216\": [0.25, 0.75, 0, 0, 0.44722],\n    \"10217\": [0.25, 0.75, 0, 0, 0.44722],\n    \"10815\": [0, 0.68611, 0, 0, 0.9],\n    \"10927\": [0.19667, 0.69667, 0, 0, 0.89444],\n    \"10928\": [0.19667, 0.69667, 0, 0, 0.89444],\n    \"57376\": [0.19444, 0.69444, 0, 0, 0]\n  },\n  \"Main-BoldItalic\": {\n    \"32\": [0, 0, 0, 0, 0.25],\n    \"33\": [0, 0.69444, 0.11417, 0, 0.38611],\n    \"34\": [0, 0.69444, 0.07939, 0, 0.62055],\n    \"35\": [0.19444, 0.69444, 0.06833, 0, 0.94444],\n    \"37\": [0.05556, 0.75, 0.12861, 0, 0.94444],\n    \"38\": [0, 0.69444, 0.08528, 0, 0.88555],\n    \"39\": [0, 0.69444, 0.12945, 0, 0.35555],\n    \"40\": [0.25, 0.75, 0.15806, 0, 0.47333],\n    \"41\": [0.25, 0.75, 0.03306, 0, 0.47333],\n    \"42\": [0, 0.75, 0.14333, 0, 0.59111],\n    \"43\": [0.10333, 0.60333, 0.03306, 0, 0.88555],\n    \"44\": [0.19444, 0.14722, 0, 0, 0.35555],\n    \"45\": [0, 0.44444, 0.02611, 0, 0.41444],\n    \"46\": [0, 0.14722, 0, 0, 0.35555],\n    \"47\": [0.25, 0.75, 0.15806, 0, 0.59111],\n    \"48\": [0, 0.64444, 0.13167, 0, 0.59111],\n    \"49\": [0, 0.64444, 0.13167, 0, 0.59111],\n    \"50\": [0, 0.64444, 0.13167, 0, 0.59111],\n    \"51\": [0, 0.64444, 0.13167, 0, 0.59111],\n    \"52\": [0.19444, 0.64444, 0.13167, 0, 0.59111],\n    \"53\": [0, 0.64444, 0.13167, 0, 0.59111],\n    \"54\": [0, 0.64444, 0.13167, 0, 0.59111],\n    \"55\": [0.19444, 0.64444, 0.13167, 0, 0.59111],\n    \"56\": [0, 0.64444, 0.13167, 0, 0.59111],\n    \"57\": [0, 0.64444, 0.13167, 0, 0.59111],\n    \"58\": [0, 0.44444, 0.06695, 0, 0.35555],\n    \"59\": [0.19444, 0.44444, 0.06695, 0, 0.35555],\n    \"61\": [-0.10889, 0.39111, 0.06833, 0, 0.88555],\n    \"63\": [0, 0.69444, 0.11472, 0, 0.59111],\n    \"64\": [0, 0.69444, 0.09208, 0, 0.88555],\n    \"65\": [0, 0.68611, 0, 0, 0.86555],\n    \"66\": [0, 0.68611, 0.0992, 0, 0.81666],\n    \"67\": [0, 0.68611, 0.14208, 0, 0.82666],\n    \"68\": [0, 0.68611, 0.09062, 0, 0.87555],\n    \"69\": [0, 0.68611, 0.11431, 0, 0.75666],\n    \"70\": [0, 0.68611, 0.12903, 0, 0.72722],\n    \"71\": [0, 0.68611, 0.07347, 0, 0.89527],\n    \"72\": [0, 0.68611, 0.17208, 0, 0.8961],\n    \"73\": [0, 0.68611, 0.15681, 0, 0.47166],\n    \"74\": [0, 0.68611, 0.145, 0, 0.61055],\n    \"75\": [0, 0.68611, 0.14208, 0, 0.89499],\n    \"76\": [0, 0.68611, 0, 0, 0.69777],\n    \"77\": [0, 0.68611, 0.17208, 0, 1.07277],\n    \"78\": [0, 0.68611, 0.17208, 0, 0.8961],\n    \"79\": [0, 0.68611, 0.09062, 0, 0.85499],\n    \"80\": [0, 0.68611, 0.0992, 0, 0.78721],\n    \"81\": [0.19444, 0.68611, 0.09062, 0, 0.85499],\n    \"82\": [0, 0.68611, 0.02559, 0, 0.85944],\n    \"83\": [0, 0.68611, 0.11264, 0, 0.64999],\n    \"84\": [0, 0.68611, 0.12903, 0, 0.7961],\n    \"85\": [0, 0.68611, 0.17208, 0, 0.88083],\n    \"86\": [0, 0.68611, 0.18625, 0, 0.86555],\n    \"87\": [0, 0.68611, 0.18625, 0, 1.15999],\n    \"88\": [0, 0.68611, 0.15681, 0, 0.86555],\n    \"89\": [0, 0.68611, 0.19803, 0, 0.86555],\n    \"90\": [0, 0.68611, 0.14208, 0, 0.70888],\n    \"91\": [0.25, 0.75, 0.1875, 0, 0.35611],\n    \"93\": [0.25, 0.75, 0.09972, 0, 0.35611],\n    \"94\": [0, 0.69444, 0.06709, 0, 0.59111],\n    \"95\": [0.31, 0.13444, 0.09811, 0, 0.59111],\n    \"97\": [0, 0.44444, 0.09426, 0, 0.59111],\n    \"98\": [0, 0.69444, 0.07861, 0, 0.53222],\n    \"99\": [0, 0.44444, 0.05222, 0, 0.53222],\n    \"100\": [0, 0.69444, 0.10861, 0, 0.59111],\n    \"101\": [0, 0.44444, 0.085, 0, 0.53222],\n    \"102\": [0.19444, 0.69444, 0.21778, 0, 0.4],\n    \"103\": [0.19444, 0.44444, 0.105, 0, 0.53222],\n    \"104\": [0, 0.69444, 0.09426, 0, 0.59111],\n    \"105\": [0, 0.69326, 0.11387, 0, 0.35555],\n    \"106\": [0.19444, 0.69326, 0.1672, 0, 0.35555],\n    \"107\": [0, 0.69444, 0.11111, 0, 0.53222],\n    \"108\": [0, 0.69444, 0.10861, 0, 0.29666],\n    \"109\": [0, 0.44444, 0.09426, 0, 0.94444],\n    \"110\": [0, 0.44444, 0.09426, 0, 0.64999],\n    \"111\": [0, 0.44444, 0.07861, 0, 0.59111],\n    \"112\": [0.19444, 0.44444, 0.07861, 0, 0.59111],\n    \"113\": [0.19444, 0.44444, 0.105, 0, 0.53222],\n    \"114\": [0, 0.44444, 0.11111, 0, 0.50167],\n    \"115\": [0, 0.44444, 0.08167, 0, 0.48694],\n    \"116\": [0, 0.63492, 0.09639, 0, 0.385],\n    \"117\": [0, 0.44444, 0.09426, 0, 0.62055],\n    \"118\": [0, 0.44444, 0.11111, 0, 0.53222],\n    \"119\": [0, 0.44444, 0.11111, 0, 0.76777],\n    \"120\": [0, 0.44444, 0.12583, 0, 0.56055],\n    \"121\": [0.19444, 0.44444, 0.105, 0, 0.56166],\n    \"122\": [0, 0.44444, 0.13889, 0, 0.49055],\n    \"126\": [0.35, 0.34444, 0.11472, 0, 0.59111],\n    \"160\": [0, 0, 0, 0, 0.25],\n    \"168\": [0, 0.69444, 0.11473, 0, 0.59111],\n    \"176\": [0, 0.69444, 0, 0, 0.94888],\n    \"184\": [0.17014, 0, 0, 0, 0.53222],\n    \"198\": [0, 0.68611, 0.11431, 0, 1.02277],\n    \"216\": [0.04861, 0.73472, 0.09062, 0, 0.88555],\n    \"223\": [0.19444, 0.69444, 0.09736, 0, 0.665],\n    \"230\": [0, 0.44444, 0.085, 0, 0.82666],\n    \"248\": [0.09722, 0.54167, 0.09458, 0, 0.59111],\n    \"305\": [0, 0.44444, 0.09426, 0, 0.35555],\n    \"338\": [0, 0.68611, 0.11431, 0, 1.14054],\n    \"339\": [0, 0.44444, 0.085, 0, 0.82666],\n    \"567\": [0.19444, 0.44444, 0.04611, 0, 0.385],\n    \"710\": [0, 0.69444, 0.06709, 0, 0.59111],\n    \"711\": [0, 0.63194, 0.08271, 0, 0.59111],\n    \"713\": [0, 0.59444, 0.10444, 0, 0.59111],\n    \"714\": [0, 0.69444, 0.08528, 0, 0.59111],\n    \"715\": [0, 0.69444, 0, 0, 0.59111],\n    \"728\": [0, 0.69444, 0.10333, 0, 0.59111],\n    \"729\": [0, 0.69444, 0.12945, 0, 0.35555],\n    \"730\": [0, 0.69444, 0, 0, 0.94888],\n    \"732\": [0, 0.69444, 0.11472, 0, 0.59111],\n    \"733\": [0, 0.69444, 0.11472, 0, 0.59111],\n    \"915\": [0, 0.68611, 0.12903, 0, 0.69777],\n    \"916\": [0, 0.68611, 0, 0, 0.94444],\n    \"920\": [0, 0.68611, 0.09062, 0, 0.88555],\n    \"923\": [0, 0.68611, 0, 0, 0.80666],\n    \"926\": [0, 0.68611, 0.15092, 0, 0.76777],\n    \"928\": [0, 0.68611, 0.17208, 0, 0.8961],\n    \"931\": [0, 0.68611, 0.11431, 0, 0.82666],\n    \"933\": [0, 0.68611, 0.10778, 0, 0.88555],\n    \"934\": [0, 0.68611, 0.05632, 0, 0.82666],\n    \"936\": [0, 0.68611, 0.10778, 0, 0.88555],\n    \"937\": [0, 0.68611, 0.0992, 0, 0.82666],\n    \"8211\": [0, 0.44444, 0.09811, 0, 0.59111],\n    \"8212\": [0, 0.44444, 0.09811, 0, 1.18221],\n    \"8216\": [0, 0.69444, 0.12945, 0, 0.35555],\n    \"8217\": [0, 0.69444, 0.12945, 0, 0.35555],\n    \"8220\": [0, 0.69444, 0.16772, 0, 0.62055],\n    \"8221\": [0, 0.69444, 0.07939, 0, 0.62055]\n  },\n  \"Main-Italic\": {\n    \"32\": [0, 0, 0, 0, 0.25],\n    \"33\": [0, 0.69444, 0.12417, 0, 0.30667],\n    \"34\": [0, 0.69444, 0.06961, 0, 0.51444],\n    \"35\": [0.19444, 0.69444, 0.06616, 0, 0.81777],\n    \"37\": [0.05556, 0.75, 0.13639, 0, 0.81777],\n    \"38\": [0, 0.69444, 0.09694, 0, 0.76666],\n    \"39\": [0, 0.69444, 0.12417, 0, 0.30667],\n    \"40\": [0.25, 0.75, 0.16194, 0, 0.40889],\n    \"41\": [0.25, 0.75, 0.03694, 0, 0.40889],\n    \"42\": [0, 0.75, 0.14917, 0, 0.51111],\n    \"43\": [0.05667, 0.56167, 0.03694, 0, 0.76666],\n    \"44\": [0.19444, 0.10556, 0, 0, 0.30667],\n    \"45\": [0, 0.43056, 0.02826, 0, 0.35778],\n    \"46\": [0, 0.10556, 0, 0, 0.30667],\n    \"47\": [0.25, 0.75, 0.16194, 0, 0.51111],\n    \"48\": [0, 0.64444, 0.13556, 0, 0.51111],\n    \"49\": [0, 0.64444, 0.13556, 0, 0.51111],\n    \"50\": [0, 0.64444, 0.13556, 0, 0.51111],\n    \"51\": [0, 0.64444, 0.13556, 0, 0.51111],\n    \"52\": [0.19444, 0.64444, 0.13556, 0, 0.51111],\n    \"53\": [0, 0.64444, 0.13556, 0, 0.51111],\n    \"54\": [0, 0.64444, 0.13556, 0, 0.51111],\n    \"55\": [0.19444, 0.64444, 0.13556, 0, 0.51111],\n    \"56\": [0, 0.64444, 0.13556, 0, 0.51111],\n    \"57\": [0, 0.64444, 0.13556, 0, 0.51111],\n    \"58\": [0, 0.43056, 0.0582, 0, 0.30667],\n    \"59\": [0.19444, 0.43056, 0.0582, 0, 0.30667],\n    \"61\": [-0.13313, 0.36687, 0.06616, 0, 0.76666],\n    \"63\": [0, 0.69444, 0.1225, 0, 0.51111],\n    \"64\": [0, 0.69444, 0.09597, 0, 0.76666],\n    \"65\": [0, 0.68333, 0, 0, 0.74333],\n    \"66\": [0, 0.68333, 0.10257, 0, 0.70389],\n    \"67\": [0, 0.68333, 0.14528, 0, 0.71555],\n    \"68\": [0, 0.68333, 0.09403, 0, 0.755],\n    \"69\": [0, 0.68333, 0.12028, 0, 0.67833],\n    \"70\": [0, 0.68333, 0.13305, 0, 0.65277],\n    \"71\": [0, 0.68333, 0.08722, 0, 0.77361],\n    \"72\": [0, 0.68333, 0.16389, 0, 0.74333],\n    \"73\": [0, 0.68333, 0.15806, 0, 0.38555],\n    \"74\": [0, 0.68333, 0.14028, 0, 0.525],\n    \"75\": [0, 0.68333, 0.14528, 0, 0.76888],\n    \"76\": [0, 0.68333, 0, 0, 0.62722],\n    \"77\": [0, 0.68333, 0.16389, 0, 0.89666],\n    \"78\": [0, 0.68333, 0.16389, 0, 0.74333],\n    \"79\": [0, 0.68333, 0.09403, 0, 0.76666],\n    \"80\": [0, 0.68333, 0.10257, 0, 0.67833],\n    \"81\": [0.19444, 0.68333, 0.09403, 0, 0.76666],\n    \"82\": [0, 0.68333, 0.03868, 0, 0.72944],\n    \"83\": [0, 0.68333, 0.11972, 0, 0.56222],\n    \"84\": [0, 0.68333, 0.13305, 0, 0.71555],\n    \"85\": [0, 0.68333, 0.16389, 0, 0.74333],\n    \"86\": [0, 0.68333, 0.18361, 0, 0.74333],\n    \"87\": [0, 0.68333, 0.18361, 0, 0.99888],\n    \"88\": [0, 0.68333, 0.15806, 0, 0.74333],\n    \"89\": [0, 0.68333, 0.19383, 0, 0.74333],\n    \"90\": [0, 0.68333, 0.14528, 0, 0.61333],\n    \"91\": [0.25, 0.75, 0.1875, 0, 0.30667],\n    \"93\": [0.25, 0.75, 0.10528, 0, 0.30667],\n    \"94\": [0, 0.69444, 0.06646, 0, 0.51111],\n    \"95\": [0.31, 0.12056, 0.09208, 0, 0.51111],\n    \"97\": [0, 0.43056, 0.07671, 0, 0.51111],\n    \"98\": [0, 0.69444, 0.06312, 0, 0.46],\n    \"99\": [0, 0.43056, 0.05653, 0, 0.46],\n    \"100\": [0, 0.69444, 0.10333, 0, 0.51111],\n    \"101\": [0, 0.43056, 0.07514, 0, 0.46],\n    \"102\": [0.19444, 0.69444, 0.21194, 0, 0.30667],\n    \"103\": [0.19444, 0.43056, 0.08847, 0, 0.46],\n    \"104\": [0, 0.69444, 0.07671, 0, 0.51111],\n    \"105\": [0, 0.65536, 0.1019, 0, 0.30667],\n    \"106\": [0.19444, 0.65536, 0.14467, 0, 0.30667],\n    \"107\": [0, 0.69444, 0.10764, 0, 0.46],\n    \"108\": [0, 0.69444, 0.10333, 0, 0.25555],\n    \"109\": [0, 0.43056, 0.07671, 0, 0.81777],\n    \"110\": [0, 0.43056, 0.07671, 0, 0.56222],\n    \"111\": [0, 0.43056, 0.06312, 0, 0.51111],\n    \"112\": [0.19444, 0.43056, 0.06312, 0, 0.51111],\n    \"113\": [0.19444, 0.43056, 0.08847, 0, 0.46],\n    \"114\": [0, 0.43056, 0.10764, 0, 0.42166],\n    \"115\": [0, 0.43056, 0.08208, 0, 0.40889],\n    \"116\": [0, 0.61508, 0.09486, 0, 0.33222],\n    \"117\": [0, 0.43056, 0.07671, 0, 0.53666],\n    \"118\": [0, 0.43056, 0.10764, 0, 0.46],\n    \"119\": [0, 0.43056, 0.10764, 0, 0.66444],\n    \"120\": [0, 0.43056, 0.12042, 0, 0.46389],\n    \"121\": [0.19444, 0.43056, 0.08847, 0, 0.48555],\n    \"122\": [0, 0.43056, 0.12292, 0, 0.40889],\n    \"126\": [0.35, 0.31786, 0.11585, 0, 0.51111],\n    \"160\": [0, 0, 0, 0, 0.25],\n    \"168\": [0, 0.66786, 0.10474, 0, 0.51111],\n    \"176\": [0, 0.69444, 0, 0, 0.83129],\n    \"184\": [0.17014, 0, 0, 0, 0.46],\n    \"198\": [0, 0.68333, 0.12028, 0, 0.88277],\n    \"216\": [0.04861, 0.73194, 0.09403, 0, 0.76666],\n    \"223\": [0.19444, 0.69444, 0.10514, 0, 0.53666],\n    \"230\": [0, 0.43056, 0.07514, 0, 0.71555],\n    \"248\": [0.09722, 0.52778, 0.09194, 0, 0.51111],\n    \"338\": [0, 0.68333, 0.12028, 0, 0.98499],\n    \"339\": [0, 0.43056, 0.07514, 0, 0.71555],\n    \"710\": [0, 0.69444, 0.06646, 0, 0.51111],\n    \"711\": [0, 0.62847, 0.08295, 0, 0.51111],\n    \"713\": [0, 0.56167, 0.10333, 0, 0.51111],\n    \"714\": [0, 0.69444, 0.09694, 0, 0.51111],\n    \"715\": [0, 0.69444, 0, 0, 0.51111],\n    \"728\": [0, 0.69444, 0.10806, 0, 0.51111],\n    \"729\": [0, 0.66786, 0.11752, 0, 0.30667],\n    \"730\": [0, 0.69444, 0, 0, 0.83129],\n    \"732\": [0, 0.66786, 0.11585, 0, 0.51111],\n    \"733\": [0, 0.69444, 0.1225, 0, 0.51111],\n    \"915\": [0, 0.68333, 0.13305, 0, 0.62722],\n    \"916\": [0, 0.68333, 0, 0, 0.81777],\n    \"920\": [0, 0.68333, 0.09403, 0, 0.76666],\n    \"923\": [0, 0.68333, 0, 0, 0.69222],\n    \"926\": [0, 0.68333, 0.15294, 0, 0.66444],\n    \"928\": [0, 0.68333, 0.16389, 0, 0.74333],\n    \"931\": [0, 0.68333, 0.12028, 0, 0.71555],\n    \"933\": [0, 0.68333, 0.11111, 0, 0.76666],\n    \"934\": [0, 0.68333, 0.05986, 0, 0.71555],\n    \"936\": [0, 0.68333, 0.11111, 0, 0.76666],\n    \"937\": [0, 0.68333, 0.10257, 0, 0.71555],\n    \"8211\": [0, 0.43056, 0.09208, 0, 0.51111],\n    \"8212\": [0, 0.43056, 0.09208, 0, 1.02222],\n    \"8216\": [0, 0.69444, 0.12417, 0, 0.30667],\n    \"8217\": [0, 0.69444, 0.12417, 0, 0.30667],\n    \"8220\": [0, 0.69444, 0.1685, 0, 0.51444],\n    \"8221\": [0, 0.69444, 0.06961, 0, 0.51444],\n    \"8463\": [0, 0.68889, 0, 0, 0.54028]\n  },\n  \"Main-Regular\": {\n    \"32\": [0, 0, 0, 0, 0.25],\n    \"33\": [0, 0.69444, 0, 0, 0.27778],\n    \"34\": [0, 0.69444, 0, 0, 0.5],\n    \"35\": [0.19444, 0.69444, 0, 0, 0.83334],\n    \"36\": [0.05556, 0.75, 0, 0, 0.5],\n    \"37\": [0.05556, 0.75, 0, 0, 0.83334],\n    \"38\": [0, 0.69444, 0, 0, 0.77778],\n    \"39\": [0, 0.69444, 0, 0, 0.27778],\n    \"40\": [0.25, 0.75, 0, 0, 0.38889],\n    \"41\": [0.25, 0.75, 0, 0, 0.38889],\n    \"42\": [0, 0.75, 0, 0, 0.5],\n    \"43\": [0.08333, 0.58333, 0, 0, 0.77778],\n    \"44\": [0.19444, 0.10556, 0, 0, 0.27778],\n    \"45\": [0, 0.43056, 0, 0, 0.33333],\n    \"46\": [0, 0.10556, 0, 0, 0.27778],\n    \"47\": [0.25, 0.75, 0, 0, 0.5],\n    \"48\": [0, 0.64444, 0, 0, 0.5],\n    \"49\": [0, 0.64444, 0, 0, 0.5],\n    \"50\": [0, 0.64444, 0, 0, 0.5],\n    \"51\": [0, 0.64444, 0, 0, 0.5],\n    \"52\": [0, 0.64444, 0, 0, 0.5],\n    \"53\": [0, 0.64444, 0, 0, 0.5],\n    \"54\": [0, 0.64444, 0, 0, 0.5],\n    \"55\": [0, 0.64444, 0, 0, 0.5],\n    \"56\": [0, 0.64444, 0, 0, 0.5],\n    \"57\": [0, 0.64444, 0, 0, 0.5],\n    \"58\": [0, 0.43056, 0, 0, 0.27778],\n    \"59\": [0.19444, 0.43056, 0, 0, 0.27778],\n    \"60\": [0.0391, 0.5391, 0, 0, 0.77778],\n    \"61\": [-0.13313, 0.36687, 0, 0, 0.77778],\n    \"62\": [0.0391, 0.5391, 0, 0, 0.77778],\n    \"63\": [0, 0.69444, 0, 0, 0.47222],\n    \"64\": [0, 0.69444, 0, 0, 0.77778],\n    \"65\": [0, 0.68333, 0, 0, 0.75],\n    \"66\": [0, 0.68333, 0, 0, 0.70834],\n    \"67\": [0, 0.68333, 0, 0, 0.72222],\n    \"68\": [0, 0.68333, 0, 0, 0.76389],\n    \"69\": [0, 0.68333, 0, 0, 0.68056],\n    \"70\": [0, 0.68333, 0, 0, 0.65278],\n    \"71\": [0, 0.68333, 0, 0, 0.78472],\n    \"72\": [0, 0.68333, 0, 0, 0.75],\n    \"73\": [0, 0.68333, 0, 0, 0.36111],\n    \"74\": [0, 0.68333, 0, 0, 0.51389],\n    \"75\": [0, 0.68333, 0, 0, 0.77778],\n    \"76\": [0, 0.68333, 0, 0, 0.625],\n    \"77\": [0, 0.68333, 0, 0, 0.91667],\n    \"78\": [0, 0.68333, 0, 0, 0.75],\n    \"79\": [0, 0.68333, 0, 0, 0.77778],\n    \"80\": [0, 0.68333, 0, 0, 0.68056],\n    \"81\": [0.19444, 0.68333, 0, 0, 0.77778],\n    \"82\": [0, 0.68333, 0, 0, 0.73611],\n    \"83\": [0, 0.68333, 0, 0, 0.55556],\n    \"84\": [0, 0.68333, 0, 0, 0.72222],\n    \"85\": [0, 0.68333, 0, 0, 0.75],\n    \"86\": [0, 0.68333, 0.01389, 0, 0.75],\n    \"87\": [0, 0.68333, 0.01389, 0, 1.02778],\n    \"88\": [0, 0.68333, 0, 0, 0.75],\n    \"89\": [0, 0.68333, 0.025, 0, 0.75],\n    \"90\": [0, 0.68333, 0, 0, 0.61111],\n    \"91\": [0.25, 0.75, 0, 0, 0.27778],\n    \"92\": [0.25, 0.75, 0, 0, 0.5],\n    \"93\": [0.25, 0.75, 0, 0, 0.27778],\n    \"94\": [0, 0.69444, 0, 0, 0.5],\n    \"95\": [0.31, 0.12056, 0.02778, 0, 0.5],\n    \"97\": [0, 0.43056, 0, 0, 0.5],\n    \"98\": [0, 0.69444, 0, 0, 0.55556],\n    \"99\": [0, 0.43056, 0, 0, 0.44445],\n    \"100\": [0, 0.69444, 0, 0, 0.55556],\n    \"101\": [0, 0.43056, 0, 0, 0.44445],\n    \"102\": [0, 0.69444, 0.07778, 0, 0.30556],\n    \"103\": [0.19444, 0.43056, 0.01389, 0, 0.5],\n    \"104\": [0, 0.69444, 0, 0, 0.55556],\n    \"105\": [0, 0.66786, 0, 0, 0.27778],\n    \"106\": [0.19444, 0.66786, 0, 0, 0.30556],\n    \"107\": [0, 0.69444, 0, 0, 0.52778],\n    \"108\": [0, 0.69444, 0, 0, 0.27778],\n    \"109\": [0, 0.43056, 0, 0, 0.83334],\n    \"110\": [0, 0.43056, 0, 0, 0.55556],\n    \"111\": [0, 0.43056, 0, 0, 0.5],\n    \"112\": [0.19444, 0.43056, 0, 0, 0.55556],\n    \"113\": [0.19444, 0.43056, 0, 0, 0.52778],\n    \"114\": [0, 0.43056, 0, 0, 0.39167],\n    \"115\": [0, 0.43056, 0, 0, 0.39445],\n    \"116\": [0, 0.61508, 0, 0, 0.38889],\n    \"117\": [0, 0.43056, 0, 0, 0.55556],\n    \"118\": [0, 0.43056, 0.01389, 0, 0.52778],\n    \"119\": [0, 0.43056, 0.01389, 0, 0.72222],\n    \"120\": [0, 0.43056, 0, 0, 0.52778],\n    \"121\": [0.19444, 0.43056, 0.01389, 0, 0.52778],\n    \"122\": [0, 0.43056, 0, 0, 0.44445],\n    \"123\": [0.25, 0.75, 0, 0, 0.5],\n    \"124\": [0.25, 0.75, 0, 0, 0.27778],\n    \"125\": [0.25, 0.75, 0, 0, 0.5],\n    \"126\": [0.35, 0.31786, 0, 0, 0.5],\n    \"160\": [0, 0, 0, 0, 0.25],\n    \"163\": [0, 0.69444, 0, 0, 0.76909],\n    \"167\": [0.19444, 0.69444, 0, 0, 0.44445],\n    \"168\": [0, 0.66786, 0, 0, 0.5],\n    \"172\": [0, 0.43056, 0, 0, 0.66667],\n    \"176\": [0, 0.69444, 0, 0, 0.75],\n    \"177\": [0.08333, 0.58333, 0, 0, 0.77778],\n    \"182\": [0.19444, 0.69444, 0, 0, 0.61111],\n    \"184\": [0.17014, 0, 0, 0, 0.44445],\n    \"198\": [0, 0.68333, 0, 0, 0.90278],\n    \"215\": [0.08333, 0.58333, 0, 0, 0.77778],\n    \"216\": [0.04861, 0.73194, 0, 0, 0.77778],\n    \"223\": [0, 0.69444, 0, 0, 0.5],\n    \"230\": [0, 0.43056, 0, 0, 0.72222],\n    \"247\": [0.08333, 0.58333, 0, 0, 0.77778],\n    \"248\": [0.09722, 0.52778, 0, 0, 0.5],\n    \"305\": [0, 0.43056, 0, 0, 0.27778],\n    \"338\": [0, 0.68333, 0, 0, 1.01389],\n    \"339\": [0, 0.43056, 0, 0, 0.77778],\n    \"567\": [0.19444, 0.43056, 0, 0, 0.30556],\n    \"710\": [0, 0.69444, 0, 0, 0.5],\n    \"711\": [0, 0.62847, 0, 0, 0.5],\n    \"713\": [0, 0.56778, 0, 0, 0.5],\n    \"714\": [0, 0.69444, 0, 0, 0.5],\n    \"715\": [0, 0.69444, 0, 0, 0.5],\n    \"728\": [0, 0.69444, 0, 0, 0.5],\n    \"729\": [0, 0.66786, 0, 0, 0.27778],\n    \"730\": [0, 0.69444, 0, 0, 0.75],\n    \"732\": [0, 0.66786, 0, 0, 0.5],\n    \"733\": [0, 0.69444, 0, 0, 0.5],\n    \"915\": [0, 0.68333, 0, 0, 0.625],\n    \"916\": [0, 0.68333, 0, 0, 0.83334],\n    \"920\": [0, 0.68333, 0, 0, 0.77778],\n    \"923\": [0, 0.68333, 0, 0, 0.69445],\n    \"926\": [0, 0.68333, 0, 0, 0.66667],\n    \"928\": [0, 0.68333, 0, 0, 0.75],\n    \"931\": [0, 0.68333, 0, 0, 0.72222],\n    \"933\": [0, 0.68333, 0, 0, 0.77778],\n    \"934\": [0, 0.68333, 0, 0, 0.72222],\n    \"936\": [0, 0.68333, 0, 0, 0.77778],\n    \"937\": [0, 0.68333, 0, 0, 0.72222],\n    \"8211\": [0, 0.43056, 0.02778, 0, 0.5],\n    \"8212\": [0, 0.43056, 0.02778, 0, 1.0],\n    \"8216\": [0, 0.69444, 0, 0, 0.27778],\n    \"8217\": [0, 0.69444, 0, 0, 0.27778],\n    \"8220\": [0, 0.69444, 0, 0, 0.5],\n    \"8221\": [0, 0.69444, 0, 0, 0.5],\n    \"8224\": [0.19444, 0.69444, 0, 0, 0.44445],\n    \"8225\": [0.19444, 0.69444, 0, 0, 0.44445],\n    \"8230\": [0, 0.123, 0, 0, 1.172],\n    \"8242\": [0, 0.55556, 0, 0, 0.275],\n    \"8407\": [0, 0.71444, 0.15382, 0, 0.5],\n    \"8463\": [0, 0.68889, 0, 0, 0.54028],\n    \"8465\": [0, 0.69444, 0, 0, 0.72222],\n    \"8467\": [0, 0.69444, 0, 0.11111, 0.41667],\n    \"8472\": [0.19444, 0.43056, 0, 0.11111, 0.63646],\n    \"8476\": [0, 0.69444, 0, 0, 0.72222],\n    \"8501\": [0, 0.69444, 0, 0, 0.61111],\n    \"8592\": [-0.13313, 0.36687, 0, 0, 1.0],\n    \"8593\": [0.19444, 0.69444, 0, 0, 0.5],\n    \"8594\": [-0.13313, 0.36687, 0, 0, 1.0],\n    \"8595\": [0.19444, 0.69444, 0, 0, 0.5],\n    \"8596\": [-0.13313, 0.36687, 0, 0, 1.0],\n    \"8597\": [0.25, 0.75, 0, 0, 0.5],\n    \"8598\": [0.19444, 0.69444, 0, 0, 1.0],\n    \"8599\": [0.19444, 0.69444, 0, 0, 1.0],\n    \"8600\": [0.19444, 0.69444, 0, 0, 1.0],\n    \"8601\": [0.19444, 0.69444, 0, 0, 1.0],\n    \"8614\": [0.011, 0.511, 0, 0, 1.0],\n    \"8617\": [0.011, 0.511, 0, 0, 1.126],\n    \"8618\": [0.011, 0.511, 0, 0, 1.126],\n    \"8636\": [-0.13313, 0.36687, 0, 0, 1.0],\n    \"8637\": [-0.13313, 0.36687, 0, 0, 1.0],\n    \"8640\": [-0.13313, 0.36687, 0, 0, 1.0],\n    \"8641\": [-0.13313, 0.36687, 0, 0, 1.0],\n    \"8652\": [0.011, 0.671, 0, 0, 1.0],\n    \"8656\": [-0.13313, 0.36687, 0, 0, 1.0],\n    \"8657\": [0.19444, 0.69444, 0, 0, 0.61111],\n    \"8658\": [-0.13313, 0.36687, 0, 0, 1.0],\n    \"8659\": [0.19444, 0.69444, 0, 0, 0.61111],\n    \"8660\": [-0.13313, 0.36687, 0, 0, 1.0],\n    \"8661\": [0.25, 0.75, 0, 0, 0.61111],\n    \"8704\": [0, 0.69444, 0, 0, 0.55556],\n    \"8706\": [0, 0.69444, 0.05556, 0.08334, 0.5309],\n    \"8707\": [0, 0.69444, 0, 0, 0.55556],\n    \"8709\": [0.05556, 0.75, 0, 0, 0.5],\n    \"8711\": [0, 0.68333, 0, 0, 0.83334],\n    \"8712\": [0.0391, 0.5391, 0, 0, 0.66667],\n    \"8715\": [0.0391, 0.5391, 0, 0, 0.66667],\n    \"8722\": [0.08333, 0.58333, 0, 0, 0.77778],\n    \"8723\": [0.08333, 0.58333, 0, 0, 0.77778],\n    \"8725\": [0.25, 0.75, 0, 0, 0.5],\n    \"8726\": [0.25, 0.75, 0, 0, 0.5],\n    \"8727\": [-0.03472, 0.46528, 0, 0, 0.5],\n    \"8728\": [-0.05555, 0.44445, 0, 0, 0.5],\n    \"8729\": [-0.05555, 0.44445, 0, 0, 0.5],\n    \"8730\": [0.2, 0.8, 0, 0, 0.83334],\n    \"8733\": [0, 0.43056, 0, 0, 0.77778],\n    \"8734\": [0, 0.43056, 0, 0, 1.0],\n    \"8736\": [0, 0.69224, 0, 0, 0.72222],\n    \"8739\": [0.25, 0.75, 0, 0, 0.27778],\n    \"8741\": [0.25, 0.75, 0, 0, 0.5],\n    \"8743\": [0, 0.55556, 0, 0, 0.66667],\n    \"8744\": [0, 0.55556, 0, 0, 0.66667],\n    \"8745\": [0, 0.55556, 0, 0, 0.66667],\n    \"8746\": [0, 0.55556, 0, 0, 0.66667],\n    \"8747\": [0.19444, 0.69444, 0.11111, 0, 0.41667],\n    \"8764\": [-0.13313, 0.36687, 0, 0, 0.77778],\n    \"8768\": [0.19444, 0.69444, 0, 0, 0.27778],\n    \"8771\": [-0.03625, 0.46375, 0, 0, 0.77778],\n    \"8773\": [-0.022, 0.589, 0, 0, 0.778],\n    \"8776\": [-0.01688, 0.48312, 0, 0, 0.77778],\n    \"8781\": [-0.03625, 0.46375, 0, 0, 0.77778],\n    \"8784\": [-0.133, 0.673, 0, 0, 0.778],\n    \"8801\": [-0.03625, 0.46375, 0, 0, 0.77778],\n    \"8804\": [0.13597, 0.63597, 0, 0, 0.77778],\n    \"8805\": [0.13597, 0.63597, 0, 0, 0.77778],\n    \"8810\": [0.0391, 0.5391, 0, 0, 1.0],\n    \"8811\": [0.0391, 0.5391, 0, 0, 1.0],\n    \"8826\": [0.0391, 0.5391, 0, 0, 0.77778],\n    \"8827\": [0.0391, 0.5391, 0, 0, 0.77778],\n    \"8834\": [0.0391, 0.5391, 0, 0, 0.77778],\n    \"8835\": [0.0391, 0.5391, 0, 0, 0.77778],\n    \"8838\": [0.13597, 0.63597, 0, 0, 0.77778],\n    \"8839\": [0.13597, 0.63597, 0, 0, 0.77778],\n    \"8846\": [0, 0.55556, 0, 0, 0.66667],\n    \"8849\": [0.13597, 0.63597, 0, 0, 0.77778],\n    \"8850\": [0.13597, 0.63597, 0, 0, 0.77778],\n    \"8851\": [0, 0.55556, 0, 0, 0.66667],\n    \"8852\": [0, 0.55556, 0, 0, 0.66667],\n    \"8853\": [0.08333, 0.58333, 0, 0, 0.77778],\n    \"8854\": [0.08333, 0.58333, 0, 0, 0.77778],\n    \"8855\": [0.08333, 0.58333, 0, 0, 0.77778],\n    \"8856\": [0.08333, 0.58333, 0, 0, 0.77778],\n    \"8857\": [0.08333, 0.58333, 0, 0, 0.77778],\n    \"8866\": [0, 0.69444, 0, 0, 0.61111],\n    \"8867\": [0, 0.69444, 0, 0, 0.61111],\n    \"8868\": [0, 0.69444, 0, 0, 0.77778],\n    \"8869\": [0, 0.69444, 0, 0, 0.77778],\n    \"8872\": [0.249, 0.75, 0, 0, 0.867],\n    \"8900\": [-0.05555, 0.44445, 0, 0, 0.5],\n    \"8901\": [-0.05555, 0.44445, 0, 0, 0.27778],\n    \"8902\": [-0.03472, 0.46528, 0, 0, 0.5],\n    \"8904\": [0.005, 0.505, 0, 0, 0.9],\n    \"8942\": [0.03, 0.903, 0, 0, 0.278],\n    \"8943\": [-0.19, 0.313, 0, 0, 1.172],\n    \"8945\": [-0.1, 0.823, 0, 0, 1.282],\n    \"8968\": [0.25, 0.75, 0, 0, 0.44445],\n    \"8969\": [0.25, 0.75, 0, 0, 0.44445],\n    \"8970\": [0.25, 0.75, 0, 0, 0.44445],\n    \"8971\": [0.25, 0.75, 0, 0, 0.44445],\n    \"8994\": [-0.14236, 0.35764, 0, 0, 1.0],\n    \"8995\": [-0.14236, 0.35764, 0, 0, 1.0],\n    \"9136\": [0.244, 0.744, 0, 0, 0.412],\n    \"9137\": [0.244, 0.745, 0, 0, 0.412],\n    \"9651\": [0.19444, 0.69444, 0, 0, 0.88889],\n    \"9657\": [-0.03472, 0.46528, 0, 0, 0.5],\n    \"9661\": [0.19444, 0.69444, 0, 0, 0.88889],\n    \"9667\": [-0.03472, 0.46528, 0, 0, 0.5],\n    \"9711\": [0.19444, 0.69444, 0, 0, 1.0],\n    \"9824\": [0.12963, 0.69444, 0, 0, 0.77778],\n    \"9825\": [0.12963, 0.69444, 0, 0, 0.77778],\n    \"9826\": [0.12963, 0.69444, 0, 0, 0.77778],\n    \"9827\": [0.12963, 0.69444, 0, 0, 0.77778],\n    \"9837\": [0, 0.75, 0, 0, 0.38889],\n    \"9838\": [0.19444, 0.69444, 0, 0, 0.38889],\n    \"9839\": [0.19444, 0.69444, 0, 0, 0.38889],\n    \"10216\": [0.25, 0.75, 0, 0, 0.38889],\n    \"10217\": [0.25, 0.75, 0, 0, 0.38889],\n    \"10222\": [0.244, 0.744, 0, 0, 0.412],\n    \"10223\": [0.244, 0.745, 0, 0, 0.412],\n    \"10229\": [0.011, 0.511, 0, 0, 1.609],\n    \"10230\": [0.011, 0.511, 0, 0, 1.638],\n    \"10231\": [0.011, 0.511, 0, 0, 1.859],\n    \"10232\": [0.024, 0.525, 0, 0, 1.609],\n    \"10233\": [0.024, 0.525, 0, 0, 1.638],\n    \"10234\": [0.024, 0.525, 0, 0, 1.858],\n    \"10236\": [0.011, 0.511, 0, 0, 1.638],\n    \"10815\": [0, 0.68333, 0, 0, 0.75],\n    \"10927\": [0.13597, 0.63597, 0, 0, 0.77778],\n    \"10928\": [0.13597, 0.63597, 0, 0, 0.77778],\n    \"57376\": [0.19444, 0.69444, 0, 0, 0]\n  },\n  \"Math-BoldItalic\": {\n    \"32\": [0, 0, 0, 0, 0.25],\n    \"48\": [0, 0.44444, 0, 0, 0.575],\n    \"49\": [0, 0.44444, 0, 0, 0.575],\n    \"50\": [0, 0.44444, 0, 0, 0.575],\n    \"51\": [0.19444, 0.44444, 0, 0, 0.575],\n    \"52\": [0.19444, 0.44444, 0, 0, 0.575],\n    \"53\": [0.19444, 0.44444, 0, 0, 0.575],\n    \"54\": [0, 0.64444, 0, 0, 0.575],\n    \"55\": [0.19444, 0.44444, 0, 0, 0.575],\n    \"56\": [0, 0.64444, 0, 0, 0.575],\n    \"57\": [0.19444, 0.44444, 0, 0, 0.575],\n    \"65\": [0, 0.68611, 0, 0, 0.86944],\n    \"66\": [0, 0.68611, 0.04835, 0, 0.8664],\n    \"67\": [0, 0.68611, 0.06979, 0, 0.81694],\n    \"68\": [0, 0.68611, 0.03194, 0, 0.93812],\n    \"69\": [0, 0.68611, 0.05451, 0, 0.81007],\n    \"70\": [0, 0.68611, 0.15972, 0, 0.68889],\n    \"71\": [0, 0.68611, 0, 0, 0.88673],\n    \"72\": [0, 0.68611, 0.08229, 0, 0.98229],\n    \"73\": [0, 0.68611, 0.07778, 0, 0.51111],\n    \"74\": [0, 0.68611, 0.10069, 0, 0.63125],\n    \"75\": [0, 0.68611, 0.06979, 0, 0.97118],\n    \"76\": [0, 0.68611, 0, 0, 0.75555],\n    \"77\": [0, 0.68611, 0.11424, 0, 1.14201],\n    \"78\": [0, 0.68611, 0.11424, 0, 0.95034],\n    \"79\": [0, 0.68611, 0.03194, 0, 0.83666],\n    \"80\": [0, 0.68611, 0.15972, 0, 0.72309],\n    \"81\": [0.19444, 0.68611, 0, 0, 0.86861],\n    \"82\": [0, 0.68611, 0.00421, 0, 0.87235],\n    \"83\": [0, 0.68611, 0.05382, 0, 0.69271],\n    \"84\": [0, 0.68611, 0.15972, 0, 0.63663],\n    \"85\": [0, 0.68611, 0.11424, 0, 0.80027],\n    \"86\": [0, 0.68611, 0.25555, 0, 0.67778],\n    \"87\": [0, 0.68611, 0.15972, 0, 1.09305],\n    \"88\": [0, 0.68611, 0.07778, 0, 0.94722],\n    \"89\": [0, 0.68611, 0.25555, 0, 0.67458],\n    \"90\": [0, 0.68611, 0.06979, 0, 0.77257],\n    \"97\": [0, 0.44444, 0, 0, 0.63287],\n    \"98\": [0, 0.69444, 0, 0, 0.52083],\n    \"99\": [0, 0.44444, 0, 0, 0.51342],\n    \"100\": [0, 0.69444, 0, 0, 0.60972],\n    \"101\": [0, 0.44444, 0, 0, 0.55361],\n    \"102\": [0.19444, 0.69444, 0.11042, 0, 0.56806],\n    \"103\": [0.19444, 0.44444, 0.03704, 0, 0.5449],\n    \"104\": [0, 0.69444, 0, 0, 0.66759],\n    \"105\": [0, 0.69326, 0, 0, 0.4048],\n    \"106\": [0.19444, 0.69326, 0.0622, 0, 0.47083],\n    \"107\": [0, 0.69444, 0.01852, 0, 0.6037],\n    \"108\": [0, 0.69444, 0.0088, 0, 0.34815],\n    \"109\": [0, 0.44444, 0, 0, 1.0324],\n    \"110\": [0, 0.44444, 0, 0, 0.71296],\n    \"111\": [0, 0.44444, 0, 0, 0.58472],\n    \"112\": [0.19444, 0.44444, 0, 0, 0.60092],\n    \"113\": [0.19444, 0.44444, 0.03704, 0, 0.54213],\n    \"114\": [0, 0.44444, 0.03194, 0, 0.5287],\n    \"115\": [0, 0.44444, 0, 0, 0.53125],\n    \"116\": [0, 0.63492, 0, 0, 0.41528],\n    \"117\": [0, 0.44444, 0, 0, 0.68102],\n    \"118\": [0, 0.44444, 0.03704, 0, 0.56666],\n    \"119\": [0, 0.44444, 0.02778, 0, 0.83148],\n    \"120\": [0, 0.44444, 0, 0, 0.65903],\n    \"121\": [0.19444, 0.44444, 0.03704, 0, 0.59028],\n    \"122\": [0, 0.44444, 0.04213, 0, 0.55509],\n    \"160\": [0, 0, 0, 0, 0.25],\n    \"915\": [0, 0.68611, 0.15972, 0, 0.65694],\n    \"916\": [0, 0.68611, 0, 0, 0.95833],\n    \"920\": [0, 0.68611, 0.03194, 0, 0.86722],\n    \"923\": [0, 0.68611, 0, 0, 0.80555],\n    \"926\": [0, 0.68611, 0.07458, 0, 0.84125],\n    \"928\": [0, 0.68611, 0.08229, 0, 0.98229],\n    \"931\": [0, 0.68611, 0.05451, 0, 0.88507],\n    \"933\": [0, 0.68611, 0.15972, 0, 0.67083],\n    \"934\": [0, 0.68611, 0, 0, 0.76666],\n    \"936\": [0, 0.68611, 0.11653, 0, 0.71402],\n    \"937\": [0, 0.68611, 0.04835, 0, 0.8789],\n    \"945\": [0, 0.44444, 0, 0, 0.76064],\n    \"946\": [0.19444, 0.69444, 0.03403, 0, 0.65972],\n    \"947\": [0.19444, 0.44444, 0.06389, 0, 0.59003],\n    \"948\": [0, 0.69444, 0.03819, 0, 0.52222],\n    \"949\": [0, 0.44444, 0, 0, 0.52882],\n    \"950\": [0.19444, 0.69444, 0.06215, 0, 0.50833],\n    \"951\": [0.19444, 0.44444, 0.03704, 0, 0.6],\n    \"952\": [0, 0.69444, 0.03194, 0, 0.5618],\n    \"953\": [0, 0.44444, 0, 0, 0.41204],\n    \"954\": [0, 0.44444, 0, 0, 0.66759],\n    \"955\": [0, 0.69444, 0, 0, 0.67083],\n    \"956\": [0.19444, 0.44444, 0, 0, 0.70787],\n    \"957\": [0, 0.44444, 0.06898, 0, 0.57685],\n    \"958\": [0.19444, 0.69444, 0.03021, 0, 0.50833],\n    \"959\": [0, 0.44444, 0, 0, 0.58472],\n    \"960\": [0, 0.44444, 0.03704, 0, 0.68241],\n    \"961\": [0.19444, 0.44444, 0, 0, 0.6118],\n    \"962\": [0.09722, 0.44444, 0.07917, 0, 0.42361],\n    \"963\": [0, 0.44444, 0.03704, 0, 0.68588],\n    \"964\": [0, 0.44444, 0.13472, 0, 0.52083],\n    \"965\": [0, 0.44444, 0.03704, 0, 0.63055],\n    \"966\": [0.19444, 0.44444, 0, 0, 0.74722],\n    \"967\": [0.19444, 0.44444, 0, 0, 0.71805],\n    \"968\": [0.19444, 0.69444, 0.03704, 0, 0.75833],\n    \"969\": [0, 0.44444, 0.03704, 0, 0.71782],\n    \"977\": [0, 0.69444, 0, 0, 0.69155],\n    \"981\": [0.19444, 0.69444, 0, 0, 0.7125],\n    \"982\": [0, 0.44444, 0.03194, 0, 0.975],\n    \"1009\": [0.19444, 0.44444, 0, 0, 0.6118],\n    \"1013\": [0, 0.44444, 0, 0, 0.48333],\n    \"57649\": [0, 0.44444, 0, 0, 0.39352],\n    \"57911\": [0.19444, 0.44444, 0, 0, 0.43889]\n  },\n  \"Math-Italic\": {\n    \"32\": [0, 0, 0, 0, 0.25],\n    \"48\": [0, 0.43056, 0, 0, 0.5],\n    \"49\": [0, 0.43056, 0, 0, 0.5],\n    \"50\": [0, 0.43056, 0, 0, 0.5],\n    \"51\": [0.19444, 0.43056, 0, 0, 0.5],\n    \"52\": [0.19444, 0.43056, 0, 0, 0.5],\n    \"53\": [0.19444, 0.43056, 0, 0, 0.5],\n    \"54\": [0, 0.64444, 0, 0, 0.5],\n    \"55\": [0.19444, 0.43056, 0, 0, 0.5],\n    \"56\": [0, 0.64444, 0, 0, 0.5],\n    \"57\": [0.19444, 0.43056, 0, 0, 0.5],\n    \"65\": [0, 0.68333, 0, 0.13889, 0.75],\n    \"66\": [0, 0.68333, 0.05017, 0.08334, 0.75851],\n    \"67\": [0, 0.68333, 0.07153, 0.08334, 0.71472],\n    \"68\": [0, 0.68333, 0.02778, 0.05556, 0.82792],\n    \"69\": [0, 0.68333, 0.05764, 0.08334, 0.7382],\n    \"70\": [0, 0.68333, 0.13889, 0.08334, 0.64306],\n    \"71\": [0, 0.68333, 0, 0.08334, 0.78625],\n    \"72\": [0, 0.68333, 0.08125, 0.05556, 0.83125],\n    \"73\": [0, 0.68333, 0.07847, 0.11111, 0.43958],\n    \"74\": [0, 0.68333, 0.09618, 0.16667, 0.55451],\n    \"75\": [0, 0.68333, 0.07153, 0.05556, 0.84931],\n    \"76\": [0, 0.68333, 0, 0.02778, 0.68056],\n    \"77\": [0, 0.68333, 0.10903, 0.08334, 0.97014],\n    \"78\": [0, 0.68333, 0.10903, 0.08334, 0.80347],\n    \"79\": [0, 0.68333, 0.02778, 0.08334, 0.76278],\n    \"80\": [0, 0.68333, 0.13889, 0.08334, 0.64201],\n    \"81\": [0.19444, 0.68333, 0, 0.08334, 0.79056],\n    \"82\": [0, 0.68333, 0.00773, 0.08334, 0.75929],\n    \"83\": [0, 0.68333, 0.05764, 0.08334, 0.6132],\n    \"84\": [0, 0.68333, 0.13889, 0.08334, 0.58438],\n    \"85\": [0, 0.68333, 0.10903, 0.02778, 0.68278],\n    \"86\": [0, 0.68333, 0.22222, 0, 0.58333],\n    \"87\": [0, 0.68333, 0.13889, 0, 0.94445],\n    \"88\": [0, 0.68333, 0.07847, 0.08334, 0.82847],\n    \"89\": [0, 0.68333, 0.22222, 0, 0.58056],\n    \"90\": [0, 0.68333, 0.07153, 0.08334, 0.68264],\n    \"97\": [0, 0.43056, 0, 0, 0.52859],\n    \"98\": [0, 0.69444, 0, 0, 0.42917],\n    \"99\": [0, 0.43056, 0, 0.05556, 0.43276],\n    \"100\": [0, 0.69444, 0, 0.16667, 0.52049],\n    \"101\": [0, 0.43056, 0, 0.05556, 0.46563],\n    \"102\": [0.19444, 0.69444, 0.10764, 0.16667, 0.48959],\n    \"103\": [0.19444, 0.43056, 0.03588, 0.02778, 0.47697],\n    \"104\": [0, 0.69444, 0, 0, 0.57616],\n    \"105\": [0, 0.65952, 0, 0, 0.34451],\n    \"106\": [0.19444, 0.65952, 0.05724, 0, 0.41181],\n    \"107\": [0, 0.69444, 0.03148, 0, 0.5206],\n    \"108\": [0, 0.69444, 0.01968, 0.08334, 0.29838],\n    \"109\": [0, 0.43056, 0, 0, 0.87801],\n    \"110\": [0, 0.43056, 0, 0, 0.60023],\n    \"111\": [0, 0.43056, 0, 0.05556, 0.48472],\n    \"112\": [0.19444, 0.43056, 0, 0.08334, 0.50313],\n    \"113\": [0.19444, 0.43056, 0.03588, 0.08334, 0.44641],\n    \"114\": [0, 0.43056, 0.02778, 0.05556, 0.45116],\n    \"115\": [0, 0.43056, 0, 0.05556, 0.46875],\n    \"116\": [0, 0.61508, 0, 0.08334, 0.36111],\n    \"117\": [0, 0.43056, 0, 0.02778, 0.57246],\n    \"118\": [0, 0.43056, 0.03588, 0.02778, 0.48472],\n    \"119\": [0, 0.43056, 0.02691, 0.08334, 0.71592],\n    \"120\": [0, 0.43056, 0, 0.02778, 0.57153],\n    \"121\": [0.19444, 0.43056, 0.03588, 0.05556, 0.49028],\n    \"122\": [0, 0.43056, 0.04398, 0.05556, 0.46505],\n    \"160\": [0, 0, 0, 0, 0.25],\n    \"915\": [0, 0.68333, 0.13889, 0.08334, 0.61528],\n    \"916\": [0, 0.68333, 0, 0.16667, 0.83334],\n    \"920\": [0, 0.68333, 0.02778, 0.08334, 0.76278],\n    \"923\": [0, 0.68333, 0, 0.16667, 0.69445],\n    \"926\": [0, 0.68333, 0.07569, 0.08334, 0.74236],\n    \"928\": [0, 0.68333, 0.08125, 0.05556, 0.83125],\n    \"931\": [0, 0.68333, 0.05764, 0.08334, 0.77986],\n    \"933\": [0, 0.68333, 0.13889, 0.05556, 0.58333],\n    \"934\": [0, 0.68333, 0, 0.08334, 0.66667],\n    \"936\": [0, 0.68333, 0.11, 0.05556, 0.61222],\n    \"937\": [0, 0.68333, 0.05017, 0.08334, 0.7724],\n    \"945\": [0, 0.43056, 0.0037, 0.02778, 0.6397],\n    \"946\": [0.19444, 0.69444, 0.05278, 0.08334, 0.56563],\n    \"947\": [0.19444, 0.43056, 0.05556, 0, 0.51773],\n    \"948\": [0, 0.69444, 0.03785, 0.05556, 0.44444],\n    \"949\": [0, 0.43056, 0, 0.08334, 0.46632],\n    \"950\": [0.19444, 0.69444, 0.07378, 0.08334, 0.4375],\n    \"951\": [0.19444, 0.43056, 0.03588, 0.05556, 0.49653],\n    \"952\": [0, 0.69444, 0.02778, 0.08334, 0.46944],\n    \"953\": [0, 0.43056, 0, 0.05556, 0.35394],\n    \"954\": [0, 0.43056, 0, 0, 0.57616],\n    \"955\": [0, 0.69444, 0, 0, 0.58334],\n    \"956\": [0.19444, 0.43056, 0, 0.02778, 0.60255],\n    \"957\": [0, 0.43056, 0.06366, 0.02778, 0.49398],\n    \"958\": [0.19444, 0.69444, 0.04601, 0.11111, 0.4375],\n    \"959\": [0, 0.43056, 0, 0.05556, 0.48472],\n    \"960\": [0, 0.43056, 0.03588, 0, 0.57003],\n    \"961\": [0.19444, 0.43056, 0, 0.08334, 0.51702],\n    \"962\": [0.09722, 0.43056, 0.07986, 0.08334, 0.36285],\n    \"963\": [0, 0.43056, 0.03588, 0, 0.57141],\n    \"964\": [0, 0.43056, 0.1132, 0.02778, 0.43715],\n    \"965\": [0, 0.43056, 0.03588, 0.02778, 0.54028],\n    \"966\": [0.19444, 0.43056, 0, 0.08334, 0.65417],\n    \"967\": [0.19444, 0.43056, 0, 0.05556, 0.62569],\n    \"968\": [0.19444, 0.69444, 0.03588, 0.11111, 0.65139],\n    \"969\": [0, 0.43056, 0.03588, 0, 0.62245],\n    \"977\": [0, 0.69444, 0, 0.08334, 0.59144],\n    \"981\": [0.19444, 0.69444, 0, 0.08334, 0.59583],\n    \"982\": [0, 0.43056, 0.02778, 0, 0.82813],\n    \"1009\": [0.19444, 0.43056, 0, 0.08334, 0.51702],\n    \"1013\": [0, 0.43056, 0, 0.05556, 0.4059],\n    \"57649\": [0, 0.43056, 0, 0.02778, 0.32246],\n    \"57911\": [0.19444, 0.43056, 0, 0.08334, 0.38403]\n  },\n  \"SansSerif-Bold\": {\n    \"32\": [0, 0, 0, 0, 0.25],\n    \"33\": [0, 0.69444, 0, 0, 0.36667],\n    \"34\": [0, 0.69444, 0, 0, 0.55834],\n    \"35\": [0.19444, 0.69444, 0, 0, 0.91667],\n    \"36\": [0.05556, 0.75, 0, 0, 0.55],\n    \"37\": [0.05556, 0.75, 0, 0, 1.02912],\n    \"38\": [0, 0.69444, 0, 0, 0.83056],\n    \"39\": [0, 0.69444, 0, 0, 0.30556],\n    \"40\": [0.25, 0.75, 0, 0, 0.42778],\n    \"41\": [0.25, 0.75, 0, 0, 0.42778],\n    \"42\": [0, 0.75, 0, 0, 0.55],\n    \"43\": [0.11667, 0.61667, 0, 0, 0.85556],\n    \"44\": [0.10556, 0.13056, 0, 0, 0.30556],\n    \"45\": [0, 0.45833, 0, 0, 0.36667],\n    \"46\": [0, 0.13056, 0, 0, 0.30556],\n    \"47\": [0.25, 0.75, 0, 0, 0.55],\n    \"48\": [0, 0.69444, 0, 0, 0.55],\n    \"49\": [0, 0.69444, 0, 0, 0.55],\n    \"50\": [0, 0.69444, 0, 0, 0.55],\n    \"51\": [0, 0.69444, 0, 0, 0.55],\n    \"52\": [0, 0.69444, 0, 0, 0.55],\n    \"53\": [0, 0.69444, 0, 0, 0.55],\n    \"54\": [0, 0.69444, 0, 0, 0.55],\n    \"55\": [0, 0.69444, 0, 0, 0.55],\n    \"56\": [0, 0.69444, 0, 0, 0.55],\n    \"57\": [0, 0.69444, 0, 0, 0.55],\n    \"58\": [0, 0.45833, 0, 0, 0.30556],\n    \"59\": [0.10556, 0.45833, 0, 0, 0.30556],\n    \"61\": [-0.09375, 0.40625, 0, 0, 0.85556],\n    \"63\": [0, 0.69444, 0, 0, 0.51945],\n    \"64\": [0, 0.69444, 0, 0, 0.73334],\n    \"65\": [0, 0.69444, 0, 0, 0.73334],\n    \"66\": [0, 0.69444, 0, 0, 0.73334],\n    \"67\": [0, 0.69444, 0, 0, 0.70278],\n    \"68\": [0, 0.69444, 0, 0, 0.79445],\n    \"69\": [0, 0.69444, 0, 0, 0.64167],\n    \"70\": [0, 0.69444, 0, 0, 0.61111],\n    \"71\": [0, 0.69444, 0, 0, 0.73334],\n    \"72\": [0, 0.69444, 0, 0, 0.79445],\n    \"73\": [0, 0.69444, 0, 0, 0.33056],\n    \"74\": [0, 0.69444, 0, 0, 0.51945],\n    \"75\": [0, 0.69444, 0, 0, 0.76389],\n    \"76\": [0, 0.69444, 0, 0, 0.58056],\n    \"77\": [0, 0.69444, 0, 0, 0.97778],\n    \"78\": [0, 0.69444, 0, 0, 0.79445],\n    \"79\": [0, 0.69444, 0, 0, 0.79445],\n    \"80\": [0, 0.69444, 0, 0, 0.70278],\n    \"81\": [0.10556, 0.69444, 0, 0, 0.79445],\n    \"82\": [0, 0.69444, 0, 0, 0.70278],\n    \"83\": [0, 0.69444, 0, 0, 0.61111],\n    \"84\": [0, 0.69444, 0, 0, 0.73334],\n    \"85\": [0, 0.69444, 0, 0, 0.76389],\n    \"86\": [0, 0.69444, 0.01528, 0, 0.73334],\n    \"87\": [0, 0.69444, 0.01528, 0, 1.03889],\n    \"88\": [0, 0.69444, 0, 0, 0.73334],\n    \"89\": [0, 0.69444, 0.0275, 0, 0.73334],\n    \"90\": [0, 0.69444, 0, 0, 0.67223],\n    \"91\": [0.25, 0.75, 0, 0, 0.34306],\n    \"93\": [0.25, 0.75, 0, 0, 0.34306],\n    \"94\": [0, 0.69444, 0, 0, 0.55],\n    \"95\": [0.35, 0.10833, 0.03056, 0, 0.55],\n    \"97\": [0, 0.45833, 0, 0, 0.525],\n    \"98\": [0, 0.69444, 0, 0, 0.56111],\n    \"99\": [0, 0.45833, 0, 0, 0.48889],\n    \"100\": [0, 0.69444, 0, 0, 0.56111],\n    \"101\": [0, 0.45833, 0, 0, 0.51111],\n    \"102\": [0, 0.69444, 0.07639, 0, 0.33611],\n    \"103\": [0.19444, 0.45833, 0.01528, 0, 0.55],\n    \"104\": [0, 0.69444, 0, 0, 0.56111],\n    \"105\": [0, 0.69444, 0, 0, 0.25556],\n    \"106\": [0.19444, 0.69444, 0, 0, 0.28611],\n    \"107\": [0, 0.69444, 0, 0, 0.53056],\n    \"108\": [0, 0.69444, 0, 0, 0.25556],\n    \"109\": [0, 0.45833, 0, 0, 0.86667],\n    \"110\": [0, 0.45833, 0, 0, 0.56111],\n    \"111\": [0, 0.45833, 0, 0, 0.55],\n    \"112\": [0.19444, 0.45833, 0, 0, 0.56111],\n    \"113\": [0.19444, 0.45833, 0, 0, 0.56111],\n    \"114\": [0, 0.45833, 0.01528, 0, 0.37222],\n    \"115\": [0, 0.45833, 0, 0, 0.42167],\n    \"116\": [0, 0.58929, 0, 0, 0.40417],\n    \"117\": [0, 0.45833, 0, 0, 0.56111],\n    \"118\": [0, 0.45833, 0.01528, 0, 0.5],\n    \"119\": [0, 0.45833, 0.01528, 0, 0.74445],\n    \"120\": [0, 0.45833, 0, 0, 0.5],\n    \"121\": [0.19444, 0.45833, 0.01528, 0, 0.5],\n    \"122\": [0, 0.45833, 0, 0, 0.47639],\n    \"126\": [0.35, 0.34444, 0, 0, 0.55],\n    \"160\": [0, 0, 0, 0, 0.25],\n    \"168\": [0, 0.69444, 0, 0, 0.55],\n    \"176\": [0, 0.69444, 0, 0, 0.73334],\n    \"180\": [0, 0.69444, 0, 0, 0.55],\n    \"184\": [0.17014, 0, 0, 0, 0.48889],\n    \"305\": [0, 0.45833, 0, 0, 0.25556],\n    \"567\": [0.19444, 0.45833, 0, 0, 0.28611],\n    \"710\": [0, 0.69444, 0, 0, 0.55],\n    \"711\": [0, 0.63542, 0, 0, 0.55],\n    \"713\": [0, 0.63778, 0, 0, 0.55],\n    \"728\": [0, 0.69444, 0, 0, 0.55],\n    \"729\": [0, 0.69444, 0, 0, 0.30556],\n    \"730\": [0, 0.69444, 0, 0, 0.73334],\n    \"732\": [0, 0.69444, 0, 0, 0.55],\n    \"733\": [0, 0.69444, 0, 0, 0.55],\n    \"915\": [0, 0.69444, 0, 0, 0.58056],\n    \"916\": [0, 0.69444, 0, 0, 0.91667],\n    \"920\": [0, 0.69444, 0, 0, 0.85556],\n    \"923\": [0, 0.69444, 0, 0, 0.67223],\n    \"926\": [0, 0.69444, 0, 0, 0.73334],\n    \"928\": [0, 0.69444, 0, 0, 0.79445],\n    \"931\": [0, 0.69444, 0, 0, 0.79445],\n    \"933\": [0, 0.69444, 0, 0, 0.85556],\n    \"934\": [0, 0.69444, 0, 0, 0.79445],\n    \"936\": [0, 0.69444, 0, 0, 0.85556],\n    \"937\": [0, 0.69444, 0, 0, 0.79445],\n    \"8211\": [0, 0.45833, 0.03056, 0, 0.55],\n    \"8212\": [0, 0.45833, 0.03056, 0, 1.10001],\n    \"8216\": [0, 0.69444, 0, 0, 0.30556],\n    \"8217\": [0, 0.69444, 0, 0, 0.30556],\n    \"8220\": [0, 0.69444, 0, 0, 0.55834],\n    \"8221\": [0, 0.69444, 0, 0, 0.55834]\n  },\n  \"SansSerif-Italic\": {\n    \"32\": [0, 0, 0, 0, 0.25],\n    \"33\": [0, 0.69444, 0.05733, 0, 0.31945],\n    \"34\": [0, 0.69444, 0.00316, 0, 0.5],\n    \"35\": [0.19444, 0.69444, 0.05087, 0, 0.83334],\n    \"36\": [0.05556, 0.75, 0.11156, 0, 0.5],\n    \"37\": [0.05556, 0.75, 0.03126, 0, 0.83334],\n    \"38\": [0, 0.69444, 0.03058, 0, 0.75834],\n    \"39\": [0, 0.69444, 0.07816, 0, 0.27778],\n    \"40\": [0.25, 0.75, 0.13164, 0, 0.38889],\n    \"41\": [0.25, 0.75, 0.02536, 0, 0.38889],\n    \"42\": [0, 0.75, 0.11775, 0, 0.5],\n    \"43\": [0.08333, 0.58333, 0.02536, 0, 0.77778],\n    \"44\": [0.125, 0.08333, 0, 0, 0.27778],\n    \"45\": [0, 0.44444, 0.01946, 0, 0.33333],\n    \"46\": [0, 0.08333, 0, 0, 0.27778],\n    \"47\": [0.25, 0.75, 0.13164, 0, 0.5],\n    \"48\": [0, 0.65556, 0.11156, 0, 0.5],\n    \"49\": [0, 0.65556, 0.11156, 0, 0.5],\n    \"50\": [0, 0.65556, 0.11156, 0, 0.5],\n    \"51\": [0, 0.65556, 0.11156, 0, 0.5],\n    \"52\": [0, 0.65556, 0.11156, 0, 0.5],\n    \"53\": [0, 0.65556, 0.11156, 0, 0.5],\n    \"54\": [0, 0.65556, 0.11156, 0, 0.5],\n    \"55\": [0, 0.65556, 0.11156, 0, 0.5],\n    \"56\": [0, 0.65556, 0.11156, 0, 0.5],\n    \"57\": [0, 0.65556, 0.11156, 0, 0.5],\n    \"58\": [0, 0.44444, 0.02502, 0, 0.27778],\n    \"59\": [0.125, 0.44444, 0.02502, 0, 0.27778],\n    \"61\": [-0.13, 0.37, 0.05087, 0, 0.77778],\n    \"63\": [0, 0.69444, 0.11809, 0, 0.47222],\n    \"64\": [0, 0.69444, 0.07555, 0, 0.66667],\n    \"65\": [0, 0.69444, 0, 0, 0.66667],\n    \"66\": [0, 0.69444, 0.08293, 0, 0.66667],\n    \"67\": [0, 0.69444, 0.11983, 0, 0.63889],\n    \"68\": [0, 0.69444, 0.07555, 0, 0.72223],\n    \"69\": [0, 0.69444, 0.11983, 0, 0.59722],\n    \"70\": [0, 0.69444, 0.13372, 0, 0.56945],\n    \"71\": [0, 0.69444, 0.11983, 0, 0.66667],\n    \"72\": [0, 0.69444, 0.08094, 0, 0.70834],\n    \"73\": [0, 0.69444, 0.13372, 0, 0.27778],\n    \"74\": [0, 0.69444, 0.08094, 0, 0.47222],\n    \"75\": [0, 0.69444, 0.11983, 0, 0.69445],\n    \"76\": [0, 0.69444, 0, 0, 0.54167],\n    \"77\": [0, 0.69444, 0.08094, 0, 0.875],\n    \"78\": [0, 0.69444, 0.08094, 0, 0.70834],\n    \"79\": [0, 0.69444, 0.07555, 0, 0.73611],\n    \"80\": [0, 0.69444, 0.08293, 0, 0.63889],\n    \"81\": [0.125, 0.69444, 0.07555, 0, 0.73611],\n    \"82\": [0, 0.69444, 0.08293, 0, 0.64584],\n    \"83\": [0, 0.69444, 0.09205, 0, 0.55556],\n    \"84\": [0, 0.69444, 0.13372, 0, 0.68056],\n    \"85\": [0, 0.69444, 0.08094, 0, 0.6875],\n    \"86\": [0, 0.69444, 0.1615, 0, 0.66667],\n    \"87\": [0, 0.69444, 0.1615, 0, 0.94445],\n    \"88\": [0, 0.69444, 0.13372, 0, 0.66667],\n    \"89\": [0, 0.69444, 0.17261, 0, 0.66667],\n    \"90\": [0, 0.69444, 0.11983, 0, 0.61111],\n    \"91\": [0.25, 0.75, 0.15942, 0, 0.28889],\n    \"93\": [0.25, 0.75, 0.08719, 0, 0.28889],\n    \"94\": [0, 0.69444, 0.0799, 0, 0.5],\n    \"95\": [0.35, 0.09444, 0.08616, 0, 0.5],\n    \"97\": [0, 0.44444, 0.00981, 0, 0.48056],\n    \"98\": [0, 0.69444, 0.03057, 0, 0.51667],\n    \"99\": [0, 0.44444, 0.08336, 0, 0.44445],\n    \"100\": [0, 0.69444, 0.09483, 0, 0.51667],\n    \"101\": [0, 0.44444, 0.06778, 0, 0.44445],\n    \"102\": [0, 0.69444, 0.21705, 0, 0.30556],\n    \"103\": [0.19444, 0.44444, 0.10836, 0, 0.5],\n    \"104\": [0, 0.69444, 0.01778, 0, 0.51667],\n    \"105\": [0, 0.67937, 0.09718, 0, 0.23889],\n    \"106\": [0.19444, 0.67937, 0.09162, 0, 0.26667],\n    \"107\": [0, 0.69444, 0.08336, 0, 0.48889],\n    \"108\": [0, 0.69444, 0.09483, 0, 0.23889],\n    \"109\": [0, 0.44444, 0.01778, 0, 0.79445],\n    \"110\": [0, 0.44444, 0.01778, 0, 0.51667],\n    \"111\": [0, 0.44444, 0.06613, 0, 0.5],\n    \"112\": [0.19444, 0.44444, 0.0389, 0, 0.51667],\n    \"113\": [0.19444, 0.44444, 0.04169, 0, 0.51667],\n    \"114\": [0, 0.44444, 0.10836, 0, 0.34167],\n    \"115\": [0, 0.44444, 0.0778, 0, 0.38333],\n    \"116\": [0, 0.57143, 0.07225, 0, 0.36111],\n    \"117\": [0, 0.44444, 0.04169, 0, 0.51667],\n    \"118\": [0, 0.44444, 0.10836, 0, 0.46111],\n    \"119\": [0, 0.44444, 0.10836, 0, 0.68334],\n    \"120\": [0, 0.44444, 0.09169, 0, 0.46111],\n    \"121\": [0.19444, 0.44444, 0.10836, 0, 0.46111],\n    \"122\": [0, 0.44444, 0.08752, 0, 0.43472],\n    \"126\": [0.35, 0.32659, 0.08826, 0, 0.5],\n    \"160\": [0, 0, 0, 0, 0.25],\n    \"168\": [0, 0.67937, 0.06385, 0, 0.5],\n    \"176\": [0, 0.69444, 0, 0, 0.73752],\n    \"184\": [0.17014, 0, 0, 0, 0.44445],\n    \"305\": [0, 0.44444, 0.04169, 0, 0.23889],\n    \"567\": [0.19444, 0.44444, 0.04169, 0, 0.26667],\n    \"710\": [0, 0.69444, 0.0799, 0, 0.5],\n    \"711\": [0, 0.63194, 0.08432, 0, 0.5],\n    \"713\": [0, 0.60889, 0.08776, 0, 0.5],\n    \"714\": [0, 0.69444, 0.09205, 0, 0.5],\n    \"715\": [0, 0.69444, 0, 0, 0.5],\n    \"728\": [0, 0.69444, 0.09483, 0, 0.5],\n    \"729\": [0, 0.67937, 0.07774, 0, 0.27778],\n    \"730\": [0, 0.69444, 0, 0, 0.73752],\n    \"732\": [0, 0.67659, 0.08826, 0, 0.5],\n    \"733\": [0, 0.69444, 0.09205, 0, 0.5],\n    \"915\": [0, 0.69444, 0.13372, 0, 0.54167],\n    \"916\": [0, 0.69444, 0, 0, 0.83334],\n    \"920\": [0, 0.69444, 0.07555, 0, 0.77778],\n    \"923\": [0, 0.69444, 0, 0, 0.61111],\n    \"926\": [0, 0.69444, 0.12816, 0, 0.66667],\n    \"928\": [0, 0.69444, 0.08094, 0, 0.70834],\n    \"931\": [0, 0.69444, 0.11983, 0, 0.72222],\n    \"933\": [0, 0.69444, 0.09031, 0, 0.77778],\n    \"934\": [0, 0.69444, 0.04603, 0, 0.72222],\n    \"936\": [0, 0.69444, 0.09031, 0, 0.77778],\n    \"937\": [0, 0.69444, 0.08293, 0, 0.72222],\n    \"8211\": [0, 0.44444, 0.08616, 0, 0.5],\n    \"8212\": [0, 0.44444, 0.08616, 0, 1.0],\n    \"8216\": [0, 0.69444, 0.07816, 0, 0.27778],\n    \"8217\": [0, 0.69444, 0.07816, 0, 0.27778],\n    \"8220\": [0, 0.69444, 0.14205, 0, 0.5],\n    \"8221\": [0, 0.69444, 0.00316, 0, 0.5]\n  },\n  \"SansSerif-Regular\": {\n    \"32\": [0, 0, 0, 0, 0.25],\n    \"33\": [0, 0.69444, 0, 0, 0.31945],\n    \"34\": [0, 0.69444, 0, 0, 0.5],\n    \"35\": [0.19444, 0.69444, 0, 0, 0.83334],\n    \"36\": [0.05556, 0.75, 0, 0, 0.5],\n    \"37\": [0.05556, 0.75, 0, 0, 0.83334],\n    \"38\": [0, 0.69444, 0, 0, 0.75834],\n    \"39\": [0, 0.69444, 0, 0, 0.27778],\n    \"40\": [0.25, 0.75, 0, 0, 0.38889],\n    \"41\": [0.25, 0.75, 0, 0, 0.38889],\n    \"42\": [0, 0.75, 0, 0, 0.5],\n    \"43\": [0.08333, 0.58333, 0, 0, 0.77778],\n    \"44\": [0.125, 0.08333, 0, 0, 0.27778],\n    \"45\": [0, 0.44444, 0, 0, 0.33333],\n    \"46\": [0, 0.08333, 0, 0, 0.27778],\n    \"47\": [0.25, 0.75, 0, 0, 0.5],\n    \"48\": [0, 0.65556, 0, 0, 0.5],\n    \"49\": [0, 0.65556, 0, 0, 0.5],\n    \"50\": [0, 0.65556, 0, 0, 0.5],\n    \"51\": [0, 0.65556, 0, 0, 0.5],\n    \"52\": [0, 0.65556, 0, 0, 0.5],\n    \"53\": [0, 0.65556, 0, 0, 0.5],\n    \"54\": [0, 0.65556, 0, 0, 0.5],\n    \"55\": [0, 0.65556, 0, 0, 0.5],\n    \"56\": [0, 0.65556, 0, 0, 0.5],\n    \"57\": [0, 0.65556, 0, 0, 0.5],\n    \"58\": [0, 0.44444, 0, 0, 0.27778],\n    \"59\": [0.125, 0.44444, 0, 0, 0.27778],\n    \"61\": [-0.13, 0.37, 0, 0, 0.77778],\n    \"63\": [0, 0.69444, 0, 0, 0.47222],\n    \"64\": [0, 0.69444, 0, 0, 0.66667],\n    \"65\": [0, 0.69444, 0, 0, 0.66667],\n    \"66\": [0, 0.69444, 0, 0, 0.66667],\n    \"67\": [0, 0.69444, 0, 0, 0.63889],\n    \"68\": [0, 0.69444, 0, 0, 0.72223],\n    \"69\": [0, 0.69444, 0, 0, 0.59722],\n    \"70\": [0, 0.69444, 0, 0, 0.56945],\n    \"71\": [0, 0.69444, 0, 0, 0.66667],\n    \"72\": [0, 0.69444, 0, 0, 0.70834],\n    \"73\": [0, 0.69444, 0, 0, 0.27778],\n    \"74\": [0, 0.69444, 0, 0, 0.47222],\n    \"75\": [0, 0.69444, 0, 0, 0.69445],\n    \"76\": [0, 0.69444, 0, 0, 0.54167],\n    \"77\": [0, 0.69444, 0, 0, 0.875],\n    \"78\": [0, 0.69444, 0, 0, 0.70834],\n    \"79\": [0, 0.69444, 0, 0, 0.73611],\n    \"80\": [0, 0.69444, 0, 0, 0.63889],\n    \"81\": [0.125, 0.69444, 0, 0, 0.73611],\n    \"82\": [0, 0.69444, 0, 0, 0.64584],\n    \"83\": [0, 0.69444, 0, 0, 0.55556],\n    \"84\": [0, 0.69444, 0, 0, 0.68056],\n    \"85\": [0, 0.69444, 0, 0, 0.6875],\n    \"86\": [0, 0.69444, 0.01389, 0, 0.66667],\n    \"87\": [0, 0.69444, 0.01389, 0, 0.94445],\n    \"88\": [0, 0.69444, 0, 0, 0.66667],\n    \"89\": [0, 0.69444, 0.025, 0, 0.66667],\n    \"90\": [0, 0.69444, 0, 0, 0.61111],\n    \"91\": [0.25, 0.75, 0, 0, 0.28889],\n    \"93\": [0.25, 0.75, 0, 0, 0.28889],\n    \"94\": [0, 0.69444, 0, 0, 0.5],\n    \"95\": [0.35, 0.09444, 0.02778, 0, 0.5],\n    \"97\": [0, 0.44444, 0, 0, 0.48056],\n    \"98\": [0, 0.69444, 0, 0, 0.51667],\n    \"99\": [0, 0.44444, 0, 0, 0.44445],\n    \"100\": [0, 0.69444, 0, 0, 0.51667],\n    \"101\": [0, 0.44444, 0, 0, 0.44445],\n    \"102\": [0, 0.69444, 0.06944, 0, 0.30556],\n    \"103\": [0.19444, 0.44444, 0.01389, 0, 0.5],\n    \"104\": [0, 0.69444, 0, 0, 0.51667],\n    \"105\": [0, 0.67937, 0, 0, 0.23889],\n    \"106\": [0.19444, 0.67937, 0, 0, 0.26667],\n    \"107\": [0, 0.69444, 0, 0, 0.48889],\n    \"108\": [0, 0.69444, 0, 0, 0.23889],\n    \"109\": [0, 0.44444, 0, 0, 0.79445],\n    \"110\": [0, 0.44444, 0, 0, 0.51667],\n    \"111\": [0, 0.44444, 0, 0, 0.5],\n    \"112\": [0.19444, 0.44444, 0, 0, 0.51667],\n    \"113\": [0.19444, 0.44444, 0, 0, 0.51667],\n    \"114\": [0, 0.44444, 0.01389, 0, 0.34167],\n    \"115\": [0, 0.44444, 0, 0, 0.38333],\n    \"116\": [0, 0.57143, 0, 0, 0.36111],\n    \"117\": [0, 0.44444, 0, 0, 0.51667],\n    \"118\": [0, 0.44444, 0.01389, 0, 0.46111],\n    \"119\": [0, 0.44444, 0.01389, 0, 0.68334],\n    \"120\": [0, 0.44444, 0, 0, 0.46111],\n    \"121\": [0.19444, 0.44444, 0.01389, 0, 0.46111],\n    \"122\": [0, 0.44444, 0, 0, 0.43472],\n    \"126\": [0.35, 0.32659, 0, 0, 0.5],\n    \"160\": [0, 0, 0, 0, 0.25],\n    \"168\": [0, 0.67937, 0, 0, 0.5],\n    \"176\": [0, 0.69444, 0, 0, 0.66667],\n    \"184\": [0.17014, 0, 0, 0, 0.44445],\n    \"305\": [0, 0.44444, 0, 0, 0.23889],\n    \"567\": [0.19444, 0.44444, 0, 0, 0.26667],\n    \"710\": [0, 0.69444, 0, 0, 0.5],\n    \"711\": [0, 0.63194, 0, 0, 0.5],\n    \"713\": [0, 0.60889, 0, 0, 0.5],\n    \"714\": [0, 0.69444, 0, 0, 0.5],\n    \"715\": [0, 0.69444, 0, 0, 0.5],\n    \"728\": [0, 0.69444, 0, 0, 0.5],\n    \"729\": [0, 0.67937, 0, 0, 0.27778],\n    \"730\": [0, 0.69444, 0, 0, 0.66667],\n    \"732\": [0, 0.67659, 0, 0, 0.5],\n    \"733\": [0, 0.69444, 0, 0, 0.5],\n    \"915\": [0, 0.69444, 0, 0, 0.54167],\n    \"916\": [0, 0.69444, 0, 0, 0.83334],\n    \"920\": [0, 0.69444, 0, 0, 0.77778],\n    \"923\": [0, 0.69444, 0, 0, 0.61111],\n    \"926\": [0, 0.69444, 0, 0, 0.66667],\n    \"928\": [0, 0.69444, 0, 0, 0.70834],\n    \"931\": [0, 0.69444, 0, 0, 0.72222],\n    \"933\": [0, 0.69444, 0, 0, 0.77778],\n    \"934\": [0, 0.69444, 0, 0, 0.72222],\n    \"936\": [0, 0.69444, 0, 0, 0.77778],\n    \"937\": [0, 0.69444, 0, 0, 0.72222],\n    \"8211\": [0, 0.44444, 0.02778, 0, 0.5],\n    \"8212\": [0, 0.44444, 0.02778, 0, 1.0],\n    \"8216\": [0, 0.69444, 0, 0, 0.27778],\n    \"8217\": [0, 0.69444, 0, 0, 0.27778],\n    \"8220\": [0, 0.69444, 0, 0, 0.5],\n    \"8221\": [0, 0.69444, 0, 0, 0.5]\n  },\n  \"Script-Regular\": {\n    \"32\": [0, 0, 0, 0, 0.25],\n    \"65\": [0, 0.7, 0.22925, 0, 0.80253],\n    \"66\": [0, 0.7, 0.04087, 0, 0.90757],\n    \"67\": [0, 0.7, 0.1689, 0, 0.66619],\n    \"68\": [0, 0.7, 0.09371, 0, 0.77443],\n    \"69\": [0, 0.7, 0.18583, 0, 0.56162],\n    \"70\": [0, 0.7, 0.13634, 0, 0.89544],\n    \"71\": [0, 0.7, 0.17322, 0, 0.60961],\n    \"72\": [0, 0.7, 0.29694, 0, 0.96919],\n    \"73\": [0, 0.7, 0.19189, 0, 0.80907],\n    \"74\": [0.27778, 0.7, 0.19189, 0, 1.05159],\n    \"75\": [0, 0.7, 0.31259, 0, 0.91364],\n    \"76\": [0, 0.7, 0.19189, 0, 0.87373],\n    \"77\": [0, 0.7, 0.15981, 0, 1.08031],\n    \"78\": [0, 0.7, 0.3525, 0, 0.9015],\n    \"79\": [0, 0.7, 0.08078, 0, 0.73787],\n    \"80\": [0, 0.7, 0.08078, 0, 1.01262],\n    \"81\": [0, 0.7, 0.03305, 0, 0.88282],\n    \"82\": [0, 0.7, 0.06259, 0, 0.85],\n    \"83\": [0, 0.7, 0.19189, 0, 0.86767],\n    \"84\": [0, 0.7, 0.29087, 0, 0.74697],\n    \"85\": [0, 0.7, 0.25815, 0, 0.79996],\n    \"86\": [0, 0.7, 0.27523, 0, 0.62204],\n    \"87\": [0, 0.7, 0.27523, 0, 0.80532],\n    \"88\": [0, 0.7, 0.26006, 0, 0.94445],\n    \"89\": [0, 0.7, 0.2939, 0, 0.70961],\n    \"90\": [0, 0.7, 0.24037, 0, 0.8212],\n    \"160\": [0, 0, 0, 0, 0.25]\n  },\n  \"Size1-Regular\": {\n    \"32\": [0, 0, 0, 0, 0.25],\n    \"40\": [0.35001, 0.85, 0, 0, 0.45834],\n    \"41\": [0.35001, 0.85, 0, 0, 0.45834],\n    \"47\": [0.35001, 0.85, 0, 0, 0.57778],\n    \"91\": [0.35001, 0.85, 0, 0, 0.41667],\n    \"92\": [0.35001, 0.85, 0, 0, 0.57778],\n    \"93\": [0.35001, 0.85, 0, 0, 0.41667],\n    \"123\": [0.35001, 0.85, 0, 0, 0.58334],\n    \"125\": [0.35001, 0.85, 0, 0, 0.58334],\n    \"160\": [0, 0, 0, 0, 0.25],\n    \"710\": [0, 0.72222, 0, 0, 0.55556],\n    \"732\": [0, 0.72222, 0, 0, 0.55556],\n    \"770\": [0, 0.72222, 0, 0, 0.55556],\n    \"771\": [0, 0.72222, 0, 0, 0.55556],\n    \"8214\": [-0.00099, 0.601, 0, 0, 0.77778],\n    \"8593\": [1e-05, 0.6, 0, 0, 0.66667],\n    \"8595\": [1e-05, 0.6, 0, 0, 0.66667],\n    \"8657\": [1e-05, 0.6, 0, 0, 0.77778],\n    \"8659\": [1e-05, 0.6, 0, 0, 0.77778],\n    \"8719\": [0.25001, 0.75, 0, 0, 0.94445],\n    \"8720\": [0.25001, 0.75, 0, 0, 0.94445],\n    \"8721\": [0.25001, 0.75, 0, 0, 1.05556],\n    \"8730\": [0.35001, 0.85, 0, 0, 1.0],\n    \"8739\": [-0.00599, 0.606, 0, 0, 0.33333],\n    \"8741\": [-0.00599, 0.606, 0, 0, 0.55556],\n    \"8747\": [0.30612, 0.805, 0.19445, 0, 0.47222],\n    \"8748\": [0.306, 0.805, 0.19445, 0, 0.47222],\n    \"8749\": [0.306, 0.805, 0.19445, 0, 0.47222],\n    \"8750\": [0.30612, 0.805, 0.19445, 0, 0.47222],\n    \"8896\": [0.25001, 0.75, 0, 0, 0.83334],\n    \"8897\": [0.25001, 0.75, 0, 0, 0.83334],\n    \"8898\": [0.25001, 0.75, 0, 0, 0.83334],\n    \"8899\": [0.25001, 0.75, 0, 0, 0.83334],\n    \"8968\": [0.35001, 0.85, 0, 0, 0.47222],\n    \"8969\": [0.35001, 0.85, 0, 0, 0.47222],\n    \"8970\": [0.35001, 0.85, 0, 0, 0.47222],\n    \"8971\": [0.35001, 0.85, 0, 0, 0.47222],\n    \"9168\": [-0.00099, 0.601, 0, 0, 0.66667],\n    \"10216\": [0.35001, 0.85, 0, 0, 0.47222],\n    \"10217\": [0.35001, 0.85, 0, 0, 0.47222],\n    \"10752\": [0.25001, 0.75, 0, 0, 1.11111],\n    \"10753\": [0.25001, 0.75, 0, 0, 1.11111],\n    \"10754\": [0.25001, 0.75, 0, 0, 1.11111],\n    \"10756\": [0.25001, 0.75, 0, 0, 0.83334],\n    \"10758\": [0.25001, 0.75, 0, 0, 0.83334]\n  },\n  \"Size2-Regular\": {\n    \"32\": [0, 0, 0, 0, 0.25],\n    \"40\": [0.65002, 1.15, 0, 0, 0.59722],\n    \"41\": [0.65002, 1.15, 0, 0, 0.59722],\n    \"47\": [0.65002, 1.15, 0, 0, 0.81111],\n    \"91\": [0.65002, 1.15, 0, 0, 0.47222],\n    \"92\": [0.65002, 1.15, 0, 0, 0.81111],\n    \"93\": [0.65002, 1.15, 0, 0, 0.47222],\n    \"123\": [0.65002, 1.15, 0, 0, 0.66667],\n    \"125\": [0.65002, 1.15, 0, 0, 0.66667],\n    \"160\": [0, 0, 0, 0, 0.25],\n    \"710\": [0, 0.75, 0, 0, 1.0],\n    \"732\": [0, 0.75, 0, 0, 1.0],\n    \"770\": [0, 0.75, 0, 0, 1.0],\n    \"771\": [0, 0.75, 0, 0, 1.0],\n    \"8719\": [0.55001, 1.05, 0, 0, 1.27778],\n    \"8720\": [0.55001, 1.05, 0, 0, 1.27778],\n    \"8721\": [0.55001, 1.05, 0, 0, 1.44445],\n    \"8730\": [0.65002, 1.15, 0, 0, 1.0],\n    \"8747\": [0.86225, 1.36, 0.44445, 0, 0.55556],\n    \"8748\": [0.862, 1.36, 0.44445, 0, 0.55556],\n    \"8749\": [0.862, 1.36, 0.44445, 0, 0.55556],\n    \"8750\": [0.86225, 1.36, 0.44445, 0, 0.55556],\n    \"8896\": [0.55001, 1.05, 0, 0, 1.11111],\n    \"8897\": [0.55001, 1.05, 0, 0, 1.11111],\n    \"8898\": [0.55001, 1.05, 0, 0, 1.11111],\n    \"8899\": [0.55001, 1.05, 0, 0, 1.11111],\n    \"8968\": [0.65002, 1.15, 0, 0, 0.52778],\n    \"8969\": [0.65002, 1.15, 0, 0, 0.52778],\n    \"8970\": [0.65002, 1.15, 0, 0, 0.52778],\n    \"8971\": [0.65002, 1.15, 0, 0, 0.52778],\n    \"10216\": [0.65002, 1.15, 0, 0, 0.61111],\n    \"10217\": [0.65002, 1.15, 0, 0, 0.61111],\n    \"10752\": [0.55001, 1.05, 0, 0, 1.51112],\n    \"10753\": [0.55001, 1.05, 0, 0, 1.51112],\n    \"10754\": [0.55001, 1.05, 0, 0, 1.51112],\n    \"10756\": [0.55001, 1.05, 0, 0, 1.11111],\n    \"10758\": [0.55001, 1.05, 0, 0, 1.11111]\n  },\n  \"Size3-Regular\": {\n    \"32\": [0, 0, 0, 0, 0.25],\n    \"40\": [0.95003, 1.45, 0, 0, 0.73611],\n    \"41\": [0.95003, 1.45, 0, 0, 0.73611],\n    \"47\": [0.95003, 1.45, 0, 0, 1.04445],\n    \"91\": [0.95003, 1.45, 0, 0, 0.52778],\n    \"92\": [0.95003, 1.45, 0, 0, 1.04445],\n    \"93\": [0.95003, 1.45, 0, 0, 0.52778],\n    \"123\": [0.95003, 1.45, 0, 0, 0.75],\n    \"125\": [0.95003, 1.45, 0, 0, 0.75],\n    \"160\": [0, 0, 0, 0, 0.25],\n    \"710\": [0, 0.75, 0, 0, 1.44445],\n    \"732\": [0, 0.75, 0, 0, 1.44445],\n    \"770\": [0, 0.75, 0, 0, 1.44445],\n    \"771\": [0, 0.75, 0, 0, 1.44445],\n    \"8730\": [0.95003, 1.45, 0, 0, 1.0],\n    \"8968\": [0.95003, 1.45, 0, 0, 0.58334],\n    \"8969\": [0.95003, 1.45, 0, 0, 0.58334],\n    \"8970\": [0.95003, 1.45, 0, 0, 0.58334],\n    \"8971\": [0.95003, 1.45, 0, 0, 0.58334],\n    \"10216\": [0.95003, 1.45, 0, 0, 0.75],\n    \"10217\": [0.95003, 1.45, 0, 0, 0.75]\n  },\n  \"Size4-Regular\": {\n    \"32\": [0, 0, 0, 0, 0.25],\n    \"40\": [1.25003, 1.75, 0, 0, 0.79167],\n    \"41\": [1.25003, 1.75, 0, 0, 0.79167],\n    \"47\": [1.25003, 1.75, 0, 0, 1.27778],\n    \"91\": [1.25003, 1.75, 0, 0, 0.58334],\n    \"92\": [1.25003, 1.75, 0, 0, 1.27778],\n    \"93\": [1.25003, 1.75, 0, 0, 0.58334],\n    \"123\": [1.25003, 1.75, 0, 0, 0.80556],\n    \"125\": [1.25003, 1.75, 0, 0, 0.80556],\n    \"160\": [0, 0, 0, 0, 0.25],\n    \"710\": [0, 0.825, 0, 0, 1.8889],\n    \"732\": [0, 0.825, 0, 0, 1.8889],\n    \"770\": [0, 0.825, 0, 0, 1.8889],\n    \"771\": [0, 0.825, 0, 0, 1.8889],\n    \"8730\": [1.25003, 1.75, 0, 0, 1.0],\n    \"8968\": [1.25003, 1.75, 0, 0, 0.63889],\n    \"8969\": [1.25003, 1.75, 0, 0, 0.63889],\n    \"8970\": [1.25003, 1.75, 0, 0, 0.63889],\n    \"8971\": [1.25003, 1.75, 0, 0, 0.63889],\n    \"9115\": [0.64502, 1.155, 0, 0, 0.875],\n    \"9116\": [1e-05, 0.6, 0, 0, 0.875],\n    \"9117\": [0.64502, 1.155, 0, 0, 0.875],\n    \"9118\": [0.64502, 1.155, 0, 0, 0.875],\n    \"9119\": [1e-05, 0.6, 0, 0, 0.875],\n    \"9120\": [0.64502, 1.155, 0, 0, 0.875],\n    \"9121\": [0.64502, 1.155, 0, 0, 0.66667],\n    \"9122\": [-0.00099, 0.601, 0, 0, 0.66667],\n    \"9123\": [0.64502, 1.155, 0, 0, 0.66667],\n    \"9124\": [0.64502, 1.155, 0, 0, 0.66667],\n    \"9125\": [-0.00099, 0.601, 0, 0, 0.66667],\n    \"9126\": [0.64502, 1.155, 0, 0, 0.66667],\n    \"9127\": [1e-05, 0.9, 0, 0, 0.88889],\n    \"9128\": [0.65002, 1.15, 0, 0, 0.88889],\n    \"9129\": [0.90001, 0, 0, 0, 0.88889],\n    \"9130\": [0, 0.3, 0, 0, 0.88889],\n    \"9131\": [1e-05, 0.9, 0, 0, 0.88889],\n    \"9132\": [0.65002, 1.15, 0, 0, 0.88889],\n    \"9133\": [0.90001, 0, 0, 0, 0.88889],\n    \"9143\": [0.88502, 0.915, 0, 0, 1.05556],\n    \"10216\": [1.25003, 1.75, 0, 0, 0.80556],\n    \"10217\": [1.25003, 1.75, 0, 0, 0.80556],\n    \"57344\": [-0.00499, 0.605, 0, 0, 1.05556],\n    \"57345\": [-0.00499, 0.605, 0, 0, 1.05556],\n    \"57680\": [0, 0.12, 0, 0, 0.45],\n    \"57681\": [0, 0.12, 0, 0, 0.45],\n    \"57682\": [0, 0.12, 0, 0, 0.45],\n    \"57683\": [0, 0.12, 0, 0, 0.45]\n  },\n  \"Typewriter-Regular\": {\n    \"32\": [0, 0, 0, 0, 0.525],\n    \"33\": [0, 0.61111, 0, 0, 0.525],\n    \"34\": [0, 0.61111, 0, 0, 0.525],\n    \"35\": [0, 0.61111, 0, 0, 0.525],\n    \"36\": [0.08333, 0.69444, 0, 0, 0.525],\n    \"37\": [0.08333, 0.69444, 0, 0, 0.525],\n    \"38\": [0, 0.61111, 0, 0, 0.525],\n    \"39\": [0, 0.61111, 0, 0, 0.525],\n    \"40\": [0.08333, 0.69444, 0, 0, 0.525],\n    \"41\": [0.08333, 0.69444, 0, 0, 0.525],\n    \"42\": [0, 0.52083, 0, 0, 0.525],\n    \"43\": [-0.08056, 0.53055, 0, 0, 0.525],\n    \"44\": [0.13889, 0.125, 0, 0, 0.525],\n    \"45\": [-0.08056, 0.53055, 0, 0, 0.525],\n    \"46\": [0, 0.125, 0, 0, 0.525],\n    \"47\": [0.08333, 0.69444, 0, 0, 0.525],\n    \"48\": [0, 0.61111, 0, 0, 0.525],\n    \"49\": [0, 0.61111, 0, 0, 0.525],\n    \"50\": [0, 0.61111, 0, 0, 0.525],\n    \"51\": [0, 0.61111, 0, 0, 0.525],\n    \"52\": [0, 0.61111, 0, 0, 0.525],\n    \"53\": [0, 0.61111, 0, 0, 0.525],\n    \"54\": [0, 0.61111, 0, 0, 0.525],\n    \"55\": [0, 0.61111, 0, 0, 0.525],\n    \"56\": [0, 0.61111, 0, 0, 0.525],\n    \"57\": [0, 0.61111, 0, 0, 0.525],\n    \"58\": [0, 0.43056, 0, 0, 0.525],\n    \"59\": [0.13889, 0.43056, 0, 0, 0.525],\n    \"60\": [-0.05556, 0.55556, 0, 0, 0.525],\n    \"61\": [-0.19549, 0.41562, 0, 0, 0.525],\n    \"62\": [-0.05556, 0.55556, 0, 0, 0.525],\n    \"63\": [0, 0.61111, 0, 0, 0.525],\n    \"64\": [0, 0.61111, 0, 0, 0.525],\n    \"65\": [0, 0.61111, 0, 0, 0.525],\n    \"66\": [0, 0.61111, 0, 0, 0.525],\n    \"67\": [0, 0.61111, 0, 0, 0.525],\n    \"68\": [0, 0.61111, 0, 0, 0.525],\n    \"69\": [0, 0.61111, 0, 0, 0.525],\n    \"70\": [0, 0.61111, 0, 0, 0.525],\n    \"71\": [0, 0.61111, 0, 0, 0.525],\n    \"72\": [0, 0.61111, 0, 0, 0.525],\n    \"73\": [0, 0.61111, 0, 0, 0.525],\n    \"74\": [0, 0.61111, 0, 0, 0.525],\n    \"75\": [0, 0.61111, 0, 0, 0.525],\n    \"76\": [0, 0.61111, 0, 0, 0.525],\n    \"77\": [0, 0.61111, 0, 0, 0.525],\n    \"78\": [0, 0.61111, 0, 0, 0.525],\n    \"79\": [0, 0.61111, 0, 0, 0.525],\n    \"80\": [0, 0.61111, 0, 0, 0.525],\n    \"81\": [0.13889, 0.61111, 0, 0, 0.525],\n    \"82\": [0, 0.61111, 0, 0, 0.525],\n    \"83\": [0, 0.61111, 0, 0, 0.525],\n    \"84\": [0, 0.61111, 0, 0, 0.525],\n    \"85\": [0, 0.61111, 0, 0, 0.525],\n    \"86\": [0, 0.61111, 0, 0, 0.525],\n    \"87\": [0, 0.61111, 0, 0, 0.525],\n    \"88\": [0, 0.61111, 0, 0, 0.525],\n    \"89\": [0, 0.61111, 0, 0, 0.525],\n    \"90\": [0, 0.61111, 0, 0, 0.525],\n    \"91\": [0.08333, 0.69444, 0, 0, 0.525],\n    \"92\": [0.08333, 0.69444, 0, 0, 0.525],\n    \"93\": [0.08333, 0.69444, 0, 0, 0.525],\n    \"94\": [0, 0.61111, 0, 0, 0.525],\n    \"95\": [0.09514, 0, 0, 0, 0.525],\n    \"96\": [0, 0.61111, 0, 0, 0.525],\n    \"97\": [0, 0.43056, 0, 0, 0.525],\n    \"98\": [0, 0.61111, 0, 0, 0.525],\n    \"99\": [0, 0.43056, 0, 0, 0.525],\n    \"100\": [0, 0.61111, 0, 0, 0.525],\n    \"101\": [0, 0.43056, 0, 0, 0.525],\n    \"102\": [0, 0.61111, 0, 0, 0.525],\n    \"103\": [0.22222, 0.43056, 0, 0, 0.525],\n    \"104\": [0, 0.61111, 0, 0, 0.525],\n    \"105\": [0, 0.61111, 0, 0, 0.525],\n    \"106\": [0.22222, 0.61111, 0, 0, 0.525],\n    \"107\": [0, 0.61111, 0, 0, 0.525],\n    \"108\": [0, 0.61111, 0, 0, 0.525],\n    \"109\": [0, 0.43056, 0, 0, 0.525],\n    \"110\": [0, 0.43056, 0, 0, 0.525],\n    \"111\": [0, 0.43056, 0, 0, 0.525],\n    \"112\": [0.22222, 0.43056, 0, 0, 0.525],\n    \"113\": [0.22222, 0.43056, 0, 0, 0.525],\n    \"114\": [0, 0.43056, 0, 0, 0.525],\n    \"115\": [0, 0.43056, 0, 0, 0.525],\n    \"116\": [0, 0.55358, 0, 0, 0.525],\n    \"117\": [0, 0.43056, 0, 0, 0.525],\n    \"118\": [0, 0.43056, 0, 0, 0.525],\n    \"119\": [0, 0.43056, 0, 0, 0.525],\n    \"120\": [0, 0.43056, 0, 0, 0.525],\n    \"121\": [0.22222, 0.43056, 0, 0, 0.525],\n    \"122\": [0, 0.43056, 0, 0, 0.525],\n    \"123\": [0.08333, 0.69444, 0, 0, 0.525],\n    \"124\": [0.08333, 0.69444, 0, 0, 0.525],\n    \"125\": [0.08333, 0.69444, 0, 0, 0.525],\n    \"126\": [0, 0.61111, 0, 0, 0.525],\n    \"127\": [0, 0.61111, 0, 0, 0.525],\n    \"160\": [0, 0, 0, 0, 0.525],\n    \"176\": [0, 0.61111, 0, 0, 0.525],\n    \"184\": [0.19445, 0, 0, 0, 0.525],\n    \"305\": [0, 0.43056, 0, 0, 0.525],\n    \"567\": [0.22222, 0.43056, 0, 0, 0.525],\n    \"711\": [0, 0.56597, 0, 0, 0.525],\n    \"713\": [0, 0.56555, 0, 0, 0.525],\n    \"714\": [0, 0.61111, 0, 0, 0.525],\n    \"715\": [0, 0.61111, 0, 0, 0.525],\n    \"728\": [0, 0.61111, 0, 0, 0.525],\n    \"730\": [0, 0.61111, 0, 0, 0.525],\n    \"770\": [0, 0.61111, 0, 0, 0.525],\n    \"771\": [0, 0.61111, 0, 0, 0.525],\n    \"776\": [0, 0.61111, 0, 0, 0.525],\n    \"915\": [0, 0.61111, 0, 0, 0.525],\n    \"916\": [0, 0.61111, 0, 0, 0.525],\n    \"920\": [0, 0.61111, 0, 0, 0.525],\n    \"923\": [0, 0.61111, 0, 0, 0.525],\n    \"926\": [0, 0.61111, 0, 0, 0.525],\n    \"928\": [0, 0.61111, 0, 0, 0.525],\n    \"931\": [0, 0.61111, 0, 0, 0.525],\n    \"933\": [0, 0.61111, 0, 0, 0.525],\n    \"934\": [0, 0.61111, 0, 0, 0.525],\n    \"936\": [0, 0.61111, 0, 0, 0.525],\n    \"937\": [0, 0.61111, 0, 0, 0.525],\n    \"8216\": [0, 0.61111, 0, 0, 0.525],\n    \"8217\": [0, 0.61111, 0, 0, 0.525],\n    \"8242\": [0, 0.61111, 0, 0, 0.525],\n    \"9251\": [0.11111, 0.21944, 0, 0, 0.525]\n  }\n};\n\n/**\n * This file contains metrics regarding fonts and individual symbols. The sigma\n * and xi variables, as well as the metricMap map contain data extracted from\n * TeX, TeX font metrics, and the TTF files. These data are then exposed via the\n * `metrics` variable and the getCharacterMetrics function.\n */\n// In TeX, there are actually three sets of dimensions, one for each of\n// textstyle (size index 5 and higher: >=9pt), scriptstyle (size index 3 and 4:\n// 7-8pt), and scriptscriptstyle (size index 1 and 2: 5-6pt).  These are\n// provided in the arrays below, in that order.\n//\n// The font metrics are stored in fonts cmsy10, cmsy7, and cmsy5 respectively.\n// This was determined by running the following script:\n//\n//     latex -interaction=nonstopmode \\\n//     '\\documentclass{article}\\usepackage{amsmath}\\begin{document}' \\\n//     '$a$ \\expandafter\\show\\the\\textfont2' \\\n//     '\\expandafter\\show\\the\\scriptfont2' \\\n//     '\\expandafter\\show\\the\\scriptscriptfont2' \\\n//     '\\stop'\n//\n// The metrics themselves were retrieved using the following commands:\n//\n//     tftopl cmsy10\n//     tftopl cmsy7\n//     tftopl cmsy5\n//\n// The output of each of these commands is quite lengthy.  The only part we\n// care about is the FONTDIMEN section. Each value is measured in EMs.\nvar sigmasAndXis = {\n  slant: [0.250, 0.250, 0.250],\n  // sigma1\n  space: [0.000, 0.000, 0.000],\n  // sigma2\n  stretch: [0.000, 0.000, 0.000],\n  // sigma3\n  shrink: [0.000, 0.000, 0.000],\n  // sigma4\n  xHeight: [0.431, 0.431, 0.431],\n  // sigma5\n  quad: [1.000, 1.171, 1.472],\n  // sigma6\n  extraSpace: [0.000, 0.000, 0.000],\n  // sigma7\n  num1: [0.677, 0.732, 0.925],\n  // sigma8\n  num2: [0.394, 0.384, 0.387],\n  // sigma9\n  num3: [0.444, 0.471, 0.504],\n  // sigma10\n  denom1: [0.686, 0.752, 1.025],\n  // sigma11\n  denom2: [0.345, 0.344, 0.532],\n  // sigma12\n  sup1: [0.413, 0.503, 0.504],\n  // sigma13\n  sup2: [0.363, 0.431, 0.404],\n  // sigma14\n  sup3: [0.289, 0.286, 0.294],\n  // sigma15\n  sub1: [0.150, 0.143, 0.200],\n  // sigma16\n  sub2: [0.247, 0.286, 0.400],\n  // sigma17\n  supDrop: [0.386, 0.353, 0.494],\n  // sigma18\n  subDrop: [0.050, 0.071, 0.100],\n  // sigma19\n  delim1: [2.390, 1.700, 1.980],\n  // sigma20\n  delim2: [1.010, 1.157, 1.420],\n  // sigma21\n  axisHeight: [0.250, 0.250, 0.250],\n  // sigma22\n  // These font metrics are extracted from TeX by using tftopl on cmex10.tfm;\n  // they correspond to the font parameters of the extension fonts (family 3).\n  // See the TeXbook, page 441. In AMSTeX, the extension fonts scale; to\n  // match cmex7, we'd use cmex7.tfm values for script and scriptscript\n  // values.\n  defaultRuleThickness: [0.04, 0.049, 0.049],\n  // xi8; cmex7: 0.049\n  bigOpSpacing1: [0.111, 0.111, 0.111],\n  // xi9\n  bigOpSpacing2: [0.166, 0.166, 0.166],\n  // xi10\n  bigOpSpacing3: [0.2, 0.2, 0.2],\n  // xi11\n  bigOpSpacing4: [0.6, 0.611, 0.611],\n  // xi12; cmex7: 0.611\n  bigOpSpacing5: [0.1, 0.143, 0.143],\n  // xi13; cmex7: 0.143\n  // The \\sqrt rule width is taken from the height of the surd character.\n  // Since we use the same font at all sizes, this thickness doesn't scale.\n  sqrtRuleThickness: [0.04, 0.04, 0.04],\n  // This value determines how large a pt is, for metrics which are defined\n  // in terms of pts.\n  // This value is also used in katex.scss; if you change it make sure the\n  // values match.\n  ptPerEm: [10.0, 10.0, 10.0],\n  // The space between adjacent `|` columns in an array definition. From\n  // `\\showthe\\doublerulesep` in LaTeX. Equals 2.0 / ptPerEm.\n  doubleRuleSep: [0.2, 0.2, 0.2],\n  // The width of separator lines in {array} environments. From\n  // `\\showthe\\arrayrulewidth` in LaTeX. Equals 0.4 / ptPerEm.\n  arrayRuleWidth: [0.04, 0.04, 0.04],\n  // Two values from LaTeX source2e:\n  fboxsep: [0.3, 0.3, 0.3],\n  //        3 pt / ptPerEm\n  fboxrule: [0.04, 0.04, 0.04] // 0.4 pt / ptPerEm\n\n}; // This map contains a mapping from font name and character code to character\n// should have Latin-1 and Cyrillic characters, but may not depending on the\n// operating system.  The metrics do not account for extra height from the\n// accents.  In the case of Cyrillic characters which have both ascenders and\n// descenders we prefer approximations with ascenders, primarily to prevent\n// the fraction bar or root line from intersecting the glyph.\n// TODO(kevinb) allow union of multiple glyph metrics for better accuracy.\n\nvar extraCharacterMap = {\n  // Latin-1\n  'Å': 'A',\n  'Ð': 'D',\n  'Þ': 'o',\n  'å': 'a',\n  'ð': 'd',\n  'þ': 'o',\n  // Cyrillic\n  'А': 'A',\n  'Б': 'B',\n  'В': 'B',\n  'Г': 'F',\n  'Д': 'A',\n  'Е': 'E',\n  'Ж': 'K',\n  'З': '3',\n  'И': 'N',\n  'Й': 'N',\n  'К': 'K',\n  'Л': 'N',\n  'М': 'M',\n  'Н': 'H',\n  'О': 'O',\n  'П': 'N',\n  'Р': 'P',\n  'С': 'C',\n  'Т': 'T',\n  'У': 'y',\n  'Ф': 'O',\n  'Х': 'X',\n  'Ц': 'U',\n  'Ч': 'h',\n  'Ш': 'W',\n  'Щ': 'W',\n  'Ъ': 'B',\n  'Ы': 'X',\n  'Ь': 'B',\n  'Э': '3',\n  'Ю': 'X',\n  'Я': 'R',\n  'а': 'a',\n  'б': 'b',\n  'в': 'a',\n  'г': 'r',\n  'д': 'y',\n  'е': 'e',\n  'ж': 'm',\n  'з': 'e',\n  'и': 'n',\n  'й': 'n',\n  'к': 'n',\n  'л': 'n',\n  'м': 'm',\n  'н': 'n',\n  'о': 'o',\n  'п': 'n',\n  'р': 'p',\n  'с': 'c',\n  'т': 'o',\n  'у': 'y',\n  'ф': 'b',\n  'х': 'x',\n  'ц': 'n',\n  'ч': 'n',\n  'ш': 'w',\n  'щ': 'w',\n  'ъ': 'a',\n  'ы': 'm',\n  'ь': 'a',\n  'э': 'e',\n  'ю': 'm',\n  'я': 'r'\n};\n\n/**\n * This function adds new font metrics to default metricMap\n * It can also override existing metrics\n */\nfunction setFontMetrics(fontName, metrics) {\n  fontMetricsData[fontName] = metrics;\n}\n/**\n * This function is a convenience function for looking up information in the\n * metricMap table. It takes a character as a string, and a font.\n *\n * Note: the `width` property may be undefined if fontMetricsData.js wasn't\n * built using `Make extended_metrics`.\n */\n\nfunction getCharacterMetrics(character, font, mode) {\n  if (!fontMetricsData[font]) {\n    throw new Error(\"Font metrics not found for font: \" + font + \".\");\n  }\n\n  var ch = character.charCodeAt(0);\n  var metrics = fontMetricsData[font][ch];\n\n  if (!metrics && character[0] in extraCharacterMap) {\n    ch = extraCharacterMap[character[0]].charCodeAt(0);\n    metrics = fontMetricsData[font][ch];\n  }\n\n  if (!metrics && mode === 'text') {\n    // We don't typically have font metrics for Asian scripts.\n    // But since we support them in text mode, we need to return\n    // some sort of metrics.\n    // So if the character is in a script we support but we\n    // don't have metrics for it, just use the metrics for\n    // the Latin capital letter M. This is close enough because\n    // we (currently) only care about the height of the glyph\n    // not its width.\n    if (supportedCodepoint(ch)) {\n      metrics = fontMetricsData[font][77]; // 77 is the charcode for 'M'\n    }\n  }\n\n  if (metrics) {\n    return {\n      depth: metrics[0],\n      height: metrics[1],\n      italic: metrics[2],\n      skew: metrics[3],\n      width: metrics[4]\n    };\n  }\n}\nvar fontMetricsBySizeIndex = {};\n/**\n * Get the font metrics for a given size.\n */\n\nfunction getGlobalMetrics(size) {\n  var sizeIndex;\n\n  if (size >= 5) {\n    sizeIndex = 0;\n  } else if (size >= 3) {\n    sizeIndex = 1;\n  } else {\n    sizeIndex = 2;\n  }\n\n  if (!fontMetricsBySizeIndex[sizeIndex]) {\n    var metrics = fontMetricsBySizeIndex[sizeIndex] = {\n      cssEmPerMu: sigmasAndXis.quad[sizeIndex] / 18\n    };\n\n    for (var key in sigmasAndXis) {\n      if (sigmasAndXis.hasOwnProperty(key)) {\n        metrics[key] = sigmasAndXis[key][sizeIndex];\n      }\n    }\n  }\n\n  return fontMetricsBySizeIndex[sizeIndex];\n}\n\n/**\n * This file contains information about the options that the Parser carries\n * around with it while parsing. Data is held in an `Options` object, and when\n * recursing, a new `Options` object can be created with the `.with*` and\n * `.reset` functions.\n */\nvar sizeStyleMap = [// Each element contains [textsize, scriptsize, scriptscriptsize].\n// The size mappings are taken from TeX with \\normalsize=10pt.\n[1, 1, 1], // size1: [5, 5, 5]              \\tiny\n[2, 1, 1], // size2: [6, 5, 5]\n[3, 1, 1], // size3: [7, 5, 5]              \\scriptsize\n[4, 2, 1], // size4: [8, 6, 5]              \\footnotesize\n[5, 2, 1], // size5: [9, 6, 5]              \\small\n[6, 3, 1], // size6: [10, 7, 5]             \\normalsize\n[7, 4, 2], // size7: [12, 8, 6]             \\large\n[8, 6, 3], // size8: [14.4, 10, 7]          \\Large\n[9, 7, 6], // size9: [17.28, 12, 10]        \\LARGE\n[10, 8, 7], // size10: [20.74, 14.4, 12]     \\huge\n[11, 10, 9] // size11: [24.88, 20.74, 17.28] \\HUGE\n];\nvar sizeMultipliers = [// fontMetrics.js:getGlobalMetrics also uses size indexes, so if\n// you change size indexes, change that function.\n0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.2, 1.44, 1.728, 2.074, 2.488];\n\nvar sizeAtStyle = function sizeAtStyle(size, style) {\n  return style.size < 2 ? size : sizeStyleMap[size - 1][style.size - 1];\n}; // In these types, \"\" (empty string) means \"no change\".\n\n\n/**\n * This is the main options class. It contains the current style, size, color,\n * and font.\n *\n * Options objects should not be modified. To create a new Options with\n * different properties, call a `.having*` method.\n */\nclass Options {\n  // A font family applies to a group of fonts (i.e. SansSerif), while a font\n  // represents a specific font (i.e. SansSerif Bold).\n  // See: https://tex.stackexchange.com/questions/22350/difference-between-textrm-and-mathrm\n\n  /**\n   * The base size index.\n   */\n  constructor(data) {\n    this.style = void 0;\n    this.color = void 0;\n    this.size = void 0;\n    this.textSize = void 0;\n    this.phantom = void 0;\n    this.font = void 0;\n    this.fontFamily = void 0;\n    this.fontWeight = void 0;\n    this.fontShape = void 0;\n    this.sizeMultiplier = void 0;\n    this.maxSize = void 0;\n    this.minRuleThickness = void 0;\n    this._fontMetrics = void 0;\n    this.style = data.style;\n    this.color = data.color;\n    this.size = data.size || Options.BASESIZE;\n    this.textSize = data.textSize || this.size;\n    this.phantom = !!data.phantom;\n    this.font = data.font || \"\";\n    this.fontFamily = data.fontFamily || \"\";\n    this.fontWeight = data.fontWeight || '';\n    this.fontShape = data.fontShape || '';\n    this.sizeMultiplier = sizeMultipliers[this.size - 1];\n    this.maxSize = data.maxSize;\n    this.minRuleThickness = data.minRuleThickness;\n    this._fontMetrics = undefined;\n  }\n  /**\n   * Returns a new options object with the same properties as \"this\".  Properties\n   * from \"extension\" will be copied to the new options object.\n   */\n\n\n  extend(extension) {\n    var data = {\n      style: this.style,\n      size: this.size,\n      textSize: this.textSize,\n      color: this.color,\n      phantom: this.phantom,\n      font: this.font,\n      fontFamily: this.fontFamily,\n      fontWeight: this.fontWeight,\n      fontShape: this.fontShape,\n      maxSize: this.maxSize,\n      minRuleThickness: this.minRuleThickness\n    };\n\n    for (var key in extension) {\n      if (extension.hasOwnProperty(key)) {\n        data[key] = extension[key];\n      }\n    }\n\n    return new Options(data);\n  }\n  /**\n   * Return an options object with the given style. If `this.style === style`,\n   * returns `this`.\n   */\n\n\n  havingStyle(style) {\n    if (this.style === style) {\n      return this;\n    } else {\n      return this.extend({\n        style: style,\n        size: sizeAtStyle(this.textSize, style)\n      });\n    }\n  }\n  /**\n   * Return an options object with a cramped version of the current style. If\n   * the current style is cramped, returns `this`.\n   */\n\n\n  havingCrampedStyle() {\n    return this.havingStyle(this.style.cramp());\n  }\n  /**\n   * Return an options object with the given size and in at least `\\textstyle`.\n   * Returns `this` if appropriate.\n   */\n\n\n  havingSize(size) {\n    if (this.size === size && this.textSize === size) {\n      return this;\n    } else {\n      return this.extend({\n        style: this.style.text(),\n        size: size,\n        textSize: size,\n        sizeMultiplier: sizeMultipliers[size - 1]\n      });\n    }\n  }\n  /**\n   * Like `this.havingSize(BASESIZE).havingStyle(style)`. If `style` is omitted,\n   * changes to at least `\\textstyle`.\n   */\n\n\n  havingBaseStyle(style) {\n    style = style || this.style.text();\n    var wantSize = sizeAtStyle(Options.BASESIZE, style);\n\n    if (this.size === wantSize && this.textSize === Options.BASESIZE && this.style === style) {\n      return this;\n    } else {\n      return this.extend({\n        style: style,\n        size: wantSize\n      });\n    }\n  }\n  /**\n   * Remove the effect of sizing changes such as \\Huge.\n   * Keep the effect of the current style, such as \\scriptstyle.\n   */\n\n\n  havingBaseSizing() {\n    var size;\n\n    switch (this.style.id) {\n      case 4:\n      case 5:\n        size = 3; // normalsize in scriptstyle\n\n        break;\n\n      case 6:\n      case 7:\n        size = 1; // normalsize in scriptscriptstyle\n\n        break;\n\n      default:\n        size = 6;\n      // normalsize in textstyle or displaystyle\n    }\n\n    return this.extend({\n      style: this.style.text(),\n      size: size\n    });\n  }\n  /**\n   * Create a new options object with the given color.\n   */\n\n\n  withColor(color) {\n    return this.extend({\n      color: color\n    });\n  }\n  /**\n   * Create a new options object with \"phantom\" set to true.\n   */\n\n\n  withPhantom() {\n    return this.extend({\n      phantom: true\n    });\n  }\n  /**\n   * Creates a new options object with the given math font or old text font.\n   * @type {[type]}\n   */\n\n\n  withFont(font) {\n    return this.extend({\n      font\n    });\n  }\n  /**\n   * Create a new options objects with the given fontFamily.\n   */\n\n\n  withTextFontFamily(fontFamily) {\n    return this.extend({\n      fontFamily,\n      font: \"\"\n    });\n  }\n  /**\n   * Creates a new options object with the given font weight\n   */\n\n\n  withTextFontWeight(fontWeight) {\n    return this.extend({\n      fontWeight,\n      font: \"\"\n    });\n  }\n  /**\n   * Creates a new options object with the given font weight\n   */\n\n\n  withTextFontShape(fontShape) {\n    return this.extend({\n      fontShape,\n      font: \"\"\n    });\n  }\n  /**\n   * Return the CSS sizing classes required to switch from enclosing options\n   * `oldOptions` to `this`. Returns an array of classes.\n   */\n\n\n  sizingClasses(oldOptions) {\n    if (oldOptions.size !== this.size) {\n      return [\"sizing\", \"reset-size\" + oldOptions.size, \"size\" + this.size];\n    } else {\n      return [];\n    }\n  }\n  /**\n   * Return the CSS sizing classes required to switch to the base size. Like\n   * `this.havingSize(BASESIZE).sizingClasses(this)`.\n   */\n\n\n  baseSizingClasses() {\n    if (this.size !== Options.BASESIZE) {\n      return [\"sizing\", \"reset-size\" + this.size, \"size\" + Options.BASESIZE];\n    } else {\n      return [];\n    }\n  }\n  /**\n   * Return the font metrics for this size.\n   */\n\n\n  fontMetrics() {\n    if (!this._fontMetrics) {\n      this._fontMetrics = getGlobalMetrics(this.size);\n    }\n\n    return this._fontMetrics;\n  }\n  /**\n   * Gets the CSS color of the current options object\n   */\n\n\n  getColor() {\n    if (this.phantom) {\n      return \"transparent\";\n    } else {\n      return this.color;\n    }\n  }\n\n}\n\nOptions.BASESIZE = 6;\n\n/**\n * This file does conversion between units.  In particular, it provides\n * calculateSize to convert other units into ems.\n */\n// Thus, multiplying a length by this number converts the length from units\n// into pts.  Dividing the result by ptPerEm gives the number of ems\n// *assuming* a font size of ptPerEm (normal size, normal style).\n\nvar ptPerUnit = {\n  // https://en.wikibooks.org/wiki/LaTeX/Lengths and\n  // https://tex.stackexchange.com/a/8263\n  \"pt\": 1,\n  // TeX point\n  \"mm\": 7227 / 2540,\n  // millimeter\n  \"cm\": 7227 / 254,\n  // centimeter\n  \"in\": 72.27,\n  // inch\n  \"bp\": 803 / 800,\n  // big (PostScript) points\n  \"pc\": 12,\n  // pica\n  \"dd\": 1238 / 1157,\n  // didot\n  \"cc\": 14856 / 1157,\n  // cicero (12 didot)\n  \"nd\": 685 / 642,\n  // new didot\n  \"nc\": 1370 / 107,\n  // new cicero (12 new didot)\n  \"sp\": 1 / 65536,\n  // scaled point (TeX's internal smallest unit)\n  // https://tex.stackexchange.com/a/41371\n  \"px\": 803 / 800 // \\pdfpxdimen defaults to 1 bp in pdfTeX and LuaTeX\n\n}; // Dictionary of relative units, for fast validity testing.\n\nvar relativeUnit = {\n  \"ex\": true,\n  \"em\": true,\n  \"mu\": true\n};\n\n/**\n * Determine whether the specified unit (either a string defining the unit\n * or a \"size\" parse node containing a unit field) is valid.\n */\nvar validUnit = function validUnit(unit) {\n  if (typeof unit !== \"string\") {\n    unit = unit.unit;\n  }\n\n  return unit in ptPerUnit || unit in relativeUnit || unit === \"ex\";\n};\n/*\n * Convert a \"size\" parse node (with numeric \"number\" and string \"unit\" fields,\n * as parsed by functions.js argType \"size\") into a CSS em value for the\n * current style/scale.  `options` gives the current options.\n */\n\nvar calculateSize = function calculateSize(sizeValue, options) {\n  var scale;\n\n  if (sizeValue.unit in ptPerUnit) {\n    // Absolute units\n    scale = ptPerUnit[sizeValue.unit] // Convert unit to pt\n    / options.fontMetrics().ptPerEm // Convert pt to CSS em\n    / options.sizeMultiplier; // Unscale to make absolute units\n  } else if (sizeValue.unit === \"mu\") {\n    // `mu` units scale with scriptstyle/scriptscriptstyle.\n    scale = options.fontMetrics().cssEmPerMu;\n  } else {\n    // Other relative units always refer to the *textstyle* font\n    // in the current size.\n    var unitOptions;\n\n    if (options.style.isTight()) {\n      // isTight() means current style is script/scriptscript.\n      unitOptions = options.havingStyle(options.style.text());\n    } else {\n      unitOptions = options;\n    } // TODO: In TeX these units are relative to the quad of the current\n    // *text* font, e.g. cmr10. KaTeX instead uses values from the\n    // comparably-sized *Computer Modern symbol* font. At 10pt, these\n    // match. At 7pt and 5pt, they differ: cmr7=1.138894, cmsy7=1.170641;\n    // cmr5=1.361133, cmsy5=1.472241. Consider $\\scriptsize a\\kern1emb$.\n    // TeX \\showlists shows a kern of 1.13889 * fontsize;\n    // KaTeX shows a kern of 1.171 * fontsize.\n\n\n    if (sizeValue.unit === \"ex\") {\n      scale = unitOptions.fontMetrics().xHeight;\n    } else if (sizeValue.unit === \"em\") {\n      scale = unitOptions.fontMetrics().quad;\n    } else {\n      throw new ParseError(\"Invalid unit: '\" + sizeValue.unit + \"'\");\n    }\n\n    if (unitOptions !== options) {\n      scale *= unitOptions.sizeMultiplier / options.sizeMultiplier;\n    }\n  }\n\n  return Math.min(sizeValue.number * scale, options.maxSize);\n};\n/**\n * Round `n` to 4 decimal places, or to the nearest 1/10,000th em. See\n * https://github.com/KaTeX/KaTeX/pull/2460.\n */\n\nvar makeEm = function makeEm(n) {\n  return +n.toFixed(4) + \"em\";\n};\n\n/**\n * These objects store the data about the DOM nodes we create, as well as some\n * extra data. They can then be transformed into real DOM nodes with the\n * `toNode` function or HTML markup using `toMarkup`. They are useful for both\n * storing extra properties on the nodes, as well as providing a way to easily\n * work with the DOM.\n *\n * Similar functions for working with MathML nodes exist in mathMLTree.js.\n *\n * TODO: refactor `span` and `anchor` into common superclass when\n * target environments support class inheritance\n */\n\n/**\n * Create an HTML className based on a list of classes. In addition to joining\n * with spaces, we also remove empty classes.\n */\nvar createClass = function createClass(classes) {\n  return classes.filter(cls => cls).join(\" \");\n};\n\nvar initNode = function initNode(classes, options, style) {\n  this.classes = classes || [];\n  this.attributes = {};\n  this.height = 0;\n  this.depth = 0;\n  this.maxFontSize = 0;\n  this.style = style || {};\n\n  if (options) {\n    if (options.style.isTight()) {\n      this.classes.push(\"mtight\");\n    }\n\n    var color = options.getColor();\n\n    if (color) {\n      this.style.color = color;\n    }\n  }\n};\n/**\n * Convert into an HTML node\n */\n\n\nvar toNode = function toNode(tagName) {\n  var node = document.createElement(tagName); // Apply the class\n\n  node.className = createClass(this.classes); // Apply inline styles\n\n  for (var style in this.style) {\n    if (this.style.hasOwnProperty(style)) {\n      // $FlowFixMe Flow doesn't seem to understand span.style's type.\n      node.style[style] = this.style[style];\n    }\n  } // Apply attributes\n\n\n  for (var attr in this.attributes) {\n    if (this.attributes.hasOwnProperty(attr)) {\n      node.setAttribute(attr, this.attributes[attr]);\n    }\n  } // Append the children, also as HTML nodes\n\n\n  for (var i = 0; i < this.children.length; i++) {\n    node.appendChild(this.children[i].toNode());\n  }\n\n  return node;\n};\n/**\n * https://w3c.github.io/html-reference/syntax.html#syntax-attributes\n *\n * > Attribute Names must consist of one or more characters\n * other than the space characters, U+0000 NULL,\n * '\"', \"'\", \">\", \"/\", \"=\", the control characters,\n * and any characters that are not defined by Unicode.\n */\n\n\nvar invalidAttributeNameRegex = /[\\s\"'>/=\\x00-\\x1f]/;\n/**\n * Convert into an HTML markup string\n */\n\nvar toMarkup = function toMarkup(tagName) {\n  var markup = \"<\" + tagName; // Add the class\n\n  if (this.classes.length) {\n    markup += \" class=\\\"\" + utils.escape(createClass(this.classes)) + \"\\\"\";\n  }\n\n  var styles = \"\"; // Add the styles, after hyphenation\n\n  for (var style in this.style) {\n    if (this.style.hasOwnProperty(style)) {\n      styles += utils.hyphenate(style) + \":\" + this.style[style] + \";\";\n    }\n  }\n\n  if (styles) {\n    markup += \" style=\\\"\" + utils.escape(styles) + \"\\\"\";\n  } // Add the attributes\n\n\n  for (var attr in this.attributes) {\n    if (this.attributes.hasOwnProperty(attr)) {\n      if (invalidAttributeNameRegex.test(attr)) {\n        throw new ParseError(\"Invalid attribute name '\" + attr + \"'\");\n      }\n\n      markup += \" \" + attr + \"=\\\"\" + utils.escape(this.attributes[attr]) + \"\\\"\";\n    }\n  }\n\n  markup += \">\"; // Add the markup of the children, also as markup\n\n  for (var i = 0; i < this.children.length; i++) {\n    markup += this.children[i].toMarkup();\n  }\n\n  markup += \"</\" + tagName + \">\";\n  return markup;\n}; // Making the type below exact with all optional fields doesn't work due to\n// - https://github.com/facebook/flow/issues/4582\n// - https://github.com/facebook/flow/issues/5688\n// However, since *all* fields are optional, $Shape<> works as suggested in 5688\n// above.\n// This type does not include all CSS properties. Additional properties should\n// be added as needed.\n\n\n/**\n * This node represents a span node, with a className, a list of children, and\n * an inline style. It also contains information about its height, depth, and\n * maxFontSize.\n *\n * Represents two types with different uses: SvgSpan to wrap an SVG and DomSpan\n * otherwise. This typesafety is important when HTML builders access a span's\n * children.\n */\nclass Span {\n  constructor(classes, children, options, style) {\n    this.children = void 0;\n    this.attributes = void 0;\n    this.classes = void 0;\n    this.height = void 0;\n    this.depth = void 0;\n    this.width = void 0;\n    this.maxFontSize = void 0;\n    this.style = void 0;\n    initNode.call(this, classes, options, style);\n    this.children = children || [];\n  }\n  /**\n   * Sets an arbitrary attribute on the span. Warning: use this wisely. Not\n   * all browsers support attributes the same, and having too many custom\n   * attributes is probably bad.\n   */\n\n\n  setAttribute(attribute, value) {\n    this.attributes[attribute] = value;\n  }\n\n  hasClass(className) {\n    return utils.contains(this.classes, className);\n  }\n\n  toNode() {\n    return toNode.call(this, \"span\");\n  }\n\n  toMarkup() {\n    return toMarkup.call(this, \"span\");\n  }\n\n}\n/**\n * This node represents an anchor (<a>) element with a hyperlink.  See `span`\n * for further details.\n */\n\nclass Anchor {\n  constructor(href, classes, children, options) {\n    this.children = void 0;\n    this.attributes = void 0;\n    this.classes = void 0;\n    this.height = void 0;\n    this.depth = void 0;\n    this.maxFontSize = void 0;\n    this.style = void 0;\n    initNode.call(this, classes, options);\n    this.children = children || [];\n    this.setAttribute('href', href);\n  }\n\n  setAttribute(attribute, value) {\n    this.attributes[attribute] = value;\n  }\n\n  hasClass(className) {\n    return utils.contains(this.classes, className);\n  }\n\n  toNode() {\n    return toNode.call(this, \"a\");\n  }\n\n  toMarkup() {\n    return toMarkup.call(this, \"a\");\n  }\n\n}\n/**\n * This node represents an image embed (<img>) element.\n */\n\nclass Img {\n  constructor(src, alt, style) {\n    this.src = void 0;\n    this.alt = void 0;\n    this.classes = void 0;\n    this.height = void 0;\n    this.depth = void 0;\n    this.maxFontSize = void 0;\n    this.style = void 0;\n    this.alt = alt;\n    this.src = src;\n    this.classes = [\"mord\"];\n    this.style = style;\n  }\n\n  hasClass(className) {\n    return utils.contains(this.classes, className);\n  }\n\n  toNode() {\n    var node = document.createElement(\"img\");\n    node.src = this.src;\n    node.alt = this.alt;\n    node.className = \"mord\"; // Apply inline styles\n\n    for (var style in this.style) {\n      if (this.style.hasOwnProperty(style)) {\n        // $FlowFixMe\n        node.style[style] = this.style[style];\n      }\n    }\n\n    return node;\n  }\n\n  toMarkup() {\n    var markup = \"<img src=\\\"\" + utils.escape(this.src) + \"\\\"\" + (\" alt=\\\"\" + utils.escape(this.alt) + \"\\\"\"); // Add the styles, after hyphenation\n\n    var styles = \"\";\n\n    for (var style in this.style) {\n      if (this.style.hasOwnProperty(style)) {\n        styles += utils.hyphenate(style) + \":\" + this.style[style] + \";\";\n      }\n    }\n\n    if (styles) {\n      markup += \" style=\\\"\" + utils.escape(styles) + \"\\\"\";\n    }\n\n    markup += \"'/>\";\n    return markup;\n  }\n\n}\nvar iCombinations = {\n  'î': '\\u0131\\u0302',\n  'ï': '\\u0131\\u0308',\n  'í': '\\u0131\\u0301',\n  // 'ī': '\\u0131\\u0304', // enable when we add Extended Latin\n  'ì': '\\u0131\\u0300'\n};\n/**\n * A symbol node contains information about a single symbol. It either renders\n * to a single text node, or a span with a single text node in it, depending on\n * whether it has CSS classes, styles, or needs italic correction.\n */\n\nclass SymbolNode {\n  constructor(text, height, depth, italic, skew, width, classes, style) {\n    this.text = void 0;\n    this.height = void 0;\n    this.depth = void 0;\n    this.italic = void 0;\n    this.skew = void 0;\n    this.width = void 0;\n    this.maxFontSize = void 0;\n    this.classes = void 0;\n    this.style = void 0;\n    this.text = text;\n    this.height = height || 0;\n    this.depth = depth || 0;\n    this.italic = italic || 0;\n    this.skew = skew || 0;\n    this.width = width || 0;\n    this.classes = classes || [];\n    this.style = style || {};\n    this.maxFontSize = 0; // Mark text from non-Latin scripts with specific classes so that we\n    // can specify which fonts to use.  This allows us to render these\n    // characters with a serif font in situations where the browser would\n    // either default to a sans serif or render a placeholder character.\n    // We use CSS class names like cjk_fallback, hangul_fallback and\n    // brahmic_fallback. See ./unicodeScripts.js for the set of possible\n    // script names\n\n    var script = scriptFromCodepoint(this.text.charCodeAt(0));\n\n    if (script) {\n      this.classes.push(script + \"_fallback\");\n    }\n\n    if (/[îïíì]/.test(this.text)) {\n      // add ī when we add Extended Latin\n      this.text = iCombinations[this.text];\n    }\n  }\n\n  hasClass(className) {\n    return utils.contains(this.classes, className);\n  }\n  /**\n   * Creates a text node or span from a symbol node. Note that a span is only\n   * created if it is needed.\n   */\n\n\n  toNode() {\n    var node = document.createTextNode(this.text);\n    var span = null;\n\n    if (this.italic > 0) {\n      span = document.createElement(\"span\");\n      span.style.marginRight = makeEm(this.italic);\n    }\n\n    if (this.classes.length > 0) {\n      span = span || document.createElement(\"span\");\n      span.className = createClass(this.classes);\n    }\n\n    for (var style in this.style) {\n      if (this.style.hasOwnProperty(style)) {\n        span = span || document.createElement(\"span\"); // $FlowFixMe Flow doesn't seem to understand span.style's type.\n\n        span.style[style] = this.style[style];\n      }\n    }\n\n    if (span) {\n      span.appendChild(node);\n      return span;\n    } else {\n      return node;\n    }\n  }\n  /**\n   * Creates markup for a symbol node.\n   */\n\n\n  toMarkup() {\n    // TODO(alpert): More duplication than I'd like from\n    // span.prototype.toMarkup and symbolNode.prototype.toNode...\n    var needsSpan = false;\n    var markup = \"<span\";\n\n    if (this.classes.length) {\n      needsSpan = true;\n      markup += \" class=\\\"\";\n      markup += utils.escape(createClass(this.classes));\n      markup += \"\\\"\";\n    }\n\n    var styles = \"\";\n\n    if (this.italic > 0) {\n      styles += \"margin-right:\" + this.italic + \"em;\";\n    }\n\n    for (var style in this.style) {\n      if (this.style.hasOwnProperty(style)) {\n        styles += utils.hyphenate(style) + \":\" + this.style[style] + \";\";\n      }\n    }\n\n    if (styles) {\n      needsSpan = true;\n      markup += \" style=\\\"\" + utils.escape(styles) + \"\\\"\";\n    }\n\n    var escaped = utils.escape(this.text);\n\n    if (needsSpan) {\n      markup += \">\";\n      markup += escaped;\n      markup += \"</span>\";\n      return markup;\n    } else {\n      return escaped;\n    }\n  }\n\n}\n/**\n * SVG nodes are used to render stretchy wide elements.\n */\n\nclass SvgNode {\n  constructor(children, attributes) {\n    this.children = void 0;\n    this.attributes = void 0;\n    this.children = children || [];\n    this.attributes = attributes || {};\n  }\n\n  toNode() {\n    var svgNS = \"http://www.w3.org/2000/svg\";\n    var node = document.createElementNS(svgNS, \"svg\"); // Apply attributes\n\n    for (var attr in this.attributes) {\n      if (Object.prototype.hasOwnProperty.call(this.attributes, attr)) {\n        node.setAttribute(attr, this.attributes[attr]);\n      }\n    }\n\n    for (var i = 0; i < this.children.length; i++) {\n      node.appendChild(this.children[i].toNode());\n    }\n\n    return node;\n  }\n\n  toMarkup() {\n    var markup = \"<svg xmlns=\\\"http://www.w3.org/2000/svg\\\"\"; // Apply attributes\n\n    for (var attr in this.attributes) {\n      if (Object.prototype.hasOwnProperty.call(this.attributes, attr)) {\n        markup += \" \" + attr + \"=\\\"\" + utils.escape(this.attributes[attr]) + \"\\\"\";\n      }\n    }\n\n    markup += \">\";\n\n    for (var i = 0; i < this.children.length; i++) {\n      markup += this.children[i].toMarkup();\n    }\n\n    markup += \"</svg>\";\n    return markup;\n  }\n\n}\nclass PathNode {\n  constructor(pathName, alternate) {\n    this.pathName = void 0;\n    this.alternate = void 0;\n    this.pathName = pathName;\n    this.alternate = alternate; // Used only for \\sqrt, \\phase, & tall delims\n  }\n\n  toNode() {\n    var svgNS = \"http://www.w3.org/2000/svg\";\n    var node = document.createElementNS(svgNS, \"path\");\n\n    if (this.alternate) {\n      node.setAttribute(\"d\", this.alternate);\n    } else {\n      node.setAttribute(\"d\", path[this.pathName]);\n    }\n\n    return node;\n  }\n\n  toMarkup() {\n    if (this.alternate) {\n      return \"<path d=\\\"\" + utils.escape(this.alternate) + \"\\\"/>\";\n    } else {\n      return \"<path d=\\\"\" + utils.escape(path[this.pathName]) + \"\\\"/>\";\n    }\n  }\n\n}\nclass LineNode {\n  constructor(attributes) {\n    this.attributes = void 0;\n    this.attributes = attributes || {};\n  }\n\n  toNode() {\n    var svgNS = \"http://www.w3.org/2000/svg\";\n    var node = document.createElementNS(svgNS, \"line\"); // Apply attributes\n\n    for (var attr in this.attributes) {\n      if (Object.prototype.hasOwnProperty.call(this.attributes, attr)) {\n        node.setAttribute(attr, this.attributes[attr]);\n      }\n    }\n\n    return node;\n  }\n\n  toMarkup() {\n    var markup = \"<line\";\n\n    for (var attr in this.attributes) {\n      if (Object.prototype.hasOwnProperty.call(this.attributes, attr)) {\n        markup += \" \" + attr + \"=\\\"\" + utils.escape(this.attributes[attr]) + \"\\\"\";\n      }\n    }\n\n    markup += \"/>\";\n    return markup;\n  }\n\n}\nfunction assertSymbolDomNode(group) {\n  if (group instanceof SymbolNode) {\n    return group;\n  } else {\n    throw new Error(\"Expected symbolNode but got \" + String(group) + \".\");\n  }\n}\nfunction assertSpan(group) {\n  if (group instanceof Span) {\n    return group;\n  } else {\n    throw new Error(\"Expected span<HtmlDomNode> but got \" + String(group) + \".\");\n  }\n}\n\n/**\n * This file holds a list of all no-argument functions and single-character\n * symbols (like 'a' or ';').\n *\n * For each of the symbols, there are three properties they can have:\n * - font (required): the font to be used for this symbol. Either \"main\" (the\n     normal font), or \"ams\" (the ams fonts).\n * - group (required): the ParseNode group type the symbol should have (i.e.\n     \"textord\", \"mathord\", etc).\n     See https://github.com/KaTeX/KaTeX/wiki/Examining-TeX#group-types\n * - replace: the character that this symbol or function should be\n *   replaced with (i.e. \"\\phi\" has a replace value of \"\\u03d5\", the phi\n *   character in the main font).\n *\n * The outermost map in the table indicates what mode the symbols should be\n * accepted in (e.g. \"math\" or \"text\").\n */\n// Some of these have a \"-token\" suffix since these are also used as `ParseNode`\n// types for raw text tokens, and we want to avoid conflicts with higher-level\n// `ParseNode` types. These `ParseNode`s are constructed within `Parser` by\n// looking up the `symbols` map.\nvar ATOMS = {\n  \"bin\": 1,\n  \"close\": 1,\n  \"inner\": 1,\n  \"open\": 1,\n  \"punct\": 1,\n  \"rel\": 1\n};\nvar NON_ATOMS = {\n  \"accent-token\": 1,\n  \"mathord\": 1,\n  \"op-token\": 1,\n  \"spacing\": 1,\n  \"textord\": 1\n};\nvar symbols = {\n  \"math\": {},\n  \"text\": {}\n};\n/** `acceptUnicodeChar = true` is only applicable if `replace` is set. */\n\nfunction defineSymbol(mode, font, group, replace, name, acceptUnicodeChar) {\n  symbols[mode][name] = {\n    font,\n    group,\n    replace\n  };\n\n  if (acceptUnicodeChar && replace) {\n    symbols[mode][replace] = symbols[mode][name];\n  }\n} // Some abbreviations for commonly used strings.\n// This helps minify the code, and also spotting typos using jshint.\n// modes:\n\nvar math = \"math\";\nvar text = \"text\"; // fonts:\n\nvar main = \"main\";\nvar ams = \"ams\"; // groups:\n\nvar accent = \"accent-token\";\nvar bin = \"bin\";\nvar close = \"close\";\nvar inner = \"inner\";\nvar mathord = \"mathord\";\nvar op = \"op-token\";\nvar open = \"open\";\nvar punct = \"punct\";\nvar rel = \"rel\";\nvar spacing = \"spacing\";\nvar textord = \"textord\"; // Now comes the symbol table\n// Relation Symbols\n\ndefineSymbol(math, main, rel, \"\\u2261\", \"\\\\equiv\", true);\ndefineSymbol(math, main, rel, \"\\u227a\", \"\\\\prec\", true);\ndefineSymbol(math, main, rel, \"\\u227b\", \"\\\\succ\", true);\ndefineSymbol(math, main, rel, \"\\u223c\", \"\\\\sim\", true);\ndefineSymbol(math, main, rel, \"\\u22a5\", \"\\\\perp\");\ndefineSymbol(math, main, rel, \"\\u2aaf\", \"\\\\preceq\", true);\ndefineSymbol(math, main, rel, \"\\u2ab0\", \"\\\\succeq\", true);\ndefineSymbol(math, main, rel, \"\\u2243\", \"\\\\simeq\", true);\ndefineSymbol(math, main, rel, \"\\u2223\", \"\\\\mid\", true);\ndefineSymbol(math, main, rel, \"\\u226a\", \"\\\\ll\", true);\ndefineSymbol(math, main, rel, \"\\u226b\", \"\\\\gg\", true);\ndefineSymbol(math, main, rel, \"\\u224d\", \"\\\\asymp\", true);\ndefineSymbol(math, main, rel, \"\\u2225\", \"\\\\parallel\");\ndefineSymbol(math, main, rel, \"\\u22c8\", \"\\\\bowtie\", true);\ndefineSymbol(math, main, rel, \"\\u2323\", \"\\\\smile\", true);\ndefineSymbol(math, main, rel, \"\\u2291\", \"\\\\sqsubseteq\", true);\ndefineSymbol(math, main, rel, \"\\u2292\", \"\\\\sqsupseteq\", true);\ndefineSymbol(math, main, rel, \"\\u2250\", \"\\\\doteq\", true);\ndefineSymbol(math, main, rel, \"\\u2322\", \"\\\\frown\", true);\ndefineSymbol(math, main, rel, \"\\u220b\", \"\\\\ni\", true);\ndefineSymbol(math, main, rel, \"\\u221d\", \"\\\\propto\", true);\ndefineSymbol(math, main, rel, \"\\u22a2\", \"\\\\vdash\", true);\ndefineSymbol(math, main, rel, \"\\u22a3\", \"\\\\dashv\", true);\ndefineSymbol(math, main, rel, \"\\u220b\", \"\\\\owns\"); // Punctuation\n\ndefineSymbol(math, main, punct, \"\\u002e\", \"\\\\ldotp\");\ndefineSymbol(math, main, punct, \"\\u22c5\", \"\\\\cdotp\"); // Misc Symbols\n\ndefineSymbol(math, main, textord, \"\\u0023\", \"\\\\#\");\ndefineSymbol(text, main, textord, \"\\u0023\", \"\\\\#\");\ndefineSymbol(math, main, textord, \"\\u0026\", \"\\\\&\");\ndefineSymbol(text, main, textord, \"\\u0026\", \"\\\\&\");\ndefineSymbol(math, main, textord, \"\\u2135\", \"\\\\aleph\", true);\ndefineSymbol(math, main, textord, \"\\u2200\", \"\\\\forall\", true);\ndefineSymbol(math, main, textord, \"\\u210f\", \"\\\\hbar\", true);\ndefineSymbol(math, main, textord, \"\\u2203\", \"\\\\exists\", true);\ndefineSymbol(math, main, textord, \"\\u2207\", \"\\\\nabla\", true);\ndefineSymbol(math, main, textord, \"\\u266d\", \"\\\\flat\", true);\ndefineSymbol(math, main, textord, \"\\u2113\", \"\\\\ell\", true);\ndefineSymbol(math, main, textord, \"\\u266e\", \"\\\\natural\", true);\ndefineSymbol(math, main, textord, \"\\u2663\", \"\\\\clubsuit\", true);\ndefineSymbol(math, main, textord, \"\\u2118\", \"\\\\wp\", true);\ndefineSymbol(math, main, textord, \"\\u266f\", \"\\\\sharp\", true);\ndefineSymbol(math, main, textord, \"\\u2662\", \"\\\\diamondsuit\", true);\ndefineSymbol(math, main, textord, \"\\u211c\", \"\\\\Re\", true);\ndefineSymbol(math, main, textord, \"\\u2661\", \"\\\\heartsuit\", true);\ndefineSymbol(math, main, textord, \"\\u2111\", \"\\\\Im\", true);\ndefineSymbol(math, main, textord, \"\\u2660\", \"\\\\spadesuit\", true);\ndefineSymbol(math, main, textord, \"\\u00a7\", \"\\\\S\", true);\ndefineSymbol(text, main, textord, \"\\u00a7\", \"\\\\S\");\ndefineSymbol(math, main, textord, \"\\u00b6\", \"\\\\P\", true);\ndefineSymbol(text, main, textord, \"\\u00b6\", \"\\\\P\"); // Math and Text\n\ndefineSymbol(math, main, textord, \"\\u2020\", \"\\\\dag\");\ndefineSymbol(text, main, textord, \"\\u2020\", \"\\\\dag\");\ndefineSymbol(text, main, textord, \"\\u2020\", \"\\\\textdagger\");\ndefineSymbol(math, main, textord, \"\\u2021\", \"\\\\ddag\");\ndefineSymbol(text, main, textord, \"\\u2021\", \"\\\\ddag\");\ndefineSymbol(text, main, textord, \"\\u2021\", \"\\\\textdaggerdbl\"); // Large Delimiters\n\ndefineSymbol(math, main, close, \"\\u23b1\", \"\\\\rmoustache\", true);\ndefineSymbol(math, main, open, \"\\u23b0\", \"\\\\lmoustache\", true);\ndefineSymbol(math, main, close, \"\\u27ef\", \"\\\\rgroup\", true);\ndefineSymbol(math, main, open, \"\\u27ee\", \"\\\\lgroup\", true); // Binary Operators\n\ndefineSymbol(math, main, bin, \"\\u2213\", \"\\\\mp\", true);\ndefineSymbol(math, main, bin, \"\\u2296\", \"\\\\ominus\", true);\ndefineSymbol(math, main, bin, \"\\u228e\", \"\\\\uplus\", true);\ndefineSymbol(math, main, bin, \"\\u2293\", \"\\\\sqcap\", true);\ndefineSymbol(math, main, bin, \"\\u2217\", \"\\\\ast\");\ndefineSymbol(math, main, bin, \"\\u2294\", \"\\\\sqcup\", true);\ndefineSymbol(math, main, bin, \"\\u25ef\", \"\\\\bigcirc\", true);\ndefineSymbol(math, main, bin, \"\\u2219\", \"\\\\bullet\", true);\ndefineSymbol(math, main, bin, \"\\u2021\", \"\\\\ddagger\");\ndefineSymbol(math, main, bin, \"\\u2240\", \"\\\\wr\", true);\ndefineSymbol(math, main, bin, \"\\u2a3f\", \"\\\\amalg\");\ndefineSymbol(math, main, bin, \"\\u0026\", \"\\\\And\"); // from amsmath\n// Arrow Symbols\n\ndefineSymbol(math, main, rel, \"\\u27f5\", \"\\\\longleftarrow\", true);\ndefineSymbol(math, main, rel, \"\\u21d0\", \"\\\\Leftarrow\", true);\ndefineSymbol(math, main, rel, \"\\u27f8\", \"\\\\Longleftarrow\", true);\ndefineSymbol(math, main, rel, \"\\u27f6\", \"\\\\longrightarrow\", true);\ndefineSymbol(math, main, rel, \"\\u21d2\", \"\\\\Rightarrow\", true);\ndefineSymbol(math, main, rel, \"\\u27f9\", \"\\\\Longrightarrow\", true);\ndefineSymbol(math, main, rel, \"\\u2194\", \"\\\\leftrightarrow\", true);\ndefineSymbol(math, main, rel, \"\\u27f7\", \"\\\\longleftrightarrow\", true);\ndefineSymbol(math, main, rel, \"\\u21d4\", \"\\\\Leftrightarrow\", true);\ndefineSymbol(math, main, rel, \"\\u27fa\", \"\\\\Longleftrightarrow\", true);\ndefineSymbol(math, main, rel, \"\\u21a6\", \"\\\\mapsto\", true);\ndefineSymbol(math, main, rel, \"\\u27fc\", \"\\\\longmapsto\", true);\ndefineSymbol(math, main, rel, \"\\u2197\", \"\\\\nearrow\", true);\ndefineSymbol(math, main, rel, \"\\u21a9\", \"\\\\hookleftarrow\", true);\ndefineSymbol(math, main, rel, \"\\u21aa\", \"\\\\hookrightarrow\", true);\ndefineSymbol(math, main, rel, \"\\u2198\", \"\\\\searrow\", true);\ndefineSymbol(math, main, rel, \"\\u21bc\", \"\\\\leftharpoonup\", true);\ndefineSymbol(math, main, rel, \"\\u21c0\", \"\\\\rightharpoonup\", true);\ndefineSymbol(math, main, rel, \"\\u2199\", \"\\\\swarrow\", true);\ndefineSymbol(math, main, rel, \"\\u21bd\", \"\\\\leftharpoondown\", true);\ndefineSymbol(math, main, rel, \"\\u21c1\", \"\\\\rightharpoondown\", true);\ndefineSymbol(math, main, rel, \"\\u2196\", \"\\\\nwarrow\", true);\ndefineSymbol(math, main, rel, \"\\u21cc\", \"\\\\rightleftharpoons\", true); // AMS Negated Binary Relations\n\ndefineSymbol(math, ams, rel, \"\\u226e\", \"\\\\nless\", true); // Symbol names preceded by \"@\" each have a corresponding macro.\n\ndefineSymbol(math, ams, rel, \"\\ue010\", \"\\\\@nleqslant\");\ndefineSymbol(math, ams, rel, \"\\ue011\", \"\\\\@nleqq\");\ndefineSymbol(math, ams, rel, \"\\u2a87\", \"\\\\lneq\", true);\ndefineSymbol(math, ams, rel, \"\\u2268\", \"\\\\lneqq\", true);\ndefineSymbol(math, ams, rel, \"\\ue00c\", \"\\\\@lvertneqq\");\ndefineSymbol(math, ams, rel, \"\\u22e6\", \"\\\\lnsim\", true);\ndefineSymbol(math, ams, rel, \"\\u2a89\", \"\\\\lnapprox\", true);\ndefineSymbol(math, ams, rel, \"\\u2280\", \"\\\\nprec\", true); // unicode-math maps \\u22e0 to \\npreccurlyeq. We'll use the AMS synonym.\n\ndefineSymbol(math, ams, rel, \"\\u22e0\", \"\\\\npreceq\", true);\ndefineSymbol(math, ams, rel, \"\\u22e8\", \"\\\\precnsim\", true);\ndefineSymbol(math, ams, rel, \"\\u2ab9\", \"\\\\precnapprox\", true);\ndefineSymbol(math, ams, rel, \"\\u2241\", \"\\\\nsim\", true);\ndefineSymbol(math, ams, rel, \"\\ue006\", \"\\\\@nshortmid\");\ndefineSymbol(math, ams, rel, \"\\u2224\", \"\\\\nmid\", true);\ndefineSymbol(math, ams, rel, \"\\u22ac\", \"\\\\nvdash\", true);\ndefineSymbol(math, ams, rel, \"\\u22ad\", \"\\\\nvDash\", true);\ndefineSymbol(math, ams, rel, \"\\u22ea\", \"\\\\ntriangleleft\");\ndefineSymbol(math, ams, rel, \"\\u22ec\", \"\\\\ntrianglelefteq\", true);\ndefineSymbol(math, ams, rel, \"\\u228a\", \"\\\\subsetneq\", true);\ndefineSymbol(math, ams, rel, \"\\ue01a\", \"\\\\@varsubsetneq\");\ndefineSymbol(math, ams, rel, \"\\u2acb\", \"\\\\subsetneqq\", true);\ndefineSymbol(math, ams, rel, \"\\ue017\", \"\\\\@varsubsetneqq\");\ndefineSymbol(math, ams, rel, \"\\u226f\", \"\\\\ngtr\", true);\ndefineSymbol(math, ams, rel, \"\\ue00f\", \"\\\\@ngeqslant\");\ndefineSymbol(math, ams, rel, \"\\ue00e\", \"\\\\@ngeqq\");\ndefineSymbol(math, ams, rel, \"\\u2a88\", \"\\\\gneq\", true);\ndefineSymbol(math, ams, rel, \"\\u2269\", \"\\\\gneqq\", true);\ndefineSymbol(math, ams, rel, \"\\ue00d\", \"\\\\@gvertneqq\");\ndefineSymbol(math, ams, rel, \"\\u22e7\", \"\\\\gnsim\", true);\ndefineSymbol(math, ams, rel, \"\\u2a8a\", \"\\\\gnapprox\", true);\ndefineSymbol(math, ams, rel, \"\\u2281\", \"\\\\nsucc\", true); // unicode-math maps \\u22e1 to \\nsucccurlyeq. We'll use the AMS synonym.\n\ndefineSymbol(math, ams, rel, \"\\u22e1\", \"\\\\nsucceq\", true);\ndefineSymbol(math, ams, rel, \"\\u22e9\", \"\\\\succnsim\", true);\ndefineSymbol(math, ams, rel, \"\\u2aba\", \"\\\\succnapprox\", true); // unicode-math maps \\u2246 to \\simneqq. We'll use the AMS synonym.\n\ndefineSymbol(math, ams, rel, \"\\u2246\", \"\\\\ncong\", true);\ndefineSymbol(math, ams, rel, \"\\ue007\", \"\\\\@nshortparallel\");\ndefineSymbol(math, ams, rel, \"\\u2226\", \"\\\\nparallel\", true);\ndefineSymbol(math, ams, rel, \"\\u22af\", \"\\\\nVDash\", true);\ndefineSymbol(math, ams, rel, \"\\u22eb\", \"\\\\ntriangleright\");\ndefineSymbol(math, ams, rel, \"\\u22ed\", \"\\\\ntrianglerighteq\", true);\ndefineSymbol(math, ams, rel, \"\\ue018\", \"\\\\@nsupseteqq\");\ndefineSymbol(math, ams, rel, \"\\u228b\", \"\\\\supsetneq\", true);\ndefineSymbol(math, ams, rel, \"\\ue01b\", \"\\\\@varsupsetneq\");\ndefineSymbol(math, ams, rel, \"\\u2acc\", \"\\\\supsetneqq\", true);\ndefineSymbol(math, ams, rel, \"\\ue019\", \"\\\\@varsupsetneqq\");\ndefineSymbol(math, ams, rel, \"\\u22ae\", \"\\\\nVdash\", true);\ndefineSymbol(math, ams, rel, \"\\u2ab5\", \"\\\\precneqq\", true);\ndefineSymbol(math, ams, rel, \"\\u2ab6\", \"\\\\succneqq\", true);\ndefineSymbol(math, ams, rel, \"\\ue016\", \"\\\\@nsubseteqq\");\ndefineSymbol(math, ams, bin, \"\\u22b4\", \"\\\\unlhd\");\ndefineSymbol(math, ams, bin, \"\\u22b5\", \"\\\\unrhd\"); // AMS Negated Arrows\n\ndefineSymbol(math, ams, rel, \"\\u219a\", \"\\\\nleftarrow\", true);\ndefineSymbol(math, ams, rel, \"\\u219b\", \"\\\\nrightarrow\", true);\ndefineSymbol(math, ams, rel, \"\\u21cd\", \"\\\\nLeftarrow\", true);\ndefineSymbol(math, ams, rel, \"\\u21cf\", \"\\\\nRightarrow\", true);\ndefineSymbol(math, ams, rel, \"\\u21ae\", \"\\\\nleftrightarrow\", true);\ndefineSymbol(math, ams, rel, \"\\u21ce\", \"\\\\nLeftrightarrow\", true); // AMS Misc\n\ndefineSymbol(math, ams, rel, \"\\u25b3\", \"\\\\vartriangle\");\ndefineSymbol(math, ams, textord, \"\\u210f\", \"\\\\hslash\");\ndefineSymbol(math, ams, textord, \"\\u25bd\", \"\\\\triangledown\");\ndefineSymbol(math, ams, textord, \"\\u25ca\", \"\\\\lozenge\");\ndefineSymbol(math, ams, textord, \"\\u24c8\", \"\\\\circledS\");\ndefineSymbol(math, ams, textord, \"\\u00ae\", \"\\\\circledR\");\ndefineSymbol(text, ams, textord, \"\\u00ae\", \"\\\\circledR\");\ndefineSymbol(math, ams, textord, \"\\u2221\", \"\\\\measuredangle\", true);\ndefineSymbol(math, ams, textord, \"\\u2204\", \"\\\\nexists\");\ndefineSymbol(math, ams, textord, \"\\u2127\", \"\\\\mho\");\ndefineSymbol(math, ams, textord, \"\\u2132\", \"\\\\Finv\", true);\ndefineSymbol(math, ams, textord, \"\\u2141\", \"\\\\Game\", true);\ndefineSymbol(math, ams, textord, \"\\u2035\", \"\\\\backprime\");\ndefineSymbol(math, ams, textord, \"\\u25b2\", \"\\\\blacktriangle\");\ndefineSymbol(math, ams, textord, \"\\u25bc\", \"\\\\blacktriangledown\");\ndefineSymbol(math, ams, textord, \"\\u25a0\", \"\\\\blacksquare\");\ndefineSymbol(math, ams, textord, \"\\u29eb\", \"\\\\blacklozenge\");\ndefineSymbol(math, ams, textord, \"\\u2605\", \"\\\\bigstar\");\ndefineSymbol(math, ams, textord, \"\\u2222\", \"\\\\sphericalangle\", true);\ndefineSymbol(math, ams, textord, \"\\u2201\", \"\\\\complement\", true); // unicode-math maps U+F0 to \\matheth. We map to AMS function \\eth\n\ndefineSymbol(math, ams, textord, \"\\u00f0\", \"\\\\eth\", true);\ndefineSymbol(text, main, textord, \"\\u00f0\", \"\\u00f0\");\ndefineSymbol(math, ams, textord, \"\\u2571\", \"\\\\diagup\");\ndefineSymbol(math, ams, textord, \"\\u2572\", \"\\\\diagdown\");\ndefineSymbol(math, ams, textord, \"\\u25a1\", \"\\\\square\");\ndefineSymbol(math, ams, textord, \"\\u25a1\", \"\\\\Box\");\ndefineSymbol(math, ams, textord, \"\\u25ca\", \"\\\\Diamond\"); // unicode-math maps U+A5 to \\mathyen. We map to AMS function \\yen\n\ndefineSymbol(math, ams, textord, \"\\u00a5\", \"\\\\yen\", true);\ndefineSymbol(text, ams, textord, \"\\u00a5\", \"\\\\yen\", true);\ndefineSymbol(math, ams, textord, \"\\u2713\", \"\\\\checkmark\", true);\ndefineSymbol(text, ams, textord, \"\\u2713\", \"\\\\checkmark\"); // AMS Hebrew\n\ndefineSymbol(math, ams, textord, \"\\u2136\", \"\\\\beth\", true);\ndefineSymbol(math, ams, textord, \"\\u2138\", \"\\\\daleth\", true);\ndefineSymbol(math, ams, textord, \"\\u2137\", \"\\\\gimel\", true); // AMS Greek\n\ndefineSymbol(math, ams, textord, \"\\u03dd\", \"\\\\digamma\", true);\ndefineSymbol(math, ams, textord, \"\\u03f0\", \"\\\\varkappa\"); // AMS Delimiters\n\ndefineSymbol(math, ams, open, \"\\u250c\", \"\\\\@ulcorner\", true);\ndefineSymbol(math, ams, close, \"\\u2510\", \"\\\\@urcorner\", true);\ndefineSymbol(math, ams, open, \"\\u2514\", \"\\\\@llcorner\", true);\ndefineSymbol(math, ams, close, \"\\u2518\", \"\\\\@lrcorner\", true); // AMS Binary Relations\n\ndefineSymbol(math, ams, rel, \"\\u2266\", \"\\\\leqq\", true);\ndefineSymbol(math, ams, rel, \"\\u2a7d\", \"\\\\leqslant\", true);\ndefineSymbol(math, ams, rel, \"\\u2a95\", \"\\\\eqslantless\", true);\ndefineSymbol(math, ams, rel, \"\\u2272\", \"\\\\lesssim\", true);\ndefineSymbol(math, ams, rel, \"\\u2a85\", \"\\\\lessapprox\", true);\ndefineSymbol(math, ams, rel, \"\\u224a\", \"\\\\approxeq\", true);\ndefineSymbol(math, ams, bin, \"\\u22d6\", \"\\\\lessdot\");\ndefineSymbol(math, ams, rel, \"\\u22d8\", \"\\\\lll\", true);\ndefineSymbol(math, ams, rel, \"\\u2276\", \"\\\\lessgtr\", true);\ndefineSymbol(math, ams, rel, \"\\u22da\", \"\\\\lesseqgtr\", true);\ndefineSymbol(math, ams, rel, \"\\u2a8b\", \"\\\\lesseqqgtr\", true);\ndefineSymbol(math, ams, rel, \"\\u2251\", \"\\\\doteqdot\");\ndefineSymbol(math, ams, rel, \"\\u2253\", \"\\\\risingdotseq\", true);\ndefineSymbol(math, ams, rel, \"\\u2252\", \"\\\\fallingdotseq\", true);\ndefineSymbol(math, ams, rel, \"\\u223d\", \"\\\\backsim\", true);\ndefineSymbol(math, ams, rel, \"\\u22cd\", \"\\\\backsimeq\", true);\ndefineSymbol(math, ams, rel, \"\\u2ac5\", \"\\\\subseteqq\", true);\ndefineSymbol(math, ams, rel, \"\\u22d0\", \"\\\\Subset\", true);\ndefineSymbol(math, ams, rel, \"\\u228f\", \"\\\\sqsubset\", true);\ndefineSymbol(math, ams, rel, \"\\u227c\", \"\\\\preccurlyeq\", true);\ndefineSymbol(math, ams, rel, \"\\u22de\", \"\\\\curlyeqprec\", true);\ndefineSymbol(math, ams, rel, \"\\u227e\", \"\\\\precsim\", true);\ndefineSymbol(math, ams, rel, \"\\u2ab7\", \"\\\\precapprox\", true);\ndefineSymbol(math, ams, rel, \"\\u22b2\", \"\\\\vartriangleleft\");\ndefineSymbol(math, ams, rel, \"\\u22b4\", \"\\\\trianglelefteq\");\ndefineSymbol(math, ams, rel, \"\\u22a8\", \"\\\\vDash\", true);\ndefineSymbol(math, ams, rel, \"\\u22aa\", \"\\\\Vvdash\", true);\ndefineSymbol(math, ams, rel, \"\\u2323\", \"\\\\smallsmile\");\ndefineSymbol(math, ams, rel, \"\\u2322\", \"\\\\smallfrown\");\ndefineSymbol(math, ams, rel, \"\\u224f\", \"\\\\bumpeq\", true);\ndefineSymbol(math, ams, rel, \"\\u224e\", \"\\\\Bumpeq\", true);\ndefineSymbol(math, ams, rel, \"\\u2267\", \"\\\\geqq\", true);\ndefineSymbol(math, ams, rel, \"\\u2a7e\", \"\\\\geqslant\", true);\ndefineSymbol(math, ams, rel, \"\\u2a96\", \"\\\\eqslantgtr\", true);\ndefineSymbol(math, ams, rel, \"\\u2273\", \"\\\\gtrsim\", true);\ndefineSymbol(math, ams, rel, \"\\u2a86\", \"\\\\gtrapprox\", true);\ndefineSymbol(math, ams, bin, \"\\u22d7\", \"\\\\gtrdot\");\ndefineSymbol(math, ams, rel, \"\\u22d9\", \"\\\\ggg\", true);\ndefineSymbol(math, ams, rel, \"\\u2277\", \"\\\\gtrless\", true);\ndefineSymbol(math, ams, rel, \"\\u22db\", \"\\\\gtreqless\", true);\ndefineSymbol(math, ams, rel, \"\\u2a8c\", \"\\\\gtreqqless\", true);\ndefineSymbol(math, ams, rel, \"\\u2256\", \"\\\\eqcirc\", true);\ndefineSymbol(math, ams, rel, \"\\u2257\", \"\\\\circeq\", true);\ndefineSymbol(math, ams, rel, \"\\u225c\", \"\\\\triangleq\", true);\ndefineSymbol(math, ams, rel, \"\\u223c\", \"\\\\thicksim\");\ndefineSymbol(math, ams, rel, \"\\u2248\", \"\\\\thickapprox\");\ndefineSymbol(math, ams, rel, \"\\u2ac6\", \"\\\\supseteqq\", true);\ndefineSymbol(math, ams, rel, \"\\u22d1\", \"\\\\Supset\", true);\ndefineSymbol(math, ams, rel, \"\\u2290\", \"\\\\sqsupset\", true);\ndefineSymbol(math, ams, rel, \"\\u227d\", \"\\\\succcurlyeq\", true);\ndefineSymbol(math, ams, rel, \"\\u22df\", \"\\\\curlyeqsucc\", true);\ndefineSymbol(math, ams, rel, \"\\u227f\", \"\\\\succsim\", true);\ndefineSymbol(math, ams, rel, \"\\u2ab8\", \"\\\\succapprox\", true);\ndefineSymbol(math, ams, rel, \"\\u22b3\", \"\\\\vartriangleright\");\ndefineSymbol(math, ams, rel, \"\\u22b5\", \"\\\\trianglerighteq\");\ndefineSymbol(math, ams, rel, \"\\u22a9\", \"\\\\Vdash\", true);\ndefineSymbol(math, ams, rel, \"\\u2223\", \"\\\\shortmid\");\ndefineSymbol(math, ams, rel, \"\\u2225\", \"\\\\shortparallel\");\ndefineSymbol(math, ams, rel, \"\\u226c\", \"\\\\between\", true);\ndefineSymbol(math, ams, rel, \"\\u22d4\", \"\\\\pitchfork\", true);\ndefineSymbol(math, ams, rel, \"\\u221d\", \"\\\\varpropto\");\ndefineSymbol(math, ams, rel, \"\\u25c0\", \"\\\\blacktriangleleft\"); // unicode-math says that \\therefore is a mathord atom.\n// We kept the amssymb atom type, which is rel.\n\ndefineSymbol(math, ams, rel, \"\\u2234\", \"\\\\therefore\", true);\ndefineSymbol(math, ams, rel, \"\\u220d\", \"\\\\backepsilon\");\ndefineSymbol(math, ams, rel, \"\\u25b6\", \"\\\\blacktriangleright\"); // unicode-math says that \\because is a mathord atom.\n// We kept the amssymb atom type, which is rel.\n\ndefineSymbol(math, ams, rel, \"\\u2235\", \"\\\\because\", true);\ndefineSymbol(math, ams, rel, \"\\u22d8\", \"\\\\llless\");\ndefineSymbol(math, ams, rel, \"\\u22d9\", \"\\\\gggtr\");\ndefineSymbol(math, ams, bin, \"\\u22b2\", \"\\\\lhd\");\ndefineSymbol(math, ams, bin, \"\\u22b3\", \"\\\\rhd\");\ndefineSymbol(math, ams, rel, \"\\u2242\", \"\\\\eqsim\", true);\ndefineSymbol(math, main, rel, \"\\u22c8\", \"\\\\Join\");\ndefineSymbol(math, ams, rel, \"\\u2251\", \"\\\\Doteq\", true); // AMS Binary Operators\n\ndefineSymbol(math, ams, bin, \"\\u2214\", \"\\\\dotplus\", true);\ndefineSymbol(math, ams, bin, \"\\u2216\", \"\\\\smallsetminus\");\ndefineSymbol(math, ams, bin, \"\\u22d2\", \"\\\\Cap\", true);\ndefineSymbol(math, ams, bin, \"\\u22d3\", \"\\\\Cup\", true);\ndefineSymbol(math, ams, bin, \"\\u2a5e\", \"\\\\doublebarwedge\", true);\ndefineSymbol(math, ams, bin, \"\\u229f\", \"\\\\boxminus\", true);\ndefineSymbol(math, ams, bin, \"\\u229e\", \"\\\\boxplus\", true);\ndefineSymbol(math, ams, bin, \"\\u22c7\", \"\\\\divideontimes\", true);\ndefineSymbol(math, ams, bin, \"\\u22c9\", \"\\\\ltimes\", true);\ndefineSymbol(math, ams, bin, \"\\u22ca\", \"\\\\rtimes\", true);\ndefineSymbol(math, ams, bin, \"\\u22cb\", \"\\\\leftthreetimes\", true);\ndefineSymbol(math, ams, bin, \"\\u22cc\", \"\\\\rightthreetimes\", true);\ndefineSymbol(math, ams, bin, \"\\u22cf\", \"\\\\curlywedge\", true);\ndefineSymbol(math, ams, bin, \"\\u22ce\", \"\\\\curlyvee\", true);\ndefineSymbol(math, ams, bin, \"\\u229d\", \"\\\\circleddash\", true);\ndefineSymbol(math, ams, bin, \"\\u229b\", \"\\\\circledast\", true);\ndefineSymbol(math, ams, bin, \"\\u22c5\", \"\\\\centerdot\");\ndefineSymbol(math, ams, bin, \"\\u22ba\", \"\\\\intercal\", true);\ndefineSymbol(math, ams, bin, \"\\u22d2\", \"\\\\doublecap\");\ndefineSymbol(math, ams, bin, \"\\u22d3\", \"\\\\doublecup\");\ndefineSymbol(math, ams, bin, \"\\u22a0\", \"\\\\boxtimes\", true); // AMS Arrows\n// Note: unicode-math maps \\u21e2 to their own function \\rightdasharrow.\n// We'll map it to AMS function \\dashrightarrow. It produces the same atom.\n\ndefineSymbol(math, ams, rel, \"\\u21e2\", \"\\\\dashrightarrow\", true); // unicode-math maps \\u21e0 to \\leftdasharrow. We'll use the AMS synonym.\n\ndefineSymbol(math, ams, rel, \"\\u21e0\", \"\\\\dashleftarrow\", true);\ndefineSymbol(math, ams, rel, \"\\u21c7\", \"\\\\leftleftarrows\", true);\ndefineSymbol(math, ams, rel, \"\\u21c6\", \"\\\\leftrightarrows\", true);\ndefineSymbol(math, ams, rel, \"\\u21da\", \"\\\\Lleftarrow\", true);\ndefineSymbol(math, ams, rel, \"\\u219e\", \"\\\\twoheadleftarrow\", true);\ndefineSymbol(math, ams, rel, \"\\u21a2\", \"\\\\leftarrowtail\", true);\ndefineSymbol(math, ams, rel, \"\\u21ab\", \"\\\\looparrowleft\", true);\ndefineSymbol(math, ams, rel, \"\\u21cb\", \"\\\\leftrightharpoons\", true);\ndefineSymbol(math, ams, rel, \"\\u21b6\", \"\\\\curvearrowleft\", true); // unicode-math maps \\u21ba to \\acwopencirclearrow. We'll use the AMS synonym.\n\ndefineSymbol(math, ams, rel, \"\\u21ba\", \"\\\\circlearrowleft\", true);\ndefineSymbol(math, ams, rel, \"\\u21b0\", \"\\\\Lsh\", true);\ndefineSymbol(math, ams, rel, \"\\u21c8\", \"\\\\upuparrows\", true);\ndefineSymbol(math, ams, rel, \"\\u21bf\", \"\\\\upharpoonleft\", true);\ndefineSymbol(math, ams, rel, \"\\u21c3\", \"\\\\downharpoonleft\", true);\ndefineSymbol(math, main, rel, \"\\u22b6\", \"\\\\origof\", true); // not in font\n\ndefineSymbol(math, main, rel, \"\\u22b7\", \"\\\\imageof\", true); // not in font\n\ndefineSymbol(math, ams, rel, \"\\u22b8\", \"\\\\multimap\", true);\ndefineSymbol(math, ams, rel, \"\\u21ad\", \"\\\\leftrightsquigarrow\", true);\ndefineSymbol(math, ams, rel, \"\\u21c9\", \"\\\\rightrightarrows\", true);\ndefineSymbol(math, ams, rel, \"\\u21c4\", \"\\\\rightleftarrows\", true);\ndefineSymbol(math, ams, rel, \"\\u21a0\", \"\\\\twoheadrightarrow\", true);\ndefineSymbol(math, ams, rel, \"\\u21a3\", \"\\\\rightarrowtail\", true);\ndefineSymbol(math, ams, rel, \"\\u21ac\", \"\\\\looparrowright\", true);\ndefineSymbol(math, ams, rel, \"\\u21b7\", \"\\\\curvearrowright\", true); // unicode-math maps \\u21bb to \\cwopencirclearrow. We'll use the AMS synonym.\n\ndefineSymbol(math, ams, rel, \"\\u21bb\", \"\\\\circlearrowright\", true);\ndefineSymbol(math, ams, rel, \"\\u21b1\", \"\\\\Rsh\", true);\ndefineSymbol(math, ams, rel, \"\\u21ca\", \"\\\\downdownarrows\", true);\ndefineSymbol(math, ams, rel, \"\\u21be\", \"\\\\upharpoonright\", true);\ndefineSymbol(math, ams, rel, \"\\u21c2\", \"\\\\downharpoonright\", true);\ndefineSymbol(math, ams, rel, \"\\u21dd\", \"\\\\rightsquigarrow\", true);\ndefineSymbol(math, ams, rel, \"\\u21dd\", \"\\\\leadsto\");\ndefineSymbol(math, ams, rel, \"\\u21db\", \"\\\\Rrightarrow\", true);\ndefineSymbol(math, ams, rel, \"\\u21be\", \"\\\\restriction\");\ndefineSymbol(math, main, textord, \"\\u2018\", \"`\");\ndefineSymbol(math, main, textord, \"$\", \"\\\\$\");\ndefineSymbol(text, main, textord, \"$\", \"\\\\$\");\ndefineSymbol(text, main, textord, \"$\", \"\\\\textdollar\");\ndefineSymbol(math, main, textord, \"%\", \"\\\\%\");\ndefineSymbol(text, main, textord, \"%\", \"\\\\%\");\ndefineSymbol(math, main, textord, \"_\", \"\\\\_\");\ndefineSymbol(text, main, textord, \"_\", \"\\\\_\");\ndefineSymbol(text, main, textord, \"_\", \"\\\\textunderscore\");\ndefineSymbol(math, main, textord, \"\\u2220\", \"\\\\angle\", true);\ndefineSymbol(math, main, textord, \"\\u221e\", \"\\\\infty\", true);\ndefineSymbol(math, main, textord, \"\\u2032\", \"\\\\prime\");\ndefineSymbol(math, main, textord, \"\\u25b3\", \"\\\\triangle\");\ndefineSymbol(math, main, textord, \"\\u0393\", \"\\\\Gamma\", true);\ndefineSymbol(math, main, textord, \"\\u0394\", \"\\\\Delta\", true);\ndefineSymbol(math, main, textord, \"\\u0398\", \"\\\\Theta\", true);\ndefineSymbol(math, main, textord, \"\\u039b\", \"\\\\Lambda\", true);\ndefineSymbol(math, main, textord, \"\\u039e\", \"\\\\Xi\", true);\ndefineSymbol(math, main, textord, \"\\u03a0\", \"\\\\Pi\", true);\ndefineSymbol(math, main, textord, \"\\u03a3\", \"\\\\Sigma\", true);\ndefineSymbol(math, main, textord, \"\\u03a5\", \"\\\\Upsilon\", true);\ndefineSymbol(math, main, textord, \"\\u03a6\", \"\\\\Phi\", true);\ndefineSymbol(math, main, textord, \"\\u03a8\", \"\\\\Psi\", true);\ndefineSymbol(math, main, textord, \"\\u03a9\", \"\\\\Omega\", true);\ndefineSymbol(math, main, textord, \"A\", \"\\u0391\");\ndefineSymbol(math, main, textord, \"B\", \"\\u0392\");\ndefineSymbol(math, main, textord, \"E\", \"\\u0395\");\ndefineSymbol(math, main, textord, \"Z\", \"\\u0396\");\ndefineSymbol(math, main, textord, \"H\", \"\\u0397\");\ndefineSymbol(math, main, textord, \"I\", \"\\u0399\");\ndefineSymbol(math, main, textord, \"K\", \"\\u039A\");\ndefineSymbol(math, main, textord, \"M\", \"\\u039C\");\ndefineSymbol(math, main, textord, \"N\", \"\\u039D\");\ndefineSymbol(math, main, textord, \"O\", \"\\u039F\");\ndefineSymbol(math, main, textord, \"P\", \"\\u03A1\");\ndefineSymbol(math, main, textord, \"T\", \"\\u03A4\");\ndefineSymbol(math, main, textord, \"X\", \"\\u03A7\");\ndefineSymbol(math, main, textord, \"\\u00ac\", \"\\\\neg\", true);\ndefineSymbol(math, main, textord, \"\\u00ac\", \"\\\\lnot\");\ndefineSymbol(math, main, textord, \"\\u22a4\", \"\\\\top\");\ndefineSymbol(math, main, textord, \"\\u22a5\", \"\\\\bot\");\ndefineSymbol(math, main, textord, \"\\u2205\", \"\\\\emptyset\");\ndefineSymbol(math, ams, textord, \"\\u2205\", \"\\\\varnothing\");\ndefineSymbol(math, main, mathord, \"\\u03b1\", \"\\\\alpha\", true);\ndefineSymbol(math, main, mathord, \"\\u03b2\", \"\\\\beta\", true);\ndefineSymbol(math, main, mathord, \"\\u03b3\", \"\\\\gamma\", true);\ndefineSymbol(math, main, mathord, \"\\u03b4\", \"\\\\delta\", true);\ndefineSymbol(math, main, mathord, \"\\u03f5\", \"\\\\epsilon\", true);\ndefineSymbol(math, main, mathord, \"\\u03b6\", \"\\\\zeta\", true);\ndefineSymbol(math, main, mathord, \"\\u03b7\", \"\\\\eta\", true);\ndefineSymbol(math, main, mathord, \"\\u03b8\", \"\\\\theta\", true);\ndefineSymbol(math, main, mathord, \"\\u03b9\", \"\\\\iota\", true);\ndefineSymbol(math, main, mathord, \"\\u03ba\", \"\\\\kappa\", true);\ndefineSymbol(math, main, mathord, \"\\u03bb\", \"\\\\lambda\", true);\ndefineSymbol(math, main, mathord, \"\\u03bc\", \"\\\\mu\", true);\ndefineSymbol(math, main, mathord, \"\\u03bd\", \"\\\\nu\", true);\ndefineSymbol(math, main, mathord, \"\\u03be\", \"\\\\xi\", true);\ndefineSymbol(math, main, mathord, \"\\u03bf\", \"\\\\omicron\", true);\ndefineSymbol(math, main, mathord, \"\\u03c0\", \"\\\\pi\", true);\ndefineSymbol(math, main, mathord, \"\\u03c1\", \"\\\\rho\", true);\ndefineSymbol(math, main, mathord, \"\\u03c3\", \"\\\\sigma\", true);\ndefineSymbol(math, main, mathord, \"\\u03c4\", \"\\\\tau\", true);\ndefineSymbol(math, main, mathord, \"\\u03c5\", \"\\\\upsilon\", true);\ndefineSymbol(math, main, mathord, \"\\u03d5\", \"\\\\phi\", true);\ndefineSymbol(math, main, mathord, \"\\u03c7\", \"\\\\chi\", true);\ndefineSymbol(math, main, mathord, \"\\u03c8\", \"\\\\psi\", true);\ndefineSymbol(math, main, mathord, \"\\u03c9\", \"\\\\omega\", true);\ndefineSymbol(math, main, mathord, \"\\u03b5\", \"\\\\varepsilon\", true);\ndefineSymbol(math, main, mathord, \"\\u03d1\", \"\\\\vartheta\", true);\ndefineSymbol(math, main, mathord, \"\\u03d6\", \"\\\\varpi\", true);\ndefineSymbol(math, main, mathord, \"\\u03f1\", \"\\\\varrho\", true);\ndefineSymbol(math, main, mathord, \"\\u03c2\", \"\\\\varsigma\", true);\ndefineSymbol(math, main, mathord, \"\\u03c6\", \"\\\\varphi\", true);\ndefineSymbol(math, main, bin, \"\\u2217\", \"*\", true);\ndefineSymbol(math, main, bin, \"+\", \"+\");\ndefineSymbol(math, main, bin, \"\\u2212\", \"-\", true);\ndefineSymbol(math, main, bin, \"\\u22c5\", \"\\\\cdot\", true);\ndefineSymbol(math, main, bin, \"\\u2218\", \"\\\\circ\", true);\ndefineSymbol(math, main, bin, \"\\u00f7\", \"\\\\div\", true);\ndefineSymbol(math, main, bin, \"\\u00b1\", \"\\\\pm\", true);\ndefineSymbol(math, main, bin, \"\\u00d7\", \"\\\\times\", true);\ndefineSymbol(math, main, bin, \"\\u2229\", \"\\\\cap\", true);\ndefineSymbol(math, main, bin, \"\\u222a\", \"\\\\cup\", true);\ndefineSymbol(math, main, bin, \"\\u2216\", \"\\\\setminus\", true);\ndefineSymbol(math, main, bin, \"\\u2227\", \"\\\\land\");\ndefineSymbol(math, main, bin, \"\\u2228\", \"\\\\lor\");\ndefineSymbol(math, main, bin, \"\\u2227\", \"\\\\wedge\", true);\ndefineSymbol(math, main, bin, \"\\u2228\", \"\\\\vee\", true);\ndefineSymbol(math, main, textord, \"\\u221a\", \"\\\\surd\");\ndefineSymbol(math, main, open, \"\\u27e8\", \"\\\\langle\", true);\ndefineSymbol(math, main, open, \"\\u2223\", \"\\\\lvert\");\ndefineSymbol(math, main, open, \"\\u2225\", \"\\\\lVert\");\ndefineSymbol(math, main, close, \"?\", \"?\");\ndefineSymbol(math, main, close, \"!\", \"!\");\ndefineSymbol(math, main, close, \"\\u27e9\", \"\\\\rangle\", true);\ndefineSymbol(math, main, close, \"\\u2223\", \"\\\\rvert\");\ndefineSymbol(math, main, close, \"\\u2225\", \"\\\\rVert\");\ndefineSymbol(math, main, rel, \"=\", \"=\");\ndefineSymbol(math, main, rel, \":\", \":\");\ndefineSymbol(math, main, rel, \"\\u2248\", \"\\\\approx\", true);\ndefineSymbol(math, main, rel, \"\\u2245\", \"\\\\cong\", true);\ndefineSymbol(math, main, rel, \"\\u2265\", \"\\\\ge\");\ndefineSymbol(math, main, rel, \"\\u2265\", \"\\\\geq\", true);\ndefineSymbol(math, main, rel, \"\\u2190\", \"\\\\gets\");\ndefineSymbol(math, main, rel, \">\", \"\\\\gt\", true);\ndefineSymbol(math, main, rel, \"\\u2208\", \"\\\\in\", true);\ndefineSymbol(math, main, rel, \"\\ue020\", \"\\\\@not\");\ndefineSymbol(math, main, rel, \"\\u2282\", \"\\\\subset\", true);\ndefineSymbol(math, main, rel, \"\\u2283\", \"\\\\supset\", true);\ndefineSymbol(math, main, rel, \"\\u2286\", \"\\\\subseteq\", true);\ndefineSymbol(math, main, rel, \"\\u2287\", \"\\\\supseteq\", true);\ndefineSymbol(math, ams, rel, \"\\u2288\", \"\\\\nsubseteq\", true);\ndefineSymbol(math, ams, rel, \"\\u2289\", \"\\\\nsupseteq\", true);\ndefineSymbol(math, main, rel, \"\\u22a8\", \"\\\\models\");\ndefineSymbol(math, main, rel, \"\\u2190\", \"\\\\leftarrow\", true);\ndefineSymbol(math, main, rel, \"\\u2264\", \"\\\\le\");\ndefineSymbol(math, main, rel, \"\\u2264\", \"\\\\leq\", true);\ndefineSymbol(math, main, rel, \"<\", \"\\\\lt\", true);\ndefineSymbol(math, main, rel, \"\\u2192\", \"\\\\rightarrow\", true);\ndefineSymbol(math, main, rel, \"\\u2192\", \"\\\\to\");\ndefineSymbol(math, ams, rel, \"\\u2271\", \"\\\\ngeq\", true);\ndefineSymbol(math, ams, rel, \"\\u2270\", \"\\\\nleq\", true);\ndefineSymbol(math, main, spacing, \"\\u00a0\", \"\\\\ \");\ndefineSymbol(math, main, spacing, \"\\u00a0\", \"\\\\space\"); // Ref: LaTeX Source 2e: \\DeclareRobustCommand{\\nobreakspace}{%\n\ndefineSymbol(math, main, spacing, \"\\u00a0\", \"\\\\nobreakspace\");\ndefineSymbol(text, main, spacing, \"\\u00a0\", \"\\\\ \");\ndefineSymbol(text, main, spacing, \"\\u00a0\", \" \");\ndefineSymbol(text, main, spacing, \"\\u00a0\", \"\\\\space\");\ndefineSymbol(text, main, spacing, \"\\u00a0\", \"\\\\nobreakspace\");\ndefineSymbol(math, main, spacing, null, \"\\\\nobreak\");\ndefineSymbol(math, main, spacing, null, \"\\\\allowbreak\");\ndefineSymbol(math, main, punct, \",\", \",\");\ndefineSymbol(math, main, punct, \";\", \";\");\ndefineSymbol(math, ams, bin, \"\\u22bc\", \"\\\\barwedge\", true);\ndefineSymbol(math, ams, bin, \"\\u22bb\", \"\\\\veebar\", true);\ndefineSymbol(math, main, bin, \"\\u2299\", \"\\\\odot\", true);\ndefineSymbol(math, main, bin, \"\\u2295\", \"\\\\oplus\", true);\ndefineSymbol(math, main, bin, \"\\u2297\", \"\\\\otimes\", true);\ndefineSymbol(math, main, textord, \"\\u2202\", \"\\\\partial\", true);\ndefineSymbol(math, main, bin, \"\\u2298\", \"\\\\oslash\", true);\ndefineSymbol(math, ams, bin, \"\\u229a\", \"\\\\circledcirc\", true);\ndefineSymbol(math, ams, bin, \"\\u22a1\", \"\\\\boxdot\", true);\ndefineSymbol(math, main, bin, \"\\u25b3\", \"\\\\bigtriangleup\");\ndefineSymbol(math, main, bin, \"\\u25bd\", \"\\\\bigtriangledown\");\ndefineSymbol(math, main, bin, \"\\u2020\", \"\\\\dagger\");\ndefineSymbol(math, main, bin, \"\\u22c4\", \"\\\\diamond\");\ndefineSymbol(math, main, bin, \"\\u22c6\", \"\\\\star\");\ndefineSymbol(math, main, bin, \"\\u25c3\", \"\\\\triangleleft\");\ndefineSymbol(math, main, bin, \"\\u25b9\", \"\\\\triangleright\");\ndefineSymbol(math, main, open, \"{\", \"\\\\{\");\ndefineSymbol(text, main, textord, \"{\", \"\\\\{\");\ndefineSymbol(text, main, textord, \"{\", \"\\\\textbraceleft\");\ndefineSymbol(math, main, close, \"}\", \"\\\\}\");\ndefineSymbol(text, main, textord, \"}\", \"\\\\}\");\ndefineSymbol(text, main, textord, \"}\", \"\\\\textbraceright\");\ndefineSymbol(math, main, open, \"{\", \"\\\\lbrace\");\ndefineSymbol(math, main, close, \"}\", \"\\\\rbrace\");\ndefineSymbol(math, main, open, \"[\", \"\\\\lbrack\", true);\ndefineSymbol(text, main, textord, \"[\", \"\\\\lbrack\", true);\ndefineSymbol(math, main, close, \"]\", \"\\\\rbrack\", true);\ndefineSymbol(text, main, textord, \"]\", \"\\\\rbrack\", true);\ndefineSymbol(math, main, open, \"(\", \"\\\\lparen\", true);\ndefineSymbol(math, main, close, \")\", \"\\\\rparen\", true);\ndefineSymbol(text, main, textord, \"<\", \"\\\\textless\", true); // in T1 fontenc\n\ndefineSymbol(text, main, textord, \">\", \"\\\\textgreater\", true); // in T1 fontenc\n\ndefineSymbol(math, main, open, \"\\u230a\", \"\\\\lfloor\", true);\ndefineSymbol(math, main, close, \"\\u230b\", \"\\\\rfloor\", true);\ndefineSymbol(math, main, open, \"\\u2308\", \"\\\\lceil\", true);\ndefineSymbol(math, main, close, \"\\u2309\", \"\\\\rceil\", true);\ndefineSymbol(math, main, textord, \"\\\\\", \"\\\\backslash\");\ndefineSymbol(math, main, textord, \"\\u2223\", \"|\");\ndefineSymbol(math, main, textord, \"\\u2223\", \"\\\\vert\");\ndefineSymbol(text, main, textord, \"|\", \"\\\\textbar\", true); // in T1 fontenc\n\ndefineSymbol(math, main, textord, \"\\u2225\", \"\\\\|\");\ndefineSymbol(math, main, textord, \"\\u2225\", \"\\\\Vert\");\ndefineSymbol(text, main, textord, \"\\u2225\", \"\\\\textbardbl\");\ndefineSymbol(text, main, textord, \"~\", \"\\\\textasciitilde\");\ndefineSymbol(text, main, textord, \"\\\\\", \"\\\\textbackslash\");\ndefineSymbol(text, main, textord, \"^\", \"\\\\textasciicircum\");\ndefineSymbol(math, main, rel, \"\\u2191\", \"\\\\uparrow\", true);\ndefineSymbol(math, main, rel, \"\\u21d1\", \"\\\\Uparrow\", true);\ndefineSymbol(math, main, rel, \"\\u2193\", \"\\\\downarrow\", true);\ndefineSymbol(math, main, rel, \"\\u21d3\", \"\\\\Downarrow\", true);\ndefineSymbol(math, main, rel, \"\\u2195\", \"\\\\updownarrow\", true);\ndefineSymbol(math, main, rel, \"\\u21d5\", \"\\\\Updownarrow\", true);\ndefineSymbol(math, main, op, \"\\u2210\", \"\\\\coprod\");\ndefineSymbol(math, main, op, \"\\u22c1\", \"\\\\bigvee\");\ndefineSymbol(math, main, op, \"\\u22c0\", \"\\\\bigwedge\");\ndefineSymbol(math, main, op, \"\\u2a04\", \"\\\\biguplus\");\ndefineSymbol(math, main, op, \"\\u22c2\", \"\\\\bigcap\");\ndefineSymbol(math, main, op, \"\\u22c3\", \"\\\\bigcup\");\ndefineSymbol(math, main, op, \"\\u222b\", \"\\\\int\");\ndefineSymbol(math, main, op, \"\\u222b\", \"\\\\intop\");\ndefineSymbol(math, main, op, \"\\u222c\", \"\\\\iint\");\ndefineSymbol(math, main, op, \"\\u222d\", \"\\\\iiint\");\ndefineSymbol(math, main, op, \"\\u220f\", \"\\\\prod\");\ndefineSymbol(math, main, op, \"\\u2211\", \"\\\\sum\");\ndefineSymbol(math, main, op, \"\\u2a02\", \"\\\\bigotimes\");\ndefineSymbol(math, main, op, \"\\u2a01\", \"\\\\bigoplus\");\ndefineSymbol(math, main, op, \"\\u2a00\", \"\\\\bigodot\");\ndefineSymbol(math, main, op, \"\\u222e\", \"\\\\oint\");\ndefineSymbol(math, main, op, \"\\u222f\", \"\\\\oiint\");\ndefineSymbol(math, main, op, \"\\u2230\", \"\\\\oiiint\");\ndefineSymbol(math, main, op, \"\\u2a06\", \"\\\\bigsqcup\");\ndefineSymbol(math, main, op, \"\\u222b\", \"\\\\smallint\");\ndefineSymbol(text, main, inner, \"\\u2026\", \"\\\\textellipsis\");\ndefineSymbol(math, main, inner, \"\\u2026\", \"\\\\mathellipsis\");\ndefineSymbol(text, main, inner, \"\\u2026\", \"\\\\ldots\", true);\ndefineSymbol(math, main, inner, \"\\u2026\", \"\\\\ldots\", true);\ndefineSymbol(math, main, inner, \"\\u22ef\", \"\\\\@cdots\", true);\ndefineSymbol(math, main, inner, \"\\u22f1\", \"\\\\ddots\", true); // \\vdots is a macro that uses one of these two symbols (with made-up names):\n\ndefineSymbol(math, main, textord, \"\\u22ee\", \"\\\\varvdots\");\ndefineSymbol(text, main, textord, \"\\u22ee\", \"\\\\varvdots\");\ndefineSymbol(math, main, accent, \"\\u02ca\", \"\\\\acute\");\ndefineSymbol(math, main, accent, \"\\u02cb\", \"\\\\grave\");\ndefineSymbol(math, main, accent, \"\\u00a8\", \"\\\\ddot\");\ndefineSymbol(math, main, accent, \"\\u007e\", \"\\\\tilde\");\ndefineSymbol(math, main, accent, \"\\u02c9\", \"\\\\bar\");\ndefineSymbol(math, main, accent, \"\\u02d8\", \"\\\\breve\");\ndefineSymbol(math, main, accent, \"\\u02c7\", \"\\\\check\");\ndefineSymbol(math, main, accent, \"\\u005e\", \"\\\\hat\");\ndefineSymbol(math, main, accent, \"\\u20d7\", \"\\\\vec\");\ndefineSymbol(math, main, accent, \"\\u02d9\", \"\\\\dot\");\ndefineSymbol(math, main, accent, \"\\u02da\", \"\\\\mathring\"); // \\imath and \\jmath should be invariant to \\mathrm, \\mathbf, etc., so use PUA\n\ndefineSymbol(math, main, mathord, \"\\ue131\", \"\\\\@imath\");\ndefineSymbol(math, main, mathord, \"\\ue237\", \"\\\\@jmath\");\ndefineSymbol(math, main, textord, \"\\u0131\", \"\\u0131\");\ndefineSymbol(math, main, textord, \"\\u0237\", \"\\u0237\");\ndefineSymbol(text, main, textord, \"\\u0131\", \"\\\\i\", true);\ndefineSymbol(text, main, textord, \"\\u0237\", \"\\\\j\", true);\ndefineSymbol(text, main, textord, \"\\u00df\", \"\\\\ss\", true);\ndefineSymbol(text, main, textord, \"\\u00e6\", \"\\\\ae\", true);\ndefineSymbol(text, main, textord, \"\\u0153\", \"\\\\oe\", true);\ndefineSymbol(text, main, textord, \"\\u00f8\", \"\\\\o\", true);\ndefineSymbol(text, main, textord, \"\\u00c6\", \"\\\\AE\", true);\ndefineSymbol(text, main, textord, \"\\u0152\", \"\\\\OE\", true);\ndefineSymbol(text, main, textord, \"\\u00d8\", \"\\\\O\", true);\ndefineSymbol(text, main, accent, \"\\u02ca\", \"\\\\'\"); // acute\n\ndefineSymbol(text, main, accent, \"\\u02cb\", \"\\\\`\"); // grave\n\ndefineSymbol(text, main, accent, \"\\u02c6\", \"\\\\^\"); // circumflex\n\ndefineSymbol(text, main, accent, \"\\u02dc\", \"\\\\~\"); // tilde\n\ndefineSymbol(text, main, accent, \"\\u02c9\", \"\\\\=\"); // macron\n\ndefineSymbol(text, main, accent, \"\\u02d8\", \"\\\\u\"); // breve\n\ndefineSymbol(text, main, accent, \"\\u02d9\", \"\\\\.\"); // dot above\n\ndefineSymbol(text, main, accent, \"\\u00b8\", \"\\\\c\"); // cedilla\n\ndefineSymbol(text, main, accent, \"\\u02da\", \"\\\\r\"); // ring above\n\ndefineSymbol(text, main, accent, \"\\u02c7\", \"\\\\v\"); // caron\n\ndefineSymbol(text, main, accent, \"\\u00a8\", '\\\\\"'); // diaresis\n\ndefineSymbol(text, main, accent, \"\\u02dd\", \"\\\\H\"); // double acute\n\ndefineSymbol(text, main, accent, \"\\u25ef\", \"\\\\textcircled\"); // \\bigcirc glyph\n// These ligatures are detected and created in Parser.js's `formLigatures`.\n\nvar ligatures = {\n  \"--\": true,\n  \"---\": true,\n  \"``\": true,\n  \"''\": true\n};\ndefineSymbol(text, main, textord, \"\\u2013\", \"--\", true);\ndefineSymbol(text, main, textord, \"\\u2013\", \"\\\\textendash\");\ndefineSymbol(text, main, textord, \"\\u2014\", \"---\", true);\ndefineSymbol(text, main, textord, \"\\u2014\", \"\\\\textemdash\");\ndefineSymbol(text, main, textord, \"\\u2018\", \"`\", true);\ndefineSymbol(text, main, textord, \"\\u2018\", \"\\\\textquoteleft\");\ndefineSymbol(text, main, textord, \"\\u2019\", \"'\", true);\ndefineSymbol(text, main, textord, \"\\u2019\", \"\\\\textquoteright\");\ndefineSymbol(text, main, textord, \"\\u201c\", \"``\", true);\ndefineSymbol(text, main, textord, \"\\u201c\", \"\\\\textquotedblleft\");\ndefineSymbol(text, main, textord, \"\\u201d\", \"''\", true);\ndefineSymbol(text, main, textord, \"\\u201d\", \"\\\\textquotedblright\"); //  \\degree from gensymb package\n\ndefineSymbol(math, main, textord, \"\\u00b0\", \"\\\\degree\", true);\ndefineSymbol(text, main, textord, \"\\u00b0\", \"\\\\degree\"); // \\textdegree from inputenc package\n\ndefineSymbol(text, main, textord, \"\\u00b0\", \"\\\\textdegree\", true); // TODO: In LaTeX, \\pounds can generate a different character in text and math\n// mode, but among our fonts, only Main-Regular defines this character \"163\".\n\ndefineSymbol(math, main, textord, \"\\u00a3\", \"\\\\pounds\");\ndefineSymbol(math, main, textord, \"\\u00a3\", \"\\\\mathsterling\", true);\ndefineSymbol(text, main, textord, \"\\u00a3\", \"\\\\pounds\");\ndefineSymbol(text, main, textord, \"\\u00a3\", \"\\\\textsterling\", true);\ndefineSymbol(math, ams, textord, \"\\u2720\", \"\\\\maltese\");\ndefineSymbol(text, ams, textord, \"\\u2720\", \"\\\\maltese\"); // There are lots of symbols which are the same, so we add them in afterwards.\n// All of these are textords in math mode\n\nvar mathTextSymbols = \"0123456789/@.\\\"\";\n\nfor (var i = 0; i < mathTextSymbols.length; i++) {\n  var ch = mathTextSymbols.charAt(i);\n  defineSymbol(math, main, textord, ch, ch);\n} // All of these are textords in text mode\n\n\nvar textSymbols = \"0123456789!@*()-=+\\\";:?/.,\";\n\nfor (var _i = 0; _i < textSymbols.length; _i++) {\n  var _ch = textSymbols.charAt(_i);\n\n  defineSymbol(text, main, textord, _ch, _ch);\n} // All of these are textords in text mode, and mathords in math mode\n\n\nvar letters = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\";\n\nfor (var _i2 = 0; _i2 < letters.length; _i2++) {\n  var _ch2 = letters.charAt(_i2);\n\n  defineSymbol(math, main, mathord, _ch2, _ch2);\n  defineSymbol(text, main, textord, _ch2, _ch2);\n} // Blackboard bold and script letters in Unicode range\n\n\ndefineSymbol(math, ams, textord, \"C\", \"\\u2102\"); // blackboard bold\n\ndefineSymbol(text, ams, textord, \"C\", \"\\u2102\");\ndefineSymbol(math, ams, textord, \"H\", \"\\u210D\");\ndefineSymbol(text, ams, textord, \"H\", \"\\u210D\");\ndefineSymbol(math, ams, textord, \"N\", \"\\u2115\");\ndefineSymbol(text, ams, textord, \"N\", \"\\u2115\");\ndefineSymbol(math, ams, textord, \"P\", \"\\u2119\");\ndefineSymbol(text, ams, textord, \"P\", \"\\u2119\");\ndefineSymbol(math, ams, textord, \"Q\", \"\\u211A\");\ndefineSymbol(text, ams, textord, \"Q\", \"\\u211A\");\ndefineSymbol(math, ams, textord, \"R\", \"\\u211D\");\ndefineSymbol(text, ams, textord, \"R\", \"\\u211D\");\ndefineSymbol(math, ams, textord, \"Z\", \"\\u2124\");\ndefineSymbol(text, ams, textord, \"Z\", \"\\u2124\");\ndefineSymbol(math, main, mathord, \"h\", \"\\u210E\"); // italic h, Planck constant\n\ndefineSymbol(text, main, mathord, \"h\", \"\\u210E\"); // The next loop loads wide (surrogate pair) characters.\n// We support some letters in the Unicode range U+1D400 to U+1D7FF,\n// Mathematical Alphanumeric Symbols.\n// Some editors do not deal well with wide characters. So don't write the\n// string into this file. Instead, create the string from the surrogate pair.\n\nvar wideChar = \"\";\n\nfor (var _i3 = 0; _i3 < letters.length; _i3++) {\n  var _ch3 = letters.charAt(_i3); // The hex numbers in the next line are a surrogate pair.\n  // 0xD835 is the high surrogate for all letters in the range we support.\n  // 0xDC00 is the low surrogate for bold A.\n\n\n  wideChar = String.fromCharCode(0xD835, 0xDC00 + _i3); // A-Z a-z bold\n\n  defineSymbol(math, main, mathord, _ch3, wideChar);\n  defineSymbol(text, main, textord, _ch3, wideChar);\n  wideChar = String.fromCharCode(0xD835, 0xDC34 + _i3); // A-Z a-z italic\n\n  defineSymbol(math, main, mathord, _ch3, wideChar);\n  defineSymbol(text, main, textord, _ch3, wideChar);\n  wideChar = String.fromCharCode(0xD835, 0xDC68 + _i3); // A-Z a-z bold italic\n\n  defineSymbol(math, main, mathord, _ch3, wideChar);\n  defineSymbol(text, main, textord, _ch3, wideChar);\n  wideChar = String.fromCharCode(0xD835, 0xDD04 + _i3); // A-Z a-z Fraktur\n\n  defineSymbol(math, main, mathord, _ch3, wideChar);\n  defineSymbol(text, main, textord, _ch3, wideChar);\n  wideChar = String.fromCharCode(0xD835, 0xDD6C + _i3); // A-Z a-z bold Fraktur\n\n  defineSymbol(math, main, mathord, _ch3, wideChar);\n  defineSymbol(text, main, textord, _ch3, wideChar);\n  wideChar = String.fromCharCode(0xD835, 0xDDA0 + _i3); // A-Z a-z sans-serif\n\n  defineSymbol(math, main, mathord, _ch3, wideChar);\n  defineSymbol(text, main, textord, _ch3, wideChar);\n  wideChar = String.fromCharCode(0xD835, 0xDDD4 + _i3); // A-Z a-z sans bold\n\n  defineSymbol(math, main, mathord, _ch3, wideChar);\n  defineSymbol(text, main, textord, _ch3, wideChar);\n  wideChar = String.fromCharCode(0xD835, 0xDE08 + _i3); // A-Z a-z sans italic\n\n  defineSymbol(math, main, mathord, _ch3, wideChar);\n  defineSymbol(text, main, textord, _ch3, wideChar);\n  wideChar = String.fromCharCode(0xD835, 0xDE70 + _i3); // A-Z a-z monospace\n\n  defineSymbol(math, main, mathord, _ch3, wideChar);\n  defineSymbol(text, main, textord, _ch3, wideChar);\n\n  if (_i3 < 26) {\n    // KaTeX fonts have only capital letters for blackboard bold and script.\n    // See exception for k below.\n    wideChar = String.fromCharCode(0xD835, 0xDD38 + _i3); // A-Z double struck\n\n    defineSymbol(math, main, mathord, _ch3, wideChar);\n    defineSymbol(text, main, textord, _ch3, wideChar);\n    wideChar = String.fromCharCode(0xD835, 0xDC9C + _i3); // A-Z script\n\n    defineSymbol(math, main, mathord, _ch3, wideChar);\n    defineSymbol(text, main, textord, _ch3, wideChar);\n  } // TODO: Add bold script when it is supported by a KaTeX font.\n\n} // \"k\" is the only double struck lower case letter in the KaTeX fonts.\n\n\nwideChar = String.fromCharCode(0xD835, 0xDD5C); // k double struck\n\ndefineSymbol(math, main, mathord, \"k\", wideChar);\ndefineSymbol(text, main, textord, \"k\", wideChar); // Next, some wide character numerals\n\nfor (var _i4 = 0; _i4 < 10; _i4++) {\n  var _ch4 = _i4.toString();\n\n  wideChar = String.fromCharCode(0xD835, 0xDFCE + _i4); // 0-9 bold\n\n  defineSymbol(math, main, mathord, _ch4, wideChar);\n  defineSymbol(text, main, textord, _ch4, wideChar);\n  wideChar = String.fromCharCode(0xD835, 0xDFE2 + _i4); // 0-9 sans serif\n\n  defineSymbol(math, main, mathord, _ch4, wideChar);\n  defineSymbol(text, main, textord, _ch4, wideChar);\n  wideChar = String.fromCharCode(0xD835, 0xDFEC + _i4); // 0-9 bold sans\n\n  defineSymbol(math, main, mathord, _ch4, wideChar);\n  defineSymbol(text, main, textord, _ch4, wideChar);\n  wideChar = String.fromCharCode(0xD835, 0xDFF6 + _i4); // 0-9 monospace\n\n  defineSymbol(math, main, mathord, _ch4, wideChar);\n  defineSymbol(text, main, textord, _ch4, wideChar);\n} // We add these Latin-1 letters as symbols for backwards-compatibility,\n// but they are not actually in the font, nor are they supported by the\n// Unicode accent mechanism, so they fall back to Times font and look ugly.\n// TODO(edemaine): Fix this.\n\n\nvar extraLatin = \"\\u00d0\\u00de\\u00fe\";\n\nfor (var _i5 = 0; _i5 < extraLatin.length; _i5++) {\n  var _ch5 = extraLatin.charAt(_i5);\n\n  defineSymbol(math, main, mathord, _ch5, _ch5);\n  defineSymbol(text, main, textord, _ch5, _ch5);\n}\n\n/**\n * This file provides support for Unicode range U+1D400 to U+1D7FF,\n * Mathematical Alphanumeric Symbols.\n *\n * Function wideCharacterFont takes a wide character as input and returns\n * the font information necessary to render it properly.\n */\n/**\n * Data below is from https://www.unicode.org/charts/PDF/U1D400.pdf\n * That document sorts characters into groups by font type, say bold or italic.\n *\n * In the arrays below, each subarray consists three elements:\n *      * The CSS class of that group when in math mode.\n *      * The CSS class of that group when in text mode.\n *      * The font name, so that KaTeX can get font metrics.\n */\n\nvar wideLatinLetterData = [[\"mathbf\", \"textbf\", \"Main-Bold\"], // A-Z bold upright\n[\"mathbf\", \"textbf\", \"Main-Bold\"], // a-z bold upright\n[\"mathnormal\", \"textit\", \"Math-Italic\"], // A-Z italic\n[\"mathnormal\", \"textit\", \"Math-Italic\"], // a-z italic\n[\"boldsymbol\", \"boldsymbol\", \"Main-BoldItalic\"], // A-Z bold italic\n[\"boldsymbol\", \"boldsymbol\", \"Main-BoldItalic\"], // a-z bold italic\n// Map fancy A-Z letters to script, not calligraphic.\n// This aligns with unicode-math and math fonts (except Cambria Math).\n[\"mathscr\", \"textscr\", \"Script-Regular\"], // A-Z script\n[\"\", \"\", \"\"], // a-z script.  No font\n[\"\", \"\", \"\"], // A-Z bold script. No font\n[\"\", \"\", \"\"], // a-z bold script. No font\n[\"mathfrak\", \"textfrak\", \"Fraktur-Regular\"], // A-Z Fraktur\n[\"mathfrak\", \"textfrak\", \"Fraktur-Regular\"], // a-z Fraktur\n[\"mathbb\", \"textbb\", \"AMS-Regular\"], // A-Z double-struck\n[\"mathbb\", \"textbb\", \"AMS-Regular\"], // k double-struck\n// Note that we are using a bold font, but font metrics for regular Fraktur.\n[\"mathboldfrak\", \"textboldfrak\", \"Fraktur-Regular\"], // A-Z bold Fraktur\n[\"mathboldfrak\", \"textboldfrak\", \"Fraktur-Regular\"], // a-z bold Fraktur\n[\"mathsf\", \"textsf\", \"SansSerif-Regular\"], // A-Z sans-serif\n[\"mathsf\", \"textsf\", \"SansSerif-Regular\"], // a-z sans-serif\n[\"mathboldsf\", \"textboldsf\", \"SansSerif-Bold\"], // A-Z bold sans-serif\n[\"mathboldsf\", \"textboldsf\", \"SansSerif-Bold\"], // a-z bold sans-serif\n[\"mathitsf\", \"textitsf\", \"SansSerif-Italic\"], // A-Z italic sans-serif\n[\"mathitsf\", \"textitsf\", \"SansSerif-Italic\"], // a-z italic sans-serif\n[\"\", \"\", \"\"], // A-Z bold italic sans. No font\n[\"\", \"\", \"\"], // a-z bold italic sans. No font\n[\"mathtt\", \"texttt\", \"Typewriter-Regular\"], // A-Z monospace\n[\"mathtt\", \"texttt\", \"Typewriter-Regular\"] // a-z monospace\n];\nvar wideNumeralData = [[\"mathbf\", \"textbf\", \"Main-Bold\"], // 0-9 bold\n[\"\", \"\", \"\"], // 0-9 double-struck. No KaTeX font.\n[\"mathsf\", \"textsf\", \"SansSerif-Regular\"], // 0-9 sans-serif\n[\"mathboldsf\", \"textboldsf\", \"SansSerif-Bold\"], // 0-9 bold sans-serif\n[\"mathtt\", \"texttt\", \"Typewriter-Regular\"] // 0-9 monospace\n];\nvar wideCharacterFont = function wideCharacterFont(wideChar, mode) {\n  // IE doesn't support codePointAt(). So work with the surrogate pair.\n  var H = wideChar.charCodeAt(0); // high surrogate\n\n  var L = wideChar.charCodeAt(1); // low surrogate\n\n  var codePoint = (H - 0xD800) * 0x400 + (L - 0xDC00) + 0x10000;\n  var j = mode === \"math\" ? 0 : 1; // column index for CSS class.\n\n  if (0x1D400 <= codePoint && codePoint < 0x1D6A4) {\n    // wideLatinLetterData contains exactly 26 chars on each row.\n    // So we can calculate the relevant row. No traverse necessary.\n    var i = Math.floor((codePoint - 0x1D400) / 26);\n    return [wideLatinLetterData[i][2], wideLatinLetterData[i][j]];\n  } else if (0x1D7CE <= codePoint && codePoint <= 0x1D7FF) {\n    // Numerals, ten per row.\n    var _i = Math.floor((codePoint - 0x1D7CE) / 10);\n\n    return [wideNumeralData[_i][2], wideNumeralData[_i][j]];\n  } else if (codePoint === 0x1D6A5 || codePoint === 0x1D6A6) {\n    // dotless i or j\n    return [wideLatinLetterData[0][2], wideLatinLetterData[0][j]];\n  } else if (0x1D6A6 < codePoint && codePoint < 0x1D7CE) {\n    // Greek letters. Not supported, yet.\n    return [\"\", \"\"];\n  } else {\n    // We don't support any wide characters outside 1D400–1D7FF.\n    throw new ParseError(\"Unsupported character: \" + wideChar);\n  }\n};\n\n/* eslint no-console:0 */\n\n/**\n * Looks up the given symbol in fontMetrics, after applying any symbol\n * replacements defined in symbol.js\n */\nvar lookupSymbol = function lookupSymbol(value, // TODO(#963): Use a union type for this.\nfontName, mode) {\n  // Replace the value with its replaced value from symbol.js\n  if (symbols[mode][value] && symbols[mode][value].replace) {\n    value = symbols[mode][value].replace;\n  }\n\n  return {\n    value: value,\n    metrics: getCharacterMetrics(value, fontName, mode)\n  };\n};\n/**\n * Makes a symbolNode after translation via the list of symbols in symbols.js.\n * Correctly pulls out metrics for the character, and optionally takes a list of\n * classes to be attached to the node.\n *\n * TODO: make argument order closer to makeSpan\n * TODO: add a separate argument for math class (e.g. `mop`, `mbin`), which\n * should if present come first in `classes`.\n * TODO(#953): Make `options` mandatory and always pass it in.\n */\n\n\nvar makeSymbol = function makeSymbol(value, fontName, mode, options, classes) {\n  var lookup = lookupSymbol(value, fontName, mode);\n  var metrics = lookup.metrics;\n  value = lookup.value;\n  var symbolNode;\n\n  if (metrics) {\n    var italic = metrics.italic;\n\n    if (mode === \"text\" || options && options.font === \"mathit\") {\n      italic = 0;\n    }\n\n    symbolNode = new SymbolNode(value, metrics.height, metrics.depth, italic, metrics.skew, metrics.width, classes);\n  } else {\n    // TODO(emily): Figure out a good way to only print this in development\n    typeof console !== \"undefined\" && console.warn(\"No character metrics \" + (\"for '\" + value + \"' in style '\" + fontName + \"' and mode '\" + mode + \"'\"));\n    symbolNode = new SymbolNode(value, 0, 0, 0, 0, 0, classes);\n  }\n\n  if (options) {\n    symbolNode.maxFontSize = options.sizeMultiplier;\n\n    if (options.style.isTight()) {\n      symbolNode.classes.push(\"mtight\");\n    }\n\n    var color = options.getColor();\n\n    if (color) {\n      symbolNode.style.color = color;\n    }\n  }\n\n  return symbolNode;\n};\n/**\n * Makes a symbol in Main-Regular or AMS-Regular.\n * Used for rel, bin, open, close, inner, and punct.\n */\n\n\nvar mathsym = function mathsym(value, mode, options, classes) {\n  if (classes === void 0) {\n    classes = [];\n  }\n\n  // Decide what font to render the symbol in by its entry in the symbols\n  // table.\n  // Have a special case for when the value = \\ because the \\ is used as a\n  // textord in unsupported command errors but cannot be parsed as a regular\n  // text ordinal and is therefore not present as a symbol in the symbols\n  // table for text, as well as a special case for boldsymbol because it\n  // can be used for bold + and -\n  if (options.font === \"boldsymbol\" && lookupSymbol(value, \"Main-Bold\", mode).metrics) {\n    return makeSymbol(value, \"Main-Bold\", mode, options, classes.concat([\"mathbf\"]));\n  } else if (value === \"\\\\\" || symbols[mode][value].font === \"main\") {\n    return makeSymbol(value, \"Main-Regular\", mode, options, classes);\n  } else {\n    return makeSymbol(value, \"AMS-Regular\", mode, options, classes.concat([\"amsrm\"]));\n  }\n};\n/**\n * Determines which of the two font names (Main-Bold and Math-BoldItalic) and\n * corresponding style tags (mathbf or boldsymbol) to use for font \"boldsymbol\",\n * depending on the symbol.  Use this function instead of fontMap for font\n * \"boldsymbol\".\n */\n\n\nvar boldsymbol = function boldsymbol(value, mode, options, classes, type) {\n  if (type !== \"textord\" && lookupSymbol(value, \"Math-BoldItalic\", mode).metrics) {\n    return {\n      fontName: \"Math-BoldItalic\",\n      fontClass: \"boldsymbol\"\n    };\n  } else {\n    // Some glyphs do not exist in Math-BoldItalic so we need to use\n    // Main-Bold instead.\n    return {\n      fontName: \"Main-Bold\",\n      fontClass: \"mathbf\"\n    };\n  }\n};\n/**\n * Makes either a mathord or textord in the correct font and color.\n */\n\n\nvar makeOrd = function makeOrd(group, options, type) {\n  var mode = group.mode;\n  var text = group.text;\n  var classes = [\"mord\"]; // Math mode or Old font (i.e. \\rm)\n\n  var isFont = mode === \"math\" || mode === \"text\" && options.font;\n  var fontOrFamily = isFont ? options.font : options.fontFamily;\n  var wideFontName = \"\";\n  var wideFontClass = \"\";\n\n  if (text.charCodeAt(0) === 0xD835) {\n    [wideFontName, wideFontClass] = wideCharacterFont(text, mode);\n  }\n\n  if (wideFontName.length > 0) {\n    // surrogate pairs get special treatment\n    return makeSymbol(text, wideFontName, mode, options, classes.concat(wideFontClass));\n  } else if (fontOrFamily) {\n    var fontName;\n    var fontClasses;\n\n    if (fontOrFamily === \"boldsymbol\") {\n      var fontData = boldsymbol(text, mode, options, classes, type);\n      fontName = fontData.fontName;\n      fontClasses = [fontData.fontClass];\n    } else if (isFont) {\n      fontName = fontMap[fontOrFamily].fontName;\n      fontClasses = [fontOrFamily];\n    } else {\n      fontName = retrieveTextFontName(fontOrFamily, options.fontWeight, options.fontShape);\n      fontClasses = [fontOrFamily, options.fontWeight, options.fontShape];\n    }\n\n    if (lookupSymbol(text, fontName, mode).metrics) {\n      return makeSymbol(text, fontName, mode, options, classes.concat(fontClasses));\n    } else if (ligatures.hasOwnProperty(text) && fontName.slice(0, 10) === \"Typewriter\") {\n      // Deconstruct ligatures in monospace fonts (\\texttt, \\tt).\n      var parts = [];\n\n      for (var i = 0; i < text.length; i++) {\n        parts.push(makeSymbol(text[i], fontName, mode, options, classes.concat(fontClasses)));\n      }\n\n      return makeFragment(parts);\n    }\n  } // Makes a symbol in the default font for mathords and textords.\n\n\n  if (type === \"mathord\") {\n    return makeSymbol(text, \"Math-Italic\", mode, options, classes.concat([\"mathnormal\"]));\n  } else if (type === \"textord\") {\n    var font = symbols[mode][text] && symbols[mode][text].font;\n\n    if (font === \"ams\") {\n      var _fontName = retrieveTextFontName(\"amsrm\", options.fontWeight, options.fontShape);\n\n      return makeSymbol(text, _fontName, mode, options, classes.concat(\"amsrm\", options.fontWeight, options.fontShape));\n    } else if (font === \"main\" || !font) {\n      var _fontName2 = retrieveTextFontName(\"textrm\", options.fontWeight, options.fontShape);\n\n      return makeSymbol(text, _fontName2, mode, options, classes.concat(options.fontWeight, options.fontShape));\n    } else {\n      // fonts added by plugins\n      var _fontName3 = retrieveTextFontName(font, options.fontWeight, options.fontShape); // We add font name as a css class\n\n\n      return makeSymbol(text, _fontName3, mode, options, classes.concat(_fontName3, options.fontWeight, options.fontShape));\n    }\n  } else {\n    throw new Error(\"unexpected type: \" + type + \" in makeOrd\");\n  }\n};\n/**\n * Returns true if subsequent symbolNodes have the same classes, skew, maxFont,\n * and styles.\n */\n\n\nvar canCombine = (prev, next) => {\n  if (createClass(prev.classes) !== createClass(next.classes) || prev.skew !== next.skew || prev.maxFontSize !== next.maxFontSize) {\n    return false;\n  } // If prev and next both are just \"mbin\"s or \"mord\"s we don't combine them\n  // so that the proper spacing can be preserved.\n\n\n  if (prev.classes.length === 1) {\n    var cls = prev.classes[0];\n\n    if (cls === \"mbin\" || cls === \"mord\") {\n      return false;\n    }\n  }\n\n  for (var style in prev.style) {\n    if (prev.style.hasOwnProperty(style) && prev.style[style] !== next.style[style]) {\n      return false;\n    }\n  }\n\n  for (var _style in next.style) {\n    if (next.style.hasOwnProperty(_style) && prev.style[_style] !== next.style[_style]) {\n      return false;\n    }\n  }\n\n  return true;\n};\n/**\n * Combine consecutive domTree.symbolNodes into a single symbolNode.\n * Note: this function mutates the argument.\n */\n\n\nvar tryCombineChars = chars => {\n  for (var i = 0; i < chars.length - 1; i++) {\n    var prev = chars[i];\n    var next = chars[i + 1];\n\n    if (prev instanceof SymbolNode && next instanceof SymbolNode && canCombine(prev, next)) {\n      prev.text += next.text;\n      prev.height = Math.max(prev.height, next.height);\n      prev.depth = Math.max(prev.depth, next.depth); // Use the last character's italic correction since we use\n      // it to add padding to the right of the span created from\n      // the combined characters.\n\n      prev.italic = next.italic;\n      chars.splice(i + 1, 1);\n      i--;\n    }\n  }\n\n  return chars;\n};\n/**\n * Calculate the height, depth, and maxFontSize of an element based on its\n * children.\n */\n\n\nvar sizeElementFromChildren = function sizeElementFromChildren(elem) {\n  var height = 0;\n  var depth = 0;\n  var maxFontSize = 0;\n\n  for (var i = 0; i < elem.children.length; i++) {\n    var child = elem.children[i];\n\n    if (child.height > height) {\n      height = child.height;\n    }\n\n    if (child.depth > depth) {\n      depth = child.depth;\n    }\n\n    if (child.maxFontSize > maxFontSize) {\n      maxFontSize = child.maxFontSize;\n    }\n  }\n\n  elem.height = height;\n  elem.depth = depth;\n  elem.maxFontSize = maxFontSize;\n};\n/**\n * Makes a span with the given list of classes, list of children, and options.\n *\n * TODO(#953): Ensure that `options` is always provided (currently some call\n * sites don't pass it) and make the type below mandatory.\n * TODO: add a separate argument for math class (e.g. `mop`, `mbin`), which\n * should if present come first in `classes`.\n */\n\n\nvar makeSpan$2 = function makeSpan(classes, children, options, style) {\n  var span = new Span(classes, children, options, style);\n  sizeElementFromChildren(span);\n  return span;\n}; // SVG one is simpler -- doesn't require height, depth, max-font setting.\n// This is also a separate method for typesafety.\n\n\nvar makeSvgSpan = (classes, children, options, style) => new Span(classes, children, options, style);\n\nvar makeLineSpan = function makeLineSpan(className, options, thickness) {\n  var line = makeSpan$2([className], [], options);\n  line.height = Math.max(thickness || options.fontMetrics().defaultRuleThickness, options.minRuleThickness);\n  line.style.borderBottomWidth = makeEm(line.height);\n  line.maxFontSize = 1.0;\n  return line;\n};\n/**\n * Makes an anchor with the given href, list of classes, list of children,\n * and options.\n */\n\n\nvar makeAnchor = function makeAnchor(href, classes, children, options) {\n  var anchor = new Anchor(href, classes, children, options);\n  sizeElementFromChildren(anchor);\n  return anchor;\n};\n/**\n * Makes a document fragment with the given list of children.\n */\n\n\nvar makeFragment = function makeFragment(children) {\n  var fragment = new DocumentFragment(children);\n  sizeElementFromChildren(fragment);\n  return fragment;\n};\n/**\n * Wraps group in a span if it's a document fragment, allowing to apply classes\n * and styles\n */\n\n\nvar wrapFragment = function wrapFragment(group, options) {\n  if (group instanceof DocumentFragment) {\n    return makeSpan$2([], [group], options);\n  }\n\n  return group;\n}; // These are exact object types to catch typos in the names of the optional fields.\n\n\n// Computes the updated `children` list and the overall depth.\n//\n// This helper function for makeVList makes it easier to enforce type safety by\n// allowing early exits (returns) in the logic.\nvar getVListChildrenAndDepth = function getVListChildrenAndDepth(params) {\n  if (params.positionType === \"individualShift\") {\n    var oldChildren = params.children;\n    var children = [oldChildren[0]]; // Add in kerns to the list of params.children to get each element to be\n    // shifted to the correct specified shift\n\n    var _depth = -oldChildren[0].shift - oldChildren[0].elem.depth;\n\n    var currPos = _depth;\n\n    for (var i = 1; i < oldChildren.length; i++) {\n      var diff = -oldChildren[i].shift - currPos - oldChildren[i].elem.depth;\n      var size = diff - (oldChildren[i - 1].elem.height + oldChildren[i - 1].elem.depth);\n      currPos = currPos + diff;\n      children.push({\n        type: \"kern\",\n        size\n      });\n      children.push(oldChildren[i]);\n    }\n\n    return {\n      children,\n      depth: _depth\n    };\n  }\n\n  var depth;\n\n  if (params.positionType === \"top\") {\n    // We always start at the bottom, so calculate the bottom by adding up\n    // all the sizes\n    var bottom = params.positionData;\n\n    for (var _i = 0; _i < params.children.length; _i++) {\n      var child = params.children[_i];\n      bottom -= child.type === \"kern\" ? child.size : child.elem.height + child.elem.depth;\n    }\n\n    depth = bottom;\n  } else if (params.positionType === \"bottom\") {\n    depth = -params.positionData;\n  } else {\n    var firstChild = params.children[0];\n\n    if (firstChild.type !== \"elem\") {\n      throw new Error('First child must have type \"elem\".');\n    }\n\n    if (params.positionType === \"shift\") {\n      depth = -firstChild.elem.depth - params.positionData;\n    } else if (params.positionType === \"firstBaseline\") {\n      depth = -firstChild.elem.depth;\n    } else {\n      throw new Error(\"Invalid positionType \" + params.positionType + \".\");\n    }\n  }\n\n  return {\n    children: params.children,\n    depth\n  };\n};\n/**\n * Makes a vertical list by stacking elements and kerns on top of each other.\n * Allows for many different ways of specifying the positioning method.\n *\n * See VListParam documentation above.\n */\n\n\nvar makeVList = function makeVList(params, options) {\n  var {\n    children,\n    depth\n  } = getVListChildrenAndDepth(params); // Create a strut that is taller than any list item. The strut is added to\n  // each item, where it will determine the item's baseline. Since it has\n  // `overflow:hidden`, the strut's top edge will sit on the item's line box's\n  // top edge and the strut's bottom edge will sit on the item's baseline,\n  // with no additional line-height spacing. This allows the item baseline to\n  // be positioned precisely without worrying about font ascent and\n  // line-height.\n\n  var pstrutSize = 0;\n\n  for (var i = 0; i < children.length; i++) {\n    var child = children[i];\n\n    if (child.type === \"elem\") {\n      var elem = child.elem;\n      pstrutSize = Math.max(pstrutSize, elem.maxFontSize, elem.height);\n    }\n  }\n\n  pstrutSize += 2;\n  var pstrut = makeSpan$2([\"pstrut\"], []);\n  pstrut.style.height = makeEm(pstrutSize); // Create a new list of actual children at the correct offsets\n\n  var realChildren = [];\n  var minPos = depth;\n  var maxPos = depth;\n  var currPos = depth;\n\n  for (var _i2 = 0; _i2 < children.length; _i2++) {\n    var _child = children[_i2];\n\n    if (_child.type === \"kern\") {\n      currPos += _child.size;\n    } else {\n      var _elem = _child.elem;\n      var classes = _child.wrapperClasses || [];\n      var style = _child.wrapperStyle || {};\n      var childWrap = makeSpan$2(classes, [pstrut, _elem], undefined, style);\n      childWrap.style.top = makeEm(-pstrutSize - currPos - _elem.depth);\n\n      if (_child.marginLeft) {\n        childWrap.style.marginLeft = _child.marginLeft;\n      }\n\n      if (_child.marginRight) {\n        childWrap.style.marginRight = _child.marginRight;\n      }\n\n      realChildren.push(childWrap);\n      currPos += _elem.height + _elem.depth;\n    }\n\n    minPos = Math.min(minPos, currPos);\n    maxPos = Math.max(maxPos, currPos);\n  } // The vlist contents go in a table-cell with `vertical-align:bottom`.\n  // This cell's bottom edge will determine the containing table's baseline\n  // without overly expanding the containing line-box.\n\n\n  var vlist = makeSpan$2([\"vlist\"], realChildren);\n  vlist.style.height = makeEm(maxPos); // A second row is used if necessary to represent the vlist's depth.\n\n  var rows;\n\n  if (minPos < 0) {\n    // We will define depth in an empty span with display: table-cell.\n    // It should render with the height that we define. But Chrome, in\n    // contenteditable mode only, treats that span as if it contains some\n    // text content. And that min-height over-rides our desired height.\n    // So we put another empty span inside the depth strut span.\n    var emptySpan = makeSpan$2([], []);\n    var depthStrut = makeSpan$2([\"vlist\"], [emptySpan]);\n    depthStrut.style.height = makeEm(-minPos); // Safari wants the first row to have inline content; otherwise it\n    // puts the bottom of the *second* row on the baseline.\n\n    var topStrut = makeSpan$2([\"vlist-s\"], [new SymbolNode(\"\\u200b\")]);\n    rows = [makeSpan$2([\"vlist-r\"], [vlist, topStrut]), makeSpan$2([\"vlist-r\"], [depthStrut])];\n  } else {\n    rows = [makeSpan$2([\"vlist-r\"], [vlist])];\n  }\n\n  var vtable = makeSpan$2([\"vlist-t\"], rows);\n\n  if (rows.length === 2) {\n    vtable.classes.push(\"vlist-t2\");\n  }\n\n  vtable.height = maxPos;\n  vtable.depth = -minPos;\n  return vtable;\n}; // Glue is a concept from TeX which is a flexible space between elements in\n// either a vertical or horizontal list. In KaTeX, at least for now, it's\n// static space between elements in a horizontal layout.\n\n\nvar makeGlue = (measurement, options) => {\n  // Make an empty span for the space\n  var rule = makeSpan$2([\"mspace\"], [], options);\n  var size = calculateSize(measurement, options);\n  rule.style.marginRight = makeEm(size);\n  return rule;\n}; // Takes font options, and returns the appropriate fontLookup name\n\n\nvar retrieveTextFontName = function retrieveTextFontName(fontFamily, fontWeight, fontShape) {\n  var baseFontName = \"\";\n\n  switch (fontFamily) {\n    case \"amsrm\":\n      baseFontName = \"AMS\";\n      break;\n\n    case \"textrm\":\n      baseFontName = \"Main\";\n      break;\n\n    case \"textsf\":\n      baseFontName = \"SansSerif\";\n      break;\n\n    case \"texttt\":\n      baseFontName = \"Typewriter\";\n      break;\n\n    default:\n      baseFontName = fontFamily;\n    // use fonts added by a plugin\n  }\n\n  var fontStylesName;\n\n  if (fontWeight === \"textbf\" && fontShape === \"textit\") {\n    fontStylesName = \"BoldItalic\";\n  } else if (fontWeight === \"textbf\") {\n    fontStylesName = \"Bold\";\n  } else if (fontWeight === \"textit\") {\n    fontStylesName = \"Italic\";\n  } else {\n    fontStylesName = \"Regular\";\n  }\n\n  return baseFontName + \"-\" + fontStylesName;\n};\n/**\n * Maps TeX font commands to objects containing:\n * - variant: string used for \"mathvariant\" attribute in buildMathML.js\n * - fontName: the \"style\" parameter to fontMetrics.getCharacterMetrics\n */\n// A map between tex font commands an MathML mathvariant attribute values\n\n\nvar fontMap = {\n  // styles\n  \"mathbf\": {\n    variant: \"bold\",\n    fontName: \"Main-Bold\"\n  },\n  \"mathrm\": {\n    variant: \"normal\",\n    fontName: \"Main-Regular\"\n  },\n  \"textit\": {\n    variant: \"italic\",\n    fontName: \"Main-Italic\"\n  },\n  \"mathit\": {\n    variant: \"italic\",\n    fontName: \"Main-Italic\"\n  },\n  \"mathnormal\": {\n    variant: \"italic\",\n    fontName: \"Math-Italic\"\n  },\n  \"mathsfit\": {\n    variant: \"sans-serif-italic\",\n    fontName: \"SansSerif-Italic\"\n  },\n  // \"boldsymbol\" is missing because they require the use of multiple fonts:\n  // Math-BoldItalic and Main-Bold.  This is handled by a special case in\n  // makeOrd which ends up calling boldsymbol.\n  // families\n  \"mathbb\": {\n    variant: \"double-struck\",\n    fontName: \"AMS-Regular\"\n  },\n  \"mathcal\": {\n    variant: \"script\",\n    fontName: \"Caligraphic-Regular\"\n  },\n  \"mathfrak\": {\n    variant: \"fraktur\",\n    fontName: \"Fraktur-Regular\"\n  },\n  \"mathscr\": {\n    variant: \"script\",\n    fontName: \"Script-Regular\"\n  },\n  \"mathsf\": {\n    variant: \"sans-serif\",\n    fontName: \"SansSerif-Regular\"\n  },\n  \"mathtt\": {\n    variant: \"monospace\",\n    fontName: \"Typewriter-Regular\"\n  }\n};\nvar svgData = {\n  //   path, width, height\n  vec: [\"vec\", 0.471, 0.714],\n  // values from the font glyph\n  oiintSize1: [\"oiintSize1\", 0.957, 0.499],\n  // oval to overlay the integrand\n  oiintSize2: [\"oiintSize2\", 1.472, 0.659],\n  oiiintSize1: [\"oiiintSize1\", 1.304, 0.499],\n  oiiintSize2: [\"oiiintSize2\", 1.98, 0.659]\n};\n\nvar staticSvg = function staticSvg(value, options) {\n  // Create a span with inline SVG for the element.\n  var [pathName, width, height] = svgData[value];\n  var path = new PathNode(pathName);\n  var svgNode = new SvgNode([path], {\n    \"width\": makeEm(width),\n    \"height\": makeEm(height),\n    // Override CSS rule `.katex svg { width: 100% }`\n    \"style\": \"width:\" + makeEm(width),\n    \"viewBox\": \"0 0 \" + 1000 * width + \" \" + 1000 * height,\n    \"preserveAspectRatio\": \"xMinYMin\"\n  });\n  var span = makeSvgSpan([\"overlay\"], [svgNode], options);\n  span.height = height;\n  span.style.height = makeEm(height);\n  span.style.width = makeEm(width);\n  return span;\n};\n\nvar buildCommon = {\n  fontMap,\n  makeSymbol,\n  mathsym,\n  makeSpan: makeSpan$2,\n  makeSvgSpan,\n  makeLineSpan,\n  makeAnchor,\n  makeFragment,\n  wrapFragment,\n  makeVList,\n  makeOrd,\n  makeGlue,\n  staticSvg,\n  svgData,\n  tryCombineChars\n};\n\n/**\n * Describes spaces between different classes of atoms.\n */\nvar thinspace = {\n  number: 3,\n  unit: \"mu\"\n};\nvar mediumspace = {\n  number: 4,\n  unit: \"mu\"\n};\nvar thickspace = {\n  number: 5,\n  unit: \"mu\"\n}; // Making the type below exact with all optional fields doesn't work due to\n// - https://github.com/facebook/flow/issues/4582\n// - https://github.com/facebook/flow/issues/5688\n// However, since *all* fields are optional, $Shape<> works as suggested in 5688\n// above.\n\n// Spacing relationships for display and text styles\nvar spacings = {\n  mord: {\n    mop: thinspace,\n    mbin: mediumspace,\n    mrel: thickspace,\n    minner: thinspace\n  },\n  mop: {\n    mord: thinspace,\n    mop: thinspace,\n    mrel: thickspace,\n    minner: thinspace\n  },\n  mbin: {\n    mord: mediumspace,\n    mop: mediumspace,\n    mopen: mediumspace,\n    minner: mediumspace\n  },\n  mrel: {\n    mord: thickspace,\n    mop: thickspace,\n    mopen: thickspace,\n    minner: thickspace\n  },\n  mopen: {},\n  mclose: {\n    mop: thinspace,\n    mbin: mediumspace,\n    mrel: thickspace,\n    minner: thinspace\n  },\n  mpunct: {\n    mord: thinspace,\n    mop: thinspace,\n    mrel: thickspace,\n    mopen: thinspace,\n    mclose: thinspace,\n    mpunct: thinspace,\n    minner: thinspace\n  },\n  minner: {\n    mord: thinspace,\n    mop: thinspace,\n    mbin: mediumspace,\n    mrel: thickspace,\n    mopen: thinspace,\n    mpunct: thinspace,\n    minner: thinspace\n  }\n}; // Spacing relationships for script and scriptscript styles\n\nvar tightSpacings = {\n  mord: {\n    mop: thinspace\n  },\n  mop: {\n    mord: thinspace,\n    mop: thinspace\n  },\n  mbin: {},\n  mrel: {},\n  mopen: {},\n  mclose: {\n    mop: thinspace\n  },\n  mpunct: {},\n  minner: {\n    mop: thinspace\n  }\n};\n\n/** Context provided to function handlers for error messages. */\n// Note: reverse the order of the return type union will cause a flow error.\n// See https://github.com/facebook/flow/issues/3663.\n// More general version of `HtmlBuilder` for nodes (e.g. \\sum, accent types)\n// whose presence impacts super/subscripting. In this case, ParseNode<\"supsub\">\n// delegates its HTML building to the HtmlBuilder corresponding to these nodes.\n\n/**\n * Final function spec for use at parse time.\n * This is almost identical to `FunctionPropSpec`, except it\n * 1. includes the function handler, and\n * 2. requires all arguments except argTypes.\n * It is generated by `defineFunction()` below.\n */\n\n/**\n * All registered functions.\n * `functions.js` just exports this same dictionary again and makes it public.\n * `Parser.js` requires this dictionary.\n */\nvar _functions = {};\n/**\n * All HTML builders. Should be only used in the `define*` and the `build*ML`\n * functions.\n */\n\nvar _htmlGroupBuilders = {};\n/**\n * All MathML builders. Should be only used in the `define*` and the `build*ML`\n * functions.\n */\n\nvar _mathmlGroupBuilders = {};\nfunction defineFunction(_ref) {\n  var {\n    type,\n    names,\n    props,\n    handler,\n    htmlBuilder,\n    mathmlBuilder\n  } = _ref;\n  // Set default values of functions\n  var data = {\n    type,\n    numArgs: props.numArgs,\n    argTypes: props.argTypes,\n    allowedInArgument: !!props.allowedInArgument,\n    allowedInText: !!props.allowedInText,\n    allowedInMath: props.allowedInMath === undefined ? true : props.allowedInMath,\n    numOptionalArgs: props.numOptionalArgs || 0,\n    infix: !!props.infix,\n    primitive: !!props.primitive,\n    handler: handler\n  };\n\n  for (var i = 0; i < names.length; ++i) {\n    _functions[names[i]] = data;\n  }\n\n  if (type) {\n    if (htmlBuilder) {\n      _htmlGroupBuilders[type] = htmlBuilder;\n    }\n\n    if (mathmlBuilder) {\n      _mathmlGroupBuilders[type] = mathmlBuilder;\n    }\n  }\n}\n/**\n * Use this to register only the HTML and MathML builders for a function (e.g.\n * if the function's ParseNode is generated in Parser.js rather than via a\n * stand-alone handler provided to `defineFunction`).\n */\n\nfunction defineFunctionBuilders(_ref2) {\n  var {\n    type,\n    htmlBuilder,\n    mathmlBuilder\n  } = _ref2;\n  defineFunction({\n    type,\n    names: [],\n    props: {\n      numArgs: 0\n    },\n\n    handler() {\n      throw new Error('Should never be called.');\n    },\n\n    htmlBuilder,\n    mathmlBuilder\n  });\n}\nvar normalizeArgument = function normalizeArgument(arg) {\n  return arg.type === \"ordgroup\" && arg.body.length === 1 ? arg.body[0] : arg;\n}; // Since the corresponding buildHTML/buildMathML function expects a\n// list of elements, we normalize for different kinds of arguments\n\nvar ordargument = function ordargument(arg) {\n  return arg.type === \"ordgroup\" ? arg.body : [arg];\n};\n\n/**\n * This file does the main work of building a domTree structure from a parse\n * tree. The entry point is the `buildHTML` function, which takes a parse tree.\n * Then, the buildExpression, buildGroup, and various groupBuilders functions\n * are called, to produce a final HTML tree.\n */\nvar makeSpan$1 = buildCommon.makeSpan; // Binary atoms (first class `mbin`) change into ordinary atoms (`mord`)\n// depending on their surroundings. See TeXbook pg. 442-446, Rules 5 and 6,\n// and the text before Rule 19.\n\nvar binLeftCanceller = [\"leftmost\", \"mbin\", \"mopen\", \"mrel\", \"mop\", \"mpunct\"];\nvar binRightCanceller = [\"rightmost\", \"mrel\", \"mclose\", \"mpunct\"];\nvar styleMap$1 = {\n  \"display\": Style$1.DISPLAY,\n  \"text\": Style$1.TEXT,\n  \"script\": Style$1.SCRIPT,\n  \"scriptscript\": Style$1.SCRIPTSCRIPT\n};\nvar DomEnum = {\n  mord: \"mord\",\n  mop: \"mop\",\n  mbin: \"mbin\",\n  mrel: \"mrel\",\n  mopen: \"mopen\",\n  mclose: \"mclose\",\n  mpunct: \"mpunct\",\n  minner: \"minner\"\n};\n\n/**\n * Take a list of nodes, build them in order, and return a list of the built\n * nodes. documentFragments are flattened into their contents, so the\n * returned list contains no fragments. `isRealGroup` is true if `expression`\n * is a real group (no atoms will be added on either side), as opposed to\n * a partial group (e.g. one created by \\color). `surrounding` is an array\n * consisting type of nodes that will be added to the left and right.\n */\nvar buildExpression$1 = function buildExpression(expression, options, isRealGroup, surrounding) {\n  if (surrounding === void 0) {\n    surrounding = [null, null];\n  }\n\n  // Parse expressions into `groups`.\n  var groups = [];\n\n  for (var i = 0; i < expression.length; i++) {\n    var output = buildGroup$1(expression[i], options);\n\n    if (output instanceof DocumentFragment) {\n      var children = output.children;\n      groups.push(...children);\n    } else {\n      groups.push(output);\n    }\n  } // Combine consecutive domTree.symbolNodes into a single symbolNode.\n\n\n  buildCommon.tryCombineChars(groups); // If `expression` is a partial group, let the parent handle spacings\n  // to avoid processing groups multiple times.\n\n  if (!isRealGroup) {\n    return groups;\n  }\n\n  var glueOptions = options;\n\n  if (expression.length === 1) {\n    var node = expression[0];\n\n    if (node.type === \"sizing\") {\n      glueOptions = options.havingSize(node.size);\n    } else if (node.type === \"styling\") {\n      glueOptions = options.havingStyle(styleMap$1[node.style]);\n    }\n  } // Dummy spans for determining spacings between surrounding atoms.\n  // If `expression` has no atoms on the left or right, class \"leftmost\"\n  // or \"rightmost\", respectively, is used to indicate it.\n\n\n  var dummyPrev = makeSpan$1([surrounding[0] || \"leftmost\"], [], options);\n  var dummyNext = makeSpan$1([surrounding[1] || \"rightmost\"], [], options); // TODO: These code assumes that a node's math class is the first element\n  // of its `classes` array. A later cleanup should ensure this, for\n  // instance by changing the signature of `makeSpan`.\n  // Before determining what spaces to insert, perform bin cancellation.\n  // Binary operators change to ordinary symbols in some contexts.\n\n  var isRoot = isRealGroup === \"root\";\n  traverseNonSpaceNodes(groups, (node, prev) => {\n    var prevType = prev.classes[0];\n    var type = node.classes[0];\n\n    if (prevType === \"mbin\" && utils.contains(binRightCanceller, type)) {\n      prev.classes[0] = \"mord\";\n    } else if (type === \"mbin\" && utils.contains(binLeftCanceller, prevType)) {\n      node.classes[0] = \"mord\";\n    }\n  }, {\n    node: dummyPrev\n  }, dummyNext, isRoot);\n  traverseNonSpaceNodes(groups, (node, prev) => {\n    var prevType = getTypeOfDomTree(prev);\n    var type = getTypeOfDomTree(node); // 'mtight' indicates that the node is script or scriptscript style.\n\n    var space = prevType && type ? node.hasClass(\"mtight\") ? tightSpacings[prevType][type] : spacings[prevType][type] : null;\n\n    if (space) {\n      // Insert glue (spacing) after the `prev`.\n      return buildCommon.makeGlue(space, glueOptions);\n    }\n  }, {\n    node: dummyPrev\n  }, dummyNext, isRoot);\n  return groups;\n}; // Depth-first traverse non-space `nodes`, calling `callback` with the current and\n// previous node as arguments, optionally returning a node to insert after the\n// previous node. `prev` is an object with the previous node and `insertAfter`\n// function to insert after it. `next` is a node that will be added to the right.\n// Used for bin cancellation and inserting spacings.\n\nvar traverseNonSpaceNodes = function traverseNonSpaceNodes(nodes, callback, prev, next, isRoot) {\n  if (next) {\n    // temporarily append the right node, if exists\n    nodes.push(next);\n  }\n\n  var i = 0;\n\n  for (; i < nodes.length; i++) {\n    var node = nodes[i];\n    var partialGroup = checkPartialGroup(node);\n\n    if (partialGroup) {\n      // Recursive DFS\n      // $FlowFixMe: make nodes a $ReadOnlyArray by returning a new array\n      traverseNonSpaceNodes(partialGroup.children, callback, prev, null, isRoot);\n      continue;\n    } // Ignore explicit spaces (e.g., \\;, \\,) when determining what implicit\n    // spacing should go between atoms of different classes\n\n\n    var nonspace = !node.hasClass(\"mspace\");\n\n    if (nonspace) {\n      var result = callback(node, prev.node);\n\n      if (result) {\n        if (prev.insertAfter) {\n          prev.insertAfter(result);\n        } else {\n          // insert at front\n          nodes.unshift(result);\n          i++;\n        }\n      }\n    }\n\n    if (nonspace) {\n      prev.node = node;\n    } else if (isRoot && node.hasClass(\"newline\")) {\n      prev.node = makeSpan$1([\"leftmost\"]); // treat like beginning of line\n    }\n\n    prev.insertAfter = (index => n => {\n      nodes.splice(index + 1, 0, n);\n      i++;\n    })(i);\n  }\n\n  if (next) {\n    nodes.pop();\n  }\n}; // Check if given node is a partial group, i.e., does not affect spacing around.\n\n\nvar checkPartialGroup = function checkPartialGroup(node) {\n  if (node instanceof DocumentFragment || node instanceof Anchor || node instanceof Span && node.hasClass(\"enclosing\")) {\n    return node;\n  }\n\n  return null;\n}; // Return the outermost node of a domTree.\n\n\nvar getOutermostNode = function getOutermostNode(node, side) {\n  var partialGroup = checkPartialGroup(node);\n\n  if (partialGroup) {\n    var children = partialGroup.children;\n\n    if (children.length) {\n      if (side === \"right\") {\n        return getOutermostNode(children[children.length - 1], \"right\");\n      } else if (side === \"left\") {\n        return getOutermostNode(children[0], \"left\");\n      }\n    }\n  }\n\n  return node;\n}; // Return math atom class (mclass) of a domTree.\n// If `side` is given, it will get the type of the outermost node at given side.\n\n\nvar getTypeOfDomTree = function getTypeOfDomTree(node, side) {\n  if (!node) {\n    return null;\n  }\n\n  if (side) {\n    node = getOutermostNode(node, side);\n  } // This makes a lot of assumptions as to where the type of atom\n  // appears.  We should do a better job of enforcing this.\n\n\n  return DomEnum[node.classes[0]] || null;\n};\nvar makeNullDelimiter = function makeNullDelimiter(options, classes) {\n  var moreClasses = [\"nulldelimiter\"].concat(options.baseSizingClasses());\n  return makeSpan$1(classes.concat(moreClasses));\n};\n/**\n * buildGroup is the function that takes a group and calls the correct groupType\n * function for it. It also handles the interaction of size and style changes\n * between parents and children.\n */\n\nvar buildGroup$1 = function buildGroup(group, options, baseOptions) {\n  if (!group) {\n    return makeSpan$1();\n  }\n\n  if (_htmlGroupBuilders[group.type]) {\n    // Call the groupBuilders function\n    // $FlowFixMe\n    var groupNode = _htmlGroupBuilders[group.type](group, options); // If the size changed between the parent and the current group, account\n    // for that size difference.\n\n    if (baseOptions && options.size !== baseOptions.size) {\n      groupNode = makeSpan$1(options.sizingClasses(baseOptions), [groupNode], options);\n      var multiplier = options.sizeMultiplier / baseOptions.sizeMultiplier;\n      groupNode.height *= multiplier;\n      groupNode.depth *= multiplier;\n    }\n\n    return groupNode;\n  } else {\n    throw new ParseError(\"Got group of unknown type: '\" + group.type + \"'\");\n  }\n};\n/**\n * Combine an array of HTML DOM nodes (e.g., the output of `buildExpression`)\n * into an unbreakable HTML node of class .base, with proper struts to\n * guarantee correct vertical extent.  `buildHTML` calls this repeatedly to\n * make up the entire expression as a sequence of unbreakable units.\n */\n\nfunction buildHTMLUnbreakable(children, options) {\n  // Compute height and depth of this chunk.\n  var body = makeSpan$1([\"base\"], children, options); // Add strut, which ensures that the top of the HTML element falls at\n  // the height of the expression, and the bottom of the HTML element\n  // falls at the depth of the expression.\n\n  var strut = makeSpan$1([\"strut\"]);\n  strut.style.height = makeEm(body.height + body.depth);\n\n  if (body.depth) {\n    strut.style.verticalAlign = makeEm(-body.depth);\n  }\n\n  body.children.unshift(strut);\n  return body;\n}\n/**\n * Take an entire parse tree, and build it into an appropriate set of HTML\n * nodes.\n */\n\n\nfunction buildHTML(tree, options) {\n  // Strip off outer tag wrapper for processing below.\n  var tag = null;\n\n  if (tree.length === 1 && tree[0].type === \"tag\") {\n    tag = tree[0].tag;\n    tree = tree[0].body;\n  } // Build the expression contained in the tree\n\n\n  var expression = buildExpression$1(tree, options, \"root\");\n  var eqnNum;\n\n  if (expression.length === 2 && expression[1].hasClass(\"tag\")) {\n    // An environment with automatic equation numbers, e.g. {gather}.\n    eqnNum = expression.pop();\n  }\n\n  var children = []; // Create one base node for each chunk between potential line breaks.\n  // The TeXBook [p.173] says \"A formula will be broken only after a\n  // relation symbol like $=$ or $<$ or $\\rightarrow$, or after a binary\n  // operation symbol like $+$ or $-$ or $\\times$, where the relation or\n  // binary operation is on the ``outer level'' of the formula (i.e., not\n  // enclosed in {...} and not part of an \\over construction).\"\n\n  var parts = [];\n\n  for (var i = 0; i < expression.length; i++) {\n    parts.push(expression[i]);\n\n    if (expression[i].hasClass(\"mbin\") || expression[i].hasClass(\"mrel\") || expression[i].hasClass(\"allowbreak\")) {\n      // Put any post-operator glue on same line as operator.\n      // Watch for \\nobreak along the way, and stop at \\newline.\n      var nobreak = false;\n\n      while (i < expression.length - 1 && expression[i + 1].hasClass(\"mspace\") && !expression[i + 1].hasClass(\"newline\")) {\n        i++;\n        parts.push(expression[i]);\n\n        if (expression[i].hasClass(\"nobreak\")) {\n          nobreak = true;\n        }\n      } // Don't allow break if \\nobreak among the post-operator glue.\n\n\n      if (!nobreak) {\n        children.push(buildHTMLUnbreakable(parts, options));\n        parts = [];\n      }\n    } else if (expression[i].hasClass(\"newline\")) {\n      // Write the line except the newline\n      parts.pop();\n\n      if (parts.length > 0) {\n        children.push(buildHTMLUnbreakable(parts, options));\n        parts = [];\n      } // Put the newline at the top level\n\n\n      children.push(expression[i]);\n    }\n  }\n\n  if (parts.length > 0) {\n    children.push(buildHTMLUnbreakable(parts, options));\n  } // Now, if there was a tag, build it too and append it as a final child.\n\n\n  var tagChild;\n\n  if (tag) {\n    tagChild = buildHTMLUnbreakable(buildExpression$1(tag, options, true));\n    tagChild.classes = [\"tag\"];\n    children.push(tagChild);\n  } else if (eqnNum) {\n    children.push(eqnNum);\n  }\n\n  var htmlNode = makeSpan$1([\"katex-html\"], children);\n  htmlNode.setAttribute(\"aria-hidden\", \"true\"); // Adjust the strut of the tag to be the maximum height of all children\n  // (the height of the enclosing htmlNode) for proper vertical alignment.\n\n  if (tagChild) {\n    var strut = tagChild.children[0];\n    strut.style.height = makeEm(htmlNode.height + htmlNode.depth);\n\n    if (htmlNode.depth) {\n      strut.style.verticalAlign = makeEm(-htmlNode.depth);\n    }\n  }\n\n  return htmlNode;\n}\n\n/**\n * These objects store data about MathML nodes. This is the MathML equivalent\n * of the types in domTree.js. Since MathML handles its own rendering, and\n * since we're mainly using MathML to improve accessibility, we don't manage\n * any of the styling state that the plain DOM nodes do.\n *\n * The `toNode` and `toMarkup` functions work similarly to how they do in\n * domTree.js, creating namespaced DOM nodes and HTML text markup respectively.\n */\nfunction newDocumentFragment(children) {\n  return new DocumentFragment(children);\n}\n/**\n * This node represents a general purpose MathML node of any type. The\n * constructor requires the type of node to create (for example, `\"mo\"` or\n * `\"mspace\"`, corresponding to `<mo>` and `<mspace>` tags).\n */\n\nclass MathNode {\n  constructor(type, children, classes) {\n    this.type = void 0;\n    this.attributes = void 0;\n    this.children = void 0;\n    this.classes = void 0;\n    this.type = type;\n    this.attributes = {};\n    this.children = children || [];\n    this.classes = classes || [];\n  }\n  /**\n   * Sets an attribute on a MathML node. MathML depends on attributes to convey a\n   * semantic content, so this is used heavily.\n   */\n\n\n  setAttribute(name, value) {\n    this.attributes[name] = value;\n  }\n  /**\n   * Gets an attribute on a MathML node.\n   */\n\n\n  getAttribute(name) {\n    return this.attributes[name];\n  }\n  /**\n   * Converts the math node into a MathML-namespaced DOM element.\n   */\n\n\n  toNode() {\n    var node = document.createElementNS(\"http://www.w3.org/1998/Math/MathML\", this.type);\n\n    for (var attr in this.attributes) {\n      if (Object.prototype.hasOwnProperty.call(this.attributes, attr)) {\n        node.setAttribute(attr, this.attributes[attr]);\n      }\n    }\n\n    if (this.classes.length > 0) {\n      node.className = createClass(this.classes);\n    }\n\n    for (var i = 0; i < this.children.length; i++) {\n      // Combine multiple TextNodes into one TextNode, to prevent\n      // screen readers from reading each as a separate word [#3995]\n      if (this.children[i] instanceof TextNode && this.children[i + 1] instanceof TextNode) {\n        var text = this.children[i].toText() + this.children[++i].toText();\n\n        while (this.children[i + 1] instanceof TextNode) {\n          text += this.children[++i].toText();\n        }\n\n        node.appendChild(new TextNode(text).toNode());\n      } else {\n        node.appendChild(this.children[i].toNode());\n      }\n    }\n\n    return node;\n  }\n  /**\n   * Converts the math node into an HTML markup string.\n   */\n\n\n  toMarkup() {\n    var markup = \"<\" + this.type; // Add the attributes\n\n    for (var attr in this.attributes) {\n      if (Object.prototype.hasOwnProperty.call(this.attributes, attr)) {\n        markup += \" \" + attr + \"=\\\"\";\n        markup += utils.escape(this.attributes[attr]);\n        markup += \"\\\"\";\n      }\n    }\n\n    if (this.classes.length > 0) {\n      markup += \" class =\\\"\" + utils.escape(createClass(this.classes)) + \"\\\"\";\n    }\n\n    markup += \">\";\n\n    for (var i = 0; i < this.children.length; i++) {\n      markup += this.children[i].toMarkup();\n    }\n\n    markup += \"</\" + this.type + \">\";\n    return markup;\n  }\n  /**\n   * Converts the math node into a string, similar to innerText, but escaped.\n   */\n\n\n  toText() {\n    return this.children.map(child => child.toText()).join(\"\");\n  }\n\n}\n/**\n * This node represents a piece of text.\n */\n\nclass TextNode {\n  constructor(text) {\n    this.text = void 0;\n    this.text = text;\n  }\n  /**\n   * Converts the text node into a DOM text node.\n   */\n\n\n  toNode() {\n    return document.createTextNode(this.text);\n  }\n  /**\n   * Converts the text node into escaped HTML markup\n   * (representing the text itself).\n   */\n\n\n  toMarkup() {\n    return utils.escape(this.toText());\n  }\n  /**\n   * Converts the text node into a string\n   * (representing the text itself).\n   */\n\n\n  toText() {\n    return this.text;\n  }\n\n}\n/**\n * This node represents a space, but may render as <mspace.../> or as text,\n * depending on the width.\n */\n\nclass SpaceNode {\n  /**\n   * Create a Space node with width given in CSS ems.\n   */\n  constructor(width) {\n    this.width = void 0;\n    this.character = void 0;\n    this.width = width; // See https://www.w3.org/TR/2000/WD-MathML2-20000328/chapter6.html\n    // for a table of space-like characters.  We use Unicode\n    // representations instead of &LongNames; as it's not clear how to\n    // make the latter via document.createTextNode.\n\n    if (width >= 0.05555 && width <= 0.05556) {\n      this.character = \"\\u200a\"; // &VeryThinSpace;\n    } else if (width >= 0.1666 && width <= 0.1667) {\n      this.character = \"\\u2009\"; // &ThinSpace;\n    } else if (width >= 0.2222 && width <= 0.2223) {\n      this.character = \"\\u2005\"; // &MediumSpace;\n    } else if (width >= 0.2777 && width <= 0.2778) {\n      this.character = \"\\u2005\\u200a\"; // &ThickSpace;\n    } else if (width >= -0.05556 && width <= -0.05555) {\n      this.character = \"\\u200a\\u2063\"; // &NegativeVeryThinSpace;\n    } else if (width >= -0.1667 && width <= -0.1666) {\n      this.character = \"\\u2009\\u2063\"; // &NegativeThinSpace;\n    } else if (width >= -0.2223 && width <= -0.2222) {\n      this.character = \"\\u205f\\u2063\"; // &NegativeMediumSpace;\n    } else if (width >= -0.2778 && width <= -0.2777) {\n      this.character = \"\\u2005\\u2063\"; // &NegativeThickSpace;\n    } else {\n      this.character = null;\n    }\n  }\n  /**\n   * Converts the math node into a MathML-namespaced DOM element.\n   */\n\n\n  toNode() {\n    if (this.character) {\n      return document.createTextNode(this.character);\n    } else {\n      var node = document.createElementNS(\"http://www.w3.org/1998/Math/MathML\", \"mspace\");\n      node.setAttribute(\"width\", makeEm(this.width));\n      return node;\n    }\n  }\n  /**\n   * Converts the math node into an HTML markup string.\n   */\n\n\n  toMarkup() {\n    if (this.character) {\n      return \"<mtext>\" + this.character + \"</mtext>\";\n    } else {\n      return \"<mspace width=\\\"\" + makeEm(this.width) + \"\\\"/>\";\n    }\n  }\n  /**\n   * Converts the math node into a string, similar to innerText.\n   */\n\n\n  toText() {\n    if (this.character) {\n      return this.character;\n    } else {\n      return \" \";\n    }\n  }\n\n}\n\nvar mathMLTree = {\n  MathNode,\n  TextNode,\n  SpaceNode,\n  newDocumentFragment\n};\n\n/**\n * This file converts a parse tree into a corresponding MathML tree. The main\n * entry point is the `buildMathML` function, which takes a parse tree from the\n * parser.\n */\n\n/**\n * Takes a symbol and converts it into a MathML text node after performing\n * optional replacement from symbols.js.\n */\nvar makeText = function makeText(text, mode, options) {\n  if (symbols[mode][text] && symbols[mode][text].replace && text.charCodeAt(0) !== 0xD835 && !(ligatures.hasOwnProperty(text) && options && (options.fontFamily && options.fontFamily.slice(4, 6) === \"tt\" || options.font && options.font.slice(4, 6) === \"tt\"))) {\n    text = symbols[mode][text].replace;\n  }\n\n  return new mathMLTree.TextNode(text);\n};\n/**\n * Wrap the given array of nodes in an <mrow> node if needed, i.e.,\n * unless the array has length 1.  Always returns a single node.\n */\n\nvar makeRow = function makeRow(body) {\n  if (body.length === 1) {\n    return body[0];\n  } else {\n    return new mathMLTree.MathNode(\"mrow\", body);\n  }\n};\n/**\n * Returns the math variant as a string or null if none is required.\n */\n\nvar getVariant = function getVariant(group, options) {\n  // Handle \\text... font specifiers as best we can.\n  // MathML has a limited list of allowable mathvariant specifiers; see\n  // https://www.w3.org/TR/MathML3/chapter3.html#presm.commatt\n  if (options.fontFamily === \"texttt\") {\n    return \"monospace\";\n  } else if (options.fontFamily === \"textsf\") {\n    if (options.fontShape === \"textit\" && options.fontWeight === \"textbf\") {\n      return \"sans-serif-bold-italic\";\n    } else if (options.fontShape === \"textit\") {\n      return \"sans-serif-italic\";\n    } else if (options.fontWeight === \"textbf\") {\n      return \"bold-sans-serif\";\n    } else {\n      return \"sans-serif\";\n    }\n  } else if (options.fontShape === \"textit\" && options.fontWeight === \"textbf\") {\n    return \"bold-italic\";\n  } else if (options.fontShape === \"textit\") {\n    return \"italic\";\n  } else if (options.fontWeight === \"textbf\") {\n    return \"bold\";\n  }\n\n  var font = options.font;\n\n  if (!font || font === \"mathnormal\") {\n    return null;\n  }\n\n  var mode = group.mode;\n\n  if (font === \"mathit\") {\n    return \"italic\";\n  } else if (font === \"boldsymbol\") {\n    return group.type === \"textord\" ? \"bold\" : \"bold-italic\";\n  } else if (font === \"mathbf\") {\n    return \"bold\";\n  } else if (font === \"mathbb\") {\n    return \"double-struck\";\n  } else if (font === \"mathsfit\") {\n    return \"sans-serif-italic\";\n  } else if (font === \"mathfrak\") {\n    return \"fraktur\";\n  } else if (font === \"mathscr\" || font === \"mathcal\") {\n    // MathML makes no distinction between script and calligraphic\n    return \"script\";\n  } else if (font === \"mathsf\") {\n    return \"sans-serif\";\n  } else if (font === \"mathtt\") {\n    return \"monospace\";\n  }\n\n  var text = group.text;\n\n  if (utils.contains([\"\\\\imath\", \"\\\\jmath\"], text)) {\n    return null;\n  }\n\n  if (symbols[mode][text] && symbols[mode][text].replace) {\n    text = symbols[mode][text].replace;\n  }\n\n  var fontName = buildCommon.fontMap[font].fontName;\n\n  if (getCharacterMetrics(text, fontName, mode)) {\n    return buildCommon.fontMap[font].variant;\n  }\n\n  return null;\n};\n/**\n * Check for <mi>.</mi> which is how a dot renders in MathML,\n * or <mo separator=\"true\" lspace=\"0em\" rspace=\"0em\">,</mo>\n * which is how a braced comma {,} renders in MathML\n */\n\nfunction isNumberPunctuation(group) {\n  if (!group) {\n    return false;\n  }\n\n  if (group.type === 'mi' && group.children.length === 1) {\n    var child = group.children[0];\n    return child instanceof TextNode && child.text === '.';\n  } else if (group.type === 'mo' && group.children.length === 1 && group.getAttribute('separator') === 'true' && group.getAttribute('lspace') === '0em' && group.getAttribute('rspace') === '0em') {\n    var _child = group.children[0];\n    return _child instanceof TextNode && _child.text === ',';\n  } else {\n    return false;\n  }\n}\n/**\n * Takes a list of nodes, builds them, and returns a list of the generated\n * MathML nodes.  Also combine consecutive <mtext> outputs into a single\n * <mtext> tag.\n */\n\n\nvar buildExpression = function buildExpression(expression, options, isOrdgroup) {\n  if (expression.length === 1) {\n    var group = buildGroup(expression[0], options);\n\n    if (isOrdgroup && group instanceof MathNode && group.type === \"mo\") {\n      // When TeX writers want to suppress spacing on an operator,\n      // they often put the operator by itself inside braces.\n      group.setAttribute(\"lspace\", \"0em\");\n      group.setAttribute(\"rspace\", \"0em\");\n    }\n\n    return [group];\n  }\n\n  var groups = [];\n  var lastGroup;\n\n  for (var i = 0; i < expression.length; i++) {\n    var _group = buildGroup(expression[i], options);\n\n    if (_group instanceof MathNode && lastGroup instanceof MathNode) {\n      // Concatenate adjacent <mtext>s\n      if (_group.type === 'mtext' && lastGroup.type === 'mtext' && _group.getAttribute('mathvariant') === lastGroup.getAttribute('mathvariant')) {\n        lastGroup.children.push(..._group.children);\n        continue; // Concatenate adjacent <mn>s\n      } else if (_group.type === 'mn' && lastGroup.type === 'mn') {\n        lastGroup.children.push(..._group.children);\n        continue; // Concatenate <mn>...</mn> followed by <mi>.</mi>\n      } else if (isNumberPunctuation(_group) && lastGroup.type === 'mn') {\n        lastGroup.children.push(..._group.children);\n        continue; // Concatenate <mi>.</mi> followed by <mn>...</mn>\n      } else if (_group.type === 'mn' && isNumberPunctuation(lastGroup)) {\n        _group.children = [...lastGroup.children, ..._group.children];\n        groups.pop(); // Put preceding <mn>...</mn> or <mi>.</mi> inside base of\n        // <msup><mn>...base...</mn>...exponent...</msup> (or <msub>)\n      } else if ((_group.type === 'msup' || _group.type === 'msub') && _group.children.length >= 1 && (lastGroup.type === 'mn' || isNumberPunctuation(lastGroup))) {\n        var base = _group.children[0];\n\n        if (base instanceof MathNode && base.type === 'mn') {\n          base.children = [...lastGroup.children, ...base.children];\n          groups.pop();\n        } // \\not\n\n      } else if (lastGroup.type === 'mi' && lastGroup.children.length === 1) {\n        var lastChild = lastGroup.children[0];\n\n        if (lastChild instanceof TextNode && lastChild.text === '\\u0338' && (_group.type === 'mo' || _group.type === 'mi' || _group.type === 'mn')) {\n          var child = _group.children[0];\n\n          if (child instanceof TextNode && child.text.length > 0) {\n            // Overlay with combining character long solidus\n            child.text = child.text.slice(0, 1) + \"\\u0338\" + child.text.slice(1);\n            groups.pop();\n          }\n        }\n      }\n    }\n\n    groups.push(_group);\n    lastGroup = _group;\n  }\n\n  return groups;\n};\n/**\n * Equivalent to buildExpression, but wraps the elements in an <mrow>\n * if there's more than one.  Returns a single node instead of an array.\n */\n\nvar buildExpressionRow = function buildExpressionRow(expression, options, isOrdgroup) {\n  return makeRow(buildExpression(expression, options, isOrdgroup));\n};\n/**\n * Takes a group from the parser and calls the appropriate groupBuilders function\n * on it to produce a MathML node.\n */\n\nvar buildGroup = function buildGroup(group, options) {\n  if (!group) {\n    return new mathMLTree.MathNode(\"mrow\");\n  }\n\n  if (_mathmlGroupBuilders[group.type]) {\n    // Call the groupBuilders function\n    // $FlowFixMe\n    var result = _mathmlGroupBuilders[group.type](group, options); // $FlowFixMe\n\n    return result;\n  } else {\n    throw new ParseError(\"Got group of unknown type: '\" + group.type + \"'\");\n  }\n};\n/**\n * Takes a full parse tree and settings and builds a MathML representation of\n * it. In particular, we put the elements from building the parse tree into a\n * <semantics> tag so we can also include that TeX source as an annotation.\n *\n * Note that we actually return a domTree element with a `<math>` inside it so\n * we can do appropriate styling.\n */\n\nfunction buildMathML(tree, texExpression, options, isDisplayMode, forMathmlOnly) {\n  var expression = buildExpression(tree, options); // TODO: Make a pass thru the MathML similar to buildHTML.traverseNonSpaceNodes\n  // and add spacing nodes. This is necessary only adjacent to math operators\n  // like \\sin or \\lim or to subsup elements that contain math operators.\n  // MathML takes care of the other spacing issues.\n  // Wrap up the expression in an mrow so it is presented in the semantics\n  // tag correctly, unless it's a single <mrow> or <mtable>.\n\n  var wrapper;\n\n  if (expression.length === 1 && expression[0] instanceof MathNode && utils.contains([\"mrow\", \"mtable\"], expression[0].type)) {\n    wrapper = expression[0];\n  } else {\n    wrapper = new mathMLTree.MathNode(\"mrow\", expression);\n  } // Build a TeX annotation of the source\n\n\n  var annotation = new mathMLTree.MathNode(\"annotation\", [new mathMLTree.TextNode(texExpression)]);\n  annotation.setAttribute(\"encoding\", \"application/x-tex\");\n  var semantics = new mathMLTree.MathNode(\"semantics\", [wrapper, annotation]);\n  var math = new mathMLTree.MathNode(\"math\", [semantics]);\n  math.setAttribute(\"xmlns\", \"http://www.w3.org/1998/Math/MathML\");\n\n  if (isDisplayMode) {\n    math.setAttribute(\"display\", \"block\");\n  } // You can't style <math> nodes, so we wrap the node in a span.\n  // NOTE: The span class is not typed to have <math> nodes as children, and\n  // we don't want to make the children type more generic since the children\n  // of span are expected to have more fields in `buildHtml` contexts.\n\n\n  var wrapperClass = forMathmlOnly ? \"katex\" : \"katex-mathml\"; // $FlowFixMe\n\n  return buildCommon.makeSpan([wrapperClass], [math]);\n}\n\nvar optionsFromSettings = function optionsFromSettings(settings) {\n  return new Options({\n    style: settings.displayMode ? Style$1.DISPLAY : Style$1.TEXT,\n    maxSize: settings.maxSize,\n    minRuleThickness: settings.minRuleThickness\n  });\n};\n\nvar displayWrap = function displayWrap(node, settings) {\n  if (settings.displayMode) {\n    var classes = [\"katex-display\"];\n\n    if (settings.leqno) {\n      classes.push(\"leqno\");\n    }\n\n    if (settings.fleqn) {\n      classes.push(\"fleqn\");\n    }\n\n    node = buildCommon.makeSpan(classes, [node]);\n  }\n\n  return node;\n};\n\nvar buildTree = function buildTree(tree, expression, settings) {\n  var options = optionsFromSettings(settings);\n  var katexNode;\n\n  if (settings.output === \"mathml\") {\n    return buildMathML(tree, expression, options, settings.displayMode, true);\n  } else if (settings.output === \"html\") {\n    var htmlNode = buildHTML(tree, options);\n    katexNode = buildCommon.makeSpan([\"katex\"], [htmlNode]);\n  } else {\n    var mathMLNode = buildMathML(tree, expression, options, settings.displayMode, false);\n\n    var _htmlNode = buildHTML(tree, options);\n\n    katexNode = buildCommon.makeSpan([\"katex\"], [mathMLNode, _htmlNode]);\n  }\n\n  return displayWrap(katexNode, settings);\n};\nvar buildHTMLTree = function buildHTMLTree(tree, expression, settings) {\n  var options = optionsFromSettings(settings);\n  var htmlNode = buildHTML(tree, options);\n  var katexNode = buildCommon.makeSpan([\"katex\"], [htmlNode]);\n  return displayWrap(katexNode, settings);\n};\n\n/**\n * This file provides support to buildMathML.js and buildHTML.js\n * for stretchy wide elements rendered from SVG files\n * and other CSS trickery.\n */\nvar stretchyCodePoint = {\n  widehat: \"^\",\n  widecheck: \"ˇ\",\n  widetilde: \"~\",\n  utilde: \"~\",\n  overleftarrow: \"\\u2190\",\n  underleftarrow: \"\\u2190\",\n  xleftarrow: \"\\u2190\",\n  overrightarrow: \"\\u2192\",\n  underrightarrow: \"\\u2192\",\n  xrightarrow: \"\\u2192\",\n  underbrace: \"\\u23df\",\n  overbrace: \"\\u23de\",\n  overgroup: \"\\u23e0\",\n  undergroup: \"\\u23e1\",\n  overleftrightarrow: \"\\u2194\",\n  underleftrightarrow: \"\\u2194\",\n  xleftrightarrow: \"\\u2194\",\n  Overrightarrow: \"\\u21d2\",\n  xRightarrow: \"\\u21d2\",\n  overleftharpoon: \"\\u21bc\",\n  xleftharpoonup: \"\\u21bc\",\n  overrightharpoon: \"\\u21c0\",\n  xrightharpoonup: \"\\u21c0\",\n  xLeftarrow: \"\\u21d0\",\n  xLeftrightarrow: \"\\u21d4\",\n  xhookleftarrow: \"\\u21a9\",\n  xhookrightarrow: \"\\u21aa\",\n  xmapsto: \"\\u21a6\",\n  xrightharpoondown: \"\\u21c1\",\n  xleftharpoondown: \"\\u21bd\",\n  xrightleftharpoons: \"\\u21cc\",\n  xleftrightharpoons: \"\\u21cb\",\n  xtwoheadleftarrow: \"\\u219e\",\n  xtwoheadrightarrow: \"\\u21a0\",\n  xlongequal: \"=\",\n  xtofrom: \"\\u21c4\",\n  xrightleftarrows: \"\\u21c4\",\n  xrightequilibrium: \"\\u21cc\",\n  // Not a perfect match.\n  xleftequilibrium: \"\\u21cb\",\n  // None better available.\n  \"\\\\cdrightarrow\": \"\\u2192\",\n  \"\\\\cdleftarrow\": \"\\u2190\",\n  \"\\\\cdlongequal\": \"=\"\n};\n\nvar mathMLnode = function mathMLnode(label) {\n  var node = new mathMLTree.MathNode(\"mo\", [new mathMLTree.TextNode(stretchyCodePoint[label.replace(/^\\\\/, '')])]);\n  node.setAttribute(\"stretchy\", \"true\");\n  return node;\n}; // Many of the KaTeX SVG images have been adapted from glyphs in KaTeX fonts.\n// Copyright (c) 2009-2010, Design Science, Inc. (<www.mathjax.org>)\n// Copyright (c) 2014-2017 Khan Academy (<www.khanacademy.org>)\n// Licensed under the SIL Open Font License, Version 1.1.\n// See \\nhttp://scripts.sil.org/OFL\n// Very Long SVGs\n//    Many of the KaTeX stretchy wide elements use a long SVG image and an\n//    overflow: hidden tactic to achieve a stretchy image while avoiding\n//    distortion of arrowheads or brace corners.\n//    The SVG typically contains a very long (400 em) arrow.\n//    The SVG is in a container span that has overflow: hidden, so the span\n//    acts like a window that exposes only part of the  SVG.\n//    The SVG always has a longer, thinner aspect ratio than the container span.\n//    After the SVG fills 100% of the height of the container span,\n//    there is a long arrow shaft left over. That left-over shaft is not shown.\n//    Instead, it is sliced off because the span's CSS has overflow: hidden.\n//    Thus, the reader sees an arrow that matches the subject matter width\n//    without distortion.\n//    Some functions, such as \\cancel, need to vary their aspect ratio. These\n//    functions do not get the overflow SVG treatment.\n// Second Brush Stroke\n//    Low resolution monitors struggle to display images in fine detail.\n//    So browsers apply anti-aliasing. A long straight arrow shaft therefore\n//    will sometimes appear as if it has a blurred edge.\n//    To mitigate this, these SVG files contain a second \"brush-stroke\" on the\n//    arrow shafts. That is, a second long thin rectangular SVG path has been\n//    written directly on top of each arrow shaft. This reinforcement causes\n//    some of the screen pixels to display as black instead of the anti-aliased\n//    gray pixel that a  single path would generate. So we get arrow shafts\n//    whose edges appear to be sharper.\n// In the katexImagesData object just below, the dimensions all\n// correspond to path geometry inside the relevant SVG.\n// For example, \\overrightarrow uses the same arrowhead as glyph U+2192\n// from the KaTeX Main font. The scaling factor is 1000.\n// That is, inside the font, that arrowhead is 522 units tall, which\n// corresponds to 0.522 em inside the document.\n\n\nvar katexImagesData = {\n  //   path(s), minWidth, height, align\n  overrightarrow: [[\"rightarrow\"], 0.888, 522, \"xMaxYMin\"],\n  overleftarrow: [[\"leftarrow\"], 0.888, 522, \"xMinYMin\"],\n  underrightarrow: [[\"rightarrow\"], 0.888, 522, \"xMaxYMin\"],\n  underleftarrow: [[\"leftarrow\"], 0.888, 522, \"xMinYMin\"],\n  xrightarrow: [[\"rightarrow\"], 1.469, 522, \"xMaxYMin\"],\n  \"\\\\cdrightarrow\": [[\"rightarrow\"], 3.0, 522, \"xMaxYMin\"],\n  // CD minwwidth2.5pc\n  xleftarrow: [[\"leftarrow\"], 1.469, 522, \"xMinYMin\"],\n  \"\\\\cdleftarrow\": [[\"leftarrow\"], 3.0, 522, \"xMinYMin\"],\n  Overrightarrow: [[\"doublerightarrow\"], 0.888, 560, \"xMaxYMin\"],\n  xRightarrow: [[\"doublerightarrow\"], 1.526, 560, \"xMaxYMin\"],\n  xLeftarrow: [[\"doubleleftarrow\"], 1.526, 560, \"xMinYMin\"],\n  overleftharpoon: [[\"leftharpoon\"], 0.888, 522, \"xMinYMin\"],\n  xleftharpoonup: [[\"leftharpoon\"], 0.888, 522, \"xMinYMin\"],\n  xleftharpoondown: [[\"leftharpoondown\"], 0.888, 522, \"xMinYMin\"],\n  overrightharpoon: [[\"rightharpoon\"], 0.888, 522, \"xMaxYMin\"],\n  xrightharpoonup: [[\"rightharpoon\"], 0.888, 522, \"xMaxYMin\"],\n  xrightharpoondown: [[\"rightharpoondown\"], 0.888, 522, \"xMaxYMin\"],\n  xlongequal: [[\"longequal\"], 0.888, 334, \"xMinYMin\"],\n  \"\\\\cdlongequal\": [[\"longequal\"], 3.0, 334, \"xMinYMin\"],\n  xtwoheadleftarrow: [[\"twoheadleftarrow\"], 0.888, 334, \"xMinYMin\"],\n  xtwoheadrightarrow: [[\"twoheadrightarrow\"], 0.888, 334, \"xMaxYMin\"],\n  overleftrightarrow: [[\"leftarrow\", \"rightarrow\"], 0.888, 522],\n  overbrace: [[\"leftbrace\", \"midbrace\", \"rightbrace\"], 1.6, 548],\n  underbrace: [[\"leftbraceunder\", \"midbraceunder\", \"rightbraceunder\"], 1.6, 548],\n  underleftrightarrow: [[\"leftarrow\", \"rightarrow\"], 0.888, 522],\n  xleftrightarrow: [[\"leftarrow\", \"rightarrow\"], 1.75, 522],\n  xLeftrightarrow: [[\"doubleleftarrow\", \"doublerightarrow\"], 1.75, 560],\n  xrightleftharpoons: [[\"leftharpoondownplus\", \"rightharpoonplus\"], 1.75, 716],\n  xleftrightharpoons: [[\"leftharpoonplus\", \"rightharpoondownplus\"], 1.75, 716],\n  xhookleftarrow: [[\"leftarrow\", \"righthook\"], 1.08, 522],\n  xhookrightarrow: [[\"lefthook\", \"rightarrow\"], 1.08, 522],\n  overlinesegment: [[\"leftlinesegment\", \"rightlinesegment\"], 0.888, 522],\n  underlinesegment: [[\"leftlinesegment\", \"rightlinesegment\"], 0.888, 522],\n  overgroup: [[\"leftgroup\", \"rightgroup\"], 0.888, 342],\n  undergroup: [[\"leftgroupunder\", \"rightgroupunder\"], 0.888, 342],\n  xmapsto: [[\"leftmapsto\", \"rightarrow\"], 1.5, 522],\n  xtofrom: [[\"leftToFrom\", \"rightToFrom\"], 1.75, 528],\n  // The next three arrows are from the mhchem package.\n  // In mhchem.sty, min-length is 2.0em. But these arrows might appear in the\n  // document as \\xrightarrow or \\xrightleftharpoons. Those have\n  // min-length = 1.75em, so we set min-length on these next three to match.\n  xrightleftarrows: [[\"baraboveleftarrow\", \"rightarrowabovebar\"], 1.75, 901],\n  xrightequilibrium: [[\"baraboveshortleftharpoon\", \"rightharpoonaboveshortbar\"], 1.75, 716],\n  xleftequilibrium: [[\"shortbaraboveleftharpoon\", \"shortrightharpoonabovebar\"], 1.75, 716]\n};\n\nvar groupLength = function groupLength(arg) {\n  if (arg.type === \"ordgroup\") {\n    return arg.body.length;\n  } else {\n    return 1;\n  }\n};\n\nvar svgSpan = function svgSpan(group, options) {\n  // Create a span with inline SVG for the element.\n  function buildSvgSpan_() {\n    var viewBoxWidth = 400000; // default\n\n    var label = group.label.slice(1);\n\n    if (utils.contains([\"widehat\", \"widecheck\", \"widetilde\", \"utilde\"], label)) {\n      // Each type in the `if` statement corresponds to one of the ParseNode\n      // types below. This narrowing is required to access `grp.base`.\n      // $FlowFixMe\n      var grp = group; // There are four SVG images available for each function.\n      // Choose a taller image when there are more characters.\n\n      var numChars = groupLength(grp.base);\n      var viewBoxHeight;\n      var pathName;\n\n      var _height;\n\n      if (numChars > 5) {\n        if (label === \"widehat\" || label === \"widecheck\") {\n          viewBoxHeight = 420;\n          viewBoxWidth = 2364;\n          _height = 0.42;\n          pathName = label + \"4\";\n        } else {\n          viewBoxHeight = 312;\n          viewBoxWidth = 2340;\n          _height = 0.34;\n          pathName = \"tilde4\";\n        }\n      } else {\n        var imgIndex = [1, 1, 2, 2, 3, 3][numChars];\n\n        if (label === \"widehat\" || label === \"widecheck\") {\n          viewBoxWidth = [0, 1062, 2364, 2364, 2364][imgIndex];\n          viewBoxHeight = [0, 239, 300, 360, 420][imgIndex];\n          _height = [0, 0.24, 0.3, 0.3, 0.36, 0.42][imgIndex];\n          pathName = label + imgIndex;\n        } else {\n          viewBoxWidth = [0, 600, 1033, 2339, 2340][imgIndex];\n          viewBoxHeight = [0, 260, 286, 306, 312][imgIndex];\n          _height = [0, 0.26, 0.286, 0.3, 0.306, 0.34][imgIndex];\n          pathName = \"tilde\" + imgIndex;\n        }\n      }\n\n      var path = new PathNode(pathName);\n      var svgNode = new SvgNode([path], {\n        \"width\": \"100%\",\n        \"height\": makeEm(_height),\n        \"viewBox\": \"0 0 \" + viewBoxWidth + \" \" + viewBoxHeight,\n        \"preserveAspectRatio\": \"none\"\n      });\n      return {\n        span: buildCommon.makeSvgSpan([], [svgNode], options),\n        minWidth: 0,\n        height: _height\n      };\n    } else {\n      var spans = [];\n      var data = katexImagesData[label];\n      var [paths, _minWidth, _viewBoxHeight] = data;\n\n      var _height2 = _viewBoxHeight / 1000;\n\n      var numSvgChildren = paths.length;\n      var widthClasses;\n      var aligns;\n\n      if (numSvgChildren === 1) {\n        // $FlowFixMe: All these cases must be of the 4-tuple type.\n        var align1 = data[3];\n        widthClasses = [\"hide-tail\"];\n        aligns = [align1];\n      } else if (numSvgChildren === 2) {\n        widthClasses = [\"halfarrow-left\", \"halfarrow-right\"];\n        aligns = [\"xMinYMin\", \"xMaxYMin\"];\n      } else if (numSvgChildren === 3) {\n        widthClasses = [\"brace-left\", \"brace-center\", \"brace-right\"];\n        aligns = [\"xMinYMin\", \"xMidYMin\", \"xMaxYMin\"];\n      } else {\n        throw new Error(\"Correct katexImagesData or update code here to support\\n                    \" + numSvgChildren + \" children.\");\n      }\n\n      for (var i = 0; i < numSvgChildren; i++) {\n        var _path = new PathNode(paths[i]);\n\n        var _svgNode = new SvgNode([_path], {\n          \"width\": \"400em\",\n          \"height\": makeEm(_height2),\n          \"viewBox\": \"0 0 \" + viewBoxWidth + \" \" + _viewBoxHeight,\n          \"preserveAspectRatio\": aligns[i] + \" slice\"\n        });\n\n        var _span = buildCommon.makeSvgSpan([widthClasses[i]], [_svgNode], options);\n\n        if (numSvgChildren === 1) {\n          return {\n            span: _span,\n            minWidth: _minWidth,\n            height: _height2\n          };\n        } else {\n          _span.style.height = makeEm(_height2);\n          spans.push(_span);\n        }\n      }\n\n      return {\n        span: buildCommon.makeSpan([\"stretchy\"], spans, options),\n        minWidth: _minWidth,\n        height: _height2\n      };\n    }\n  } // buildSvgSpan_()\n\n\n  var {\n    span,\n    minWidth,\n    height\n  } = buildSvgSpan_(); // Note that we are returning span.depth = 0.\n  // Any adjustments relative to the baseline must be done in buildHTML.\n\n  span.height = height;\n  span.style.height = makeEm(height);\n\n  if (minWidth > 0) {\n    span.style.minWidth = makeEm(minWidth);\n  }\n\n  return span;\n};\n\nvar encloseSpan = function encloseSpan(inner, label, topPad, bottomPad, options) {\n  // Return an image span for \\cancel, \\bcancel, \\xcancel, \\fbox, or \\angl\n  var img;\n  var totalHeight = inner.height + inner.depth + topPad + bottomPad;\n\n  if (/fbox|color|angl/.test(label)) {\n    img = buildCommon.makeSpan([\"stretchy\", label], [], options);\n\n    if (label === \"fbox\") {\n      var color = options.color && options.getColor();\n\n      if (color) {\n        img.style.borderColor = color;\n      }\n    }\n  } else {\n    // \\cancel, \\bcancel, or \\xcancel\n    // Since \\cancel's SVG is inline and it omits the viewBox attribute,\n    // its stroke-width will not vary with span area.\n    var lines = [];\n\n    if (/^[bx]cancel$/.test(label)) {\n      lines.push(new LineNode({\n        \"x1\": \"0\",\n        \"y1\": \"0\",\n        \"x2\": \"100%\",\n        \"y2\": \"100%\",\n        \"stroke-width\": \"0.046em\"\n      }));\n    }\n\n    if (/^x?cancel$/.test(label)) {\n      lines.push(new LineNode({\n        \"x1\": \"0\",\n        \"y1\": \"100%\",\n        \"x2\": \"100%\",\n        \"y2\": \"0\",\n        \"stroke-width\": \"0.046em\"\n      }));\n    }\n\n    var svgNode = new SvgNode(lines, {\n      \"width\": \"100%\",\n      \"height\": makeEm(totalHeight)\n    });\n    img = buildCommon.makeSvgSpan([], [svgNode], options);\n  }\n\n  img.height = totalHeight;\n  img.style.height = makeEm(totalHeight);\n  return img;\n};\n\nvar stretchy = {\n  encloseSpan,\n  mathMLnode,\n  svgSpan\n};\n\n/**\n * Asserts that the node is of the given type and returns it with stricter\n * typing. Throws if the node's type does not match.\n */\nfunction assertNodeType(node, type) {\n  if (!node || node.type !== type) {\n    throw new Error(\"Expected node of type \" + type + \", but got \" + (node ? \"node of type \" + node.type : String(node)));\n  } // $FlowFixMe, >=0.125\n\n\n  return node;\n}\n/**\n * Returns the node more strictly typed iff it is of the given type. Otherwise,\n * returns null.\n */\n\nfunction assertSymbolNodeType(node) {\n  var typedNode = checkSymbolNodeType(node);\n\n  if (!typedNode) {\n    throw new Error(\"Expected node of symbol group type, but got \" + (node ? \"node of type \" + node.type : String(node)));\n  }\n\n  return typedNode;\n}\n/**\n * Returns the node more strictly typed iff it is of the given type. Otherwise,\n * returns null.\n */\n\nfunction checkSymbolNodeType(node) {\n  if (node && (node.type === \"atom\" || NON_ATOMS.hasOwnProperty(node.type))) {\n    // $FlowFixMe\n    return node;\n  }\n\n  return null;\n}\n\n// NOTE: Unlike most `htmlBuilder`s, this one handles not only \"accent\", but\n// also \"supsub\" since an accent can affect super/subscripting.\nvar htmlBuilder$a = (grp, options) => {\n  // Accents are handled in the TeXbook pg. 443, rule 12.\n  var base;\n  var group;\n  var supSubGroup;\n\n  if (grp && grp.type === \"supsub\") {\n    // If our base is a character box, and we have superscripts and\n    // subscripts, the supsub will defer to us. In particular, we want\n    // to attach the superscripts and subscripts to the inner body (so\n    // that the position of the superscripts and subscripts won't be\n    // affected by the height of the accent). We accomplish this by\n    // sticking the base of the accent into the base of the supsub, and\n    // rendering that, while keeping track of where the accent is.\n    // The real accent group is the base of the supsub group\n    group = assertNodeType(grp.base, \"accent\"); // The character box is the base of the accent group\n\n    base = group.base; // Stick the character box into the base of the supsub group\n\n    grp.base = base; // Rerender the supsub group with its new base, and store that\n    // result.\n\n    supSubGroup = assertSpan(buildGroup$1(grp, options)); // reset original base\n\n    grp.base = group;\n  } else {\n    group = assertNodeType(grp, \"accent\");\n    base = group.base;\n  } // Build the base group\n\n\n  var body = buildGroup$1(base, options.havingCrampedStyle()); // Does the accent need to shift for the skew of a character?\n\n  var mustShift = group.isShifty && utils.isCharacterBox(base); // Calculate the skew of the accent. This is based on the line \"If the\n  // nucleus is not a single character, let s = 0; otherwise set s to the\n  // kern amount for the nucleus followed by the \\skewchar of its font.\"\n  // Note that our skew metrics are just the kern between each character\n  // and the skewchar.\n\n  var skew = 0;\n\n  if (mustShift) {\n    // If the base is a character box, then we want the skew of the\n    // innermost character. To do that, we find the innermost character:\n    var baseChar = utils.getBaseElem(base); // Then, we render its group to get the symbol inside it\n\n    var baseGroup = buildGroup$1(baseChar, options.havingCrampedStyle()); // Finally, we pull the skew off of the symbol.\n\n    skew = assertSymbolDomNode(baseGroup).skew; // Note that we now throw away baseGroup, because the layers we\n    // removed with getBaseElem might contain things like \\color which\n    // we can't get rid of.\n    // TODO(emily): Find a better way to get the skew\n  }\n\n  var accentBelow = group.label === \"\\\\c\"; // calculate the amount of space between the body and the accent\n\n  var clearance = accentBelow ? body.height + body.depth : Math.min(body.height, options.fontMetrics().xHeight); // Build the accent\n\n  var accentBody;\n\n  if (!group.isStretchy) {\n    var accent;\n    var width;\n\n    if (group.label === \"\\\\vec\") {\n      // Before version 0.9, \\vec used the combining font glyph U+20D7.\n      // But browsers, especially Safari, are not consistent in how they\n      // render combining characters when not preceded by a character.\n      // So now we use an SVG.\n      // If Safari reforms, we should consider reverting to the glyph.\n      accent = buildCommon.staticSvg(\"vec\", options);\n      width = buildCommon.svgData.vec[1];\n    } else {\n      accent = buildCommon.makeOrd({\n        mode: group.mode,\n        text: group.label\n      }, options, \"textord\");\n      accent = assertSymbolDomNode(accent); // Remove the italic correction of the accent, because it only serves to\n      // shift the accent over to a place we don't want.\n\n      accent.italic = 0;\n      width = accent.width;\n\n      if (accentBelow) {\n        clearance += accent.depth;\n      }\n    }\n\n    accentBody = buildCommon.makeSpan([\"accent-body\"], [accent]); // \"Full\" accents expand the width of the resulting symbol to be\n    // at least the width of the accent, and overlap directly onto the\n    // character without any vertical offset.\n\n    var accentFull = group.label === \"\\\\textcircled\";\n\n    if (accentFull) {\n      accentBody.classes.push('accent-full');\n      clearance = body.height;\n    } // Shift the accent over by the skew.\n\n\n    var left = skew; // CSS defines `.katex .accent .accent-body:not(.accent-full) { width: 0 }`\n    // so that the accent doesn't contribute to the bounding box.\n    // We need to shift the character by its width (effectively half\n    // its width) to compensate.\n\n    if (!accentFull) {\n      left -= width / 2;\n    }\n\n    accentBody.style.left = makeEm(left); // \\textcircled uses the \\bigcirc glyph, so it needs some\n    // vertical adjustment to match LaTeX.\n\n    if (group.label === \"\\\\textcircled\") {\n      accentBody.style.top = \".2em\";\n    }\n\n    accentBody = buildCommon.makeVList({\n      positionType: \"firstBaseline\",\n      children: [{\n        type: \"elem\",\n        elem: body\n      }, {\n        type: \"kern\",\n        size: -clearance\n      }, {\n        type: \"elem\",\n        elem: accentBody\n      }]\n    }, options);\n  } else {\n    accentBody = stretchy.svgSpan(group, options);\n    accentBody = buildCommon.makeVList({\n      positionType: \"firstBaseline\",\n      children: [{\n        type: \"elem\",\n        elem: body\n      }, {\n        type: \"elem\",\n        elem: accentBody,\n        wrapperClasses: [\"svg-align\"],\n        wrapperStyle: skew > 0 ? {\n          width: \"calc(100% - \" + makeEm(2 * skew) + \")\",\n          marginLeft: makeEm(2 * skew)\n        } : undefined\n      }]\n    }, options);\n  }\n\n  var accentWrap = buildCommon.makeSpan([\"mord\", \"accent\"], [accentBody], options);\n\n  if (supSubGroup) {\n    // Here, we replace the \"base\" child of the supsub with our newly\n    // generated accent.\n    supSubGroup.children[0] = accentWrap; // Since we don't rerun the height calculation after replacing the\n    // accent, we manually recalculate height.\n\n    supSubGroup.height = Math.max(accentWrap.height, supSubGroup.height); // Accents should always be ords, even when their innards are not.\n\n    supSubGroup.classes[0] = \"mord\";\n    return supSubGroup;\n  } else {\n    return accentWrap;\n  }\n};\n\nvar mathmlBuilder$9 = (group, options) => {\n  var accentNode = group.isStretchy ? stretchy.mathMLnode(group.label) : new mathMLTree.MathNode(\"mo\", [makeText(group.label, group.mode)]);\n  var node = new mathMLTree.MathNode(\"mover\", [buildGroup(group.base, options), accentNode]);\n  node.setAttribute(\"accent\", \"true\");\n  return node;\n};\n\nvar NON_STRETCHY_ACCENT_REGEX = new RegExp([\"\\\\acute\", \"\\\\grave\", \"\\\\ddot\", \"\\\\tilde\", \"\\\\bar\", \"\\\\breve\", \"\\\\check\", \"\\\\hat\", \"\\\\vec\", \"\\\\dot\", \"\\\\mathring\"].map(accent => \"\\\\\" + accent).join(\"|\")); // Accents\n\ndefineFunction({\n  type: \"accent\",\n  names: [\"\\\\acute\", \"\\\\grave\", \"\\\\ddot\", \"\\\\tilde\", \"\\\\bar\", \"\\\\breve\", \"\\\\check\", \"\\\\hat\", \"\\\\vec\", \"\\\\dot\", \"\\\\mathring\", \"\\\\widecheck\", \"\\\\widehat\", \"\\\\widetilde\", \"\\\\overrightarrow\", \"\\\\overleftarrow\", \"\\\\Overrightarrow\", \"\\\\overleftrightarrow\", \"\\\\overgroup\", \"\\\\overlinesegment\", \"\\\\overleftharpoon\", \"\\\\overrightharpoon\"],\n  props: {\n    numArgs: 1\n  },\n  handler: (context, args) => {\n    var base = normalizeArgument(args[0]);\n    var isStretchy = !NON_STRETCHY_ACCENT_REGEX.test(context.funcName);\n    var isShifty = !isStretchy || context.funcName === \"\\\\widehat\" || context.funcName === \"\\\\widetilde\" || context.funcName === \"\\\\widecheck\";\n    return {\n      type: \"accent\",\n      mode: context.parser.mode,\n      label: context.funcName,\n      isStretchy: isStretchy,\n      isShifty: isShifty,\n      base: base\n    };\n  },\n  htmlBuilder: htmlBuilder$a,\n  mathmlBuilder: mathmlBuilder$9\n}); // Text-mode accents\n\ndefineFunction({\n  type: \"accent\",\n  names: [\"\\\\'\", \"\\\\`\", \"\\\\^\", \"\\\\~\", \"\\\\=\", \"\\\\u\", \"\\\\.\", '\\\\\"', \"\\\\c\", \"\\\\r\", \"\\\\H\", \"\\\\v\", \"\\\\textcircled\"],\n  props: {\n    numArgs: 1,\n    allowedInText: true,\n    allowedInMath: true,\n    // unless in strict mode\n    argTypes: [\"primitive\"]\n  },\n  handler: (context, args) => {\n    var base = args[0];\n    var mode = context.parser.mode;\n\n    if (mode === \"math\") {\n      context.parser.settings.reportNonstrict(\"mathVsTextAccents\", \"LaTeX's accent \" + context.funcName + \" works only in text mode\");\n      mode = \"text\";\n    }\n\n    return {\n      type: \"accent\",\n      mode: mode,\n      label: context.funcName,\n      isStretchy: false,\n      isShifty: true,\n      base: base\n    };\n  },\n  htmlBuilder: htmlBuilder$a,\n  mathmlBuilder: mathmlBuilder$9\n});\n\n// Horizontal overlap functions\ndefineFunction({\n  type: \"accentUnder\",\n  names: [\"\\\\underleftarrow\", \"\\\\underrightarrow\", \"\\\\underleftrightarrow\", \"\\\\undergroup\", \"\\\\underlinesegment\", \"\\\\utilde\"],\n  props: {\n    numArgs: 1\n  },\n  handler: (_ref, args) => {\n    var {\n      parser,\n      funcName\n    } = _ref;\n    var base = args[0];\n    return {\n      type: \"accentUnder\",\n      mode: parser.mode,\n      label: funcName,\n      base: base\n    };\n  },\n  htmlBuilder: (group, options) => {\n    // Treat under accents much like underlines.\n    var innerGroup = buildGroup$1(group.base, options);\n    var accentBody = stretchy.svgSpan(group, options);\n    var kern = group.label === \"\\\\utilde\" ? 0.12 : 0; // Generate the vlist, with the appropriate kerns\n\n    var vlist = buildCommon.makeVList({\n      positionType: \"top\",\n      positionData: innerGroup.height,\n      children: [{\n        type: \"elem\",\n        elem: accentBody,\n        wrapperClasses: [\"svg-align\"]\n      }, {\n        type: \"kern\",\n        size: kern\n      }, {\n        type: \"elem\",\n        elem: innerGroup\n      }]\n    }, options);\n    return buildCommon.makeSpan([\"mord\", \"accentunder\"], [vlist], options);\n  },\n  mathmlBuilder: (group, options) => {\n    var accentNode = stretchy.mathMLnode(group.label);\n    var node = new mathMLTree.MathNode(\"munder\", [buildGroup(group.base, options), accentNode]);\n    node.setAttribute(\"accentunder\", \"true\");\n    return node;\n  }\n});\n\n// Helper function\nvar paddedNode = group => {\n  var node = new mathMLTree.MathNode(\"mpadded\", group ? [group] : []);\n  node.setAttribute(\"width\", \"+0.6em\");\n  node.setAttribute(\"lspace\", \"0.3em\");\n  return node;\n}; // Stretchy arrows with an optional argument\n\n\ndefineFunction({\n  type: \"xArrow\",\n  names: [\"\\\\xleftarrow\", \"\\\\xrightarrow\", \"\\\\xLeftarrow\", \"\\\\xRightarrow\", \"\\\\xleftrightarrow\", \"\\\\xLeftrightarrow\", \"\\\\xhookleftarrow\", \"\\\\xhookrightarrow\", \"\\\\xmapsto\", \"\\\\xrightharpoondown\", \"\\\\xrightharpoonup\", \"\\\\xleftharpoondown\", \"\\\\xleftharpoonup\", \"\\\\xrightleftharpoons\", \"\\\\xleftrightharpoons\", \"\\\\xlongequal\", \"\\\\xtwoheadrightarrow\", \"\\\\xtwoheadleftarrow\", \"\\\\xtofrom\", // The next 3 functions are here to support the mhchem extension.\n  // Direct use of these functions is discouraged and may break someday.\n  \"\\\\xrightleftarrows\", \"\\\\xrightequilibrium\", \"\\\\xleftequilibrium\", // The next 3 functions are here only to support the {CD} environment.\n  \"\\\\\\\\cdrightarrow\", \"\\\\\\\\cdleftarrow\", \"\\\\\\\\cdlongequal\"],\n  props: {\n    numArgs: 1,\n    numOptionalArgs: 1\n  },\n\n  handler(_ref, args, optArgs) {\n    var {\n      parser,\n      funcName\n    } = _ref;\n    return {\n      type: \"xArrow\",\n      mode: parser.mode,\n      label: funcName,\n      body: args[0],\n      below: optArgs[0]\n    };\n  },\n\n  // Flow is unable to correctly infer the type of `group`, even though it's\n  // unambiguously determined from the passed-in `type` above.\n  htmlBuilder(group, options) {\n    var style = options.style; // Build the argument groups in the appropriate style.\n    // Ref: amsmath.dtx:   \\hbox{$\\scriptstyle\\mkern#3mu{#6}\\mkern#4mu$}%\n    // Some groups can return document fragments.  Handle those by wrapping\n    // them in a span.\n\n    var newOptions = options.havingStyle(style.sup());\n    var upperGroup = buildCommon.wrapFragment(buildGroup$1(group.body, newOptions, options), options);\n    var arrowPrefix = group.label.slice(0, 2) === \"\\\\x\" ? \"x\" : \"cd\";\n    upperGroup.classes.push(arrowPrefix + \"-arrow-pad\");\n    var lowerGroup;\n\n    if (group.below) {\n      // Build the lower group\n      newOptions = options.havingStyle(style.sub());\n      lowerGroup = buildCommon.wrapFragment(buildGroup$1(group.below, newOptions, options), options);\n      lowerGroup.classes.push(arrowPrefix + \"-arrow-pad\");\n    }\n\n    var arrowBody = stretchy.svgSpan(group, options); // Re shift: Note that stretchy.svgSpan returned arrowBody.depth = 0.\n    // The point we want on the math axis is at 0.5 * arrowBody.height.\n\n    var arrowShift = -options.fontMetrics().axisHeight + 0.5 * arrowBody.height; // 2 mu kern. Ref: amsmath.dtx: #7\\if0#2\\else\\mkern#2mu\\fi\n\n    var upperShift = -options.fontMetrics().axisHeight - 0.5 * arrowBody.height - 0.111; // 0.111 em = 2 mu\n\n    if (upperGroup.depth > 0.25 || group.label === \"\\\\xleftequilibrium\") {\n      upperShift -= upperGroup.depth; // shift up if depth encroaches\n    } // Generate the vlist\n\n\n    var vlist;\n\n    if (lowerGroup) {\n      var lowerShift = -options.fontMetrics().axisHeight + lowerGroup.height + 0.5 * arrowBody.height + 0.111;\n      vlist = buildCommon.makeVList({\n        positionType: \"individualShift\",\n        children: [{\n          type: \"elem\",\n          elem: upperGroup,\n          shift: upperShift\n        }, {\n          type: \"elem\",\n          elem: arrowBody,\n          shift: arrowShift\n        }, {\n          type: \"elem\",\n          elem: lowerGroup,\n          shift: lowerShift\n        }]\n      }, options);\n    } else {\n      vlist = buildCommon.makeVList({\n        positionType: \"individualShift\",\n        children: [{\n          type: \"elem\",\n          elem: upperGroup,\n          shift: upperShift\n        }, {\n          type: \"elem\",\n          elem: arrowBody,\n          shift: arrowShift\n        }]\n      }, options);\n    } // $FlowFixMe: Replace this with passing \"svg-align\" into makeVList.\n\n\n    vlist.children[0].children[0].children[1].classes.push(\"svg-align\");\n    return buildCommon.makeSpan([\"mrel\", \"x-arrow\"], [vlist], options);\n  },\n\n  mathmlBuilder(group, options) {\n    var arrowNode = stretchy.mathMLnode(group.label);\n    arrowNode.setAttribute(\"minsize\", group.label.charAt(0) === \"x\" ? \"1.75em\" : \"3.0em\");\n    var node;\n\n    if (group.body) {\n      var upperNode = paddedNode(buildGroup(group.body, options));\n\n      if (group.below) {\n        var lowerNode = paddedNode(buildGroup(group.below, options));\n        node = new mathMLTree.MathNode(\"munderover\", [arrowNode, lowerNode, upperNode]);\n      } else {\n        node = new mathMLTree.MathNode(\"mover\", [arrowNode, upperNode]);\n      }\n    } else if (group.below) {\n      var _lowerNode = paddedNode(buildGroup(group.below, options));\n\n      node = new mathMLTree.MathNode(\"munder\", [arrowNode, _lowerNode]);\n    } else {\n      // This should never happen.\n      // Parser.js throws an error if there is no argument.\n      node = paddedNode();\n      node = new mathMLTree.MathNode(\"mover\", [arrowNode, node]);\n    }\n\n    return node;\n  }\n\n});\n\nvar makeSpan = buildCommon.makeSpan;\n\nfunction htmlBuilder$9(group, options) {\n  var elements = buildExpression$1(group.body, options, true);\n  return makeSpan([group.mclass], elements, options);\n}\n\nfunction mathmlBuilder$8(group, options) {\n  var node;\n  var inner = buildExpression(group.body, options);\n\n  if (group.mclass === \"minner\") {\n    node = new mathMLTree.MathNode(\"mpadded\", inner);\n  } else if (group.mclass === \"mord\") {\n    if (group.isCharacterBox) {\n      node = inner[0];\n      node.type = \"mi\";\n    } else {\n      node = new mathMLTree.MathNode(\"mi\", inner);\n    }\n  } else {\n    if (group.isCharacterBox) {\n      node = inner[0];\n      node.type = \"mo\";\n    } else {\n      node = new mathMLTree.MathNode(\"mo\", inner);\n    } // Set spacing based on what is the most likely adjacent atom type.\n    // See TeXbook p170.\n\n\n    if (group.mclass === \"mbin\") {\n      node.attributes.lspace = \"0.22em\"; // medium space\n\n      node.attributes.rspace = \"0.22em\";\n    } else if (group.mclass === \"mpunct\") {\n      node.attributes.lspace = \"0em\";\n      node.attributes.rspace = \"0.17em\"; // thinspace\n    } else if (group.mclass === \"mopen\" || group.mclass === \"mclose\") {\n      node.attributes.lspace = \"0em\";\n      node.attributes.rspace = \"0em\";\n    } else if (group.mclass === \"minner\") {\n      node.attributes.lspace = \"0.0556em\"; // 1 mu is the most likely option\n\n      node.attributes.width = \"+0.1111em\";\n    } // MathML <mo> default space is 5/18 em, so <mrel> needs no action.\n    // Ref: https://developer.mozilla.org/en-US/docs/Web/MathML/Element/mo\n\n  }\n\n  return node;\n} // Math class commands except \\mathop\n\n\ndefineFunction({\n  type: \"mclass\",\n  names: [\"\\\\mathord\", \"\\\\mathbin\", \"\\\\mathrel\", \"\\\\mathopen\", \"\\\\mathclose\", \"\\\\mathpunct\", \"\\\\mathinner\"],\n  props: {\n    numArgs: 1,\n    primitive: true\n  },\n\n  handler(_ref, args) {\n    var {\n      parser,\n      funcName\n    } = _ref;\n    var body = args[0];\n    return {\n      type: \"mclass\",\n      mode: parser.mode,\n      mclass: \"m\" + funcName.slice(5),\n      // TODO(kevinb): don't prefix with 'm'\n      body: ordargument(body),\n      isCharacterBox: utils.isCharacterBox(body)\n    };\n  },\n\n  htmlBuilder: htmlBuilder$9,\n  mathmlBuilder: mathmlBuilder$8\n});\nvar binrelClass = arg => {\n  // \\binrel@ spacing varies with (bin|rel|ord) of the atom in the argument.\n  // (by rendering separately and with {}s before and after, and measuring\n  // the change in spacing).  We'll do roughly the same by detecting the\n  // atom type directly.\n  var atom = arg.type === \"ordgroup\" && arg.body.length ? arg.body[0] : arg;\n\n  if (atom.type === \"atom\" && (atom.family === \"bin\" || atom.family === \"rel\")) {\n    return \"m\" + atom.family;\n  } else {\n    return \"mord\";\n  }\n}; // \\@binrel{x}{y} renders like y but as mbin/mrel/mord if x is mbin/mrel/mord.\n// This is equivalent to \\binrel@{x}\\binrel@@{y} in AMSTeX.\n\ndefineFunction({\n  type: \"mclass\",\n  names: [\"\\\\@binrel\"],\n  props: {\n    numArgs: 2\n  },\n\n  handler(_ref2, args) {\n    var {\n      parser\n    } = _ref2;\n    return {\n      type: \"mclass\",\n      mode: parser.mode,\n      mclass: binrelClass(args[0]),\n      body: ordargument(args[1]),\n      isCharacterBox: utils.isCharacterBox(args[1])\n    };\n  }\n\n}); // Build a relation or stacked op by placing one symbol on top of another\n\ndefineFunction({\n  type: \"mclass\",\n  names: [\"\\\\stackrel\", \"\\\\overset\", \"\\\\underset\"],\n  props: {\n    numArgs: 2\n  },\n\n  handler(_ref3, args) {\n    var {\n      parser,\n      funcName\n    } = _ref3;\n    var baseArg = args[1];\n    var shiftedArg = args[0];\n    var mclass;\n\n    if (funcName !== \"\\\\stackrel\") {\n      // LaTeX applies \\binrel spacing to \\overset and \\underset.\n      mclass = binrelClass(baseArg);\n    } else {\n      mclass = \"mrel\"; // for \\stackrel\n    }\n\n    var baseOp = {\n      type: \"op\",\n      mode: baseArg.mode,\n      limits: true,\n      alwaysHandleSupSub: true,\n      parentIsSupSub: false,\n      symbol: false,\n      suppressBaseShift: funcName !== \"\\\\stackrel\",\n      body: ordargument(baseArg)\n    };\n    var supsub = {\n      type: \"supsub\",\n      mode: shiftedArg.mode,\n      base: baseOp,\n      sup: funcName === \"\\\\underset\" ? null : shiftedArg,\n      sub: funcName === \"\\\\underset\" ? shiftedArg : null\n    };\n    return {\n      type: \"mclass\",\n      mode: parser.mode,\n      mclass,\n      body: [supsub],\n      isCharacterBox: utils.isCharacterBox(supsub)\n    };\n  },\n\n  htmlBuilder: htmlBuilder$9,\n  mathmlBuilder: mathmlBuilder$8\n});\n\n// \\pmb is a simulation of bold font.\n// The version of \\pmb in ambsy.sty works by typesetting three copies\n// with small offsets. We use CSS text-shadow.\n// It's a hack. Not as good as a real bold font. Better than nothing.\ndefineFunction({\n  type: \"pmb\",\n  names: [\"\\\\pmb\"],\n  props: {\n    numArgs: 1,\n    allowedInText: true\n  },\n\n  handler(_ref, args) {\n    var {\n      parser\n    } = _ref;\n    return {\n      type: \"pmb\",\n      mode: parser.mode,\n      mclass: binrelClass(args[0]),\n      body: ordargument(args[0])\n    };\n  },\n\n  htmlBuilder(group, options) {\n    var elements = buildExpression$1(group.body, options, true);\n    var node = buildCommon.makeSpan([group.mclass], elements, options);\n    node.style.textShadow = \"0.02em 0.01em 0.04px\";\n    return node;\n  },\n\n  mathmlBuilder(group, style) {\n    var inner = buildExpression(group.body, style); // Wrap with an <mstyle> element.\n\n    var node = new mathMLTree.MathNode(\"mstyle\", inner);\n    node.setAttribute(\"style\", \"text-shadow: 0.02em 0.01em 0.04px\");\n    return node;\n  }\n\n});\n\nvar cdArrowFunctionName = {\n  \">\": \"\\\\\\\\cdrightarrow\",\n  \"<\": \"\\\\\\\\cdleftarrow\",\n  \"=\": \"\\\\\\\\cdlongequal\",\n  \"A\": \"\\\\uparrow\",\n  \"V\": \"\\\\downarrow\",\n  \"|\": \"\\\\Vert\",\n  \".\": \"no arrow\"\n};\n\nvar newCell = () => {\n  // Create an empty cell, to be filled below with parse nodes.\n  // The parseTree from this module must be constructed like the\n  // one created by parseArray(), so an empty CD cell must\n  // be a ParseNode<\"styling\">. And CD is always displaystyle.\n  // So these values are fixed and flow can do implicit typing.\n  return {\n    type: \"styling\",\n    body: [],\n    mode: \"math\",\n    style: \"display\"\n  };\n};\n\nvar isStartOfArrow = node => {\n  return node.type === \"textord\" && node.text === \"@\";\n};\n\nvar isLabelEnd = (node, endChar) => {\n  return (node.type === \"mathord\" || node.type === \"atom\") && node.text === endChar;\n};\n\nfunction cdArrow(arrowChar, labels, parser) {\n  // Return a parse tree of an arrow and its labels.\n  // This acts in a way similar to a macro expansion.\n  var funcName = cdArrowFunctionName[arrowChar];\n\n  switch (funcName) {\n    case \"\\\\\\\\cdrightarrow\":\n    case \"\\\\\\\\cdleftarrow\":\n      return parser.callFunction(funcName, [labels[0]], [labels[1]]);\n\n    case \"\\\\uparrow\":\n    case \"\\\\downarrow\":\n      {\n        var leftLabel = parser.callFunction(\"\\\\\\\\cdleft\", [labels[0]], []);\n        var bareArrow = {\n          type: \"atom\",\n          text: funcName,\n          mode: \"math\",\n          family: \"rel\"\n        };\n        var sizedArrow = parser.callFunction(\"\\\\Big\", [bareArrow], []);\n        var rightLabel = parser.callFunction(\"\\\\\\\\cdright\", [labels[1]], []);\n        var arrowGroup = {\n          type: \"ordgroup\",\n          mode: \"math\",\n          body: [leftLabel, sizedArrow, rightLabel]\n        };\n        return parser.callFunction(\"\\\\\\\\cdparent\", [arrowGroup], []);\n      }\n\n    case \"\\\\\\\\cdlongequal\":\n      return parser.callFunction(\"\\\\\\\\cdlongequal\", [], []);\n\n    case \"\\\\Vert\":\n      {\n        var arrow = {\n          type: \"textord\",\n          text: \"\\\\Vert\",\n          mode: \"math\"\n        };\n        return parser.callFunction(\"\\\\Big\", [arrow], []);\n      }\n\n    default:\n      return {\n        type: \"textord\",\n        text: \" \",\n        mode: \"math\"\n      };\n  }\n}\n\nfunction parseCD(parser) {\n  // Get the array's parse nodes with \\\\ temporarily mapped to \\cr.\n  var parsedRows = [];\n  parser.gullet.beginGroup();\n  parser.gullet.macros.set(\"\\\\cr\", \"\\\\\\\\\\\\relax\");\n  parser.gullet.beginGroup();\n\n  while (true) {\n    // eslint-disable-line no-constant-condition\n    // Get the parse nodes for the next row.\n    parsedRows.push(parser.parseExpression(false, \"\\\\\\\\\"));\n    parser.gullet.endGroup();\n    parser.gullet.beginGroup();\n    var next = parser.fetch().text;\n\n    if (next === \"&\" || next === \"\\\\\\\\\") {\n      parser.consume();\n    } else if (next === \"\\\\end\") {\n      if (parsedRows[parsedRows.length - 1].length === 0) {\n        parsedRows.pop(); // final row ended in \\\\\n      }\n\n      break;\n    } else {\n      throw new ParseError(\"Expected \\\\\\\\ or \\\\cr or \\\\end\", parser.nextToken);\n    }\n  }\n\n  var row = [];\n  var body = [row]; // Loop thru the parse nodes. Collect them into cells and arrows.\n\n  for (var i = 0; i < parsedRows.length; i++) {\n    // Start a new row.\n    var rowNodes = parsedRows[i]; // Create the first cell.\n\n    var cell = newCell();\n\n    for (var j = 0; j < rowNodes.length; j++) {\n      if (!isStartOfArrow(rowNodes[j])) {\n        // If a parseNode is not an arrow, it goes into a cell.\n        cell.body.push(rowNodes[j]);\n      } else {\n        // Parse node j is an \"@\", the start of an arrow.\n        // Before starting on the arrow, push the cell into `row`.\n        row.push(cell); // Now collect parseNodes into an arrow.\n        // The character after \"@\" defines the arrow type.\n\n        j += 1;\n        var arrowChar = assertSymbolNodeType(rowNodes[j]).text; // Create two empty label nodes. We may or may not use them.\n\n        var labels = new Array(2);\n        labels[0] = {\n          type: \"ordgroup\",\n          mode: \"math\",\n          body: []\n        };\n        labels[1] = {\n          type: \"ordgroup\",\n          mode: \"math\",\n          body: []\n        }; // Process the arrow.\n\n        if (\"=|.\".indexOf(arrowChar) > -1) ; else if (\"<>AV\".indexOf(arrowChar) > -1) {\n          // Four arrows, `@>>>`, `@<<<`, `@AAA`, and `@VVV`, each take\n          // two optional labels. E.g. the right-point arrow syntax is\n          // really:  @>{optional label}>{optional label}>\n          // Collect parseNodes into labels.\n          for (var labelNum = 0; labelNum < 2; labelNum++) {\n            var inLabel = true;\n\n            for (var k = j + 1; k < rowNodes.length; k++) {\n              if (isLabelEnd(rowNodes[k], arrowChar)) {\n                inLabel = false;\n                j = k;\n                break;\n              }\n\n              if (isStartOfArrow(rowNodes[k])) {\n                throw new ParseError(\"Missing a \" + arrowChar + \" character to complete a CD arrow.\", rowNodes[k]);\n              }\n\n              labels[labelNum].body.push(rowNodes[k]);\n            }\n\n            if (inLabel) {\n              // isLabelEnd never returned a true.\n              throw new ParseError(\"Missing a \" + arrowChar + \" character to complete a CD arrow.\", rowNodes[j]);\n            }\n          }\n        } else {\n          throw new ParseError(\"Expected one of \\\"<>AV=|.\\\" after @\", rowNodes[j]);\n        } // Now join the arrow to its labels.\n\n\n        var arrow = cdArrow(arrowChar, labels, parser); // Wrap the arrow in  ParseNode<\"styling\">.\n        // This is done to match parseArray() behavior.\n\n        var wrappedArrow = {\n          type: \"styling\",\n          body: [arrow],\n          mode: \"math\",\n          style: \"display\" // CD is always displaystyle.\n\n        };\n        row.push(wrappedArrow); // In CD's syntax, cells are implicit. That is, everything that\n        // is not an arrow gets collected into a cell. So create an empty\n        // cell now. It will collect upcoming parseNodes.\n\n        cell = newCell();\n      }\n    }\n\n    if (i % 2 === 0) {\n      // Even-numbered rows consist of: cell, arrow, cell, arrow, ... cell\n      // The last cell is not yet pushed into `row`, so:\n      row.push(cell);\n    } else {\n      // Odd-numbered rows consist of: vert arrow, empty cell, ... vert arrow\n      // Remove the empty cell that was placed at the beginning of `row`.\n      row.shift();\n    }\n\n    row = [];\n    body.push(row);\n  } // End row group\n\n\n  parser.gullet.endGroup(); // End array group defining \\\\\n\n  parser.gullet.endGroup(); // define column separation.\n\n  var cols = new Array(body[0].length).fill({\n    type: \"align\",\n    align: \"c\",\n    pregap: 0.25,\n    // CD package sets \\enskip between columns.\n    postgap: 0.25 // So pre and post each get half an \\enskip, i.e. 0.25em.\n\n  });\n  return {\n    type: \"array\",\n    mode: \"math\",\n    body,\n    arraystretch: 1,\n    addJot: true,\n    rowGaps: [null],\n    cols,\n    colSeparationType: \"CD\",\n    hLinesBeforeRow: new Array(body.length + 1).fill([])\n  };\n} // The functions below are not available for general use.\n// They are here only for internal use by the {CD} environment in placing labels\n// next to vertical arrows.\n// We don't need any such functions for horizontal arrows because we can reuse\n// the functionality that already exists for extensible arrows.\n\ndefineFunction({\n  type: \"cdlabel\",\n  names: [\"\\\\\\\\cdleft\", \"\\\\\\\\cdright\"],\n  props: {\n    numArgs: 1\n  },\n\n  handler(_ref, args) {\n    var {\n      parser,\n      funcName\n    } = _ref;\n    return {\n      type: \"cdlabel\",\n      mode: parser.mode,\n      side: funcName.slice(4),\n      label: args[0]\n    };\n  },\n\n  htmlBuilder(group, options) {\n    var newOptions = options.havingStyle(options.style.sup());\n    var label = buildCommon.wrapFragment(buildGroup$1(group.label, newOptions, options), options);\n    label.classes.push(\"cd-label-\" + group.side);\n    label.style.bottom = makeEm(0.8 - label.depth); // Zero out label height & depth, so vertical align of arrow is set\n    // by the arrow height, not by the label.\n\n    label.height = 0;\n    label.depth = 0;\n    return label;\n  },\n\n  mathmlBuilder(group, options) {\n    var label = new mathMLTree.MathNode(\"mrow\", [buildGroup(group.label, options)]);\n    label = new mathMLTree.MathNode(\"mpadded\", [label]);\n    label.setAttribute(\"width\", \"0\");\n\n    if (group.side === \"left\") {\n      label.setAttribute(\"lspace\", \"-1width\");\n    } // We have to guess at vertical alignment. We know the arrow is 1.8em tall,\n    // But we don't know the height or depth of the label.\n\n\n    label.setAttribute(\"voffset\", \"0.7em\");\n    label = new mathMLTree.MathNode(\"mstyle\", [label]);\n    label.setAttribute(\"displaystyle\", \"false\");\n    label.setAttribute(\"scriptlevel\", \"1\");\n    return label;\n  }\n\n});\ndefineFunction({\n  type: \"cdlabelparent\",\n  names: [\"\\\\\\\\cdparent\"],\n  props: {\n    numArgs: 1\n  },\n\n  handler(_ref2, args) {\n    var {\n      parser\n    } = _ref2;\n    return {\n      type: \"cdlabelparent\",\n      mode: parser.mode,\n      fragment: args[0]\n    };\n  },\n\n  htmlBuilder(group, options) {\n    // Wrap the vertical arrow and its labels.\n    // The parent gets position: relative. The child gets position: absolute.\n    // So CSS can locate the label correctly.\n    var parent = buildCommon.wrapFragment(buildGroup$1(group.fragment, options), options);\n    parent.classes.push(\"cd-vert-arrow\");\n    return parent;\n  },\n\n  mathmlBuilder(group, options) {\n    return new mathMLTree.MathNode(\"mrow\", [buildGroup(group.fragment, options)]);\n  }\n\n});\n\n// {123} and converts into symbol with code 123.  It is used by the *macro*\n// \\char defined in macros.js.\n\ndefineFunction({\n  type: \"textord\",\n  names: [\"\\\\@char\"],\n  props: {\n    numArgs: 1,\n    allowedInText: true\n  },\n\n  handler(_ref, args) {\n    var {\n      parser\n    } = _ref;\n    var arg = assertNodeType(args[0], \"ordgroup\");\n    var group = arg.body;\n    var number = \"\";\n\n    for (var i = 0; i < group.length; i++) {\n      var node = assertNodeType(group[i], \"textord\");\n      number += node.text;\n    }\n\n    var code = parseInt(number);\n    var text;\n\n    if (isNaN(code)) {\n      throw new ParseError(\"\\\\@char has non-numeric argument \" + number); // If we drop IE support, the following code could be replaced with\n      // text = String.fromCodePoint(code)\n    } else if (code < 0 || code >= 0x10ffff) {\n      throw new ParseError(\"\\\\@char with invalid code point \" + number);\n    } else if (code <= 0xffff) {\n      text = String.fromCharCode(code);\n    } else {\n      // Astral code point; split into surrogate halves\n      code -= 0x10000;\n      text = String.fromCharCode((code >> 10) + 0xd800, (code & 0x3ff) + 0xdc00);\n    }\n\n    return {\n      type: \"textord\",\n      mode: parser.mode,\n      text: text\n    };\n  }\n\n});\n\nvar htmlBuilder$8 = (group, options) => {\n  var elements = buildExpression$1(group.body, options.withColor(group.color), false); // \\color isn't supposed to affect the type of the elements it contains.\n  // To accomplish this, we wrap the results in a fragment, so the inner\n  // elements will be able to directly interact with their neighbors. For\n  // example, `\\color{red}{2 +} 3` has the same spacing as `2 + 3`\n\n  return buildCommon.makeFragment(elements);\n};\n\nvar mathmlBuilder$7 = (group, options) => {\n  var inner = buildExpression(group.body, options.withColor(group.color));\n  var node = new mathMLTree.MathNode(\"mstyle\", inner);\n  node.setAttribute(\"mathcolor\", group.color);\n  return node;\n};\n\ndefineFunction({\n  type: \"color\",\n  names: [\"\\\\textcolor\"],\n  props: {\n    numArgs: 2,\n    allowedInText: true,\n    argTypes: [\"color\", \"original\"]\n  },\n\n  handler(_ref, args) {\n    var {\n      parser\n    } = _ref;\n    var color = assertNodeType(args[0], \"color-token\").color;\n    var body = args[1];\n    return {\n      type: \"color\",\n      mode: parser.mode,\n      color,\n      body: ordargument(body)\n    };\n  },\n\n  htmlBuilder: htmlBuilder$8,\n  mathmlBuilder: mathmlBuilder$7\n});\ndefineFunction({\n  type: \"color\",\n  names: [\"\\\\color\"],\n  props: {\n    numArgs: 1,\n    allowedInText: true,\n    argTypes: [\"color\"]\n  },\n\n  handler(_ref2, args) {\n    var {\n      parser,\n      breakOnTokenText\n    } = _ref2;\n    var color = assertNodeType(args[0], \"color-token\").color; // Set macro \\current@color in current namespace to store the current\n    // color, mimicking the behavior of color.sty.\n    // This is currently used just to correctly color a \\right\n    // that follows a \\color command.\n\n    parser.gullet.macros.set(\"\\\\current@color\", color); // Parse out the implicit body that should be colored.\n\n    var body = parser.parseExpression(true, breakOnTokenText);\n    return {\n      type: \"color\",\n      mode: parser.mode,\n      color,\n      body\n    };\n  },\n\n  htmlBuilder: htmlBuilder$8,\n  mathmlBuilder: mathmlBuilder$7\n});\n\n// Row breaks within tabular environments, and line breaks at top level\n\ndefineFunction({\n  type: \"cr\",\n  names: [\"\\\\\\\\\"],\n  props: {\n    numArgs: 0,\n    numOptionalArgs: 0,\n    allowedInText: true\n  },\n\n  handler(_ref, args, optArgs) {\n    var {\n      parser\n    } = _ref;\n    var size = parser.gullet.future().text === \"[\" ? parser.parseSizeGroup(true) : null;\n    var newLine = !parser.settings.displayMode || !parser.settings.useStrictBehavior(\"newLineInDisplayMode\", \"In LaTeX, \\\\\\\\ or \\\\newline \" + \"does nothing in display mode\");\n    return {\n      type: \"cr\",\n      mode: parser.mode,\n      newLine,\n      size: size && assertNodeType(size, \"size\").value\n    };\n  },\n\n  // The following builders are called only at the top level,\n  // not within tabular/array environments.\n  htmlBuilder(group, options) {\n    var span = buildCommon.makeSpan([\"mspace\"], [], options);\n\n    if (group.newLine) {\n      span.classes.push(\"newline\");\n\n      if (group.size) {\n        span.style.marginTop = makeEm(calculateSize(group.size, options));\n      }\n    }\n\n    return span;\n  },\n\n  mathmlBuilder(group, options) {\n    var node = new mathMLTree.MathNode(\"mspace\");\n\n    if (group.newLine) {\n      node.setAttribute(\"linebreak\", \"newline\");\n\n      if (group.size) {\n        node.setAttribute(\"height\", makeEm(calculateSize(group.size, options)));\n      }\n    }\n\n    return node;\n  }\n\n});\n\nvar globalMap = {\n  \"\\\\global\": \"\\\\global\",\n  \"\\\\long\": \"\\\\\\\\globallong\",\n  \"\\\\\\\\globallong\": \"\\\\\\\\globallong\",\n  \"\\\\def\": \"\\\\gdef\",\n  \"\\\\gdef\": \"\\\\gdef\",\n  \"\\\\edef\": \"\\\\xdef\",\n  \"\\\\xdef\": \"\\\\xdef\",\n  \"\\\\let\": \"\\\\\\\\globallet\",\n  \"\\\\futurelet\": \"\\\\\\\\globalfuture\"\n};\n\nvar checkControlSequence = tok => {\n  var name = tok.text;\n\n  if (/^(?:[\\\\{}$&#^_]|EOF)$/.test(name)) {\n    throw new ParseError(\"Expected a control sequence\", tok);\n  }\n\n  return name;\n};\n\nvar getRHS = parser => {\n  var tok = parser.gullet.popToken();\n\n  if (tok.text === \"=\") {\n    // consume optional equals\n    tok = parser.gullet.popToken();\n\n    if (tok.text === \" \") {\n      // consume one optional space\n      tok = parser.gullet.popToken();\n    }\n  }\n\n  return tok;\n};\n\nvar letCommand = (parser, name, tok, global) => {\n  var macro = parser.gullet.macros.get(tok.text);\n\n  if (macro == null) {\n    // don't expand it later even if a macro with the same name is defined\n    // e.g., \\let\\foo=\\frac \\def\\frac{\\relax} \\frac12\n    tok.noexpand = true;\n    macro = {\n      tokens: [tok],\n      numArgs: 0,\n      // reproduce the same behavior in expansion\n      unexpandable: !parser.gullet.isExpandable(tok.text)\n    };\n  }\n\n  parser.gullet.macros.set(name, macro, global);\n}; // <assignment> -> <non-macro assignment>|<macro assignment>\n// <non-macro assignment> -> <simple assignment>|\\global<non-macro assignment>\n// <macro assignment> -> <definition>|<prefix><macro assignment>\n// <prefix> -> \\global|\\long|\\outer\n\n\ndefineFunction({\n  type: \"internal\",\n  names: [\"\\\\global\", \"\\\\long\", \"\\\\\\\\globallong\" // can’t be entered directly\n  ],\n  props: {\n    numArgs: 0,\n    allowedInText: true\n  },\n\n  handler(_ref) {\n    var {\n      parser,\n      funcName\n    } = _ref;\n    parser.consumeSpaces();\n    var token = parser.fetch();\n\n    if (globalMap[token.text]) {\n      // KaTeX doesn't have \\par, so ignore \\long\n      if (funcName === \"\\\\global\" || funcName === \"\\\\\\\\globallong\") {\n        token.text = globalMap[token.text];\n      }\n\n      return assertNodeType(parser.parseFunction(), \"internal\");\n    }\n\n    throw new ParseError(\"Invalid token after macro prefix\", token);\n  }\n\n}); // Basic support for macro definitions: \\def, \\gdef, \\edef, \\xdef\n// <definition> -> <def><control sequence><definition text>\n// <def> -> \\def|\\gdef|\\edef|\\xdef\n// <definition text> -> <parameter text><left brace><balanced text><right brace>\n\ndefineFunction({\n  type: \"internal\",\n  names: [\"\\\\def\", \"\\\\gdef\", \"\\\\edef\", \"\\\\xdef\"],\n  props: {\n    numArgs: 0,\n    allowedInText: true,\n    primitive: true\n  },\n\n  handler(_ref2) {\n    var {\n      parser,\n      funcName\n    } = _ref2;\n    var tok = parser.gullet.popToken();\n    var name = tok.text;\n\n    if (/^(?:[\\\\{}$&#^_]|EOF)$/.test(name)) {\n      throw new ParseError(\"Expected a control sequence\", tok);\n    }\n\n    var numArgs = 0;\n    var insert;\n    var delimiters = [[]]; // <parameter text> contains no braces\n\n    while (parser.gullet.future().text !== \"{\") {\n      tok = parser.gullet.popToken();\n\n      if (tok.text === \"#\") {\n        // If the very last character of the <parameter text> is #, so that\n        // this # is immediately followed by {, TeX will behave as if the {\n        // had been inserted at the right end of both the parameter text\n        // and the replacement text.\n        if (parser.gullet.future().text === \"{\") {\n          insert = parser.gullet.future();\n          delimiters[numArgs].push(\"{\");\n          break;\n        } // A parameter, the first appearance of # must be followed by 1,\n        // the next by 2, and so on; up to nine #’s are allowed\n\n\n        tok = parser.gullet.popToken();\n\n        if (!/^[1-9]$/.test(tok.text)) {\n          throw new ParseError(\"Invalid argument number \\\"\" + tok.text + \"\\\"\");\n        }\n\n        if (parseInt(tok.text) !== numArgs + 1) {\n          throw new ParseError(\"Argument number \\\"\" + tok.text + \"\\\" out of order\");\n        }\n\n        numArgs++;\n        delimiters.push([]);\n      } else if (tok.text === \"EOF\") {\n        throw new ParseError(\"Expected a macro definition\");\n      } else {\n        delimiters[numArgs].push(tok.text);\n      }\n    } // replacement text, enclosed in '{' and '}' and properly nested\n\n\n    var {\n      tokens\n    } = parser.gullet.consumeArg();\n\n    if (insert) {\n      tokens.unshift(insert);\n    }\n\n    if (funcName === \"\\\\edef\" || funcName === \"\\\\xdef\") {\n      tokens = parser.gullet.expandTokens(tokens);\n      tokens.reverse(); // to fit in with stack order\n    } // Final arg is the expansion of the macro\n\n\n    parser.gullet.macros.set(name, {\n      tokens,\n      numArgs,\n      delimiters\n    }, funcName === globalMap[funcName]);\n    return {\n      type: \"internal\",\n      mode: parser.mode\n    };\n  }\n\n}); // <simple assignment> -> <let assignment>\n// <let assignment> -> \\futurelet<control sequence><token><token>\n//     | \\let<control sequence><equals><one optional space><token>\n// <equals> -> <optional spaces>|<optional spaces>=\n\ndefineFunction({\n  type: \"internal\",\n  names: [\"\\\\let\", \"\\\\\\\\globallet\" // can’t be entered directly\n  ],\n  props: {\n    numArgs: 0,\n    allowedInText: true,\n    primitive: true\n  },\n\n  handler(_ref3) {\n    var {\n      parser,\n      funcName\n    } = _ref3;\n    var name = checkControlSequence(parser.gullet.popToken());\n    parser.gullet.consumeSpaces();\n    var tok = getRHS(parser);\n    letCommand(parser, name, tok, funcName === \"\\\\\\\\globallet\");\n    return {\n      type: \"internal\",\n      mode: parser.mode\n    };\n  }\n\n}); // ref: https://www.tug.org/TUGboat/tb09-3/tb22bechtolsheim.pdf\n\ndefineFunction({\n  type: \"internal\",\n  names: [\"\\\\futurelet\", \"\\\\\\\\globalfuture\" // can’t be entered directly\n  ],\n  props: {\n    numArgs: 0,\n    allowedInText: true,\n    primitive: true\n  },\n\n  handler(_ref4) {\n    var {\n      parser,\n      funcName\n    } = _ref4;\n    var name = checkControlSequence(parser.gullet.popToken());\n    var middle = parser.gullet.popToken();\n    var tok = parser.gullet.popToken();\n    letCommand(parser, name, tok, funcName === \"\\\\\\\\globalfuture\");\n    parser.gullet.pushToken(tok);\n    parser.gullet.pushToken(middle);\n    return {\n      type: \"internal\",\n      mode: parser.mode\n    };\n  }\n\n});\n\n/**\n * This file deals with creating delimiters of various sizes. The TeXbook\n * discusses these routines on page 441-442, in the \"Another subroutine sets box\n * x to a specified variable delimiter\" paragraph.\n *\n * There are three main routines here. `makeSmallDelim` makes a delimiter in the\n * normal font, but in either text, script, or scriptscript style.\n * `makeLargeDelim` makes a delimiter in textstyle, but in one of the Size1,\n * Size2, Size3, or Size4 fonts. `makeStackedDelim` makes a delimiter out of\n * smaller pieces that are stacked on top of one another.\n *\n * The functions take a parameter `center`, which determines if the delimiter\n * should be centered around the axis.\n *\n * Then, there are three exposed functions. `sizedDelim` makes a delimiter in\n * one of the given sizes. This is used for things like `\\bigl`.\n * `customSizedDelim` makes a delimiter with a given total height+depth. It is\n * called in places like `\\sqrt`. `leftRightDelim` makes an appropriate\n * delimiter which surrounds an expression of a given height an depth. It is\n * used in `\\left` and `\\right`.\n */\n\n/**\n * Get the metrics for a given symbol and font, after transformation (i.e.\n * after following replacement from symbols.js)\n */\nvar getMetrics = function getMetrics(symbol, font, mode) {\n  var replace = symbols.math[symbol] && symbols.math[symbol].replace;\n  var metrics = getCharacterMetrics(replace || symbol, font, mode);\n\n  if (!metrics) {\n    throw new Error(\"Unsupported symbol \" + symbol + \" and font size \" + font + \".\");\n  }\n\n  return metrics;\n};\n/**\n * Puts a delimiter span in a given style, and adds appropriate height, depth,\n * and maxFontSizes.\n */\n\n\nvar styleWrap = function styleWrap(delim, toStyle, options, classes) {\n  var newOptions = options.havingBaseStyle(toStyle);\n  var span = buildCommon.makeSpan(classes.concat(newOptions.sizingClasses(options)), [delim], options);\n  var delimSizeMultiplier = newOptions.sizeMultiplier / options.sizeMultiplier;\n  span.height *= delimSizeMultiplier;\n  span.depth *= delimSizeMultiplier;\n  span.maxFontSize = newOptions.sizeMultiplier;\n  return span;\n};\n\nvar centerSpan = function centerSpan(span, options, style) {\n  var newOptions = options.havingBaseStyle(style);\n  var shift = (1 - options.sizeMultiplier / newOptions.sizeMultiplier) * options.fontMetrics().axisHeight;\n  span.classes.push(\"delimcenter\");\n  span.style.top = makeEm(shift);\n  span.height -= shift;\n  span.depth += shift;\n};\n/**\n * Makes a small delimiter. This is a delimiter that comes in the Main-Regular\n * font, but is restyled to either be in textstyle, scriptstyle, or\n * scriptscriptstyle.\n */\n\n\nvar makeSmallDelim = function makeSmallDelim(delim, style, center, options, mode, classes) {\n  var text = buildCommon.makeSymbol(delim, \"Main-Regular\", mode, options);\n  var span = styleWrap(text, style, options, classes);\n\n  if (center) {\n    centerSpan(span, options, style);\n  }\n\n  return span;\n};\n/**\n * Builds a symbol in the given font size (note size is an integer)\n */\n\n\nvar mathrmSize = function mathrmSize(value, size, mode, options) {\n  return buildCommon.makeSymbol(value, \"Size\" + size + \"-Regular\", mode, options);\n};\n/**\n * Makes a large delimiter. This is a delimiter that comes in the Size1, Size2,\n * Size3, or Size4 fonts. It is always rendered in textstyle.\n */\n\n\nvar makeLargeDelim = function makeLargeDelim(delim, size, center, options, mode, classes) {\n  var inner = mathrmSize(delim, size, mode, options);\n  var span = styleWrap(buildCommon.makeSpan([\"delimsizing\", \"size\" + size], [inner], options), Style$1.TEXT, options, classes);\n\n  if (center) {\n    centerSpan(span, options, Style$1.TEXT);\n  }\n\n  return span;\n};\n/**\n * Make a span from a font glyph with the given offset and in the given font.\n * This is used in makeStackedDelim to make the stacking pieces for the delimiter.\n */\n\n\nvar makeGlyphSpan = function makeGlyphSpan(symbol, font, mode) {\n  var sizeClass; // Apply the correct CSS class to choose the right font.\n\n  if (font === \"Size1-Regular\") {\n    sizeClass = \"delim-size1\";\n  } else\n    /* if (font === \"Size4-Regular\") */\n    {\n      sizeClass = \"delim-size4\";\n    }\n\n  var corner = buildCommon.makeSpan([\"delimsizinginner\", sizeClass], [buildCommon.makeSpan([], [buildCommon.makeSymbol(symbol, font, mode)])]); // Since this will be passed into `makeVList` in the end, wrap the element\n  // in the appropriate tag that VList uses.\n\n  return {\n    type: \"elem\",\n    elem: corner\n  };\n};\n\nvar makeInner = function makeInner(ch, height, options) {\n  // Create a span with inline SVG for the inner part of a tall stacked delimiter.\n  var width = fontMetricsData['Size4-Regular'][ch.charCodeAt(0)] ? fontMetricsData['Size4-Regular'][ch.charCodeAt(0)][4] : fontMetricsData['Size1-Regular'][ch.charCodeAt(0)][4];\n  var path = new PathNode(\"inner\", innerPath(ch, Math.round(1000 * height)));\n  var svgNode = new SvgNode([path], {\n    \"width\": makeEm(width),\n    \"height\": makeEm(height),\n    // Override CSS rule `.katex svg { width: 100% }`\n    \"style\": \"width:\" + makeEm(width),\n    \"viewBox\": \"0 0 \" + 1000 * width + \" \" + Math.round(1000 * height),\n    \"preserveAspectRatio\": \"xMinYMin\"\n  });\n  var span = buildCommon.makeSvgSpan([], [svgNode], options);\n  span.height = height;\n  span.style.height = makeEm(height);\n  span.style.width = makeEm(width);\n  return {\n    type: \"elem\",\n    elem: span\n  };\n}; // Helpers for makeStackedDelim\n\n\nvar lapInEms = 0.008;\nvar lap = {\n  type: \"kern\",\n  size: -1 * lapInEms\n};\nvar verts = [\"|\", \"\\\\lvert\", \"\\\\rvert\", \"\\\\vert\"];\nvar doubleVerts = [\"\\\\|\", \"\\\\lVert\", \"\\\\rVert\", \"\\\\Vert\"];\n/**\n * Make a stacked delimiter out of a given delimiter, with the total height at\n * least `heightTotal`. This routine is mentioned on page 442 of the TeXbook.\n */\n\nvar makeStackedDelim = function makeStackedDelim(delim, heightTotal, center, options, mode, classes) {\n  // There are four parts, the top, an optional middle, a repeated part, and a\n  // bottom.\n  var top;\n  var middle;\n  var repeat;\n  var bottom;\n  var svgLabel = \"\";\n  var viewBoxWidth = 0;\n  top = repeat = bottom = delim;\n  middle = null; // Also keep track of what font the delimiters are in\n\n  var font = \"Size1-Regular\"; // We set the parts and font based on the symbol. Note that we use\n  // '\\u23d0' instead of '|' and '\\u2016' instead of '\\\\|' for the\n  // repeats of the arrows\n\n  if (delim === \"\\\\uparrow\") {\n    repeat = bottom = \"\\u23d0\";\n  } else if (delim === \"\\\\Uparrow\") {\n    repeat = bottom = \"\\u2016\";\n  } else if (delim === \"\\\\downarrow\") {\n    top = repeat = \"\\u23d0\";\n  } else if (delim === \"\\\\Downarrow\") {\n    top = repeat = \"\\u2016\";\n  } else if (delim === \"\\\\updownarrow\") {\n    top = \"\\\\uparrow\";\n    repeat = \"\\u23d0\";\n    bottom = \"\\\\downarrow\";\n  } else if (delim === \"\\\\Updownarrow\") {\n    top = \"\\\\Uparrow\";\n    repeat = \"\\u2016\";\n    bottom = \"\\\\Downarrow\";\n  } else if (utils.contains(verts, delim)) {\n    repeat = \"\\u2223\";\n    svgLabel = \"vert\";\n    viewBoxWidth = 333;\n  } else if (utils.contains(doubleVerts, delim)) {\n    repeat = \"\\u2225\";\n    svgLabel = \"doublevert\";\n    viewBoxWidth = 556;\n  } else if (delim === \"[\" || delim === \"\\\\lbrack\") {\n    top = \"\\u23a1\";\n    repeat = \"\\u23a2\";\n    bottom = \"\\u23a3\";\n    font = \"Size4-Regular\";\n    svgLabel = \"lbrack\";\n    viewBoxWidth = 667;\n  } else if (delim === \"]\" || delim === \"\\\\rbrack\") {\n    top = \"\\u23a4\";\n    repeat = \"\\u23a5\";\n    bottom = \"\\u23a6\";\n    font = \"Size4-Regular\";\n    svgLabel = \"rbrack\";\n    viewBoxWidth = 667;\n  } else if (delim === \"\\\\lfloor\" || delim === \"\\u230a\") {\n    repeat = top = \"\\u23a2\";\n    bottom = \"\\u23a3\";\n    font = \"Size4-Regular\";\n    svgLabel = \"lfloor\";\n    viewBoxWidth = 667;\n  } else if (delim === \"\\\\lceil\" || delim === \"\\u2308\") {\n    top = \"\\u23a1\";\n    repeat = bottom = \"\\u23a2\";\n    font = \"Size4-Regular\";\n    svgLabel = \"lceil\";\n    viewBoxWidth = 667;\n  } else if (delim === \"\\\\rfloor\" || delim === \"\\u230b\") {\n    repeat = top = \"\\u23a5\";\n    bottom = \"\\u23a6\";\n    font = \"Size4-Regular\";\n    svgLabel = \"rfloor\";\n    viewBoxWidth = 667;\n  } else if (delim === \"\\\\rceil\" || delim === \"\\u2309\") {\n    top = \"\\u23a4\";\n    repeat = bottom = \"\\u23a5\";\n    font = \"Size4-Regular\";\n    svgLabel = \"rceil\";\n    viewBoxWidth = 667;\n  } else if (delim === \"(\" || delim === \"\\\\lparen\") {\n    top = \"\\u239b\";\n    repeat = \"\\u239c\";\n    bottom = \"\\u239d\";\n    font = \"Size4-Regular\";\n    svgLabel = \"lparen\";\n    viewBoxWidth = 875;\n  } else if (delim === \")\" || delim === \"\\\\rparen\") {\n    top = \"\\u239e\";\n    repeat = \"\\u239f\";\n    bottom = \"\\u23a0\";\n    font = \"Size4-Regular\";\n    svgLabel = \"rparen\";\n    viewBoxWidth = 875;\n  } else if (delim === \"\\\\{\" || delim === \"\\\\lbrace\") {\n    top = \"\\u23a7\";\n    middle = \"\\u23a8\";\n    bottom = \"\\u23a9\";\n    repeat = \"\\u23aa\";\n    font = \"Size4-Regular\";\n  } else if (delim === \"\\\\}\" || delim === \"\\\\rbrace\") {\n    top = \"\\u23ab\";\n    middle = \"\\u23ac\";\n    bottom = \"\\u23ad\";\n    repeat = \"\\u23aa\";\n    font = \"Size4-Regular\";\n  } else if (delim === \"\\\\lgroup\" || delim === \"\\u27ee\") {\n    top = \"\\u23a7\";\n    bottom = \"\\u23a9\";\n    repeat = \"\\u23aa\";\n    font = \"Size4-Regular\";\n  } else if (delim === \"\\\\rgroup\" || delim === \"\\u27ef\") {\n    top = \"\\u23ab\";\n    bottom = \"\\u23ad\";\n    repeat = \"\\u23aa\";\n    font = \"Size4-Regular\";\n  } else if (delim === \"\\\\lmoustache\" || delim === \"\\u23b0\") {\n    top = \"\\u23a7\";\n    bottom = \"\\u23ad\";\n    repeat = \"\\u23aa\";\n    font = \"Size4-Regular\";\n  } else if (delim === \"\\\\rmoustache\" || delim === \"\\u23b1\") {\n    top = \"\\u23ab\";\n    bottom = \"\\u23a9\";\n    repeat = \"\\u23aa\";\n    font = \"Size4-Regular\";\n  } // Get the metrics of the four sections\n\n\n  var topMetrics = getMetrics(top, font, mode);\n  var topHeightTotal = topMetrics.height + topMetrics.depth;\n  var repeatMetrics = getMetrics(repeat, font, mode);\n  var repeatHeightTotal = repeatMetrics.height + repeatMetrics.depth;\n  var bottomMetrics = getMetrics(bottom, font, mode);\n  var bottomHeightTotal = bottomMetrics.height + bottomMetrics.depth;\n  var middleHeightTotal = 0;\n  var middleFactor = 1;\n\n  if (middle !== null) {\n    var middleMetrics = getMetrics(middle, font, mode);\n    middleHeightTotal = middleMetrics.height + middleMetrics.depth;\n    middleFactor = 2; // repeat symmetrically above and below middle\n  } // Calculate the minimal height that the delimiter can have.\n  // It is at least the size of the top, bottom, and optional middle combined.\n\n\n  var minHeight = topHeightTotal + bottomHeightTotal + middleHeightTotal; // Compute the number of copies of the repeat symbol we will need\n\n  var repeatCount = Math.max(0, Math.ceil((heightTotal - minHeight) / (middleFactor * repeatHeightTotal))); // Compute the total height of the delimiter including all the symbols\n\n  var realHeightTotal = minHeight + repeatCount * middleFactor * repeatHeightTotal; // The center of the delimiter is placed at the center of the axis. Note\n  // that in this context, \"center\" means that the delimiter should be\n  // centered around the axis in the current style, while normally it is\n  // centered around the axis in textstyle.\n\n  var axisHeight = options.fontMetrics().axisHeight;\n\n  if (center) {\n    axisHeight *= options.sizeMultiplier;\n  } // Calculate the depth\n\n\n  var depth = realHeightTotal / 2 - axisHeight; // Now, we start building the pieces that will go into the vlist\n  // Keep a list of the pieces of the stacked delimiter\n\n  var stack = [];\n\n  if (svgLabel.length > 0) {\n    // Instead of stacking glyphs, create a single SVG.\n    // This evades browser problems with imprecise positioning of spans.\n    var midHeight = realHeightTotal - topHeightTotal - bottomHeightTotal;\n    var viewBoxHeight = Math.round(realHeightTotal * 1000);\n    var pathStr = tallDelim(svgLabel, Math.round(midHeight * 1000));\n    var path = new PathNode(svgLabel, pathStr);\n    var width = (viewBoxWidth / 1000).toFixed(3) + \"em\";\n    var height = (viewBoxHeight / 1000).toFixed(3) + \"em\";\n    var svg = new SvgNode([path], {\n      \"width\": width,\n      \"height\": height,\n      \"viewBox\": \"0 0 \" + viewBoxWidth + \" \" + viewBoxHeight\n    });\n    var wrapper = buildCommon.makeSvgSpan([], [svg], options);\n    wrapper.height = viewBoxHeight / 1000;\n    wrapper.style.width = width;\n    wrapper.style.height = height;\n    stack.push({\n      type: \"elem\",\n      elem: wrapper\n    });\n  } else {\n    // Stack glyphs\n    // Start by adding the bottom symbol\n    stack.push(makeGlyphSpan(bottom, font, mode));\n    stack.push(lap); // overlap\n\n    if (middle === null) {\n      // The middle section will be an SVG. Make it an extra 0.016em tall.\n      // We'll overlap by 0.008em at top and bottom.\n      var innerHeight = realHeightTotal - topHeightTotal - bottomHeightTotal + 2 * lapInEms;\n      stack.push(makeInner(repeat, innerHeight, options));\n    } else {\n      // When there is a middle bit, we need the middle part and two repeated\n      // sections\n      var _innerHeight = (realHeightTotal - topHeightTotal - bottomHeightTotal - middleHeightTotal) / 2 + 2 * lapInEms;\n\n      stack.push(makeInner(repeat, _innerHeight, options)); // Now insert the middle of the brace.\n\n      stack.push(lap);\n      stack.push(makeGlyphSpan(middle, font, mode));\n      stack.push(lap);\n      stack.push(makeInner(repeat, _innerHeight, options));\n    } // Add the top symbol\n\n\n    stack.push(lap);\n    stack.push(makeGlyphSpan(top, font, mode));\n  } // Finally, build the vlist\n\n\n  var newOptions = options.havingBaseStyle(Style$1.TEXT);\n  var inner = buildCommon.makeVList({\n    positionType: \"bottom\",\n    positionData: depth,\n    children: stack\n  }, newOptions);\n  return styleWrap(buildCommon.makeSpan([\"delimsizing\", \"mult\"], [inner], newOptions), Style$1.TEXT, options, classes);\n}; // All surds have 0.08em padding above the vinculum inside the SVG.\n// That keeps browser span height rounding error from pinching the line.\n\n\nvar vbPad = 80; // padding above the surd, measured inside the viewBox.\n\nvar emPad = 0.08; // padding, in ems, measured in the document.\n\nvar sqrtSvg = function sqrtSvg(sqrtName, height, viewBoxHeight, extraVinculum, options) {\n  var path = sqrtPath(sqrtName, extraVinculum, viewBoxHeight);\n  var pathNode = new PathNode(sqrtName, path);\n  var svg = new SvgNode([pathNode], {\n    // Note: 1000:1 ratio of viewBox to document em width.\n    \"width\": \"400em\",\n    \"height\": makeEm(height),\n    \"viewBox\": \"0 0 400000 \" + viewBoxHeight,\n    \"preserveAspectRatio\": \"xMinYMin slice\"\n  });\n  return buildCommon.makeSvgSpan([\"hide-tail\"], [svg], options);\n};\n/**\n * Make a sqrt image of the given height,\n */\n\n\nvar makeSqrtImage = function makeSqrtImage(height, options) {\n  // Define a newOptions that removes the effect of size changes such as \\Huge.\n  // We don't pick different a height surd for \\Huge. For it, we scale up.\n  var newOptions = options.havingBaseSizing(); // Pick the desired surd glyph from a sequence of surds.\n\n  var delim = traverseSequence(\"\\\\surd\", height * newOptions.sizeMultiplier, stackLargeDelimiterSequence, newOptions);\n  var sizeMultiplier = newOptions.sizeMultiplier; // default\n  // The standard sqrt SVGs each have a 0.04em thick vinculum.\n  // If Settings.minRuleThickness is larger than that, we add extraVinculum.\n\n  var extraVinculum = Math.max(0, options.minRuleThickness - options.fontMetrics().sqrtRuleThickness); // Create a span containing an SVG image of a sqrt symbol.\n\n  var span;\n  var spanHeight = 0;\n  var texHeight = 0;\n  var viewBoxHeight = 0;\n  var advanceWidth; // We create viewBoxes with 80 units of \"padding\" above each surd.\n  // Then browser rounding error on the parent span height will not\n  // encroach on the ink of the vinculum. But that padding is not\n  // included in the TeX-like `height` used for calculation of\n  // vertical alignment. So texHeight = span.height < span.style.height.\n\n  if (delim.type === \"small\") {\n    // Get an SVG that is derived from glyph U+221A in font KaTeX-Main.\n    // 1000 unit normal glyph height.\n    viewBoxHeight = 1000 + 1000 * extraVinculum + vbPad;\n\n    if (height < 1.0) {\n      sizeMultiplier = 1.0; // mimic a \\textfont radical\n    } else if (height < 1.4) {\n      sizeMultiplier = 0.7; // mimic a \\scriptfont radical\n    }\n\n    spanHeight = (1.0 + extraVinculum + emPad) / sizeMultiplier;\n    texHeight = (1.00 + extraVinculum) / sizeMultiplier;\n    span = sqrtSvg(\"sqrtMain\", spanHeight, viewBoxHeight, extraVinculum, options);\n    span.style.minWidth = \"0.853em\";\n    advanceWidth = 0.833 / sizeMultiplier; // from the font.\n  } else if (delim.type === \"large\") {\n    // These SVGs come from fonts: KaTeX_Size1, _Size2, etc.\n    viewBoxHeight = (1000 + vbPad) * sizeToMaxHeight[delim.size];\n    texHeight = (sizeToMaxHeight[delim.size] + extraVinculum) / sizeMultiplier;\n    spanHeight = (sizeToMaxHeight[delim.size] + extraVinculum + emPad) / sizeMultiplier;\n    span = sqrtSvg(\"sqrtSize\" + delim.size, spanHeight, viewBoxHeight, extraVinculum, options);\n    span.style.minWidth = \"1.02em\";\n    advanceWidth = 1.0 / sizeMultiplier; // 1.0 from the font.\n  } else {\n    // Tall sqrt. In TeX, this would be stacked using multiple glyphs.\n    // We'll use a single SVG to accomplish the same thing.\n    spanHeight = height + extraVinculum + emPad;\n    texHeight = height + extraVinculum;\n    viewBoxHeight = Math.floor(1000 * height + extraVinculum) + vbPad;\n    span = sqrtSvg(\"sqrtTall\", spanHeight, viewBoxHeight, extraVinculum, options);\n    span.style.minWidth = \"0.742em\";\n    advanceWidth = 1.056;\n  }\n\n  span.height = texHeight;\n  span.style.height = makeEm(spanHeight);\n  return {\n    span,\n    advanceWidth,\n    // Calculate the actual line width.\n    // This actually should depend on the chosen font -- e.g. \\boldmath\n    // should use the thicker surd symbols from e.g. KaTeX_Main-Bold, and\n    // have thicker rules.\n    ruleWidth: (options.fontMetrics().sqrtRuleThickness + extraVinculum) * sizeMultiplier\n  };\n}; // There are three kinds of delimiters, delimiters that stack when they become\n// too large\n\n\nvar stackLargeDelimiters = [\"(\", \"\\\\lparen\", \")\", \"\\\\rparen\", \"[\", \"\\\\lbrack\", \"]\", \"\\\\rbrack\", \"\\\\{\", \"\\\\lbrace\", \"\\\\}\", \"\\\\rbrace\", \"\\\\lfloor\", \"\\\\rfloor\", \"\\u230a\", \"\\u230b\", \"\\\\lceil\", \"\\\\rceil\", \"\\u2308\", \"\\u2309\", \"\\\\surd\"]; // delimiters that always stack\n\nvar stackAlwaysDelimiters = [\"\\\\uparrow\", \"\\\\downarrow\", \"\\\\updownarrow\", \"\\\\Uparrow\", \"\\\\Downarrow\", \"\\\\Updownarrow\", \"|\", \"\\\\|\", \"\\\\vert\", \"\\\\Vert\", \"\\\\lvert\", \"\\\\rvert\", \"\\\\lVert\", \"\\\\rVert\", \"\\\\lgroup\", \"\\\\rgroup\", \"\\u27ee\", \"\\u27ef\", \"\\\\lmoustache\", \"\\\\rmoustache\", \"\\u23b0\", \"\\u23b1\"]; // and delimiters that never stack\n\nvar stackNeverDelimiters = [\"<\", \">\", \"\\\\langle\", \"\\\\rangle\", \"/\", \"\\\\backslash\", \"\\\\lt\", \"\\\\gt\"]; // Metrics of the different sizes. Found by looking at TeX's output of\n// $\\bigl| // \\Bigl| \\biggl| \\Biggl| \\showlists$\n// Used to create stacked delimiters of appropriate sizes in makeSizedDelim.\n\nvar sizeToMaxHeight = [0, 1.2, 1.8, 2.4, 3.0];\n/**\n * Used to create a delimiter of a specific size, where `size` is 1, 2, 3, or 4.\n */\n\nvar makeSizedDelim = function makeSizedDelim(delim, size, options, mode, classes) {\n  // < and > turn into \\langle and \\rangle in delimiters\n  if (delim === \"<\" || delim === \"\\\\lt\" || delim === \"\\u27e8\") {\n    delim = \"\\\\langle\";\n  } else if (delim === \">\" || delim === \"\\\\gt\" || delim === \"\\u27e9\") {\n    delim = \"\\\\rangle\";\n  } // Sized delimiters are never centered.\n\n\n  if (utils.contains(stackLargeDelimiters, delim) || utils.contains(stackNeverDelimiters, delim)) {\n    return makeLargeDelim(delim, size, false, options, mode, classes);\n  } else if (utils.contains(stackAlwaysDelimiters, delim)) {\n    return makeStackedDelim(delim, sizeToMaxHeight[size], false, options, mode, classes);\n  } else {\n    throw new ParseError(\"Illegal delimiter: '\" + delim + \"'\");\n  }\n};\n/**\n * There are three different sequences of delimiter sizes that the delimiters\n * follow depending on the kind of delimiter. This is used when creating custom\n * sized delimiters to decide whether to create a small, large, or stacked\n * delimiter.\n *\n * In real TeX, these sequences aren't explicitly defined, but are instead\n * defined inside the font metrics. Since there are only three sequences that\n * are possible for the delimiters that TeX defines, it is easier to just encode\n * them explicitly here.\n */\n\n\n// Delimiters that never stack try small delimiters and large delimiters only\nvar stackNeverDelimiterSequence = [{\n  type: \"small\",\n  style: Style$1.SCRIPTSCRIPT\n}, {\n  type: \"small\",\n  style: Style$1.SCRIPT\n}, {\n  type: \"small\",\n  style: Style$1.TEXT\n}, {\n  type: \"large\",\n  size: 1\n}, {\n  type: \"large\",\n  size: 2\n}, {\n  type: \"large\",\n  size: 3\n}, {\n  type: \"large\",\n  size: 4\n}]; // Delimiters that always stack try the small delimiters first, then stack\n\nvar stackAlwaysDelimiterSequence = [{\n  type: \"small\",\n  style: Style$1.SCRIPTSCRIPT\n}, {\n  type: \"small\",\n  style: Style$1.SCRIPT\n}, {\n  type: \"small\",\n  style: Style$1.TEXT\n}, {\n  type: \"stack\"\n}]; // Delimiters that stack when large try the small and then large delimiters, and\n// stack afterwards\n\nvar stackLargeDelimiterSequence = [{\n  type: \"small\",\n  style: Style$1.SCRIPTSCRIPT\n}, {\n  type: \"small\",\n  style: Style$1.SCRIPT\n}, {\n  type: \"small\",\n  style: Style$1.TEXT\n}, {\n  type: \"large\",\n  size: 1\n}, {\n  type: \"large\",\n  size: 2\n}, {\n  type: \"large\",\n  size: 3\n}, {\n  type: \"large\",\n  size: 4\n}, {\n  type: \"stack\"\n}];\n/**\n * Get the font used in a delimiter based on what kind of delimiter it is.\n * TODO(#963) Use more specific font family return type once that is introduced.\n */\n\nvar delimTypeToFont = function delimTypeToFont(type) {\n  if (type.type === \"small\") {\n    return \"Main-Regular\";\n  } else if (type.type === \"large\") {\n    return \"Size\" + type.size + \"-Regular\";\n  } else if (type.type === \"stack\") {\n    return \"Size4-Regular\";\n  } else {\n    throw new Error(\"Add support for delim type '\" + type.type + \"' here.\");\n  }\n};\n/**\n * Traverse a sequence of types of delimiters to decide what kind of delimiter\n * should be used to create a delimiter of the given height+depth.\n */\n\n\nvar traverseSequence = function traverseSequence(delim, height, sequence, options) {\n  // Here, we choose the index we should start at in the sequences. In smaller\n  // sizes (which correspond to larger numbers in style.size) we start earlier\n  // in the sequence. Thus, scriptscript starts at index 3-3=0, script starts\n  // at index 3-2=1, text starts at 3-1=2, and display starts at min(2,3-0)=2\n  var start = Math.min(2, 3 - options.style.size);\n\n  for (var i = start; i < sequence.length; i++) {\n    if (sequence[i].type === \"stack\") {\n      // This is always the last delimiter, so we just break the loop now.\n      break;\n    }\n\n    var metrics = getMetrics(delim, delimTypeToFont(sequence[i]), \"math\");\n    var heightDepth = metrics.height + metrics.depth; // Small delimiters are scaled down versions of the same font, so we\n    // account for the style change size.\n\n    if (sequence[i].type === \"small\") {\n      var newOptions = options.havingBaseStyle(sequence[i].style);\n      heightDepth *= newOptions.sizeMultiplier;\n    } // Check if the delimiter at this size works for the given height.\n\n\n    if (heightDepth > height) {\n      return sequence[i];\n    }\n  } // If we reached the end of the sequence, return the last sequence element.\n\n\n  return sequence[sequence.length - 1];\n};\n/**\n * Make a delimiter of a given height+depth, with optional centering. Here, we\n * traverse the sequences, and create a delimiter that the sequence tells us to.\n */\n\n\nvar makeCustomSizedDelim = function makeCustomSizedDelim(delim, height, center, options, mode, classes) {\n  if (delim === \"<\" || delim === \"\\\\lt\" || delim === \"\\u27e8\") {\n    delim = \"\\\\langle\";\n  } else if (delim === \">\" || delim === \"\\\\gt\" || delim === \"\\u27e9\") {\n    delim = \"\\\\rangle\";\n  } // Decide what sequence to use\n\n\n  var sequence;\n\n  if (utils.contains(stackNeverDelimiters, delim)) {\n    sequence = stackNeverDelimiterSequence;\n  } else if (utils.contains(stackLargeDelimiters, delim)) {\n    sequence = stackLargeDelimiterSequence;\n  } else {\n    sequence = stackAlwaysDelimiterSequence;\n  } // Look through the sequence\n\n\n  var delimType = traverseSequence(delim, height, sequence, options); // Get the delimiter from font glyphs.\n  // Depending on the sequence element we decided on, call the\n  // appropriate function.\n\n  if (delimType.type === \"small\") {\n    return makeSmallDelim(delim, delimType.style, center, options, mode, classes);\n  } else if (delimType.type === \"large\") {\n    return makeLargeDelim(delim, delimType.size, center, options, mode, classes);\n  } else\n    /* if (delimType.type === \"stack\") */\n    {\n      return makeStackedDelim(delim, height, center, options, mode, classes);\n    }\n};\n/**\n * Make a delimiter for use with `\\left` and `\\right`, given a height and depth\n * of an expression that the delimiters surround.\n */\n\n\nvar makeLeftRightDelim = function makeLeftRightDelim(delim, height, depth, options, mode, classes) {\n  // We always center \\left/\\right delimiters, so the axis is always shifted\n  var axisHeight = options.fontMetrics().axisHeight * options.sizeMultiplier; // Taken from TeX source, tex.web, function make_left_right\n\n  var delimiterFactor = 901;\n  var delimiterExtend = 5.0 / options.fontMetrics().ptPerEm;\n  var maxDistFromAxis = Math.max(height - axisHeight, depth + axisHeight);\n  var totalHeight = Math.max( // In real TeX, calculations are done using integral values which are\n  // 65536 per pt, or 655360 per em. So, the division here truncates in\n  // TeX but doesn't here, producing different results. If we wanted to\n  // exactly match TeX's calculation, we could do\n  //   Math.floor(655360 * maxDistFromAxis / 500) *\n  //    delimiterFactor / 655360\n  // (To see the difference, compare\n  //    x^{x^{\\left(\\rule{0.1em}{0.68em}\\right)}}\n  // in TeX and KaTeX)\n  maxDistFromAxis / 500 * delimiterFactor, 2 * maxDistFromAxis - delimiterExtend); // Finally, we defer to `makeCustomSizedDelim` with our calculated total\n  // height\n\n  return makeCustomSizedDelim(delim, totalHeight, true, options, mode, classes);\n};\n\nvar delimiter = {\n  sqrtImage: makeSqrtImage,\n  sizedDelim: makeSizedDelim,\n  sizeToMaxHeight: sizeToMaxHeight,\n  customSizedDelim: makeCustomSizedDelim,\n  leftRightDelim: makeLeftRightDelim\n};\n\n// Extra data needed for the delimiter handler down below\nvar delimiterSizes = {\n  \"\\\\bigl\": {\n    mclass: \"mopen\",\n    size: 1\n  },\n  \"\\\\Bigl\": {\n    mclass: \"mopen\",\n    size: 2\n  },\n  \"\\\\biggl\": {\n    mclass: \"mopen\",\n    size: 3\n  },\n  \"\\\\Biggl\": {\n    mclass: \"mopen\",\n    size: 4\n  },\n  \"\\\\bigr\": {\n    mclass: \"mclose\",\n    size: 1\n  },\n  \"\\\\Bigr\": {\n    mclass: \"mclose\",\n    size: 2\n  },\n  \"\\\\biggr\": {\n    mclass: \"mclose\",\n    size: 3\n  },\n  \"\\\\Biggr\": {\n    mclass: \"mclose\",\n    size: 4\n  },\n  \"\\\\bigm\": {\n    mclass: \"mrel\",\n    size: 1\n  },\n  \"\\\\Bigm\": {\n    mclass: \"mrel\",\n    size: 2\n  },\n  \"\\\\biggm\": {\n    mclass: \"mrel\",\n    size: 3\n  },\n  \"\\\\Biggm\": {\n    mclass: \"mrel\",\n    size: 4\n  },\n  \"\\\\big\": {\n    mclass: \"mord\",\n    size: 1\n  },\n  \"\\\\Big\": {\n    mclass: \"mord\",\n    size: 2\n  },\n  \"\\\\bigg\": {\n    mclass: \"mord\",\n    size: 3\n  },\n  \"\\\\Bigg\": {\n    mclass: \"mord\",\n    size: 4\n  }\n};\nvar delimiters = [\"(\", \"\\\\lparen\", \")\", \"\\\\rparen\", \"[\", \"\\\\lbrack\", \"]\", \"\\\\rbrack\", \"\\\\{\", \"\\\\lbrace\", \"\\\\}\", \"\\\\rbrace\", \"\\\\lfloor\", \"\\\\rfloor\", \"\\u230a\", \"\\u230b\", \"\\\\lceil\", \"\\\\rceil\", \"\\u2308\", \"\\u2309\", \"<\", \">\", \"\\\\langle\", \"\\u27e8\", \"\\\\rangle\", \"\\u27e9\", \"\\\\lt\", \"\\\\gt\", \"\\\\lvert\", \"\\\\rvert\", \"\\\\lVert\", \"\\\\rVert\", \"\\\\lgroup\", \"\\\\rgroup\", \"\\u27ee\", \"\\u27ef\", \"\\\\lmoustache\", \"\\\\rmoustache\", \"\\u23b0\", \"\\u23b1\", \"/\", \"\\\\backslash\", \"|\", \"\\\\vert\", \"\\\\|\", \"\\\\Vert\", \"\\\\uparrow\", \"\\\\Uparrow\", \"\\\\downarrow\", \"\\\\Downarrow\", \"\\\\updownarrow\", \"\\\\Updownarrow\", \".\"];\n\n// Delimiter functions\nfunction checkDelimiter(delim, context) {\n  var symDelim = checkSymbolNodeType(delim);\n\n  if (symDelim && utils.contains(delimiters, symDelim.text)) {\n    return symDelim;\n  } else if (symDelim) {\n    throw new ParseError(\"Invalid delimiter '\" + symDelim.text + \"' after '\" + context.funcName + \"'\", delim);\n  } else {\n    throw new ParseError(\"Invalid delimiter type '\" + delim.type + \"'\", delim);\n  }\n}\n\ndefineFunction({\n  type: \"delimsizing\",\n  names: [\"\\\\bigl\", \"\\\\Bigl\", \"\\\\biggl\", \"\\\\Biggl\", \"\\\\bigr\", \"\\\\Bigr\", \"\\\\biggr\", \"\\\\Biggr\", \"\\\\bigm\", \"\\\\Bigm\", \"\\\\biggm\", \"\\\\Biggm\", \"\\\\big\", \"\\\\Big\", \"\\\\bigg\", \"\\\\Bigg\"],\n  props: {\n    numArgs: 1,\n    argTypes: [\"primitive\"]\n  },\n  handler: (context, args) => {\n    var delim = checkDelimiter(args[0], context);\n    return {\n      type: \"delimsizing\",\n      mode: context.parser.mode,\n      size: delimiterSizes[context.funcName].size,\n      mclass: delimiterSizes[context.funcName].mclass,\n      delim: delim.text\n    };\n  },\n  htmlBuilder: (group, options) => {\n    if (group.delim === \".\") {\n      // Empty delimiters still count as elements, even though they don't\n      // show anything.\n      return buildCommon.makeSpan([group.mclass]);\n    } // Use delimiter.sizedDelim to generate the delimiter.\n\n\n    return delimiter.sizedDelim(group.delim, group.size, options, group.mode, [group.mclass]);\n  },\n  mathmlBuilder: group => {\n    var children = [];\n\n    if (group.delim !== \".\") {\n      children.push(makeText(group.delim, group.mode));\n    }\n\n    var node = new mathMLTree.MathNode(\"mo\", children);\n\n    if (group.mclass === \"mopen\" || group.mclass === \"mclose\") {\n      // Only some of the delimsizing functions act as fences, and they\n      // return \"mopen\" or \"mclose\" mclass.\n      node.setAttribute(\"fence\", \"true\");\n    } else {\n      // Explicitly disable fencing if it's not a fence, to override the\n      // defaults.\n      node.setAttribute(\"fence\", \"false\");\n    }\n\n    node.setAttribute(\"stretchy\", \"true\");\n    var size = makeEm(delimiter.sizeToMaxHeight[group.size]);\n    node.setAttribute(\"minsize\", size);\n    node.setAttribute(\"maxsize\", size);\n    return node;\n  }\n});\n\nfunction assertParsed(group) {\n  if (!group.body) {\n    throw new Error(\"Bug: The leftright ParseNode wasn't fully parsed.\");\n  }\n}\n\ndefineFunction({\n  type: \"leftright-right\",\n  names: [\"\\\\right\"],\n  props: {\n    numArgs: 1,\n    primitive: true\n  },\n  handler: (context, args) => {\n    // \\left case below triggers parsing of \\right in\n    //   `const right = parser.parseFunction();`\n    // uses this return value.\n    var color = context.parser.gullet.macros.get(\"\\\\current@color\");\n\n    if (color && typeof color !== \"string\") {\n      throw new ParseError(\"\\\\current@color set to non-string in \\\\right\");\n    }\n\n    return {\n      type: \"leftright-right\",\n      mode: context.parser.mode,\n      delim: checkDelimiter(args[0], context).text,\n      color // undefined if not set via \\color\n\n    };\n  }\n});\ndefineFunction({\n  type: \"leftright\",\n  names: [\"\\\\left\"],\n  props: {\n    numArgs: 1,\n    primitive: true\n  },\n  handler: (context, args) => {\n    var delim = checkDelimiter(args[0], context);\n    var parser = context.parser; // Parse out the implicit body\n\n    ++parser.leftrightDepth; // parseExpression stops before '\\\\right'\n\n    var body = parser.parseExpression(false);\n    --parser.leftrightDepth; // Check the next token\n\n    parser.expect(\"\\\\right\", false);\n    var right = assertNodeType(parser.parseFunction(), \"leftright-right\");\n    return {\n      type: \"leftright\",\n      mode: parser.mode,\n      body,\n      left: delim.text,\n      right: right.delim,\n      rightColor: right.color\n    };\n  },\n  htmlBuilder: (group, options) => {\n    assertParsed(group); // Build the inner expression\n\n    var inner = buildExpression$1(group.body, options, true, [\"mopen\", \"mclose\"]);\n    var innerHeight = 0;\n    var innerDepth = 0;\n    var hadMiddle = false; // Calculate its height and depth\n\n    for (var i = 0; i < inner.length; i++) {\n      // Property `isMiddle` not defined on `span`. See comment in\n      // \"middle\"'s htmlBuilder.\n      // $FlowFixMe\n      if (inner[i].isMiddle) {\n        hadMiddle = true;\n      } else {\n        innerHeight = Math.max(inner[i].height, innerHeight);\n        innerDepth = Math.max(inner[i].depth, innerDepth);\n      }\n    } // The size of delimiters is the same, regardless of what style we are\n    // in. Thus, to correctly calculate the size of delimiter we need around\n    // a group, we scale down the inner size based on the size.\n\n\n    innerHeight *= options.sizeMultiplier;\n    innerDepth *= options.sizeMultiplier;\n    var leftDelim;\n\n    if (group.left === \".\") {\n      // Empty delimiters in \\left and \\right make null delimiter spaces.\n      leftDelim = makeNullDelimiter(options, [\"mopen\"]);\n    } else {\n      // Otherwise, use leftRightDelim to generate the correct sized\n      // delimiter.\n      leftDelim = delimiter.leftRightDelim(group.left, innerHeight, innerDepth, options, group.mode, [\"mopen\"]);\n    } // Add it to the beginning of the expression\n\n\n    inner.unshift(leftDelim); // Handle middle delimiters\n\n    if (hadMiddle) {\n      for (var _i = 1; _i < inner.length; _i++) {\n        var middleDelim = inner[_i]; // Property `isMiddle` not defined on `span`. See comment in\n        // \"middle\"'s htmlBuilder.\n        // $FlowFixMe\n\n        var isMiddle = middleDelim.isMiddle;\n\n        if (isMiddle) {\n          // Apply the options that were active when \\middle was called\n          inner[_i] = delimiter.leftRightDelim(isMiddle.delim, innerHeight, innerDepth, isMiddle.options, group.mode, []);\n        }\n      }\n    }\n\n    var rightDelim; // Same for the right delimiter, but using color specified by \\color\n\n    if (group.right === \".\") {\n      rightDelim = makeNullDelimiter(options, [\"mclose\"]);\n    } else {\n      var colorOptions = group.rightColor ? options.withColor(group.rightColor) : options;\n      rightDelim = delimiter.leftRightDelim(group.right, innerHeight, innerDepth, colorOptions, group.mode, [\"mclose\"]);\n    } // Add it to the end of the expression.\n\n\n    inner.push(rightDelim);\n    return buildCommon.makeSpan([\"minner\"], inner, options);\n  },\n  mathmlBuilder: (group, options) => {\n    assertParsed(group);\n    var inner = buildExpression(group.body, options);\n\n    if (group.left !== \".\") {\n      var leftNode = new mathMLTree.MathNode(\"mo\", [makeText(group.left, group.mode)]);\n      leftNode.setAttribute(\"fence\", \"true\");\n      inner.unshift(leftNode);\n    }\n\n    if (group.right !== \".\") {\n      var rightNode = new mathMLTree.MathNode(\"mo\", [makeText(group.right, group.mode)]);\n      rightNode.setAttribute(\"fence\", \"true\");\n\n      if (group.rightColor) {\n        rightNode.setAttribute(\"mathcolor\", group.rightColor);\n      }\n\n      inner.push(rightNode);\n    }\n\n    return makeRow(inner);\n  }\n});\ndefineFunction({\n  type: \"middle\",\n  names: [\"\\\\middle\"],\n  props: {\n    numArgs: 1,\n    primitive: true\n  },\n  handler: (context, args) => {\n    var delim = checkDelimiter(args[0], context);\n\n    if (!context.parser.leftrightDepth) {\n      throw new ParseError(\"\\\\middle without preceding \\\\left\", delim);\n    }\n\n    return {\n      type: \"middle\",\n      mode: context.parser.mode,\n      delim: delim.text\n    };\n  },\n  htmlBuilder: (group, options) => {\n    var middleDelim;\n\n    if (group.delim === \".\") {\n      middleDelim = makeNullDelimiter(options, []);\n    } else {\n      middleDelim = delimiter.sizedDelim(group.delim, 1, options, group.mode, []);\n      var isMiddle = {\n        delim: group.delim,\n        options\n      }; // Property `isMiddle` not defined on `span`. It is only used in\n      // this file above.\n      // TODO: Fix this violation of the `span` type and possibly rename\n      // things since `isMiddle` sounds like a boolean, but is a struct.\n      // $FlowFixMe\n\n      middleDelim.isMiddle = isMiddle;\n    }\n\n    return middleDelim;\n  },\n  mathmlBuilder: (group, options) => {\n    // A Firefox \\middle will stretch a character vertically only if it\n    // is in the fence part of the operator dictionary at:\n    // https://www.w3.org/TR/MathML3/appendixc.html.\n    // So we need to avoid U+2223 and use plain \"|\" instead.\n    var textNode = group.delim === \"\\\\vert\" || group.delim === \"|\" ? makeText(\"|\", \"text\") : makeText(group.delim, group.mode);\n    var middleNode = new mathMLTree.MathNode(\"mo\", [textNode]);\n    middleNode.setAttribute(\"fence\", \"true\"); // MathML gives 5/18em spacing to each <mo> element.\n    // \\middle should get delimiter spacing instead.\n\n    middleNode.setAttribute(\"lspace\", \"0.05em\");\n    middleNode.setAttribute(\"rspace\", \"0.05em\");\n    return middleNode;\n  }\n});\n\nvar htmlBuilder$7 = (group, options) => {\n  // \\cancel, \\bcancel, \\xcancel, \\sout, \\fbox, \\colorbox, \\fcolorbox, \\phase\n  // Some groups can return document fragments.  Handle those by wrapping\n  // them in a span.\n  var inner = buildCommon.wrapFragment(buildGroup$1(group.body, options), options);\n  var label = group.label.slice(1);\n  var scale = options.sizeMultiplier;\n  var img;\n  var imgShift = 0; // In the LaTeX cancel package, line geometry is slightly different\n  // depending on whether the subject is wider than it is tall, or vice versa.\n  // We don't know the width of a group, so as a proxy, we test if\n  // the subject is a single character. This captures most of the\n  // subjects that should get the \"tall\" treatment.\n\n  var isSingleChar = utils.isCharacterBox(group.body);\n\n  if (label === \"sout\") {\n    img = buildCommon.makeSpan([\"stretchy\", \"sout\"]);\n    img.height = options.fontMetrics().defaultRuleThickness / scale;\n    imgShift = -0.5 * options.fontMetrics().xHeight;\n  } else if (label === \"phase\") {\n    // Set a couple of dimensions from the steinmetz package.\n    var lineWeight = calculateSize({\n      number: 0.6,\n      unit: \"pt\"\n    }, options);\n    var clearance = calculateSize({\n      number: 0.35,\n      unit: \"ex\"\n    }, options); // Prevent size changes like \\Huge from affecting line thickness\n\n    var newOptions = options.havingBaseSizing();\n    scale = scale / newOptions.sizeMultiplier;\n    var angleHeight = inner.height + inner.depth + lineWeight + clearance; // Reserve a left pad for the angle.\n\n    inner.style.paddingLeft = makeEm(angleHeight / 2 + lineWeight); // Create an SVG\n\n    var viewBoxHeight = Math.floor(1000 * angleHeight * scale);\n    var path = phasePath(viewBoxHeight);\n    var svgNode = new SvgNode([new PathNode(\"phase\", path)], {\n      \"width\": \"400em\",\n      \"height\": makeEm(viewBoxHeight / 1000),\n      \"viewBox\": \"0 0 400000 \" + viewBoxHeight,\n      \"preserveAspectRatio\": \"xMinYMin slice\"\n    }); // Wrap it in a span with overflow: hidden.\n\n    img = buildCommon.makeSvgSpan([\"hide-tail\"], [svgNode], options);\n    img.style.height = makeEm(angleHeight);\n    imgShift = inner.depth + lineWeight + clearance;\n  } else {\n    // Add horizontal padding\n    if (/cancel/.test(label)) {\n      if (!isSingleChar) {\n        inner.classes.push(\"cancel-pad\");\n      }\n    } else if (label === \"angl\") {\n      inner.classes.push(\"anglpad\");\n    } else {\n      inner.classes.push(\"boxpad\");\n    } // Add vertical padding\n\n\n    var topPad = 0;\n    var bottomPad = 0;\n    var ruleThickness = 0; // ref: cancel package: \\advance\\totalheight2\\p@ % \"+2\"\n\n    if (/box/.test(label)) {\n      ruleThickness = Math.max(options.fontMetrics().fboxrule, // default\n      options.minRuleThickness // User override.\n      );\n      topPad = options.fontMetrics().fboxsep + (label === \"colorbox\" ? 0 : ruleThickness);\n      bottomPad = topPad;\n    } else if (label === \"angl\") {\n      ruleThickness = Math.max(options.fontMetrics().defaultRuleThickness, options.minRuleThickness);\n      topPad = 4 * ruleThickness; // gap = 3 × line, plus the line itself.\n\n      bottomPad = Math.max(0, 0.25 - inner.depth);\n    } else {\n      topPad = isSingleChar ? 0.2 : 0;\n      bottomPad = topPad;\n    }\n\n    img = stretchy.encloseSpan(inner, label, topPad, bottomPad, options);\n\n    if (/fbox|boxed|fcolorbox/.test(label)) {\n      img.style.borderStyle = \"solid\";\n      img.style.borderWidth = makeEm(ruleThickness);\n    } else if (label === \"angl\" && ruleThickness !== 0.049) {\n      img.style.borderTopWidth = makeEm(ruleThickness);\n      img.style.borderRightWidth = makeEm(ruleThickness);\n    }\n\n    imgShift = inner.depth + bottomPad;\n\n    if (group.backgroundColor) {\n      img.style.backgroundColor = group.backgroundColor;\n\n      if (group.borderColor) {\n        img.style.borderColor = group.borderColor;\n      }\n    }\n  }\n\n  var vlist;\n\n  if (group.backgroundColor) {\n    vlist = buildCommon.makeVList({\n      positionType: \"individualShift\",\n      children: [// Put the color background behind inner;\n      {\n        type: \"elem\",\n        elem: img,\n        shift: imgShift\n      }, {\n        type: \"elem\",\n        elem: inner,\n        shift: 0\n      }]\n    }, options);\n  } else {\n    var classes = /cancel|phase/.test(label) ? [\"svg-align\"] : [];\n    vlist = buildCommon.makeVList({\n      positionType: \"individualShift\",\n      children: [// Write the \\cancel stroke on top of inner.\n      {\n        type: \"elem\",\n        elem: inner,\n        shift: 0\n      }, {\n        type: \"elem\",\n        elem: img,\n        shift: imgShift,\n        wrapperClasses: classes\n      }]\n    }, options);\n  }\n\n  if (/cancel/.test(label)) {\n    // The cancel package documentation says that cancel lines add their height\n    // to the expression, but tests show that isn't how it actually works.\n    vlist.height = inner.height;\n    vlist.depth = inner.depth;\n  }\n\n  if (/cancel/.test(label) && !isSingleChar) {\n    // cancel does not create horiz space for its line extension.\n    return buildCommon.makeSpan([\"mord\", \"cancel-lap\"], [vlist], options);\n  } else {\n    return buildCommon.makeSpan([\"mord\"], [vlist], options);\n  }\n};\n\nvar mathmlBuilder$6 = (group, options) => {\n  var fboxsep = 0;\n  var node = new mathMLTree.MathNode(group.label.indexOf(\"colorbox\") > -1 ? \"mpadded\" : \"menclose\", [buildGroup(group.body, options)]);\n\n  switch (group.label) {\n    case \"\\\\cancel\":\n      node.setAttribute(\"notation\", \"updiagonalstrike\");\n      break;\n\n    case \"\\\\bcancel\":\n      node.setAttribute(\"notation\", \"downdiagonalstrike\");\n      break;\n\n    case \"\\\\phase\":\n      node.setAttribute(\"notation\", \"phasorangle\");\n      break;\n\n    case \"\\\\sout\":\n      node.setAttribute(\"notation\", \"horizontalstrike\");\n      break;\n\n    case \"\\\\fbox\":\n      node.setAttribute(\"notation\", \"box\");\n      break;\n\n    case \"\\\\angl\":\n      node.setAttribute(\"notation\", \"actuarial\");\n      break;\n\n    case \"\\\\fcolorbox\":\n    case \"\\\\colorbox\":\n      // <menclose> doesn't have a good notation option. So use <mpadded>\n      // instead. Set some attributes that come included with <menclose>.\n      fboxsep = options.fontMetrics().fboxsep * options.fontMetrics().ptPerEm;\n      node.setAttribute(\"width\", \"+\" + 2 * fboxsep + \"pt\");\n      node.setAttribute(\"height\", \"+\" + 2 * fboxsep + \"pt\");\n      node.setAttribute(\"lspace\", fboxsep + \"pt\"); //\n\n      node.setAttribute(\"voffset\", fboxsep + \"pt\");\n\n      if (group.label === \"\\\\fcolorbox\") {\n        var thk = Math.max(options.fontMetrics().fboxrule, // default\n        options.minRuleThickness // user override\n        );\n        node.setAttribute(\"style\", \"border: \" + thk + \"em solid \" + String(group.borderColor));\n      }\n\n      break;\n\n    case \"\\\\xcancel\":\n      node.setAttribute(\"notation\", \"updiagonalstrike downdiagonalstrike\");\n      break;\n  }\n\n  if (group.backgroundColor) {\n    node.setAttribute(\"mathbackground\", group.backgroundColor);\n  }\n\n  return node;\n};\n\ndefineFunction({\n  type: \"enclose\",\n  names: [\"\\\\colorbox\"],\n  props: {\n    numArgs: 2,\n    allowedInText: true,\n    argTypes: [\"color\", \"text\"]\n  },\n\n  handler(_ref, args, optArgs) {\n    var {\n      parser,\n      funcName\n    } = _ref;\n    var color = assertNodeType(args[0], \"color-token\").color;\n    var body = args[1];\n    return {\n      type: \"enclose\",\n      mode: parser.mode,\n      label: funcName,\n      backgroundColor: color,\n      body\n    };\n  },\n\n  htmlBuilder: htmlBuilder$7,\n  mathmlBuilder: mathmlBuilder$6\n});\ndefineFunction({\n  type: \"enclose\",\n  names: [\"\\\\fcolorbox\"],\n  props: {\n    numArgs: 3,\n    allowedInText: true,\n    argTypes: [\"color\", \"color\", \"text\"]\n  },\n\n  handler(_ref2, args, optArgs) {\n    var {\n      parser,\n      funcName\n    } = _ref2;\n    var borderColor = assertNodeType(args[0], \"color-token\").color;\n    var backgroundColor = assertNodeType(args[1], \"color-token\").color;\n    var body = args[2];\n    return {\n      type: \"enclose\",\n      mode: parser.mode,\n      label: funcName,\n      backgroundColor,\n      borderColor,\n      body\n    };\n  },\n\n  htmlBuilder: htmlBuilder$7,\n  mathmlBuilder: mathmlBuilder$6\n});\ndefineFunction({\n  type: \"enclose\",\n  names: [\"\\\\fbox\"],\n  props: {\n    numArgs: 1,\n    argTypes: [\"hbox\"],\n    allowedInText: true\n  },\n\n  handler(_ref3, args) {\n    var {\n      parser\n    } = _ref3;\n    return {\n      type: \"enclose\",\n      mode: parser.mode,\n      label: \"\\\\fbox\",\n      body: args[0]\n    };\n  }\n\n});\ndefineFunction({\n  type: \"enclose\",\n  names: [\"\\\\cancel\", \"\\\\bcancel\", \"\\\\xcancel\", \"\\\\sout\", \"\\\\phase\"],\n  props: {\n    numArgs: 1\n  },\n\n  handler(_ref4, args) {\n    var {\n      parser,\n      funcName\n    } = _ref4;\n    var body = args[0];\n    return {\n      type: \"enclose\",\n      mode: parser.mode,\n      label: funcName,\n      body\n    };\n  },\n\n  htmlBuilder: htmlBuilder$7,\n  mathmlBuilder: mathmlBuilder$6\n});\ndefineFunction({\n  type: \"enclose\",\n  names: [\"\\\\angl\"],\n  props: {\n    numArgs: 1,\n    argTypes: [\"hbox\"],\n    allowedInText: false\n  },\n\n  handler(_ref5, args) {\n    var {\n      parser\n    } = _ref5;\n    return {\n      type: \"enclose\",\n      mode: parser.mode,\n      label: \"\\\\angl\",\n      body: args[0]\n    };\n  }\n\n});\n\n/**\n * All registered environments.\n * `environments.js` exports this same dictionary again and makes it public.\n * `Parser.js` requires this dictionary via `environments.js`.\n */\nvar _environments = {};\nfunction defineEnvironment(_ref) {\n  var {\n    type,\n    names,\n    props,\n    handler,\n    htmlBuilder,\n    mathmlBuilder\n  } = _ref;\n  // Set default values of environments.\n  var data = {\n    type,\n    numArgs: props.numArgs || 0,\n    allowedInText: false,\n    numOptionalArgs: 0,\n    handler\n  };\n\n  for (var i = 0; i < names.length; ++i) {\n    // TODO: The value type of _environments should be a type union of all\n    // possible `EnvSpec<>` possibilities instead of `EnvSpec<*>`, which is\n    // an existential type.\n    _environments[names[i]] = data;\n  }\n\n  if (htmlBuilder) {\n    _htmlGroupBuilders[type] = htmlBuilder;\n  }\n\n  if (mathmlBuilder) {\n    _mathmlGroupBuilders[type] = mathmlBuilder;\n  }\n}\n\n/**\n * All registered global/built-in macros.\n * `macros.js` exports this same dictionary again and makes it public.\n * `Parser.js` requires this dictionary via `macros.js`.\n */\nvar _macros = {}; // This function might one day accept an additional argument and do more things.\n\nfunction defineMacro(name, body) {\n  _macros[name] = body;\n}\n\n// Helper functions\nfunction getHLines(parser) {\n  // Return an array. The array length = number of hlines.\n  // Each element in the array tells if the line is dashed.\n  var hlineInfo = [];\n  parser.consumeSpaces();\n  var nxt = parser.fetch().text;\n\n  if (nxt === \"\\\\relax\") {\n    // \\relax is an artifact of the \\cr macro below\n    parser.consume();\n    parser.consumeSpaces();\n    nxt = parser.fetch().text;\n  }\n\n  while (nxt === \"\\\\hline\" || nxt === \"\\\\hdashline\") {\n    parser.consume();\n    hlineInfo.push(nxt === \"\\\\hdashline\");\n    parser.consumeSpaces();\n    nxt = parser.fetch().text;\n  }\n\n  return hlineInfo;\n}\n\nvar validateAmsEnvironmentContext = context => {\n  var settings = context.parser.settings;\n\n  if (!settings.displayMode) {\n    throw new ParseError(\"{\" + context.envName + \"} can be used only in\" + \" display mode.\");\n  }\n}; // autoTag (an argument to parseArray) can be one of three values:\n// * undefined: Regular (not-top-level) array; no tags on each row\n// * true: Automatic equation numbering, overridable by \\tag\n// * false: Tags allowed on each row, but no automatic numbering\n// This function *doesn't* work with the \"split\" environment name.\n\n\nfunction getAutoTag(name) {\n  if (name.indexOf(\"ed\") === -1) {\n    return name.indexOf(\"*\") === -1;\n  } // return undefined;\n\n}\n/**\n * Parse the body of the environment, with rows delimited by \\\\ and\n * columns delimited by &, and create a nested list in row-major order\n * with one group per cell.  If given an optional argument style\n * (\"text\", \"display\", etc.), then each cell is cast into that style.\n */\n\n\nfunction parseArray(parser, _ref, style) {\n  var {\n    hskipBeforeAndAfter,\n    addJot,\n    cols,\n    arraystretch,\n    colSeparationType,\n    autoTag,\n    singleRow,\n    emptySingleRow,\n    maxNumCols,\n    leqno\n  } = _ref;\n  parser.gullet.beginGroup();\n\n  if (!singleRow) {\n    // \\cr is equivalent to \\\\ without the optional size argument (see below)\n    // TODO: provide helpful error when \\cr is used outside array environment\n    parser.gullet.macros.set(\"\\\\cr\", \"\\\\\\\\\\\\relax\");\n  } // Get current arraystretch if it's not set by the environment\n\n\n  if (!arraystretch) {\n    var stretch = parser.gullet.expandMacroAsText(\"\\\\arraystretch\");\n\n    if (stretch == null) {\n      // Default \\arraystretch from lttab.dtx\n      arraystretch = 1;\n    } else {\n      arraystretch = parseFloat(stretch);\n\n      if (!arraystretch || arraystretch < 0) {\n        throw new ParseError(\"Invalid \\\\arraystretch: \" + stretch);\n      }\n    }\n  } // Start group for first cell\n\n\n  parser.gullet.beginGroup();\n  var row = [];\n  var body = [row];\n  var rowGaps = [];\n  var hLinesBeforeRow = [];\n  var tags = autoTag != null ? [] : undefined; // amsmath uses \\global\\@eqnswtrue and \\global\\@eqnswfalse to represent\n  // whether this row should have an equation number.  Simulate this with\n  // a \\@eqnsw macro set to 1 or 0.\n\n  function beginRow() {\n    if (autoTag) {\n      parser.gullet.macros.set(\"\\\\@eqnsw\", \"1\", true);\n    }\n  }\n\n  function endRow() {\n    if (tags) {\n      if (parser.gullet.macros.get(\"\\\\df@tag\")) {\n        tags.push(parser.subparse([new Token(\"\\\\df@tag\")]));\n        parser.gullet.macros.set(\"\\\\df@tag\", undefined, true);\n      } else {\n        tags.push(Boolean(autoTag) && parser.gullet.macros.get(\"\\\\@eqnsw\") === \"1\");\n      }\n    }\n  }\n\n  beginRow(); // Test for \\hline at the top of the array.\n\n  hLinesBeforeRow.push(getHLines(parser));\n\n  while (true) {\n    // eslint-disable-line no-constant-condition\n    // Parse each cell in its own group (namespace)\n    var cell = parser.parseExpression(false, singleRow ? \"\\\\end\" : \"\\\\\\\\\");\n    parser.gullet.endGroup();\n    parser.gullet.beginGroup();\n    cell = {\n      type: \"ordgroup\",\n      mode: parser.mode,\n      body: cell\n    };\n\n    if (style) {\n      cell = {\n        type: \"styling\",\n        mode: parser.mode,\n        style,\n        body: [cell]\n      };\n    }\n\n    row.push(cell);\n    var next = parser.fetch().text;\n\n    if (next === \"&\") {\n      if (maxNumCols && row.length === maxNumCols) {\n        if (singleRow || colSeparationType) {\n          // {equation} or {split}\n          throw new ParseError(\"Too many tab characters: &\", parser.nextToken);\n        } else {\n          // {array} environment\n          parser.settings.reportNonstrict(\"textEnv\", \"Too few columns \" + \"specified in the {array} column argument.\");\n        }\n      }\n\n      parser.consume();\n    } else if (next === \"\\\\end\") {\n      endRow(); // Arrays terminate newlines with `\\crcr` which consumes a `\\cr` if\n      // the last line is empty.  However, AMS environments keep the\n      // empty row if it's the only one.\n      // NOTE: Currently, `cell` is the last item added into `row`.\n\n      if (row.length === 1 && cell.type === \"styling\" && cell.body[0].body.length === 0 && (body.length > 1 || !emptySingleRow)) {\n        body.pop();\n      }\n\n      if (hLinesBeforeRow.length < body.length + 1) {\n        hLinesBeforeRow.push([]);\n      }\n\n      break;\n    } else if (next === \"\\\\\\\\\") {\n      parser.consume();\n      var size = void 0; // \\def\\Let@{\\let\\\\\\math@cr}\n      // \\def\\math@cr{...\\math@cr@}\n      // \\def\\math@cr@{\\new@ifnextchar[\\math@cr@@{\\math@cr@@[\\z@]}}\n      // \\def\\math@cr@@[#1]{...\\math@cr@@@...}\n      // \\def\\math@cr@@@{\\cr}\n\n      if (parser.gullet.future().text !== \" \") {\n        size = parser.parseSizeGroup(true);\n      }\n\n      rowGaps.push(size ? size.value : null);\n      endRow(); // check for \\hline(s) following the row separator\n\n      hLinesBeforeRow.push(getHLines(parser));\n      row = [];\n      body.push(row);\n      beginRow();\n    } else {\n      throw new ParseError(\"Expected & or \\\\\\\\ or \\\\cr or \\\\end\", parser.nextToken);\n    }\n  } // End cell group\n\n\n  parser.gullet.endGroup(); // End array group defining \\cr\n\n  parser.gullet.endGroup();\n  return {\n    type: \"array\",\n    mode: parser.mode,\n    addJot,\n    arraystretch,\n    body,\n    cols,\n    rowGaps,\n    hskipBeforeAndAfter,\n    hLinesBeforeRow,\n    colSeparationType,\n    tags,\n    leqno\n  };\n} // Decides on a style for cells in an array according to whether the given\n// environment name starts with the letter 'd'.\n\n\nfunction dCellStyle(envName) {\n  if (envName.slice(0, 1) === \"d\") {\n    return \"display\";\n  } else {\n    return \"text\";\n  }\n}\n\nvar htmlBuilder$6 = function htmlBuilder(group, options) {\n  var r;\n  var c;\n  var nr = group.body.length;\n  var hLinesBeforeRow = group.hLinesBeforeRow;\n  var nc = 0;\n  var body = new Array(nr);\n  var hlines = [];\n  var ruleThickness = Math.max( // From LaTeX \\showthe\\arrayrulewidth. Equals 0.04 em.\n  options.fontMetrics().arrayRuleWidth, options.minRuleThickness // User override.\n  ); // Horizontal spacing\n\n  var pt = 1 / options.fontMetrics().ptPerEm;\n  var arraycolsep = 5 * pt; // default value, i.e. \\arraycolsep in article.cls\n\n  if (group.colSeparationType && group.colSeparationType === \"small\") {\n    // We're in a {smallmatrix}. Default column space is \\thickspace,\n    // i.e. 5/18em = 0.2778em, per amsmath.dtx for {smallmatrix}.\n    // But that needs adjustment because LaTeX applies \\scriptstyle to the\n    // entire array, including the colspace, but this function applies\n    // \\scriptstyle only inside each element.\n    var localMultiplier = options.havingStyle(Style$1.SCRIPT).sizeMultiplier;\n    arraycolsep = 0.2778 * (localMultiplier / options.sizeMultiplier);\n  } // Vertical spacing\n\n\n  var baselineskip = group.colSeparationType === \"CD\" ? calculateSize({\n    number: 3,\n    unit: \"ex\"\n  }, options) : 12 * pt; // see size10.clo\n  // Default \\jot from ltmath.dtx\n  // TODO(edemaine): allow overriding \\jot via \\setlength (#687)\n\n  var jot = 3 * pt;\n  var arrayskip = group.arraystretch * baselineskip;\n  var arstrutHeight = 0.7 * arrayskip; // \\strutbox in ltfsstrc.dtx and\n\n  var arstrutDepth = 0.3 * arrayskip; // \\@arstrutbox in lttab.dtx\n\n  var totalHeight = 0; // Set a position for \\hline(s) at the top of the array, if any.\n\n  function setHLinePos(hlinesInGap) {\n    for (var i = 0; i < hlinesInGap.length; ++i) {\n      if (i > 0) {\n        totalHeight += 0.25;\n      }\n\n      hlines.push({\n        pos: totalHeight,\n        isDashed: hlinesInGap[i]\n      });\n    }\n  }\n\n  setHLinePos(hLinesBeforeRow[0]);\n\n  for (r = 0; r < group.body.length; ++r) {\n    var inrow = group.body[r];\n    var height = arstrutHeight; // \\@array adds an \\@arstrut\n\n    var depth = arstrutDepth; // to each tow (via the template)\n\n    if (nc < inrow.length) {\n      nc = inrow.length;\n    }\n\n    var outrow = new Array(inrow.length);\n\n    for (c = 0; c < inrow.length; ++c) {\n      var elt = buildGroup$1(inrow[c], options);\n\n      if (depth < elt.depth) {\n        depth = elt.depth;\n      }\n\n      if (height < elt.height) {\n        height = elt.height;\n      }\n\n      outrow[c] = elt;\n    }\n\n    var rowGap = group.rowGaps[r];\n    var gap = 0;\n\n    if (rowGap) {\n      gap = calculateSize(rowGap, options);\n\n      if (gap > 0) {\n        // \\@argarraycr\n        gap += arstrutDepth;\n\n        if (depth < gap) {\n          depth = gap; // \\@xargarraycr\n        }\n\n        gap = 0;\n      }\n    } // In AMS multiline environments such as aligned and gathered, rows\n    // correspond to lines that have additional \\jot added to the\n    // \\baselineskip via \\openup.\n\n\n    if (group.addJot) {\n      depth += jot;\n    }\n\n    outrow.height = height;\n    outrow.depth = depth;\n    totalHeight += height;\n    outrow.pos = totalHeight;\n    totalHeight += depth + gap; // \\@yargarraycr\n\n    body[r] = outrow; // Set a position for \\hline(s), if any.\n\n    setHLinePos(hLinesBeforeRow[r + 1]);\n  }\n\n  var offset = totalHeight / 2 + options.fontMetrics().axisHeight;\n  var colDescriptions = group.cols || [];\n  var cols = [];\n  var colSep;\n  var colDescrNum;\n  var tagSpans = [];\n\n  if (group.tags && group.tags.some(tag => tag)) {\n    // An environment with manual tags and/or automatic equation numbers.\n    // Create node(s), the latter of which trigger CSS counter increment.\n    for (r = 0; r < nr; ++r) {\n      var rw = body[r];\n      var shift = rw.pos - offset;\n      var tag = group.tags[r];\n      var tagSpan = void 0;\n\n      if (tag === true) {\n        // automatic numbering\n        tagSpan = buildCommon.makeSpan([\"eqn-num\"], [], options);\n      } else if (tag === false) {\n        // \\nonumber/\\notag or starred environment\n        tagSpan = buildCommon.makeSpan([], [], options);\n      } else {\n        // manual \\tag\n        tagSpan = buildCommon.makeSpan([], buildExpression$1(tag, options, true), options);\n      }\n\n      tagSpan.depth = rw.depth;\n      tagSpan.height = rw.height;\n      tagSpans.push({\n        type: \"elem\",\n        elem: tagSpan,\n        shift\n      });\n    }\n  }\n\n  for (c = 0, colDescrNum = 0; // Continue while either there are more columns or more column\n  // descriptions, so trailing separators don't get lost.\n  c < nc || colDescrNum < colDescriptions.length; ++c, ++colDescrNum) {\n    var colDescr = colDescriptions[colDescrNum] || {};\n    var firstSeparator = true;\n\n    while (colDescr.type === \"separator\") {\n      // If there is more than one separator in a row, add a space\n      // between them.\n      if (!firstSeparator) {\n        colSep = buildCommon.makeSpan([\"arraycolsep\"], []);\n        colSep.style.width = makeEm(options.fontMetrics().doubleRuleSep);\n        cols.push(colSep);\n      }\n\n      if (colDescr.separator === \"|\" || colDescr.separator === \":\") {\n        var lineType = colDescr.separator === \"|\" ? \"solid\" : \"dashed\";\n        var separator = buildCommon.makeSpan([\"vertical-separator\"], [], options);\n        separator.style.height = makeEm(totalHeight);\n        separator.style.borderRightWidth = makeEm(ruleThickness);\n        separator.style.borderRightStyle = lineType;\n        separator.style.margin = \"0 \" + makeEm(-ruleThickness / 2);\n\n        var _shift = totalHeight - offset;\n\n        if (_shift) {\n          separator.style.verticalAlign = makeEm(-_shift);\n        }\n\n        cols.push(separator);\n      } else {\n        throw new ParseError(\"Invalid separator type: \" + colDescr.separator);\n      }\n\n      colDescrNum++;\n      colDescr = colDescriptions[colDescrNum] || {};\n      firstSeparator = false;\n    }\n\n    if (c >= nc) {\n      continue;\n    }\n\n    var sepwidth = void 0;\n\n    if (c > 0 || group.hskipBeforeAndAfter) {\n      sepwidth = utils.deflt(colDescr.pregap, arraycolsep);\n\n      if (sepwidth !== 0) {\n        colSep = buildCommon.makeSpan([\"arraycolsep\"], []);\n        colSep.style.width = makeEm(sepwidth);\n        cols.push(colSep);\n      }\n    }\n\n    var col = [];\n\n    for (r = 0; r < nr; ++r) {\n      var row = body[r];\n      var elem = row[c];\n\n      if (!elem) {\n        continue;\n      }\n\n      var _shift2 = row.pos - offset;\n\n      elem.depth = row.depth;\n      elem.height = row.height;\n      col.push({\n        type: \"elem\",\n        elem: elem,\n        shift: _shift2\n      });\n    }\n\n    col = buildCommon.makeVList({\n      positionType: \"individualShift\",\n      children: col\n    }, options);\n    col = buildCommon.makeSpan([\"col-align-\" + (colDescr.align || \"c\")], [col]);\n    cols.push(col);\n\n    if (c < nc - 1 || group.hskipBeforeAndAfter) {\n      sepwidth = utils.deflt(colDescr.postgap, arraycolsep);\n\n      if (sepwidth !== 0) {\n        colSep = buildCommon.makeSpan([\"arraycolsep\"], []);\n        colSep.style.width = makeEm(sepwidth);\n        cols.push(colSep);\n      }\n    }\n  }\n\n  body = buildCommon.makeSpan([\"mtable\"], cols); // Add \\hline(s), if any.\n\n  if (hlines.length > 0) {\n    var line = buildCommon.makeLineSpan(\"hline\", options, ruleThickness);\n    var dashes = buildCommon.makeLineSpan(\"hdashline\", options, ruleThickness);\n    var vListElems = [{\n      type: \"elem\",\n      elem: body,\n      shift: 0\n    }];\n\n    while (hlines.length > 0) {\n      var hline = hlines.pop();\n      var lineShift = hline.pos - offset;\n\n      if (hline.isDashed) {\n        vListElems.push({\n          type: \"elem\",\n          elem: dashes,\n          shift: lineShift\n        });\n      } else {\n        vListElems.push({\n          type: \"elem\",\n          elem: line,\n          shift: lineShift\n        });\n      }\n    }\n\n    body = buildCommon.makeVList({\n      positionType: \"individualShift\",\n      children: vListElems\n    }, options);\n  }\n\n  if (tagSpans.length === 0) {\n    return buildCommon.makeSpan([\"mord\"], [body], options);\n  } else {\n    var eqnNumCol = buildCommon.makeVList({\n      positionType: \"individualShift\",\n      children: tagSpans\n    }, options);\n    eqnNumCol = buildCommon.makeSpan([\"tag\"], [eqnNumCol], options);\n    return buildCommon.makeFragment([body, eqnNumCol]);\n  }\n};\n\nvar alignMap = {\n  c: \"center \",\n  l: \"left \",\n  r: \"right \"\n};\n\nvar mathmlBuilder$5 = function mathmlBuilder(group, options) {\n  var tbl = [];\n  var glue = new mathMLTree.MathNode(\"mtd\", [], [\"mtr-glue\"]);\n  var tag = new mathMLTree.MathNode(\"mtd\", [], [\"mml-eqn-num\"]);\n\n  for (var i = 0; i < group.body.length; i++) {\n    var rw = group.body[i];\n    var row = [];\n\n    for (var j = 0; j < rw.length; j++) {\n      row.push(new mathMLTree.MathNode(\"mtd\", [buildGroup(rw[j], options)]));\n    }\n\n    if (group.tags && group.tags[i]) {\n      row.unshift(glue);\n      row.push(glue);\n\n      if (group.leqno) {\n        row.unshift(tag);\n      } else {\n        row.push(tag);\n      }\n    }\n\n    tbl.push(new mathMLTree.MathNode(\"mtr\", row));\n  }\n\n  var table = new mathMLTree.MathNode(\"mtable\", tbl); // Set column alignment, row spacing, column spacing, and\n  // array lines by setting attributes on the table element.\n  // Set the row spacing. In MathML, we specify a gap distance.\n  // We do not use rowGap[] because MathML automatically increases\n  // cell height with the height/depth of the element content.\n  // LaTeX \\arraystretch multiplies the row baseline-to-baseline distance.\n  // We simulate this by adding (arraystretch - 1)em to the gap. This\n  // does a reasonable job of adjusting arrays containing 1 em tall content.\n  // The 0.16 and 0.09 values are found empirically. They produce an array\n  // similar to LaTeX and in which content does not interfere with \\hlines.\n\n  var gap = group.arraystretch === 0.5 ? 0.1 // {smallmatrix}, {subarray}\n  : 0.16 + group.arraystretch - 1 + (group.addJot ? 0.09 : 0);\n  table.setAttribute(\"rowspacing\", makeEm(gap)); // MathML table lines go only between cells.\n  // To place a line on an edge we'll use <menclose>, if necessary.\n\n  var menclose = \"\";\n  var align = \"\";\n\n  if (group.cols && group.cols.length > 0) {\n    // Find column alignment, column spacing, and  vertical lines.\n    var cols = group.cols;\n    var columnLines = \"\";\n    var prevTypeWasAlign = false;\n    var iStart = 0;\n    var iEnd = cols.length;\n\n    if (cols[0].type === \"separator\") {\n      menclose += \"top \";\n      iStart = 1;\n    }\n\n    if (cols[cols.length - 1].type === \"separator\") {\n      menclose += \"bottom \";\n      iEnd -= 1;\n    }\n\n    for (var _i = iStart; _i < iEnd; _i++) {\n      if (cols[_i].type === \"align\") {\n        align += alignMap[cols[_i].align];\n\n        if (prevTypeWasAlign) {\n          columnLines += \"none \";\n        }\n\n        prevTypeWasAlign = true;\n      } else if (cols[_i].type === \"separator\") {\n        // MathML accepts only single lines between cells.\n        // So we read only the first of consecutive separators.\n        if (prevTypeWasAlign) {\n          columnLines += cols[_i].separator === \"|\" ? \"solid \" : \"dashed \";\n          prevTypeWasAlign = false;\n        }\n      }\n    }\n\n    table.setAttribute(\"columnalign\", align.trim());\n\n    if (/[sd]/.test(columnLines)) {\n      table.setAttribute(\"columnlines\", columnLines.trim());\n    }\n  } // Set column spacing.\n\n\n  if (group.colSeparationType === \"align\") {\n    var _cols = group.cols || [];\n\n    var spacing = \"\";\n\n    for (var _i2 = 1; _i2 < _cols.length; _i2++) {\n      spacing += _i2 % 2 ? \"0em \" : \"1em \";\n    }\n\n    table.setAttribute(\"columnspacing\", spacing.trim());\n  } else if (group.colSeparationType === \"alignat\" || group.colSeparationType === \"gather\") {\n    table.setAttribute(\"columnspacing\", \"0em\");\n  } else if (group.colSeparationType === \"small\") {\n    table.setAttribute(\"columnspacing\", \"0.2778em\");\n  } else if (group.colSeparationType === \"CD\") {\n    table.setAttribute(\"columnspacing\", \"0.5em\");\n  } else {\n    table.setAttribute(\"columnspacing\", \"1em\");\n  } // Address \\hline and \\hdashline\n\n\n  var rowLines = \"\";\n  var hlines = group.hLinesBeforeRow;\n  menclose += hlines[0].length > 0 ? \"left \" : \"\";\n  menclose += hlines[hlines.length - 1].length > 0 ? \"right \" : \"\";\n\n  for (var _i3 = 1; _i3 < hlines.length - 1; _i3++) {\n    rowLines += hlines[_i3].length === 0 ? \"none \" // MathML accepts only a single line between rows. Read one element.\n    : hlines[_i3][0] ? \"dashed \" : \"solid \";\n  }\n\n  if (/[sd]/.test(rowLines)) {\n    table.setAttribute(\"rowlines\", rowLines.trim());\n  }\n\n  if (menclose !== \"\") {\n    table = new mathMLTree.MathNode(\"menclose\", [table]);\n    table.setAttribute(\"notation\", menclose.trim());\n  }\n\n  if (group.arraystretch && group.arraystretch < 1) {\n    // A small array. Wrap in scriptstyle so row gap is not too large.\n    table = new mathMLTree.MathNode(\"mstyle\", [table]);\n    table.setAttribute(\"scriptlevel\", \"1\");\n  }\n\n  return table;\n}; // Convenience function for align, align*, aligned, alignat, alignat*, alignedat.\n\n\nvar alignedHandler = function alignedHandler(context, args) {\n  if (context.envName.indexOf(\"ed\") === -1) {\n    validateAmsEnvironmentContext(context);\n  }\n\n  var cols = [];\n  var separationType = context.envName.indexOf(\"at\") > -1 ? \"alignat\" : \"align\";\n  var isSplit = context.envName === \"split\";\n  var res = parseArray(context.parser, {\n    cols,\n    addJot: true,\n    autoTag: isSplit ? undefined : getAutoTag(context.envName),\n    emptySingleRow: true,\n    colSeparationType: separationType,\n    maxNumCols: isSplit ? 2 : undefined,\n    leqno: context.parser.settings.leqno\n  }, \"display\"); // Determining number of columns.\n  // 1. If the first argument is given, we use it as a number of columns,\n  //    and makes sure that each row doesn't exceed that number.\n  // 2. Otherwise, just count number of columns = maximum number\n  //    of cells in each row (\"aligned\" mode -- isAligned will be true).\n  //\n  // At the same time, prepend empty group {} at beginning of every second\n  // cell in each row (starting with second cell) so that operators become\n  // binary.  This behavior is implemented in amsmath's \\start@aligned.\n\n  var numMaths;\n  var numCols = 0;\n  var emptyGroup = {\n    type: \"ordgroup\",\n    mode: context.mode,\n    body: []\n  };\n\n  if (args[0] && args[0].type === \"ordgroup\") {\n    var arg0 = \"\";\n\n    for (var i = 0; i < args[0].body.length; i++) {\n      var textord = assertNodeType(args[0].body[i], \"textord\");\n      arg0 += textord.text;\n    }\n\n    numMaths = Number(arg0);\n    numCols = numMaths * 2;\n  }\n\n  var isAligned = !numCols;\n  res.body.forEach(function (row) {\n    for (var _i4 = 1; _i4 < row.length; _i4 += 2) {\n      // Modify ordgroup node within styling node\n      var styling = assertNodeType(row[_i4], \"styling\");\n      var ordgroup = assertNodeType(styling.body[0], \"ordgroup\");\n      ordgroup.body.unshift(emptyGroup);\n    }\n\n    if (!isAligned) {\n      // Case 1\n      var curMaths = row.length / 2;\n\n      if (numMaths < curMaths) {\n        throw new ParseError(\"Too many math in a row: \" + (\"expected \" + numMaths + \", but got \" + curMaths), row[0]);\n      }\n    } else if (numCols < row.length) {\n      // Case 2\n      numCols = row.length;\n    }\n  }); // Adjusting alignment.\n  // In aligned mode, we add one \\qquad between columns;\n  // otherwise we add nothing.\n\n  for (var _i5 = 0; _i5 < numCols; ++_i5) {\n    var align = \"r\";\n    var pregap = 0;\n\n    if (_i5 % 2 === 1) {\n      align = \"l\";\n    } else if (_i5 > 0 && isAligned) {\n      // \"aligned\" mode.\n      pregap = 1; // add one \\quad\n    }\n\n    cols[_i5] = {\n      type: \"align\",\n      align: align,\n      pregap: pregap,\n      postgap: 0\n    };\n  }\n\n  res.colSeparationType = isAligned ? \"align\" : \"alignat\";\n  return res;\n}; // Arrays are part of LaTeX, defined in lttab.dtx so its documentation\n// is part of the source2e.pdf file of LaTeX2e source documentation.\n// {darray} is an {array} environment where cells are set in \\displaystyle,\n// as defined in nccmath.sty.\n\n\ndefineEnvironment({\n  type: \"array\",\n  names: [\"array\", \"darray\"],\n  props: {\n    numArgs: 1\n  },\n\n  handler(context, args) {\n    // Since no types are specified above, the two possibilities are\n    // - The argument is wrapped in {} or [], in which case Parser's\n    //   parseGroup() returns an \"ordgroup\" wrapping some symbol node.\n    // - The argument is a bare symbol node.\n    var symNode = checkSymbolNodeType(args[0]);\n    var colalign = symNode ? [args[0]] : assertNodeType(args[0], \"ordgroup\").body;\n    var cols = colalign.map(function (nde) {\n      var node = assertSymbolNodeType(nde);\n      var ca = node.text;\n\n      if (\"lcr\".indexOf(ca) !== -1) {\n        return {\n          type: \"align\",\n          align: ca\n        };\n      } else if (ca === \"|\") {\n        return {\n          type: \"separator\",\n          separator: \"|\"\n        };\n      } else if (ca === \":\") {\n        return {\n          type: \"separator\",\n          separator: \":\"\n        };\n      }\n\n      throw new ParseError(\"Unknown column alignment: \" + ca, nde);\n    });\n    var res = {\n      cols,\n      hskipBeforeAndAfter: true,\n      // \\@preamble in lttab.dtx\n      maxNumCols: cols.length\n    };\n    return parseArray(context.parser, res, dCellStyle(context.envName));\n  },\n\n  htmlBuilder: htmlBuilder$6,\n  mathmlBuilder: mathmlBuilder$5\n}); // The matrix environments of amsmath builds on the array environment\n// of LaTeX, which is discussed above.\n// The mathtools package adds starred versions of the same environments.\n// These have an optional argument to choose left|center|right justification.\n\ndefineEnvironment({\n  type: \"array\",\n  names: [\"matrix\", \"pmatrix\", \"bmatrix\", \"Bmatrix\", \"vmatrix\", \"Vmatrix\", \"matrix*\", \"pmatrix*\", \"bmatrix*\", \"Bmatrix*\", \"vmatrix*\", \"Vmatrix*\"],\n  props: {\n    numArgs: 0\n  },\n\n  handler(context) {\n    var delimiters = {\n      \"matrix\": null,\n      \"pmatrix\": [\"(\", \")\"],\n      \"bmatrix\": [\"[\", \"]\"],\n      \"Bmatrix\": [\"\\\\{\", \"\\\\}\"],\n      \"vmatrix\": [\"|\", \"|\"],\n      \"Vmatrix\": [\"\\\\Vert\", \"\\\\Vert\"]\n    }[context.envName.replace(\"*\", \"\")]; // \\hskip -\\arraycolsep in amsmath\n\n    var colAlign = \"c\";\n    var payload = {\n      hskipBeforeAndAfter: false,\n      cols: [{\n        type: \"align\",\n        align: colAlign\n      }]\n    };\n\n    if (context.envName.charAt(context.envName.length - 1) === \"*\") {\n      // It's one of the mathtools starred functions.\n      // Parse the optional alignment argument.\n      var parser = context.parser;\n      parser.consumeSpaces();\n\n      if (parser.fetch().text === \"[\") {\n        parser.consume();\n        parser.consumeSpaces();\n        colAlign = parser.fetch().text;\n\n        if (\"lcr\".indexOf(colAlign) === -1) {\n          throw new ParseError(\"Expected l or c or r\", parser.nextToken);\n        }\n\n        parser.consume();\n        parser.consumeSpaces();\n        parser.expect(\"]\");\n        parser.consume();\n        payload.cols = [{\n          type: \"align\",\n          align: colAlign\n        }];\n      }\n    }\n\n    var res = parseArray(context.parser, payload, dCellStyle(context.envName)); // Populate cols with the correct number of column alignment specs.\n\n    var numCols = Math.max(0, ...res.body.map(row => row.length));\n    res.cols = new Array(numCols).fill({\n      type: \"align\",\n      align: colAlign\n    });\n    return delimiters ? {\n      type: \"leftright\",\n      mode: context.mode,\n      body: [res],\n      left: delimiters[0],\n      right: delimiters[1],\n      rightColor: undefined // \\right uninfluenced by \\color in array\n\n    } : res;\n  },\n\n  htmlBuilder: htmlBuilder$6,\n  mathmlBuilder: mathmlBuilder$5\n});\ndefineEnvironment({\n  type: \"array\",\n  names: [\"smallmatrix\"],\n  props: {\n    numArgs: 0\n  },\n\n  handler(context) {\n    var payload = {\n      arraystretch: 0.5\n    };\n    var res = parseArray(context.parser, payload, \"script\");\n    res.colSeparationType = \"small\";\n    return res;\n  },\n\n  htmlBuilder: htmlBuilder$6,\n  mathmlBuilder: mathmlBuilder$5\n});\ndefineEnvironment({\n  type: \"array\",\n  names: [\"subarray\"],\n  props: {\n    numArgs: 1\n  },\n\n  handler(context, args) {\n    // Parsing of {subarray} is similar to {array}\n    var symNode = checkSymbolNodeType(args[0]);\n    var colalign = symNode ? [args[0]] : assertNodeType(args[0], \"ordgroup\").body;\n    var cols = colalign.map(function (nde) {\n      var node = assertSymbolNodeType(nde);\n      var ca = node.text; // {subarray} only recognizes \"l\" & \"c\"\n\n      if (\"lc\".indexOf(ca) !== -1) {\n        return {\n          type: \"align\",\n          align: ca\n        };\n      }\n\n      throw new ParseError(\"Unknown column alignment: \" + ca, nde);\n    });\n\n    if (cols.length > 1) {\n      throw new ParseError(\"{subarray} can contain only one column\");\n    }\n\n    var res = {\n      cols,\n      hskipBeforeAndAfter: false,\n      arraystretch: 0.5\n    };\n    res = parseArray(context.parser, res, \"script\");\n\n    if (res.body.length > 0 && res.body[0].length > 1) {\n      throw new ParseError(\"{subarray} can contain only one column\");\n    }\n\n    return res;\n  },\n\n  htmlBuilder: htmlBuilder$6,\n  mathmlBuilder: mathmlBuilder$5\n}); // A cases environment (in amsmath.sty) is almost equivalent to\n// \\def\\arraystretch{1.2}%\n// \\left\\{\\begin{array}{@{}l@{\\quad}l@{}} … \\end{array}\\right.\n// {dcases} is a {cases} environment where cells are set in \\displaystyle,\n// as defined in mathtools.sty.\n// {rcases} is another mathtools environment. It's brace is on the right side.\n\ndefineEnvironment({\n  type: \"array\",\n  names: [\"cases\", \"dcases\", \"rcases\", \"drcases\"],\n  props: {\n    numArgs: 0\n  },\n\n  handler(context) {\n    var payload = {\n      arraystretch: 1.2,\n      cols: [{\n        type: \"align\",\n        align: \"l\",\n        pregap: 0,\n        // TODO(kevinb) get the current style.\n        // For now we use the metrics for TEXT style which is what we were\n        // doing before.  Before attempting to get the current style we\n        // should look at TeX's behavior especially for \\over and matrices.\n        postgap: 1.0\n        /* 1em quad */\n\n      }, {\n        type: \"align\",\n        align: \"l\",\n        pregap: 0,\n        postgap: 0\n      }]\n    };\n    var res = parseArray(context.parser, payload, dCellStyle(context.envName));\n    return {\n      type: \"leftright\",\n      mode: context.mode,\n      body: [res],\n      left: context.envName.indexOf(\"r\") > -1 ? \".\" : \"\\\\{\",\n      right: context.envName.indexOf(\"r\") > -1 ? \"\\\\}\" : \".\",\n      rightColor: undefined\n    };\n  },\n\n  htmlBuilder: htmlBuilder$6,\n  mathmlBuilder: mathmlBuilder$5\n}); // In the align environment, one uses ampersands, &, to specify number of\n// columns in each row, and to locate spacing between each column.\n// align gets automatic numbering. align* and aligned do not.\n// The alignedat environment can be used in math mode.\n// Note that we assume \\nomallineskiplimit to be zero,\n// so that \\strut@ is the same as \\strut.\n\ndefineEnvironment({\n  type: \"array\",\n  names: [\"align\", \"align*\", \"aligned\", \"split\"],\n  props: {\n    numArgs: 0\n  },\n  handler: alignedHandler,\n  htmlBuilder: htmlBuilder$6,\n  mathmlBuilder: mathmlBuilder$5\n}); // A gathered environment is like an array environment with one centered\n// column, but where rows are considered lines so get \\jot line spacing\n// and contents are set in \\displaystyle.\n\ndefineEnvironment({\n  type: \"array\",\n  names: [\"gathered\", \"gather\", \"gather*\"],\n  props: {\n    numArgs: 0\n  },\n\n  handler(context) {\n    if (utils.contains([\"gather\", \"gather*\"], context.envName)) {\n      validateAmsEnvironmentContext(context);\n    }\n\n    var res = {\n      cols: [{\n        type: \"align\",\n        align: \"c\"\n      }],\n      addJot: true,\n      colSeparationType: \"gather\",\n      autoTag: getAutoTag(context.envName),\n      emptySingleRow: true,\n      leqno: context.parser.settings.leqno\n    };\n    return parseArray(context.parser, res, \"display\");\n  },\n\n  htmlBuilder: htmlBuilder$6,\n  mathmlBuilder: mathmlBuilder$5\n}); // alignat environment is like an align environment, but one must explicitly\n// specify maximum number of columns in each row, and can adjust spacing between\n// each columns.\n\ndefineEnvironment({\n  type: \"array\",\n  names: [\"alignat\", \"alignat*\", \"alignedat\"],\n  props: {\n    numArgs: 1\n  },\n  handler: alignedHandler,\n  htmlBuilder: htmlBuilder$6,\n  mathmlBuilder: mathmlBuilder$5\n});\ndefineEnvironment({\n  type: \"array\",\n  names: [\"equation\", \"equation*\"],\n  props: {\n    numArgs: 0\n  },\n\n  handler(context) {\n    validateAmsEnvironmentContext(context);\n    var res = {\n      autoTag: getAutoTag(context.envName),\n      emptySingleRow: true,\n      singleRow: true,\n      maxNumCols: 1,\n      leqno: context.parser.settings.leqno\n    };\n    return parseArray(context.parser, res, \"display\");\n  },\n\n  htmlBuilder: htmlBuilder$6,\n  mathmlBuilder: mathmlBuilder$5\n});\ndefineEnvironment({\n  type: \"array\",\n  names: [\"CD\"],\n  props: {\n    numArgs: 0\n  },\n\n  handler(context) {\n    validateAmsEnvironmentContext(context);\n    return parseCD(context.parser);\n  },\n\n  htmlBuilder: htmlBuilder$6,\n  mathmlBuilder: mathmlBuilder$5\n});\ndefineMacro(\"\\\\nonumber\", \"\\\\gdef\\\\@eqnsw{0}\");\ndefineMacro(\"\\\\notag\", \"\\\\nonumber\"); // Catch \\hline outside array environment\n\ndefineFunction({\n  type: \"text\",\n  // Doesn't matter what this is.\n  names: [\"\\\\hline\", \"\\\\hdashline\"],\n  props: {\n    numArgs: 0,\n    allowedInText: true,\n    allowedInMath: true\n  },\n\n  handler(context, args) {\n    throw new ParseError(context.funcName + \" valid only within array environment\");\n  }\n\n});\n\nvar environments = _environments;\n\n// defineEnvironment definitions.\n\ndefineFunction({\n  type: \"environment\",\n  names: [\"\\\\begin\", \"\\\\end\"],\n  props: {\n    numArgs: 1,\n    argTypes: [\"text\"]\n  },\n\n  handler(_ref, args) {\n    var {\n      parser,\n      funcName\n    } = _ref;\n    var nameGroup = args[0];\n\n    if (nameGroup.type !== \"ordgroup\") {\n      throw new ParseError(\"Invalid environment name\", nameGroup);\n    }\n\n    var envName = \"\";\n\n    for (var i = 0; i < nameGroup.body.length; ++i) {\n      envName += assertNodeType(nameGroup.body[i], \"textord\").text;\n    }\n\n    if (funcName === \"\\\\begin\") {\n      // begin...end is similar to left...right\n      if (!environments.hasOwnProperty(envName)) {\n        throw new ParseError(\"No such environment: \" + envName, nameGroup);\n      } // Build the environment object. Arguments and other information will\n      // be made available to the begin and end methods using properties.\n\n\n      var env = environments[envName];\n      var {\n        args: _args,\n        optArgs\n      } = parser.parseArguments(\"\\\\begin{\" + envName + \"}\", env);\n      var context = {\n        mode: parser.mode,\n        envName,\n        parser\n      };\n      var result = env.handler(context, _args, optArgs);\n      parser.expect(\"\\\\end\", false);\n      var endNameToken = parser.nextToken;\n      var end = assertNodeType(parser.parseFunction(), \"environment\");\n\n      if (end.name !== envName) {\n        throw new ParseError(\"Mismatch: \\\\begin{\" + envName + \"} matched by \\\\end{\" + end.name + \"}\", endNameToken);\n      } // $FlowFixMe, \"environment\" handler returns an environment ParseNode\n\n\n      return result;\n    }\n\n    return {\n      type: \"environment\",\n      mode: parser.mode,\n      name: envName,\n      nameGroup\n    };\n  }\n\n});\n\n// TODO(kevinb): implement \\\\sl and \\\\sc\n\nvar htmlBuilder$5 = (group, options) => {\n  var font = group.font;\n  var newOptions = options.withFont(font);\n  return buildGroup$1(group.body, newOptions);\n};\n\nvar mathmlBuilder$4 = (group, options) => {\n  var font = group.font;\n  var newOptions = options.withFont(font);\n  return buildGroup(group.body, newOptions);\n};\n\nvar fontAliases = {\n  \"\\\\Bbb\": \"\\\\mathbb\",\n  \"\\\\bold\": \"\\\\mathbf\",\n  \"\\\\frak\": \"\\\\mathfrak\",\n  \"\\\\bm\": \"\\\\boldsymbol\"\n};\ndefineFunction({\n  type: \"font\",\n  names: [// styles, except \\boldsymbol defined below\n  \"\\\\mathrm\", \"\\\\mathit\", \"\\\\mathbf\", \"\\\\mathnormal\", \"\\\\mathsfit\", // families\n  \"\\\\mathbb\", \"\\\\mathcal\", \"\\\\mathfrak\", \"\\\\mathscr\", \"\\\\mathsf\", \"\\\\mathtt\", // aliases, except \\bm defined below\n  \"\\\\Bbb\", \"\\\\bold\", \"\\\\frak\"],\n  props: {\n    numArgs: 1,\n    allowedInArgument: true\n  },\n  handler: (_ref, args) => {\n    var {\n      parser,\n      funcName\n    } = _ref;\n    var body = normalizeArgument(args[0]);\n    var func = funcName;\n\n    if (func in fontAliases) {\n      func = fontAliases[func];\n    }\n\n    return {\n      type: \"font\",\n      mode: parser.mode,\n      font: func.slice(1),\n      body\n    };\n  },\n  htmlBuilder: htmlBuilder$5,\n  mathmlBuilder: mathmlBuilder$4\n});\ndefineFunction({\n  type: \"mclass\",\n  names: [\"\\\\boldsymbol\", \"\\\\bm\"],\n  props: {\n    numArgs: 1\n  },\n  handler: (_ref2, args) => {\n    var {\n      parser\n    } = _ref2;\n    var body = args[0];\n    var isCharacterBox = utils.isCharacterBox(body); // amsbsy.sty's \\boldsymbol uses \\binrel spacing to inherit the\n    // argument's bin|rel|ord status\n\n    return {\n      type: \"mclass\",\n      mode: parser.mode,\n      mclass: binrelClass(body),\n      body: [{\n        type: \"font\",\n        mode: parser.mode,\n        font: \"boldsymbol\",\n        body\n      }],\n      isCharacterBox: isCharacterBox\n    };\n  }\n}); // Old font changing functions\n\ndefineFunction({\n  type: \"font\",\n  names: [\"\\\\rm\", \"\\\\sf\", \"\\\\tt\", \"\\\\bf\", \"\\\\it\", \"\\\\cal\"],\n  props: {\n    numArgs: 0,\n    allowedInText: true\n  },\n  handler: (_ref3, args) => {\n    var {\n      parser,\n      funcName,\n      breakOnTokenText\n    } = _ref3;\n    var {\n      mode\n    } = parser;\n    var body = parser.parseExpression(true, breakOnTokenText);\n    var style = \"math\" + funcName.slice(1);\n    return {\n      type: \"font\",\n      mode: mode,\n      font: style,\n      body: {\n        type: \"ordgroup\",\n        mode: parser.mode,\n        body\n      }\n    };\n  },\n  htmlBuilder: htmlBuilder$5,\n  mathmlBuilder: mathmlBuilder$4\n});\n\nvar adjustStyle = (size, originalStyle) => {\n  // Figure out what style this fraction should be in based on the\n  // function used\n  var style = originalStyle;\n\n  if (size === \"display\") {\n    // Get display style as a default.\n    // If incoming style is sub/sup, use style.text() to get correct size.\n    style = style.id >= Style$1.SCRIPT.id ? style.text() : Style$1.DISPLAY;\n  } else if (size === \"text\" && style.size === Style$1.DISPLAY.size) {\n    // We're in a \\tfrac but incoming style is displaystyle, so:\n    style = Style$1.TEXT;\n  } else if (size === \"script\") {\n    style = Style$1.SCRIPT;\n  } else if (size === \"scriptscript\") {\n    style = Style$1.SCRIPTSCRIPT;\n  }\n\n  return style;\n};\n\nvar htmlBuilder$4 = (group, options) => {\n  // Fractions are handled in the TeXbook on pages 444-445, rules 15(a-e).\n  var style = adjustStyle(group.size, options.style);\n  var nstyle = style.fracNum();\n  var dstyle = style.fracDen();\n  var newOptions;\n  newOptions = options.havingStyle(nstyle);\n  var numerm = buildGroup$1(group.numer, newOptions, options);\n\n  if (group.continued) {\n    // \\cfrac inserts a \\strut into the numerator.\n    // Get \\strut dimensions from TeXbook page 353.\n    var hStrut = 8.5 / options.fontMetrics().ptPerEm;\n    var dStrut = 3.5 / options.fontMetrics().ptPerEm;\n    numerm.height = numerm.height < hStrut ? hStrut : numerm.height;\n    numerm.depth = numerm.depth < dStrut ? dStrut : numerm.depth;\n  }\n\n  newOptions = options.havingStyle(dstyle);\n  var denomm = buildGroup$1(group.denom, newOptions, options);\n  var rule;\n  var ruleWidth;\n  var ruleSpacing;\n\n  if (group.hasBarLine) {\n    if (group.barSize) {\n      ruleWidth = calculateSize(group.barSize, options);\n      rule = buildCommon.makeLineSpan(\"frac-line\", options, ruleWidth);\n    } else {\n      rule = buildCommon.makeLineSpan(\"frac-line\", options);\n    }\n\n    ruleWidth = rule.height;\n    ruleSpacing = rule.height;\n  } else {\n    rule = null;\n    ruleWidth = 0;\n    ruleSpacing = options.fontMetrics().defaultRuleThickness;\n  } // Rule 15b\n\n\n  var numShift;\n  var clearance;\n  var denomShift;\n\n  if (style.size === Style$1.DISPLAY.size || group.size === \"display\") {\n    numShift = options.fontMetrics().num1;\n\n    if (ruleWidth > 0) {\n      clearance = 3 * ruleSpacing;\n    } else {\n      clearance = 7 * ruleSpacing;\n    }\n\n    denomShift = options.fontMetrics().denom1;\n  } else {\n    if (ruleWidth > 0) {\n      numShift = options.fontMetrics().num2;\n      clearance = ruleSpacing;\n    } else {\n      numShift = options.fontMetrics().num3;\n      clearance = 3 * ruleSpacing;\n    }\n\n    denomShift = options.fontMetrics().denom2;\n  }\n\n  var frac;\n\n  if (!rule) {\n    // Rule 15c\n    var candidateClearance = numShift - numerm.depth - (denomm.height - denomShift);\n\n    if (candidateClearance < clearance) {\n      numShift += 0.5 * (clearance - candidateClearance);\n      denomShift += 0.5 * (clearance - candidateClearance);\n    }\n\n    frac = buildCommon.makeVList({\n      positionType: \"individualShift\",\n      children: [{\n        type: \"elem\",\n        elem: denomm,\n        shift: denomShift\n      }, {\n        type: \"elem\",\n        elem: numerm,\n        shift: -numShift\n      }]\n    }, options);\n  } else {\n    // Rule 15d\n    var axisHeight = options.fontMetrics().axisHeight;\n\n    if (numShift - numerm.depth - (axisHeight + 0.5 * ruleWidth) < clearance) {\n      numShift += clearance - (numShift - numerm.depth - (axisHeight + 0.5 * ruleWidth));\n    }\n\n    if (axisHeight - 0.5 * ruleWidth - (denomm.height - denomShift) < clearance) {\n      denomShift += clearance - (axisHeight - 0.5 * ruleWidth - (denomm.height - denomShift));\n    }\n\n    var midShift = -(axisHeight - 0.5 * ruleWidth);\n    frac = buildCommon.makeVList({\n      positionType: \"individualShift\",\n      children: [{\n        type: \"elem\",\n        elem: denomm,\n        shift: denomShift\n      }, {\n        type: \"elem\",\n        elem: rule,\n        shift: midShift\n      }, {\n        type: \"elem\",\n        elem: numerm,\n        shift: -numShift\n      }]\n    }, options);\n  } // Since we manually change the style sometimes (with \\dfrac or \\tfrac),\n  // account for the possible size change here.\n\n\n  newOptions = options.havingStyle(style);\n  frac.height *= newOptions.sizeMultiplier / options.sizeMultiplier;\n  frac.depth *= newOptions.sizeMultiplier / options.sizeMultiplier; // Rule 15e\n\n  var delimSize;\n\n  if (style.size === Style$1.DISPLAY.size) {\n    delimSize = options.fontMetrics().delim1;\n  } else if (style.size === Style$1.SCRIPTSCRIPT.size) {\n    delimSize = options.havingStyle(Style$1.SCRIPT).fontMetrics().delim2;\n  } else {\n    delimSize = options.fontMetrics().delim2;\n  }\n\n  var leftDelim;\n  var rightDelim;\n\n  if (group.leftDelim == null) {\n    leftDelim = makeNullDelimiter(options, [\"mopen\"]);\n  } else {\n    leftDelim = delimiter.customSizedDelim(group.leftDelim, delimSize, true, options.havingStyle(style), group.mode, [\"mopen\"]);\n  }\n\n  if (group.continued) {\n    rightDelim = buildCommon.makeSpan([]); // zero width for \\cfrac\n  } else if (group.rightDelim == null) {\n    rightDelim = makeNullDelimiter(options, [\"mclose\"]);\n  } else {\n    rightDelim = delimiter.customSizedDelim(group.rightDelim, delimSize, true, options.havingStyle(style), group.mode, [\"mclose\"]);\n  }\n\n  return buildCommon.makeSpan([\"mord\"].concat(newOptions.sizingClasses(options)), [leftDelim, buildCommon.makeSpan([\"mfrac\"], [frac]), rightDelim], options);\n};\n\nvar mathmlBuilder$3 = (group, options) => {\n  var node = new mathMLTree.MathNode(\"mfrac\", [buildGroup(group.numer, options), buildGroup(group.denom, options)]);\n\n  if (!group.hasBarLine) {\n    node.setAttribute(\"linethickness\", \"0px\");\n  } else if (group.barSize) {\n    var ruleWidth = calculateSize(group.barSize, options);\n    node.setAttribute(\"linethickness\", makeEm(ruleWidth));\n  }\n\n  var style = adjustStyle(group.size, options.style);\n\n  if (style.size !== options.style.size) {\n    node = new mathMLTree.MathNode(\"mstyle\", [node]);\n    var isDisplay = style.size === Style$1.DISPLAY.size ? \"true\" : \"false\";\n    node.setAttribute(\"displaystyle\", isDisplay);\n    node.setAttribute(\"scriptlevel\", \"0\");\n  }\n\n  if (group.leftDelim != null || group.rightDelim != null) {\n    var withDelims = [];\n\n    if (group.leftDelim != null) {\n      var leftOp = new mathMLTree.MathNode(\"mo\", [new mathMLTree.TextNode(group.leftDelim.replace(\"\\\\\", \"\"))]);\n      leftOp.setAttribute(\"fence\", \"true\");\n      withDelims.push(leftOp);\n    }\n\n    withDelims.push(node);\n\n    if (group.rightDelim != null) {\n      var rightOp = new mathMLTree.MathNode(\"mo\", [new mathMLTree.TextNode(group.rightDelim.replace(\"\\\\\", \"\"))]);\n      rightOp.setAttribute(\"fence\", \"true\");\n      withDelims.push(rightOp);\n    }\n\n    return makeRow(withDelims);\n  }\n\n  return node;\n};\n\ndefineFunction({\n  type: \"genfrac\",\n  names: [\"\\\\dfrac\", \"\\\\frac\", \"\\\\tfrac\", \"\\\\dbinom\", \"\\\\binom\", \"\\\\tbinom\", \"\\\\\\\\atopfrac\", // can’t be entered directly\n  \"\\\\\\\\bracefrac\", \"\\\\\\\\brackfrac\" // ditto\n  ],\n  props: {\n    numArgs: 2,\n    allowedInArgument: true\n  },\n  handler: (_ref, args) => {\n    var {\n      parser,\n      funcName\n    } = _ref;\n    var numer = args[0];\n    var denom = args[1];\n    var hasBarLine;\n    var leftDelim = null;\n    var rightDelim = null;\n    var size = \"auto\";\n\n    switch (funcName) {\n      case \"\\\\dfrac\":\n      case \"\\\\frac\":\n      case \"\\\\tfrac\":\n        hasBarLine = true;\n        break;\n\n      case \"\\\\\\\\atopfrac\":\n        hasBarLine = false;\n        break;\n\n      case \"\\\\dbinom\":\n      case \"\\\\binom\":\n      case \"\\\\tbinom\":\n        hasBarLine = false;\n        leftDelim = \"(\";\n        rightDelim = \")\";\n        break;\n\n      case \"\\\\\\\\bracefrac\":\n        hasBarLine = false;\n        leftDelim = \"\\\\{\";\n        rightDelim = \"\\\\}\";\n        break;\n\n      case \"\\\\\\\\brackfrac\":\n        hasBarLine = false;\n        leftDelim = \"[\";\n        rightDelim = \"]\";\n        break;\n\n      default:\n        throw new Error(\"Unrecognized genfrac command\");\n    }\n\n    switch (funcName) {\n      case \"\\\\dfrac\":\n      case \"\\\\dbinom\":\n        size = \"display\";\n        break;\n\n      case \"\\\\tfrac\":\n      case \"\\\\tbinom\":\n        size = \"text\";\n        break;\n    }\n\n    return {\n      type: \"genfrac\",\n      mode: parser.mode,\n      continued: false,\n      numer,\n      denom,\n      hasBarLine,\n      leftDelim,\n      rightDelim,\n      size,\n      barSize: null\n    };\n  },\n  htmlBuilder: htmlBuilder$4,\n  mathmlBuilder: mathmlBuilder$3\n});\ndefineFunction({\n  type: \"genfrac\",\n  names: [\"\\\\cfrac\"],\n  props: {\n    numArgs: 2\n  },\n  handler: (_ref2, args) => {\n    var {\n      parser,\n      funcName\n    } = _ref2;\n    var numer = args[0];\n    var denom = args[1];\n    return {\n      type: \"genfrac\",\n      mode: parser.mode,\n      continued: true,\n      numer,\n      denom,\n      hasBarLine: true,\n      leftDelim: null,\n      rightDelim: null,\n      size: \"display\",\n      barSize: null\n    };\n  }\n}); // Infix generalized fractions -- these are not rendered directly, but replaced\n// immediately by one of the variants above.\n\ndefineFunction({\n  type: \"infix\",\n  names: [\"\\\\over\", \"\\\\choose\", \"\\\\atop\", \"\\\\brace\", \"\\\\brack\"],\n  props: {\n    numArgs: 0,\n    infix: true\n  },\n\n  handler(_ref3) {\n    var {\n      parser,\n      funcName,\n      token\n    } = _ref3;\n    var replaceWith;\n\n    switch (funcName) {\n      case \"\\\\over\":\n        replaceWith = \"\\\\frac\";\n        break;\n\n      case \"\\\\choose\":\n        replaceWith = \"\\\\binom\";\n        break;\n\n      case \"\\\\atop\":\n        replaceWith = \"\\\\\\\\atopfrac\";\n        break;\n\n      case \"\\\\brace\":\n        replaceWith = \"\\\\\\\\bracefrac\";\n        break;\n\n      case \"\\\\brack\":\n        replaceWith = \"\\\\\\\\brackfrac\";\n        break;\n\n      default:\n        throw new Error(\"Unrecognized infix genfrac command\");\n    }\n\n    return {\n      type: \"infix\",\n      mode: parser.mode,\n      replaceWith,\n      token\n    };\n  }\n\n});\nvar stylArray = [\"display\", \"text\", \"script\", \"scriptscript\"];\n\nvar delimFromValue = function delimFromValue(delimString) {\n  var delim = null;\n\n  if (delimString.length > 0) {\n    delim = delimString;\n    delim = delim === \".\" ? null : delim;\n  }\n\n  return delim;\n};\n\ndefineFunction({\n  type: \"genfrac\",\n  names: [\"\\\\genfrac\"],\n  props: {\n    numArgs: 6,\n    allowedInArgument: true,\n    argTypes: [\"math\", \"math\", \"size\", \"text\", \"math\", \"math\"]\n  },\n\n  handler(_ref4, args) {\n    var {\n      parser\n    } = _ref4;\n    var numer = args[4];\n    var denom = args[5]; // Look into the parse nodes to get the desired delimiters.\n\n    var leftNode = normalizeArgument(args[0]);\n    var leftDelim = leftNode.type === \"atom\" && leftNode.family === \"open\" ? delimFromValue(leftNode.text) : null;\n    var rightNode = normalizeArgument(args[1]);\n    var rightDelim = rightNode.type === \"atom\" && rightNode.family === \"close\" ? delimFromValue(rightNode.text) : null;\n    var barNode = assertNodeType(args[2], \"size\");\n    var hasBarLine;\n    var barSize = null;\n\n    if (barNode.isBlank) {\n      // \\genfrac acts differently than \\above.\n      // \\genfrac treats an empty size group as a signal to use a\n      // standard bar size. \\above would see size = 0 and omit the bar.\n      hasBarLine = true;\n    } else {\n      barSize = barNode.value;\n      hasBarLine = barSize.number > 0;\n    } // Find out if we want displaystyle, textstyle, etc.\n\n\n    var size = \"auto\";\n    var styl = args[3];\n\n    if (styl.type === \"ordgroup\") {\n      if (styl.body.length > 0) {\n        var textOrd = assertNodeType(styl.body[0], \"textord\");\n        size = stylArray[Number(textOrd.text)];\n      }\n    } else {\n      styl = assertNodeType(styl, \"textord\");\n      size = stylArray[Number(styl.text)];\n    }\n\n    return {\n      type: \"genfrac\",\n      mode: parser.mode,\n      numer,\n      denom,\n      continued: false,\n      hasBarLine,\n      barSize,\n      leftDelim,\n      rightDelim,\n      size\n    };\n  },\n\n  htmlBuilder: htmlBuilder$4,\n  mathmlBuilder: mathmlBuilder$3\n}); // \\above is an infix fraction that also defines a fraction bar size.\n\ndefineFunction({\n  type: \"infix\",\n  names: [\"\\\\above\"],\n  props: {\n    numArgs: 1,\n    argTypes: [\"size\"],\n    infix: true\n  },\n\n  handler(_ref5, args) {\n    var {\n      parser,\n      funcName,\n      token\n    } = _ref5;\n    return {\n      type: \"infix\",\n      mode: parser.mode,\n      replaceWith: \"\\\\\\\\abovefrac\",\n      size: assertNodeType(args[0], \"size\").value,\n      token\n    };\n  }\n\n});\ndefineFunction({\n  type: \"genfrac\",\n  names: [\"\\\\\\\\abovefrac\"],\n  props: {\n    numArgs: 3,\n    argTypes: [\"math\", \"size\", \"math\"]\n  },\n  handler: (_ref6, args) => {\n    var {\n      parser,\n      funcName\n    } = _ref6;\n    var numer = args[0];\n    var barSize = assert(assertNodeType(args[1], \"infix\").size);\n    var denom = args[2];\n    var hasBarLine = barSize.number > 0;\n    return {\n      type: \"genfrac\",\n      mode: parser.mode,\n      numer,\n      denom,\n      continued: false,\n      hasBarLine,\n      barSize,\n      leftDelim: null,\n      rightDelim: null,\n      size: \"auto\"\n    };\n  },\n  htmlBuilder: htmlBuilder$4,\n  mathmlBuilder: mathmlBuilder$3\n});\n\n// NOTE: Unlike most `htmlBuilder`s, this one handles not only \"horizBrace\", but\n// also \"supsub\" since an over/underbrace can affect super/subscripting.\nvar htmlBuilder$3 = (grp, options) => {\n  var style = options.style; // Pull out the `ParseNode<\"horizBrace\">` if `grp` is a \"supsub\" node.\n\n  var supSubGroup;\n  var group;\n\n  if (grp.type === \"supsub\") {\n    // Ref: LaTeX source2e: }}}}\\limits}\n    // i.e. LaTeX treats the brace similar to an op and passes it\n    // with \\limits, so we need to assign supsub style.\n    supSubGroup = grp.sup ? buildGroup$1(grp.sup, options.havingStyle(style.sup()), options) : buildGroup$1(grp.sub, options.havingStyle(style.sub()), options);\n    group = assertNodeType(grp.base, \"horizBrace\");\n  } else {\n    group = assertNodeType(grp, \"horizBrace\");\n  } // Build the base group\n\n\n  var body = buildGroup$1(group.base, options.havingBaseStyle(Style$1.DISPLAY)); // Create the stretchy element\n\n  var braceBody = stretchy.svgSpan(group, options); // Generate the vlist, with the appropriate kerns        ┏━━━━━━━━┓\n  // This first vlist contains the content and the brace:   equation\n\n  var vlist;\n\n  if (group.isOver) {\n    vlist = buildCommon.makeVList({\n      positionType: \"firstBaseline\",\n      children: [{\n        type: \"elem\",\n        elem: body\n      }, {\n        type: \"kern\",\n        size: 0.1\n      }, {\n        type: \"elem\",\n        elem: braceBody\n      }]\n    }, options); // $FlowFixMe: Replace this with passing \"svg-align\" into makeVList.\n\n    vlist.children[0].children[0].children[1].classes.push(\"svg-align\");\n  } else {\n    vlist = buildCommon.makeVList({\n      positionType: \"bottom\",\n      positionData: body.depth + 0.1 + braceBody.height,\n      children: [{\n        type: \"elem\",\n        elem: braceBody\n      }, {\n        type: \"kern\",\n        size: 0.1\n      }, {\n        type: \"elem\",\n        elem: body\n      }]\n    }, options); // $FlowFixMe: Replace this with passing \"svg-align\" into makeVList.\n\n    vlist.children[0].children[0].children[0].classes.push(\"svg-align\");\n  }\n\n  if (supSubGroup) {\n    // To write the supsub, wrap the first vlist in another vlist:\n    // They can't all go in the same vlist, because the note might be\n    // wider than the equation. We want the equation to control the\n    // brace width.\n    //      note          long note           long note\n    //   ┏━━━━━━━━┓   or    ┏━━━┓     not    ┏━━━━━━━━━┓\n    //    equation           eqn                 eqn\n    var vSpan = buildCommon.makeSpan([\"mord\", group.isOver ? \"mover\" : \"munder\"], [vlist], options);\n\n    if (group.isOver) {\n      vlist = buildCommon.makeVList({\n        positionType: \"firstBaseline\",\n        children: [{\n          type: \"elem\",\n          elem: vSpan\n        }, {\n          type: \"kern\",\n          size: 0.2\n        }, {\n          type: \"elem\",\n          elem: supSubGroup\n        }]\n      }, options);\n    } else {\n      vlist = buildCommon.makeVList({\n        positionType: \"bottom\",\n        positionData: vSpan.depth + 0.2 + supSubGroup.height + supSubGroup.depth,\n        children: [{\n          type: \"elem\",\n          elem: supSubGroup\n        }, {\n          type: \"kern\",\n          size: 0.2\n        }, {\n          type: \"elem\",\n          elem: vSpan\n        }]\n      }, options);\n    }\n  }\n\n  return buildCommon.makeSpan([\"mord\", group.isOver ? \"mover\" : \"munder\"], [vlist], options);\n};\n\nvar mathmlBuilder$2 = (group, options) => {\n  var accentNode = stretchy.mathMLnode(group.label);\n  return new mathMLTree.MathNode(group.isOver ? \"mover\" : \"munder\", [buildGroup(group.base, options), accentNode]);\n}; // Horizontal stretchy braces\n\n\ndefineFunction({\n  type: \"horizBrace\",\n  names: [\"\\\\overbrace\", \"\\\\underbrace\"],\n  props: {\n    numArgs: 1\n  },\n\n  handler(_ref, args) {\n    var {\n      parser,\n      funcName\n    } = _ref;\n    return {\n      type: \"horizBrace\",\n      mode: parser.mode,\n      label: funcName,\n      isOver: /^\\\\over/.test(funcName),\n      base: args[0]\n    };\n  },\n\n  htmlBuilder: htmlBuilder$3,\n  mathmlBuilder: mathmlBuilder$2\n});\n\ndefineFunction({\n  type: \"href\",\n  names: [\"\\\\href\"],\n  props: {\n    numArgs: 2,\n    argTypes: [\"url\", \"original\"],\n    allowedInText: true\n  },\n  handler: (_ref, args) => {\n    var {\n      parser\n    } = _ref;\n    var body = args[1];\n    var href = assertNodeType(args[0], \"url\").url;\n\n    if (!parser.settings.isTrusted({\n      command: \"\\\\href\",\n      url: href\n    })) {\n      return parser.formatUnsupportedCmd(\"\\\\href\");\n    }\n\n    return {\n      type: \"href\",\n      mode: parser.mode,\n      href,\n      body: ordargument(body)\n    };\n  },\n  htmlBuilder: (group, options) => {\n    var elements = buildExpression$1(group.body, options, false);\n    return buildCommon.makeAnchor(group.href, [], elements, options);\n  },\n  mathmlBuilder: (group, options) => {\n    var math = buildExpressionRow(group.body, options);\n\n    if (!(math instanceof MathNode)) {\n      math = new MathNode(\"mrow\", [math]);\n    }\n\n    math.setAttribute(\"href\", group.href);\n    return math;\n  }\n});\ndefineFunction({\n  type: \"href\",\n  names: [\"\\\\url\"],\n  props: {\n    numArgs: 1,\n    argTypes: [\"url\"],\n    allowedInText: true\n  },\n  handler: (_ref2, args) => {\n    var {\n      parser\n    } = _ref2;\n    var href = assertNodeType(args[0], \"url\").url;\n\n    if (!parser.settings.isTrusted({\n      command: \"\\\\url\",\n      url: href\n    })) {\n      return parser.formatUnsupportedCmd(\"\\\\url\");\n    }\n\n    var chars = [];\n\n    for (var i = 0; i < href.length; i++) {\n      var c = href[i];\n\n      if (c === \"~\") {\n        c = \"\\\\textasciitilde\";\n      }\n\n      chars.push({\n        type: \"textord\",\n        mode: \"text\",\n        text: c\n      });\n    }\n\n    var body = {\n      type: \"text\",\n      mode: parser.mode,\n      font: \"\\\\texttt\",\n      body: chars\n    };\n    return {\n      type: \"href\",\n      mode: parser.mode,\n      href,\n      body: ordargument(body)\n    };\n  }\n});\n\n// In LaTeX, \\vcenter can act only on a box, as in\n// \\vcenter{\\hbox{$\\frac{a+b}{\\dfrac{c}{d}}$}}\n// This function by itself doesn't do anything but prevent a soft line break.\n\ndefineFunction({\n  type: \"hbox\",\n  names: [\"\\\\hbox\"],\n  props: {\n    numArgs: 1,\n    argTypes: [\"text\"],\n    allowedInText: true,\n    primitive: true\n  },\n\n  handler(_ref, args) {\n    var {\n      parser\n    } = _ref;\n    return {\n      type: \"hbox\",\n      mode: parser.mode,\n      body: ordargument(args[0])\n    };\n  },\n\n  htmlBuilder(group, options) {\n    var elements = buildExpression$1(group.body, options, false);\n    return buildCommon.makeFragment(elements);\n  },\n\n  mathmlBuilder(group, options) {\n    return new mathMLTree.MathNode(\"mrow\", buildExpression(group.body, options));\n  }\n\n});\n\ndefineFunction({\n  type: \"html\",\n  names: [\"\\\\htmlClass\", \"\\\\htmlId\", \"\\\\htmlStyle\", \"\\\\htmlData\"],\n  props: {\n    numArgs: 2,\n    argTypes: [\"raw\", \"original\"],\n    allowedInText: true\n  },\n  handler: (_ref, args) => {\n    var {\n      parser,\n      funcName,\n      token\n    } = _ref;\n    var value = assertNodeType(args[0], \"raw\").string;\n    var body = args[1];\n\n    if (parser.settings.strict) {\n      parser.settings.reportNonstrict(\"htmlExtension\", \"HTML extension is disabled on strict mode\");\n    }\n\n    var trustContext;\n    var attributes = {};\n\n    switch (funcName) {\n      case \"\\\\htmlClass\":\n        attributes.class = value;\n        trustContext = {\n          command: \"\\\\htmlClass\",\n          class: value\n        };\n        break;\n\n      case \"\\\\htmlId\":\n        attributes.id = value;\n        trustContext = {\n          command: \"\\\\htmlId\",\n          id: value\n        };\n        break;\n\n      case \"\\\\htmlStyle\":\n        attributes.style = value;\n        trustContext = {\n          command: \"\\\\htmlStyle\",\n          style: value\n        };\n        break;\n\n      case \"\\\\htmlData\":\n        {\n          var data = value.split(\",\");\n\n          for (var i = 0; i < data.length; i++) {\n            var keyVal = data[i].split(\"=\");\n\n            if (keyVal.length !== 2) {\n              throw new ParseError(\"Error parsing key-value for \\\\htmlData\");\n            }\n\n            attributes[\"data-\" + keyVal[0].trim()] = keyVal[1].trim();\n          }\n\n          trustContext = {\n            command: \"\\\\htmlData\",\n            attributes\n          };\n          break;\n        }\n\n      default:\n        throw new Error(\"Unrecognized html command\");\n    }\n\n    if (!parser.settings.isTrusted(trustContext)) {\n      return parser.formatUnsupportedCmd(funcName);\n    }\n\n    return {\n      type: \"html\",\n      mode: parser.mode,\n      attributes,\n      body: ordargument(body)\n    };\n  },\n  htmlBuilder: (group, options) => {\n    var elements = buildExpression$1(group.body, options, false);\n    var classes = [\"enclosing\"];\n\n    if (group.attributes.class) {\n      classes.push(...group.attributes.class.trim().split(/\\s+/));\n    }\n\n    var span = buildCommon.makeSpan(classes, elements, options);\n\n    for (var attr in group.attributes) {\n      if (attr !== \"class\" && group.attributes.hasOwnProperty(attr)) {\n        span.setAttribute(attr, group.attributes[attr]);\n      }\n    }\n\n    return span;\n  },\n  mathmlBuilder: (group, options) => {\n    return buildExpressionRow(group.body, options);\n  }\n});\n\ndefineFunction({\n  type: \"htmlmathml\",\n  names: [\"\\\\html@mathml\"],\n  props: {\n    numArgs: 2,\n    allowedInText: true\n  },\n  handler: (_ref, args) => {\n    var {\n      parser\n    } = _ref;\n    return {\n      type: \"htmlmathml\",\n      mode: parser.mode,\n      html: ordargument(args[0]),\n      mathml: ordargument(args[1])\n    };\n  },\n  htmlBuilder: (group, options) => {\n    var elements = buildExpression$1(group.html, options, false);\n    return buildCommon.makeFragment(elements);\n  },\n  mathmlBuilder: (group, options) => {\n    return buildExpressionRow(group.mathml, options);\n  }\n});\n\nvar sizeData = function sizeData(str) {\n  if (/^[-+]? *(\\d+(\\.\\d*)?|\\.\\d+)$/.test(str)) {\n    // str is a number with no unit specified.\n    // default unit is bp, per graphix package.\n    return {\n      number: +str,\n      unit: \"bp\"\n    };\n  } else {\n    var match = /([-+]?) *(\\d+(?:\\.\\d*)?|\\.\\d+) *([a-z]{2})/.exec(str);\n\n    if (!match) {\n      throw new ParseError(\"Invalid size: '\" + str + \"' in \\\\includegraphics\");\n    }\n\n    var data = {\n      number: +(match[1] + match[2]),\n      // sign + magnitude, cast to number\n      unit: match[3]\n    };\n\n    if (!validUnit(data)) {\n      throw new ParseError(\"Invalid unit: '\" + data.unit + \"' in \\\\includegraphics.\");\n    }\n\n    return data;\n  }\n};\n\ndefineFunction({\n  type: \"includegraphics\",\n  names: [\"\\\\includegraphics\"],\n  props: {\n    numArgs: 1,\n    numOptionalArgs: 1,\n    argTypes: [\"raw\", \"url\"],\n    allowedInText: false\n  },\n  handler: (_ref, args, optArgs) => {\n    var {\n      parser\n    } = _ref;\n    var width = {\n      number: 0,\n      unit: \"em\"\n    };\n    var height = {\n      number: 0.9,\n      unit: \"em\"\n    }; // sorta character sized.\n\n    var totalheight = {\n      number: 0,\n      unit: \"em\"\n    };\n    var alt = \"\";\n\n    if (optArgs[0]) {\n      var attributeStr = assertNodeType(optArgs[0], \"raw\").string; // Parser.js does not parse key/value pairs. We get a string.\n\n      var attributes = attributeStr.split(\",\");\n\n      for (var i = 0; i < attributes.length; i++) {\n        var keyVal = attributes[i].split(\"=\");\n\n        if (keyVal.length === 2) {\n          var str = keyVal[1].trim();\n\n          switch (keyVal[0].trim()) {\n            case \"alt\":\n              alt = str;\n              break;\n\n            case \"width\":\n              width = sizeData(str);\n              break;\n\n            case \"height\":\n              height = sizeData(str);\n              break;\n\n            case \"totalheight\":\n              totalheight = sizeData(str);\n              break;\n\n            default:\n              throw new ParseError(\"Invalid key: '\" + keyVal[0] + \"' in \\\\includegraphics.\");\n          }\n        }\n      }\n    }\n\n    var src = assertNodeType(args[0], \"url\").url;\n\n    if (alt === \"\") {\n      // No alt given. Use the file name. Strip away the path.\n      alt = src;\n      alt = alt.replace(/^.*[\\\\/]/, '');\n      alt = alt.substring(0, alt.lastIndexOf('.'));\n    }\n\n    if (!parser.settings.isTrusted({\n      command: \"\\\\includegraphics\",\n      url: src\n    })) {\n      return parser.formatUnsupportedCmd(\"\\\\includegraphics\");\n    }\n\n    return {\n      type: \"includegraphics\",\n      mode: parser.mode,\n      alt: alt,\n      width: width,\n      height: height,\n      totalheight: totalheight,\n      src: src\n    };\n  },\n  htmlBuilder: (group, options) => {\n    var height = calculateSize(group.height, options);\n    var depth = 0;\n\n    if (group.totalheight.number > 0) {\n      depth = calculateSize(group.totalheight, options) - height;\n    }\n\n    var width = 0;\n\n    if (group.width.number > 0) {\n      width = calculateSize(group.width, options);\n    }\n\n    var style = {\n      height: makeEm(height + depth)\n    };\n\n    if (width > 0) {\n      style.width = makeEm(width);\n    }\n\n    if (depth > 0) {\n      style.verticalAlign = makeEm(-depth);\n    }\n\n    var node = new Img(group.src, group.alt, style);\n    node.height = height;\n    node.depth = depth;\n    return node;\n  },\n  mathmlBuilder: (group, options) => {\n    var node = new mathMLTree.MathNode(\"mglyph\", []);\n    node.setAttribute(\"alt\", group.alt);\n    var height = calculateSize(group.height, options);\n    var depth = 0;\n\n    if (group.totalheight.number > 0) {\n      depth = calculateSize(group.totalheight, options) - height;\n      node.setAttribute(\"valign\", makeEm(-depth));\n    }\n\n    node.setAttribute(\"height\", makeEm(height + depth));\n\n    if (group.width.number > 0) {\n      var width = calculateSize(group.width, options);\n      node.setAttribute(\"width\", makeEm(width));\n    }\n\n    node.setAttribute(\"src\", group.src);\n    return node;\n  }\n});\n\n// Horizontal spacing commands\n\ndefineFunction({\n  type: \"kern\",\n  names: [\"\\\\kern\", \"\\\\mkern\", \"\\\\hskip\", \"\\\\mskip\"],\n  props: {\n    numArgs: 1,\n    argTypes: [\"size\"],\n    primitive: true,\n    allowedInText: true\n  },\n\n  handler(_ref, args) {\n    var {\n      parser,\n      funcName\n    } = _ref;\n    var size = assertNodeType(args[0], \"size\");\n\n    if (parser.settings.strict) {\n      var mathFunction = funcName[1] === 'm'; // \\mkern, \\mskip\n\n      var muUnit = size.value.unit === 'mu';\n\n      if (mathFunction) {\n        if (!muUnit) {\n          parser.settings.reportNonstrict(\"mathVsTextUnits\", \"LaTeX's \" + funcName + \" supports only mu units, \" + (\"not \" + size.value.unit + \" units\"));\n        }\n\n        if (parser.mode !== \"math\") {\n          parser.settings.reportNonstrict(\"mathVsTextUnits\", \"LaTeX's \" + funcName + \" works only in math mode\");\n        }\n      } else {\n        // !mathFunction\n        if (muUnit) {\n          parser.settings.reportNonstrict(\"mathVsTextUnits\", \"LaTeX's \" + funcName + \" doesn't support mu units\");\n        }\n      }\n    }\n\n    return {\n      type: \"kern\",\n      mode: parser.mode,\n      dimension: size.value\n    };\n  },\n\n  htmlBuilder(group, options) {\n    return buildCommon.makeGlue(group.dimension, options);\n  },\n\n  mathmlBuilder(group, options) {\n    var dimension = calculateSize(group.dimension, options);\n    return new mathMLTree.SpaceNode(dimension);\n  }\n\n});\n\n// Horizontal overlap functions\ndefineFunction({\n  type: \"lap\",\n  names: [\"\\\\mathllap\", \"\\\\mathrlap\", \"\\\\mathclap\"],\n  props: {\n    numArgs: 1,\n    allowedInText: true\n  },\n  handler: (_ref, args) => {\n    var {\n      parser,\n      funcName\n    } = _ref;\n    var body = args[0];\n    return {\n      type: \"lap\",\n      mode: parser.mode,\n      alignment: funcName.slice(5),\n      body\n    };\n  },\n  htmlBuilder: (group, options) => {\n    // mathllap, mathrlap, mathclap\n    var inner;\n\n    if (group.alignment === \"clap\") {\n      // ref: https://www.math.lsu.edu/~aperlis/publications/mathclap/\n      inner = buildCommon.makeSpan([], [buildGroup$1(group.body, options)]); // wrap, since CSS will center a .clap > .inner > span\n\n      inner = buildCommon.makeSpan([\"inner\"], [inner], options);\n    } else {\n      inner = buildCommon.makeSpan([\"inner\"], [buildGroup$1(group.body, options)]);\n    }\n\n    var fix = buildCommon.makeSpan([\"fix\"], []);\n    var node = buildCommon.makeSpan([group.alignment], [inner, fix], options); // At this point, we have correctly set horizontal alignment of the\n    // two items involved in the lap.\n    // Next, use a strut to set the height of the HTML bounding box.\n    // Otherwise, a tall argument may be misplaced.\n    // This code resolved issue #1153\n\n    var strut = buildCommon.makeSpan([\"strut\"]);\n    strut.style.height = makeEm(node.height + node.depth);\n\n    if (node.depth) {\n      strut.style.verticalAlign = makeEm(-node.depth);\n    }\n\n    node.children.unshift(strut); // Next, prevent vertical misplacement when next to something tall.\n    // This code resolves issue #1234\n\n    node = buildCommon.makeSpan([\"thinbox\"], [node], options);\n    return buildCommon.makeSpan([\"mord\", \"vbox\"], [node], options);\n  },\n  mathmlBuilder: (group, options) => {\n    // mathllap, mathrlap, mathclap\n    var node = new mathMLTree.MathNode(\"mpadded\", [buildGroup(group.body, options)]);\n\n    if (group.alignment !== \"rlap\") {\n      var offset = group.alignment === \"llap\" ? \"-1\" : \"-0.5\";\n      node.setAttribute(\"lspace\", offset + \"width\");\n    }\n\n    node.setAttribute(\"width\", \"0px\");\n    return node;\n  }\n});\n\ndefineFunction({\n  type: \"styling\",\n  names: [\"\\\\(\", \"$\"],\n  props: {\n    numArgs: 0,\n    allowedInText: true,\n    allowedInMath: false\n  },\n\n  handler(_ref, args) {\n    var {\n      funcName,\n      parser\n    } = _ref;\n    var outerMode = parser.mode;\n    parser.switchMode(\"math\");\n    var close = funcName === \"\\\\(\" ? \"\\\\)\" : \"$\";\n    var body = parser.parseExpression(false, close);\n    parser.expect(close);\n    parser.switchMode(outerMode);\n    return {\n      type: \"styling\",\n      mode: parser.mode,\n      style: \"text\",\n      body\n    };\n  }\n\n}); // Check for extra closing math delimiters\n\ndefineFunction({\n  type: \"text\",\n  // Doesn't matter what this is.\n  names: [\"\\\\)\", \"\\\\]\"],\n  props: {\n    numArgs: 0,\n    allowedInText: true,\n    allowedInMath: false\n  },\n\n  handler(context, args) {\n    throw new ParseError(\"Mismatched \" + context.funcName);\n  }\n\n});\n\nvar chooseMathStyle = (group, options) => {\n  switch (options.style.size) {\n    case Style$1.DISPLAY.size:\n      return group.display;\n\n    case Style$1.TEXT.size:\n      return group.text;\n\n    case Style$1.SCRIPT.size:\n      return group.script;\n\n    case Style$1.SCRIPTSCRIPT.size:\n      return group.scriptscript;\n\n    default:\n      return group.text;\n  }\n};\n\ndefineFunction({\n  type: \"mathchoice\",\n  names: [\"\\\\mathchoice\"],\n  props: {\n    numArgs: 4,\n    primitive: true\n  },\n  handler: (_ref, args) => {\n    var {\n      parser\n    } = _ref;\n    return {\n      type: \"mathchoice\",\n      mode: parser.mode,\n      display: ordargument(args[0]),\n      text: ordargument(args[1]),\n      script: ordargument(args[2]),\n      scriptscript: ordargument(args[3])\n    };\n  },\n  htmlBuilder: (group, options) => {\n    var body = chooseMathStyle(group, options);\n    var elements = buildExpression$1(body, options, false);\n    return buildCommon.makeFragment(elements);\n  },\n  mathmlBuilder: (group, options) => {\n    var body = chooseMathStyle(group, options);\n    return buildExpressionRow(body, options);\n  }\n});\n\nvar assembleSupSub = (base, supGroup, subGroup, options, style, slant, baseShift) => {\n  base = buildCommon.makeSpan([], [base]);\n  var subIsSingleCharacter = subGroup && utils.isCharacterBox(subGroup);\n  var sub;\n  var sup; // We manually have to handle the superscripts and subscripts. This,\n  // aside from the kern calculations, is copied from supsub.\n\n  if (supGroup) {\n    var elem = buildGroup$1(supGroup, options.havingStyle(style.sup()), options);\n    sup = {\n      elem,\n      kern: Math.max(options.fontMetrics().bigOpSpacing1, options.fontMetrics().bigOpSpacing3 - elem.depth)\n    };\n  }\n\n  if (subGroup) {\n    var _elem = buildGroup$1(subGroup, options.havingStyle(style.sub()), options);\n\n    sub = {\n      elem: _elem,\n      kern: Math.max(options.fontMetrics().bigOpSpacing2, options.fontMetrics().bigOpSpacing4 - _elem.height)\n    };\n  } // Build the final group as a vlist of the possible subscript, base,\n  // and possible superscript.\n\n\n  var finalGroup;\n\n  if (sup && sub) {\n    var bottom = options.fontMetrics().bigOpSpacing5 + sub.elem.height + sub.elem.depth + sub.kern + base.depth + baseShift;\n    finalGroup = buildCommon.makeVList({\n      positionType: \"bottom\",\n      positionData: bottom,\n      children: [{\n        type: \"kern\",\n        size: options.fontMetrics().bigOpSpacing5\n      }, {\n        type: \"elem\",\n        elem: sub.elem,\n        marginLeft: makeEm(-slant)\n      }, {\n        type: \"kern\",\n        size: sub.kern\n      }, {\n        type: \"elem\",\n        elem: base\n      }, {\n        type: \"kern\",\n        size: sup.kern\n      }, {\n        type: \"elem\",\n        elem: sup.elem,\n        marginLeft: makeEm(slant)\n      }, {\n        type: \"kern\",\n        size: options.fontMetrics().bigOpSpacing5\n      }]\n    }, options);\n  } else if (sub) {\n    var top = base.height - baseShift; // Shift the limits by the slant of the symbol. Note\n    // that we are supposed to shift the limits by 1/2 of the slant,\n    // but since we are centering the limits adding a full slant of\n    // margin will shift by 1/2 that.\n\n    finalGroup = buildCommon.makeVList({\n      positionType: \"top\",\n      positionData: top,\n      children: [{\n        type: \"kern\",\n        size: options.fontMetrics().bigOpSpacing5\n      }, {\n        type: \"elem\",\n        elem: sub.elem,\n        marginLeft: makeEm(-slant)\n      }, {\n        type: \"kern\",\n        size: sub.kern\n      }, {\n        type: \"elem\",\n        elem: base\n      }]\n    }, options);\n  } else if (sup) {\n    var _bottom = base.depth + baseShift;\n\n    finalGroup = buildCommon.makeVList({\n      positionType: \"bottom\",\n      positionData: _bottom,\n      children: [{\n        type: \"elem\",\n        elem: base\n      }, {\n        type: \"kern\",\n        size: sup.kern\n      }, {\n        type: \"elem\",\n        elem: sup.elem,\n        marginLeft: makeEm(slant)\n      }, {\n        type: \"kern\",\n        size: options.fontMetrics().bigOpSpacing5\n      }]\n    }, options);\n  } else {\n    // This case probably shouldn't occur (this would mean the\n    // supsub was sending us a group with no superscript or\n    // subscript) but be safe.\n    return base;\n  }\n\n  var parts = [finalGroup];\n\n  if (sub && slant !== 0 && !subIsSingleCharacter) {\n    // A negative margin-left was applied to the lower limit.\n    // Avoid an overlap by placing a spacer on the left on the group.\n    var spacer = buildCommon.makeSpan([\"mspace\"], [], options);\n    spacer.style.marginRight = makeEm(slant);\n    parts.unshift(spacer);\n  }\n\n  return buildCommon.makeSpan([\"mop\", \"op-limits\"], parts, options);\n};\n\n// Limits, symbols\n// Most operators have a large successor symbol, but these don't.\nvar noSuccessor = [\"\\\\smallint\"]; // NOTE: Unlike most `htmlBuilder`s, this one handles not only \"op\", but also\n// \"supsub\" since some of them (like \\int) can affect super/subscripting.\n\nvar htmlBuilder$2 = (grp, options) => {\n  // Operators are handled in the TeXbook pg. 443-444, rule 13(a).\n  var supGroup;\n  var subGroup;\n  var hasLimits = false;\n  var group;\n\n  if (grp.type === \"supsub\") {\n    // If we have limits, supsub will pass us its group to handle. Pull\n    // out the superscript and subscript and set the group to the op in\n    // its base.\n    supGroup = grp.sup;\n    subGroup = grp.sub;\n    group = assertNodeType(grp.base, \"op\");\n    hasLimits = true;\n  } else {\n    group = assertNodeType(grp, \"op\");\n  }\n\n  var style = options.style;\n  var large = false;\n\n  if (style.size === Style$1.DISPLAY.size && group.symbol && !utils.contains(noSuccessor, group.name)) {\n    // Most symbol operators get larger in displaystyle (rule 13)\n    large = true;\n  }\n\n  var base;\n\n  if (group.symbol) {\n    // If this is a symbol, create the symbol.\n    var fontName = large ? \"Size2-Regular\" : \"Size1-Regular\";\n    var stash = \"\";\n\n    if (group.name === \"\\\\oiint\" || group.name === \"\\\\oiiint\") {\n      // No font glyphs yet, so use a glyph w/o the oval.\n      // TODO: When font glyphs are available, delete this code.\n      stash = group.name.slice(1);\n      group.name = stash === \"oiint\" ? \"\\\\iint\" : \"\\\\iiint\";\n    }\n\n    base = buildCommon.makeSymbol(group.name, fontName, \"math\", options, [\"mop\", \"op-symbol\", large ? \"large-op\" : \"small-op\"]);\n\n    if (stash.length > 0) {\n      // We're in \\oiint or \\oiiint. Overlay the oval.\n      // TODO: When font glyphs are available, delete this code.\n      var italic = base.italic;\n      var oval = buildCommon.staticSvg(stash + \"Size\" + (large ? \"2\" : \"1\"), options);\n      base = buildCommon.makeVList({\n        positionType: \"individualShift\",\n        children: [{\n          type: \"elem\",\n          elem: base,\n          shift: 0\n        }, {\n          type: \"elem\",\n          elem: oval,\n          shift: large ? 0.08 : 0\n        }]\n      }, options);\n      group.name = \"\\\\\" + stash;\n      base.classes.unshift(\"mop\"); // $FlowFixMe\n\n      base.italic = italic;\n    }\n  } else if (group.body) {\n    // If this is a list, compose that list.\n    var inner = buildExpression$1(group.body, options, true);\n\n    if (inner.length === 1 && inner[0] instanceof SymbolNode) {\n      base = inner[0];\n      base.classes[0] = \"mop\"; // replace old mclass\n    } else {\n      base = buildCommon.makeSpan([\"mop\"], inner, options);\n    }\n  } else {\n    // Otherwise, this is a text operator. Build the text from the\n    // operator's name.\n    var output = [];\n\n    for (var i = 1; i < group.name.length; i++) {\n      output.push(buildCommon.mathsym(group.name[i], group.mode, options));\n    }\n\n    base = buildCommon.makeSpan([\"mop\"], output, options);\n  } // If content of op is a single symbol, shift it vertically.\n\n\n  var baseShift = 0;\n  var slant = 0;\n\n  if ((base instanceof SymbolNode || group.name === \"\\\\oiint\" || group.name === \"\\\\oiiint\") && !group.suppressBaseShift) {\n    // We suppress the shift of the base of \\overset and \\underset. Otherwise,\n    // shift the symbol so its center lies on the axis (rule 13). It\n    // appears that our fonts have the centers of the symbols already\n    // almost on the axis, so these numbers are very small. Note we\n    // don't actually apply this here, but instead it is used either in\n    // the vlist creation or separately when there are no limits.\n    baseShift = (base.height - base.depth) / 2 - options.fontMetrics().axisHeight; // The slant of the symbol is just its italic correction.\n    // $FlowFixMe\n\n    slant = base.italic;\n  }\n\n  if (hasLimits) {\n    return assembleSupSub(base, supGroup, subGroup, options, style, slant, baseShift);\n  } else {\n    if (baseShift) {\n      base.style.position = \"relative\";\n      base.style.top = makeEm(baseShift);\n    }\n\n    return base;\n  }\n};\n\nvar mathmlBuilder$1 = (group, options) => {\n  var node;\n\n  if (group.symbol) {\n    // This is a symbol. Just add the symbol.\n    node = new MathNode(\"mo\", [makeText(group.name, group.mode)]);\n\n    if (utils.contains(noSuccessor, group.name)) {\n      node.setAttribute(\"largeop\", \"false\");\n    }\n  } else if (group.body) {\n    // This is an operator with children. Add them.\n    node = new MathNode(\"mo\", buildExpression(group.body, options));\n  } else {\n    // This is a text operator. Add all of the characters from the\n    // operator's name.\n    node = new MathNode(\"mi\", [new TextNode(group.name.slice(1))]); // Append an <mo>&ApplyFunction;</mo>.\n    // ref: https://www.w3.org/TR/REC-MathML/chap3_2.html#sec3.2.4\n\n    var operator = new MathNode(\"mo\", [makeText(\"\\u2061\", \"text\")]);\n\n    if (group.parentIsSupSub) {\n      node = new MathNode(\"mrow\", [node, operator]);\n    } else {\n      node = newDocumentFragment([node, operator]);\n    }\n  }\n\n  return node;\n};\n\nvar singleCharBigOps = {\n  \"\\u220F\": \"\\\\prod\",\n  \"\\u2210\": \"\\\\coprod\",\n  \"\\u2211\": \"\\\\sum\",\n  \"\\u22c0\": \"\\\\bigwedge\",\n  \"\\u22c1\": \"\\\\bigvee\",\n  \"\\u22c2\": \"\\\\bigcap\",\n  \"\\u22c3\": \"\\\\bigcup\",\n  \"\\u2a00\": \"\\\\bigodot\",\n  \"\\u2a01\": \"\\\\bigoplus\",\n  \"\\u2a02\": \"\\\\bigotimes\",\n  \"\\u2a04\": \"\\\\biguplus\",\n  \"\\u2a06\": \"\\\\bigsqcup\"\n};\ndefineFunction({\n  type: \"op\",\n  names: [\"\\\\coprod\", \"\\\\bigvee\", \"\\\\bigwedge\", \"\\\\biguplus\", \"\\\\bigcap\", \"\\\\bigcup\", \"\\\\intop\", \"\\\\prod\", \"\\\\sum\", \"\\\\bigotimes\", \"\\\\bigoplus\", \"\\\\bigodot\", \"\\\\bigsqcup\", \"\\\\smallint\", \"\\u220F\", \"\\u2210\", \"\\u2211\", \"\\u22c0\", \"\\u22c1\", \"\\u22c2\", \"\\u22c3\", \"\\u2a00\", \"\\u2a01\", \"\\u2a02\", \"\\u2a04\", \"\\u2a06\"],\n  props: {\n    numArgs: 0\n  },\n  handler: (_ref, args) => {\n    var {\n      parser,\n      funcName\n    } = _ref;\n    var fName = funcName;\n\n    if (fName.length === 1) {\n      fName = singleCharBigOps[fName];\n    }\n\n    return {\n      type: \"op\",\n      mode: parser.mode,\n      limits: true,\n      parentIsSupSub: false,\n      symbol: true,\n      name: fName\n    };\n  },\n  htmlBuilder: htmlBuilder$2,\n  mathmlBuilder: mathmlBuilder$1\n}); // Note: calling defineFunction with a type that's already been defined only\n// works because the same htmlBuilder and mathmlBuilder are being used.\n\ndefineFunction({\n  type: \"op\",\n  names: [\"\\\\mathop\"],\n  props: {\n    numArgs: 1,\n    primitive: true\n  },\n  handler: (_ref2, args) => {\n    var {\n      parser\n    } = _ref2;\n    var body = args[0];\n    return {\n      type: \"op\",\n      mode: parser.mode,\n      limits: false,\n      parentIsSupSub: false,\n      symbol: false,\n      body: ordargument(body)\n    };\n  },\n  htmlBuilder: htmlBuilder$2,\n  mathmlBuilder: mathmlBuilder$1\n}); // There are 2 flags for operators; whether they produce limits in\n// displaystyle, and whether they are symbols and should grow in\n// displaystyle. These four groups cover the four possible choices.\n\nvar singleCharIntegrals = {\n  \"\\u222b\": \"\\\\int\",\n  \"\\u222c\": \"\\\\iint\",\n  \"\\u222d\": \"\\\\iiint\",\n  \"\\u222e\": \"\\\\oint\",\n  \"\\u222f\": \"\\\\oiint\",\n  \"\\u2230\": \"\\\\oiiint\"\n}; // No limits, not symbols\n\ndefineFunction({\n  type: \"op\",\n  names: [\"\\\\arcsin\", \"\\\\arccos\", \"\\\\arctan\", \"\\\\arctg\", \"\\\\arcctg\", \"\\\\arg\", \"\\\\ch\", \"\\\\cos\", \"\\\\cosec\", \"\\\\cosh\", \"\\\\cot\", \"\\\\cotg\", \"\\\\coth\", \"\\\\csc\", \"\\\\ctg\", \"\\\\cth\", \"\\\\deg\", \"\\\\dim\", \"\\\\exp\", \"\\\\hom\", \"\\\\ker\", \"\\\\lg\", \"\\\\ln\", \"\\\\log\", \"\\\\sec\", \"\\\\sin\", \"\\\\sinh\", \"\\\\sh\", \"\\\\tan\", \"\\\\tanh\", \"\\\\tg\", \"\\\\th\"],\n  props: {\n    numArgs: 0\n  },\n\n  handler(_ref3) {\n    var {\n      parser,\n      funcName\n    } = _ref3;\n    return {\n      type: \"op\",\n      mode: parser.mode,\n      limits: false,\n      parentIsSupSub: false,\n      symbol: false,\n      name: funcName\n    };\n  },\n\n  htmlBuilder: htmlBuilder$2,\n  mathmlBuilder: mathmlBuilder$1\n}); // Limits, not symbols\n\ndefineFunction({\n  type: \"op\",\n  names: [\"\\\\det\", \"\\\\gcd\", \"\\\\inf\", \"\\\\lim\", \"\\\\max\", \"\\\\min\", \"\\\\Pr\", \"\\\\sup\"],\n  props: {\n    numArgs: 0\n  },\n\n  handler(_ref4) {\n    var {\n      parser,\n      funcName\n    } = _ref4;\n    return {\n      type: \"op\",\n      mode: parser.mode,\n      limits: true,\n      parentIsSupSub: false,\n      symbol: false,\n      name: funcName\n    };\n  },\n\n  htmlBuilder: htmlBuilder$2,\n  mathmlBuilder: mathmlBuilder$1\n}); // No limits, symbols\n\ndefineFunction({\n  type: \"op\",\n  names: [\"\\\\int\", \"\\\\iint\", \"\\\\iiint\", \"\\\\oint\", \"\\\\oiint\", \"\\\\oiiint\", \"\\u222b\", \"\\u222c\", \"\\u222d\", \"\\u222e\", \"\\u222f\", \"\\u2230\"],\n  props: {\n    numArgs: 0\n  },\n\n  handler(_ref5) {\n    var {\n      parser,\n      funcName\n    } = _ref5;\n    var fName = funcName;\n\n    if (fName.length === 1) {\n      fName = singleCharIntegrals[fName];\n    }\n\n    return {\n      type: \"op\",\n      mode: parser.mode,\n      limits: false,\n      parentIsSupSub: false,\n      symbol: true,\n      name: fName\n    };\n  },\n\n  htmlBuilder: htmlBuilder$2,\n  mathmlBuilder: mathmlBuilder$1\n});\n\n// NOTE: Unlike most `htmlBuilder`s, this one handles not only\n// \"operatorname\", but also  \"supsub\" since \\operatorname* can\n// affect super/subscripting.\nvar htmlBuilder$1 = (grp, options) => {\n  // Operators are handled in the TeXbook pg. 443-444, rule 13(a).\n  var supGroup;\n  var subGroup;\n  var hasLimits = false;\n  var group;\n\n  if (grp.type === \"supsub\") {\n    // If we have limits, supsub will pass us its group to handle. Pull\n    // out the superscript and subscript and set the group to the op in\n    // its base.\n    supGroup = grp.sup;\n    subGroup = grp.sub;\n    group = assertNodeType(grp.base, \"operatorname\");\n    hasLimits = true;\n  } else {\n    group = assertNodeType(grp, \"operatorname\");\n  }\n\n  var base;\n\n  if (group.body.length > 0) {\n    var body = group.body.map(child => {\n      // $FlowFixMe: Check if the node has a string `text` property.\n      var childText = child.text;\n\n      if (typeof childText === \"string\") {\n        return {\n          type: \"textord\",\n          mode: child.mode,\n          text: childText\n        };\n      } else {\n        return child;\n      }\n    }); // Consolidate function names into symbol characters.\n\n    var expression = buildExpression$1(body, options.withFont(\"mathrm\"), true);\n\n    for (var i = 0; i < expression.length; i++) {\n      var child = expression[i];\n\n      if (child instanceof SymbolNode) {\n        // Per amsopn package,\n        // change minus to hyphen and \\ast to asterisk\n        child.text = child.text.replace(/\\u2212/, \"-\").replace(/\\u2217/, \"*\");\n      }\n    }\n\n    base = buildCommon.makeSpan([\"mop\"], expression, options);\n  } else {\n    base = buildCommon.makeSpan([\"mop\"], [], options);\n  }\n\n  if (hasLimits) {\n    return assembleSupSub(base, supGroup, subGroup, options, options.style, 0, 0);\n  } else {\n    return base;\n  }\n};\n\nvar mathmlBuilder = (group, options) => {\n  // The steps taken here are similar to the html version.\n  var expression = buildExpression(group.body, options.withFont(\"mathrm\")); // Is expression a string or has it something like a fraction?\n\n  var isAllString = true; // default\n\n  for (var i = 0; i < expression.length; i++) {\n    var node = expression[i];\n\n    if (node instanceof mathMLTree.SpaceNode) ; else if (node instanceof mathMLTree.MathNode) {\n      switch (node.type) {\n        case \"mi\":\n        case \"mn\":\n        case \"ms\":\n        case \"mspace\":\n        case \"mtext\":\n          break;\n        // Do nothing yet.\n\n        case \"mo\":\n          {\n            var child = node.children[0];\n\n            if (node.children.length === 1 && child instanceof mathMLTree.TextNode) {\n              child.text = child.text.replace(/\\u2212/, \"-\").replace(/\\u2217/, \"*\");\n            } else {\n              isAllString = false;\n            }\n\n            break;\n          }\n\n        default:\n          isAllString = false;\n      }\n    } else {\n      isAllString = false;\n    }\n  }\n\n  if (isAllString) {\n    // Write a single TextNode instead of multiple nested tags.\n    var word = expression.map(node => node.toText()).join(\"\");\n    expression = [new mathMLTree.TextNode(word)];\n  }\n\n  var identifier = new mathMLTree.MathNode(\"mi\", expression);\n  identifier.setAttribute(\"mathvariant\", \"normal\"); // \\u2061 is the same as &ApplyFunction;\n  // ref: https://www.w3schools.com/charsets/ref_html_entities_a.asp\n\n  var operator = new mathMLTree.MathNode(\"mo\", [makeText(\"\\u2061\", \"text\")]);\n\n  if (group.parentIsSupSub) {\n    return new mathMLTree.MathNode(\"mrow\", [identifier, operator]);\n  } else {\n    return mathMLTree.newDocumentFragment([identifier, operator]);\n  }\n}; // \\operatorname\n// amsopn.dtx: \\mathop{#1\\kern\\z@\\operator@font#3}\\newmcodes@\n\n\ndefineFunction({\n  type: \"operatorname\",\n  names: [\"\\\\operatorname@\", \"\\\\operatornamewithlimits\"],\n  props: {\n    numArgs: 1\n  },\n  handler: (_ref, args) => {\n    var {\n      parser,\n      funcName\n    } = _ref;\n    var body = args[0];\n    return {\n      type: \"operatorname\",\n      mode: parser.mode,\n      body: ordargument(body),\n      alwaysHandleSupSub: funcName === \"\\\\operatornamewithlimits\",\n      limits: false,\n      parentIsSupSub: false\n    };\n  },\n  htmlBuilder: htmlBuilder$1,\n  mathmlBuilder\n});\ndefineMacro(\"\\\\operatorname\", \"\\\\@ifstar\\\\operatornamewithlimits\\\\operatorname@\");\n\ndefineFunctionBuilders({\n  type: \"ordgroup\",\n\n  htmlBuilder(group, options) {\n    if (group.semisimple) {\n      return buildCommon.makeFragment(buildExpression$1(group.body, options, false));\n    }\n\n    return buildCommon.makeSpan([\"mord\"], buildExpression$1(group.body, options, true), options);\n  },\n\n  mathmlBuilder(group, options) {\n    return buildExpressionRow(group.body, options, true);\n  }\n\n});\n\ndefineFunction({\n  type: \"overline\",\n  names: [\"\\\\overline\"],\n  props: {\n    numArgs: 1\n  },\n\n  handler(_ref, args) {\n    var {\n      parser\n    } = _ref;\n    var body = args[0];\n    return {\n      type: \"overline\",\n      mode: parser.mode,\n      body\n    };\n  },\n\n  htmlBuilder(group, options) {\n    // Overlines are handled in the TeXbook pg 443, Rule 9.\n    // Build the inner group in the cramped style.\n    var innerGroup = buildGroup$1(group.body, options.havingCrampedStyle()); // Create the line above the body\n\n    var line = buildCommon.makeLineSpan(\"overline-line\", options); // Generate the vlist, with the appropriate kerns\n\n    var defaultRuleThickness = options.fontMetrics().defaultRuleThickness;\n    var vlist = buildCommon.makeVList({\n      positionType: \"firstBaseline\",\n      children: [{\n        type: \"elem\",\n        elem: innerGroup\n      }, {\n        type: \"kern\",\n        size: 3 * defaultRuleThickness\n      }, {\n        type: \"elem\",\n        elem: line\n      }, {\n        type: \"kern\",\n        size: defaultRuleThickness\n      }]\n    }, options);\n    return buildCommon.makeSpan([\"mord\", \"overline\"], [vlist], options);\n  },\n\n  mathmlBuilder(group, options) {\n    var operator = new mathMLTree.MathNode(\"mo\", [new mathMLTree.TextNode(\"\\u203e\")]);\n    operator.setAttribute(\"stretchy\", \"true\");\n    var node = new mathMLTree.MathNode(\"mover\", [buildGroup(group.body, options), operator]);\n    node.setAttribute(\"accent\", \"true\");\n    return node;\n  }\n\n});\n\ndefineFunction({\n  type: \"phantom\",\n  names: [\"\\\\phantom\"],\n  props: {\n    numArgs: 1,\n    allowedInText: true\n  },\n  handler: (_ref, args) => {\n    var {\n      parser\n    } = _ref;\n    var body = args[0];\n    return {\n      type: \"phantom\",\n      mode: parser.mode,\n      body: ordargument(body)\n    };\n  },\n  htmlBuilder: (group, options) => {\n    var elements = buildExpression$1(group.body, options.withPhantom(), false); // \\phantom isn't supposed to affect the elements it contains.\n    // See \"color\" for more details.\n\n    return buildCommon.makeFragment(elements);\n  },\n  mathmlBuilder: (group, options) => {\n    var inner = buildExpression(group.body, options);\n    return new mathMLTree.MathNode(\"mphantom\", inner);\n  }\n});\ndefineFunction({\n  type: \"hphantom\",\n  names: [\"\\\\hphantom\"],\n  props: {\n    numArgs: 1,\n    allowedInText: true\n  },\n  handler: (_ref2, args) => {\n    var {\n      parser\n    } = _ref2;\n    var body = args[0];\n    return {\n      type: \"hphantom\",\n      mode: parser.mode,\n      body\n    };\n  },\n  htmlBuilder: (group, options) => {\n    var node = buildCommon.makeSpan([], [buildGroup$1(group.body, options.withPhantom())]);\n    node.height = 0;\n    node.depth = 0;\n\n    if (node.children) {\n      for (var i = 0; i < node.children.length; i++) {\n        node.children[i].height = 0;\n        node.children[i].depth = 0;\n      }\n    } // See smash for comment re: use of makeVList\n\n\n    node = buildCommon.makeVList({\n      positionType: \"firstBaseline\",\n      children: [{\n        type: \"elem\",\n        elem: node\n      }]\n    }, options); // For spacing, TeX treats \\smash as a math group (same spacing as ord).\n\n    return buildCommon.makeSpan([\"mord\"], [node], options);\n  },\n  mathmlBuilder: (group, options) => {\n    var inner = buildExpression(ordargument(group.body), options);\n    var phantom = new mathMLTree.MathNode(\"mphantom\", inner);\n    var node = new mathMLTree.MathNode(\"mpadded\", [phantom]);\n    node.setAttribute(\"height\", \"0px\");\n    node.setAttribute(\"depth\", \"0px\");\n    return node;\n  }\n});\ndefineFunction({\n  type: \"vphantom\",\n  names: [\"\\\\vphantom\"],\n  props: {\n    numArgs: 1,\n    allowedInText: true\n  },\n  handler: (_ref3, args) => {\n    var {\n      parser\n    } = _ref3;\n    var body = args[0];\n    return {\n      type: \"vphantom\",\n      mode: parser.mode,\n      body\n    };\n  },\n  htmlBuilder: (group, options) => {\n    var inner = buildCommon.makeSpan([\"inner\"], [buildGroup$1(group.body, options.withPhantom())]);\n    var fix = buildCommon.makeSpan([\"fix\"], []);\n    return buildCommon.makeSpan([\"mord\", \"rlap\"], [inner, fix], options);\n  },\n  mathmlBuilder: (group, options) => {\n    var inner = buildExpression(ordargument(group.body), options);\n    var phantom = new mathMLTree.MathNode(\"mphantom\", inner);\n    var node = new mathMLTree.MathNode(\"mpadded\", [phantom]);\n    node.setAttribute(\"width\", \"0px\");\n    return node;\n  }\n});\n\ndefineFunction({\n  type: \"raisebox\",\n  names: [\"\\\\raisebox\"],\n  props: {\n    numArgs: 2,\n    argTypes: [\"size\", \"hbox\"],\n    allowedInText: true\n  },\n\n  handler(_ref, args) {\n    var {\n      parser\n    } = _ref;\n    var amount = assertNodeType(args[0], \"size\").value;\n    var body = args[1];\n    return {\n      type: \"raisebox\",\n      mode: parser.mode,\n      dy: amount,\n      body\n    };\n  },\n\n  htmlBuilder(group, options) {\n    var body = buildGroup$1(group.body, options);\n    var dy = calculateSize(group.dy, options);\n    return buildCommon.makeVList({\n      positionType: \"shift\",\n      positionData: -dy,\n      children: [{\n        type: \"elem\",\n        elem: body\n      }]\n    }, options);\n  },\n\n  mathmlBuilder(group, options) {\n    var node = new mathMLTree.MathNode(\"mpadded\", [buildGroup(group.body, options)]);\n    var dy = group.dy.number + group.dy.unit;\n    node.setAttribute(\"voffset\", dy);\n    return node;\n  }\n\n});\n\ndefineFunction({\n  type: \"internal\",\n  names: [\"\\\\relax\"],\n  props: {\n    numArgs: 0,\n    allowedInText: true\n  },\n\n  handler(_ref) {\n    var {\n      parser\n    } = _ref;\n    return {\n      type: \"internal\",\n      mode: parser.mode\n    };\n  }\n\n});\n\ndefineFunction({\n  type: \"rule\",\n  names: [\"\\\\rule\"],\n  props: {\n    numArgs: 2,\n    numOptionalArgs: 1,\n    allowedInText: true,\n    allowedInMath: true,\n    argTypes: [\"size\", \"size\", \"size\"]\n  },\n\n  handler(_ref, args, optArgs) {\n    var {\n      parser\n    } = _ref;\n    var shift = optArgs[0];\n    var width = assertNodeType(args[0], \"size\");\n    var height = assertNodeType(args[1], \"size\");\n    return {\n      type: \"rule\",\n      mode: parser.mode,\n      shift: shift && assertNodeType(shift, \"size\").value,\n      width: width.value,\n      height: height.value\n    };\n  },\n\n  htmlBuilder(group, options) {\n    // Make an empty span for the rule\n    var rule = buildCommon.makeSpan([\"mord\", \"rule\"], [], options); // Calculate the shift, width, and height of the rule, and account for units\n\n    var width = calculateSize(group.width, options);\n    var height = calculateSize(group.height, options);\n    var shift = group.shift ? calculateSize(group.shift, options) : 0; // Style the rule to the right size\n\n    rule.style.borderRightWidth = makeEm(width);\n    rule.style.borderTopWidth = makeEm(height);\n    rule.style.bottom = makeEm(shift); // Record the height and width\n\n    rule.width = width;\n    rule.height = height + shift;\n    rule.depth = -shift; // Font size is the number large enough that the browser will\n    // reserve at least `absHeight` space above the baseline.\n    // The 1.125 factor was empirically determined\n\n    rule.maxFontSize = height * 1.125 * options.sizeMultiplier;\n    return rule;\n  },\n\n  mathmlBuilder(group, options) {\n    var width = calculateSize(group.width, options);\n    var height = calculateSize(group.height, options);\n    var shift = group.shift ? calculateSize(group.shift, options) : 0;\n    var color = options.color && options.getColor() || \"black\";\n    var rule = new mathMLTree.MathNode(\"mspace\");\n    rule.setAttribute(\"mathbackground\", color);\n    rule.setAttribute(\"width\", makeEm(width));\n    rule.setAttribute(\"height\", makeEm(height));\n    var wrapper = new mathMLTree.MathNode(\"mpadded\", [rule]);\n\n    if (shift >= 0) {\n      wrapper.setAttribute(\"height\", makeEm(shift));\n    } else {\n      wrapper.setAttribute(\"height\", makeEm(shift));\n      wrapper.setAttribute(\"depth\", makeEm(-shift));\n    }\n\n    wrapper.setAttribute(\"voffset\", makeEm(shift));\n    return wrapper;\n  }\n\n});\n\nfunction sizingGroup(value, options, baseOptions) {\n  var inner = buildExpression$1(value, options, false);\n  var multiplier = options.sizeMultiplier / baseOptions.sizeMultiplier; // Add size-resetting classes to the inner list and set maxFontSize\n  // manually. Handle nested size changes.\n\n  for (var i = 0; i < inner.length; i++) {\n    var pos = inner[i].classes.indexOf(\"sizing\");\n\n    if (pos < 0) {\n      Array.prototype.push.apply(inner[i].classes, options.sizingClasses(baseOptions));\n    } else if (inner[i].classes[pos + 1] === \"reset-size\" + options.size) {\n      // This is a nested size change: e.g., inner[i] is the \"b\" in\n      // `\\Huge a \\small b`. Override the old size (the `reset-` class)\n      // but not the new size.\n      inner[i].classes[pos + 1] = \"reset-size\" + baseOptions.size;\n    }\n\n    inner[i].height *= multiplier;\n    inner[i].depth *= multiplier;\n  }\n\n  return buildCommon.makeFragment(inner);\n}\nvar sizeFuncs = [\"\\\\tiny\", \"\\\\sixptsize\", \"\\\\scriptsize\", \"\\\\footnotesize\", \"\\\\small\", \"\\\\normalsize\", \"\\\\large\", \"\\\\Large\", \"\\\\LARGE\", \"\\\\huge\", \"\\\\Huge\"];\nvar htmlBuilder = (group, options) => {\n  // Handle sizing operators like \\Huge. Real TeX doesn't actually allow\n  // these functions inside of math expressions, so we do some special\n  // handling.\n  var newOptions = options.havingSize(group.size);\n  return sizingGroup(group.body, newOptions, options);\n};\ndefineFunction({\n  type: \"sizing\",\n  names: sizeFuncs,\n  props: {\n    numArgs: 0,\n    allowedInText: true\n  },\n  handler: (_ref, args) => {\n    var {\n      breakOnTokenText,\n      funcName,\n      parser\n    } = _ref;\n    var body = parser.parseExpression(false, breakOnTokenText);\n    return {\n      type: \"sizing\",\n      mode: parser.mode,\n      // Figure out what size to use based on the list of functions above\n      size: sizeFuncs.indexOf(funcName) + 1,\n      body\n    };\n  },\n  htmlBuilder,\n  mathmlBuilder: (group, options) => {\n    var newOptions = options.havingSize(group.size);\n    var inner = buildExpression(group.body, newOptions);\n    var node = new mathMLTree.MathNode(\"mstyle\", inner); // TODO(emily): This doesn't produce the correct size for nested size\n    // changes, because we don't keep state of what style we're currently\n    // in, so we can't reset the size to normal before changing it.  Now\n    // that we're passing an options parameter we should be able to fix\n    // this.\n\n    node.setAttribute(\"mathsize\", makeEm(newOptions.sizeMultiplier));\n    return node;\n  }\n});\n\n// smash, with optional [tb], as in AMS\ndefineFunction({\n  type: \"smash\",\n  names: [\"\\\\smash\"],\n  props: {\n    numArgs: 1,\n    numOptionalArgs: 1,\n    allowedInText: true\n  },\n  handler: (_ref, args, optArgs) => {\n    var {\n      parser\n    } = _ref;\n    var smashHeight = false;\n    var smashDepth = false;\n    var tbArg = optArgs[0] && assertNodeType(optArgs[0], \"ordgroup\");\n\n    if (tbArg) {\n      // Optional [tb] argument is engaged.\n      // ref: amsmath: \\renewcommand{\\smash}[1][tb]{%\n      //               def\\mb@t{\\ht}\\def\\mb@b{\\dp}\\def\\mb@tb{\\ht\\z@\\z@\\dp}%\n      var letter = \"\";\n\n      for (var i = 0; i < tbArg.body.length; ++i) {\n        var node = tbArg.body[i]; // $FlowFixMe: Not every node type has a `text` property.\n\n        letter = node.text;\n\n        if (letter === \"t\") {\n          smashHeight = true;\n        } else if (letter === \"b\") {\n          smashDepth = true;\n        } else {\n          smashHeight = false;\n          smashDepth = false;\n          break;\n        }\n      }\n    } else {\n      smashHeight = true;\n      smashDepth = true;\n    }\n\n    var body = args[0];\n    return {\n      type: \"smash\",\n      mode: parser.mode,\n      body,\n      smashHeight,\n      smashDepth\n    };\n  },\n  htmlBuilder: (group, options) => {\n    var node = buildCommon.makeSpan([], [buildGroup$1(group.body, options)]);\n\n    if (!group.smashHeight && !group.smashDepth) {\n      return node;\n    }\n\n    if (group.smashHeight) {\n      node.height = 0; // In order to influence makeVList, we have to reset the children.\n\n      if (node.children) {\n        for (var i = 0; i < node.children.length; i++) {\n          node.children[i].height = 0;\n        }\n      }\n    }\n\n    if (group.smashDepth) {\n      node.depth = 0;\n\n      if (node.children) {\n        for (var _i = 0; _i < node.children.length; _i++) {\n          node.children[_i].depth = 0;\n        }\n      }\n    } // At this point, we've reset the TeX-like height and depth values.\n    // But the span still has an HTML line height.\n    // makeVList applies \"display: table-cell\", which prevents the browser\n    // from acting on that line height. So we'll call makeVList now.\n\n\n    var smashedNode = buildCommon.makeVList({\n      positionType: \"firstBaseline\",\n      children: [{\n        type: \"elem\",\n        elem: node\n      }]\n    }, options); // For spacing, TeX treats \\hphantom as a math group (same spacing as ord).\n\n    return buildCommon.makeSpan([\"mord\"], [smashedNode], options);\n  },\n  mathmlBuilder: (group, options) => {\n    var node = new mathMLTree.MathNode(\"mpadded\", [buildGroup(group.body, options)]);\n\n    if (group.smashHeight) {\n      node.setAttribute(\"height\", \"0px\");\n    }\n\n    if (group.smashDepth) {\n      node.setAttribute(\"depth\", \"0px\");\n    }\n\n    return node;\n  }\n});\n\ndefineFunction({\n  type: \"sqrt\",\n  names: [\"\\\\sqrt\"],\n  props: {\n    numArgs: 1,\n    numOptionalArgs: 1\n  },\n\n  handler(_ref, args, optArgs) {\n    var {\n      parser\n    } = _ref;\n    var index = optArgs[0];\n    var body = args[0];\n    return {\n      type: \"sqrt\",\n      mode: parser.mode,\n      body,\n      index\n    };\n  },\n\n  htmlBuilder(group, options) {\n    // Square roots are handled in the TeXbook pg. 443, Rule 11.\n    // First, we do the same steps as in overline to build the inner group\n    // and line\n    var inner = buildGroup$1(group.body, options.havingCrampedStyle());\n\n    if (inner.height === 0) {\n      // Render a small surd.\n      inner.height = options.fontMetrics().xHeight;\n    } // Some groups can return document fragments.  Handle those by wrapping\n    // them in a span.\n\n\n    inner = buildCommon.wrapFragment(inner, options); // Calculate the minimum size for the \\surd delimiter\n\n    var metrics = options.fontMetrics();\n    var theta = metrics.defaultRuleThickness;\n    var phi = theta;\n\n    if (options.style.id < Style$1.TEXT.id) {\n      phi = options.fontMetrics().xHeight;\n    } // Calculate the clearance between the body and line\n\n\n    var lineClearance = theta + phi / 4;\n    var minDelimiterHeight = inner.height + inner.depth + lineClearance + theta; // Create a sqrt SVG of the required minimum size\n\n    var {\n      span: img,\n      ruleWidth,\n      advanceWidth\n    } = delimiter.sqrtImage(minDelimiterHeight, options);\n    var delimDepth = img.height - ruleWidth; // Adjust the clearance based on the delimiter size\n\n    if (delimDepth > inner.height + inner.depth + lineClearance) {\n      lineClearance = (lineClearance + delimDepth - inner.height - inner.depth) / 2;\n    } // Shift the sqrt image\n\n\n    var imgShift = img.height - inner.height - lineClearance - ruleWidth;\n    inner.style.paddingLeft = makeEm(advanceWidth); // Overlay the image and the argument.\n\n    var body = buildCommon.makeVList({\n      positionType: \"firstBaseline\",\n      children: [{\n        type: \"elem\",\n        elem: inner,\n        wrapperClasses: [\"svg-align\"]\n      }, {\n        type: \"kern\",\n        size: -(inner.height + imgShift)\n      }, {\n        type: \"elem\",\n        elem: img\n      }, {\n        type: \"kern\",\n        size: ruleWidth\n      }]\n    }, options);\n\n    if (!group.index) {\n      return buildCommon.makeSpan([\"mord\", \"sqrt\"], [body], options);\n    } else {\n      // Handle the optional root index\n      // The index is always in scriptscript style\n      var newOptions = options.havingStyle(Style$1.SCRIPTSCRIPT);\n      var rootm = buildGroup$1(group.index, newOptions, options); // The amount the index is shifted by. This is taken from the TeX\n      // source, in the definition of `\\r@@t`.\n\n      var toShift = 0.6 * (body.height - body.depth); // Build a VList with the superscript shifted up correctly\n\n      var rootVList = buildCommon.makeVList({\n        positionType: \"shift\",\n        positionData: -toShift,\n        children: [{\n          type: \"elem\",\n          elem: rootm\n        }]\n      }, options); // Add a class surrounding it so we can add on the appropriate\n      // kerning\n\n      var rootVListWrap = buildCommon.makeSpan([\"root\"], [rootVList]);\n      return buildCommon.makeSpan([\"mord\", \"sqrt\"], [rootVListWrap, body], options);\n    }\n  },\n\n  mathmlBuilder(group, options) {\n    var {\n      body,\n      index\n    } = group;\n    return index ? new mathMLTree.MathNode(\"mroot\", [buildGroup(body, options), buildGroup(index, options)]) : new mathMLTree.MathNode(\"msqrt\", [buildGroup(body, options)]);\n  }\n\n});\n\nvar styleMap = {\n  \"display\": Style$1.DISPLAY,\n  \"text\": Style$1.TEXT,\n  \"script\": Style$1.SCRIPT,\n  \"scriptscript\": Style$1.SCRIPTSCRIPT\n};\ndefineFunction({\n  type: \"styling\",\n  names: [\"\\\\displaystyle\", \"\\\\textstyle\", \"\\\\scriptstyle\", \"\\\\scriptscriptstyle\"],\n  props: {\n    numArgs: 0,\n    allowedInText: true,\n    primitive: true\n  },\n\n  handler(_ref, args) {\n    var {\n      breakOnTokenText,\n      funcName,\n      parser\n    } = _ref;\n    // parse out the implicit body\n    var body = parser.parseExpression(true, breakOnTokenText); // TODO: Refactor to avoid duplicating styleMap in multiple places (e.g.\n    // here and in buildHTML and de-dupe the enumeration of all the styles).\n    // $FlowFixMe: The names above exactly match the styles.\n\n    var style = funcName.slice(1, funcName.length - 5);\n    return {\n      type: \"styling\",\n      mode: parser.mode,\n      // Figure out what style to use by pulling out the style from\n      // the function name\n      style,\n      body\n    };\n  },\n\n  htmlBuilder(group, options) {\n    // Style changes are handled in the TeXbook on pg. 442, Rule 3.\n    var newStyle = styleMap[group.style];\n    var newOptions = options.havingStyle(newStyle).withFont('');\n    return sizingGroup(group.body, newOptions, options);\n  },\n\n  mathmlBuilder(group, options) {\n    // Figure out what style we're changing to.\n    var newStyle = styleMap[group.style];\n    var newOptions = options.havingStyle(newStyle);\n    var inner = buildExpression(group.body, newOptions);\n    var node = new mathMLTree.MathNode(\"mstyle\", inner);\n    var styleAttributes = {\n      \"display\": [\"0\", \"true\"],\n      \"text\": [\"0\", \"false\"],\n      \"script\": [\"1\", \"false\"],\n      \"scriptscript\": [\"2\", \"false\"]\n    };\n    var attr = styleAttributes[group.style];\n    node.setAttribute(\"scriptlevel\", attr[0]);\n    node.setAttribute(\"displaystyle\", attr[1]);\n    return node;\n  }\n\n});\n\n/**\n * Sometimes, groups perform special rules when they have superscripts or\n * subscripts attached to them. This function lets the `supsub` group know that\n * Sometimes, groups perform special rules when they have superscripts or\n * its inner element should handle the superscripts and subscripts instead of\n * handling them itself.\n */\nvar htmlBuilderDelegate = function htmlBuilderDelegate(group, options) {\n  var base = group.base;\n\n  if (!base) {\n    return null;\n  } else if (base.type === \"op\") {\n    // Operators handle supsubs differently when they have limits\n    // (e.g. `\\displaystyle\\sum_2^3`)\n    var delegate = base.limits && (options.style.size === Style$1.DISPLAY.size || base.alwaysHandleSupSub);\n    return delegate ? htmlBuilder$2 : null;\n  } else if (base.type === \"operatorname\") {\n    var _delegate = base.alwaysHandleSupSub && (options.style.size === Style$1.DISPLAY.size || base.limits);\n\n    return _delegate ? htmlBuilder$1 : null;\n  } else if (base.type === \"accent\") {\n    return utils.isCharacterBox(base.base) ? htmlBuilder$a : null;\n  } else if (base.type === \"horizBrace\") {\n    var isSup = !group.sub;\n    return isSup === base.isOver ? htmlBuilder$3 : null;\n  } else {\n    return null;\n  }\n}; // Super scripts and subscripts, whose precise placement can depend on other\n// functions that precede them.\n\n\ndefineFunctionBuilders({\n  type: \"supsub\",\n\n  htmlBuilder(group, options) {\n    // Superscript and subscripts are handled in the TeXbook on page\n    // 445-446, rules 18(a-f).\n    // Here is where we defer to the inner group if it should handle\n    // superscripts and subscripts itself.\n    var builderDelegate = htmlBuilderDelegate(group, options);\n\n    if (builderDelegate) {\n      return builderDelegate(group, options);\n    }\n\n    var {\n      base: valueBase,\n      sup: valueSup,\n      sub: valueSub\n    } = group;\n    var base = buildGroup$1(valueBase, options);\n    var supm;\n    var subm;\n    var metrics = options.fontMetrics(); // Rule 18a\n\n    var supShift = 0;\n    var subShift = 0;\n    var isCharacterBox = valueBase && utils.isCharacterBox(valueBase);\n\n    if (valueSup) {\n      var newOptions = options.havingStyle(options.style.sup());\n      supm = buildGroup$1(valueSup, newOptions, options);\n\n      if (!isCharacterBox) {\n        supShift = base.height - newOptions.fontMetrics().supDrop * newOptions.sizeMultiplier / options.sizeMultiplier;\n      }\n    }\n\n    if (valueSub) {\n      var _newOptions = options.havingStyle(options.style.sub());\n\n      subm = buildGroup$1(valueSub, _newOptions, options);\n\n      if (!isCharacterBox) {\n        subShift = base.depth + _newOptions.fontMetrics().subDrop * _newOptions.sizeMultiplier / options.sizeMultiplier;\n      }\n    } // Rule 18c\n\n\n    var minSupShift;\n\n    if (options.style === Style$1.DISPLAY) {\n      minSupShift = metrics.sup1;\n    } else if (options.style.cramped) {\n      minSupShift = metrics.sup3;\n    } else {\n      minSupShift = metrics.sup2;\n    } // scriptspace is a font-size-independent size, so scale it\n    // appropriately for use as the marginRight.\n\n\n    var multiplier = options.sizeMultiplier;\n    var marginRight = makeEm(0.5 / metrics.ptPerEm / multiplier);\n    var marginLeft = null;\n\n    if (subm) {\n      // Subscripts shouldn't be shifted by the base's italic correction.\n      // Account for that by shifting the subscript back the appropriate\n      // amount. Note we only do this when the base is a single symbol.\n      var isOiint = group.base && group.base.type === \"op\" && group.base.name && (group.base.name === \"\\\\oiint\" || group.base.name === \"\\\\oiiint\");\n\n      if (base instanceof SymbolNode || isOiint) {\n        // $FlowFixMe\n        marginLeft = makeEm(-base.italic);\n      }\n    }\n\n    var supsub;\n\n    if (supm && subm) {\n      supShift = Math.max(supShift, minSupShift, supm.depth + 0.25 * metrics.xHeight);\n      subShift = Math.max(subShift, metrics.sub2);\n      var ruleWidth = metrics.defaultRuleThickness; // Rule 18e\n\n      var maxWidth = 4 * ruleWidth;\n\n      if (supShift - supm.depth - (subm.height - subShift) < maxWidth) {\n        subShift = maxWidth - (supShift - supm.depth) + subm.height;\n        var psi = 0.8 * metrics.xHeight - (supShift - supm.depth);\n\n        if (psi > 0) {\n          supShift += psi;\n          subShift -= psi;\n        }\n      }\n\n      var vlistElem = [{\n        type: \"elem\",\n        elem: subm,\n        shift: subShift,\n        marginRight,\n        marginLeft\n      }, {\n        type: \"elem\",\n        elem: supm,\n        shift: -supShift,\n        marginRight\n      }];\n      supsub = buildCommon.makeVList({\n        positionType: \"individualShift\",\n        children: vlistElem\n      }, options);\n    } else if (subm) {\n      // Rule 18b\n      subShift = Math.max(subShift, metrics.sub1, subm.height - 0.8 * metrics.xHeight);\n      var _vlistElem = [{\n        type: \"elem\",\n        elem: subm,\n        marginLeft,\n        marginRight\n      }];\n      supsub = buildCommon.makeVList({\n        positionType: \"shift\",\n        positionData: subShift,\n        children: _vlistElem\n      }, options);\n    } else if (supm) {\n      // Rule 18c, d\n      supShift = Math.max(supShift, minSupShift, supm.depth + 0.25 * metrics.xHeight);\n      supsub = buildCommon.makeVList({\n        positionType: \"shift\",\n        positionData: -supShift,\n        children: [{\n          type: \"elem\",\n          elem: supm,\n          marginRight\n        }]\n      }, options);\n    } else {\n      throw new Error(\"supsub must have either sup or sub.\");\n    } // Wrap the supsub vlist in a span.msupsub to reset text-align.\n\n\n    var mclass = getTypeOfDomTree(base, \"right\") || \"mord\";\n    return buildCommon.makeSpan([mclass], [base, buildCommon.makeSpan([\"msupsub\"], [supsub])], options);\n  },\n\n  mathmlBuilder(group, options) {\n    // Is the inner group a relevant horizonal brace?\n    var isBrace = false;\n    var isOver;\n    var isSup;\n\n    if (group.base && group.base.type === \"horizBrace\") {\n      isSup = !!group.sup;\n\n      if (isSup === group.base.isOver) {\n        isBrace = true;\n        isOver = group.base.isOver;\n      }\n    }\n\n    if (group.base && (group.base.type === \"op\" || group.base.type === \"operatorname\")) {\n      group.base.parentIsSupSub = true;\n    }\n\n    var children = [buildGroup(group.base, options)];\n\n    if (group.sub) {\n      children.push(buildGroup(group.sub, options));\n    }\n\n    if (group.sup) {\n      children.push(buildGroup(group.sup, options));\n    }\n\n    var nodeType;\n\n    if (isBrace) {\n      nodeType = isOver ? \"mover\" : \"munder\";\n    } else if (!group.sub) {\n      var base = group.base;\n\n      if (base && base.type === \"op\" && base.limits && (options.style === Style$1.DISPLAY || base.alwaysHandleSupSub)) {\n        nodeType = \"mover\";\n      } else if (base && base.type === \"operatorname\" && base.alwaysHandleSupSub && (base.limits || options.style === Style$1.DISPLAY)) {\n        nodeType = \"mover\";\n      } else {\n        nodeType = \"msup\";\n      }\n    } else if (!group.sup) {\n      var _base = group.base;\n\n      if (_base && _base.type === \"op\" && _base.limits && (options.style === Style$1.DISPLAY || _base.alwaysHandleSupSub)) {\n        nodeType = \"munder\";\n      } else if (_base && _base.type === \"operatorname\" && _base.alwaysHandleSupSub && (_base.limits || options.style === Style$1.DISPLAY)) {\n        nodeType = \"munder\";\n      } else {\n        nodeType = \"msub\";\n      }\n    } else {\n      var _base2 = group.base;\n\n      if (_base2 && _base2.type === \"op\" && _base2.limits && options.style === Style$1.DISPLAY) {\n        nodeType = \"munderover\";\n      } else if (_base2 && _base2.type === \"operatorname\" && _base2.alwaysHandleSupSub && (options.style === Style$1.DISPLAY || _base2.limits)) {\n        nodeType = \"munderover\";\n      } else {\n        nodeType = \"msubsup\";\n      }\n    }\n\n    return new mathMLTree.MathNode(nodeType, children);\n  }\n\n});\n\ndefineFunctionBuilders({\n  type: \"atom\",\n\n  htmlBuilder(group, options) {\n    return buildCommon.mathsym(group.text, group.mode, options, [\"m\" + group.family]);\n  },\n\n  mathmlBuilder(group, options) {\n    var node = new mathMLTree.MathNode(\"mo\", [makeText(group.text, group.mode)]);\n\n    if (group.family === \"bin\") {\n      var variant = getVariant(group, options);\n\n      if (variant === \"bold-italic\") {\n        node.setAttribute(\"mathvariant\", variant);\n      }\n    } else if (group.family === \"punct\") {\n      node.setAttribute(\"separator\", \"true\");\n    } else if (group.family === \"open\" || group.family === \"close\") {\n      // Delims built here should not stretch vertically.\n      // See delimsizing.js for stretchy delims.\n      node.setAttribute(\"stretchy\", \"false\");\n    }\n\n    return node;\n  }\n\n});\n\n// \"mathord\" and \"textord\" ParseNodes created in Parser.js from symbol Groups in\n// src/symbols.js.\nvar defaultVariant = {\n  \"mi\": \"italic\",\n  \"mn\": \"normal\",\n  \"mtext\": \"normal\"\n};\ndefineFunctionBuilders({\n  type: \"mathord\",\n\n  htmlBuilder(group, options) {\n    return buildCommon.makeOrd(group, options, \"mathord\");\n  },\n\n  mathmlBuilder(group, options) {\n    var node = new mathMLTree.MathNode(\"mi\", [makeText(group.text, group.mode, options)]);\n    var variant = getVariant(group, options) || \"italic\";\n\n    if (variant !== defaultVariant[node.type]) {\n      node.setAttribute(\"mathvariant\", variant);\n    }\n\n    return node;\n  }\n\n});\ndefineFunctionBuilders({\n  type: \"textord\",\n\n  htmlBuilder(group, options) {\n    return buildCommon.makeOrd(group, options, \"textord\");\n  },\n\n  mathmlBuilder(group, options) {\n    var text = makeText(group.text, group.mode, options);\n    var variant = getVariant(group, options) || \"normal\";\n    var node;\n\n    if (group.mode === 'text') {\n      node = new mathMLTree.MathNode(\"mtext\", [text]);\n    } else if (/[0-9]/.test(group.text)) {\n      node = new mathMLTree.MathNode(\"mn\", [text]);\n    } else if (group.text === \"\\\\prime\") {\n      node = new mathMLTree.MathNode(\"mo\", [text]);\n    } else {\n      node = new mathMLTree.MathNode(\"mi\", [text]);\n    }\n\n    if (variant !== defaultVariant[node.type]) {\n      node.setAttribute(\"mathvariant\", variant);\n    }\n\n    return node;\n  }\n\n});\n\nvar cssSpace = {\n  \"\\\\nobreak\": \"nobreak\",\n  \"\\\\allowbreak\": \"allowbreak\"\n}; // A lookup table to determine whether a spacing function/symbol should be\n// treated like a regular space character.  If a symbol or command is a key\n// in this table, then it should be a regular space character.  Furthermore,\n// the associated value may have a `className` specifying an extra CSS class\n// to add to the created `span`.\n\nvar regularSpace = {\n  \" \": {},\n  \"\\\\ \": {},\n  \"~\": {\n    className: \"nobreak\"\n  },\n  \"\\\\space\": {},\n  \"\\\\nobreakspace\": {\n    className: \"nobreak\"\n  }\n}; // ParseNode<\"spacing\"> created in Parser.js from the \"spacing\" symbol Groups in\n// src/symbols.js.\n\ndefineFunctionBuilders({\n  type: \"spacing\",\n\n  htmlBuilder(group, options) {\n    if (regularSpace.hasOwnProperty(group.text)) {\n      var className = regularSpace[group.text].className || \"\"; // Spaces are generated by adding an actual space. Each of these\n      // things has an entry in the symbols table, so these will be turned\n      // into appropriate outputs.\n\n      if (group.mode === \"text\") {\n        var ord = buildCommon.makeOrd(group, options, \"textord\");\n        ord.classes.push(className);\n        return ord;\n      } else {\n        return buildCommon.makeSpan([\"mspace\", className], [buildCommon.mathsym(group.text, group.mode, options)], options);\n      }\n    } else if (cssSpace.hasOwnProperty(group.text)) {\n      // Spaces based on just a CSS class.\n      return buildCommon.makeSpan([\"mspace\", cssSpace[group.text]], [], options);\n    } else {\n      throw new ParseError(\"Unknown type of space \\\"\" + group.text + \"\\\"\");\n    }\n  },\n\n  mathmlBuilder(group, options) {\n    var node;\n\n    if (regularSpace.hasOwnProperty(group.text)) {\n      node = new mathMLTree.MathNode(\"mtext\", [new mathMLTree.TextNode(\"\\u00a0\")]);\n    } else if (cssSpace.hasOwnProperty(group.text)) {\n      // CSS-based MathML spaces (\\nobreak, \\allowbreak) are ignored\n      return new mathMLTree.MathNode(\"mspace\");\n    } else {\n      throw new ParseError(\"Unknown type of space \\\"\" + group.text + \"\\\"\");\n    }\n\n    return node;\n  }\n\n});\n\nvar pad = () => {\n  var padNode = new mathMLTree.MathNode(\"mtd\", []);\n  padNode.setAttribute(\"width\", \"50%\");\n  return padNode;\n};\n\ndefineFunctionBuilders({\n  type: \"tag\",\n\n  mathmlBuilder(group, options) {\n    var table = new mathMLTree.MathNode(\"mtable\", [new mathMLTree.MathNode(\"mtr\", [pad(), new mathMLTree.MathNode(\"mtd\", [buildExpressionRow(group.body, options)]), pad(), new mathMLTree.MathNode(\"mtd\", [buildExpressionRow(group.tag, options)])])]);\n    table.setAttribute(\"width\", \"100%\");\n    return table; // TODO: Left-aligned tags.\n    // Currently, the group and options passed here do not contain\n    // enough info to set tag alignment. `leqno` is in Settings but it is\n    // not passed to Options. On the HTML side, leqno is\n    // set by a CSS class applied in buildTree.js. That would have worked\n    // in MathML if browsers supported <mlabeledtr>. Since they don't, we\n    // need to rewrite the way this function is called.\n  }\n\n});\n\nvar textFontFamilies = {\n  \"\\\\text\": undefined,\n  \"\\\\textrm\": \"textrm\",\n  \"\\\\textsf\": \"textsf\",\n  \"\\\\texttt\": \"texttt\",\n  \"\\\\textnormal\": \"textrm\"\n};\nvar textFontWeights = {\n  \"\\\\textbf\": \"textbf\",\n  \"\\\\textmd\": \"textmd\"\n};\nvar textFontShapes = {\n  \"\\\\textit\": \"textit\",\n  \"\\\\textup\": \"textup\"\n};\n\nvar optionsWithFont = (group, options) => {\n  var font = group.font; // Checks if the argument is a font family or a font style.\n\n  if (!font) {\n    return options;\n  } else if (textFontFamilies[font]) {\n    return options.withTextFontFamily(textFontFamilies[font]);\n  } else if (textFontWeights[font]) {\n    return options.withTextFontWeight(textFontWeights[font]);\n  } else if (font === \"\\\\emph\") {\n    return options.fontShape === \"textit\" ? options.withTextFontShape(\"textup\") : options.withTextFontShape(\"textit\");\n  }\n\n  return options.withTextFontShape(textFontShapes[font]);\n};\n\ndefineFunction({\n  type: \"text\",\n  names: [// Font families\n  \"\\\\text\", \"\\\\textrm\", \"\\\\textsf\", \"\\\\texttt\", \"\\\\textnormal\", // Font weights\n  \"\\\\textbf\", \"\\\\textmd\", // Font Shapes\n  \"\\\\textit\", \"\\\\textup\", \"\\\\emph\"],\n  props: {\n    numArgs: 1,\n    argTypes: [\"text\"],\n    allowedInArgument: true,\n    allowedInText: true\n  },\n\n  handler(_ref, args) {\n    var {\n      parser,\n      funcName\n    } = _ref;\n    var body = args[0];\n    return {\n      type: \"text\",\n      mode: parser.mode,\n      body: ordargument(body),\n      font: funcName\n    };\n  },\n\n  htmlBuilder(group, options) {\n    var newOptions = optionsWithFont(group, options);\n    var inner = buildExpression$1(group.body, newOptions, true);\n    return buildCommon.makeSpan([\"mord\", \"text\"], inner, newOptions);\n  },\n\n  mathmlBuilder(group, options) {\n    var newOptions = optionsWithFont(group, options);\n    return buildExpressionRow(group.body, newOptions);\n  }\n\n});\n\ndefineFunction({\n  type: \"underline\",\n  names: [\"\\\\underline\"],\n  props: {\n    numArgs: 1,\n    allowedInText: true\n  },\n\n  handler(_ref, args) {\n    var {\n      parser\n    } = _ref;\n    return {\n      type: \"underline\",\n      mode: parser.mode,\n      body: args[0]\n    };\n  },\n\n  htmlBuilder(group, options) {\n    // Underlines are handled in the TeXbook pg 443, Rule 10.\n    // Build the inner group.\n    var innerGroup = buildGroup$1(group.body, options); // Create the line to go below the body\n\n    var line = buildCommon.makeLineSpan(\"underline-line\", options); // Generate the vlist, with the appropriate kerns\n\n    var defaultRuleThickness = options.fontMetrics().defaultRuleThickness;\n    var vlist = buildCommon.makeVList({\n      positionType: \"top\",\n      positionData: innerGroup.height,\n      children: [{\n        type: \"kern\",\n        size: defaultRuleThickness\n      }, {\n        type: \"elem\",\n        elem: line\n      }, {\n        type: \"kern\",\n        size: 3 * defaultRuleThickness\n      }, {\n        type: \"elem\",\n        elem: innerGroup\n      }]\n    }, options);\n    return buildCommon.makeSpan([\"mord\", \"underline\"], [vlist], options);\n  },\n\n  mathmlBuilder(group, options) {\n    var operator = new mathMLTree.MathNode(\"mo\", [new mathMLTree.TextNode(\"\\u203e\")]);\n    operator.setAttribute(\"stretchy\", \"true\");\n    var node = new mathMLTree.MathNode(\"munder\", [buildGroup(group.body, options), operator]);\n    node.setAttribute(\"accentunder\", \"true\");\n    return node;\n  }\n\n});\n\ndefineFunction({\n  type: \"vcenter\",\n  names: [\"\\\\vcenter\"],\n  props: {\n    numArgs: 1,\n    argTypes: [\"original\"],\n    // In LaTeX, \\vcenter can act only on a box.\n    allowedInText: false\n  },\n\n  handler(_ref, args) {\n    var {\n      parser\n    } = _ref;\n    return {\n      type: \"vcenter\",\n      mode: parser.mode,\n      body: args[0]\n    };\n  },\n\n  htmlBuilder(group, options) {\n    var body = buildGroup$1(group.body, options);\n    var axisHeight = options.fontMetrics().axisHeight;\n    var dy = 0.5 * (body.height - axisHeight - (body.depth + axisHeight));\n    return buildCommon.makeVList({\n      positionType: \"shift\",\n      positionData: dy,\n      children: [{\n        type: \"elem\",\n        elem: body\n      }]\n    }, options);\n  },\n\n  mathmlBuilder(group, options) {\n    // There is no way to do this in MathML.\n    // Write a class as a breadcrumb in case some post-processor wants\n    // to perform a vcenter adjustment.\n    return new mathMLTree.MathNode(\"mpadded\", [buildGroup(group.body, options)], [\"vcenter\"]);\n  }\n\n});\n\ndefineFunction({\n  type: \"verb\",\n  names: [\"\\\\verb\"],\n  props: {\n    numArgs: 0,\n    allowedInText: true\n  },\n\n  handler(context, args, optArgs) {\n    // \\verb and \\verb* are dealt with directly in Parser.js.\n    // If we end up here, it's because of a failure to match the two delimiters\n    // in the regex in Lexer.js.  LaTeX raises the following error when \\verb is\n    // terminated by end of line (or file).\n    throw new ParseError(\"\\\\verb ended by end of line instead of matching delimiter\");\n  },\n\n  htmlBuilder(group, options) {\n    var text = makeVerb(group);\n    var body = []; // \\verb enters text mode and therefore is sized like \\textstyle\n\n    var newOptions = options.havingStyle(options.style.text());\n\n    for (var i = 0; i < text.length; i++) {\n      var c = text[i];\n\n      if (c === '~') {\n        c = '\\\\textasciitilde';\n      }\n\n      body.push(buildCommon.makeSymbol(c, \"Typewriter-Regular\", group.mode, newOptions, [\"mord\", \"texttt\"]));\n    }\n\n    return buildCommon.makeSpan([\"mord\", \"text\"].concat(newOptions.sizingClasses(options)), buildCommon.tryCombineChars(body), newOptions);\n  },\n\n  mathmlBuilder(group, options) {\n    var text = new mathMLTree.TextNode(makeVerb(group));\n    var node = new mathMLTree.MathNode(\"mtext\", [text]);\n    node.setAttribute(\"mathvariant\", \"monospace\");\n    return node;\n  }\n\n});\n/**\n * Converts verb group into body string.\n *\n * \\verb* replaces each space with an open box \\u2423\n * \\verb replaces each space with a no-break space \\xA0\n */\n\nvar makeVerb = group => group.body.replace(/ /g, group.star ? '\\u2423' : '\\xA0');\n\n/** Include this to ensure that all functions are defined. */\nvar functions = _functions;\n\n/**\n * The Lexer class handles tokenizing the input in various ways. Since our\n * parser expects us to be able to backtrack, the lexer allows lexing from any\n * given starting point.\n *\n * Its main exposed function is the `lex` function, which takes a position to\n * lex from and a type of token to lex. It defers to the appropriate `_innerLex`\n * function.\n *\n * The various `_innerLex` functions perform the actual lexing of different\n * kinds.\n */\n\n/* The following tokenRegex\n * - matches typical whitespace (but not NBSP etc.) using its first group\n * - does not match any control character \\x00-\\x1f except whitespace\n * - does not match a bare backslash\n * - matches any ASCII character except those just mentioned\n * - does not match the BMP private use area \\uE000-\\uF8FF\n * - does not match bare surrogate code units\n * - matches any BMP character except for those just described\n * - matches any valid Unicode surrogate pair\n * - matches a backslash followed by one or more whitespace characters\n * - matches a backslash followed by one or more letters then whitespace\n * - matches a backslash followed by any BMP character\n * Capturing groups:\n *   [1] regular whitespace\n *   [2] backslash followed by whitespace\n *   [3] anything else, which may include:\n *     [4] left character of \\verb*\n *     [5] left character of \\verb\n *     [6] backslash followed by word, excluding any trailing whitespace\n * Just because the Lexer matches something doesn't mean it's valid input:\n * If there is no matching function or symbol definition, the Parser will\n * still reject the input.\n */\nvar spaceRegexString = \"[ \\r\\n\\t]\";\nvar controlWordRegexString = \"\\\\\\\\[a-zA-Z@]+\";\nvar controlSymbolRegexString = \"\\\\\\\\[^\\uD800-\\uDFFF]\";\nvar controlWordWhitespaceRegexString = \"(\" + controlWordRegexString + \")\" + spaceRegexString + \"*\";\nvar controlSpaceRegexString = \"\\\\\\\\(\\n|[ \\r\\t]+\\n?)[ \\r\\t]*\";\nvar combiningDiacriticalMarkString = \"[\\u0300-\\u036f]\";\nvar combiningDiacriticalMarksEndRegex = new RegExp(combiningDiacriticalMarkString + \"+$\");\nvar tokenRegexString = \"(\" + spaceRegexString + \"+)|\" + ( // whitespace\ncontrolSpaceRegexString + \"|\") + // \\whitespace\n\"([!-\\\\[\\\\]-\\u2027\\u202A-\\uD7FF\\uF900-\\uFFFF]\" + ( // single codepoint\ncombiningDiacriticalMarkString + \"*\") + // ...plus accents\n\"|[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]\" + ( // surrogate pair\ncombiningDiacriticalMarkString + \"*\") + // ...plus accents\n\"|\\\\\\\\verb\\\\*([^]).*?\\\\4\" + // \\verb*\n\"|\\\\\\\\verb([^*a-zA-Z]).*?\\\\5\" + ( // \\verb unstarred\n\"|\" + controlWordWhitespaceRegexString) + ( // \\macroName + spaces\n\"|\" + controlSymbolRegexString + \")\"); // \\\\, \\', etc.\n\n/** Main Lexer class */\n\nclass Lexer {\n  // Category codes. The lexer only supports comment characters (14) for now.\n  // MacroExpander additionally distinguishes active (13).\n  constructor(input, settings) {\n    this.input = void 0;\n    this.settings = void 0;\n    this.tokenRegex = void 0;\n    this.catcodes = void 0;\n    // Separate accents from characters\n    this.input = input;\n    this.settings = settings;\n    this.tokenRegex = new RegExp(tokenRegexString, 'g');\n    this.catcodes = {\n      \"%\": 14,\n      // comment character\n      \"~\": 13 // active character\n\n    };\n  }\n\n  setCatcode(char, code) {\n    this.catcodes[char] = code;\n  }\n  /**\n   * This function lexes a single token.\n   */\n\n\n  lex() {\n    var input = this.input;\n    var pos = this.tokenRegex.lastIndex;\n\n    if (pos === input.length) {\n      return new Token(\"EOF\", new SourceLocation(this, pos, pos));\n    }\n\n    var match = this.tokenRegex.exec(input);\n\n    if (match === null || match.index !== pos) {\n      throw new ParseError(\"Unexpected character: '\" + input[pos] + \"'\", new Token(input[pos], new SourceLocation(this, pos, pos + 1)));\n    }\n\n    var text = match[6] || match[3] || (match[2] ? \"\\\\ \" : \" \");\n\n    if (this.catcodes[text] === 14) {\n      // comment character\n      var nlIndex = input.indexOf('\\n', this.tokenRegex.lastIndex);\n\n      if (nlIndex === -1) {\n        this.tokenRegex.lastIndex = input.length; // EOF\n\n        this.settings.reportNonstrict(\"commentAtEnd\", \"% comment has no terminating newline; LaTeX would \" + \"fail because of commenting the end of math mode (e.g. $)\");\n      } else {\n        this.tokenRegex.lastIndex = nlIndex + 1;\n      }\n\n      return this.lex();\n    }\n\n    return new Token(text, new SourceLocation(this, pos, this.tokenRegex.lastIndex));\n  }\n\n}\n\n/**\n * A `Namespace` refers to a space of nameable things like macros or lengths,\n * which can be `set` either globally or local to a nested group, using an\n * undo stack similar to how TeX implements this functionality.\n * Performance-wise, `get` and local `set` take constant time, while global\n * `set` takes time proportional to the depth of group nesting.\n */\nclass Namespace {\n  /**\n   * Both arguments are optional.  The first argument is an object of\n   * built-in mappings which never change.  The second argument is an object\n   * of initial (global-level) mappings, which will constantly change\n   * according to any global/top-level `set`s done.\n   */\n  constructor(builtins, globalMacros) {\n    if (builtins === void 0) {\n      builtins = {};\n    }\n\n    if (globalMacros === void 0) {\n      globalMacros = {};\n    }\n\n    this.current = void 0;\n    this.builtins = void 0;\n    this.undefStack = void 0;\n    this.current = globalMacros;\n    this.builtins = builtins;\n    this.undefStack = [];\n  }\n  /**\n   * Start a new nested group, affecting future local `set`s.\n   */\n\n\n  beginGroup() {\n    this.undefStack.push({});\n  }\n  /**\n   * End current nested group, restoring values before the group began.\n   */\n\n\n  endGroup() {\n    if (this.undefStack.length === 0) {\n      throw new ParseError(\"Unbalanced namespace destruction: attempt \" + \"to pop global namespace; please report this as a bug\");\n    }\n\n    var undefs = this.undefStack.pop();\n\n    for (var undef in undefs) {\n      if (undefs.hasOwnProperty(undef)) {\n        if (undefs[undef] == null) {\n          delete this.current[undef];\n        } else {\n          this.current[undef] = undefs[undef];\n        }\n      }\n    }\n  }\n  /**\n   * Ends all currently nested groups (if any), restoring values before the\n   * groups began.  Useful in case of an error in the middle of parsing.\n   */\n\n\n  endGroups() {\n    while (this.undefStack.length > 0) {\n      this.endGroup();\n    }\n  }\n  /**\n   * Detect whether `name` has a definition.  Equivalent to\n   * `get(name) != null`.\n   */\n\n\n  has(name) {\n    return this.current.hasOwnProperty(name) || this.builtins.hasOwnProperty(name);\n  }\n  /**\n   * Get the current value of a name, or `undefined` if there is no value.\n   *\n   * Note: Do not use `if (namespace.get(...))` to detect whether a macro\n   * is defined, as the definition may be the empty string which evaluates\n   * to `false` in JavaScript.  Use `if (namespace.get(...) != null)` or\n   * `if (namespace.has(...))`.\n   */\n\n\n  get(name) {\n    if (this.current.hasOwnProperty(name)) {\n      return this.current[name];\n    } else {\n      return this.builtins[name];\n    }\n  }\n  /**\n   * Set the current value of a name, and optionally set it globally too.\n   * Local set() sets the current value and (when appropriate) adds an undo\n   * operation to the undo stack.  Global set() may change the undo\n   * operation at every level, so takes time linear in their number.\n   * A value of undefined means to delete existing definitions.\n   */\n\n\n  set(name, value, global) {\n    if (global === void 0) {\n      global = false;\n    }\n\n    if (global) {\n      // Global set is equivalent to setting in all groups.  Simulate this\n      // by destroying any undos currently scheduled for this name,\n      // and adding an undo with the *new* value (in case it later gets\n      // locally reset within this environment).\n      for (var i = 0; i < this.undefStack.length; i++) {\n        delete this.undefStack[i][name];\n      }\n\n      if (this.undefStack.length > 0) {\n        this.undefStack[this.undefStack.length - 1][name] = value;\n      }\n    } else {\n      // Undo this set at end of this group (possibly to `undefined`),\n      // unless an undo is already in place, in which case that older\n      // value is the correct one.\n      var top = this.undefStack[this.undefStack.length - 1];\n\n      if (top && !top.hasOwnProperty(name)) {\n        top[name] = this.current[name];\n      }\n    }\n\n    if (value == null) {\n      delete this.current[name];\n    } else {\n      this.current[name] = value;\n    }\n  }\n\n}\n\n/**\n * Predefined macros for KaTeX.\n * This can be used to define some commands in terms of others.\n */\nvar macros = _macros;\n// macro tools\n\ndefineMacro(\"\\\\noexpand\", function (context) {\n  // The expansion is the token itself; but that token is interpreted\n  // as if its meaning were ‘\\relax’ if it is a control sequence that\n  // would ordinarily be expanded by TeX’s expansion rules.\n  var t = context.popToken();\n\n  if (context.isExpandable(t.text)) {\n    t.noexpand = true;\n    t.treatAsRelax = true;\n  }\n\n  return {\n    tokens: [t],\n    numArgs: 0\n  };\n});\ndefineMacro(\"\\\\expandafter\", function (context) {\n  // TeX first reads the token that comes immediately after \\expandafter,\n  // without expanding it; let’s call this token t. Then TeX reads the\n  // token that comes after t (and possibly more tokens, if that token\n  // has an argument), replacing it by its expansion. Finally TeX puts\n  // t back in front of that expansion.\n  var t = context.popToken();\n  context.expandOnce(true); // expand only an expandable token\n\n  return {\n    tokens: [t],\n    numArgs: 0\n  };\n}); // LaTeX's \\@firstoftwo{#1}{#2} expands to #1, skipping #2\n// TeX source: \\long\\def\\@firstoftwo#1#2{#1}\n\ndefineMacro(\"\\\\@firstoftwo\", function (context) {\n  var args = context.consumeArgs(2);\n  return {\n    tokens: args[0],\n    numArgs: 0\n  };\n}); // LaTeX's \\@secondoftwo{#1}{#2} expands to #2, skipping #1\n// TeX source: \\long\\def\\@secondoftwo#1#2{#2}\n\ndefineMacro(\"\\\\@secondoftwo\", function (context) {\n  var args = context.consumeArgs(2);\n  return {\n    tokens: args[1],\n    numArgs: 0\n  };\n}); // LaTeX's \\@ifnextchar{#1}{#2}{#3} looks ahead to the next (unexpanded)\n// symbol that isn't a space, consuming any spaces but not consuming the\n// first nonspace character.  If that nonspace character matches #1, then\n// the macro expands to #2; otherwise, it expands to #3.\n\ndefineMacro(\"\\\\@ifnextchar\", function (context) {\n  var args = context.consumeArgs(3); // symbol, if, else\n\n  context.consumeSpaces();\n  var nextToken = context.future();\n\n  if (args[0].length === 1 && args[0][0].text === nextToken.text) {\n    return {\n      tokens: args[1],\n      numArgs: 0\n    };\n  } else {\n    return {\n      tokens: args[2],\n      numArgs: 0\n    };\n  }\n}); // LaTeX's \\@ifstar{#1}{#2} looks ahead to the next (unexpanded) symbol.\n// If it is `*`, then it consumes the symbol, and the macro expands to #1;\n// otherwise, the macro expands to #2 (without consuming the symbol).\n// TeX source: \\def\\@ifstar#1{\\@ifnextchar *{\\@firstoftwo{#1}}}\n\ndefineMacro(\"\\\\@ifstar\", \"\\\\@ifnextchar *{\\\\@firstoftwo{#1}}\"); // LaTeX's \\TextOrMath{#1}{#2} expands to #1 in text mode, #2 in math mode\n\ndefineMacro(\"\\\\TextOrMath\", function (context) {\n  var args = context.consumeArgs(2);\n\n  if (context.mode === 'text') {\n    return {\n      tokens: args[0],\n      numArgs: 0\n    };\n  } else {\n    return {\n      tokens: args[1],\n      numArgs: 0\n    };\n  }\n}); // Lookup table for parsing numbers in base 8 through 16\n\nvar digitToNumber = {\n  \"0\": 0,\n  \"1\": 1,\n  \"2\": 2,\n  \"3\": 3,\n  \"4\": 4,\n  \"5\": 5,\n  \"6\": 6,\n  \"7\": 7,\n  \"8\": 8,\n  \"9\": 9,\n  \"a\": 10,\n  \"A\": 10,\n  \"b\": 11,\n  \"B\": 11,\n  \"c\": 12,\n  \"C\": 12,\n  \"d\": 13,\n  \"D\": 13,\n  \"e\": 14,\n  \"E\": 14,\n  \"f\": 15,\n  \"F\": 15\n}; // TeX \\char makes a literal character (catcode 12) using the following forms:\n// (see The TeXBook, p. 43)\n//   \\char123  -- decimal\n//   \\char'123 -- octal\n//   \\char\"123 -- hex\n//   \\char`x   -- character that can be written (i.e. isn't active)\n//   \\char`\\x  -- character that cannot be written (e.g. %)\n// These all refer to characters from the font, so we turn them into special\n// calls to a function \\@char dealt with in the Parser.\n\ndefineMacro(\"\\\\char\", function (context) {\n  var token = context.popToken();\n  var base;\n  var number = '';\n\n  if (token.text === \"'\") {\n    base = 8;\n    token = context.popToken();\n  } else if (token.text === '\"') {\n    base = 16;\n    token = context.popToken();\n  } else if (token.text === \"`\") {\n    token = context.popToken();\n\n    if (token.text[0] === \"\\\\\") {\n      number = token.text.charCodeAt(1);\n    } else if (token.text === \"EOF\") {\n      throw new ParseError(\"\\\\char` missing argument\");\n    } else {\n      number = token.text.charCodeAt(0);\n    }\n  } else {\n    base = 10;\n  }\n\n  if (base) {\n    // Parse a number in the given base, starting with first `token`.\n    number = digitToNumber[token.text];\n\n    if (number == null || number >= base) {\n      throw new ParseError(\"Invalid base-\" + base + \" digit \" + token.text);\n    }\n\n    var digit;\n\n    while ((digit = digitToNumber[context.future().text]) != null && digit < base) {\n      number *= base;\n      number += digit;\n      context.popToken();\n    }\n  }\n\n  return \"\\\\@char{\" + number + \"}\";\n}); // \\newcommand{\\macro}[args]{definition}\n// \\renewcommand{\\macro}[args]{definition}\n// TODO: Optional arguments: \\newcommand{\\macro}[args][default]{definition}\n\nvar newcommand = (context, existsOK, nonexistsOK, skipIfExists) => {\n  var arg = context.consumeArg().tokens;\n\n  if (arg.length !== 1) {\n    throw new ParseError(\"\\\\newcommand's first argument must be a macro name\");\n  }\n\n  var name = arg[0].text;\n  var exists = context.isDefined(name);\n\n  if (exists && !existsOK) {\n    throw new ParseError(\"\\\\newcommand{\" + name + \"} attempting to redefine \" + (name + \"; use \\\\renewcommand\"));\n  }\n\n  if (!exists && !nonexistsOK) {\n    throw new ParseError(\"\\\\renewcommand{\" + name + \"} when command \" + name + \" \" + \"does not yet exist; use \\\\newcommand\");\n  }\n\n  var numArgs = 0;\n  arg = context.consumeArg().tokens;\n\n  if (arg.length === 1 && arg[0].text === \"[\") {\n    var argText = '';\n    var token = context.expandNextToken();\n\n    while (token.text !== \"]\" && token.text !== \"EOF\") {\n      // TODO: Should properly expand arg, e.g., ignore {}s\n      argText += token.text;\n      token = context.expandNextToken();\n    }\n\n    if (!argText.match(/^\\s*[0-9]+\\s*$/)) {\n      throw new ParseError(\"Invalid number of arguments: \" + argText);\n    }\n\n    numArgs = parseInt(argText);\n    arg = context.consumeArg().tokens;\n  }\n\n  if (!(exists && skipIfExists)) {\n    // Final arg is the expansion of the macro\n    context.macros.set(name, {\n      tokens: arg,\n      numArgs\n    });\n  }\n\n  return '';\n};\n\ndefineMacro(\"\\\\newcommand\", context => newcommand(context, false, true, false));\ndefineMacro(\"\\\\renewcommand\", context => newcommand(context, true, false, false));\ndefineMacro(\"\\\\providecommand\", context => newcommand(context, true, true, true)); // terminal (console) tools\n\ndefineMacro(\"\\\\message\", context => {\n  var arg = context.consumeArgs(1)[0]; // eslint-disable-next-line no-console\n\n  console.log(arg.reverse().map(token => token.text).join(\"\"));\n  return '';\n});\ndefineMacro(\"\\\\errmessage\", context => {\n  var arg = context.consumeArgs(1)[0]; // eslint-disable-next-line no-console\n\n  console.error(arg.reverse().map(token => token.text).join(\"\"));\n  return '';\n});\ndefineMacro(\"\\\\show\", context => {\n  var tok = context.popToken();\n  var name = tok.text; // eslint-disable-next-line no-console\n\n  console.log(tok, context.macros.get(name), functions[name], symbols.math[name], symbols.text[name]);\n  return '';\n}); //////////////////////////////////////////////////////////////////////\n// Grouping\n// \\let\\bgroup={ \\let\\egroup=}\n\ndefineMacro(\"\\\\bgroup\", \"{\");\ndefineMacro(\"\\\\egroup\", \"}\"); // Symbols from latex.ltx:\n// \\def~{\\nobreakspace{}}\n// \\def\\lq{`}\n// \\def\\rq{'}\n// \\def \\aa {\\r a}\n// \\def \\AA {\\r A}\n\ndefineMacro(\"~\", \"\\\\nobreakspace\");\ndefineMacro(\"\\\\lq\", \"`\");\ndefineMacro(\"\\\\rq\", \"'\");\ndefineMacro(\"\\\\aa\", \"\\\\r a\");\ndefineMacro(\"\\\\AA\", \"\\\\r A\"); // Copyright (C) and registered (R) symbols. Use raw symbol in MathML.\n// \\DeclareTextCommandDefault{\\textcopyright}{\\textcircled{c}}\n// \\DeclareTextCommandDefault{\\textregistered}{\\textcircled{%\n//      \\check@mathfonts\\fontsize\\sf@size\\z@\\math@fontsfalse\\selectfont R}}\n// \\DeclareRobustCommand{\\copyright}{%\n//    \\ifmmode{\\nfss@text{\\textcopyright}}\\else\\textcopyright\\fi}\n\ndefineMacro(\"\\\\textcopyright\", \"\\\\html@mathml{\\\\textcircled{c}}{\\\\char`©}\");\ndefineMacro(\"\\\\copyright\", \"\\\\TextOrMath{\\\\textcopyright}{\\\\text{\\\\textcopyright}}\");\ndefineMacro(\"\\\\textregistered\", \"\\\\html@mathml{\\\\textcircled{\\\\scriptsize R}}{\\\\char`®}\"); // Characters omitted from Unicode range 1D400–1D7FF\n\ndefineMacro(\"\\u212C\", \"\\\\mathscr{B}\"); // script\n\ndefineMacro(\"\\u2130\", \"\\\\mathscr{E}\");\ndefineMacro(\"\\u2131\", \"\\\\mathscr{F}\");\ndefineMacro(\"\\u210B\", \"\\\\mathscr{H}\");\ndefineMacro(\"\\u2110\", \"\\\\mathscr{I}\");\ndefineMacro(\"\\u2112\", \"\\\\mathscr{L}\");\ndefineMacro(\"\\u2133\", \"\\\\mathscr{M}\");\ndefineMacro(\"\\u211B\", \"\\\\mathscr{R}\");\ndefineMacro(\"\\u212D\", \"\\\\mathfrak{C}\"); // Fraktur\n\ndefineMacro(\"\\u210C\", \"\\\\mathfrak{H}\");\ndefineMacro(\"\\u2128\", \"\\\\mathfrak{Z}\"); // Define \\Bbbk with a macro that works in both HTML and MathML.\n\ndefineMacro(\"\\\\Bbbk\", \"\\\\Bbb{k}\"); // Unicode middle dot\n// The KaTeX fonts do not contain U+00B7. Instead, \\cdotp displays\n// the dot at U+22C5 and gives it punct spacing.\n\ndefineMacro(\"\\u00b7\", \"\\\\cdotp\"); // \\llap and \\rlap render their contents in text mode\n\ndefineMacro(\"\\\\llap\", \"\\\\mathllap{\\\\textrm{#1}}\");\ndefineMacro(\"\\\\rlap\", \"\\\\mathrlap{\\\\textrm{#1}}\");\ndefineMacro(\"\\\\clap\", \"\\\\mathclap{\\\\textrm{#1}}\"); // \\mathstrut from the TeXbook, p 360\n\ndefineMacro(\"\\\\mathstrut\", \"\\\\vphantom{(}\"); // \\underbar from TeXbook p 353\n\ndefineMacro(\"\\\\underbar\", \"\\\\underline{\\\\text{#1}}\"); // \\not is defined by base/fontmath.ltx via\n// \\DeclareMathSymbol{\\not}{\\mathrel}{symbols}{\"36}\n// It's thus treated like a \\mathrel, but defined by a symbol that has zero\n// width but extends to the right.  We use \\rlap to get that spacing.\n// For MathML we write U+0338 here. buildMathML.js will then do the overlay.\n\ndefineMacro(\"\\\\not\", '\\\\html@mathml{\\\\mathrel{\\\\mathrlap\\\\@not}}{\\\\char\"338}'); // Negated symbols from base/fontmath.ltx:\n// \\def\\neq{\\not=} \\let\\ne=\\neq\n// \\DeclareRobustCommand\n//   \\notin{\\mathrel{\\m@th\\mathpalette\\c@ncel\\in}}\n// \\def\\c@ncel#1#2{\\m@th\\ooalign{$\\hfil#1\\mkern1mu/\\hfil$\\crcr$#1#2$}}\n\ndefineMacro(\"\\\\neq\", \"\\\\html@mathml{\\\\mathrel{\\\\not=}}{\\\\mathrel{\\\\char`≠}}\");\ndefineMacro(\"\\\\ne\", \"\\\\neq\");\ndefineMacro(\"\\u2260\", \"\\\\neq\");\ndefineMacro(\"\\\\notin\", \"\\\\html@mathml{\\\\mathrel{{\\\\in}\\\\mathllap{/\\\\mskip1mu}}}\" + \"{\\\\mathrel{\\\\char`∉}}\");\ndefineMacro(\"\\u2209\", \"\\\\notin\"); // Unicode stacked relations\n\ndefineMacro(\"\\u2258\", \"\\\\html@mathml{\" + \"\\\\mathrel{=\\\\kern{-1em}\\\\raisebox{0.4em}{$\\\\scriptsize\\\\frown$}}\" + \"}{\\\\mathrel{\\\\char`\\u2258}}\");\ndefineMacro(\"\\u2259\", \"\\\\html@mathml{\\\\stackrel{\\\\tiny\\\\wedge}{=}}{\\\\mathrel{\\\\char`\\u2258}}\");\ndefineMacro(\"\\u225A\", \"\\\\html@mathml{\\\\stackrel{\\\\tiny\\\\vee}{=}}{\\\\mathrel{\\\\char`\\u225A}}\");\ndefineMacro(\"\\u225B\", \"\\\\html@mathml{\\\\stackrel{\\\\scriptsize\\\\star}{=}}\" + \"{\\\\mathrel{\\\\char`\\u225B}}\");\ndefineMacro(\"\\u225D\", \"\\\\html@mathml{\\\\stackrel{\\\\tiny\\\\mathrm{def}}{=}}\" + \"{\\\\mathrel{\\\\char`\\u225D}}\");\ndefineMacro(\"\\u225E\", \"\\\\html@mathml{\\\\stackrel{\\\\tiny\\\\mathrm{m}}{=}}\" + \"{\\\\mathrel{\\\\char`\\u225E}}\");\ndefineMacro(\"\\u225F\", \"\\\\html@mathml{\\\\stackrel{\\\\tiny?}{=}}{\\\\mathrel{\\\\char`\\u225F}}\"); // Misc Unicode\n\ndefineMacro(\"\\u27C2\", \"\\\\perp\");\ndefineMacro(\"\\u203C\", \"\\\\mathclose{!\\\\mkern-0.8mu!}\");\ndefineMacro(\"\\u220C\", \"\\\\notni\");\ndefineMacro(\"\\u231C\", \"\\\\ulcorner\");\ndefineMacro(\"\\u231D\", \"\\\\urcorner\");\ndefineMacro(\"\\u231E\", \"\\\\llcorner\");\ndefineMacro(\"\\u231F\", \"\\\\lrcorner\");\ndefineMacro(\"\\u00A9\", \"\\\\copyright\");\ndefineMacro(\"\\u00AE\", \"\\\\textregistered\");\ndefineMacro(\"\\uFE0F\", \"\\\\textregistered\"); // The KaTeX fonts have corners at codepoints that don't match Unicode.\n// For MathML purposes, use the Unicode code point.\n\ndefineMacro(\"\\\\ulcorner\", \"\\\\html@mathml{\\\\@ulcorner}{\\\\mathop{\\\\char\\\"231c}}\");\ndefineMacro(\"\\\\urcorner\", \"\\\\html@mathml{\\\\@urcorner}{\\\\mathop{\\\\char\\\"231d}}\");\ndefineMacro(\"\\\\llcorner\", \"\\\\html@mathml{\\\\@llcorner}{\\\\mathop{\\\\char\\\"231e}}\");\ndefineMacro(\"\\\\lrcorner\", \"\\\\html@mathml{\\\\@lrcorner}{\\\\mathop{\\\\char\\\"231f}}\"); //////////////////////////////////////////////////////////////////////\n// LaTeX_2ε\n// \\vdots{\\vbox{\\baselineskip4\\p@  \\lineskiplimit\\z@\n// \\kern6\\p@\\hbox{.}\\hbox{.}\\hbox{.}}}\n// We'll call \\varvdots, which gets a glyph from symbols.js.\n// The zero-width rule gets us an equivalent to the vertical 6pt kern.\n\ndefineMacro(\"\\\\vdots\", \"{\\\\varvdots\\\\rule{0pt}{15pt}}\");\ndefineMacro(\"\\u22ee\", \"\\\\vdots\"); //////////////////////////////////////////////////////////////////////\n// amsmath.sty\n// http://mirrors.concertpass.com/tex-archive/macros/latex/required/amsmath/amsmath.pdf\n// Italic Greek capital letters.  AMS defines these with \\DeclareMathSymbol,\n// but they are equivalent to \\mathit{\\Letter}.\n\ndefineMacro(\"\\\\varGamma\", \"\\\\mathit{\\\\Gamma}\");\ndefineMacro(\"\\\\varDelta\", \"\\\\mathit{\\\\Delta}\");\ndefineMacro(\"\\\\varTheta\", \"\\\\mathit{\\\\Theta}\");\ndefineMacro(\"\\\\varLambda\", \"\\\\mathit{\\\\Lambda}\");\ndefineMacro(\"\\\\varXi\", \"\\\\mathit{\\\\Xi}\");\ndefineMacro(\"\\\\varPi\", \"\\\\mathit{\\\\Pi}\");\ndefineMacro(\"\\\\varSigma\", \"\\\\mathit{\\\\Sigma}\");\ndefineMacro(\"\\\\varUpsilon\", \"\\\\mathit{\\\\Upsilon}\");\ndefineMacro(\"\\\\varPhi\", \"\\\\mathit{\\\\Phi}\");\ndefineMacro(\"\\\\varPsi\", \"\\\\mathit{\\\\Psi}\");\ndefineMacro(\"\\\\varOmega\", \"\\\\mathit{\\\\Omega}\"); //\\newcommand{\\substack}[1]{\\subarray{c}#1\\endsubarray}\n\ndefineMacro(\"\\\\substack\", \"\\\\begin{subarray}{c}#1\\\\end{subarray}\"); // \\renewcommand{\\colon}{\\nobreak\\mskip2mu\\mathpunct{}\\nonscript\n// \\mkern-\\thinmuskip{:}\\mskip6muplus1mu\\relax}\n\ndefineMacro(\"\\\\colon\", \"\\\\nobreak\\\\mskip2mu\\\\mathpunct{}\" + \"\\\\mathchoice{\\\\mkern-3mu}{\\\\mkern-3mu}{}{}{:}\\\\mskip6mu\\\\relax\"); // \\newcommand{\\boxed}[1]{\\fbox{\\m@th$\\displaystyle#1$}}\n\ndefineMacro(\"\\\\boxed\", \"\\\\fbox{$\\\\displaystyle{#1}$}\"); // \\def\\iff{\\DOTSB\\;\\Longleftrightarrow\\;}\n// \\def\\implies{\\DOTSB\\;\\Longrightarrow\\;}\n// \\def\\impliedby{\\DOTSB\\;\\Longleftarrow\\;}\n\ndefineMacro(\"\\\\iff\", \"\\\\DOTSB\\\\;\\\\Longleftrightarrow\\\\;\");\ndefineMacro(\"\\\\implies\", \"\\\\DOTSB\\\\;\\\\Longrightarrow\\\\;\");\ndefineMacro(\"\\\\impliedby\", \"\\\\DOTSB\\\\;\\\\Longleftarrow\\\\;\"); // \\def\\dddot#1{{\\mathop{#1}\\limits^{\\vbox to-1.4\\ex@{\\kern-\\tw@\\ex@\n//  \\hbox{\\normalfont ...}\\vss}}}}\n// We use \\overset which avoids the vertical shift of \\mathop.\n\ndefineMacro(\"\\\\dddot\", \"{\\\\overset{\\\\raisebox{-0.1ex}{\\\\normalsize ...}}{#1}}\");\ndefineMacro(\"\\\\ddddot\", \"{\\\\overset{\\\\raisebox{-0.1ex}{\\\\normalsize ....}}{#1}}\"); // AMSMath's automatic \\dots, based on \\mdots@@ macro.\n\nvar dotsByToken = {\n  ',': '\\\\dotsc',\n  '\\\\not': '\\\\dotsb',\n  // \\keybin@ checks for the following:\n  '+': '\\\\dotsb',\n  '=': '\\\\dotsb',\n  '<': '\\\\dotsb',\n  '>': '\\\\dotsb',\n  '-': '\\\\dotsb',\n  '*': '\\\\dotsb',\n  ':': '\\\\dotsb',\n  // Symbols whose definition starts with \\DOTSB:\n  '\\\\DOTSB': '\\\\dotsb',\n  '\\\\coprod': '\\\\dotsb',\n  '\\\\bigvee': '\\\\dotsb',\n  '\\\\bigwedge': '\\\\dotsb',\n  '\\\\biguplus': '\\\\dotsb',\n  '\\\\bigcap': '\\\\dotsb',\n  '\\\\bigcup': '\\\\dotsb',\n  '\\\\prod': '\\\\dotsb',\n  '\\\\sum': '\\\\dotsb',\n  '\\\\bigotimes': '\\\\dotsb',\n  '\\\\bigoplus': '\\\\dotsb',\n  '\\\\bigodot': '\\\\dotsb',\n  '\\\\bigsqcup': '\\\\dotsb',\n  '\\\\And': '\\\\dotsb',\n  '\\\\longrightarrow': '\\\\dotsb',\n  '\\\\Longrightarrow': '\\\\dotsb',\n  '\\\\longleftarrow': '\\\\dotsb',\n  '\\\\Longleftarrow': '\\\\dotsb',\n  '\\\\longleftrightarrow': '\\\\dotsb',\n  '\\\\Longleftrightarrow': '\\\\dotsb',\n  '\\\\mapsto': '\\\\dotsb',\n  '\\\\longmapsto': '\\\\dotsb',\n  '\\\\hookrightarrow': '\\\\dotsb',\n  '\\\\doteq': '\\\\dotsb',\n  // Symbols whose definition starts with \\mathbin:\n  '\\\\mathbin': '\\\\dotsb',\n  // Symbols whose definition starts with \\mathrel:\n  '\\\\mathrel': '\\\\dotsb',\n  '\\\\relbar': '\\\\dotsb',\n  '\\\\Relbar': '\\\\dotsb',\n  '\\\\xrightarrow': '\\\\dotsb',\n  '\\\\xleftarrow': '\\\\dotsb',\n  // Symbols whose definition starts with \\DOTSI:\n  '\\\\DOTSI': '\\\\dotsi',\n  '\\\\int': '\\\\dotsi',\n  '\\\\oint': '\\\\dotsi',\n  '\\\\iint': '\\\\dotsi',\n  '\\\\iiint': '\\\\dotsi',\n  '\\\\iiiint': '\\\\dotsi',\n  '\\\\idotsint': '\\\\dotsi',\n  // Symbols whose definition starts with \\DOTSX:\n  '\\\\DOTSX': '\\\\dotsx'\n};\ndefineMacro(\"\\\\dots\", function (context) {\n  // TODO: If used in text mode, should expand to \\textellipsis.\n  // However, in KaTeX, \\textellipsis and \\ldots behave the same\n  // (in text mode), and it's unlikely we'd see any of the math commands\n  // that affect the behavior of \\dots when in text mode.  So fine for now\n  // (until we support \\ifmmode ... \\else ... \\fi).\n  var thedots = '\\\\dotso';\n  var next = context.expandAfterFuture().text;\n\n  if (next in dotsByToken) {\n    thedots = dotsByToken[next];\n  } else if (next.slice(0, 4) === '\\\\not') {\n    thedots = '\\\\dotsb';\n  } else if (next in symbols.math) {\n    if (utils.contains(['bin', 'rel'], symbols.math[next].group)) {\n      thedots = '\\\\dotsb';\n    }\n  }\n\n  return thedots;\n});\nvar spaceAfterDots = {\n  // \\rightdelim@ checks for the following:\n  ')': true,\n  ']': true,\n  '\\\\rbrack': true,\n  '\\\\}': true,\n  '\\\\rbrace': true,\n  '\\\\rangle': true,\n  '\\\\rceil': true,\n  '\\\\rfloor': true,\n  '\\\\rgroup': true,\n  '\\\\rmoustache': true,\n  '\\\\right': true,\n  '\\\\bigr': true,\n  '\\\\biggr': true,\n  '\\\\Bigr': true,\n  '\\\\Biggr': true,\n  // \\extra@ also tests for the following:\n  '$': true,\n  // \\extrap@ checks for the following:\n  ';': true,\n  '.': true,\n  ',': true\n};\ndefineMacro(\"\\\\dotso\", function (context) {\n  var next = context.future().text;\n\n  if (next in spaceAfterDots) {\n    return \"\\\\ldots\\\\,\";\n  } else {\n    return \"\\\\ldots\";\n  }\n});\ndefineMacro(\"\\\\dotsc\", function (context) {\n  var next = context.future().text; // \\dotsc uses \\extra@ but not \\extrap@, instead specially checking for\n  // ';' and '.', but doesn't check for ','.\n\n  if (next in spaceAfterDots && next !== ',') {\n    return \"\\\\ldots\\\\,\";\n  } else {\n    return \"\\\\ldots\";\n  }\n});\ndefineMacro(\"\\\\cdots\", function (context) {\n  var next = context.future().text;\n\n  if (next in spaceAfterDots) {\n    return \"\\\\@cdots\\\\,\";\n  } else {\n    return \"\\\\@cdots\";\n  }\n});\ndefineMacro(\"\\\\dotsb\", \"\\\\cdots\");\ndefineMacro(\"\\\\dotsm\", \"\\\\cdots\");\ndefineMacro(\"\\\\dotsi\", \"\\\\!\\\\cdots\"); // amsmath doesn't actually define \\dotsx, but \\dots followed by a macro\n// starting with \\DOTSX implies \\dotso, and then \\extra@ detects this case\n// and forces the added `\\,`.\n\ndefineMacro(\"\\\\dotsx\", \"\\\\ldots\\\\,\"); // \\let\\DOTSI\\relax\n// \\let\\DOTSB\\relax\n// \\let\\DOTSX\\relax\n\ndefineMacro(\"\\\\DOTSI\", \"\\\\relax\");\ndefineMacro(\"\\\\DOTSB\", \"\\\\relax\");\ndefineMacro(\"\\\\DOTSX\", \"\\\\relax\"); // Spacing, based on amsmath.sty's override of LaTeX defaults\n// \\DeclareRobustCommand{\\tmspace}[3]{%\n//   \\ifmmode\\mskip#1#2\\else\\kern#1#3\\fi\\relax}\n\ndefineMacro(\"\\\\tmspace\", \"\\\\TextOrMath{\\\\kern#1#3}{\\\\mskip#1#2}\\\\relax\"); // \\renewcommand{\\,}{\\tmspace+\\thinmuskip{.1667em}}\n// TODO: math mode should use \\thinmuskip\n\ndefineMacro(\"\\\\,\", \"\\\\tmspace+{3mu}{.1667em}\"); // \\let\\thinspace\\,\n\ndefineMacro(\"\\\\thinspace\", \"\\\\,\"); // \\def\\>{\\mskip\\medmuskip}\n// \\renewcommand{\\:}{\\tmspace+\\medmuskip{.2222em}}\n// TODO: \\> and math mode of \\: should use \\medmuskip = 4mu plus 2mu minus 4mu\n\ndefineMacro(\"\\\\>\", \"\\\\mskip{4mu}\");\ndefineMacro(\"\\\\:\", \"\\\\tmspace+{4mu}{.2222em}\"); // \\let\\medspace\\:\n\ndefineMacro(\"\\\\medspace\", \"\\\\:\"); // \\renewcommand{\\;}{\\tmspace+\\thickmuskip{.2777em}}\n// TODO: math mode should use \\thickmuskip = 5mu plus 5mu\n\ndefineMacro(\"\\\\;\", \"\\\\tmspace+{5mu}{.2777em}\"); // \\let\\thickspace\\;\n\ndefineMacro(\"\\\\thickspace\", \"\\\\;\"); // \\renewcommand{\\!}{\\tmspace-\\thinmuskip{.1667em}}\n// TODO: math mode should use \\thinmuskip\n\ndefineMacro(\"\\\\!\", \"\\\\tmspace-{3mu}{.1667em}\"); // \\let\\negthinspace\\!\n\ndefineMacro(\"\\\\negthinspace\", \"\\\\!\"); // \\newcommand{\\negmedspace}{\\tmspace-\\medmuskip{.2222em}}\n// TODO: math mode should use \\medmuskip\n\ndefineMacro(\"\\\\negmedspace\", \"\\\\tmspace-{4mu}{.2222em}\"); // \\newcommand{\\negthickspace}{\\tmspace-\\thickmuskip{.2777em}}\n// TODO: math mode should use \\thickmuskip\n\ndefineMacro(\"\\\\negthickspace\", \"\\\\tmspace-{5mu}{.277em}\"); // \\def\\enspace{\\kern.5em }\n\ndefineMacro(\"\\\\enspace\", \"\\\\kern.5em \"); // \\def\\enskip{\\hskip.5em\\relax}\n\ndefineMacro(\"\\\\enskip\", \"\\\\hskip.5em\\\\relax\"); // \\def\\quad{\\hskip1em\\relax}\n\ndefineMacro(\"\\\\quad\", \"\\\\hskip1em\\\\relax\"); // \\def\\qquad{\\hskip2em\\relax}\n\ndefineMacro(\"\\\\qquad\", \"\\\\hskip2em\\\\relax\"); // \\tag@in@display form of \\tag\n\ndefineMacro(\"\\\\tag\", \"\\\\@ifstar\\\\tag@literal\\\\tag@paren\");\ndefineMacro(\"\\\\tag@paren\", \"\\\\tag@literal{({#1})}\");\ndefineMacro(\"\\\\tag@literal\", context => {\n  if (context.macros.get(\"\\\\df@tag\")) {\n    throw new ParseError(\"Multiple \\\\tag\");\n  }\n\n  return \"\\\\gdef\\\\df@tag{\\\\text{#1}}\";\n}); // \\renewcommand{\\bmod}{\\nonscript\\mskip-\\medmuskip\\mkern5mu\\mathbin\n//   {\\operator@font mod}\\penalty900\n//   \\mkern5mu\\nonscript\\mskip-\\medmuskip}\n// \\newcommand{\\pod}[1]{\\allowbreak\n//   \\if@display\\mkern18mu\\else\\mkern8mu\\fi(#1)}\n// \\renewcommand{\\pmod}[1]{\\pod{{\\operator@font mod}\\mkern6mu#1}}\n// \\newcommand{\\mod}[1]{\\allowbreak\\if@display\\mkern18mu\n//   \\else\\mkern12mu\\fi{\\operator@font mod}\\,\\,#1}\n// TODO: math mode should use \\medmuskip = 4mu plus 2mu minus 4mu\n\ndefineMacro(\"\\\\bmod\", \"\\\\mathchoice{\\\\mskip1mu}{\\\\mskip1mu}{\\\\mskip5mu}{\\\\mskip5mu}\" + \"\\\\mathbin{\\\\rm mod}\" + \"\\\\mathchoice{\\\\mskip1mu}{\\\\mskip1mu}{\\\\mskip5mu}{\\\\mskip5mu}\");\ndefineMacro(\"\\\\pod\", \"\\\\allowbreak\" + \"\\\\mathchoice{\\\\mkern18mu}{\\\\mkern8mu}{\\\\mkern8mu}{\\\\mkern8mu}(#1)\");\ndefineMacro(\"\\\\pmod\", \"\\\\pod{{\\\\rm mod}\\\\mkern6mu#1}\");\ndefineMacro(\"\\\\mod\", \"\\\\allowbreak\" + \"\\\\mathchoice{\\\\mkern18mu}{\\\\mkern12mu}{\\\\mkern12mu}{\\\\mkern12mu}\" + \"{\\\\rm mod}\\\\,\\\\,#1\"); //////////////////////////////////////////////////////////////////////\n// LaTeX source2e\n// \\expandafter\\let\\expandafter\\@normalcr\n//     \\csname\\expandafter\\@gobble\\string\\\\ \\endcsname\n// \\DeclareRobustCommand\\newline{\\@normalcr\\relax}\n\ndefineMacro(\"\\\\newline\", \"\\\\\\\\\\\\relax\"); // \\def\\TeX{T\\kern-.1667em\\lower.5ex\\hbox{E}\\kern-.125emX\\@}\n// TODO: Doesn't normally work in math mode because \\@ fails.  KaTeX doesn't\n// support \\@ yet, so that's omitted, and we add \\text so that the result\n// doesn't look funny in math mode.\n\ndefineMacro(\"\\\\TeX\", \"\\\\textrm{\\\\html@mathml{\" + \"T\\\\kern-.1667em\\\\raisebox{-.5ex}{E}\\\\kern-.125emX\" + \"}{TeX}}\"); // \\DeclareRobustCommand{\\LaTeX}{L\\kern-.36em%\n//         {\\sbox\\z@ T%\n//          \\vbox to\\ht\\z@{\\hbox{\\check@mathfonts\n//                               \\fontsize\\sf@size\\z@\n//                               \\math@fontsfalse\\selectfont\n//                               A}%\n//                         \\vss}%\n//         }%\n//         \\kern-.15em%\n//         \\TeX}\n// This code aligns the top of the A with the T (from the perspective of TeX's\n// boxes, though visually the A appears to extend above slightly).\n// We compute the corresponding \\raisebox when A is rendered in \\normalsize\n// \\scriptstyle, which has a scale factor of 0.7 (see Options.js).\n\nvar latexRaiseA = makeEm(fontMetricsData['Main-Regular'][\"T\".charCodeAt(0)][1] - 0.7 * fontMetricsData['Main-Regular'][\"A\".charCodeAt(0)][1]);\ndefineMacro(\"\\\\LaTeX\", \"\\\\textrm{\\\\html@mathml{\" + (\"L\\\\kern-.36em\\\\raisebox{\" + latexRaiseA + \"}{\\\\scriptstyle A}\") + \"\\\\kern-.15em\\\\TeX}{LaTeX}}\"); // New KaTeX logo based on tweaking LaTeX logo\n\ndefineMacro(\"\\\\KaTeX\", \"\\\\textrm{\\\\html@mathml{\" + (\"K\\\\kern-.17em\\\\raisebox{\" + latexRaiseA + \"}{\\\\scriptstyle A}\") + \"\\\\kern-.15em\\\\TeX}{KaTeX}}\"); // \\DeclareRobustCommand\\hspace{\\@ifstar\\@hspacer\\@hspace}\n// \\def\\@hspace#1{\\hskip  #1\\relax}\n// \\def\\@hspacer#1{\\vrule \\@width\\z@\\nobreak\n//                 \\hskip #1\\hskip \\z@skip}\n\ndefineMacro(\"\\\\hspace\", \"\\\\@ifstar\\\\@hspacer\\\\@hspace\");\ndefineMacro(\"\\\\@hspace\", \"\\\\hskip #1\\\\relax\");\ndefineMacro(\"\\\\@hspacer\", \"\\\\rule{0pt}{0pt}\\\\hskip #1\\\\relax\"); //////////////////////////////////////////////////////////////////////\n// mathtools.sty\n//\\providecommand\\ordinarycolon{:}\n\ndefineMacro(\"\\\\ordinarycolon\", \":\"); //\\def\\vcentcolon{\\mathrel{\\mathop\\ordinarycolon}}\n//TODO(edemaine): Not yet centered. Fix via \\raisebox or #726\n\ndefineMacro(\"\\\\vcentcolon\", \"\\\\mathrel{\\\\mathop\\\\ordinarycolon}\"); // \\providecommand*\\dblcolon{\\vcentcolon\\mathrel{\\mkern-.9mu}\\vcentcolon}\n\ndefineMacro(\"\\\\dblcolon\", \"\\\\html@mathml{\" + \"\\\\mathrel{\\\\vcentcolon\\\\mathrel{\\\\mkern-.9mu}\\\\vcentcolon}}\" + \"{\\\\mathop{\\\\char\\\"2237}}\"); // \\providecommand*\\coloneqq{\\vcentcolon\\mathrel{\\mkern-1.2mu}=}\n\ndefineMacro(\"\\\\coloneqq\", \"\\\\html@mathml{\" + \"\\\\mathrel{\\\\vcentcolon\\\\mathrel{\\\\mkern-1.2mu}=}}\" + \"{\\\\mathop{\\\\char\\\"2254}}\"); // ≔\n// \\providecommand*\\Coloneqq{\\dblcolon\\mathrel{\\mkern-1.2mu}=}\n\ndefineMacro(\"\\\\Coloneqq\", \"\\\\html@mathml{\" + \"\\\\mathrel{\\\\dblcolon\\\\mathrel{\\\\mkern-1.2mu}=}}\" + \"{\\\\mathop{\\\\char\\\"2237\\\\char\\\"3d}}\"); // \\providecommand*\\coloneq{\\vcentcolon\\mathrel{\\mkern-1.2mu}\\mathrel{-}}\n\ndefineMacro(\"\\\\coloneq\", \"\\\\html@mathml{\" + \"\\\\mathrel{\\\\vcentcolon\\\\mathrel{\\\\mkern-1.2mu}\\\\mathrel{-}}}\" + \"{\\\\mathop{\\\\char\\\"3a\\\\char\\\"2212}}\"); // \\providecommand*\\Coloneq{\\dblcolon\\mathrel{\\mkern-1.2mu}\\mathrel{-}}\n\ndefineMacro(\"\\\\Coloneq\", \"\\\\html@mathml{\" + \"\\\\mathrel{\\\\dblcolon\\\\mathrel{\\\\mkern-1.2mu}\\\\mathrel{-}}}\" + \"{\\\\mathop{\\\\char\\\"2237\\\\char\\\"2212}}\"); // \\providecommand*\\eqqcolon{=\\mathrel{\\mkern-1.2mu}\\vcentcolon}\n\ndefineMacro(\"\\\\eqqcolon\", \"\\\\html@mathml{\" + \"\\\\mathrel{=\\\\mathrel{\\\\mkern-1.2mu}\\\\vcentcolon}}\" + \"{\\\\mathop{\\\\char\\\"2255}}\"); // ≕\n// \\providecommand*\\Eqqcolon{=\\mathrel{\\mkern-1.2mu}\\dblcolon}\n\ndefineMacro(\"\\\\Eqqcolon\", \"\\\\html@mathml{\" + \"\\\\mathrel{=\\\\mathrel{\\\\mkern-1.2mu}\\\\dblcolon}}\" + \"{\\\\mathop{\\\\char\\\"3d\\\\char\\\"2237}}\"); // \\providecommand*\\eqcolon{\\mathrel{-}\\mathrel{\\mkern-1.2mu}\\vcentcolon}\n\ndefineMacro(\"\\\\eqcolon\", \"\\\\html@mathml{\" + \"\\\\mathrel{\\\\mathrel{-}\\\\mathrel{\\\\mkern-1.2mu}\\\\vcentcolon}}\" + \"{\\\\mathop{\\\\char\\\"2239}}\"); // \\providecommand*\\Eqcolon{\\mathrel{-}\\mathrel{\\mkern-1.2mu}\\dblcolon}\n\ndefineMacro(\"\\\\Eqcolon\", \"\\\\html@mathml{\" + \"\\\\mathrel{\\\\mathrel{-}\\\\mathrel{\\\\mkern-1.2mu}\\\\dblcolon}}\" + \"{\\\\mathop{\\\\char\\\"2212\\\\char\\\"2237}}\"); // \\providecommand*\\colonapprox{\\vcentcolon\\mathrel{\\mkern-1.2mu}\\approx}\n\ndefineMacro(\"\\\\colonapprox\", \"\\\\html@mathml{\" + \"\\\\mathrel{\\\\vcentcolon\\\\mathrel{\\\\mkern-1.2mu}\\\\approx}}\" + \"{\\\\mathop{\\\\char\\\"3a\\\\char\\\"2248}}\"); // \\providecommand*\\Colonapprox{\\dblcolon\\mathrel{\\mkern-1.2mu}\\approx}\n\ndefineMacro(\"\\\\Colonapprox\", \"\\\\html@mathml{\" + \"\\\\mathrel{\\\\dblcolon\\\\mathrel{\\\\mkern-1.2mu}\\\\approx}}\" + \"{\\\\mathop{\\\\char\\\"2237\\\\char\\\"2248}}\"); // \\providecommand*\\colonsim{\\vcentcolon\\mathrel{\\mkern-1.2mu}\\sim}\n\ndefineMacro(\"\\\\colonsim\", \"\\\\html@mathml{\" + \"\\\\mathrel{\\\\vcentcolon\\\\mathrel{\\\\mkern-1.2mu}\\\\sim}}\" + \"{\\\\mathop{\\\\char\\\"3a\\\\char\\\"223c}}\"); // \\providecommand*\\Colonsim{\\dblcolon\\mathrel{\\mkern-1.2mu}\\sim}\n\ndefineMacro(\"\\\\Colonsim\", \"\\\\html@mathml{\" + \"\\\\mathrel{\\\\dblcolon\\\\mathrel{\\\\mkern-1.2mu}\\\\sim}}\" + \"{\\\\mathop{\\\\char\\\"2237\\\\char\\\"223c}}\"); // Some Unicode characters are implemented with macros to mathtools functions.\n\ndefineMacro(\"\\u2237\", \"\\\\dblcolon\"); // ::\n\ndefineMacro(\"\\u2239\", \"\\\\eqcolon\"); // -:\n\ndefineMacro(\"\\u2254\", \"\\\\coloneqq\"); // :=\n\ndefineMacro(\"\\u2255\", \"\\\\eqqcolon\"); // =:\n\ndefineMacro(\"\\u2A74\", \"\\\\Coloneqq\"); // ::=\n//////////////////////////////////////////////////////////////////////\n// colonequals.sty\n// Alternate names for mathtools's macros:\n\ndefineMacro(\"\\\\ratio\", \"\\\\vcentcolon\");\ndefineMacro(\"\\\\coloncolon\", \"\\\\dblcolon\");\ndefineMacro(\"\\\\colonequals\", \"\\\\coloneqq\");\ndefineMacro(\"\\\\coloncolonequals\", \"\\\\Coloneqq\");\ndefineMacro(\"\\\\equalscolon\", \"\\\\eqqcolon\");\ndefineMacro(\"\\\\equalscoloncolon\", \"\\\\Eqqcolon\");\ndefineMacro(\"\\\\colonminus\", \"\\\\coloneq\");\ndefineMacro(\"\\\\coloncolonminus\", \"\\\\Coloneq\");\ndefineMacro(\"\\\\minuscolon\", \"\\\\eqcolon\");\ndefineMacro(\"\\\\minuscoloncolon\", \"\\\\Eqcolon\"); // \\colonapprox name is same in mathtools and colonequals.\n\ndefineMacro(\"\\\\coloncolonapprox\", \"\\\\Colonapprox\"); // \\colonsim name is same in mathtools and colonequals.\n\ndefineMacro(\"\\\\coloncolonsim\", \"\\\\Colonsim\"); // Additional macros, implemented by analogy with mathtools definitions:\n\ndefineMacro(\"\\\\simcolon\", \"\\\\mathrel{\\\\sim\\\\mathrel{\\\\mkern-1.2mu}\\\\vcentcolon}\");\ndefineMacro(\"\\\\simcoloncolon\", \"\\\\mathrel{\\\\sim\\\\mathrel{\\\\mkern-1.2mu}\\\\dblcolon}\");\ndefineMacro(\"\\\\approxcolon\", \"\\\\mathrel{\\\\approx\\\\mathrel{\\\\mkern-1.2mu}\\\\vcentcolon}\");\ndefineMacro(\"\\\\approxcoloncolon\", \"\\\\mathrel{\\\\approx\\\\mathrel{\\\\mkern-1.2mu}\\\\dblcolon}\"); // Present in newtxmath, pxfonts and txfonts\n\ndefineMacro(\"\\\\notni\", \"\\\\html@mathml{\\\\not\\\\ni}{\\\\mathrel{\\\\char`\\u220C}}\");\ndefineMacro(\"\\\\limsup\", \"\\\\DOTSB\\\\operatorname*{lim\\\\,sup}\");\ndefineMacro(\"\\\\liminf\", \"\\\\DOTSB\\\\operatorname*{lim\\\\,inf}\"); //////////////////////////////////////////////////////////////////////\n// From amsopn.sty\n\ndefineMacro(\"\\\\injlim\", \"\\\\DOTSB\\\\operatorname*{inj\\\\,lim}\");\ndefineMacro(\"\\\\projlim\", \"\\\\DOTSB\\\\operatorname*{proj\\\\,lim}\");\ndefineMacro(\"\\\\varlimsup\", \"\\\\DOTSB\\\\operatorname*{\\\\overline{lim}}\");\ndefineMacro(\"\\\\varliminf\", \"\\\\DOTSB\\\\operatorname*{\\\\underline{lim}}\");\ndefineMacro(\"\\\\varinjlim\", \"\\\\DOTSB\\\\operatorname*{\\\\underrightarrow{lim}}\");\ndefineMacro(\"\\\\varprojlim\", \"\\\\DOTSB\\\\operatorname*{\\\\underleftarrow{lim}}\"); //////////////////////////////////////////////////////////////////////\n// MathML alternates for KaTeX glyphs in the Unicode private area\n\ndefineMacro(\"\\\\gvertneqq\", \"\\\\html@mathml{\\\\@gvertneqq}{\\u2269}\");\ndefineMacro(\"\\\\lvertneqq\", \"\\\\html@mathml{\\\\@lvertneqq}{\\u2268}\");\ndefineMacro(\"\\\\ngeqq\", \"\\\\html@mathml{\\\\@ngeqq}{\\u2271}\");\ndefineMacro(\"\\\\ngeqslant\", \"\\\\html@mathml{\\\\@ngeqslant}{\\u2271}\");\ndefineMacro(\"\\\\nleqq\", \"\\\\html@mathml{\\\\@nleqq}{\\u2270}\");\ndefineMacro(\"\\\\nleqslant\", \"\\\\html@mathml{\\\\@nleqslant}{\\u2270}\");\ndefineMacro(\"\\\\nshortmid\", \"\\\\html@mathml{\\\\@nshortmid}{∤}\");\ndefineMacro(\"\\\\nshortparallel\", \"\\\\html@mathml{\\\\@nshortparallel}{∦}\");\ndefineMacro(\"\\\\nsubseteqq\", \"\\\\html@mathml{\\\\@nsubseteqq}{\\u2288}\");\ndefineMacro(\"\\\\nsupseteqq\", \"\\\\html@mathml{\\\\@nsupseteqq}{\\u2289}\");\ndefineMacro(\"\\\\varsubsetneq\", \"\\\\html@mathml{\\\\@varsubsetneq}{⊊}\");\ndefineMacro(\"\\\\varsubsetneqq\", \"\\\\html@mathml{\\\\@varsubsetneqq}{⫋}\");\ndefineMacro(\"\\\\varsupsetneq\", \"\\\\html@mathml{\\\\@varsupsetneq}{⊋}\");\ndefineMacro(\"\\\\varsupsetneqq\", \"\\\\html@mathml{\\\\@varsupsetneqq}{⫌}\");\ndefineMacro(\"\\\\imath\", \"\\\\html@mathml{\\\\@imath}{\\u0131}\");\ndefineMacro(\"\\\\jmath\", \"\\\\html@mathml{\\\\@jmath}{\\u0237}\"); //////////////////////////////////////////////////////////////////////\n// stmaryrd and semantic\n// The stmaryrd and semantic packages render the next four items by calling a\n// glyph. Those glyphs do not exist in the KaTeX fonts. Hence the macros.\n\ndefineMacro(\"\\\\llbracket\", \"\\\\html@mathml{\" + \"\\\\mathopen{[\\\\mkern-3.2mu[}}\" + \"{\\\\mathopen{\\\\char`\\u27e6}}\");\ndefineMacro(\"\\\\rrbracket\", \"\\\\html@mathml{\" + \"\\\\mathclose{]\\\\mkern-3.2mu]}}\" + \"{\\\\mathclose{\\\\char`\\u27e7}}\");\ndefineMacro(\"\\u27e6\", \"\\\\llbracket\"); // blackboard bold [\n\ndefineMacro(\"\\u27e7\", \"\\\\rrbracket\"); // blackboard bold ]\n\ndefineMacro(\"\\\\lBrace\", \"\\\\html@mathml{\" + \"\\\\mathopen{\\\\{\\\\mkern-3.2mu[}}\" + \"{\\\\mathopen{\\\\char`\\u2983}}\");\ndefineMacro(\"\\\\rBrace\", \"\\\\html@mathml{\" + \"\\\\mathclose{]\\\\mkern-3.2mu\\\\}}}\" + \"{\\\\mathclose{\\\\char`\\u2984}}\");\ndefineMacro(\"\\u2983\", \"\\\\lBrace\"); // blackboard bold {\n\ndefineMacro(\"\\u2984\", \"\\\\rBrace\"); // blackboard bold }\n// TODO: Create variable sized versions of the last two items. I believe that\n// will require new font glyphs.\n// The stmaryrd function `\\minuso` provides a \"Plimsoll\" symbol that\n// superimposes the characters \\circ and \\mathminus. Used in chemistry.\n\ndefineMacro(\"\\\\minuso\", \"\\\\mathbin{\\\\html@mathml{\" + \"{\\\\mathrlap{\\\\mathchoice{\\\\kern{0.145em}}{\\\\kern{0.145em}}\" + \"{\\\\kern{0.1015em}}{\\\\kern{0.0725em}}\\\\circ}{-}}}\" + \"{\\\\char`⦵}}\");\ndefineMacro(\"⦵\", \"\\\\minuso\"); //////////////////////////////////////////////////////////////////////\n// texvc.sty\n// The texvc package contains macros available in mediawiki pages.\n// We omit the functions deprecated at\n// https://en.wikipedia.org/wiki/Help:Displaying_a_formula#Deprecated_syntax\n// We also omit texvc's \\O, which conflicts with \\text{\\O}\n\ndefineMacro(\"\\\\darr\", \"\\\\downarrow\");\ndefineMacro(\"\\\\dArr\", \"\\\\Downarrow\");\ndefineMacro(\"\\\\Darr\", \"\\\\Downarrow\");\ndefineMacro(\"\\\\lang\", \"\\\\langle\");\ndefineMacro(\"\\\\rang\", \"\\\\rangle\");\ndefineMacro(\"\\\\uarr\", \"\\\\uparrow\");\ndefineMacro(\"\\\\uArr\", \"\\\\Uparrow\");\ndefineMacro(\"\\\\Uarr\", \"\\\\Uparrow\");\ndefineMacro(\"\\\\N\", \"\\\\mathbb{N}\");\ndefineMacro(\"\\\\R\", \"\\\\mathbb{R}\");\ndefineMacro(\"\\\\Z\", \"\\\\mathbb{Z}\");\ndefineMacro(\"\\\\alef\", \"\\\\aleph\");\ndefineMacro(\"\\\\alefsym\", \"\\\\aleph\");\ndefineMacro(\"\\\\Alpha\", \"\\\\mathrm{A}\");\ndefineMacro(\"\\\\Beta\", \"\\\\mathrm{B}\");\ndefineMacro(\"\\\\bull\", \"\\\\bullet\");\ndefineMacro(\"\\\\Chi\", \"\\\\mathrm{X}\");\ndefineMacro(\"\\\\clubs\", \"\\\\clubsuit\");\ndefineMacro(\"\\\\cnums\", \"\\\\mathbb{C}\");\ndefineMacro(\"\\\\Complex\", \"\\\\mathbb{C}\");\ndefineMacro(\"\\\\Dagger\", \"\\\\ddagger\");\ndefineMacro(\"\\\\diamonds\", \"\\\\diamondsuit\");\ndefineMacro(\"\\\\empty\", \"\\\\emptyset\");\ndefineMacro(\"\\\\Epsilon\", \"\\\\mathrm{E}\");\ndefineMacro(\"\\\\Eta\", \"\\\\mathrm{H}\");\ndefineMacro(\"\\\\exist\", \"\\\\exists\");\ndefineMacro(\"\\\\harr\", \"\\\\leftrightarrow\");\ndefineMacro(\"\\\\hArr\", \"\\\\Leftrightarrow\");\ndefineMacro(\"\\\\Harr\", \"\\\\Leftrightarrow\");\ndefineMacro(\"\\\\hearts\", \"\\\\heartsuit\");\ndefineMacro(\"\\\\image\", \"\\\\Im\");\ndefineMacro(\"\\\\infin\", \"\\\\infty\");\ndefineMacro(\"\\\\Iota\", \"\\\\mathrm{I}\");\ndefineMacro(\"\\\\isin\", \"\\\\in\");\ndefineMacro(\"\\\\Kappa\", \"\\\\mathrm{K}\");\ndefineMacro(\"\\\\larr\", \"\\\\leftarrow\");\ndefineMacro(\"\\\\lArr\", \"\\\\Leftarrow\");\ndefineMacro(\"\\\\Larr\", \"\\\\Leftarrow\");\ndefineMacro(\"\\\\lrarr\", \"\\\\leftrightarrow\");\ndefineMacro(\"\\\\lrArr\", \"\\\\Leftrightarrow\");\ndefineMacro(\"\\\\Lrarr\", \"\\\\Leftrightarrow\");\ndefineMacro(\"\\\\Mu\", \"\\\\mathrm{M}\");\ndefineMacro(\"\\\\natnums\", \"\\\\mathbb{N}\");\ndefineMacro(\"\\\\Nu\", \"\\\\mathrm{N}\");\ndefineMacro(\"\\\\Omicron\", \"\\\\mathrm{O}\");\ndefineMacro(\"\\\\plusmn\", \"\\\\pm\");\ndefineMacro(\"\\\\rarr\", \"\\\\rightarrow\");\ndefineMacro(\"\\\\rArr\", \"\\\\Rightarrow\");\ndefineMacro(\"\\\\Rarr\", \"\\\\Rightarrow\");\ndefineMacro(\"\\\\real\", \"\\\\Re\");\ndefineMacro(\"\\\\reals\", \"\\\\mathbb{R}\");\ndefineMacro(\"\\\\Reals\", \"\\\\mathbb{R}\");\ndefineMacro(\"\\\\Rho\", \"\\\\mathrm{P}\");\ndefineMacro(\"\\\\sdot\", \"\\\\cdot\");\ndefineMacro(\"\\\\sect\", \"\\\\S\");\ndefineMacro(\"\\\\spades\", \"\\\\spadesuit\");\ndefineMacro(\"\\\\sub\", \"\\\\subset\");\ndefineMacro(\"\\\\sube\", \"\\\\subseteq\");\ndefineMacro(\"\\\\supe\", \"\\\\supseteq\");\ndefineMacro(\"\\\\Tau\", \"\\\\mathrm{T}\");\ndefineMacro(\"\\\\thetasym\", \"\\\\vartheta\"); // TODO: defineMacro(\"\\\\varcoppa\", \"\\\\\\mbox{\\\\coppa}\");\n\ndefineMacro(\"\\\\weierp\", \"\\\\wp\");\ndefineMacro(\"\\\\Zeta\", \"\\\\mathrm{Z}\"); //////////////////////////////////////////////////////////////////////\n// statmath.sty\n// https://ctan.math.illinois.edu/macros/latex/contrib/statmath/statmath.pdf\n\ndefineMacro(\"\\\\argmin\", \"\\\\DOTSB\\\\operatorname*{arg\\\\,min}\");\ndefineMacro(\"\\\\argmax\", \"\\\\DOTSB\\\\operatorname*{arg\\\\,max}\");\ndefineMacro(\"\\\\plim\", \"\\\\DOTSB\\\\mathop{\\\\operatorname{plim}}\\\\limits\"); //////////////////////////////////////////////////////////////////////\n// braket.sty\n// http://ctan.math.washington.edu/tex-archive/macros/latex/contrib/braket/braket.pdf\n\ndefineMacro(\"\\\\bra\", \"\\\\mathinner{\\\\langle{#1}|}\");\ndefineMacro(\"\\\\ket\", \"\\\\mathinner{|{#1}\\\\rangle}\");\ndefineMacro(\"\\\\braket\", \"\\\\mathinner{\\\\langle{#1}\\\\rangle}\");\ndefineMacro(\"\\\\Bra\", \"\\\\left\\\\langle#1\\\\right|\");\ndefineMacro(\"\\\\Ket\", \"\\\\left|#1\\\\right\\\\rangle\");\n\nvar braketHelper = one => context => {\n  var left = context.consumeArg().tokens;\n  var middle = context.consumeArg().tokens;\n  var middleDouble = context.consumeArg().tokens;\n  var right = context.consumeArg().tokens;\n  var oldMiddle = context.macros.get(\"|\");\n  var oldMiddleDouble = context.macros.get(\"\\\\|\");\n  context.macros.beginGroup();\n\n  var midMacro = double => context => {\n    if (one) {\n      // Only modify the first instance of | or \\|\n      context.macros.set(\"|\", oldMiddle);\n\n      if (middleDouble.length) {\n        context.macros.set(\"\\\\|\", oldMiddleDouble);\n      }\n    }\n\n    var doubled = double;\n\n    if (!double && middleDouble.length) {\n      // Mimic \\@ifnextchar\n      var nextToken = context.future();\n\n      if (nextToken.text === \"|\") {\n        context.popToken();\n        doubled = true;\n      }\n    }\n\n    return {\n      tokens: doubled ? middleDouble : middle,\n      numArgs: 0\n    };\n  };\n\n  context.macros.set(\"|\", midMacro(false));\n\n  if (middleDouble.length) {\n    context.macros.set(\"\\\\|\", midMacro(true));\n  }\n\n  var arg = context.consumeArg().tokens;\n  var expanded = context.expandTokens([...right, ...arg, ...left // reversed\n  ]);\n  context.macros.endGroup();\n  return {\n    tokens: expanded.reverse(),\n    numArgs: 0\n  };\n};\n\ndefineMacro(\"\\\\bra@ket\", braketHelper(false));\ndefineMacro(\"\\\\bra@set\", braketHelper(true));\ndefineMacro(\"\\\\Braket\", \"\\\\bra@ket{\\\\left\\\\langle}\" + \"{\\\\,\\\\middle\\\\vert\\\\,}{\\\\,\\\\middle\\\\vert\\\\,}{\\\\right\\\\rangle}\");\ndefineMacro(\"\\\\Set\", \"\\\\bra@set{\\\\left\\\\{\\\\:}\" + \"{\\\\;\\\\middle\\\\vert\\\\;}{\\\\;\\\\middle\\\\Vert\\\\;}{\\\\:\\\\right\\\\}}\");\ndefineMacro(\"\\\\set\", \"\\\\bra@set{\\\\{\\\\,}{\\\\mid}{}{\\\\,\\\\}}\"); // has no support for special || or \\|\n//////////////////////////////////////////////////////////////////////\n// actuarialangle.dtx\n\ndefineMacro(\"\\\\angln\", \"{\\\\angl n}\"); // Custom Khan Academy colors, should be moved to an optional package\n\ndefineMacro(\"\\\\blue\", \"\\\\textcolor{##6495ed}{#1}\");\ndefineMacro(\"\\\\orange\", \"\\\\textcolor{##ffa500}{#1}\");\ndefineMacro(\"\\\\pink\", \"\\\\textcolor{##ff00af}{#1}\");\ndefineMacro(\"\\\\red\", \"\\\\textcolor{##df0030}{#1}\");\ndefineMacro(\"\\\\green\", \"\\\\textcolor{##28ae7b}{#1}\");\ndefineMacro(\"\\\\gray\", \"\\\\textcolor{gray}{#1}\");\ndefineMacro(\"\\\\purple\", \"\\\\textcolor{##9d38bd}{#1}\");\ndefineMacro(\"\\\\blueA\", \"\\\\textcolor{##ccfaff}{#1}\");\ndefineMacro(\"\\\\blueB\", \"\\\\textcolor{##80f6ff}{#1}\");\ndefineMacro(\"\\\\blueC\", \"\\\\textcolor{##63d9ea}{#1}\");\ndefineMacro(\"\\\\blueD\", \"\\\\textcolor{##11accd}{#1}\");\ndefineMacro(\"\\\\blueE\", \"\\\\textcolor{##0c7f99}{#1}\");\ndefineMacro(\"\\\\tealA\", \"\\\\textcolor{##94fff5}{#1}\");\ndefineMacro(\"\\\\tealB\", \"\\\\textcolor{##26edd5}{#1}\");\ndefineMacro(\"\\\\tealC\", \"\\\\textcolor{##01d1c1}{#1}\");\ndefineMacro(\"\\\\tealD\", \"\\\\textcolor{##01a995}{#1}\");\ndefineMacro(\"\\\\tealE\", \"\\\\textcolor{##208170}{#1}\");\ndefineMacro(\"\\\\greenA\", \"\\\\textcolor{##b6ffb0}{#1}\");\ndefineMacro(\"\\\\greenB\", \"\\\\textcolor{##8af281}{#1}\");\ndefineMacro(\"\\\\greenC\", \"\\\\textcolor{##74cf70}{#1}\");\ndefineMacro(\"\\\\greenD\", \"\\\\textcolor{##1fab54}{#1}\");\ndefineMacro(\"\\\\greenE\", \"\\\\textcolor{##0d923f}{#1}\");\ndefineMacro(\"\\\\goldA\", \"\\\\textcolor{##ffd0a9}{#1}\");\ndefineMacro(\"\\\\goldB\", \"\\\\textcolor{##ffbb71}{#1}\");\ndefineMacro(\"\\\\goldC\", \"\\\\textcolor{##ff9c39}{#1}\");\ndefineMacro(\"\\\\goldD\", \"\\\\textcolor{##e07d10}{#1}\");\ndefineMacro(\"\\\\goldE\", \"\\\\textcolor{##a75a05}{#1}\");\ndefineMacro(\"\\\\redA\", \"\\\\textcolor{##fca9a9}{#1}\");\ndefineMacro(\"\\\\redB\", \"\\\\textcolor{##ff8482}{#1}\");\ndefineMacro(\"\\\\redC\", \"\\\\textcolor{##f9685d}{#1}\");\ndefineMacro(\"\\\\redD\", \"\\\\textcolor{##e84d39}{#1}\");\ndefineMacro(\"\\\\redE\", \"\\\\textcolor{##bc2612}{#1}\");\ndefineMacro(\"\\\\maroonA\", \"\\\\textcolor{##ffbde0}{#1}\");\ndefineMacro(\"\\\\maroonB\", \"\\\\textcolor{##ff92c6}{#1}\");\ndefineMacro(\"\\\\maroonC\", \"\\\\textcolor{##ed5fa6}{#1}\");\ndefineMacro(\"\\\\maroonD\", \"\\\\textcolor{##ca337c}{#1}\");\ndefineMacro(\"\\\\maroonE\", \"\\\\textcolor{##9e034e}{#1}\");\ndefineMacro(\"\\\\purpleA\", \"\\\\textcolor{##ddd7ff}{#1}\");\ndefineMacro(\"\\\\purpleB\", \"\\\\textcolor{##c6b9fc}{#1}\");\ndefineMacro(\"\\\\purpleC\", \"\\\\textcolor{##aa87ff}{#1}\");\ndefineMacro(\"\\\\purpleD\", \"\\\\textcolor{##7854ab}{#1}\");\ndefineMacro(\"\\\\purpleE\", \"\\\\textcolor{##543b78}{#1}\");\ndefineMacro(\"\\\\mintA\", \"\\\\textcolor{##f5f9e8}{#1}\");\ndefineMacro(\"\\\\mintB\", \"\\\\textcolor{##edf2df}{#1}\");\ndefineMacro(\"\\\\mintC\", \"\\\\textcolor{##e0e5cc}{#1}\");\ndefineMacro(\"\\\\grayA\", \"\\\\textcolor{##f6f7f7}{#1}\");\ndefineMacro(\"\\\\grayB\", \"\\\\textcolor{##f0f1f2}{#1}\");\ndefineMacro(\"\\\\grayC\", \"\\\\textcolor{##e3e5e6}{#1}\");\ndefineMacro(\"\\\\grayD\", \"\\\\textcolor{##d6d8da}{#1}\");\ndefineMacro(\"\\\\grayE\", \"\\\\textcolor{##babec2}{#1}\");\ndefineMacro(\"\\\\grayF\", \"\\\\textcolor{##888d93}{#1}\");\ndefineMacro(\"\\\\grayG\", \"\\\\textcolor{##626569}{#1}\");\ndefineMacro(\"\\\\grayH\", \"\\\\textcolor{##3b3e40}{#1}\");\ndefineMacro(\"\\\\grayI\", \"\\\\textcolor{##21242c}{#1}\");\ndefineMacro(\"\\\\kaBlue\", \"\\\\textcolor{##314453}{#1}\");\ndefineMacro(\"\\\\kaGreen\", \"\\\\textcolor{##71B307}{#1}\");\n\n/**\n * This file contains the “gullet” where macros are expanded\n * until only non-macro tokens remain.\n */\n// List of commands that act like macros but aren't defined as a macro,\n// function, or symbol.  Used in `isDefined`.\nvar implicitCommands = {\n  \"^\": true,\n  // Parser.js\n  \"_\": true,\n  // Parser.js\n  \"\\\\limits\": true,\n  // Parser.js\n  \"\\\\nolimits\": true // Parser.js\n\n};\nclass MacroExpander {\n  constructor(input, settings, mode) {\n    this.settings = void 0;\n    this.expansionCount = void 0;\n    this.lexer = void 0;\n    this.macros = void 0;\n    this.stack = void 0;\n    this.mode = void 0;\n    this.settings = settings;\n    this.expansionCount = 0;\n    this.feed(input); // Make new global namespace\n\n    this.macros = new Namespace(macros, settings.macros);\n    this.mode = mode;\n    this.stack = []; // contains tokens in REVERSE order\n  }\n  /**\n   * Feed a new input string to the same MacroExpander\n   * (with existing macros etc.).\n   */\n\n\n  feed(input) {\n    this.lexer = new Lexer(input, this.settings);\n  }\n  /**\n   * Switches between \"text\" and \"math\" modes.\n   */\n\n\n  switchMode(newMode) {\n    this.mode = newMode;\n  }\n  /**\n   * Start a new group nesting within all namespaces.\n   */\n\n\n  beginGroup() {\n    this.macros.beginGroup();\n  }\n  /**\n   * End current group nesting within all namespaces.\n   */\n\n\n  endGroup() {\n    this.macros.endGroup();\n  }\n  /**\n   * Ends all currently nested groups (if any), restoring values before the\n   * groups began.  Useful in case of an error in the middle of parsing.\n   */\n\n\n  endGroups() {\n    this.macros.endGroups();\n  }\n  /**\n   * Returns the topmost token on the stack, without expanding it.\n   * Similar in behavior to TeX's `\\futurelet`.\n   */\n\n\n  future() {\n    if (this.stack.length === 0) {\n      this.pushToken(this.lexer.lex());\n    }\n\n    return this.stack[this.stack.length - 1];\n  }\n  /**\n   * Remove and return the next unexpanded token.\n   */\n\n\n  popToken() {\n    this.future(); // ensure non-empty stack\n\n    return this.stack.pop();\n  }\n  /**\n   * Add a given token to the token stack.  In particular, this get be used\n   * to put back a token returned from one of the other methods.\n   */\n\n\n  pushToken(token) {\n    this.stack.push(token);\n  }\n  /**\n   * Append an array of tokens to the token stack.\n   */\n\n\n  pushTokens(tokens) {\n    this.stack.push(...tokens);\n  }\n  /**\n   * Find an macro argument without expanding tokens and append the array of\n   * tokens to the token stack. Uses Token as a container for the result.\n   */\n\n\n  scanArgument(isOptional) {\n    var start;\n    var end;\n    var tokens;\n\n    if (isOptional) {\n      this.consumeSpaces(); // \\@ifnextchar gobbles any space following it\n\n      if (this.future().text !== \"[\") {\n        return null;\n      }\n\n      start = this.popToken(); // don't include [ in tokens\n\n      ({\n        tokens,\n        end\n      } = this.consumeArg([\"]\"]));\n    } else {\n      ({\n        tokens,\n        start,\n        end\n      } = this.consumeArg());\n    } // indicate the end of an argument\n\n\n    this.pushToken(new Token(\"EOF\", end.loc));\n    this.pushTokens(tokens);\n    return start.range(end, \"\");\n  }\n  /**\n   * Consume all following space tokens, without expansion.\n   */\n\n\n  consumeSpaces() {\n    for (;;) {\n      var token = this.future();\n\n      if (token.text === \" \") {\n        this.stack.pop();\n      } else {\n        break;\n      }\n    }\n  }\n  /**\n   * Consume an argument from the token stream, and return the resulting array\n   * of tokens and start/end token.\n   */\n\n\n  consumeArg(delims) {\n    // The argument for a delimited parameter is the shortest (possibly\n    // empty) sequence of tokens with properly nested {...} groups that is\n    // followed ... by this particular list of non-parameter tokens.\n    // The argument for an undelimited parameter is the next nonblank\n    // token, unless that token is ‘{’, when the argument will be the\n    // entire {...} group that follows.\n    var tokens = [];\n    var isDelimited = delims && delims.length > 0;\n\n    if (!isDelimited) {\n      // Ignore spaces between arguments.  As the TeXbook says:\n      // \"After you have said ‘\\def\\row#1#2{...}’, you are allowed to\n      //  put spaces between the arguments (e.g., ‘\\row x n’), because\n      //  TeX doesn’t use single spaces as undelimited arguments.\"\n      this.consumeSpaces();\n    }\n\n    var start = this.future();\n    var tok;\n    var depth = 0;\n    var match = 0;\n\n    do {\n      tok = this.popToken();\n      tokens.push(tok);\n\n      if (tok.text === \"{\") {\n        ++depth;\n      } else if (tok.text === \"}\") {\n        --depth;\n\n        if (depth === -1) {\n          throw new ParseError(\"Extra }\", tok);\n        }\n      } else if (tok.text === \"EOF\") {\n        throw new ParseError(\"Unexpected end of input in a macro argument\" + \", expected '\" + (delims && isDelimited ? delims[match] : \"}\") + \"'\", tok);\n      }\n\n      if (delims && isDelimited) {\n        if ((depth === 0 || depth === 1 && delims[match] === \"{\") && tok.text === delims[match]) {\n          ++match;\n\n          if (match === delims.length) {\n            // don't include delims in tokens\n            tokens.splice(-match, match);\n            break;\n          }\n        } else {\n          match = 0;\n        }\n      }\n    } while (depth !== 0 || isDelimited); // If the argument found ... has the form ‘{<nested tokens>}’,\n    // ... the outermost braces enclosing the argument are removed\n\n\n    if (start.text === \"{\" && tokens[tokens.length - 1].text === \"}\") {\n      tokens.pop();\n      tokens.shift();\n    }\n\n    tokens.reverse(); // to fit in with stack order\n\n    return {\n      tokens,\n      start,\n      end: tok\n    };\n  }\n  /**\n   * Consume the specified number of (delimited) arguments from the token\n   * stream and return the resulting array of arguments.\n   */\n\n\n  consumeArgs(numArgs, delimiters) {\n    if (delimiters) {\n      if (delimiters.length !== numArgs + 1) {\n        throw new ParseError(\"The length of delimiters doesn't match the number of args!\");\n      }\n\n      var delims = delimiters[0];\n\n      for (var i = 0; i < delims.length; i++) {\n        var tok = this.popToken();\n\n        if (delims[i] !== tok.text) {\n          throw new ParseError(\"Use of the macro doesn't match its definition\", tok);\n        }\n      }\n    }\n\n    var args = [];\n\n    for (var _i = 0; _i < numArgs; _i++) {\n      args.push(this.consumeArg(delimiters && delimiters[_i + 1]).tokens);\n    }\n\n    return args;\n  }\n  /**\n   * Increment `expansionCount` by the specified amount.\n   * Throw an error if it exceeds `maxExpand`.\n   */\n\n\n  countExpansion(amount) {\n    this.expansionCount += amount;\n\n    if (this.expansionCount > this.settings.maxExpand) {\n      throw new ParseError(\"Too many expansions: infinite loop or \" + \"need to increase maxExpand setting\");\n    }\n  }\n  /**\n   * Expand the next token only once if possible.\n   *\n   * If the token is expanded, the resulting tokens will be pushed onto\n   * the stack in reverse order, and the number of such tokens will be\n   * returned.  This number might be zero or positive.\n   *\n   * If not, the return value is `false`, and the next token remains at the\n   * top of the stack.\n   *\n   * In either case, the next token will be on the top of the stack,\n   * or the stack will be empty (in case of empty expansion\n   * and no other tokens).\n   *\n   * Used to implement `expandAfterFuture` and `expandNextToken`.\n   *\n   * If expandableOnly, only expandable tokens are expanded and\n   * an undefined control sequence results in an error.\n   */\n\n\n  expandOnce(expandableOnly) {\n    var topToken = this.popToken();\n    var name = topToken.text;\n    var expansion = !topToken.noexpand ? this._getExpansion(name) : null;\n\n    if (expansion == null || expandableOnly && expansion.unexpandable) {\n      if (expandableOnly && expansion == null && name[0] === \"\\\\\" && !this.isDefined(name)) {\n        throw new ParseError(\"Undefined control sequence: \" + name);\n      }\n\n      this.pushToken(topToken);\n      return false;\n    }\n\n    this.countExpansion(1);\n    var tokens = expansion.tokens;\n    var args = this.consumeArgs(expansion.numArgs, expansion.delimiters);\n\n    if (expansion.numArgs) {\n      // paste arguments in place of the placeholders\n      tokens = tokens.slice(); // make a shallow copy\n\n      for (var i = tokens.length - 1; i >= 0; --i) {\n        var tok = tokens[i];\n\n        if (tok.text === \"#\") {\n          if (i === 0) {\n            throw new ParseError(\"Incomplete placeholder at end of macro body\", tok);\n          }\n\n          tok = tokens[--i]; // next token on stack\n\n          if (tok.text === \"#\") {\n            // ## → #\n            tokens.splice(i + 1, 1); // drop first #\n          } else if (/^[1-9]$/.test(tok.text)) {\n            // replace the placeholder with the indicated argument\n            tokens.splice(i, 2, ...args[+tok.text - 1]);\n          } else {\n            throw new ParseError(\"Not a valid argument number\", tok);\n          }\n        }\n      }\n    } // Concatenate expansion onto top of stack.\n\n\n    this.pushTokens(tokens);\n    return tokens.length;\n  }\n  /**\n   * Expand the next token only once (if possible), and return the resulting\n   * top token on the stack (without removing anything from the stack).\n   * Similar in behavior to TeX's `\\expandafter\\futurelet`.\n   * Equivalent to expandOnce() followed by future().\n   */\n\n\n  expandAfterFuture() {\n    this.expandOnce();\n    return this.future();\n  }\n  /**\n   * Recursively expand first token, then return first non-expandable token.\n   */\n\n\n  expandNextToken() {\n    for (;;) {\n      if (this.expandOnce() === false) {\n        // fully expanded\n        var token = this.stack.pop(); // the token after \\noexpand is interpreted as if its meaning\n        // were ‘\\relax’\n\n        if (token.treatAsRelax) {\n          token.text = \"\\\\relax\";\n        }\n\n        return token;\n      }\n    } // Flow unable to figure out that this pathway is impossible.\n    // https://github.com/facebook/flow/issues/4808\n\n\n    throw new Error(); // eslint-disable-line no-unreachable\n  }\n  /**\n   * Fully expand the given macro name and return the resulting list of\n   * tokens, or return `undefined` if no such macro is defined.\n   */\n\n\n  expandMacro(name) {\n    return this.macros.has(name) ? this.expandTokens([new Token(name)]) : undefined;\n  }\n  /**\n   * Fully expand the given token stream and return the resulting list of\n   * tokens.  Note that the input tokens are in reverse order, but the\n   * output tokens are in forward order.\n   */\n\n\n  expandTokens(tokens) {\n    var output = [];\n    var oldStackLength = this.stack.length;\n    this.pushTokens(tokens);\n\n    while (this.stack.length > oldStackLength) {\n      // Expand only expandable tokens\n      if (this.expandOnce(true) === false) {\n        // fully expanded\n        var token = this.stack.pop();\n\n        if (token.treatAsRelax) {\n          // the expansion of \\noexpand is the token itself\n          token.noexpand = false;\n          token.treatAsRelax = false;\n        }\n\n        output.push(token);\n      }\n    } // Count all of these tokens as additional expansions, to prevent\n    // exponential blowup from linearly many \\edef's.\n\n\n    this.countExpansion(output.length);\n    return output;\n  }\n  /**\n   * Fully expand the given macro name and return the result as a string,\n   * or return `undefined` if no such macro is defined.\n   */\n\n\n  expandMacroAsText(name) {\n    var tokens = this.expandMacro(name);\n\n    if (tokens) {\n      return tokens.map(token => token.text).join(\"\");\n    } else {\n      return tokens;\n    }\n  }\n  /**\n   * Returns the expanded macro as a reversed array of tokens and a macro\n   * argument count.  Or returns `null` if no such macro.\n   */\n\n\n  _getExpansion(name) {\n    var definition = this.macros.get(name);\n\n    if (definition == null) {\n      // mainly checking for undefined here\n      return definition;\n    } // If a single character has an associated catcode other than 13\n    // (active character), then don't expand it.\n\n\n    if (name.length === 1) {\n      var catcode = this.lexer.catcodes[name];\n\n      if (catcode != null && catcode !== 13) {\n        return;\n      }\n    }\n\n    var expansion = typeof definition === \"function\" ? definition(this) : definition;\n\n    if (typeof expansion === \"string\") {\n      var numArgs = 0;\n\n      if (expansion.indexOf(\"#\") !== -1) {\n        var stripped = expansion.replace(/##/g, \"\");\n\n        while (stripped.indexOf(\"#\" + (numArgs + 1)) !== -1) {\n          ++numArgs;\n        }\n      }\n\n      var bodyLexer = new Lexer(expansion, this.settings);\n      var tokens = [];\n      var tok = bodyLexer.lex();\n\n      while (tok.text !== \"EOF\") {\n        tokens.push(tok);\n        tok = bodyLexer.lex();\n      }\n\n      tokens.reverse(); // to fit in with stack using push and pop\n\n      var expanded = {\n        tokens,\n        numArgs\n      };\n      return expanded;\n    }\n\n    return expansion;\n  }\n  /**\n   * Determine whether a command is currently \"defined\" (has some\n   * functionality), meaning that it's a macro (in the current group),\n   * a function, a symbol, or one of the special commands listed in\n   * `implicitCommands`.\n   */\n\n\n  isDefined(name) {\n    return this.macros.has(name) || functions.hasOwnProperty(name) || symbols.math.hasOwnProperty(name) || symbols.text.hasOwnProperty(name) || implicitCommands.hasOwnProperty(name);\n  }\n  /**\n   * Determine whether a command is expandable.\n   */\n\n\n  isExpandable(name) {\n    var macro = this.macros.get(name);\n    return macro != null ? typeof macro === \"string\" || typeof macro === \"function\" || !macro.unexpandable : functions.hasOwnProperty(name) && !functions[name].primitive;\n  }\n\n}\n\n// Helpers for Parser.js handling of Unicode (sub|super)script characters.\nvar unicodeSubRegEx = /^[₊₋₌₍₎₀₁₂₃₄₅₆₇₈₉ₐₑₕᵢⱼₖₗₘₙₒₚᵣₛₜᵤᵥₓᵦᵧᵨᵩᵪ]/;\nvar uSubsAndSups = Object.freeze({\n  '₊': '+',\n  '₋': '-',\n  '₌': '=',\n  '₍': '(',\n  '₎': ')',\n  '₀': '0',\n  '₁': '1',\n  '₂': '2',\n  '₃': '3',\n  '₄': '4',\n  '₅': '5',\n  '₆': '6',\n  '₇': '7',\n  '₈': '8',\n  '₉': '9',\n  '\\u2090': 'a',\n  '\\u2091': 'e',\n  '\\u2095': 'h',\n  '\\u1D62': 'i',\n  '\\u2C7C': 'j',\n  '\\u2096': 'k',\n  '\\u2097': 'l',\n  '\\u2098': 'm',\n  '\\u2099': 'n',\n  '\\u2092': 'o',\n  '\\u209A': 'p',\n  '\\u1D63': 'r',\n  '\\u209B': 's',\n  '\\u209C': 't',\n  '\\u1D64': 'u',\n  '\\u1D65': 'v',\n  '\\u2093': 'x',\n  '\\u1D66': 'β',\n  '\\u1D67': 'γ',\n  '\\u1D68': 'ρ',\n  '\\u1D69': '\\u03d5',\n  '\\u1D6A': 'χ',\n  '⁺': '+',\n  '⁻': '-',\n  '⁼': '=',\n  '⁽': '(',\n  '⁾': ')',\n  '⁰': '0',\n  '¹': '1',\n  '²': '2',\n  '³': '3',\n  '⁴': '4',\n  '⁵': '5',\n  '⁶': '6',\n  '⁷': '7',\n  '⁸': '8',\n  '⁹': '9',\n  '\\u1D2C': 'A',\n  '\\u1D2E': 'B',\n  '\\u1D30': 'D',\n  '\\u1D31': 'E',\n  '\\u1D33': 'G',\n  '\\u1D34': 'H',\n  '\\u1D35': 'I',\n  '\\u1D36': 'J',\n  '\\u1D37': 'K',\n  '\\u1D38': 'L',\n  '\\u1D39': 'M',\n  '\\u1D3A': 'N',\n  '\\u1D3C': 'O',\n  '\\u1D3E': 'P',\n  '\\u1D3F': 'R',\n  '\\u1D40': 'T',\n  '\\u1D41': 'U',\n  '\\u2C7D': 'V',\n  '\\u1D42': 'W',\n  '\\u1D43': 'a',\n  '\\u1D47': 'b',\n  '\\u1D9C': 'c',\n  '\\u1D48': 'd',\n  '\\u1D49': 'e',\n  '\\u1DA0': 'f',\n  '\\u1D4D': 'g',\n  '\\u02B0': 'h',\n  '\\u2071': 'i',\n  '\\u02B2': 'j',\n  '\\u1D4F': 'k',\n  '\\u02E1': 'l',\n  '\\u1D50': 'm',\n  '\\u207F': 'n',\n  '\\u1D52': 'o',\n  '\\u1D56': 'p',\n  '\\u02B3': 'r',\n  '\\u02E2': 's',\n  '\\u1D57': 't',\n  '\\u1D58': 'u',\n  '\\u1D5B': 'v',\n  '\\u02B7': 'w',\n  '\\u02E3': 'x',\n  '\\u02B8': 'y',\n  '\\u1DBB': 'z',\n  '\\u1D5D': 'β',\n  '\\u1D5E': 'γ',\n  '\\u1D5F': 'δ',\n  '\\u1D60': '\\u03d5',\n  '\\u1D61': 'χ',\n  '\\u1DBF': 'θ'\n});\n\n/* eslint no-constant-condition:0 */\n\nvar unicodeAccents = {\n  \"́\": {\n    \"text\": \"\\\\'\",\n    \"math\": \"\\\\acute\"\n  },\n  \"̀\": {\n    \"text\": \"\\\\`\",\n    \"math\": \"\\\\grave\"\n  },\n  \"̈\": {\n    \"text\": \"\\\\\\\"\",\n    \"math\": \"\\\\ddot\"\n  },\n  \"̃\": {\n    \"text\": \"\\\\~\",\n    \"math\": \"\\\\tilde\"\n  },\n  \"̄\": {\n    \"text\": \"\\\\=\",\n    \"math\": \"\\\\bar\"\n  },\n  \"̆\": {\n    \"text\": \"\\\\u\",\n    \"math\": \"\\\\breve\"\n  },\n  \"̌\": {\n    \"text\": \"\\\\v\",\n    \"math\": \"\\\\check\"\n  },\n  \"̂\": {\n    \"text\": \"\\\\^\",\n    \"math\": \"\\\\hat\"\n  },\n  \"̇\": {\n    \"text\": \"\\\\.\",\n    \"math\": \"\\\\dot\"\n  },\n  \"̊\": {\n    \"text\": \"\\\\r\",\n    \"math\": \"\\\\mathring\"\n  },\n  \"̋\": {\n    \"text\": \"\\\\H\"\n  },\n  \"̧\": {\n    \"text\": \"\\\\c\"\n  }\n};\nvar unicodeSymbols = {\n  \"á\": \"á\",\n  \"à\": \"à\",\n  \"ä\": \"ä\",\n  \"ǟ\": \"ǟ\",\n  \"ã\": \"ã\",\n  \"ā\": \"ā\",\n  \"ă\": \"ă\",\n  \"ắ\": \"ắ\",\n  \"ằ\": \"ằ\",\n  \"ẵ\": \"ẵ\",\n  \"ǎ\": \"ǎ\",\n  \"â\": \"â\",\n  \"ấ\": \"ấ\",\n  \"ầ\": \"ầ\",\n  \"ẫ\": \"ẫ\",\n  \"ȧ\": \"ȧ\",\n  \"ǡ\": \"ǡ\",\n  \"å\": \"å\",\n  \"ǻ\": \"ǻ\",\n  \"ḃ\": \"ḃ\",\n  \"ć\": \"ć\",\n  \"ḉ\": \"ḉ\",\n  \"č\": \"č\",\n  \"ĉ\": \"ĉ\",\n  \"ċ\": \"ċ\",\n  \"ç\": \"ç\",\n  \"ď\": \"ď\",\n  \"ḋ\": \"ḋ\",\n  \"ḑ\": \"ḑ\",\n  \"é\": \"é\",\n  \"è\": \"è\",\n  \"ë\": \"ë\",\n  \"ẽ\": \"ẽ\",\n  \"ē\": \"ē\",\n  \"ḗ\": \"ḗ\",\n  \"ḕ\": \"ḕ\",\n  \"ĕ\": \"ĕ\",\n  \"ḝ\": \"ḝ\",\n  \"ě\": \"ě\",\n  \"ê\": \"ê\",\n  \"ế\": \"ế\",\n  \"ề\": \"ề\",\n  \"ễ\": \"ễ\",\n  \"ė\": \"ė\",\n  \"ȩ\": \"ȩ\",\n  \"ḟ\": \"ḟ\",\n  \"ǵ\": \"ǵ\",\n  \"ḡ\": \"ḡ\",\n  \"ğ\": \"ğ\",\n  \"ǧ\": \"ǧ\",\n  \"ĝ\": \"ĝ\",\n  \"ġ\": \"ġ\",\n  \"ģ\": \"ģ\",\n  \"ḧ\": \"ḧ\",\n  \"ȟ\": \"ȟ\",\n  \"ĥ\": \"ĥ\",\n  \"ḣ\": \"ḣ\",\n  \"ḩ\": \"ḩ\",\n  \"í\": \"í\",\n  \"ì\": \"ì\",\n  \"ï\": \"ï\",\n  \"ḯ\": \"ḯ\",\n  \"ĩ\": \"ĩ\",\n  \"ī\": \"ī\",\n  \"ĭ\": \"ĭ\",\n  \"ǐ\": \"ǐ\",\n  \"î\": \"î\",\n  \"ǰ\": \"ǰ\",\n  \"ĵ\": \"ĵ\",\n  \"ḱ\": \"ḱ\",\n  \"ǩ\": \"ǩ\",\n  \"ķ\": \"ķ\",\n  \"ĺ\": \"ĺ\",\n  \"ľ\": \"ľ\",\n  \"ļ\": \"ļ\",\n  \"ḿ\": \"ḿ\",\n  \"ṁ\": \"ṁ\",\n  \"ń\": \"ń\",\n  \"ǹ\": \"ǹ\",\n  \"ñ\": \"ñ\",\n  \"ň\": \"ň\",\n  \"ṅ\": \"ṅ\",\n  \"ņ\": \"ņ\",\n  \"ó\": \"ó\",\n  \"ò\": \"ò\",\n  \"ö\": \"ö\",\n  \"ȫ\": \"ȫ\",\n  \"õ\": \"õ\",\n  \"ṍ\": \"ṍ\",\n  \"ṏ\": \"ṏ\",\n  \"ȭ\": \"ȭ\",\n  \"ō\": \"ō\",\n  \"ṓ\": \"ṓ\",\n  \"ṑ\": \"ṑ\",\n  \"ŏ\": \"ŏ\",\n  \"ǒ\": \"ǒ\",\n  \"ô\": \"ô\",\n  \"ố\": \"ố\",\n  \"ồ\": \"ồ\",\n  \"ỗ\": \"ỗ\",\n  \"ȯ\": \"ȯ\",\n  \"ȱ\": \"ȱ\",\n  \"ő\": \"ő\",\n  \"ṕ\": \"ṕ\",\n  \"ṗ\": \"ṗ\",\n  \"ŕ\": \"ŕ\",\n  \"ř\": \"ř\",\n  \"ṙ\": \"ṙ\",\n  \"ŗ\": \"ŗ\",\n  \"ś\": \"ś\",\n  \"ṥ\": \"ṥ\",\n  \"š\": \"š\",\n  \"ṧ\": \"ṧ\",\n  \"ŝ\": \"ŝ\",\n  \"ṡ\": \"ṡ\",\n  \"ş\": \"ş\",\n  \"ẗ\": \"ẗ\",\n  \"ť\": \"ť\",\n  \"ṫ\": \"ṫ\",\n  \"ţ\": \"ţ\",\n  \"ú\": \"ú\",\n  \"ù\": \"ù\",\n  \"ü\": \"ü\",\n  \"ǘ\": \"ǘ\",\n  \"ǜ\": \"ǜ\",\n  \"ǖ\": \"ǖ\",\n  \"ǚ\": \"ǚ\",\n  \"ũ\": \"ũ\",\n  \"ṹ\": \"ṹ\",\n  \"ū\": \"ū\",\n  \"ṻ\": \"ṻ\",\n  \"ŭ\": \"ŭ\",\n  \"ǔ\": \"ǔ\",\n  \"û\": \"û\",\n  \"ů\": \"ů\",\n  \"ű\": \"ű\",\n  \"ṽ\": \"ṽ\",\n  \"ẃ\": \"ẃ\",\n  \"ẁ\": \"ẁ\",\n  \"ẅ\": \"ẅ\",\n  \"ŵ\": \"ŵ\",\n  \"ẇ\": \"ẇ\",\n  \"ẘ\": \"ẘ\",\n  \"ẍ\": \"ẍ\",\n  \"ẋ\": \"ẋ\",\n  \"ý\": \"ý\",\n  \"ỳ\": \"ỳ\",\n  \"ÿ\": \"ÿ\",\n  \"ỹ\": \"ỹ\",\n  \"ȳ\": \"ȳ\",\n  \"ŷ\": \"ŷ\",\n  \"ẏ\": \"ẏ\",\n  \"ẙ\": \"ẙ\",\n  \"ź\": \"ź\",\n  \"ž\": \"ž\",\n  \"ẑ\": \"ẑ\",\n  \"ż\": \"ż\",\n  \"Á\": \"Á\",\n  \"À\": \"À\",\n  \"Ä\": \"Ä\",\n  \"Ǟ\": \"Ǟ\",\n  \"Ã\": \"Ã\",\n  \"Ā\": \"Ā\",\n  \"Ă\": \"Ă\",\n  \"Ắ\": \"Ắ\",\n  \"Ằ\": \"Ằ\",\n  \"Ẵ\": \"Ẵ\",\n  \"Ǎ\": \"Ǎ\",\n  \"Â\": \"Â\",\n  \"Ấ\": \"Ấ\",\n  \"Ầ\": \"Ầ\",\n  \"Ẫ\": \"Ẫ\",\n  \"Ȧ\": \"Ȧ\",\n  \"Ǡ\": \"Ǡ\",\n  \"Å\": \"Å\",\n  \"Ǻ\": \"Ǻ\",\n  \"Ḃ\": \"Ḃ\",\n  \"Ć\": \"Ć\",\n  \"Ḉ\": \"Ḉ\",\n  \"Č\": \"Č\",\n  \"Ĉ\": \"Ĉ\",\n  \"Ċ\": \"Ċ\",\n  \"Ç\": \"Ç\",\n  \"Ď\": \"Ď\",\n  \"Ḋ\": \"Ḋ\",\n  \"Ḑ\": \"Ḑ\",\n  \"É\": \"É\",\n  \"È\": \"È\",\n  \"Ë\": \"Ë\",\n  \"Ẽ\": \"Ẽ\",\n  \"Ē\": \"Ē\",\n  \"Ḗ\": \"Ḗ\",\n  \"Ḕ\": \"Ḕ\",\n  \"Ĕ\": \"Ĕ\",\n  \"Ḝ\": \"Ḝ\",\n  \"Ě\": \"Ě\",\n  \"Ê\": \"Ê\",\n  \"Ế\": \"Ế\",\n  \"Ề\": \"Ề\",\n  \"Ễ\": \"Ễ\",\n  \"Ė\": \"Ė\",\n  \"Ȩ\": \"Ȩ\",\n  \"Ḟ\": \"Ḟ\",\n  \"Ǵ\": \"Ǵ\",\n  \"Ḡ\": \"Ḡ\",\n  \"Ğ\": \"Ğ\",\n  \"Ǧ\": \"Ǧ\",\n  \"Ĝ\": \"Ĝ\",\n  \"Ġ\": \"Ġ\",\n  \"Ģ\": \"Ģ\",\n  \"Ḧ\": \"Ḧ\",\n  \"Ȟ\": \"Ȟ\",\n  \"Ĥ\": \"Ĥ\",\n  \"Ḣ\": \"Ḣ\",\n  \"Ḩ\": \"Ḩ\",\n  \"Í\": \"Í\",\n  \"Ì\": \"Ì\",\n  \"Ï\": \"Ï\",\n  \"Ḯ\": \"Ḯ\",\n  \"Ĩ\": \"Ĩ\",\n  \"Ī\": \"Ī\",\n  \"Ĭ\": \"Ĭ\",\n  \"Ǐ\": \"Ǐ\",\n  \"Î\": \"Î\",\n  \"İ\": \"İ\",\n  \"Ĵ\": \"Ĵ\",\n  \"Ḱ\": \"Ḱ\",\n  \"Ǩ\": \"Ǩ\",\n  \"Ķ\": \"Ķ\",\n  \"Ĺ\": \"Ĺ\",\n  \"Ľ\": \"Ľ\",\n  \"Ļ\": \"Ļ\",\n  \"Ḿ\": \"Ḿ\",\n  \"Ṁ\": \"Ṁ\",\n  \"Ń\": \"Ń\",\n  \"Ǹ\": \"Ǹ\",\n  \"Ñ\": \"Ñ\",\n  \"Ň\": \"Ň\",\n  \"Ṅ\": \"Ṅ\",\n  \"Ņ\": \"Ņ\",\n  \"Ó\": \"Ó\",\n  \"Ò\": \"Ò\",\n  \"Ö\": \"Ö\",\n  \"Ȫ\": \"Ȫ\",\n  \"Õ\": \"Õ\",\n  \"Ṍ\": \"Ṍ\",\n  \"Ṏ\": \"Ṏ\",\n  \"Ȭ\": \"Ȭ\",\n  \"Ō\": \"Ō\",\n  \"Ṓ\": \"Ṓ\",\n  \"Ṑ\": \"Ṑ\",\n  \"Ŏ\": \"Ŏ\",\n  \"Ǒ\": \"Ǒ\",\n  \"Ô\": \"Ô\",\n  \"Ố\": \"Ố\",\n  \"Ồ\": \"Ồ\",\n  \"Ỗ\": \"Ỗ\",\n  \"Ȯ\": \"Ȯ\",\n  \"Ȱ\": \"Ȱ\",\n  \"Ő\": \"Ő\",\n  \"Ṕ\": \"Ṕ\",\n  \"Ṗ\": \"Ṗ\",\n  \"Ŕ\": \"Ŕ\",\n  \"Ř\": \"Ř\",\n  \"Ṙ\": \"Ṙ\",\n  \"Ŗ\": \"Ŗ\",\n  \"Ś\": \"Ś\",\n  \"Ṥ\": \"Ṥ\",\n  \"Š\": \"Š\",\n  \"Ṧ\": \"Ṧ\",\n  \"Ŝ\": \"Ŝ\",\n  \"Ṡ\": \"Ṡ\",\n  \"Ş\": \"Ş\",\n  \"Ť\": \"Ť\",\n  \"Ṫ\": \"Ṫ\",\n  \"Ţ\": \"Ţ\",\n  \"Ú\": \"Ú\",\n  \"Ù\": \"Ù\",\n  \"Ü\": \"Ü\",\n  \"Ǘ\": \"Ǘ\",\n  \"Ǜ\": \"Ǜ\",\n  \"Ǖ\": \"Ǖ\",\n  \"Ǚ\": \"Ǚ\",\n  \"Ũ\": \"Ũ\",\n  \"Ṹ\": \"Ṹ\",\n  \"Ū\": \"Ū\",\n  \"Ṻ\": \"Ṻ\",\n  \"Ŭ\": \"Ŭ\",\n  \"Ǔ\": \"Ǔ\",\n  \"Û\": \"Û\",\n  \"Ů\": \"Ů\",\n  \"Ű\": \"Ű\",\n  \"Ṽ\": \"Ṽ\",\n  \"Ẃ\": \"Ẃ\",\n  \"Ẁ\": \"Ẁ\",\n  \"Ẅ\": \"Ẅ\",\n  \"Ŵ\": \"Ŵ\",\n  \"Ẇ\": \"Ẇ\",\n  \"Ẍ\": \"Ẍ\",\n  \"Ẋ\": \"Ẋ\",\n  \"Ý\": \"Ý\",\n  \"Ỳ\": \"Ỳ\",\n  \"Ÿ\": \"Ÿ\",\n  \"Ỹ\": \"Ỹ\",\n  \"Ȳ\": \"Ȳ\",\n  \"Ŷ\": \"Ŷ\",\n  \"Ẏ\": \"Ẏ\",\n  \"Ź\": \"Ź\",\n  \"Ž\": \"Ž\",\n  \"Ẑ\": \"Ẑ\",\n  \"Ż\": \"Ż\",\n  \"ά\": \"ά\",\n  \"ὰ\": \"ὰ\",\n  \"ᾱ\": \"ᾱ\",\n  \"ᾰ\": \"ᾰ\",\n  \"έ\": \"έ\",\n  \"ὲ\": \"ὲ\",\n  \"ή\": \"ή\",\n  \"ὴ\": \"ὴ\",\n  \"ί\": \"ί\",\n  \"ὶ\": \"ὶ\",\n  \"ϊ\": \"ϊ\",\n  \"ΐ\": \"ΐ\",\n  \"ῒ\": \"ῒ\",\n  \"ῑ\": \"ῑ\",\n  \"ῐ\": \"ῐ\",\n  \"ό\": \"ό\",\n  \"ὸ\": \"ὸ\",\n  \"ύ\": \"ύ\",\n  \"ὺ\": \"ὺ\",\n  \"ϋ\": \"ϋ\",\n  \"ΰ\": \"ΰ\",\n  \"ῢ\": \"ῢ\",\n  \"ῡ\": \"ῡ\",\n  \"ῠ\": \"ῠ\",\n  \"ώ\": \"ώ\",\n  \"ὼ\": \"ὼ\",\n  \"Ύ\": \"Ύ\",\n  \"Ὺ\": \"Ὺ\",\n  \"Ϋ\": \"Ϋ\",\n  \"Ῡ\": \"Ῡ\",\n  \"Ῠ\": \"Ῠ\",\n  \"Ώ\": \"Ώ\",\n  \"Ὼ\": \"Ὼ\"\n};\n\n/**\n * This file contains the parser used to parse out a TeX expression from the\n * input. Since TeX isn't context-free, standard parsers don't work particularly\n * well.\n *\n * The strategy of this parser is as such:\n *\n * The main functions (the `.parse...` ones) take a position in the current\n * parse string to parse tokens from. The lexer (found in Lexer.js, stored at\n * this.gullet.lexer) also supports pulling out tokens at arbitrary places. When\n * individual tokens are needed at a position, the lexer is called to pull out a\n * token, which is then used.\n *\n * The parser has a property called \"mode\" indicating the mode that\n * the parser is currently in. Currently it has to be one of \"math\" or\n * \"text\", which denotes whether the current environment is a math-y\n * one or a text-y one (e.g. inside \\text). Currently, this serves to\n * limit the functions which can be used in text mode.\n *\n * The main functions then return an object which contains the useful data that\n * was parsed at its given point, and a new position at the end of the parsed\n * data. The main functions can call each other and continue the parsing by\n * using the returned position as a new starting point.\n *\n * There are also extra `.handle...` functions, which pull out some reused\n * functionality into self-contained functions.\n *\n * The functions return ParseNodes.\n */\nclass Parser {\n  constructor(input, settings) {\n    this.mode = void 0;\n    this.gullet = void 0;\n    this.settings = void 0;\n    this.leftrightDepth = void 0;\n    this.nextToken = void 0;\n    // Start in math mode\n    this.mode = \"math\"; // Create a new macro expander (gullet) and (indirectly via that) also a\n    // new lexer (mouth) for this parser (stomach, in the language of TeX)\n\n    this.gullet = new MacroExpander(input, settings, this.mode); // Store the settings for use in parsing\n\n    this.settings = settings; // Count leftright depth (for \\middle errors)\n\n    this.leftrightDepth = 0;\n  }\n  /**\n   * Checks a result to make sure it has the right type, and throws an\n   * appropriate error otherwise.\n   */\n\n\n  expect(text, consume) {\n    if (consume === void 0) {\n      consume = true;\n    }\n\n    if (this.fetch().text !== text) {\n      throw new ParseError(\"Expected '\" + text + \"', got '\" + this.fetch().text + \"'\", this.fetch());\n    }\n\n    if (consume) {\n      this.consume();\n    }\n  }\n  /**\n   * Discards the current lookahead token, considering it consumed.\n   */\n\n\n  consume() {\n    this.nextToken = null;\n  }\n  /**\n   * Return the current lookahead token, or if there isn't one (at the\n   * beginning, or if the previous lookahead token was consume()d),\n   * fetch the next token as the new lookahead token and return it.\n   */\n\n\n  fetch() {\n    if (this.nextToken == null) {\n      this.nextToken = this.gullet.expandNextToken();\n    }\n\n    return this.nextToken;\n  }\n  /**\n   * Switches between \"text\" and \"math\" modes.\n   */\n\n\n  switchMode(newMode) {\n    this.mode = newMode;\n    this.gullet.switchMode(newMode);\n  }\n  /**\n   * Main parsing function, which parses an entire input.\n   */\n\n\n  parse() {\n    if (!this.settings.globalGroup) {\n      // Create a group namespace for the math expression.\n      // (LaTeX creates a new group for every $...$, $$...$$, \\[...\\].)\n      this.gullet.beginGroup();\n    } // Use old \\color behavior (same as LaTeX's \\textcolor) if requested.\n    // We do this within the group for the math expression, so it doesn't\n    // pollute settings.macros.\n\n\n    if (this.settings.colorIsTextColor) {\n      this.gullet.macros.set(\"\\\\color\", \"\\\\textcolor\");\n    }\n\n    try {\n      // Try to parse the input\n      var parse = this.parseExpression(false); // If we succeeded, make sure there's an EOF at the end\n\n      this.expect(\"EOF\"); // End the group namespace for the expression\n\n      if (!this.settings.globalGroup) {\n        this.gullet.endGroup();\n      }\n\n      return parse; // Close any leftover groups in case of a parse error.\n    } finally {\n      this.gullet.endGroups();\n    }\n  }\n  /**\n   * Fully parse a separate sequence of tokens as a separate job.\n   * Tokens should be specified in reverse order, as in a MacroDefinition.\n   */\n\n\n  subparse(tokens) {\n    // Save the next token from the current job.\n    var oldToken = this.nextToken;\n    this.consume(); // Run the new job, terminating it with an excess '}'\n\n    this.gullet.pushToken(new Token(\"}\"));\n    this.gullet.pushTokens(tokens);\n    var parse = this.parseExpression(false);\n    this.expect(\"}\"); // Restore the next token from the current job.\n\n    this.nextToken = oldToken;\n    return parse;\n  }\n\n  /**\n   * Parses an \"expression\", which is a list of atoms.\n   *\n   * `breakOnInfix`: Should the parsing stop when we hit infix nodes? This\n   *                 happens when functions have higher precedence han infix\n   *                 nodes in implicit parses.\n   *\n   * `breakOnTokenText`: The text of the token that the expression should end\n   *                     with, or `null` if something else should end the\n   *                     expression.\n   */\n  parseExpression(breakOnInfix, breakOnTokenText) {\n    var body = []; // Keep adding atoms to the body until we can't parse any more atoms (either\n    // we reached the end, a }, or a \\right)\n\n    while (true) {\n      // Ignore spaces in math mode\n      if (this.mode === \"math\") {\n        this.consumeSpaces();\n      }\n\n      var lex = this.fetch();\n\n      if (Parser.endOfExpression.indexOf(lex.text) !== -1) {\n        break;\n      }\n\n      if (breakOnTokenText && lex.text === breakOnTokenText) {\n        break;\n      }\n\n      if (breakOnInfix && functions[lex.text] && functions[lex.text].infix) {\n        break;\n      }\n\n      var atom = this.parseAtom(breakOnTokenText);\n\n      if (!atom) {\n        break;\n      } else if (atom.type === \"internal\") {\n        continue;\n      }\n\n      body.push(atom);\n    }\n\n    if (this.mode === \"text\") {\n      this.formLigatures(body);\n    }\n\n    return this.handleInfixNodes(body);\n  }\n  /**\n   * Rewrites infix operators such as \\over with corresponding commands such\n   * as \\frac.\n   *\n   * There can only be one infix operator per group.  If there's more than one\n   * then the expression is ambiguous.  This can be resolved by adding {}.\n   */\n\n\n  handleInfixNodes(body) {\n    var overIndex = -1;\n    var funcName;\n\n    for (var i = 0; i < body.length; i++) {\n      if (body[i].type === \"infix\") {\n        if (overIndex !== -1) {\n          throw new ParseError(\"only one infix operator per group\", body[i].token);\n        }\n\n        overIndex = i;\n        funcName = body[i].replaceWith;\n      }\n    }\n\n    if (overIndex !== -1 && funcName) {\n      var numerNode;\n      var denomNode;\n      var numerBody = body.slice(0, overIndex);\n      var denomBody = body.slice(overIndex + 1);\n\n      if (numerBody.length === 1 && numerBody[0].type === \"ordgroup\") {\n        numerNode = numerBody[0];\n      } else {\n        numerNode = {\n          type: \"ordgroup\",\n          mode: this.mode,\n          body: numerBody\n        };\n      }\n\n      if (denomBody.length === 1 && denomBody[0].type === \"ordgroup\") {\n        denomNode = denomBody[0];\n      } else {\n        denomNode = {\n          type: \"ordgroup\",\n          mode: this.mode,\n          body: denomBody\n        };\n      }\n\n      var node;\n\n      if (funcName === \"\\\\\\\\abovefrac\") {\n        node = this.callFunction(funcName, [numerNode, body[overIndex], denomNode], []);\n      } else {\n        node = this.callFunction(funcName, [numerNode, denomNode], []);\n      }\n\n      return [node];\n    } else {\n      return body;\n    }\n  }\n  /**\n   * Handle a subscript or superscript with nice errors.\n   */\n\n\n  handleSupSubscript(name // For error reporting.\n  ) {\n    var symbolToken = this.fetch();\n    var symbol = symbolToken.text;\n    this.consume();\n    this.consumeSpaces(); // ignore spaces before sup/subscript argument\n\n    var group = this.parseGroup(name);\n\n    if (!group) {\n      throw new ParseError(\"Expected group after '\" + symbol + \"'\", symbolToken);\n    }\n\n    return group;\n  }\n  /**\n   * Converts the textual input of an unsupported command into a text node\n   * contained within a color node whose color is determined by errorColor\n   */\n\n\n  formatUnsupportedCmd(text) {\n    var textordArray = [];\n\n    for (var i = 0; i < text.length; i++) {\n      textordArray.push({\n        type: \"textord\",\n        mode: \"text\",\n        text: text[i]\n      });\n    }\n\n    var textNode = {\n      type: \"text\",\n      mode: this.mode,\n      body: textordArray\n    };\n    var colorNode = {\n      type: \"color\",\n      mode: this.mode,\n      color: this.settings.errorColor,\n      body: [textNode]\n    };\n    return colorNode;\n  }\n  /**\n   * Parses a group with optional super/subscripts.\n   */\n\n\n  parseAtom(breakOnTokenText) {\n    // The body of an atom is an implicit group, so that things like\n    // \\left(x\\right)^2 work correctly.\n    var base = this.parseGroup(\"atom\", breakOnTokenText); // In text mode, we don't have superscripts or subscripts\n\n    if (this.mode === \"text\") {\n      return base;\n    } // Note that base may be empty (i.e. null) at this point.\n\n\n    var superscript;\n    var subscript;\n\n    while (true) {\n      // Guaranteed in math mode, so eat any spaces first.\n      this.consumeSpaces(); // Lex the first token\n\n      var lex = this.fetch();\n\n      if (lex.text === \"\\\\limits\" || lex.text === \"\\\\nolimits\") {\n        // We got a limit control\n        if (base && base.type === \"op\") {\n          var limits = lex.text === \"\\\\limits\";\n          base.limits = limits;\n          base.alwaysHandleSupSub = true;\n        } else if (base && base.type === \"operatorname\") {\n          if (base.alwaysHandleSupSub) {\n            base.limits = lex.text === \"\\\\limits\";\n          }\n        } else {\n          throw new ParseError(\"Limit controls must follow a math operator\", lex);\n        }\n\n        this.consume();\n      } else if (lex.text === \"^\") {\n        // We got a superscript start\n        if (superscript) {\n          throw new ParseError(\"Double superscript\", lex);\n        }\n\n        superscript = this.handleSupSubscript(\"superscript\");\n      } else if (lex.text === \"_\") {\n        // We got a subscript start\n        if (subscript) {\n          throw new ParseError(\"Double subscript\", lex);\n        }\n\n        subscript = this.handleSupSubscript(\"subscript\");\n      } else if (lex.text === \"'\") {\n        // We got a prime\n        if (superscript) {\n          throw new ParseError(\"Double superscript\", lex);\n        }\n\n        var prime = {\n          type: \"textord\",\n          mode: this.mode,\n          text: \"\\\\prime\"\n        }; // Many primes can be grouped together, so we handle this here\n\n        var primes = [prime];\n        this.consume(); // Keep lexing tokens until we get something that's not a prime\n\n        while (this.fetch().text === \"'\") {\n          // For each one, add another prime to the list\n          primes.push(prime);\n          this.consume();\n        } // If there's a superscript following the primes, combine that\n        // superscript in with the primes.\n\n\n        if (this.fetch().text === \"^\") {\n          primes.push(this.handleSupSubscript(\"superscript\"));\n        } // Put everything into an ordgroup as the superscript\n\n\n        superscript = {\n          type: \"ordgroup\",\n          mode: this.mode,\n          body: primes\n        };\n      } else if (uSubsAndSups[lex.text]) {\n        // A Unicode subscript or superscript character.\n        // We treat these similarly to the unicode-math package.\n        // So we render a string of Unicode (sub|super)scripts the\n        // same as a (sub|super)script of regular characters.\n        var isSub = unicodeSubRegEx.test(lex.text);\n        var subsupTokens = [];\n        subsupTokens.push(new Token(uSubsAndSups[lex.text]));\n        this.consume(); // Continue fetching tokens to fill out the string.\n\n        while (true) {\n          var token = this.fetch().text;\n\n          if (!uSubsAndSups[token]) {\n            break;\n          }\n\n          if (unicodeSubRegEx.test(token) !== isSub) {\n            break;\n          }\n\n          subsupTokens.unshift(new Token(uSubsAndSups[token]));\n          this.consume();\n        } // Now create a (sub|super)script.\n\n\n        var body = this.subparse(subsupTokens);\n\n        if (isSub) {\n          subscript = {\n            type: \"ordgroup\",\n            mode: \"math\",\n            body\n          };\n        } else {\n          superscript = {\n            type: \"ordgroup\",\n            mode: \"math\",\n            body\n          };\n        }\n      } else {\n        // If it wasn't ^, _, or ', stop parsing super/subscripts\n        break;\n      }\n    } // Base must be set if superscript or subscript are set per logic above,\n    // but need to check here for type check to pass.\n\n\n    if (superscript || subscript) {\n      // If we got either a superscript or subscript, create a supsub\n      return {\n        type: \"supsub\",\n        mode: this.mode,\n        base: base,\n        sup: superscript,\n        sub: subscript\n      };\n    } else {\n      // Otherwise return the original body\n      return base;\n    }\n  }\n  /**\n   * Parses an entire function, including its base and all of its arguments.\n   */\n\n\n  parseFunction(breakOnTokenText, name // For determining its context\n  ) {\n    var token = this.fetch();\n    var func = token.text;\n    var funcData = functions[func];\n\n    if (!funcData) {\n      return null;\n    }\n\n    this.consume(); // consume command token\n\n    if (name && name !== \"atom\" && !funcData.allowedInArgument) {\n      throw new ParseError(\"Got function '\" + func + \"' with no arguments\" + (name ? \" as \" + name : \"\"), token);\n    } else if (this.mode === \"text\" && !funcData.allowedInText) {\n      throw new ParseError(\"Can't use function '\" + func + \"' in text mode\", token);\n    } else if (this.mode === \"math\" && funcData.allowedInMath === false) {\n      throw new ParseError(\"Can't use function '\" + func + \"' in math mode\", token);\n    }\n\n    var {\n      args,\n      optArgs\n    } = this.parseArguments(func, funcData);\n    return this.callFunction(func, args, optArgs, token, breakOnTokenText);\n  }\n  /**\n   * Call a function handler with a suitable context and arguments.\n   */\n\n\n  callFunction(name, args, optArgs, token, breakOnTokenText) {\n    var context = {\n      funcName: name,\n      parser: this,\n      token,\n      breakOnTokenText\n    };\n    var func = functions[name];\n\n    if (func && func.handler) {\n      return func.handler(context, args, optArgs);\n    } else {\n      throw new ParseError(\"No function handler for \" + name);\n    }\n  }\n  /**\n   * Parses the arguments of a function or environment\n   */\n\n\n  parseArguments(func, // Should look like \"\\name\" or \"\\begin{name}\".\n  funcData) {\n    var totalArgs = funcData.numArgs + funcData.numOptionalArgs;\n\n    if (totalArgs === 0) {\n      return {\n        args: [],\n        optArgs: []\n      };\n    }\n\n    var args = [];\n    var optArgs = [];\n\n    for (var i = 0; i < totalArgs; i++) {\n      var argType = funcData.argTypes && funcData.argTypes[i];\n      var isOptional = i < funcData.numOptionalArgs;\n\n      if (funcData.primitive && argType == null || // \\sqrt expands into primitive if optional argument doesn't exist\n      funcData.type === \"sqrt\" && i === 1 && optArgs[0] == null) {\n        argType = \"primitive\";\n      }\n\n      var arg = this.parseGroupOfType(\"argument to '\" + func + \"'\", argType, isOptional);\n\n      if (isOptional) {\n        optArgs.push(arg);\n      } else if (arg != null) {\n        args.push(arg);\n      } else {\n        // should be unreachable\n        throw new ParseError(\"Null argument, please report this as a bug\");\n      }\n    }\n\n    return {\n      args,\n      optArgs\n    };\n  }\n  /**\n   * Parses a group when the mode is changing.\n   */\n\n\n  parseGroupOfType(name, type, optional) {\n    switch (type) {\n      case \"color\":\n        return this.parseColorGroup(optional);\n\n      case \"size\":\n        return this.parseSizeGroup(optional);\n\n      case \"url\":\n        return this.parseUrlGroup(optional);\n\n      case \"math\":\n      case \"text\":\n        return this.parseArgumentGroup(optional, type);\n\n      case \"hbox\":\n        {\n          // hbox argument type wraps the argument in the equivalent of\n          // \\hbox, which is like \\text but switching to \\textstyle size.\n          var group = this.parseArgumentGroup(optional, \"text\");\n          return group != null ? {\n            type: \"styling\",\n            mode: group.mode,\n            body: [group],\n            style: \"text\" // simulate \\textstyle\n\n          } : null;\n        }\n\n      case \"raw\":\n        {\n          var token = this.parseStringGroup(\"raw\", optional);\n          return token != null ? {\n            type: \"raw\",\n            mode: \"text\",\n            string: token.text\n          } : null;\n        }\n\n      case \"primitive\":\n        {\n          if (optional) {\n            throw new ParseError(\"A primitive argument cannot be optional\");\n          }\n\n          var _group = this.parseGroup(name);\n\n          if (_group == null) {\n            throw new ParseError(\"Expected group as \" + name, this.fetch());\n          }\n\n          return _group;\n        }\n\n      case \"original\":\n      case null:\n      case undefined:\n        return this.parseArgumentGroup(optional);\n\n      default:\n        throw new ParseError(\"Unknown group type as \" + name, this.fetch());\n    }\n  }\n  /**\n   * Discard any space tokens, fetching the next non-space token.\n   */\n\n\n  consumeSpaces() {\n    while (this.fetch().text === \" \") {\n      this.consume();\n    }\n  }\n  /**\n   * Parses a group, essentially returning the string formed by the\n   * brace-enclosed tokens plus some position information.\n   */\n\n\n  parseStringGroup(modeName, // Used to describe the mode in error messages.\n  optional) {\n    var argToken = this.gullet.scanArgument(optional);\n\n    if (argToken == null) {\n      return null;\n    }\n\n    var str = \"\";\n    var nextToken;\n\n    while ((nextToken = this.fetch()).text !== \"EOF\") {\n      str += nextToken.text;\n      this.consume();\n    }\n\n    this.consume(); // consume the end of the argument\n\n    argToken.text = str;\n    return argToken;\n  }\n  /**\n   * Parses a regex-delimited group: the largest sequence of tokens\n   * whose concatenated strings match `regex`. Returns the string\n   * formed by the tokens plus some position information.\n   */\n\n\n  parseRegexGroup(regex, modeName // Used to describe the mode in error messages.\n  ) {\n    var firstToken = this.fetch();\n    var lastToken = firstToken;\n    var str = \"\";\n    var nextToken;\n\n    while ((nextToken = this.fetch()).text !== \"EOF\" && regex.test(str + nextToken.text)) {\n      lastToken = nextToken;\n      str += lastToken.text;\n      this.consume();\n    }\n\n    if (str === \"\") {\n      throw new ParseError(\"Invalid \" + modeName + \": '\" + firstToken.text + \"'\", firstToken);\n    }\n\n    return firstToken.range(lastToken, str);\n  }\n  /**\n   * Parses a color description.\n   */\n\n\n  parseColorGroup(optional) {\n    var res = this.parseStringGroup(\"color\", optional);\n\n    if (res == null) {\n      return null;\n    }\n\n    var match = /^(#[a-f0-9]{3}|#?[a-f0-9]{6}|[a-z]+)$/i.exec(res.text);\n\n    if (!match) {\n      throw new ParseError(\"Invalid color: '\" + res.text + \"'\", res);\n    }\n\n    var color = match[0];\n\n    if (/^[0-9a-f]{6}$/i.test(color)) {\n      // We allow a 6-digit HTML color spec without a leading \"#\".\n      // This follows the xcolor package's HTML color model.\n      // Predefined color names are all missed by this RegEx pattern.\n      color = \"#\" + color;\n    }\n\n    return {\n      type: \"color-token\",\n      mode: this.mode,\n      color\n    };\n  }\n  /**\n   * Parses a size specification, consisting of magnitude and unit.\n   */\n\n\n  parseSizeGroup(optional) {\n    var res;\n    var isBlank = false; // don't expand before parseStringGroup\n\n    this.gullet.consumeSpaces();\n\n    if (!optional && this.gullet.future().text !== \"{\") {\n      res = this.parseRegexGroup(/^[-+]? *(?:$|\\d+|\\d+\\.\\d*|\\.\\d*) *[a-z]{0,2} *$/, \"size\");\n    } else {\n      res = this.parseStringGroup(\"size\", optional);\n    }\n\n    if (!res) {\n      return null;\n    }\n\n    if (!optional && res.text.length === 0) {\n      // Because we've tested for what is !optional, this block won't\n      // affect \\kern, \\hspace, etc. It will capture the mandatory arguments\n      // to \\genfrac and \\above.\n      res.text = \"0pt\"; // Enable \\above{}\n\n      isBlank = true; // This is here specifically for \\genfrac\n    }\n\n    var match = /([-+]?) *(\\d+(?:\\.\\d*)?|\\.\\d+) *([a-z]{2})/.exec(res.text);\n\n    if (!match) {\n      throw new ParseError(\"Invalid size: '\" + res.text + \"'\", res);\n    }\n\n    var data = {\n      number: +(match[1] + match[2]),\n      // sign + magnitude, cast to number\n      unit: match[3]\n    };\n\n    if (!validUnit(data)) {\n      throw new ParseError(\"Invalid unit: '\" + data.unit + \"'\", res);\n    }\n\n    return {\n      type: \"size\",\n      mode: this.mode,\n      value: data,\n      isBlank\n    };\n  }\n  /**\n   * Parses an URL, checking escaped letters and allowed protocols,\n   * and setting the catcode of % as an active character (as in \\hyperref).\n   */\n\n\n  parseUrlGroup(optional) {\n    this.gullet.lexer.setCatcode(\"%\", 13); // active character\n\n    this.gullet.lexer.setCatcode(\"~\", 12); // other character\n\n    var res = this.parseStringGroup(\"url\", optional);\n    this.gullet.lexer.setCatcode(\"%\", 14); // comment character\n\n    this.gullet.lexer.setCatcode(\"~\", 13); // active character\n\n    if (res == null) {\n      return null;\n    } // hyperref package allows backslashes alone in href, but doesn't\n    // generate valid links in such cases; we interpret this as\n    // \"undefined\" behaviour, and keep them as-is. Some browser will\n    // replace backslashes with forward slashes.\n\n\n    var url = res.text.replace(/\\\\([#$%&~_^{}])/g, '$1');\n    return {\n      type: \"url\",\n      mode: this.mode,\n      url\n    };\n  }\n  /**\n   * Parses an argument with the mode specified.\n   */\n\n\n  parseArgumentGroup(optional, mode) {\n    var argToken = this.gullet.scanArgument(optional);\n\n    if (argToken == null) {\n      return null;\n    }\n\n    var outerMode = this.mode;\n\n    if (mode) {\n      // Switch to specified mode\n      this.switchMode(mode);\n    }\n\n    this.gullet.beginGroup();\n    var expression = this.parseExpression(false, \"EOF\"); // TODO: find an alternative way to denote the end\n\n    this.expect(\"EOF\"); // expect the end of the argument\n\n    this.gullet.endGroup();\n    var result = {\n      type: \"ordgroup\",\n      mode: this.mode,\n      loc: argToken.loc,\n      body: expression\n    };\n\n    if (mode) {\n      // Switch mode back\n      this.switchMode(outerMode);\n    }\n\n    return result;\n  }\n  /**\n   * Parses an ordinary group, which is either a single nucleus (like \"x\")\n   * or an expression in braces (like \"{x+y}\") or an implicit group, a group\n   * that starts at the current position, and ends right before a higher explicit\n   * group ends, or at EOF.\n   */\n\n\n  parseGroup(name, // For error reporting.\n  breakOnTokenText) {\n    var firstToken = this.fetch();\n    var text = firstToken.text;\n    var result; // Try to parse an open brace or \\begingroup\n\n    if (text === \"{\" || text === \"\\\\begingroup\") {\n      this.consume();\n      var groupEnd = text === \"{\" ? \"}\" : \"\\\\endgroup\";\n      this.gullet.beginGroup(); // If we get a brace, parse an expression\n\n      var expression = this.parseExpression(false, groupEnd);\n      var lastToken = this.fetch();\n      this.expect(groupEnd); // Check that we got a matching closing brace\n\n      this.gullet.endGroup();\n      result = {\n        type: \"ordgroup\",\n        mode: this.mode,\n        loc: SourceLocation.range(firstToken, lastToken),\n        body: expression,\n        // A group formed by \\begingroup...\\endgroup is a semi-simple group\n        // which doesn't affect spacing in math mode, i.e., is transparent.\n        // https://tex.stackexchange.com/questions/1930/when-should-one-\n        // use-begingroup-instead-of-bgroup\n        semisimple: text === \"\\\\begingroup\" || undefined\n      };\n    } else {\n      // If there exists a function with this name, parse the function.\n      // Otherwise, just return a nucleus\n      result = this.parseFunction(breakOnTokenText, name) || this.parseSymbol();\n\n      if (result == null && text[0] === \"\\\\\" && !implicitCommands.hasOwnProperty(text)) {\n        if (this.settings.throwOnError) {\n          throw new ParseError(\"Undefined control sequence: \" + text, firstToken);\n        }\n\n        result = this.formatUnsupportedCmd(text);\n        this.consume();\n      }\n    }\n\n    return result;\n  }\n  /**\n   * Form ligature-like combinations of characters for text mode.\n   * This includes inputs like \"--\", \"---\", \"``\" and \"''\".\n   * The result will simply replace multiple textord nodes with a single\n   * character in each value by a single textord node having multiple\n   * characters in its value.  The representation is still ASCII source.\n   * The group will be modified in place.\n   */\n\n\n  formLigatures(group) {\n    var n = group.length - 1;\n\n    for (var i = 0; i < n; ++i) {\n      var a = group[i]; // $FlowFixMe: Not every node type has a `text` property.\n\n      var v = a.text;\n\n      if (v === \"-\" && group[i + 1].text === \"-\") {\n        if (i + 1 < n && group[i + 2].text === \"-\") {\n          group.splice(i, 3, {\n            type: \"textord\",\n            mode: \"text\",\n            loc: SourceLocation.range(a, group[i + 2]),\n            text: \"---\"\n          });\n          n -= 2;\n        } else {\n          group.splice(i, 2, {\n            type: \"textord\",\n            mode: \"text\",\n            loc: SourceLocation.range(a, group[i + 1]),\n            text: \"--\"\n          });\n          n -= 1;\n        }\n      }\n\n      if ((v === \"'\" || v === \"`\") && group[i + 1].text === v) {\n        group.splice(i, 2, {\n          type: \"textord\",\n          mode: \"text\",\n          loc: SourceLocation.range(a, group[i + 1]),\n          text: v + v\n        });\n        n -= 1;\n      }\n    }\n  }\n  /**\n   * Parse a single symbol out of the string. Here, we handle single character\n   * symbols and special functions like \\verb.\n   */\n\n\n  parseSymbol() {\n    var nucleus = this.fetch();\n    var text = nucleus.text;\n\n    if (/^\\\\verb[^a-zA-Z]/.test(text)) {\n      this.consume();\n      var arg = text.slice(5);\n      var star = arg.charAt(0) === \"*\";\n\n      if (star) {\n        arg = arg.slice(1);\n      } // Lexer's tokenRegex is constructed to always have matching\n      // first/last characters.\n\n\n      if (arg.length < 2 || arg.charAt(0) !== arg.slice(-1)) {\n        throw new ParseError(\"\\\\verb assertion failed --\\n                    please report what input caused this bug\");\n      }\n\n      arg = arg.slice(1, -1); // remove first and last char\n\n      return {\n        type: \"verb\",\n        mode: \"text\",\n        body: arg,\n        star\n      };\n    } // At this point, we should have a symbol, possibly with accents.\n    // First expand any accented base symbol according to unicodeSymbols.\n\n\n    if (unicodeSymbols.hasOwnProperty(text[0]) && !symbols[this.mode][text[0]]) {\n      // This behavior is not strict (XeTeX-compatible) in math mode.\n      if (this.settings.strict && this.mode === \"math\") {\n        this.settings.reportNonstrict(\"unicodeTextInMathMode\", \"Accented Unicode text character \\\"\" + text[0] + \"\\\" used in \" + \"math mode\", nucleus);\n      }\n\n      text = unicodeSymbols[text[0]] + text.slice(1);\n    } // Strip off any combining characters\n\n\n    var match = combiningDiacriticalMarksEndRegex.exec(text);\n\n    if (match) {\n      text = text.substring(0, match.index);\n\n      if (text === 'i') {\n        text = '\\u0131'; // dotless i, in math and text mode\n      } else if (text === 'j') {\n        text = '\\u0237'; // dotless j, in math and text mode\n      }\n    } // Recognize base symbol\n\n\n    var symbol;\n\n    if (symbols[this.mode][text]) {\n      if (this.settings.strict && this.mode === 'math' && extraLatin.indexOf(text) >= 0) {\n        this.settings.reportNonstrict(\"unicodeTextInMathMode\", \"Latin-1/Unicode text character \\\"\" + text[0] + \"\\\" used in \" + \"math mode\", nucleus);\n      }\n\n      var group = symbols[this.mode][text].group;\n      var loc = SourceLocation.range(nucleus);\n      var s;\n\n      if (ATOMS.hasOwnProperty(group)) {\n        // $FlowFixMe\n        var family = group;\n        s = {\n          type: \"atom\",\n          mode: this.mode,\n          family,\n          loc,\n          text\n        };\n      } else {\n        // $FlowFixMe\n        s = {\n          type: group,\n          mode: this.mode,\n          loc,\n          text\n        };\n      } // $FlowFixMe\n\n\n      symbol = s;\n    } else if (text.charCodeAt(0) >= 0x80) {\n      // no symbol for e.g. ^\n      if (this.settings.strict) {\n        if (!supportedCodepoint(text.charCodeAt(0))) {\n          this.settings.reportNonstrict(\"unknownSymbol\", \"Unrecognized Unicode character \\\"\" + text[0] + \"\\\"\" + (\" (\" + text.charCodeAt(0) + \")\"), nucleus);\n        } else if (this.mode === \"math\") {\n          this.settings.reportNonstrict(\"unicodeTextInMathMode\", \"Unicode text character \\\"\" + text[0] + \"\\\" used in math mode\", nucleus);\n        }\n      } // All nonmathematical Unicode characters are rendered as if they\n      // are in text mode (wrapped in \\text) because that's what it\n      // takes to render them in LaTeX.  Setting `mode: this.mode` is\n      // another natural choice (the user requested math mode), but\n      // this makes it more difficult for getCharacterMetrics() to\n      // distinguish Unicode characters without metrics and those for\n      // which we want to simulate the letter M.\n\n\n      symbol = {\n        type: \"textord\",\n        mode: \"text\",\n        loc: SourceLocation.range(nucleus),\n        text\n      };\n    } else {\n      return null; // EOF, ^, _, {, }, etc.\n    }\n\n    this.consume(); // Transform combining characters into accents\n\n    if (match) {\n      for (var i = 0; i < match[0].length; i++) {\n        var accent = match[0][i];\n\n        if (!unicodeAccents[accent]) {\n          throw new ParseError(\"Unknown accent ' \" + accent + \"'\", nucleus);\n        }\n\n        var command = unicodeAccents[accent][this.mode] || unicodeAccents[accent].text;\n\n        if (!command) {\n          throw new ParseError(\"Accent \" + accent + \" unsupported in \" + this.mode + \" mode\", nucleus);\n        }\n\n        symbol = {\n          type: \"accent\",\n          mode: this.mode,\n          loc: SourceLocation.range(nucleus),\n          label: command,\n          isStretchy: false,\n          isShifty: true,\n          // $FlowFixMe\n          base: symbol\n        };\n      }\n    } // $FlowFixMe\n\n\n    return symbol;\n  }\n\n}\nParser.endOfExpression = [\"}\", \"\\\\endgroup\", \"\\\\end\", \"\\\\right\", \"&\"];\n\n/**\n * Provides a single function for parsing an expression using a Parser\n * TODO(emily): Remove this\n */\n\n/**\n * Parses an expression using a Parser, then returns the parsed result.\n */\nvar parseTree = function parseTree(toParse, settings) {\n  if (!(typeof toParse === 'string' || toParse instanceof String)) {\n    throw new TypeError('KaTeX can only parse string typed expression');\n  }\n\n  var parser = new Parser(toParse, settings); // Blank out any \\df@tag to avoid spurious \"Duplicate \\tag\" errors\n\n  delete parser.gullet.macros.current[\"\\\\df@tag\"];\n  var tree = parser.parse(); // Prevent a color definition from persisting between calls to katex.render().\n\n  delete parser.gullet.macros.current[\"\\\\current@color\"];\n  delete parser.gullet.macros.current[\"\\\\color\"]; // If the input used \\tag, it will set the \\df@tag macro to the tag.\n  // In this case, we separately parse the tag and wrap the tree.\n\n  if (parser.gullet.macros.get(\"\\\\df@tag\")) {\n    if (!settings.displayMode) {\n      throw new ParseError(\"\\\\tag works only in display equations\");\n    }\n\n    tree = [{\n      type: \"tag\",\n      mode: \"text\",\n      body: tree,\n      tag: parser.subparse([new Token(\"\\\\df@tag\")])\n    }];\n  }\n\n  return tree;\n};\n\n/* eslint no-console:0 */\n\n/**\n * Parse and build an expression, and place that expression in the DOM node\n * given.\n */\nvar render = function render(expression, baseNode, options) {\n  baseNode.textContent = \"\";\n  var node = renderToDomTree(expression, options).toNode();\n  baseNode.appendChild(node);\n}; // KaTeX's styles don't work properly in quirks mode. Print out an error, and\n// disable rendering.\n\n\nif (typeof document !== \"undefined\") {\n  if (document.compatMode !== \"CSS1Compat\") {\n    typeof console !== \"undefined\" && console.warn(\"Warning: KaTeX doesn't work in quirks mode. Make sure your \" + \"website has a suitable doctype.\");\n\n    render = function render() {\n      throw new ParseError(\"KaTeX doesn't work in quirks mode.\");\n    };\n  }\n}\n/**\n * Parse and build an expression, and return the markup for that.\n */\n\n\nvar renderToString = function renderToString(expression, options) {\n  var markup = renderToDomTree(expression, options).toMarkup();\n  return markup;\n};\n/**\n * Parse an expression and return the parse tree.\n */\n\n\nvar generateParseTree = function generateParseTree(expression, options) {\n  var settings = new Settings(options);\n  return parseTree(expression, settings);\n};\n/**\n * If the given error is a KaTeX ParseError and options.throwOnError is false,\n * renders the invalid LaTeX as a span with hover title giving the KaTeX\n * error message.  Otherwise, simply throws the error.\n */\n\n\nvar renderError = function renderError(error, expression, options) {\n  if (options.throwOnError || !(error instanceof ParseError)) {\n    throw error;\n  }\n\n  var node = buildCommon.makeSpan([\"katex-error\"], [new SymbolNode(expression)]);\n  node.setAttribute(\"title\", error.toString());\n  node.setAttribute(\"style\", \"color:\" + options.errorColor);\n  return node;\n};\n/**\n * Generates and returns the katex build tree. This is used for advanced\n * use cases (like rendering to custom output).\n */\n\n\nvar renderToDomTree = function renderToDomTree(expression, options) {\n  var settings = new Settings(options);\n\n  try {\n    var tree = parseTree(expression, settings);\n    return buildTree(tree, expression, settings);\n  } catch (error) {\n    return renderError(error, expression, settings);\n  }\n};\n/**\n * Generates and returns the katex build tree, with just HTML (no MathML).\n * This is used for advanced use cases (like rendering to custom output).\n */\n\n\nvar renderToHTMLTree = function renderToHTMLTree(expression, options) {\n  var settings = new Settings(options);\n\n  try {\n    var tree = parseTree(expression, settings);\n    return buildHTMLTree(tree, expression, settings);\n  } catch (error) {\n    return renderError(error, expression, settings);\n  }\n};\n\nvar version = \"0.16.21\";\nvar __domTree = {\n  Span,\n  Anchor,\n  SymbolNode,\n  SvgNode,\n  PathNode,\n  LineNode\n}; // ESM exports\n\nvar katex = {\n  /**\n   * Current KaTeX version\n   */\n  version,\n\n  /**\n   * Renders the given LaTeX into an HTML+MathML combination, and adds\n   * it as a child to the specified DOM node.\n   */\n  render,\n\n  /**\n   * Renders the given LaTeX into an HTML+MathML combination string,\n   * for sending to the client.\n   */\n  renderToString,\n\n  /**\n   * KaTeX error, usually during parsing.\n   */\n  ParseError,\n\n  /**\n   * The schema of Settings\n   */\n  SETTINGS_SCHEMA,\n\n  /**\n   * Parses the given LaTeX into KaTeX's internal parse tree structure,\n   * without rendering to HTML or MathML.\n   *\n   * NOTE: This method is not currently recommended for public use.\n   * The internal tree representation is unstable and is very likely\n   * to change. Use at your own risk.\n   */\n  __parse: generateParseTree,\n\n  /**\n   * Renders the given LaTeX into an HTML+MathML internal DOM tree\n   * representation, without flattening that representation to a string.\n   *\n   * NOTE: This method is not currently recommended for public use.\n   * The internal tree representation is unstable and is very likely\n   * to change. Use at your own risk.\n   */\n  __renderToDomTree: renderToDomTree,\n\n  /**\n   * Renders the given LaTeX into an HTML internal DOM tree representation,\n   * without MathML and without flattening that representation to a string.\n   *\n   * NOTE: This method is not currently recommended for public use.\n   * The internal tree representation is unstable and is very likely\n   * to change. Use at your own risk.\n   */\n  __renderToHTMLTree: renderToHTMLTree,\n\n  /**\n   * extends internal font metrics object with a new object\n   * each key in the new object represents a font name\n  */\n  __setFontMetrics: setFontMetrics,\n\n  /**\n   * adds a new symbol to builtin symbols table\n   */\n  __defineSymbol: defineSymbol,\n\n  /**\n   * adds a new function to builtin function list,\n   * which directly produce parse tree elements\n   * and have their own html/mathml builders\n   */\n  __defineFunction: defineFunction,\n\n  /**\n   * adds a new macro to builtin macro list\n   */\n  __defineMacro: defineMacro,\n\n  /**\n   * Expose the dom tree node types, which can be useful for type checking nodes.\n   *\n   * NOTE: These methods are not currently recommended for public use.\n   * The internal tree representation is unstable and is very likely\n   * to change. Use at your own risk.\n   */\n  __domTree\n};\n\nexport { ParseError, SETTINGS_SCHEMA, defineFunction as __defineFunction, defineMacro as __defineMacro, defineSymbol as __defineSymbol, __domTree, generateParseTree as __parse, renderToDomTree as __renderToDomTree, renderToHTMLTree as __renderToHTMLTree, setFontMetrics as __setFontMetrics, katex as default, render, renderToString, version };\n","import { Options, tokenize } from 'linkifyjs';\n\nconst HTML_NODE = 1,\n  TXT_NODE = 3;\n\n/**\n * @param {HTMLElement} parent\n * @param {Text | HTMLElement | ChildNode} oldChild\n * @param {Array<Text | HTMLElement>} newChildren\n */\nfunction replaceChildWithChildren(parent, oldChild, newChildren) {\n  let lastNewChild = newChildren[newChildren.length - 1];\n  parent.replaceChild(lastNewChild, oldChild);\n  for (let i = newChildren.length - 2; i >= 0; i--) {\n    parent.insertBefore(newChildren[i], lastNewChild);\n    lastNewChild = newChildren[i];\n  }\n}\n\n/**\n * @param {import('linkifyjs').MultiToken[]} tokens\n * @param {import('linkifyjs').Options} options\n * @param {Document} doc Document implementation\n * @returns {Array<Text | HTMLElement>}\n */\nfunction tokensToNodes(tokens, options, doc) {\n  const result = [];\n  for (let i = 0; i < tokens.length; i++) {\n    const token = tokens[i];\n    if (token.t === 'nl' && options.get('nl2br')) {\n      result.push(doc.createElement('br'));\n    } else if (!token.isLink || !options.check(token)) {\n      result.push(doc.createTextNode(token.toString()));\n    } else {\n      result.push(options.render(token));\n    }\n  }\n  return result;\n}\n\n/**\n * Requires document.createElement\n * @param {HTMLElement | ChildNode} element\n * @param {import('linkifyjs').Options} options\n * @param {Document} doc\n * @returns {HTMLElement}\n */\nfunction linkifyElementHelper(element, options, doc) {\n  // Can the element be linkified?\n  if (!element || element.nodeType !== HTML_NODE) {\n    throw new Error(`Cannot linkify ${element} - Invalid DOM Node type`);\n  }\n\n  // Is this element already a link?\n  if (element.tagName === 'A' || options.ignoreTags.indexOf(element.tagName) >= 0) {\n    // No need to linkify\n    return element;\n  }\n  let childElement = element.firstChild;\n  while (childElement) {\n    let str, tokens, nodes;\n    switch (childElement.nodeType) {\n      case HTML_NODE:\n        linkifyElementHelper(childElement, options, doc);\n        break;\n      case TXT_NODE:\n        {\n          str = childElement.nodeValue;\n          tokens = tokenize(str);\n          if (tokens.length === 0 || tokens.length === 1 && tokens[0].t === 'text') {\n            // No node replacement required\n            break;\n          }\n          nodes = tokensToNodes(tokens, options, doc);\n\n          // Swap out the current child for the set of nodes\n          replaceChildWithChildren(element, childElement, nodes);\n\n          // so that the correct sibling is selected next\n          childElement = nodes[nodes.length - 1];\n          break;\n        }\n    }\n    childElement = childElement.nextSibling;\n  }\n  return element;\n}\n\n/**\n * @param {Document} doc The document implementaiton\n */\nfunction getDefaultRender(doc) {\n  return ({\n    tagName,\n    attributes,\n    content,\n    eventListeners\n  }) => {\n    const link = doc.createElement(tagName);\n    for (const attr in attributes) {\n      link.setAttribute(attr, attributes[attr]);\n    }\n    if (eventListeners && link.addEventListener) {\n      for (const event in eventListeners) {\n        link.addEventListener(event, eventListeners[event]);\n      }\n    }\n    link.appendChild(doc.createTextNode(content));\n    return link;\n  };\n}\n\n/**\n * Recursively traverse the given DOM node, find all links in the text and\n * convert them to anchor tags.\n *\n * @param {HTMLElement} element A DOM node to linkify\n * @param {import('linkifyjs').Opts} [opts] linkify options\n * @param {Document} [doc] (optional) window.document implementation, if differs from global\n * @returns {HTMLElement}\n */\nfunction linkifyElement(element, opts = null, doc = null) {\n  try {\n    doc = doc || document || window && window.document || global && global.document;\n  } catch (_) {/* do nothing for now */}\n  if (!doc) {\n    throw new Error('Cannot find document implementation. ' + 'If you are in a non-browser environment like Node.js, ' + 'pass the document implementation as the third argument to linkifyElement.');\n  }\n  const options = new Options(opts, getDefaultRender(doc));\n  return linkifyElementHelper(element, options, doc);\n}\n\n// Maintain reference to the recursive helper and option-normalization for use\n// in linkify-jquery\nlinkifyElement.helper = linkifyElementHelper;\nlinkifyElement.getDefaultRender = getDefaultRender;\n\n/**\n * @param {import('linkifyjs').Opts | import('linkifyjs').Options} opts\n * @param {Document} doc\n */\nlinkifyElement.normalize = (opts, doc) => new Options(opts, getDefaultRender(doc));\n\nexport { linkifyElement as default };\n","import * as React from 'react';\nimport { Options, options, tokenize } from 'linkifyjs';\n\n/**\n * Given a string, converts to an array of valid React components\n * (which may include strings)\n * @param {string} str\n * @param {Options} opts\n * @param {{ [elementId: string]: number }} meta\n * @returns {React.ReactNodeArray}\n */\nfunction stringToElements(str, opts, meta) {\n  const tokens = tokenize(str);\n  const elements = [];\n  for (let i = 0; i < tokens.length; i++) {\n    const token = tokens[i];\n    if (token.t === 'nl' && opts.get('nl2br')) {\n      const key = `__linkify-el-${meta.elementId++}`;\n      elements.push(React.createElement('br', {\n        key\n      }));\n    } else if (!token.isLink || !opts.check(token)) {\n      // Regular text\n      elements.push(token.toString());\n    } else {\n      let rendered = opts.render(token);\n      if (!('key' in rendered.props)) {\n        // Ensure generated element has unique key\n        const key = `__linkify-el-${meta.elementId++}`;\n        const props = options.assign({\n          key\n        }, rendered.props);\n        rendered = React.cloneElement(rendered, props);\n      }\n      elements.push(rendered);\n    }\n  }\n  return elements;\n}\n\n// Recursively linkify the contents of the given React Element instance\n/**\n * @template P\n * @template {string | React.JSXElementConstructor<P>} T\n * @param {React.ReactElement<P, T>} element\n * @param {Options} opts\n * @param {{ [elementId: string]: number }} meta\n * @returns {React.ReactElement<P, T>}\n */\nfunction linkifyReactElement(element, opts, meta) {\n  if (React.Children.count(element.props.children) === 0) {\n    // No need to clone if the element had no children\n    return element;\n  }\n  const children = [];\n  React.Children.forEach(element.props.children, child => {\n    if (typeof child === 'string') {\n      // ensure that we always generate unique element IDs for keys\n      children.push.apply(children, stringToElements(child, opts, meta));\n    } else if (React.isValidElement(child)) {\n      if (typeof child.type === 'string' && opts.ignoreTags.indexOf(child.type.toUpperCase()) >= 0) {\n        // Don't linkify this element\n        children.push(child);\n      } else {\n        children.push(linkifyReactElement(child, opts, meta));\n      }\n    } else {\n      // Unknown element type, just push\n      children.push(child);\n    }\n  });\n\n  // Set a default unique key, copy over remaining props\n  const key = `__linkify-el-${meta.elementId++}`;\n  const newProps = options.assign({\n    key\n  }, element.props);\n  return React.cloneElement(element, newProps, children);\n}\n\n/**\n * @template P\n * @template {string | React.JSXElementConstructor<P>} T\n * @param {P & { as?: T, tagName?: T, options?: import('linkifyjs').Opts, children?: React.ReactNode}} props\n * @returns {React.ReactElement<P, T>}\n */\nconst Linkify = props => {\n  // Copy over all non-linkify-specific props\n  let linkId = 0;\n  const defaultLinkRender = ({\n    tagName,\n    attributes,\n    content\n  }) => {\n    attributes.key = `__linkify-lnk-${linkId++}`;\n    if (attributes.class) {\n      attributes.className = attributes.class;\n      delete attributes.class;\n    }\n    return React.createElement(tagName, attributes, content);\n  };\n  const newProps = {\n    key: '__linkify-wrapper'\n  };\n  for (const prop in props) {\n    if (prop !== 'options' && prop !== 'as' && prop !== 'tagName' && prop !== 'children') {\n      newProps[prop] = props[prop];\n    }\n  }\n  const opts = new Options(props.options, defaultLinkRender);\n  const as = props.as || props.tagName || React.Fragment || 'span';\n  const children = props.children;\n  const element = React.createElement(as, newProps, children);\n  return linkifyReactElement(element, opts, {\n    elementId: 0\n  });\n};\n\nexport { Linkify as default };\n","import { Options, tokenize } from 'linkifyjs';\n\n/**\n\tConvert strings of text into linkable HTML text\n*/\nfunction escapeText(text) {\n  return text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');\n}\nfunction escapeAttr(href) {\n  return href.replace(/\"/g, '&quot;');\n}\nfunction attributesToString(attributes) {\n  const result = [];\n  for (const attr in attributes) {\n    let val = attributes[attr] + '';\n    result.push(`${attr}=\"${escapeAttr(val)}\"`);\n  }\n  return result.join(' ');\n}\nfunction defaultRender({\n  tagName,\n  attributes,\n  content\n}) {\n  return `<${tagName} ${attributesToString(attributes)}>${escapeText(content)}</${tagName}>`;\n}\n\n/**\n * Convert a plan text string to an HTML string with links. Expects that the\n * given strings does not contain any HTML entities. Use the linkify-html\n * interface if you need to parse HTML entities.\n *\n * @param {string} str string to linkify\n * @param {import('linkifyjs').Opts} [opts] overridable options\n * @returns {string}\n */\nfunction linkifyStr(str, opts = {}) {\n  opts = new Options(opts, defaultRender);\n  const tokens = tokenize(str);\n  const result = [];\n  for (let i = 0; i < tokens.length; i++) {\n    const token = tokens[i];\n    if (token.t === 'nl' && opts.get('nl2br')) {\n      result.push('<br>\\n');\n    } else if (!token.isLink || !opts.check(token)) {\n      result.push(escapeText(token.toString()));\n    } else {\n      result.push(opts.render(token));\n    }\n  }\n  return result.join('');\n}\nif (!String.prototype.linkify) {\n  Object.defineProperty(String.prototype, 'linkify', {\n    writable: false,\n    value: function linkify(options) {\n      return linkifyStr(this, options);\n    }\n  });\n}\n\nexport { linkifyStr as default };\n","// THIS FILE IS AUTOMATICALLY GENERATED DO NOT EDIT DIRECTLY\n// See update-tlds.js for encoding/decoding format\n// https://data.iana.org/TLD/tlds-alpha-by-domain.txt\nconst encodedTlds = 'aaa1rp3bb0ott3vie4c1le2ogado5udhabi7c0ademy5centure6ountant0s9o1tor4d0s1ult4e0g1ro2tna4f0l1rica5g0akhan5ency5i0g1rbus3force5tel5kdn3l0ibaba4pay4lfinanz6state5y2sace3tom5m0azon4ericanexpress7family11x2fam3ica3sterdam8nalytics7droid5quan4z2o0l2partments8p0le4q0uarelle8r0ab1mco4chi3my2pa2t0e3s0da2ia2sociates9t0hleta5torney7u0ction5di0ble3o3spost5thor3o0s4w0s2x0a2z0ure5ba0by2idu3namex4d1k2r0celona5laycard4s5efoot5gains6seball5ketball8uhaus5yern5b0c1t1va3cg1n2d1e0ats2uty4er2ntley5rlin4st0buy5t2f1g1h0arti5i0ble3d1ke2ng0o3o1z2j1lack0friday9ockbuster8g1omberg7ue3m0s1w2n0pparibas9o0ats3ehringer8fa2m1nd2o0k0ing5sch2tik2on4t1utique6x2r0adesco6idgestone9oadway5ker3ther5ussels7s1t1uild0ers6siness6y1zz3v1w1y1z0h3ca0b1fe2l0l1vinklein9m0era3p2non3petown5ital0one8r0avan4ds2e0er0s4s2sa1e1h1ino4t0ering5holic7ba1n1re3c1d1enter4o1rn3f0a1d2g1h0anel2nel4rity4se2t2eap3intai5ristmas6ome4urch5i0priani6rcle4sco3tadel4i0c2y3k1l0aims4eaning6ick2nic1que6othing5ud3ub0med6m1n1o0ach3des3ffee4llege4ogne5m0mbank4unity6pany2re3uter5sec4ndos3struction8ulting7tact3ractors9oking4l1p2rsica5untry4pon0s4rses6pa2r0edit0card4union9icket5own3s1uise0s6u0isinella9v1w1x1y0mru3ou3z2dad1nce3ta1e1ing3sun4y2clk3ds2e0al0er2s3gree4livery5l1oitte5ta3mocrat6ntal2ist5si0gn4v2hl2iamonds6et2gital5rect0ory7scount3ver5h2y2j1k1m1np2o0cs1tor4g1mains5t1wnload7rive4tv2ubai3nlop4pont4rban5vag2r2z2earth3t2c0o2deka3u0cation8e1g1mail3erck5nergy4gineer0ing9terprises10pson4quipment8r0icsson6ni3s0q1tate5t1u0rovision8s2vents5xchange6pert3osed4ress5traspace10fage2il1rwinds6th3mily4n0s2rm0ers5shion4t3edex3edback6rrari3ero6i0delity5o2lm2nal1nce1ial7re0stone6mdale6sh0ing5t0ness6j1k1lickr3ghts4r2orist4wers5y2m1o0o0d1tball6rd1ex2sale4um3undation8x2r0ee1senius7l1ogans4ntier7tr2ujitsu5n0d2rniture7tbol5yi3ga0l0lery3o1up4me0s3p1rden4y2b0iz3d0n2e0a1nt0ing5orge5f1g0ee3h1i0ft0s3ves2ing5l0ass3e1obal2o4m0ail3bh2o1x2n1odaddy5ld0point6f2o0dyear5g0le4p1t1v2p1q1r0ainger5phics5tis4een3ipe3ocery4up4s1t1u0cci3ge2ide2tars5ru3w1y2hair2mburg5ngout5us3bo2dfc0bank7ealth0care8lp1sinki6re1mes5iphop4samitsu7tachi5v2k0t2m1n1ockey4ldings5iday5medepot5goods5s0ense7nda3rse3spital5t0ing5t0els3mail5use3w2r1sbc3t1u0ghes5yatt3undai7ibm2cbc2e1u2d1e0ee3fm2kano4l1m0amat4db2mo0bilien9n0c1dustries8finiti5o2g1k1stitute6urance4e4t0ernational10uit4vestments10o1piranga7q1r0ish4s0maili5t0anbul7t0au2v3jaguar4va3cb2e0ep2tzt3welry6io2ll2m0p2nj2o0bs1urg4t1y2p0morgan6rs3uegos4niper7kaufen5ddi3e0rryhotels6logistics9properties14fh2g1h1i0a1ds2m1ndle4tchen5wi3m1n1oeln3matsu5sher5p0mg2n2r0d1ed3uokgroup8w1y0oto4z2la0caixa5mborghini8er3ncaster6d0rover6xess5salle5t0ino3robe5w0yer5b1c1ds2ease3clerc5frak4gal2o2xus4gbt3i0dl2fe0insurance9style7ghting6ke2lly3mited4o2ncoln4k2psy3ve1ing5k1lc1p2oan0s3cker3us3l1ndon4tte1o3ve3pl0financial11r1s1t0d0a3u0ndbeck6xe1ury5v1y2ma0drid4if1son4keup4n0agement7go3p1rket0ing3s4riott5shalls7ttel5ba2c0kinsey7d1e0d0ia3et2lbourne7me1orial6n0u2rckmsd7g1h1iami3crosoft7l1ni1t2t0subishi9k1l0b1s2m0a2n1o0bi0le4da2e1i1m1nash3ey2ster5rmon3tgage6scow4to0rcycles9v0ie4p1q1r1s0d2t0n1r2u0seum3ic4v1w1x1y1z2na0b1goya4me2vy3ba2c1e0c1t0bank4flix4work5ustar5w0s2xt0direct7us4f0l2g0o2hk2i0co2ke1on3nja3ssan1y5l1o0kia3rton4w0ruz3tv4p1r0a1w2tt2u1yc2z2obi1server7ffice5kinawa6layan0group9lo3m0ega4ne1g1l0ine5oo2pen3racle3nge4g0anic5igins6saka4tsuka4t2vh3pa0ge2nasonic7ris2s1tners4s1y3y2ccw3e0t2f0izer5g1h0armacy6d1ilips5one2to0graphy6s4ysio5ics1tet2ures6d1n0g1k2oneer5zza4k1l0ace2y0station9umbing5s3m1n0c2ohl2ker3litie5rn2st3r0america6xi3ess3ime3o0d0uctions8f1gressive8mo2perties3y5tection8u0dential9s1t1ub2w0c2y2qa1pon3uebec3st5racing4dio4e0ad1lestate6tor2y4cipes5d0stone5umbrella9hab3ise0n3t2liance6n0t0als5pair3ort3ublican8st0aurant8view0s5xroth6ich0ardli6oh3l1o1p2o0cks3deo3gers4om3s0vp3u0gby3hr2n2w0e2yukyu6sa0arland6fe0ty4kura4le1on3msclub4ung5ndvik0coromant12ofi4p1rl2s1ve2xo3b0i1s2c0b1haeffler7midt4olarships8ol3ule3warz5ience5ot3d1e0arch3t2cure1ity6ek2lect4ner3rvices6ven3w1x0y3fr2g1h0angrila6rp3ell3ia1ksha5oes2p0ping5uji3w3i0lk2na1gles5te3j1k0i0n2y0pe4l0ing4m0art3ile4n0cf3o0ccer3ial4ftbank4ware6hu2lar2utions7ng1y2y2pa0ce3ort2t3r0l2s1t0ada2ples4r1tebank4farm7c0group6ockholm6rage3e3ream4udio2y3yle4u0cks3pplies3y2ort5rf1gery5zuki5v1watch4iss4x1y0dney4stems6z2tab1ipei4lk2obao4rget4tamotors6r2too4x0i3c0i2d0k2eam2ch0nology8l1masek5nnis4va3f1g1h0d1eater2re6iaa2ckets5enda4ps2res2ol4j0maxx4x2k0maxx5l1m0all4n1o0day3kyo3ols3p1ray3shiba5tal3urs3wn2yota3s3r0ade1ing4ining5vel0ers0insurance16ust3v2t1ube2i1nes3shu4v0s2w1z2ua1bank3s2g1k1nicom3versity8o2ol2ps2s1y1z2va0cations7na1guard7c1e0gas3ntures6risign5mögensberater2ung14sicherung10t2g1i0ajes4deo3g1king4llas4n1p1rgin4sa1ion4va1o3laanderen9n1odka3lvo3te1ing3o2yage5u2wales2mart4ter4ng0gou5tch0es6eather0channel12bcam3er2site5d0ding5ibo2r3f1hoswho6ien2ki2lliamhill9n0dows4e1ners6me2olterskluwer11odside6rk0s2ld3w2s1tc1f3xbox3erox4ihuan4n2xx2yz3yachts4hoo3maxun5ndex5e1odobashi7ga2kohama6u0tube6t1un3za0ppos4ra3ero3ip2m1one3uerich6w2';\n// Internationalized domain names containing non-ASCII\nconst encodedUtlds = 'ελ1υ2бг1ел3дети4ею2католик6ом3мкд2он1сква6онлайн5рг3рус2ф2сайт3рб3укр3қаз3հայ3ישראל5קום3ابوظبي5رامكو5لاردن4بحرين5جزائر5سعودية6عليان5مغرب5مارات5یران5بارت2زار4يتك3ھارت5تونس4سودان3رية5شبكة4عراق2ب2مان4فلسطين6قطر3كاثوليك6وم3مصر2ليسيا5وريتانيا7قع4همراه5پاکستان7ڀارت4कॉम3नेट3भारत0म्3ोत5संगठन5বাংলা5ভারত2ৰত4ਭਾਰਤ4ભારત4ଭାରତ4இந்தியா6லங்கை6சிங்கப்பூர்11భారత్5ಭಾರತ4ഭാരതം5ලංකා4คอม3ไทย3ລາວ3გე2みんな3アマゾン4クラウド4グーグル4コム2ストア3セール3ファッション6ポイント4世界2中信1国1國1文网3亚马逊3企业2佛山2信息2健康2八卦2公司1益2台湾1灣2商城1店1标2嘉里0大酒店5在线2大拿2天主教3娱乐2家電2广东2微博2慈善2我爱你3手机2招聘2政务1府2新加坡2闻2时尚2書籍2机构2淡马锡3游戏2澳門2点看2移动2组织机构4网址1店1站1络2联通2谷歌2购物2通販2集团2電訊盈科4飞利浦3食品2餐厅2香格里拉3港2닷넷1컴2삼성2한국2';\n\n/**\n * @template A\n * @template B\n * @param {A} target\n * @param {B} properties\n * @return {A & B}\n */\nconst assign = (target, properties) => {\n  for (const key in properties) {\n    target[key] = properties[key];\n  }\n  return target;\n};\n\n/**\n * Finite State Machine generation utilities\n */\n\n/**\n * @template T\n * @typedef {{ [group: string]: T[] }} Collections\n */\n\n/**\n * @typedef {{ [group: string]: true }} Flags\n */\n\n// Keys in scanner Collections instances\nconst numeric = 'numeric';\nconst ascii = 'ascii';\nconst alpha = 'alpha';\nconst asciinumeric = 'asciinumeric';\nconst alphanumeric = 'alphanumeric';\nconst domain = 'domain';\nconst emoji = 'emoji';\nconst scheme = 'scheme';\nconst slashscheme = 'slashscheme';\nconst whitespace = 'whitespace';\n\n/**\n * @template T\n * @param {string} name\n * @param {Collections<T>} groups to register in\n * @returns {T[]} Current list of tokens in the given collection\n */\nfunction registerGroup(name, groups) {\n  if (!(name in groups)) {\n    groups[name] = [];\n  }\n  return groups[name];\n}\n\n/**\n * @template T\n * @param {T} t token to add\n * @param {Collections<T>} groups\n * @param {Flags} flags\n */\nfunction addToGroups(t, flags, groups) {\n  if (flags[numeric]) {\n    flags[asciinumeric] = true;\n    flags[alphanumeric] = true;\n  }\n  if (flags[ascii]) {\n    flags[asciinumeric] = true;\n    flags[alpha] = true;\n  }\n  if (flags[asciinumeric]) {\n    flags[alphanumeric] = true;\n  }\n  if (flags[alpha]) {\n    flags[alphanumeric] = true;\n  }\n  if (flags[alphanumeric]) {\n    flags[domain] = true;\n  }\n  if (flags[emoji]) {\n    flags[domain] = true;\n  }\n  for (const k in flags) {\n    const group = registerGroup(k, groups);\n    if (group.indexOf(t) < 0) {\n      group.push(t);\n    }\n  }\n}\n\n/**\n * @template T\n * @param {T} t token to check\n * @param {Collections<T>} groups\n * @returns {Flags} group flags that contain this token\n */\nfunction flagsForToken(t, groups) {\n  const result = {};\n  for (const c in groups) {\n    if (groups[c].indexOf(t) >= 0) {\n      result[c] = true;\n    }\n  }\n  return result;\n}\n\n/**\n * @template T\n * @typedef {null | T } Transition\n */\n\n/**\n * Define a basic state machine state. j is the list of character transitions,\n * jr is the list of regex-match transitions, jd is the default state to\n * transition to t is the accepting token type, if any. If this is the terminal\n * state, then it does not emit a token.\n *\n * The template type T represents the type of the token this state accepts. This\n * should be a string (such as of the token exports in `text.js`) or a\n * MultiToken subclass (from `multi.js`)\n *\n * @template T\n * @param {T} [token] Token that this state emits\n */\nfunction State(token = null) {\n  // this.n = null; // DEBUG: State name\n  /** @type {{ [input: string]: State<T> }} j */\n  this.j = {}; // IMPLEMENTATION 1\n  // this.j = []; // IMPLEMENTATION 2\n  /** @type {[RegExp, State<T>][]} jr */\n  this.jr = [];\n  /** @type {?State<T>} jd */\n  this.jd = null;\n  /** @type {?T} t */\n  this.t = token;\n}\n\n/**\n * Scanner token groups\n * @type Collections<string>\n */\nState.groups = {};\nState.prototype = {\n  accepts() {\n    return !!this.t;\n  },\n  /**\n   * Follow an existing transition from the given input to the next state.\n   * Does not mutate.\n   * @param {string} input character or token type to transition on\n   * @returns {?State<T>} the next state, if any\n   */\n  go(input) {\n    const state = this;\n    const nextState = state.j[input];\n    if (nextState) {\n      return nextState;\n    }\n    for (let i = 0; i < state.jr.length; i++) {\n      const regex = state.jr[i][0];\n      const nextState = state.jr[i][1]; // note: might be empty to prevent default jump\n      if (nextState && regex.test(input)) {\n        return nextState;\n      }\n    }\n    // Nowhere left to jump! Return default, if any\n    return state.jd;\n  },\n  /**\n   * Whether the state has a transition for the given input. Set the second\n   * argument to true to only look for an exact match (and not a default or\n   * regular-expression-based transition)\n   * @param {string} input\n   * @param {boolean} exactOnly\n   */\n  has(input, exactOnly = false) {\n    return exactOnly ? input in this.j : !!this.go(input);\n  },\n  /**\n   * Short for \"transition all\"; create a transition from the array of items\n   * in the given list to the same final resulting state.\n   * @param {string | string[]} inputs Group of inputs to transition on\n   * @param {Transition<T> | State<T>} [next] Transition options\n   * @param {Flags} [flags] Collections flags to add token to\n   * @param {Collections<T>} [groups] Master list of token groups\n   */\n  ta(inputs, next, flags, groups) {\n    for (let i = 0; i < inputs.length; i++) {\n      this.tt(inputs[i], next, flags, groups);\n    }\n  },\n  /**\n   * Short for \"take regexp transition\"; defines a transition for this state\n   * when it encounters a token which matches the given regular expression\n   * @param {RegExp} regexp Regular expression transition (populate first)\n   * @param {T | State<T>} [next] Transition options\n   * @param {Flags} [flags] Collections flags to add token to\n   * @param {Collections<T>} [groups] Master list of token groups\n   * @returns {State<T>} taken after the given input\n   */\n  tr(regexp, next, flags, groups) {\n    groups = groups || State.groups;\n    let nextState;\n    if (next && next.j) {\n      nextState = next;\n    } else {\n      // Token with maybe token groups\n      nextState = new State(next);\n      if (flags && groups) {\n        addToGroups(next, flags, groups);\n      }\n    }\n    this.jr.push([regexp, nextState]);\n    return nextState;\n  },\n  /**\n   * Short for \"take transitions\", will take as many sequential transitions as\n   * the length of the given input and returns the\n   * resulting final state.\n   * @param {string | string[]} input\n   * @param {T | State<T>} [next] Transition options\n   * @param {Flags} [flags] Collections flags to add token to\n   * @param {Collections<T>} [groups] Master list of token groups\n   * @returns {State<T>} taken after the given input\n   */\n  ts(input, next, flags, groups) {\n    let state = this;\n    const len = input.length;\n    if (!len) {\n      return state;\n    }\n    for (let i = 0; i < len - 1; i++) {\n      state = state.tt(input[i]);\n    }\n    return state.tt(input[len - 1], next, flags, groups);\n  },\n  /**\n   * Short for \"take transition\", this is a method for building/working with\n   * state machines.\n   *\n   * If a state already exists for the given input, returns it.\n   *\n   * If a token is specified, that state will emit that token when reached by\n   * the linkify engine.\n   *\n   * If no state exists, it will be initialized with some default transitions\n   * that resemble existing default transitions.\n   *\n   * If a state is given for the second argument, that state will be\n   * transitioned to on the given input regardless of what that input\n   * previously did.\n   *\n   * Specify a token group flags to define groups that this token belongs to.\n   * The token will be added to corresponding entires in the given groups\n   * object.\n   *\n   * @param {string} input character, token type to transition on\n   * @param {T | State<T>} [next] Transition options\n   * @param {Flags} [flags] Collections flags to add token to\n   * @param {Collections<T>} [groups] Master list of groups\n   * @returns {State<T>} taken after the given input\n   */\n  tt(input, next, flags, groups) {\n    groups = groups || State.groups;\n    const state = this;\n\n    // Check if existing state given, just a basic transition\n    if (next && next.j) {\n      state.j[input] = next;\n      return next;\n    }\n    const t = next;\n\n    // Take the transition with the usual default mechanisms and use that as\n    // a template for creating the next state\n    let nextState,\n      templateState = state.go(input);\n    if (templateState) {\n      nextState = new State();\n      assign(nextState.j, templateState.j);\n      nextState.jr.push.apply(nextState.jr, templateState.jr);\n      nextState.jd = templateState.jd;\n      nextState.t = templateState.t;\n    } else {\n      nextState = new State();\n    }\n    if (t) {\n      // Ensure newly token is in the same groups as the old token\n      if (groups) {\n        if (nextState.t && typeof nextState.t === 'string') {\n          const allFlags = assign(flagsForToken(nextState.t, groups), flags);\n          addToGroups(t, allFlags, groups);\n        } else if (flags) {\n          addToGroups(t, flags, groups);\n        }\n      }\n      nextState.t = t; // overwrite anything that was previously there\n    }\n    state.j[input] = nextState;\n    return nextState;\n  }\n};\n\n// Helper functions to improve minification (not exported outside linkifyjs module)\n\n/**\n * @template T\n * @param {State<T>} state\n * @param {string | string[]} input\n * @param {Flags} [flags]\n * @param {Collections<T>} [groups]\n */\nconst ta = (state, input, next, flags, groups) => state.ta(input, next, flags, groups);\n\n/**\n * @template T\n * @param {State<T>} state\n * @param {RegExp} regexp\n * @param {T | State<T>} [next]\n * @param {Flags} [flags]\n * @param {Collections<T>} [groups]\n */\nconst tr = (state, regexp, next, flags, groups) => state.tr(regexp, next, flags, groups);\n\n/**\n * @template T\n * @param {State<T>} state\n * @param {string | string[]} input\n * @param {T | State<T>} [next]\n * @param {Flags} [flags]\n * @param {Collections<T>} [groups]\n */\nconst ts = (state, input, next, flags, groups) => state.ts(input, next, flags, groups);\n\n/**\n * @template T\n * @param {State<T>} state\n * @param {string} input\n * @param {T | State<T>} [next]\n * @param {Collections<T>} [groups]\n * @param {Flags} [flags]\n */\nconst tt = (state, input, next, flags, groups) => state.tt(input, next, flags, groups);\n\n/******************************************************************************\nText Tokens\nIdentifiers for token outputs from the regexp scanner\n******************************************************************************/\n\n// A valid web domain token\nconst WORD = 'WORD'; // only contains a-z\nconst UWORD = 'UWORD'; // contains letters other than a-z, used for IDN\nconst ASCIINUMERICAL = 'ASCIINUMERICAL'; // contains a-z, 0-9\nconst ALPHANUMERICAL = 'ALPHANUMERICAL'; // contains numbers and letters other than a-z, used for IDN\n\n// Special case of word\nconst LOCALHOST = 'LOCALHOST';\n\n// Valid top-level domain, special case of WORD (see tlds.js)\nconst TLD = 'TLD';\n\n// Valid IDN TLD, special case of UWORD (see tlds.js)\nconst UTLD = 'UTLD';\n\n// The scheme portion of a web URI protocol. Supported types include: `mailto`,\n// `file`, and user-defined custom protocols. Limited to schemes that contain\n// only letters\nconst SCHEME = 'SCHEME';\n\n// Similar to SCHEME, except makes distinction for schemes that must always be\n// followed by `://`, not just `:`. Supported types include `http`, `https`,\n// `ftp`, `ftps`\nconst SLASH_SCHEME = 'SLASH_SCHEME';\n\n// Any sequence of digits 0-9\nconst NUM = 'NUM';\n\n// Any number of consecutive whitespace characters that are not newline\nconst WS = 'WS';\n\n// New line (unix style)\nconst NL = 'NL'; // \\n\n\n// Opening/closing bracket classes\n// TODO: Rename OPEN -> LEFT and CLOSE -> RIGHT in v5 to fit with Unicode names\n// Also rename angle brackes to LESSTHAN and GREATER THAN\nconst OPENBRACE = 'OPENBRACE'; // {\nconst CLOSEBRACE = 'CLOSEBRACE'; // }\nconst OPENBRACKET = 'OPENBRACKET'; // [\nconst CLOSEBRACKET = 'CLOSEBRACKET'; // ]\nconst OPENPAREN = 'OPENPAREN'; // (\nconst CLOSEPAREN = 'CLOSEPAREN'; // )\nconst OPENANGLEBRACKET = 'OPENANGLEBRACKET'; // <\nconst CLOSEANGLEBRACKET = 'CLOSEANGLEBRACKET'; // >\nconst FULLWIDTHLEFTPAREN = 'FULLWIDTHLEFTPAREN'; // （\nconst FULLWIDTHRIGHTPAREN = 'FULLWIDTHRIGHTPAREN'; // ）\nconst LEFTCORNERBRACKET = 'LEFTCORNERBRACKET'; // 「\nconst RIGHTCORNERBRACKET = 'RIGHTCORNERBRACKET'; // 」\nconst LEFTWHITECORNERBRACKET = 'LEFTWHITECORNERBRACKET'; // 『\nconst RIGHTWHITECORNERBRACKET = 'RIGHTWHITECORNERBRACKET'; // 』\nconst FULLWIDTHLESSTHAN = 'FULLWIDTHLESSTHAN'; // ＜\nconst FULLWIDTHGREATERTHAN = 'FULLWIDTHGREATERTHAN'; // ＞\n\n// Various symbols\nconst AMPERSAND = 'AMPERSAND'; // &\nconst APOSTROPHE = 'APOSTROPHE'; // '\nconst ASTERISK = 'ASTERISK'; // *\nconst AT = 'AT'; // @\nconst BACKSLASH = 'BACKSLASH'; // \\\nconst BACKTICK = 'BACKTICK'; // `\nconst CARET = 'CARET'; // ^\nconst COLON = 'COLON'; // :\nconst COMMA = 'COMMA'; // ,\nconst DOLLAR = 'DOLLAR'; // $\nconst DOT = 'DOT'; // .\nconst EQUALS = 'EQUALS'; // =\nconst EXCLAMATION = 'EXCLAMATION'; // !\nconst HYPHEN = 'HYPHEN'; // -\nconst PERCENT = 'PERCENT'; // %\nconst PIPE = 'PIPE'; // |\nconst PLUS = 'PLUS'; // +\nconst POUND = 'POUND'; // #\nconst QUERY = 'QUERY'; // ?\nconst QUOTE = 'QUOTE'; // \"\nconst FULLWIDTHMIDDLEDOT = 'FULLWIDTHMIDDLEDOT'; // ・\n\nconst SEMI = 'SEMI'; // ;\nconst SLASH = 'SLASH'; // /\nconst TILDE = 'TILDE'; // ~\nconst UNDERSCORE = 'UNDERSCORE'; // _\n\n// Emoji symbol\nconst EMOJI$1 = 'EMOJI';\n\n// Default token - anything that is not one of the above\nconst SYM = 'SYM';\n\nvar tk = /*#__PURE__*/Object.freeze({\n\t__proto__: null,\n\tWORD: WORD,\n\tUWORD: UWORD,\n\tASCIINUMERICAL: ASCIINUMERICAL,\n\tALPHANUMERICAL: ALPHANUMERICAL,\n\tLOCALHOST: LOCALHOST,\n\tTLD: TLD,\n\tUTLD: UTLD,\n\tSCHEME: SCHEME,\n\tSLASH_SCHEME: SLASH_SCHEME,\n\tNUM: NUM,\n\tWS: WS,\n\tNL: NL,\n\tOPENBRACE: OPENBRACE,\n\tCLOSEBRACE: CLOSEBRACE,\n\tOPENBRACKET: OPENBRACKET,\n\tCLOSEBRACKET: CLOSEBRACKET,\n\tOPENPAREN: OPENPAREN,\n\tCLOSEPAREN: CLOSEPAREN,\n\tOPENANGLEBRACKET: OPENANGLEBRACKET,\n\tCLOSEANGLEBRACKET: CLOSEANGLEBRACKET,\n\tFULLWIDTHLEFTPAREN: FULLWIDTHLEFTPAREN,\n\tFULLWIDTHRIGHTPAREN: FULLWIDTHRIGHTPAREN,\n\tLEFTCORNERBRACKET: LEFTCORNERBRACKET,\n\tRIGHTCORNERBRACKET: RIGHTCORNERBRACKET,\n\tLEFTWHITECORNERBRACKET: LEFTWHITECORNERBRACKET,\n\tRIGHTWHITECORNERBRACKET: RIGHTWHITECORNERBRACKET,\n\tFULLWIDTHLESSTHAN: FULLWIDTHLESSTHAN,\n\tFULLWIDTHGREATERTHAN: FULLWIDTHGREATERTHAN,\n\tAMPERSAND: AMPERSAND,\n\tAPOSTROPHE: APOSTROPHE,\n\tASTERISK: ASTERISK,\n\tAT: AT,\n\tBACKSLASH: BACKSLASH,\n\tBACKTICK: BACKTICK,\n\tCARET: CARET,\n\tCOLON: COLON,\n\tCOMMA: COMMA,\n\tDOLLAR: DOLLAR,\n\tDOT: DOT,\n\tEQUALS: EQUALS,\n\tEXCLAMATION: EXCLAMATION,\n\tHYPHEN: HYPHEN,\n\tPERCENT: PERCENT,\n\tPIPE: PIPE,\n\tPLUS: PLUS,\n\tPOUND: POUND,\n\tQUERY: QUERY,\n\tQUOTE: QUOTE,\n\tFULLWIDTHMIDDLEDOT: FULLWIDTHMIDDLEDOT,\n\tSEMI: SEMI,\n\tSLASH: SLASH,\n\tTILDE: TILDE,\n\tUNDERSCORE: UNDERSCORE,\n\tEMOJI: EMOJI$1,\n\tSYM: SYM\n});\n\n// Note that these two Unicode ones expand into a really big one with Babel\nconst ASCII_LETTER = /[a-z]/;\nconst LETTER = /\\p{L}/u; // Any Unicode character with letter data type\nconst EMOJI = /\\p{Emoji}/u; // Any Unicode emoji character\nconst EMOJI_VARIATION$1 = /\\ufe0f/;\nconst DIGIT = /\\d/;\nconst SPACE = /\\s/;\n\nvar regexp = /*#__PURE__*/Object.freeze({\n\t__proto__: null,\n\tASCII_LETTER: ASCII_LETTER,\n\tLETTER: LETTER,\n\tEMOJI: EMOJI,\n\tEMOJI_VARIATION: EMOJI_VARIATION$1,\n\tDIGIT: DIGIT,\n\tSPACE: SPACE\n});\n\n/**\n\tThe scanner provides an interface that takes a string of text as input, and\n\toutputs an array of tokens instances that can be used for easy URL parsing.\n*/\nconst CR = '\\r'; // carriage-return character\nconst LF = '\\n'; // line-feed character\nconst EMOJI_VARIATION = '\\ufe0f'; // Variation selector, follows heart and others\nconst EMOJI_JOINER = '\\u200d'; // zero-width joiner\nconst OBJECT_REPLACEMENT = '\\ufffc'; // whitespace placeholder that sometimes appears in rich text editors\n\nlet tlds = null,\n  utlds = null; // don't change so only have to be computed once\n\n/**\n * Scanner output token:\n * - `t` is the token name (e.g., 'NUM', 'EMOJI', 'TLD')\n * - `v` is the value of the token (e.g., '123', '❤️', 'com')\n * - `s` is the start index of the token in the original string\n * - `e` is the end index of the token in the original string\n * @typedef {{t: string, v: string, s: number, e: number}} Token\n */\n\n/**\n * @template T\n * @typedef {{ [collection: string]: T[] }} Collections\n */\n\n/**\n * Initialize the scanner character-based state machine for the given start\n * state\n * @param {[string, boolean][]} customSchemes List of custom schemes, where each\n * item is a length-2 tuple with the first element set to the string scheme, and\n * the second element set to `true` if the `://` after the scheme is optional\n */\nfunction init$2(customSchemes = []) {\n  // Frequently used states (name argument removed during minification)\n  /** @type Collections<string> */\n  const groups = {}; // of tokens\n  State.groups = groups;\n  /** @type State<string> */\n  const Start = new State();\n  if (tlds == null) {\n    tlds = decodeTlds(encodedTlds);\n  }\n  if (utlds == null) {\n    utlds = decodeTlds(encodedUtlds);\n  }\n\n  // States for special URL symbols that accept immediately after start\n  tt(Start, \"'\", APOSTROPHE);\n  tt(Start, '{', OPENBRACE);\n  tt(Start, '}', CLOSEBRACE);\n  tt(Start, '[', OPENBRACKET);\n  tt(Start, ']', CLOSEBRACKET);\n  tt(Start, '(', OPENPAREN);\n  tt(Start, ')', CLOSEPAREN);\n  tt(Start, '<', OPENANGLEBRACKET);\n  tt(Start, '>', CLOSEANGLEBRACKET);\n  tt(Start, '（', FULLWIDTHLEFTPAREN);\n  tt(Start, '）', FULLWIDTHRIGHTPAREN);\n  tt(Start, '「', LEFTCORNERBRACKET);\n  tt(Start, '」', RIGHTCORNERBRACKET);\n  tt(Start, '『', LEFTWHITECORNERBRACKET);\n  tt(Start, '』', RIGHTWHITECORNERBRACKET);\n  tt(Start, '＜', FULLWIDTHLESSTHAN);\n  tt(Start, '＞', FULLWIDTHGREATERTHAN);\n  tt(Start, '&', AMPERSAND);\n  tt(Start, '*', ASTERISK);\n  tt(Start, '@', AT);\n  tt(Start, '`', BACKTICK);\n  tt(Start, '^', CARET);\n  tt(Start, ':', COLON);\n  tt(Start, ',', COMMA);\n  tt(Start, '$', DOLLAR);\n  tt(Start, '.', DOT);\n  tt(Start, '=', EQUALS);\n  tt(Start, '!', EXCLAMATION);\n  tt(Start, '-', HYPHEN);\n  tt(Start, '%', PERCENT);\n  tt(Start, '|', PIPE);\n  tt(Start, '+', PLUS);\n  tt(Start, '#', POUND);\n  tt(Start, '?', QUERY);\n  tt(Start, '\"', QUOTE);\n  tt(Start, '/', SLASH);\n  tt(Start, ';', SEMI);\n  tt(Start, '~', TILDE);\n  tt(Start, '_', UNDERSCORE);\n  tt(Start, '\\\\', BACKSLASH);\n  tt(Start, '・', FULLWIDTHMIDDLEDOT);\n  const Num = tr(Start, DIGIT, NUM, {\n    [numeric]: true\n  });\n  tr(Num, DIGIT, Num);\n  const Asciinumeric = tr(Num, ASCII_LETTER, ASCIINUMERICAL, {\n    [asciinumeric]: true\n  });\n  const Alphanumeric = tr(Num, LETTER, ALPHANUMERICAL, {\n    [alphanumeric]: true\n  });\n\n  // State which emits a word token\n  const Word = tr(Start, ASCII_LETTER, WORD, {\n    [ascii]: true\n  });\n  tr(Word, DIGIT, Asciinumeric);\n  tr(Word, ASCII_LETTER, Word);\n  tr(Asciinumeric, DIGIT, Asciinumeric);\n  tr(Asciinumeric, ASCII_LETTER, Asciinumeric);\n\n  // Same as previous, but specific to non-fsm.ascii alphabet words\n  const UWord = tr(Start, LETTER, UWORD, {\n    [alpha]: true\n  });\n  tr(UWord, ASCII_LETTER); // Non-accepting\n  tr(UWord, DIGIT, Alphanumeric);\n  tr(UWord, LETTER, UWord);\n  tr(Alphanumeric, DIGIT, Alphanumeric);\n  tr(Alphanumeric, ASCII_LETTER); // Non-accepting\n  tr(Alphanumeric, LETTER, Alphanumeric); // Non-accepting\n\n  // Whitespace jumps\n  // Tokens of only non-newline whitespace are arbitrarily long\n  // If any whitespace except newline, more whitespace!\n  const Nl = tt(Start, LF, NL, {\n    [whitespace]: true\n  });\n  const Cr = tt(Start, CR, WS, {\n    [whitespace]: true\n  });\n  const Ws = tr(Start, SPACE, WS, {\n    [whitespace]: true\n  });\n  tt(Start, OBJECT_REPLACEMENT, Ws);\n  tt(Cr, LF, Nl); // \\r\\n\n  tt(Cr, OBJECT_REPLACEMENT, Ws);\n  tr(Cr, SPACE, Ws);\n  tt(Ws, CR); // non-accepting state to avoid mixing whitespaces\n  tt(Ws, LF); // non-accepting state to avoid mixing whitespaces\n  tr(Ws, SPACE, Ws);\n  tt(Ws, OBJECT_REPLACEMENT, Ws);\n\n  // Emoji tokens. They are not grouped by the scanner except in cases where a\n  // zero-width joiner is present\n  const Emoji = tr(Start, EMOJI, EMOJI$1, {\n    [emoji]: true\n  });\n  tt(Emoji, '#'); // no transition, emoji regex seems to match #\n  tr(Emoji, EMOJI, Emoji);\n  tt(Emoji, EMOJI_VARIATION, Emoji);\n  // tt(Start, EMOJI_VARIATION, Emoji); // This one is sketchy\n\n  const EmojiJoiner = tt(Emoji, EMOJI_JOINER);\n  tt(EmojiJoiner, '#');\n  tr(EmojiJoiner, EMOJI, Emoji);\n  // tt(EmojiJoiner, EMOJI_VARIATION, Emoji); // also sketchy\n\n  // Generates states for top-level domains\n  // Note that this is most accurate when tlds are in alphabetical order\n  const wordjr = [[ASCII_LETTER, Word], [DIGIT, Asciinumeric]];\n  const uwordjr = [[ASCII_LETTER, null], [LETTER, UWord], [DIGIT, Alphanumeric]];\n  for (let i = 0; i < tlds.length; i++) {\n    fastts(Start, tlds[i], TLD, WORD, wordjr);\n  }\n  for (let i = 0; i < utlds.length; i++) {\n    fastts(Start, utlds[i], UTLD, UWORD, uwordjr);\n  }\n  addToGroups(TLD, {\n    tld: true,\n    ascii: true\n  }, groups);\n  addToGroups(UTLD, {\n    utld: true,\n    alpha: true\n  }, groups);\n\n  // Collect the states generated by different protocols. NOTE: If any new TLDs\n  // get added that are also protocols, set the token to be the same as the\n  // protocol to ensure parsing works as expected.\n  fastts(Start, 'file', SCHEME, WORD, wordjr);\n  fastts(Start, 'mailto', SCHEME, WORD, wordjr);\n  fastts(Start, 'http', SLASH_SCHEME, WORD, wordjr);\n  fastts(Start, 'https', SLASH_SCHEME, WORD, wordjr);\n  fastts(Start, 'ftp', SLASH_SCHEME, WORD, wordjr);\n  fastts(Start, 'ftps', SLASH_SCHEME, WORD, wordjr);\n  addToGroups(SCHEME, {\n    scheme: true,\n    ascii: true\n  }, groups);\n  addToGroups(SLASH_SCHEME, {\n    slashscheme: true,\n    ascii: true\n  }, groups);\n\n  // Register custom schemes. Assumes each scheme is asciinumeric with hyphens\n  customSchemes = customSchemes.sort((a, b) => a[0] > b[0] ? 1 : -1);\n  for (let i = 0; i < customSchemes.length; i++) {\n    const sch = customSchemes[i][0];\n    const optionalSlashSlash = customSchemes[i][1];\n    const flags = optionalSlashSlash ? {\n      [scheme]: true\n    } : {\n      [slashscheme]: true\n    };\n    if (sch.indexOf('-') >= 0) {\n      flags[domain] = true;\n    } else if (!ASCII_LETTER.test(sch)) {\n      flags[numeric] = true; // numbers only\n    } else if (DIGIT.test(sch)) {\n      flags[asciinumeric] = true;\n    } else {\n      flags[ascii] = true;\n    }\n    ts(Start, sch, sch, flags);\n  }\n\n  // Localhost token\n  ts(Start, 'localhost', LOCALHOST, {\n    ascii: true\n  });\n\n  // Set default transition for start state (some symbol)\n  Start.jd = new State(SYM);\n  return {\n    start: Start,\n    tokens: assign({\n      groups\n    }, tk)\n  };\n}\n\n/**\n\tGiven a string, returns an array of TOKEN instances representing the\n\tcomposition of that string.\n\n\t@method run\n\t@param {State<string>} start scanner starting state\n\t@param {string} str input string to scan\n\t@return {Token[]} list of tokens, each with a type and value\n*/\nfunction run$1(start, str) {\n  // State machine is not case sensitive, so input is tokenized in lowercased\n  // form (still returns regular case). Uses selective `toLowerCase` because\n  // lowercasing the entire string causes the length and character position to\n  // vary in some non-English strings with V8-based runtimes.\n  const iterable = stringToArray(str.replace(/[A-Z]/g, c => c.toLowerCase()));\n  const charCount = iterable.length; // <= len if there are emojis, etc\n  const tokens = []; // return value\n\n  // cursor through the string itself, accounting for characters that have\n  // width with length 2 such as emojis\n  let cursor = 0;\n\n  // Cursor through the array-representation of the string\n  let charCursor = 0;\n\n  // Tokenize the string\n  while (charCursor < charCount) {\n    let state = start;\n    let nextState = null;\n    let tokenLength = 0;\n    let latestAccepting = null;\n    let sinceAccepts = -1;\n    let charsSinceAccepts = -1;\n    while (charCursor < charCount && (nextState = state.go(iterable[charCursor]))) {\n      state = nextState;\n\n      // Keep track of the latest accepting state\n      if (state.accepts()) {\n        sinceAccepts = 0;\n        charsSinceAccepts = 0;\n        latestAccepting = state;\n      } else if (sinceAccepts >= 0) {\n        sinceAccepts += iterable[charCursor].length;\n        charsSinceAccepts++;\n      }\n      tokenLength += iterable[charCursor].length;\n      cursor += iterable[charCursor].length;\n      charCursor++;\n    }\n\n    // Roll back to the latest accepting state\n    cursor -= sinceAccepts;\n    charCursor -= charsSinceAccepts;\n    tokenLength -= sinceAccepts;\n\n    // No more jumps, just make a new token from the last accepting one\n    tokens.push({\n      t: latestAccepting.t,\n      // token type/name\n      v: str.slice(cursor - tokenLength, cursor),\n      // string value\n      s: cursor - tokenLength,\n      // start index\n      e: cursor // end index (excluding)\n    });\n  }\n  return tokens;\n}\n\n/**\n * Convert a String to an Array of characters, taking into account that some\n * characters like emojis take up two string indexes.\n *\n * Adapted from core-js (MIT license)\n * https://github.com/zloirock/core-js/blob/2d69cf5f99ab3ea3463c395df81e5a15b68f49d9/packages/core-js/internals/string-multibyte.js\n *\n * @function stringToArray\n * @param {string} str\n * @returns {string[]}\n */\nfunction stringToArray(str) {\n  const result = [];\n  const len = str.length;\n  let index = 0;\n  while (index < len) {\n    let first = str.charCodeAt(index);\n    let second;\n    let char = first < 0xd800 || first > 0xdbff || index + 1 === len || (second = str.charCodeAt(index + 1)) < 0xdc00 || second > 0xdfff ? str[index] // single character\n    : str.slice(index, index + 2); // two-index characters\n    result.push(char);\n    index += char.length;\n  }\n  return result;\n}\n\n/**\n * Fast version of ts function for when transition defaults are well known\n * @param {State<string>} state\n * @param {string} input\n * @param {string} t\n * @param {string} defaultt\n * @param {[RegExp, State<string>][]} jr\n * @returns {State<string>}\n */\nfunction fastts(state, input, t, defaultt, jr) {\n  let next;\n  const len = input.length;\n  for (let i = 0; i < len - 1; i++) {\n    const char = input[i];\n    if (state.j[char]) {\n      next = state.j[char];\n    } else {\n      next = new State(defaultt);\n      next.jr = jr.slice();\n      state.j[char] = next;\n    }\n    state = next;\n  }\n  next = new State(t);\n  next.jr = jr.slice();\n  state.j[input[len - 1]] = next;\n  return next;\n}\n\n/**\n * Converts a string of Top-Level Domain names encoded in update-tlds.js back\n * into a list of strings.\n * @param {str} encoded encoded TLDs string\n * @returns {str[]} original TLDs list\n */\nfunction decodeTlds(encoded) {\n  const words = [];\n  const stack = [];\n  let i = 0;\n  let digits = '0123456789';\n  while (i < encoded.length) {\n    let popDigitCount = 0;\n    while (digits.indexOf(encoded[i + popDigitCount]) >= 0) {\n      popDigitCount++; // encountered some digits, have to pop to go one level up trie\n    }\n    if (popDigitCount > 0) {\n      words.push(stack.join('')); // whatever preceded the pop digits must be a word\n      for (let popCount = parseInt(encoded.substring(i, i + popDigitCount), 10); popCount > 0; popCount--) {\n        stack.pop();\n      }\n      i += popDigitCount;\n    } else {\n      stack.push(encoded[i]); // drop down a level into the trie\n      i++;\n    }\n  }\n  return words;\n}\n\n/**\n * An object where each key is a valid DOM Event Name such as `click` or `focus`\n * and each value is an event handler function.\n *\n * https://developer.mozilla.org/en-US/docs/Web/API/Element#events\n * @typedef {?{ [event: string]: Function }} EventListeners\n */\n\n/**\n * All formatted properties required to render a link, including `tagName`,\n * `attributes`, `content` and `eventListeners`.\n * @typedef {{ tagName: any, attributes: {[attr: string]: any}, content: string,\n * eventListeners: EventListeners }} IntermediateRepresentation\n */\n\n/**\n * Specify either an object described by the template type `O` or a function.\n *\n * The function takes a string value (usually the link's href attribute), the\n * link type (`'url'`, `'hashtag`', etc.) and an internal token representation\n * of the link. It should return an object of the template type `O`\n * @template O\n * @typedef {O | ((value: string, type: string, token: MultiToken) => O)} OptObj\n */\n\n/**\n * Specify either a function described by template type `F` or an object.\n *\n * Each key in the object should be a link type (`'url'`, `'hashtag`', etc.). Each\n * value should be a function with template type `F` that is called when the\n * corresponding link type is encountered.\n * @template F\n * @typedef {F | { [type: string]: F}} OptFn\n */\n\n/**\n * Specify either a value with template type `V`, a function that returns `V` or\n * an object where each value resolves to `V`.\n *\n * The function takes a string value (usually the link's href attribute), the\n * link type (`'url'`, `'hashtag`', etc.) and an internal token representation\n * of the link. It should return an object of the template type `V`\n *\n * For the object, each key should be a link type (`'url'`, `'hashtag`', etc.).\n * Each value should either have type `V` or a function that returns V. This\n * function similarly takes a string value and a token.\n *\n * Example valid types for `Opt<string>`:\n *\n * ```js\n * 'hello'\n * (value, type, token) => 'world'\n * { url: 'hello', email: (value, token) => 'world'}\n * ```\n * @template V\n * @typedef {V | ((value: string, type: string, token: MultiToken) => V) | { [type: string]: V | ((value: string, token: MultiToken) => V) }} Opt\n */\n\n/**\n * See available options: https://linkify.js.org/docs/options.html\n * @typedef {{\n * \tdefaultProtocol?: string,\n *  events?: OptObj<EventListeners>,\n * \tformat?: Opt<string>,\n * \tformatHref?: Opt<string>,\n * \tnl2br?: boolean,\n * \ttagName?: Opt<any>,\n * \ttarget?: Opt<string>,\n * \trel?: Opt<string>,\n * \tvalidate?: Opt<boolean>,\n * \ttruncate?: Opt<number>,\n * \tclassName?: Opt<string>,\n * \tattributes?: OptObj<({ [attr: string]: any })>,\n *  ignoreTags?: string[],\n * \trender?: OptFn<((ir: IntermediateRepresentation) => any)>\n * }} Opts\n */\n\n/**\n * @type Required<Opts>\n */\nconst defaults = {\n  defaultProtocol: 'http',\n  events: null,\n  format: noop,\n  formatHref: noop,\n  nl2br: false,\n  tagName: 'a',\n  target: null,\n  rel: null,\n  validate: true,\n  truncate: Infinity,\n  className: null,\n  attributes: null,\n  ignoreTags: [],\n  render: null\n};\n\n/**\n * Utility class for linkify interfaces to apply specified\n * {@link Opts formatting and rendering options}.\n *\n * @param {Opts | Options} [opts] Option value overrides.\n * @param {(ir: IntermediateRepresentation) => any} [defaultRender] (For\n *   internal use) default render function that determines how to generate an\n *   HTML element based on a link token's derived tagName, attributes and HTML.\n *   Similar to render option\n */\nfunction Options(opts, defaultRender = null) {\n  let o = assign({}, defaults);\n  if (opts) {\n    o = assign(o, opts instanceof Options ? opts.o : opts);\n  }\n\n  // Ensure all ignored tags are uppercase\n  const ignoredTags = o.ignoreTags;\n  const uppercaseIgnoredTags = [];\n  for (let i = 0; i < ignoredTags.length; i++) {\n    uppercaseIgnoredTags.push(ignoredTags[i].toUpperCase());\n  }\n  /** @protected */\n  this.o = o;\n  if (defaultRender) {\n    this.defaultRender = defaultRender;\n  }\n  this.ignoreTags = uppercaseIgnoredTags;\n}\nOptions.prototype = {\n  o: defaults,\n  /**\n   * @type string[]\n   */\n  ignoreTags: [],\n  /**\n   * @param {IntermediateRepresentation} ir\n   * @returns {any}\n   */\n  defaultRender(ir) {\n    return ir;\n  },\n  /**\n   * Returns true or false based on whether a token should be displayed as a\n   * link based on the user options.\n   * @param {MultiToken} token\n   * @returns {boolean}\n   */\n  check(token) {\n    return this.get('validate', token.toString(), token);\n  },\n  // Private methods\n\n  /**\n   * Resolve an option's value based on the value of the option and the given\n   * params. If operator and token are specified and the target option is\n   * callable, automatically calls the function with the given argument.\n   * @template {keyof Opts} K\n   * @param {K} key Name of option to use\n   * @param {string} [operator] will be passed to the target option if it's a\n   * function. If not specified, RAW function value gets returned\n   * @param {MultiToken} [token] The token from linkify.tokenize\n   * @returns {Opts[K] | any}\n   */\n  get(key, operator, token) {\n    const isCallable = operator != null;\n    let option = this.o[key];\n    if (!option) {\n      return option;\n    }\n    if (typeof option === 'object') {\n      option = token.t in option ? option[token.t] : defaults[key];\n      if (typeof option === 'function' && isCallable) {\n        option = option(operator, token);\n      }\n    } else if (typeof option === 'function' && isCallable) {\n      option = option(operator, token.t, token);\n    }\n    return option;\n  },\n  /**\n   * @template {keyof Opts} L\n   * @param {L} key Name of options object to use\n   * @param {string} [operator]\n   * @param {MultiToken} [token]\n   * @returns {Opts[L] | any}\n   */\n  getObj(key, operator, token) {\n    let obj = this.o[key];\n    if (typeof obj === 'function' && operator != null) {\n      obj = obj(operator, token.t, token);\n    }\n    return obj;\n  },\n  /**\n   * Convert the given token to a rendered element that may be added to the\n   * calling-interface's DOM\n   * @param {MultiToken} token Token to render to an HTML element\n   * @returns {any} Render result; e.g., HTML string, DOM element, React\n   *   Component, etc.\n   */\n  render(token) {\n    const ir = token.render(this); // intermediate representation\n    const renderFn = this.get('render', null, token) || this.defaultRender;\n    return renderFn(ir, token.t, token);\n  }\n};\nfunction noop(val) {\n  return val;\n}\n\nvar options = /*#__PURE__*/Object.freeze({\n\t__proto__: null,\n\tdefaults: defaults,\n\tOptions: Options,\n\tassign: assign\n});\n\n/******************************************************************************\n\tMulti-Tokens\n\tTokens composed of arrays of TextTokens\n******************************************************************************/\n\n/**\n * @param {string} value\n * @param {Token[]} tokens\n */\nfunction MultiToken(value, tokens) {\n  this.t = 'token';\n  this.v = value;\n  this.tk = tokens;\n}\n\n/**\n * Abstract class used for manufacturing tokens of text tokens. That is rather\n * than the value for a token being a small string of text, it's value an array\n * of text tokens.\n *\n * Used for grouping together URLs, emails, hashtags, and other potential\n * creations.\n * @class MultiToken\n * @property {string} t\n * @property {string} v\n * @property {Token[]} tk\n * @abstract\n */\nMultiToken.prototype = {\n  isLink: false,\n  /**\n   * Return the string this token represents.\n   * @return {string}\n   */\n  toString() {\n    return this.v;\n  },\n  /**\n   * What should the value for this token be in the `href` HTML attribute?\n   * Returns the `.toString` value by default.\n   * @param {string} [scheme]\n   * @return {string}\n   */\n  toHref(scheme) {\n    return this.toString();\n  },\n  /**\n   * @param {Options} options Formatting options\n   * @returns {string}\n   */\n  toFormattedString(options) {\n    const val = this.toString();\n    const truncate = options.get('truncate', val, this);\n    const formatted = options.get('format', val, this);\n    return truncate && formatted.length > truncate ? formatted.substring(0, truncate) + '…' : formatted;\n  },\n  /**\n   *\n   * @param {Options} options\n   * @returns {string}\n   */\n  toFormattedHref(options) {\n    return options.get('formatHref', this.toHref(options.get('defaultProtocol')), this);\n  },\n  /**\n   * The start index of this token in the original input string\n   * @returns {number}\n   */\n  startIndex() {\n    return this.tk[0].s;\n  },\n  /**\n   * The end index of this token in the original input string (up to this\n   * index but not including it)\n   * @returns {number}\n   */\n  endIndex() {\n    return this.tk[this.tk.length - 1].e;\n  },\n  /**\n  \tReturns an object  of relevant values for this token, which includes keys\n  \t* type - Kind of token ('url', 'email', etc.)\n  \t* value - Original text\n  \t* href - The value that should be added to the anchor tag's href\n  \t\tattribute\n  \t\t@method toObject\n  \t@param {string} [protocol] `'http'` by default\n  */\n  toObject(protocol = defaults.defaultProtocol) {\n    return {\n      type: this.t,\n      value: this.toString(),\n      isLink: this.isLink,\n      href: this.toHref(protocol),\n      start: this.startIndex(),\n      end: this.endIndex()\n    };\n  },\n  /**\n   *\n   * @param {Options} options Formatting option\n   */\n  toFormattedObject(options) {\n    return {\n      type: this.t,\n      value: this.toFormattedString(options),\n      isLink: this.isLink,\n      href: this.toFormattedHref(options),\n      start: this.startIndex(),\n      end: this.endIndex()\n    };\n  },\n  /**\n   * Whether this token should be rendered as a link according to the given options\n   * @param {Options} options\n   * @returns {boolean}\n   */\n  validate(options) {\n    return options.get('validate', this.toString(), this);\n  },\n  /**\n   * Return an object that represents how this link should be rendered.\n   * @param {Options} options Formattinng options\n   */\n  render(options) {\n    const token = this;\n    const href = this.toHref(options.get('defaultProtocol'));\n    const formattedHref = options.get('formatHref', href, this);\n    const tagName = options.get('tagName', href, token);\n    const content = this.toFormattedString(options);\n    const attributes = {};\n    const className = options.get('className', href, token);\n    const target = options.get('target', href, token);\n    const rel = options.get('rel', href, token);\n    const attrs = options.getObj('attributes', href, token);\n    const eventListeners = options.getObj('events', href, token);\n    attributes.href = formattedHref;\n    if (className) {\n      attributes.class = className;\n    }\n    if (target) {\n      attributes.target = target;\n    }\n    if (rel) {\n      attributes.rel = rel;\n    }\n    if (attrs) {\n      assign(attributes, attrs);\n    }\n    return {\n      tagName,\n      attributes,\n      content,\n      eventListeners\n    };\n  }\n};\n\n/**\n * Create a new token that can be emitted by the parser state machine\n * @param {string} type readable type of the token\n * @param {object} props properties to assign or override, including isLink = true or false\n * @returns {new (value: string, tokens: Token[]) => MultiToken} new token class\n */\nfunction createTokenClass(type, props) {\n  class Token extends MultiToken {\n    constructor(value, tokens) {\n      super(value, tokens);\n      this.t = type;\n    }\n  }\n  for (const p in props) {\n    Token.prototype[p] = props[p];\n  }\n  Token.t = type;\n  return Token;\n}\n\n/**\n\tRepresents a list of tokens making up a valid email address\n*/\nconst Email = createTokenClass('email', {\n  isLink: true,\n  toHref() {\n    return 'mailto:' + this.toString();\n  }\n});\n\n/**\n\tRepresents some plain text\n*/\nconst Text = createTokenClass('text');\n\n/**\n\tMulti-linebreak token - represents a line break\n\t@class Nl\n*/\nconst Nl = createTokenClass('nl');\n\n/**\n\tRepresents a list of text tokens making up a valid URL\n\t@class Url\n*/\nconst Url = createTokenClass('url', {\n  isLink: true,\n  /**\n  \tLowercases relevant parts of the domain and adds the protocol if\n  \trequired. Note that this will not escape unsafe HTML characters in the\n  \tURL.\n  \t\t@param {string} [scheme] default scheme (e.g., 'https')\n  \t@return {string} the full href\n  */\n  toHref(scheme = defaults.defaultProtocol) {\n    // Check if already has a prefix scheme\n    return this.hasProtocol() ? this.v : `${scheme}://${this.v}`;\n  },\n  /**\n   * Check whether this URL token has a protocol\n   * @return {boolean}\n   */\n  hasProtocol() {\n    const tokens = this.tk;\n    return tokens.length >= 2 && tokens[0].t !== LOCALHOST && tokens[1].t === COLON;\n  }\n});\n\nvar multi = /*#__PURE__*/Object.freeze({\n\t__proto__: null,\n\tMultiToken: MultiToken,\n\tBase: MultiToken,\n\tcreateTokenClass: createTokenClass,\n\tEmail: Email,\n\tText: Text,\n\tNl: Nl,\n\tUrl: Url\n});\n\n/**\n\tNot exactly parser, more like the second-stage scanner (although we can\n\ttheoretically hotswap the code here with a real parser in the future... but\n\tfor a little URL-finding utility abstract syntax trees may be a little\n\toverkill).\n\n\tURL format: http://en.wikipedia.org/wiki/URI_scheme\n\tEmail format: http://en.wikipedia.org/wiki/EmailAddress (links to RFC in\n\treference)\n\n\t@module linkify\n\t@submodule parser\n\t@main run\n*/\nconst makeState = arg => new State(arg);\n\n/**\n * Generate the parser multi token-based state machine\n * @param {{ groups: Collections<string> }} tokens\n */\nfunction init$1({\n  groups\n}) {\n  // Types of characters the URL can definitely end in\n  const qsAccepting = groups.domain.concat([AMPERSAND, ASTERISK, AT, BACKSLASH, BACKTICK, CARET, DOLLAR, EQUALS, HYPHEN, NUM, PERCENT, PIPE, PLUS, POUND, SLASH, SYM, TILDE, UNDERSCORE]);\n\n  // Types of tokens that can follow a URL and be part of the query string\n  // but cannot be the very last characters\n  // Characters that cannot appear in the URL at all should be excluded\n  const qsNonAccepting = [COLON, COMMA, DOT, EXCLAMATION, PERCENT, QUERY, QUOTE, SEMI, OPENANGLEBRACKET, CLOSEANGLEBRACKET, OPENBRACE, CLOSEBRACE, CLOSEBRACKET, OPENBRACKET, OPENPAREN, CLOSEPAREN, FULLWIDTHLEFTPAREN, FULLWIDTHRIGHTPAREN, LEFTCORNERBRACKET, RIGHTCORNERBRACKET, LEFTWHITECORNERBRACKET, RIGHTWHITECORNERBRACKET, FULLWIDTHLESSTHAN, FULLWIDTHGREATERTHAN];\n\n  // For addresses without the mailto prefix\n  // Tokens allowed in the localpart of the email\n  const localpartAccepting = [AMPERSAND, APOSTROPHE, ASTERISK, BACKSLASH, BACKTICK, CARET, DOLLAR, EQUALS, HYPHEN, OPENBRACE, CLOSEBRACE, PERCENT, PIPE, PLUS, POUND, QUERY, SLASH, SYM, TILDE, UNDERSCORE];\n\n  // The universal starting state.\n  /**\n   * @type State<Token>\n   */\n  const Start = makeState();\n  const Localpart = tt(Start, TILDE); // Local part of the email address\n  ta(Localpart, localpartAccepting, Localpart);\n  ta(Localpart, groups.domain, Localpart);\n  const Domain = makeState(),\n    Scheme = makeState(),\n    SlashScheme = makeState();\n  ta(Start, groups.domain, Domain); // parsed string ends with a potential domain name (A)\n  ta(Start, groups.scheme, Scheme); // e.g., 'mailto'\n  ta(Start, groups.slashscheme, SlashScheme); // e.g., 'http'\n\n  ta(Domain, localpartAccepting, Localpart);\n  ta(Domain, groups.domain, Domain);\n  const LocalpartAt = tt(Domain, AT); // Local part of the email address plus @\n\n  tt(Localpart, AT, LocalpartAt); // close to an email address now\n\n  // Local part of an email address can be e.g. 'http' or 'mailto'\n  tt(Scheme, AT, LocalpartAt);\n  tt(SlashScheme, AT, LocalpartAt);\n  const LocalpartDot = tt(Localpart, DOT); // Local part of the email address plus '.' (localpart cannot end in .)\n  ta(LocalpartDot, localpartAccepting, Localpart);\n  ta(LocalpartDot, groups.domain, Localpart);\n  const EmailDomain = makeState();\n  ta(LocalpartAt, groups.domain, EmailDomain); // parsed string starts with local email info + @ with a potential domain name\n  ta(EmailDomain, groups.domain, EmailDomain);\n  const EmailDomainDot = tt(EmailDomain, DOT); // domain followed by DOT\n  ta(EmailDomainDot, groups.domain, EmailDomain);\n  const Email$1 = makeState(Email); // Possible email address (could have more tlds)\n  ta(EmailDomainDot, groups.tld, Email$1);\n  ta(EmailDomainDot, groups.utld, Email$1);\n  tt(LocalpartAt, LOCALHOST, Email$1);\n\n  // Hyphen can jump back to a domain name\n  const EmailDomainHyphen = tt(EmailDomain, HYPHEN); // parsed string starts with local email info + @ with a potential domain name\n  tt(EmailDomainHyphen, HYPHEN, EmailDomainHyphen);\n  ta(EmailDomainHyphen, groups.domain, EmailDomain);\n  ta(Email$1, groups.domain, EmailDomain);\n  tt(Email$1, DOT, EmailDomainDot);\n  tt(Email$1, HYPHEN, EmailDomainHyphen);\n\n  // Final possible email states\n  const EmailColon = tt(Email$1, COLON); // URL followed by colon (potential port number here)\n  /*const EmailColonPort = */\n  ta(EmailColon, groups.numeric, Email); // URL followed by colon and port number\n\n  // Account for dots and hyphens. Hyphens are usually parts of domain names\n  // (but not TLDs)\n  const DomainHyphen = tt(Domain, HYPHEN); // domain followed by hyphen\n  const DomainDot = tt(Domain, DOT); // domain followed by DOT\n  tt(DomainHyphen, HYPHEN, DomainHyphen);\n  ta(DomainHyphen, groups.domain, Domain);\n  ta(DomainDot, localpartAccepting, Localpart);\n  ta(DomainDot, groups.domain, Domain);\n  const DomainDotTld = makeState(Url); // Simplest possible URL with no query string\n  ta(DomainDot, groups.tld, DomainDotTld);\n  ta(DomainDot, groups.utld, DomainDotTld);\n  ta(DomainDotTld, groups.domain, Domain);\n  ta(DomainDotTld, localpartAccepting, Localpart);\n  tt(DomainDotTld, DOT, DomainDot);\n  tt(DomainDotTld, HYPHEN, DomainHyphen);\n  tt(DomainDotTld, AT, LocalpartAt);\n  const DomainDotTldColon = tt(DomainDotTld, COLON); // URL followed by colon (potential port number here)\n  const DomainDotTldColonPort = makeState(Url); // TLD followed by a port number\n  ta(DomainDotTldColon, groups.numeric, DomainDotTldColonPort);\n\n  // Long URL with optional port and maybe query string\n  const Url$1 = makeState(Url);\n\n  // URL with extra symbols at the end, followed by an opening bracket\n  const UrlNonaccept = makeState(); // URL followed by some symbols (will not be part of the final URL)\n\n  // Query strings\n  ta(Url$1, qsAccepting, Url$1);\n  ta(Url$1, qsNonAccepting, UrlNonaccept);\n  ta(UrlNonaccept, qsAccepting, Url$1);\n  ta(UrlNonaccept, qsNonAccepting, UrlNonaccept);\n\n  // Become real URLs after `SLASH` or `COLON NUM SLASH`\n  // Here works with or without scheme:// prefix\n  tt(DomainDotTld, SLASH, Url$1);\n  tt(DomainDotTldColonPort, SLASH, Url$1);\n\n  // Note that domains that begin with schemes are treated slighly differently\n  const SchemeColon = tt(Scheme, COLON); // e.g., 'mailto:'\n  const SlashSchemeColon = tt(SlashScheme, COLON); // e.g., 'http:'\n  const SlashSchemeColonSlash = tt(SlashSchemeColon, SLASH); // e.g., 'http:/'\n\n  const UriPrefix = tt(SlashSchemeColonSlash, SLASH); // e.g., 'http://'\n\n  // Scheme states can transition to domain states\n  ta(Scheme, groups.domain, Domain);\n  tt(Scheme, DOT, DomainDot);\n  tt(Scheme, HYPHEN, DomainHyphen);\n  ta(SlashScheme, groups.domain, Domain);\n  tt(SlashScheme, DOT, DomainDot);\n  tt(SlashScheme, HYPHEN, DomainHyphen);\n\n  // Force URL with scheme prefix followed by anything sane\n  ta(SchemeColon, groups.domain, Url$1);\n  tt(SchemeColon, SLASH, Url$1);\n  tt(SchemeColon, QUERY, Url$1);\n  ta(UriPrefix, groups.domain, Url$1);\n  ta(UriPrefix, qsAccepting, Url$1);\n  tt(UriPrefix, SLASH, Url$1);\n  const bracketPairs = [[OPENBRACE, CLOSEBRACE],\n  // {}\n  [OPENBRACKET, CLOSEBRACKET],\n  // []\n  [OPENPAREN, CLOSEPAREN],\n  // ()\n  [OPENANGLEBRACKET, CLOSEANGLEBRACKET],\n  // <>\n  [FULLWIDTHLEFTPAREN, FULLWIDTHRIGHTPAREN],\n  // （）\n  [LEFTCORNERBRACKET, RIGHTCORNERBRACKET],\n  // 「」\n  [LEFTWHITECORNERBRACKET, RIGHTWHITECORNERBRACKET],\n  // 『』\n  [FULLWIDTHLESSTHAN, FULLWIDTHGREATERTHAN] // ＜＞\n  ];\n  for (let i = 0; i < bracketPairs.length; i++) {\n    const [OPEN, CLOSE] = bracketPairs[i];\n    const UrlOpen = tt(Url$1, OPEN); // URL followed by open bracket\n\n    // Continue not accepting for open brackets\n    tt(UrlNonaccept, OPEN, UrlOpen);\n\n    // Closing bracket component. This character WILL be included in the URL\n    tt(UrlOpen, CLOSE, Url$1);\n\n    // URL that beings with an opening bracket, followed by a symbols.\n    // Note that the final state can still be `UrlOpen` (if the URL has a\n    // single opening bracket for some reason).\n    const UrlOpenQ = makeState(Url);\n    ta(UrlOpen, qsAccepting, UrlOpenQ);\n    const UrlOpenSyms = makeState(); // UrlOpen followed by some symbols it cannot end it\n    ta(UrlOpen, qsNonAccepting);\n\n    // URL that begins with an opening bracket, followed by some symbols\n    ta(UrlOpenQ, qsAccepting, UrlOpenQ);\n    ta(UrlOpenQ, qsNonAccepting, UrlOpenSyms);\n    ta(UrlOpenSyms, qsAccepting, UrlOpenQ);\n    ta(UrlOpenSyms, qsNonAccepting, UrlOpenSyms);\n\n    // Close brace/bracket to become regular URL\n    tt(UrlOpenQ, CLOSE, Url$1);\n    tt(UrlOpenSyms, CLOSE, Url$1);\n  }\n  tt(Start, LOCALHOST, DomainDotTld); // localhost is a valid URL state\n  tt(Start, NL, Nl); // single new line\n\n  return {\n    start: Start,\n    tokens: tk\n  };\n}\n\n/**\n * Run the parser state machine on a list of scanned string-based tokens to\n * create a list of multi tokens, each of which represents a URL, email address,\n * plain text, etc.\n *\n * @param {State<MultiToken>} start parser start state\n * @param {string} input the original input used to generate the given tokens\n * @param {Token[]} tokens list of scanned tokens\n * @returns {MultiToken[]}\n */\nfunction run(start, input, tokens) {\n  let len = tokens.length;\n  let cursor = 0;\n  let multis = [];\n  let textTokens = [];\n  while (cursor < len) {\n    let state = start;\n    let secondState = null;\n    let nextState = null;\n    let multiLength = 0;\n    let latestAccepting = null;\n    let sinceAccepts = -1;\n    while (cursor < len && !(secondState = state.go(tokens[cursor].t))) {\n      // Starting tokens with nowhere to jump to.\n      // Consider these to be just plain text\n      textTokens.push(tokens[cursor++]);\n    }\n    while (cursor < len && (nextState = secondState || state.go(tokens[cursor].t))) {\n      // Get the next state\n      secondState = null;\n      state = nextState;\n\n      // Keep track of the latest accepting state\n      if (state.accepts()) {\n        sinceAccepts = 0;\n        latestAccepting = state;\n      } else if (sinceAccepts >= 0) {\n        sinceAccepts++;\n      }\n      cursor++;\n      multiLength++;\n    }\n    if (sinceAccepts < 0) {\n      // No accepting state was found, part of a regular text token add\n      // the first text token to the text tokens array and try again from\n      // the next\n      cursor -= multiLength;\n      if (cursor < len) {\n        textTokens.push(tokens[cursor]);\n        cursor++;\n      }\n    } else {\n      // Accepting state!\n      // First close off the textTokens (if available)\n      if (textTokens.length > 0) {\n        multis.push(initMultiToken(Text, input, textTokens));\n        textTokens = [];\n      }\n\n      // Roll back to the latest accepting state\n      cursor -= sinceAccepts;\n      multiLength -= sinceAccepts;\n\n      // Create a new multitoken\n      const Multi = latestAccepting.t;\n      const subtokens = tokens.slice(cursor - multiLength, cursor);\n      multis.push(initMultiToken(Multi, input, subtokens));\n    }\n  }\n\n  // Finally close off the textTokens (if available)\n  if (textTokens.length > 0) {\n    multis.push(initMultiToken(Text, input, textTokens));\n  }\n  return multis;\n}\n\n/**\n * Utility function for instantiating a new multitoken with all the relevant\n * fields during parsing.\n * @param {new (value: string, tokens: Token[]) => MultiToken} Multi class to instantiate\n * @param {string} input original input string\n * @param {Token[]} tokens consecutive tokens scanned from input string\n * @returns {MultiToken}\n */\nfunction initMultiToken(Multi, input, tokens) {\n  const startIdx = tokens[0].s;\n  const endIdx = tokens[tokens.length - 1].e;\n  const value = input.slice(startIdx, endIdx);\n  return new Multi(value, tokens);\n}\n\nconst warn = typeof console !== 'undefined' && console && console.warn || (() => {});\nconst warnAdvice = 'until manual call of linkify.init(). Register all schemes and plugins before invoking linkify the first time.';\n\n// Side-effect initialization state\nconst INIT = {\n  scanner: null,\n  parser: null,\n  tokenQueue: [],\n  pluginQueue: [],\n  customSchemes: [],\n  initialized: false\n};\n\n/**\n * @typedef {{\n * \tstart: State<string>,\n * \ttokens: { groups: Collections<string> } & typeof tk\n * }} ScannerInit\n */\n\n/**\n * @typedef {{\n * \tstart: State<MultiToken>,\n * \ttokens: typeof multi\n * }} ParserInit\n */\n\n/**\n * @typedef {(arg: { scanner: ScannerInit }) => void} TokenPlugin\n */\n\n/**\n * @typedef {(arg: { scanner: ScannerInit, parser: ParserInit }) => void} Plugin\n */\n\n/**\n * De-register all plugins and reset the internal state-machine. Used for\n * testing; not required in practice.\n * @private\n */\nfunction reset() {\n  State.groups = {};\n  INIT.scanner = null;\n  INIT.parser = null;\n  INIT.tokenQueue = [];\n  INIT.pluginQueue = [];\n  INIT.customSchemes = [];\n  INIT.initialized = false;\n  return INIT;\n}\n\n/**\n * Register a token plugin to allow the scanner to recognize additional token\n * types before the parser state machine is constructed from the results.\n * @param {string} name of plugin to register\n * @param {TokenPlugin} plugin function that accepts the scanner state machine\n * and available scanner tokens and collections and extends the state machine to\n * recognize additional tokens or groups.\n */\nfunction registerTokenPlugin(name, plugin) {\n  if (typeof plugin !== 'function') {\n    throw new Error(`linkifyjs: Invalid token plugin ${plugin} (expects function)`);\n  }\n  for (let i = 0; i < INIT.tokenQueue.length; i++) {\n    if (name === INIT.tokenQueue[i][0]) {\n      warn(`linkifyjs: token plugin \"${name}\" already registered - will be overwritten`);\n      INIT.tokenQueue[i] = [name, plugin];\n      return;\n    }\n  }\n  INIT.tokenQueue.push([name, plugin]);\n  if (INIT.initialized) {\n    warn(`linkifyjs: already initialized - will not register token plugin \"${name}\" ${warnAdvice}`);\n  }\n}\n\n/**\n * Register a linkify plugin\n * @param {string} name of plugin to register\n * @param {Plugin} plugin function that accepts the parser state machine and\n * extends the parser to recognize additional link types\n */\nfunction registerPlugin(name, plugin) {\n  if (typeof plugin !== 'function') {\n    throw new Error(`linkifyjs: Invalid plugin ${plugin} (expects function)`);\n  }\n  for (let i = 0; i < INIT.pluginQueue.length; i++) {\n    if (name === INIT.pluginQueue[i][0]) {\n      warn(`linkifyjs: plugin \"${name}\" already registered - will be overwritten`);\n      INIT.pluginQueue[i] = [name, plugin];\n      return;\n    }\n  }\n  INIT.pluginQueue.push([name, plugin]);\n  if (INIT.initialized) {\n    warn(`linkifyjs: already initialized - will not register plugin \"${name}\" ${warnAdvice}`);\n  }\n}\n\n/**\n * Detect URLs with the following additional protocol. Anything with format\n * \"protocol://...\" will be considered a link. If `optionalSlashSlash` is set to\n * `true`, anything with format \"protocol:...\" will be considered a link.\n * @param {string} scheme\n * @param {boolean} [optionalSlashSlash]\n */\nfunction registerCustomProtocol(scheme, optionalSlashSlash = false) {\n  if (INIT.initialized) {\n    warn(`linkifyjs: already initialized - will not register custom scheme \"${scheme}\" ${warnAdvice}`);\n  }\n  if (!/^[0-9a-z]+(-[0-9a-z]+)*$/.test(scheme)) {\n    throw new Error(`linkifyjs: incorrect scheme format.\n1. Must only contain digits, lowercase ASCII letters or \"-\"\n2. Cannot start or end with \"-\"\n3. \"-\" cannot repeat`);\n  }\n  INIT.customSchemes.push([scheme, optionalSlashSlash]);\n}\n\n/**\n * Initialize the linkify state machine. Called automatically the first time\n * linkify is called on a string, but may be called manually as well.\n */\nfunction init() {\n  // Initialize scanner state machine and plugins\n  INIT.scanner = init$2(INIT.customSchemes);\n  for (let i = 0; i < INIT.tokenQueue.length; i++) {\n    INIT.tokenQueue[i][1]({\n      scanner: INIT.scanner\n    });\n  }\n\n  // Initialize parser state machine and plugins\n  INIT.parser = init$1(INIT.scanner.tokens);\n  for (let i = 0; i < INIT.pluginQueue.length; i++) {\n    INIT.pluginQueue[i][1]({\n      scanner: INIT.scanner,\n      parser: INIT.parser\n    });\n  }\n  INIT.initialized = true;\n  return INIT;\n}\n\n/**\n * Parse a string into tokens that represent linkable and non-linkable sub-components\n * @param {string} str\n * @return {MultiToken[]} tokens\n */\nfunction tokenize(str) {\n  if (!INIT.initialized) {\n    init();\n  }\n  return run(INIT.parser.start, str, run$1(INIT.scanner.start, str));\n}\ntokenize.scan = run$1; // for testing\n\n/**\n * Find a list of linkable items in the given string.\n * @param {string} str string to find links in\n * @param {string | Opts} [type] either formatting options or specific type of\n * links to find, e.g., 'url' or 'email'\n * @param {Opts} [opts] formatting options for final output. Cannot be specified\n * if opts already provided in `type` argument\n */\nfunction find(str, type = null, opts = null) {\n  if (type && typeof type === 'object') {\n    if (opts) {\n      throw Error(`linkifyjs: Invalid link type ${type}; must be a string`);\n    }\n    opts = type;\n    type = null;\n  }\n  const options = new Options(opts);\n  const tokens = tokenize(str);\n  const filtered = [];\n  for (let i = 0; i < tokens.length; i++) {\n    const token = tokens[i];\n    if (token.isLink && (!type || token.t === type) && options.check(token)) {\n      filtered.push(token.toFormattedObject(options));\n    }\n  }\n  return filtered;\n}\n\n/**\n * Is the given string valid linkable text of some sort. Note that this does not\n * trim the text for you.\n *\n * Optionally pass in a second `type` param, which is the type of link to test\n * for.\n *\n * For example,\n *\n *     linkify.test(str, 'email');\n *\n * Returns `true` if str is a valid email.\n * @param {string} str string to test for links\n * @param {string} [type] optional specific link type to look for\n * @returns boolean true/false\n */\nfunction test(str, type = null) {\n  const tokens = tokenize(str);\n  return tokens.length === 1 && tokens[0].isLink && (!type || tokens[0].t === type);\n}\n\nexport { MultiToken, Options, State, createTokenClass, find, init, multi, options, regexp, registerCustomProtocol, registerPlugin, registerTokenPlugin, reset, stringToArray, test, multi as text, tokenize };\n","/**\n * @license\n * Lodash <https://lodash.com/>\n * Copyright OpenJS Foundation and other contributors <https://openjsf.org/>\n * Released under MIT license <https://lodash.com/license>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n */\n;(function() {\n\n  /** Used as a safe reference for `undefined` in pre-ES5 environments. */\n  var undefined;\n\n  /** Used as the semantic version number. */\n  var VERSION = '4.17.21';\n\n  /** Used as the size to enable large array optimizations. */\n  var LARGE_ARRAY_SIZE = 200;\n\n  /** Error message constants. */\n  var CORE_ERROR_TEXT = 'Unsupported core-js use. Try https://npms.io/search?q=ponyfill.',\n      FUNC_ERROR_TEXT = 'Expected a function',\n      INVALID_TEMPL_VAR_ERROR_TEXT = 'Invalid `variable` option passed into `_.template`';\n\n  /** Used to stand-in for `undefined` hash values. */\n  var HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n  /** Used as the maximum memoize cache size. */\n  var MAX_MEMOIZE_SIZE = 500;\n\n  /** Used as the internal argument placeholder. */\n  var PLACEHOLDER = '__lodash_placeholder__';\n\n  /** Used to compose bitmasks for cloning. */\n  var CLONE_DEEP_FLAG = 1,\n      CLONE_FLAT_FLAG = 2,\n      CLONE_SYMBOLS_FLAG = 4;\n\n  /** Used to compose bitmasks for value comparisons. */\n  var COMPARE_PARTIAL_FLAG = 1,\n      COMPARE_UNORDERED_FLAG = 2;\n\n  /** Used to compose bitmasks for function metadata. */\n  var WRAP_BIND_FLAG = 1,\n      WRAP_BIND_KEY_FLAG = 2,\n      WRAP_CURRY_BOUND_FLAG = 4,\n      WRAP_CURRY_FLAG = 8,\n      WRAP_CURRY_RIGHT_FLAG = 16,\n      WRAP_PARTIAL_FLAG = 32,\n      WRAP_PARTIAL_RIGHT_FLAG = 64,\n      WRAP_ARY_FLAG = 128,\n      WRAP_REARG_FLAG = 256,\n      WRAP_FLIP_FLAG = 512;\n\n  /** Used as default options for `_.truncate`. */\n  var DEFAULT_TRUNC_LENGTH = 30,\n      DEFAULT_TRUNC_OMISSION = '...';\n\n  /** Used to detect hot functions by number of calls within a span of milliseconds. */\n  var HOT_COUNT = 800,\n      HOT_SPAN = 16;\n\n  /** Used to indicate the type of lazy iteratees. */\n  var LAZY_FILTER_FLAG = 1,\n      LAZY_MAP_FLAG = 2,\n      LAZY_WHILE_FLAG = 3;\n\n  /** Used as references for various `Number` constants. */\n  var INFINITY = 1 / 0,\n      MAX_SAFE_INTEGER = 9007199254740991,\n      MAX_INTEGER = 1.7976931348623157e+308,\n      NAN = 0 / 0;\n\n  /** Used as references for the maximum length and index of an array. */\n  var MAX_ARRAY_LENGTH = 4294967295,\n      MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH - 1,\n      HALF_MAX_ARRAY_LENGTH = MAX_ARRAY_LENGTH >>> 1;\n\n  /** Used to associate wrap methods with their bit flags. */\n  var wrapFlags = [\n    ['ary', WRAP_ARY_FLAG],\n    ['bind', WRAP_BIND_FLAG],\n    ['bindKey', WRAP_BIND_KEY_FLAG],\n    ['curry', WRAP_CURRY_FLAG],\n    ['curryRight', WRAP_CURRY_RIGHT_FLAG],\n    ['flip', WRAP_FLIP_FLAG],\n    ['partial', WRAP_PARTIAL_FLAG],\n    ['partialRight', WRAP_PARTIAL_RIGHT_FLAG],\n    ['rearg', WRAP_REARG_FLAG]\n  ];\n\n  /** `Object#toString` result references. */\n  var argsTag = '[object Arguments]',\n      arrayTag = '[object Array]',\n      asyncTag = '[object AsyncFunction]',\n      boolTag = '[object Boolean]',\n      dateTag = '[object Date]',\n      domExcTag = '[object DOMException]',\n      errorTag = '[object Error]',\n      funcTag = '[object Function]',\n      genTag = '[object GeneratorFunction]',\n      mapTag = '[object Map]',\n      numberTag = '[object Number]',\n      nullTag = '[object Null]',\n      objectTag = '[object Object]',\n      promiseTag = '[object Promise]',\n      proxyTag = '[object Proxy]',\n      regexpTag = '[object RegExp]',\n      setTag = '[object Set]',\n      stringTag = '[object String]',\n      symbolTag = '[object Symbol]',\n      undefinedTag = '[object Undefined]',\n      weakMapTag = '[object WeakMap]',\n      weakSetTag = '[object WeakSet]';\n\n  var arrayBufferTag = '[object ArrayBuffer]',\n      dataViewTag = '[object DataView]',\n      float32Tag = '[object Float32Array]',\n      float64Tag = '[object Float64Array]',\n      int8Tag = '[object Int8Array]',\n      int16Tag = '[object Int16Array]',\n      int32Tag = '[object Int32Array]',\n      uint8Tag = '[object Uint8Array]',\n      uint8ClampedTag = '[object Uint8ClampedArray]',\n      uint16Tag = '[object Uint16Array]',\n      uint32Tag = '[object Uint32Array]';\n\n  /** Used to match empty string literals in compiled template source. */\n  var reEmptyStringLeading = /\\b__p \\+= '';/g,\n      reEmptyStringMiddle = /\\b(__p \\+=) '' \\+/g,\n      reEmptyStringTrailing = /(__e\\(.*?\\)|\\b__t\\)) \\+\\n'';/g;\n\n  /** Used to match HTML entities and HTML characters. */\n  var reEscapedHtml = /&(?:amp|lt|gt|quot|#39);/g,\n      reUnescapedHtml = /[&<>\"']/g,\n      reHasEscapedHtml = RegExp(reEscapedHtml.source),\n      reHasUnescapedHtml = RegExp(reUnescapedHtml.source);\n\n  /** Used to match template delimiters. */\n  var reEscape = /<%-([\\s\\S]+?)%>/g,\n      reEvaluate = /<%([\\s\\S]+?)%>/g,\n      reInterpolate = /<%=([\\s\\S]+?)%>/g;\n\n  /** Used to match property names within property paths. */\n  var reIsDeepProp = /\\.|\\[(?:[^[\\]]*|([\"'])(?:(?!\\1)[^\\\\]|\\\\.)*?\\1)\\]/,\n      reIsPlainProp = /^\\w*$/,\n      rePropName = /[^.[\\]]+|\\[(?:(-?\\d+(?:\\.\\d+)?)|([\"'])((?:(?!\\2)[^\\\\]|\\\\.)*?)\\2)\\]|(?=(?:\\.|\\[\\])(?:\\.|\\[\\]|$))/g;\n\n  /**\n   * Used to match `RegExp`\n   * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).\n   */\n  var reRegExpChar = /[\\\\^$.*+?()[\\]{}|]/g,\n      reHasRegExpChar = RegExp(reRegExpChar.source);\n\n  /** Used to match leading whitespace. */\n  var reTrimStart = /^\\s+/;\n\n  /** Used to match a single whitespace character. */\n  var reWhitespace = /\\s/;\n\n  /** Used to match wrap detail comments. */\n  var reWrapComment = /\\{(?:\\n\\/\\* \\[wrapped with .+\\] \\*\\/)?\\n?/,\n      reWrapDetails = /\\{\\n\\/\\* \\[wrapped with (.+)\\] \\*/,\n      reSplitDetails = /,? & /;\n\n  /** Used to match words composed of alphanumeric characters. */\n  var reAsciiWord = /[^\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\x7f]+/g;\n\n  /**\n   * Used to validate the `validate` option in `_.template` variable.\n   *\n   * Forbids characters which could potentially change the meaning of the function argument definition:\n   * - \"(),\" (modification of function parameters)\n   * - \"=\" (default value)\n   * - \"[]{}\" (destructuring of function parameters)\n   * - \"/\" (beginning of a comment)\n   * - whitespace\n   */\n  var reForbiddenIdentifierChars = /[()=,{}\\[\\]\\/\\s]/;\n\n  /** Used to match backslashes in property paths. */\n  var reEscapeChar = /\\\\(\\\\)?/g;\n\n  /**\n   * Used to match\n   * [ES template delimiters](http://ecma-international.org/ecma-262/7.0/#sec-template-literal-lexical-components).\n   */\n  var reEsTemplate = /\\$\\{([^\\\\}]*(?:\\\\.[^\\\\}]*)*)\\}/g;\n\n  /** Used to match `RegExp` flags from their coerced string values. */\n  var reFlags = /\\w*$/;\n\n  /** Used to detect bad signed hexadecimal string values. */\n  var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;\n\n  /** Used to detect binary string values. */\n  var reIsBinary = /^0b[01]+$/i;\n\n  /** Used to detect host constructors (Safari). */\n  var reIsHostCtor = /^\\[object .+?Constructor\\]$/;\n\n  /** Used to detect octal string values. */\n  var reIsOctal = /^0o[0-7]+$/i;\n\n  /** Used to detect unsigned integer values. */\n  var reIsUint = /^(?:0|[1-9]\\d*)$/;\n\n  /** Used to match Latin Unicode letters (excluding mathematical operators). */\n  var reLatin = /[\\xc0-\\xd6\\xd8-\\xf6\\xf8-\\xff\\u0100-\\u017f]/g;\n\n  /** Used to ensure capturing order of template delimiters. */\n  var reNoMatch = /($^)/;\n\n  /** Used to match unescaped characters in compiled string literals. */\n  var reUnescapedString = /['\\n\\r\\u2028\\u2029\\\\]/g;\n\n  /** Used to compose unicode character classes. */\n  var rsAstralRange = '\\\\ud800-\\\\udfff',\n      rsComboMarksRange = '\\\\u0300-\\\\u036f',\n      reComboHalfMarksRange = '\\\\ufe20-\\\\ufe2f',\n      rsComboSymbolsRange = '\\\\u20d0-\\\\u20ff',\n      rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange,\n      rsDingbatRange = '\\\\u2700-\\\\u27bf',\n      rsLowerRange = 'a-z\\\\xdf-\\\\xf6\\\\xf8-\\\\xff',\n      rsMathOpRange = '\\\\xac\\\\xb1\\\\xd7\\\\xf7',\n      rsNonCharRange = '\\\\x00-\\\\x2f\\\\x3a-\\\\x40\\\\x5b-\\\\x60\\\\x7b-\\\\xbf',\n      rsPunctuationRange = '\\\\u2000-\\\\u206f',\n      rsSpaceRange = ' \\\\t\\\\x0b\\\\f\\\\xa0\\\\ufeff\\\\n\\\\r\\\\u2028\\\\u2029\\\\u1680\\\\u180e\\\\u2000\\\\u2001\\\\u2002\\\\u2003\\\\u2004\\\\u2005\\\\u2006\\\\u2007\\\\u2008\\\\u2009\\\\u200a\\\\u202f\\\\u205f\\\\u3000',\n      rsUpperRange = 'A-Z\\\\xc0-\\\\xd6\\\\xd8-\\\\xde',\n      rsVarRange = '\\\\ufe0e\\\\ufe0f',\n      rsBreakRange = rsMathOpRange + rsNonCharRange + rsPunctuationRange + rsSpaceRange;\n\n  /** Used to compose unicode capture groups. */\n  var rsApos = \"['\\u2019]\",\n      rsAstral = '[' + rsAstralRange + ']',\n      rsBreak = '[' + rsBreakRange + ']',\n      rsCombo = '[' + rsComboRange + ']',\n      rsDigits = '\\\\d+',\n      rsDingbat = '[' + rsDingbatRange + ']',\n      rsLower = '[' + rsLowerRange + ']',\n      rsMisc = '[^' + rsAstralRange + rsBreakRange + rsDigits + rsDingbatRange + rsLowerRange + rsUpperRange + ']',\n      rsFitz = '\\\\ud83c[\\\\udffb-\\\\udfff]',\n      rsModifier = '(?:' + rsCombo + '|' + rsFitz + ')',\n      rsNonAstral = '[^' + rsAstralRange + ']',\n      rsRegional = '(?:\\\\ud83c[\\\\udde6-\\\\uddff]){2}',\n      rsSurrPair = '[\\\\ud800-\\\\udbff][\\\\udc00-\\\\udfff]',\n      rsUpper = '[' + rsUpperRange + ']',\n      rsZWJ = '\\\\u200d';\n\n  /** Used to compose unicode regexes. */\n  var rsMiscLower = '(?:' + rsLower + '|' + rsMisc + ')',\n      rsMiscUpper = '(?:' + rsUpper + '|' + rsMisc + ')',\n      rsOptContrLower = '(?:' + rsApos + '(?:d|ll|m|re|s|t|ve))?',\n      rsOptContrUpper = '(?:' + rsApos + '(?:D|LL|M|RE|S|T|VE))?',\n      reOptMod = rsModifier + '?',\n      rsOptVar = '[' + rsVarRange + ']?',\n      rsOptJoin = '(?:' + rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVar + reOptMod + ')*',\n      rsOrdLower = '\\\\d*(?:1st|2nd|3rd|(?![123])\\\\dth)(?=\\\\b|[A-Z_])',\n      rsOrdUpper = '\\\\d*(?:1ST|2ND|3RD|(?![123])\\\\dTH)(?=\\\\b|[a-z_])',\n      rsSeq = rsOptVar + reOptMod + rsOptJoin,\n      rsEmoji = '(?:' + [rsDingbat, rsRegional, rsSurrPair].join('|') + ')' + rsSeq,\n      rsSymbol = '(?:' + [rsNonAstral + rsCombo + '?', rsCombo, rsRegional, rsSurrPair, rsAstral].join('|') + ')';\n\n  /** Used to match apostrophes. */\n  var reApos = RegExp(rsApos, 'g');\n\n  /**\n   * Used to match [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks) and\n   * [combining diacritical marks for symbols](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks_for_Symbols).\n   */\n  var reComboMark = RegExp(rsCombo, 'g');\n\n  /** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */\n  var reUnicode = RegExp(rsFitz + '(?=' + rsFitz + ')|' + rsSymbol + rsSeq, 'g');\n\n  /** Used to match complex or compound words. */\n  var reUnicodeWord = RegExp([\n    rsUpper + '?' + rsLower + '+' + rsOptContrLower + '(?=' + [rsBreak, rsUpper, '$'].join('|') + ')',\n    rsMiscUpper + '+' + rsOptContrUpper + '(?=' + [rsBreak, rsUpper + rsMiscLower, '$'].join('|') + ')',\n    rsUpper + '?' + rsMiscLower + '+' + rsOptContrLower,\n    rsUpper + '+' + rsOptContrUpper,\n    rsOrdUpper,\n    rsOrdLower,\n    rsDigits,\n    rsEmoji\n  ].join('|'), 'g');\n\n  /** Used to detect strings with [zero-width joiners or code points from the astral planes](http://eev.ee/blog/2015/09/12/dark-corners-of-unicode/). */\n  var reHasUnicode = RegExp('[' + rsZWJ + rsAstralRange  + rsComboRange + rsVarRange + ']');\n\n  /** Used to detect strings that need a more robust regexp to match words. */\n  var reHasUnicodeWord = /[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/;\n\n  /** Used to assign default `context` object properties. */\n  var contextProps = [\n    'Array', 'Buffer', 'DataView', 'Date', 'Error', 'Float32Array', 'Float64Array',\n    'Function', 'Int8Array', 'Int16Array', 'Int32Array', 'Map', 'Math', 'Object',\n    'Promise', 'RegExp', 'Set', 'String', 'Symbol', 'TypeError', 'Uint8Array',\n    'Uint8ClampedArray', 'Uint16Array', 'Uint32Array', 'WeakMap',\n    '_', 'clearTimeout', 'isFinite', 'parseInt', 'setTimeout'\n  ];\n\n  /** Used to make template sourceURLs easier to identify. */\n  var templateCounter = -1;\n\n  /** Used to identify `toStringTag` values of typed arrays. */\n  var typedArrayTags = {};\n  typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =\n  typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =\n  typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =\n  typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =\n  typedArrayTags[uint32Tag] = true;\n  typedArrayTags[argsTag] = typedArrayTags[arrayTag] =\n  typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =\n  typedArrayTags[dataViewTag] = typedArrayTags[dateTag] =\n  typedArrayTags[errorTag] = typedArrayTags[funcTag] =\n  typedArrayTags[mapTag] = typedArrayTags[numberTag] =\n  typedArrayTags[objectTag] = typedArrayTags[regexpTag] =\n  typedArrayTags[setTag] = typedArrayTags[stringTag] =\n  typedArrayTags[weakMapTag] = false;\n\n  /** Used to identify `toStringTag` values supported by `_.clone`. */\n  var cloneableTags = {};\n  cloneableTags[argsTag] = cloneableTags[arrayTag] =\n  cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] =\n  cloneableTags[boolTag] = cloneableTags[dateTag] =\n  cloneableTags[float32Tag] = cloneableTags[float64Tag] =\n  cloneableTags[int8Tag] = cloneableTags[int16Tag] =\n  cloneableTags[int32Tag] = cloneableTags[mapTag] =\n  cloneableTags[numberTag] = cloneableTags[objectTag] =\n  cloneableTags[regexpTag] = cloneableTags[setTag] =\n  cloneableTags[stringTag] = cloneableTags[symbolTag] =\n  cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =\n  cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;\n  cloneableTags[errorTag] = cloneableTags[funcTag] =\n  cloneableTags[weakMapTag] = false;\n\n  /** Used to map Latin Unicode letters to basic Latin letters. */\n  var deburredLetters = {\n    // Latin-1 Supplement block.\n    '\\xc0': 'A',  '\\xc1': 'A', '\\xc2': 'A', '\\xc3': 'A', '\\xc4': 'A', '\\xc5': 'A',\n    '\\xe0': 'a',  '\\xe1': 'a', '\\xe2': 'a', '\\xe3': 'a', '\\xe4': 'a', '\\xe5': 'a',\n    '\\xc7': 'C',  '\\xe7': 'c',\n    '\\xd0': 'D',  '\\xf0': 'd',\n    '\\xc8': 'E',  '\\xc9': 'E', '\\xca': 'E', '\\xcb': 'E',\n    '\\xe8': 'e',  '\\xe9': 'e', '\\xea': 'e', '\\xeb': 'e',\n    '\\xcc': 'I',  '\\xcd': 'I', '\\xce': 'I', '\\xcf': 'I',\n    '\\xec': 'i',  '\\xed': 'i', '\\xee': 'i', '\\xef': 'i',\n    '\\xd1': 'N',  '\\xf1': 'n',\n    '\\xd2': 'O',  '\\xd3': 'O', '\\xd4': 'O', '\\xd5': 'O', '\\xd6': 'O', '\\xd8': 'O',\n    '\\xf2': 'o',  '\\xf3': 'o', '\\xf4': 'o', '\\xf5': 'o', '\\xf6': 'o', '\\xf8': 'o',\n    '\\xd9': 'U',  '\\xda': 'U', '\\xdb': 'U', '\\xdc': 'U',\n    '\\xf9': 'u',  '\\xfa': 'u', '\\xfb': 'u', '\\xfc': 'u',\n    '\\xdd': 'Y',  '\\xfd': 'y', '\\xff': 'y',\n    '\\xc6': 'Ae', '\\xe6': 'ae',\n    '\\xde': 'Th', '\\xfe': 'th',\n    '\\xdf': 'ss',\n    // Latin Extended-A block.\n    '\\u0100': 'A',  '\\u0102': 'A', '\\u0104': 'A',\n    '\\u0101': 'a',  '\\u0103': 'a', '\\u0105': 'a',\n    '\\u0106': 'C',  '\\u0108': 'C', '\\u010a': 'C', '\\u010c': 'C',\n    '\\u0107': 'c',  '\\u0109': 'c', '\\u010b': 'c', '\\u010d': 'c',\n    '\\u010e': 'D',  '\\u0110': 'D', '\\u010f': 'd', '\\u0111': 'd',\n    '\\u0112': 'E',  '\\u0114': 'E', '\\u0116': 'E', '\\u0118': 'E', '\\u011a': 'E',\n    '\\u0113': 'e',  '\\u0115': 'e', '\\u0117': 'e', '\\u0119': 'e', '\\u011b': 'e',\n    '\\u011c': 'G',  '\\u011e': 'G', '\\u0120': 'G', '\\u0122': 'G',\n    '\\u011d': 'g',  '\\u011f': 'g', '\\u0121': 'g', '\\u0123': 'g',\n    '\\u0124': 'H',  '\\u0126': 'H', '\\u0125': 'h', '\\u0127': 'h',\n    '\\u0128': 'I',  '\\u012a': 'I', '\\u012c': 'I', '\\u012e': 'I', '\\u0130': 'I',\n    '\\u0129': 'i',  '\\u012b': 'i', '\\u012d': 'i', '\\u012f': 'i', '\\u0131': 'i',\n    '\\u0134': 'J',  '\\u0135': 'j',\n    '\\u0136': 'K',  '\\u0137': 'k', '\\u0138': 'k',\n    '\\u0139': 'L',  '\\u013b': 'L', '\\u013d': 'L', '\\u013f': 'L', '\\u0141': 'L',\n    '\\u013a': 'l',  '\\u013c': 'l', '\\u013e': 'l', '\\u0140': 'l', '\\u0142': 'l',\n    '\\u0143': 'N',  '\\u0145': 'N', '\\u0147': 'N', '\\u014a': 'N',\n    '\\u0144': 'n',  '\\u0146': 'n', '\\u0148': 'n', '\\u014b': 'n',\n    '\\u014c': 'O',  '\\u014e': 'O', '\\u0150': 'O',\n    '\\u014d': 'o',  '\\u014f': 'o', '\\u0151': 'o',\n    '\\u0154': 'R',  '\\u0156': 'R', '\\u0158': 'R',\n    '\\u0155': 'r',  '\\u0157': 'r', '\\u0159': 'r',\n    '\\u015a': 'S',  '\\u015c': 'S', '\\u015e': 'S', '\\u0160': 'S',\n    '\\u015b': 's',  '\\u015d': 's', '\\u015f': 's', '\\u0161': 's',\n    '\\u0162': 'T',  '\\u0164': 'T', '\\u0166': 'T',\n    '\\u0163': 't',  '\\u0165': 't', '\\u0167': 't',\n    '\\u0168': 'U',  '\\u016a': 'U', '\\u016c': 'U', '\\u016e': 'U', '\\u0170': 'U', '\\u0172': 'U',\n    '\\u0169': 'u',  '\\u016b': 'u', '\\u016d': 'u', '\\u016f': 'u', '\\u0171': 'u', '\\u0173': 'u',\n    '\\u0174': 'W',  '\\u0175': 'w',\n    '\\u0176': 'Y',  '\\u0177': 'y', '\\u0178': 'Y',\n    '\\u0179': 'Z',  '\\u017b': 'Z', '\\u017d': 'Z',\n    '\\u017a': 'z',  '\\u017c': 'z', '\\u017e': 'z',\n    '\\u0132': 'IJ', '\\u0133': 'ij',\n    '\\u0152': 'Oe', '\\u0153': 'oe',\n    '\\u0149': \"'n\", '\\u017f': 's'\n  };\n\n  /** Used to map characters to HTML entities. */\n  var htmlEscapes = {\n    '&': '&amp;',\n    '<': '&lt;',\n    '>': '&gt;',\n    '\"': '&quot;',\n    \"'\": '&#39;'\n  };\n\n  /** Used to map HTML entities to characters. */\n  var htmlUnescapes = {\n    '&amp;': '&',\n    '&lt;': '<',\n    '&gt;': '>',\n    '&quot;': '\"',\n    '&#39;': \"'\"\n  };\n\n  /** Used to escape characters for inclusion in compiled string literals. */\n  var stringEscapes = {\n    '\\\\': '\\\\',\n    \"'\": \"'\",\n    '\\n': 'n',\n    '\\r': 'r',\n    '\\u2028': 'u2028',\n    '\\u2029': 'u2029'\n  };\n\n  /** Built-in method references without a dependency on `root`. */\n  var freeParseFloat = parseFloat,\n      freeParseInt = parseInt;\n\n  /** Detect free variable `global` from Node.js. */\n  var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\n  /** Detect free variable `self`. */\n  var freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n  /** Used as a reference to the global object. */\n  var root = freeGlobal || freeSelf || Function('return this')();\n\n  /** Detect free variable `exports`. */\n  var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n  /** Detect free variable `module`. */\n  var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n  /** Detect the popular CommonJS extension `module.exports`. */\n  var moduleExports = freeModule && freeModule.exports === freeExports;\n\n  /** Detect free variable `process` from Node.js. */\n  var freeProcess = moduleExports && freeGlobal.process;\n\n  /** Used to access faster Node.js helpers. */\n  var nodeUtil = (function() {\n    try {\n      // Use `util.types` for Node.js 10+.\n      var types = freeModule && freeModule.require && freeModule.require('util').types;\n\n      if (types) {\n        return types;\n      }\n\n      // Legacy `process.binding('util')` for Node.js < 10.\n      return freeProcess && freeProcess.binding && freeProcess.binding('util');\n    } catch (e) {}\n  }());\n\n  /* Node.js helper references. */\n  var nodeIsArrayBuffer = nodeUtil && nodeUtil.isArrayBuffer,\n      nodeIsDate = nodeUtil && nodeUtil.isDate,\n      nodeIsMap = nodeUtil && nodeUtil.isMap,\n      nodeIsRegExp = nodeUtil && nodeUtil.isRegExp,\n      nodeIsSet = nodeUtil && nodeUtil.isSet,\n      nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;\n\n  /*--------------------------------------------------------------------------*/\n\n  /**\n   * A faster alternative to `Function#apply`, this function invokes `func`\n   * with the `this` binding of `thisArg` and the arguments of `args`.\n   *\n   * @private\n   * @param {Function} func The function to invoke.\n   * @param {*} thisArg The `this` binding of `func`.\n   * @param {Array} args The arguments to invoke `func` with.\n   * @returns {*} Returns the result of `func`.\n   */\n  function apply(func, thisArg, args) {\n    switch (args.length) {\n      case 0: return func.call(thisArg);\n      case 1: return func.call(thisArg, args[0]);\n      case 2: return func.call(thisArg, args[0], args[1]);\n      case 3: return func.call(thisArg, args[0], args[1], args[2]);\n    }\n    return func.apply(thisArg, args);\n  }\n\n  /**\n   * A specialized version of `baseAggregator` for arrays.\n   *\n   * @private\n   * @param {Array} [array] The array to iterate over.\n   * @param {Function} setter The function to set `accumulator` values.\n   * @param {Function} iteratee The iteratee to transform keys.\n   * @param {Object} accumulator The initial aggregated object.\n   * @returns {Function} Returns `accumulator`.\n   */\n  function arrayAggregator(array, setter, iteratee, accumulator) {\n    var index = -1,\n        length = array == null ? 0 : array.length;\n\n    while (++index < length) {\n      var value = array[index];\n      setter(accumulator, value, iteratee(value), array);\n    }\n    return accumulator;\n  }\n\n  /**\n   * A specialized version of `_.forEach` for arrays without support for\n   * iteratee shorthands.\n   *\n   * @private\n   * @param {Array} [array] The array to iterate over.\n   * @param {Function} iteratee The function invoked per iteration.\n   * @returns {Array} Returns `array`.\n   */\n  function arrayEach(array, iteratee) {\n    var index = -1,\n        length = array == null ? 0 : array.length;\n\n    while (++index < length) {\n      if (iteratee(array[index], index, array) === false) {\n        break;\n      }\n    }\n    return array;\n  }\n\n  /**\n   * A specialized version of `_.forEachRight` for arrays without support for\n   * iteratee shorthands.\n   *\n   * @private\n   * @param {Array} [array] The array to iterate over.\n   * @param {Function} iteratee The function invoked per iteration.\n   * @returns {Array} Returns `array`.\n   */\n  function arrayEachRight(array, iteratee) {\n    var length = array == null ? 0 : array.length;\n\n    while (length--) {\n      if (iteratee(array[length], length, array) === false) {\n        break;\n      }\n    }\n    return array;\n  }\n\n  /**\n   * A specialized version of `_.every` for arrays without support for\n   * iteratee shorthands.\n   *\n   * @private\n   * @param {Array} [array] The array to iterate over.\n   * @param {Function} predicate The function invoked per iteration.\n   * @returns {boolean} Returns `true` if all elements pass the predicate check,\n   *  else `false`.\n   */\n  function arrayEvery(array, predicate) {\n    var index = -1,\n        length = array == null ? 0 : array.length;\n\n    while (++index < length) {\n      if (!predicate(array[index], index, array)) {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  /**\n   * A specialized version of `_.filter` for arrays without support for\n   * iteratee shorthands.\n   *\n   * @private\n   * @param {Array} [array] The array to iterate over.\n   * @param {Function} predicate The function invoked per iteration.\n   * @returns {Array} Returns the new filtered array.\n   */\n  function arrayFilter(array, predicate) {\n    var index = -1,\n        length = array == null ? 0 : array.length,\n        resIndex = 0,\n        result = [];\n\n    while (++index < length) {\n      var value = array[index];\n      if (predicate(value, index, array)) {\n        result[resIndex++] = value;\n      }\n    }\n    return result;\n  }\n\n  /**\n   * A specialized version of `_.includes` for arrays without support for\n   * specifying an index to search from.\n   *\n   * @private\n   * @param {Array} [array] The array to inspect.\n   * @param {*} target The value to search for.\n   * @returns {boolean} Returns `true` if `target` is found, else `false`.\n   */\n  function arrayIncludes(array, value) {\n    var length = array == null ? 0 : array.length;\n    return !!length && baseIndexOf(array, value, 0) > -1;\n  }\n\n  /**\n   * This function is like `arrayIncludes` except that it accepts a comparator.\n   *\n   * @private\n   * @param {Array} [array] The array to inspect.\n   * @param {*} target The value to search for.\n   * @param {Function} comparator The comparator invoked per element.\n   * @returns {boolean} Returns `true` if `target` is found, else `false`.\n   */\n  function arrayIncludesWith(array, value, comparator) {\n    var index = -1,\n        length = array == null ? 0 : array.length;\n\n    while (++index < length) {\n      if (comparator(value, array[index])) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  /**\n   * A specialized version of `_.map` for arrays without support for iteratee\n   * shorthands.\n   *\n   * @private\n   * @param {Array} [array] The array to iterate over.\n   * @param {Function} iteratee The function invoked per iteration.\n   * @returns {Array} Returns the new mapped array.\n   */\n  function arrayMap(array, iteratee) {\n    var index = -1,\n        length = array == null ? 0 : array.length,\n        result = Array(length);\n\n    while (++index < length) {\n      result[index] = iteratee(array[index], index, array);\n    }\n    return result;\n  }\n\n  /**\n   * Appends the elements of `values` to `array`.\n   *\n   * @private\n   * @param {Array} array The array to modify.\n   * @param {Array} values The values to append.\n   * @returns {Array} Returns `array`.\n   */\n  function arrayPush(array, values) {\n    var index = -1,\n        length = values.length,\n        offset = array.length;\n\n    while (++index < length) {\n      array[offset + index] = values[index];\n    }\n    return array;\n  }\n\n  /**\n   * A specialized version of `_.reduce` for arrays without support for\n   * iteratee shorthands.\n   *\n   * @private\n   * @param {Array} [array] The array to iterate over.\n   * @param {Function} iteratee The function invoked per iteration.\n   * @param {*} [accumulator] The initial value.\n   * @param {boolean} [initAccum] Specify using the first element of `array` as\n   *  the initial value.\n   * @returns {*} Returns the accumulated value.\n   */\n  function arrayReduce(array, iteratee, accumulator, initAccum) {\n    var index = -1,\n        length = array == null ? 0 : array.length;\n\n    if (initAccum && length) {\n      accumulator = array[++index];\n    }\n    while (++index < length) {\n      accumulator = iteratee(accumulator, array[index], index, array);\n    }\n    return accumulator;\n  }\n\n  /**\n   * A specialized version of `_.reduceRight` for arrays without support for\n   * iteratee shorthands.\n   *\n   * @private\n   * @param {Array} [array] The array to iterate over.\n   * @param {Function} iteratee The function invoked per iteration.\n   * @param {*} [accumulator] The initial value.\n   * @param {boolean} [initAccum] Specify using the last element of `array` as\n   *  the initial value.\n   * @returns {*} Returns the accumulated value.\n   */\n  function arrayReduceRight(array, iteratee, accumulator, initAccum) {\n    var length = array == null ? 0 : array.length;\n    if (initAccum && length) {\n      accumulator = array[--length];\n    }\n    while (length--) {\n      accumulator = iteratee(accumulator, array[length], length, array);\n    }\n    return accumulator;\n  }\n\n  /**\n   * A specialized version of `_.some` for arrays without support for iteratee\n   * shorthands.\n   *\n   * @private\n   * @param {Array} [array] The array to iterate over.\n   * @param {Function} predicate The function invoked per iteration.\n   * @returns {boolean} Returns `true` if any element passes the predicate check,\n   *  else `false`.\n   */\n  function arraySome(array, predicate) {\n    var index = -1,\n        length = array == null ? 0 : array.length;\n\n    while (++index < length) {\n      if (predicate(array[index], index, array)) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  /**\n   * Gets the size of an ASCII `string`.\n   *\n   * @private\n   * @param {string} string The string inspect.\n   * @returns {number} Returns the string size.\n   */\n  var asciiSize = baseProperty('length');\n\n  /**\n   * Converts an ASCII `string` to an array.\n   *\n   * @private\n   * @param {string} string The string to convert.\n   * @returns {Array} Returns the converted array.\n   */\n  function asciiToArray(string) {\n    return string.split('');\n  }\n\n  /**\n   * Splits an ASCII `string` into an array of its words.\n   *\n   * @private\n   * @param {string} The string to inspect.\n   * @returns {Array} Returns the words of `string`.\n   */\n  function asciiWords(string) {\n    return string.match(reAsciiWord) || [];\n  }\n\n  /**\n   * The base implementation of methods like `_.findKey` and `_.findLastKey`,\n   * without support for iteratee shorthands, which iterates over `collection`\n   * using `eachFunc`.\n   *\n   * @private\n   * @param {Array|Object} collection The collection to inspect.\n   * @param {Function} predicate The function invoked per iteration.\n   * @param {Function} eachFunc The function to iterate over `collection`.\n   * @returns {*} Returns the found element or its key, else `undefined`.\n   */\n  function baseFindKey(collection, predicate, eachFunc) {\n    var result;\n    eachFunc(collection, function(value, key, collection) {\n      if (predicate(value, key, collection)) {\n        result = key;\n        return false;\n      }\n    });\n    return result;\n  }\n\n  /**\n   * The base implementation of `_.findIndex` and `_.findLastIndex` without\n   * support for iteratee shorthands.\n   *\n   * @private\n   * @param {Array} array The array to inspect.\n   * @param {Function} predicate The function invoked per iteration.\n   * @param {number} fromIndex The index to search from.\n   * @param {boolean} [fromRight] Specify iterating from right to left.\n   * @returns {number} Returns the index of the matched value, else `-1`.\n   */\n  function baseFindIndex(array, predicate, fromIndex, fromRight) {\n    var length = array.length,\n        index = fromIndex + (fromRight ? 1 : -1);\n\n    while ((fromRight ? index-- : ++index < length)) {\n      if (predicate(array[index], index, array)) {\n        return index;\n      }\n    }\n    return -1;\n  }\n\n  /**\n   * The base implementation of `_.indexOf` without `fromIndex` bounds checks.\n   *\n   * @private\n   * @param {Array} array The array to inspect.\n   * @param {*} value The value to search for.\n   * @param {number} fromIndex The index to search from.\n   * @returns {number} Returns the index of the matched value, else `-1`.\n   */\n  function baseIndexOf(array, value, fromIndex) {\n    return value === value\n      ? strictIndexOf(array, value, fromIndex)\n      : baseFindIndex(array, baseIsNaN, fromIndex);\n  }\n\n  /**\n   * This function is like `baseIndexOf` except that it accepts a comparator.\n   *\n   * @private\n   * @param {Array} array The array to inspect.\n   * @param {*} value The value to search for.\n   * @param {number} fromIndex The index to search from.\n   * @param {Function} comparator The comparator invoked per element.\n   * @returns {number} Returns the index of the matched value, else `-1`.\n   */\n  function baseIndexOfWith(array, value, fromIndex, comparator) {\n    var index = fromIndex - 1,\n        length = array.length;\n\n    while (++index < length) {\n      if (comparator(array[index], value)) {\n        return index;\n      }\n    }\n    return -1;\n  }\n\n  /**\n   * The base implementation of `_.isNaN` without support for number objects.\n   *\n   * @private\n   * @param {*} value The value to check.\n   * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.\n   */\n  function baseIsNaN(value) {\n    return value !== value;\n  }\n\n  /**\n   * The base implementation of `_.mean` and `_.meanBy` without support for\n   * iteratee shorthands.\n   *\n   * @private\n   * @param {Array} array The array to iterate over.\n   * @param {Function} iteratee The function invoked per iteration.\n   * @returns {number} Returns the mean.\n   */\n  function baseMean(array, iteratee) {\n    var length = array == null ? 0 : array.length;\n    return length ? (baseSum(array, iteratee) / length) : NAN;\n  }\n\n  /**\n   * The base implementation of `_.property` without support for deep paths.\n   *\n   * @private\n   * @param {string} key The key of the property to get.\n   * @returns {Function} Returns the new accessor function.\n   */\n  function baseProperty(key) {\n    return function(object) {\n      return object == null ? undefined : object[key];\n    };\n  }\n\n  /**\n   * The base implementation of `_.propertyOf` without support for deep paths.\n   *\n   * @private\n   * @param {Object} object The object to query.\n   * @returns {Function} Returns the new accessor function.\n   */\n  function basePropertyOf(object) {\n    return function(key) {\n      return object == null ? undefined : object[key];\n    };\n  }\n\n  /**\n   * The base implementation of `_.reduce` and `_.reduceRight`, without support\n   * for iteratee shorthands, which iterates over `collection` using `eachFunc`.\n   *\n   * @private\n   * @param {Array|Object} collection The collection to iterate over.\n   * @param {Function} iteratee The function invoked per iteration.\n   * @param {*} accumulator The initial value.\n   * @param {boolean} initAccum Specify using the first or last element of\n   *  `collection` as the initial value.\n   * @param {Function} eachFunc The function to iterate over `collection`.\n   * @returns {*} Returns the accumulated value.\n   */\n  function baseReduce(collection, iteratee, accumulator, initAccum, eachFunc) {\n    eachFunc(collection, function(value, index, collection) {\n      accumulator = initAccum\n        ? (initAccum = false, value)\n        : iteratee(accumulator, value, index, collection);\n    });\n    return accumulator;\n  }\n\n  /**\n   * The base implementation of `_.sortBy` which uses `comparer` to define the\n   * sort order of `array` and replaces criteria objects with their corresponding\n   * values.\n   *\n   * @private\n   * @param {Array} array The array to sort.\n   * @param {Function} comparer The function to define sort order.\n   * @returns {Array} Returns `array`.\n   */\n  function baseSortBy(array, comparer) {\n    var length = array.length;\n\n    array.sort(comparer);\n    while (length--) {\n      array[length] = array[length].value;\n    }\n    return array;\n  }\n\n  /**\n   * The base implementation of `_.sum` and `_.sumBy` without support for\n   * iteratee shorthands.\n   *\n   * @private\n   * @param {Array} array The array to iterate over.\n   * @param {Function} iteratee The function invoked per iteration.\n   * @returns {number} Returns the sum.\n   */\n  function baseSum(array, iteratee) {\n    var result,\n        index = -1,\n        length = array.length;\n\n    while (++index < length) {\n      var current = iteratee(array[index]);\n      if (current !== undefined) {\n        result = result === undefined ? current : (result + current);\n      }\n    }\n    return result;\n  }\n\n  /**\n   * The base implementation of `_.times` without support for iteratee shorthands\n   * or max array length checks.\n   *\n   * @private\n   * @param {number} n The number of times to invoke `iteratee`.\n   * @param {Function} iteratee The function invoked per iteration.\n   * @returns {Array} Returns the array of results.\n   */\n  function baseTimes(n, iteratee) {\n    var index = -1,\n        result = Array(n);\n\n    while (++index < n) {\n      result[index] = iteratee(index);\n    }\n    return result;\n  }\n\n  /**\n   * The base implementation of `_.toPairs` and `_.toPairsIn` which creates an array\n   * of key-value pairs for `object` corresponding to the property names of `props`.\n   *\n   * @private\n   * @param {Object} object The object to query.\n   * @param {Array} props The property names to get values for.\n   * @returns {Object} Returns the key-value pairs.\n   */\n  function baseToPairs(object, props) {\n    return arrayMap(props, function(key) {\n      return [key, object[key]];\n    });\n  }\n\n  /**\n   * The base implementation of `_.trim`.\n   *\n   * @private\n   * @param {string} string The string to trim.\n   * @returns {string} Returns the trimmed string.\n   */\n  function baseTrim(string) {\n    return string\n      ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, '')\n      : string;\n  }\n\n  /**\n   * The base implementation of `_.unary` without support for storing metadata.\n   *\n   * @private\n   * @param {Function} func The function to cap arguments for.\n   * @returns {Function} Returns the new capped function.\n   */\n  function baseUnary(func) {\n    return function(value) {\n      return func(value);\n    };\n  }\n\n  /**\n   * The base implementation of `_.values` and `_.valuesIn` which creates an\n   * array of `object` property values corresponding to the property names\n   * of `props`.\n   *\n   * @private\n   * @param {Object} object The object to query.\n   * @param {Array} props The property names to get values for.\n   * @returns {Object} Returns the array of property values.\n   */\n  function baseValues(object, props) {\n    return arrayMap(props, function(key) {\n      return object[key];\n    });\n  }\n\n  /**\n   * Checks if a `cache` value for `key` exists.\n   *\n   * @private\n   * @param {Object} cache The cache to query.\n   * @param {string} key The key of the entry to check.\n   * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n   */\n  function cacheHas(cache, key) {\n    return cache.has(key);\n  }\n\n  /**\n   * Used by `_.trim` and `_.trimStart` to get the index of the first string symbol\n   * that is not found in the character symbols.\n   *\n   * @private\n   * @param {Array} strSymbols The string symbols to inspect.\n   * @param {Array} chrSymbols The character symbols to find.\n   * @returns {number} Returns the index of the first unmatched string symbol.\n   */\n  function charsStartIndex(strSymbols, chrSymbols) {\n    var index = -1,\n        length = strSymbols.length;\n\n    while (++index < length && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {}\n    return index;\n  }\n\n  /**\n   * Used by `_.trim` and `_.trimEnd` to get the index of the last string symbol\n   * that is not found in the character symbols.\n   *\n   * @private\n   * @param {Array} strSymbols The string symbols to inspect.\n   * @param {Array} chrSymbols The character symbols to find.\n   * @returns {number} Returns the index of the last unmatched string symbol.\n   */\n  function charsEndIndex(strSymbols, chrSymbols) {\n    var index = strSymbols.length;\n\n    while (index-- && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {}\n    return index;\n  }\n\n  /**\n   * Gets the number of `placeholder` occurrences in `array`.\n   *\n   * @private\n   * @param {Array} array The array to inspect.\n   * @param {*} placeholder The placeholder to search for.\n   * @returns {number} Returns the placeholder count.\n   */\n  function countHolders(array, placeholder) {\n    var length = array.length,\n        result = 0;\n\n    while (length--) {\n      if (array[length] === placeholder) {\n        ++result;\n      }\n    }\n    return result;\n  }\n\n  /**\n   * Used by `_.deburr` to convert Latin-1 Supplement and Latin Extended-A\n   * letters to basic Latin letters.\n   *\n   * @private\n   * @param {string} letter The matched letter to deburr.\n   * @returns {string} Returns the deburred letter.\n   */\n  var deburrLetter = basePropertyOf(deburredLetters);\n\n  /**\n   * Used by `_.escape` to convert characters to HTML entities.\n   *\n   * @private\n   * @param {string} chr The matched character to escape.\n   * @returns {string} Returns the escaped character.\n   */\n  var escapeHtmlChar = basePropertyOf(htmlEscapes);\n\n  /**\n   * Used by `_.template` to escape characters for inclusion in compiled string literals.\n   *\n   * @private\n   * @param {string} chr The matched character to escape.\n   * @returns {string} Returns the escaped character.\n   */\n  function escapeStringChar(chr) {\n    return '\\\\' + stringEscapes[chr];\n  }\n\n  /**\n   * Gets the value at `key` of `object`.\n   *\n   * @private\n   * @param {Object} [object] The object to query.\n   * @param {string} key The key of the property to get.\n   * @returns {*} Returns the property value.\n   */\n  function getValue(object, key) {\n    return object == null ? undefined : object[key];\n  }\n\n  /**\n   * Checks if `string` contains Unicode symbols.\n   *\n   * @private\n   * @param {string} string The string to inspect.\n   * @returns {boolean} Returns `true` if a symbol is found, else `false`.\n   */\n  function hasUnicode(string) {\n    return reHasUnicode.test(string);\n  }\n\n  /**\n   * Checks if `string` contains a word composed of Unicode symbols.\n   *\n   * @private\n   * @param {string} string The string to inspect.\n   * @returns {boolean} Returns `true` if a word is found, else `false`.\n   */\n  function hasUnicodeWord(string) {\n    return reHasUnicodeWord.test(string);\n  }\n\n  /**\n   * Converts `iterator` to an array.\n   *\n   * @private\n   * @param {Object} iterator The iterator to convert.\n   * @returns {Array} Returns the converted array.\n   */\n  function iteratorToArray(iterator) {\n    var data,\n        result = [];\n\n    while (!(data = iterator.next()).done) {\n      result.push(data.value);\n    }\n    return result;\n  }\n\n  /**\n   * Converts `map` to its key-value pairs.\n   *\n   * @private\n   * @param {Object} map The map to convert.\n   * @returns {Array} Returns the key-value pairs.\n   */\n  function mapToArray(map) {\n    var index = -1,\n        result = Array(map.size);\n\n    map.forEach(function(value, key) {\n      result[++index] = [key, value];\n    });\n    return result;\n  }\n\n  /**\n   * Creates a unary function that invokes `func` with its argument transformed.\n   *\n   * @private\n   * @param {Function} func The function to wrap.\n   * @param {Function} transform The argument transform.\n   * @returns {Function} Returns the new function.\n   */\n  function overArg(func, transform) {\n    return function(arg) {\n      return func(transform(arg));\n    };\n  }\n\n  /**\n   * Replaces all `placeholder` elements in `array` with an internal placeholder\n   * and returns an array of their indexes.\n   *\n   * @private\n   * @param {Array} array The array to modify.\n   * @param {*} placeholder The placeholder to replace.\n   * @returns {Array} Returns the new array of placeholder indexes.\n   */\n  function replaceHolders(array, placeholder) {\n    var index = -1,\n        length = array.length,\n        resIndex = 0,\n        result = [];\n\n    while (++index < length) {\n      var value = array[index];\n      if (value === placeholder || value === PLACEHOLDER) {\n        array[index] = PLACEHOLDER;\n        result[resIndex++] = index;\n      }\n    }\n    return result;\n  }\n\n  /**\n   * Converts `set` to an array of its values.\n   *\n   * @private\n   * @param {Object} set The set to convert.\n   * @returns {Array} Returns the values.\n   */\n  function setToArray(set) {\n    var index = -1,\n        result = Array(set.size);\n\n    set.forEach(function(value) {\n      result[++index] = value;\n    });\n    return result;\n  }\n\n  /**\n   * Converts `set` to its value-value pairs.\n   *\n   * @private\n   * @param {Object} set The set to convert.\n   * @returns {Array} Returns the value-value pairs.\n   */\n  function setToPairs(set) {\n    var index = -1,\n        result = Array(set.size);\n\n    set.forEach(function(value) {\n      result[++index] = [value, value];\n    });\n    return result;\n  }\n\n  /**\n   * A specialized version of `_.indexOf` which performs strict equality\n   * comparisons of values, i.e. `===`.\n   *\n   * @private\n   * @param {Array} array The array to inspect.\n   * @param {*} value The value to search for.\n   * @param {number} fromIndex The index to search from.\n   * @returns {number} Returns the index of the matched value, else `-1`.\n   */\n  function strictIndexOf(array, value, fromIndex) {\n    var index = fromIndex - 1,\n        length = array.length;\n\n    while (++index < length) {\n      if (array[index] === value) {\n        return index;\n      }\n    }\n    return -1;\n  }\n\n  /**\n   * A specialized version of `_.lastIndexOf` which performs strict equality\n   * comparisons of values, i.e. `===`.\n   *\n   * @private\n   * @param {Array} array The array to inspect.\n   * @param {*} value The value to search for.\n   * @param {number} fromIndex The index to search from.\n   * @returns {number} Returns the index of the matched value, else `-1`.\n   */\n  function strictLastIndexOf(array, value, fromIndex) {\n    var index = fromIndex + 1;\n    while (index--) {\n      if (array[index] === value) {\n        return index;\n      }\n    }\n    return index;\n  }\n\n  /**\n   * Gets the number of symbols in `string`.\n   *\n   * @private\n   * @param {string} string The string to inspect.\n   * @returns {number} Returns the string size.\n   */\n  function stringSize(string) {\n    return hasUnicode(string)\n      ? unicodeSize(string)\n      : asciiSize(string);\n  }\n\n  /**\n   * Converts `string` to an array.\n   *\n   * @private\n   * @param {string} string The string to convert.\n   * @returns {Array} Returns the converted array.\n   */\n  function stringToArray(string) {\n    return hasUnicode(string)\n      ? unicodeToArray(string)\n      : asciiToArray(string);\n  }\n\n  /**\n   * Used by `_.trim` and `_.trimEnd` to get the index of the last non-whitespace\n   * character of `string`.\n   *\n   * @private\n   * @param {string} string The string to inspect.\n   * @returns {number} Returns the index of the last non-whitespace character.\n   */\n  function trimmedEndIndex(string) {\n    var index = string.length;\n\n    while (index-- && reWhitespace.test(string.charAt(index))) {}\n    return index;\n  }\n\n  /**\n   * Used by `_.unescape` to convert HTML entities to characters.\n   *\n   * @private\n   * @param {string} chr The matched character to unescape.\n   * @returns {string} Returns the unescaped character.\n   */\n  var unescapeHtmlChar = basePropertyOf(htmlUnescapes);\n\n  /**\n   * Gets the size of a Unicode `string`.\n   *\n   * @private\n   * @param {string} string The string inspect.\n   * @returns {number} Returns the string size.\n   */\n  function unicodeSize(string) {\n    var result = reUnicode.lastIndex = 0;\n    while (reUnicode.test(string)) {\n      ++result;\n    }\n    return result;\n  }\n\n  /**\n   * Converts a Unicode `string` to an array.\n   *\n   * @private\n   * @param {string} string The string to convert.\n   * @returns {Array} Returns the converted array.\n   */\n  function unicodeToArray(string) {\n    return string.match(reUnicode) || [];\n  }\n\n  /**\n   * Splits a Unicode `string` into an array of its words.\n   *\n   * @private\n   * @param {string} The string to inspect.\n   * @returns {Array} Returns the words of `string`.\n   */\n  function unicodeWords(string) {\n    return string.match(reUnicodeWord) || [];\n  }\n\n  /*--------------------------------------------------------------------------*/\n\n  /**\n   * Create a new pristine `lodash` function using the `context` object.\n   *\n   * @static\n   * @memberOf _\n   * @since 1.1.0\n   * @category Util\n   * @param {Object} [context=root] The context object.\n   * @returns {Function} Returns a new `lodash` function.\n   * @example\n   *\n   * _.mixin({ 'foo': _.constant('foo') });\n   *\n   * var lodash = _.runInContext();\n   * lodash.mixin({ 'bar': lodash.constant('bar') });\n   *\n   * _.isFunction(_.foo);\n   * // => true\n   * _.isFunction(_.bar);\n   * // => false\n   *\n   * lodash.isFunction(lodash.foo);\n   * // => false\n   * lodash.isFunction(lodash.bar);\n   * // => true\n   *\n   * // Create a suped-up `defer` in Node.js.\n   * var defer = _.runInContext({ 'setTimeout': setImmediate }).defer;\n   */\n  var runInContext = (function runInContext(context) {\n    context = context == null ? root : _.defaults(root.Object(), context, _.pick(root, contextProps));\n\n    /** Built-in constructor references. */\n    var Array = context.Array,\n        Date = context.Date,\n        Error = context.Error,\n        Function = context.Function,\n        Math = context.Math,\n        Object = context.Object,\n        RegExp = context.RegExp,\n        String = context.String,\n        TypeError = context.TypeError;\n\n    /** Used for built-in method references. */\n    var arrayProto = Array.prototype,\n        funcProto = Function.prototype,\n        objectProto = Object.prototype;\n\n    /** Used to detect overreaching core-js shims. */\n    var coreJsData = context['__core-js_shared__'];\n\n    /** Used to resolve the decompiled source of functions. */\n    var funcToString = funcProto.toString;\n\n    /** Used to check objects for own properties. */\n    var hasOwnProperty = objectProto.hasOwnProperty;\n\n    /** Used to generate unique IDs. */\n    var idCounter = 0;\n\n    /** Used to detect methods masquerading as native. */\n    var maskSrcKey = (function() {\n      var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');\n      return uid ? ('Symbol(src)_1.' + uid) : '';\n    }());\n\n    /**\n     * Used to resolve the\n     * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n     * of values.\n     */\n    var nativeObjectToString = objectProto.toString;\n\n    /** Used to infer the `Object` constructor. */\n    var objectCtorString = funcToString.call(Object);\n\n    /** Used to restore the original `_` reference in `_.noConflict`. */\n    var oldDash = root._;\n\n    /** Used to detect if a method is native. */\n    var reIsNative = RegExp('^' +\n      funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\\\$&')\n      .replace(/hasOwnProperty|(function).*?(?=\\\\\\()| for .+?(?=\\\\\\])/g, '$1.*?') + '$'\n    );\n\n    /** Built-in value references. */\n    var Buffer = moduleExports ? context.Buffer : undefined,\n        Symbol = context.Symbol,\n        Uint8Array = context.Uint8Array,\n        allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined,\n        getPrototype = overArg(Object.getPrototypeOf, Object),\n        objectCreate = Object.create,\n        propertyIsEnumerable = objectProto.propertyIsEnumerable,\n        splice = arrayProto.splice,\n        spreadableSymbol = Symbol ? Symbol.isConcatSpreadable : undefined,\n        symIterator = Symbol ? Symbol.iterator : undefined,\n        symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n    var defineProperty = (function() {\n      try {\n        var func = getNative(Object, 'defineProperty');\n        func({}, '', {});\n        return func;\n      } catch (e) {}\n    }());\n\n    /** Mocked built-ins. */\n    var ctxClearTimeout = context.clearTimeout !== root.clearTimeout && context.clearTimeout,\n        ctxNow = Date && Date.now !== root.Date.now && Date.now,\n        ctxSetTimeout = context.setTimeout !== root.setTimeout && context.setTimeout;\n\n    /* Built-in method references for those with the same name as other `lodash` methods. */\n    var nativeCeil = Math.ceil,\n        nativeFloor = Math.floor,\n        nativeGetSymbols = Object.getOwnPropertySymbols,\n        nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined,\n        nativeIsFinite = context.isFinite,\n        nativeJoin = arrayProto.join,\n        nativeKeys = overArg(Object.keys, Object),\n        nativeMax = Math.max,\n        nativeMin = Math.min,\n        nativeNow = Date.now,\n        nativeParseInt = context.parseInt,\n        nativeRandom = Math.random,\n        nativeReverse = arrayProto.reverse;\n\n    /* Built-in method references that are verified to be native. */\n    var DataView = getNative(context, 'DataView'),\n        Map = getNative(context, 'Map'),\n        Promise = getNative(context, 'Promise'),\n        Set = getNative(context, 'Set'),\n        WeakMap = getNative(context, 'WeakMap'),\n        nativeCreate = getNative(Object, 'create');\n\n    /** Used to store function metadata. */\n    var metaMap = WeakMap && new WeakMap;\n\n    /** Used to lookup unminified function names. */\n    var realNames = {};\n\n    /** Used to detect maps, sets, and weakmaps. */\n    var dataViewCtorString = toSource(DataView),\n        mapCtorString = toSource(Map),\n        promiseCtorString = toSource(Promise),\n        setCtorString = toSource(Set),\n        weakMapCtorString = toSource(WeakMap);\n\n    /** Used to convert symbols to primitives and strings. */\n    var symbolProto = Symbol ? Symbol.prototype : undefined,\n        symbolValueOf = symbolProto ? symbolProto.valueOf : undefined,\n        symbolToString = symbolProto ? symbolProto.toString : undefined;\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates a `lodash` object which wraps `value` to enable implicit method\n     * chain sequences. Methods that operate on and return arrays, collections,\n     * and functions can be chained together. Methods that retrieve a single value\n     * or may return a primitive value will automatically end the chain sequence\n     * and return the unwrapped value. Otherwise, the value must be unwrapped\n     * with `_#value`.\n     *\n     * Explicit chain sequences, which must be unwrapped with `_#value`, may be\n     * enabled using `_.chain`.\n     *\n     * The execution of chained methods is lazy, that is, it's deferred until\n     * `_#value` is implicitly or explicitly called.\n     *\n     * Lazy evaluation allows several methods to support shortcut fusion.\n     * Shortcut fusion is an optimization to merge iteratee calls; this avoids\n     * the creation of intermediate arrays and can greatly reduce the number of\n     * iteratee executions. Sections of a chain sequence qualify for shortcut\n     * fusion if the section is applied to an array and iteratees accept only\n     * one argument. The heuristic for whether a section qualifies for shortcut\n     * fusion is subject to change.\n     *\n     * Chaining is supported in custom builds as long as the `_#value` method is\n     * directly or indirectly included in the build.\n     *\n     * In addition to lodash methods, wrappers have `Array` and `String` methods.\n     *\n     * The wrapper `Array` methods are:\n     * `concat`, `join`, `pop`, `push`, `shift`, `sort`, `splice`, and `unshift`\n     *\n     * The wrapper `String` methods are:\n     * `replace` and `split`\n     *\n     * The wrapper methods that support shortcut fusion are:\n     * `at`, `compact`, `drop`, `dropRight`, `dropWhile`, `filter`, `find`,\n     * `findLast`, `head`, `initial`, `last`, `map`, `reject`, `reverse`, `slice`,\n     * `tail`, `take`, `takeRight`, `takeRightWhile`, `takeWhile`, and `toArray`\n     *\n     * The chainable wrapper methods are:\n     * `after`, `ary`, `assign`, `assignIn`, `assignInWith`, `assignWith`, `at`,\n     * `before`, `bind`, `bindAll`, `bindKey`, `castArray`, `chain`, `chunk`,\n     * `commit`, `compact`, `concat`, `conforms`, `constant`, `countBy`, `create`,\n     * `curry`, `debounce`, `defaults`, `defaultsDeep`, `defer`, `delay`,\n     * `difference`, `differenceBy`, `differenceWith`, `drop`, `dropRight`,\n     * `dropRightWhile`, `dropWhile`, `extend`, `extendWith`, `fill`, `filter`,\n     * `flatMap`, `flatMapDeep`, `flatMapDepth`, `flatten`, `flattenDeep`,\n     * `flattenDepth`, `flip`, `flow`, `flowRight`, `fromPairs`, `functions`,\n     * `functionsIn`, `groupBy`, `initial`, `intersection`, `intersectionBy`,\n     * `intersectionWith`, `invert`, `invertBy`, `invokeMap`, `iteratee`, `keyBy`,\n     * `keys`, `keysIn`, `map`, `mapKeys`, `mapValues`, `matches`, `matchesProperty`,\n     * `memoize`, `merge`, `mergeWith`, `method`, `methodOf`, `mixin`, `negate`,\n     * `nthArg`, `omit`, `omitBy`, `once`, `orderBy`, `over`, `overArgs`,\n     * `overEvery`, `overSome`, `partial`, `partialRight`, `partition`, `pick`,\n     * `pickBy`, `plant`, `property`, `propertyOf`, `pull`, `pullAll`, `pullAllBy`,\n     * `pullAllWith`, `pullAt`, `push`, `range`, `rangeRight`, `rearg`, `reject`,\n     * `remove`, `rest`, `reverse`, `sampleSize`, `set`, `setWith`, `shuffle`,\n     * `slice`, `sort`, `sortBy`, `splice`, `spread`, `tail`, `take`, `takeRight`,\n     * `takeRightWhile`, `takeWhile`, `tap`, `throttle`, `thru`, `toArray`,\n     * `toPairs`, `toPairsIn`, `toPath`, `toPlainObject`, `transform`, `unary`,\n     * `union`, `unionBy`, `unionWith`, `uniq`, `uniqBy`, `uniqWith`, `unset`,\n     * `unshift`, `unzip`, `unzipWith`, `update`, `updateWith`, `values`,\n     * `valuesIn`, `without`, `wrap`, `xor`, `xorBy`, `xorWith`, `zip`,\n     * `zipObject`, `zipObjectDeep`, and `zipWith`\n     *\n     * The wrapper methods that are **not** chainable by default are:\n     * `add`, `attempt`, `camelCase`, `capitalize`, `ceil`, `clamp`, `clone`,\n     * `cloneDeep`, `cloneDeepWith`, `cloneWith`, `conformsTo`, `deburr`,\n     * `defaultTo`, `divide`, `each`, `eachRight`, `endsWith`, `eq`, `escape`,\n     * `escapeRegExp`, `every`, `find`, `findIndex`, `findKey`, `findLast`,\n     * `findLastIndex`, `findLastKey`, `first`, `floor`, `forEach`, `forEachRight`,\n     * `forIn`, `forInRight`, `forOwn`, `forOwnRight`, `get`, `gt`, `gte`, `has`,\n     * `hasIn`, `head`, `identity`, `includes`, `indexOf`, `inRange`, `invoke`,\n     * `isArguments`, `isArray`, `isArrayBuffer`, `isArrayLike`, `isArrayLikeObject`,\n     * `isBoolean`, `isBuffer`, `isDate`, `isElement`, `isEmpty`, `isEqual`,\n     * `isEqualWith`, `isError`, `isFinite`, `isFunction`, `isInteger`, `isLength`,\n     * `isMap`, `isMatch`, `isMatchWith`, `isNaN`, `isNative`, `isNil`, `isNull`,\n     * `isNumber`, `isObject`, `isObjectLike`, `isPlainObject`, `isRegExp`,\n     * `isSafeInteger`, `isSet`, `isString`, `isUndefined`, `isTypedArray`,\n     * `isWeakMap`, `isWeakSet`, `join`, `kebabCase`, `last`, `lastIndexOf`,\n     * `lowerCase`, `lowerFirst`, `lt`, `lte`, `max`, `maxBy`, `mean`, `meanBy`,\n     * `min`, `minBy`, `multiply`, `noConflict`, `noop`, `now`, `nth`, `pad`,\n     * `padEnd`, `padStart`, `parseInt`, `pop`, `random`, `reduce`, `reduceRight`,\n     * `repeat`, `result`, `round`, `runInContext`, `sample`, `shift`, `size`,\n     * `snakeCase`, `some`, `sortedIndex`, `sortedIndexBy`, `sortedLastIndex`,\n     * `sortedLastIndexBy`, `startCase`, `startsWith`, `stubArray`, `stubFalse`,\n     * `stubObject`, `stubString`, `stubTrue`, `subtract`, `sum`, `sumBy`,\n     * `template`, `times`, `toFinite`, `toInteger`, `toJSON`, `toLength`,\n     * `toLower`, `toNumber`, `toSafeInteger`, `toString`, `toUpper`, `trim`,\n     * `trimEnd`, `trimStart`, `truncate`, `unescape`, `uniqueId`, `upperCase`,\n     * `upperFirst`, `value`, and `words`\n     *\n     * @name _\n     * @constructor\n     * @category Seq\n     * @param {*} value The value to wrap in a `lodash` instance.\n     * @returns {Object} Returns the new `lodash` wrapper instance.\n     * @example\n     *\n     * function square(n) {\n     *   return n * n;\n     * }\n     *\n     * var wrapped = _([1, 2, 3]);\n     *\n     * // Returns an unwrapped value.\n     * wrapped.reduce(_.add);\n     * // => 6\n     *\n     * // Returns a wrapped value.\n     * var squares = wrapped.map(square);\n     *\n     * _.isArray(squares);\n     * // => false\n     *\n     * _.isArray(squares.value());\n     * // => true\n     */\n    function lodash(value) {\n      if (isObjectLike(value) && !isArray(value) && !(value instanceof LazyWrapper)) {\n        if (value instanceof LodashWrapper) {\n          return value;\n        }\n        if (hasOwnProperty.call(value, '__wrapped__')) {\n          return wrapperClone(value);\n        }\n      }\n      return new LodashWrapper(value);\n    }\n\n    /**\n     * The base implementation of `_.create` without support for assigning\n     * properties to the created object.\n     *\n     * @private\n     * @param {Object} proto The object to inherit from.\n     * @returns {Object} Returns the new object.\n     */\n    var baseCreate = (function() {\n      function object() {}\n      return function(proto) {\n        if (!isObject(proto)) {\n          return {};\n        }\n        if (objectCreate) {\n          return objectCreate(proto);\n        }\n        object.prototype = proto;\n        var result = new object;\n        object.prototype = undefined;\n        return result;\n      };\n    }());\n\n    /**\n     * The function whose prototype chain sequence wrappers inherit from.\n     *\n     * @private\n     */\n    function baseLodash() {\n      // No operation performed.\n    }\n\n    /**\n     * The base constructor for creating `lodash` wrapper objects.\n     *\n     * @private\n     * @param {*} value The value to wrap.\n     * @param {boolean} [chainAll] Enable explicit method chain sequences.\n     */\n    function LodashWrapper(value, chainAll) {\n      this.__wrapped__ = value;\n      this.__actions__ = [];\n      this.__chain__ = !!chainAll;\n      this.__index__ = 0;\n      this.__values__ = undefined;\n    }\n\n    /**\n     * By default, the template delimiters used by lodash are like those in\n     * embedded Ruby (ERB) as well as ES2015 template strings. Change the\n     * following template settings to use alternative delimiters.\n     *\n     * @static\n     * @memberOf _\n     * @type {Object}\n     */\n    lodash.templateSettings = {\n\n      /**\n       * Used to detect `data` property values to be HTML-escaped.\n       *\n       * @memberOf _.templateSettings\n       * @type {RegExp}\n       */\n      'escape': reEscape,\n\n      /**\n       * Used to detect code to be evaluated.\n       *\n       * @memberOf _.templateSettings\n       * @type {RegExp}\n       */\n      'evaluate': reEvaluate,\n\n      /**\n       * Used to detect `data` property values to inject.\n       *\n       * @memberOf _.templateSettings\n       * @type {RegExp}\n       */\n      'interpolate': reInterpolate,\n\n      /**\n       * Used to reference the data object in the template text.\n       *\n       * @memberOf _.templateSettings\n       * @type {string}\n       */\n      'variable': '',\n\n      /**\n       * Used to import variables into the compiled template.\n       *\n       * @memberOf _.templateSettings\n       * @type {Object}\n       */\n      'imports': {\n\n        /**\n         * A reference to the `lodash` function.\n         *\n         * @memberOf _.templateSettings.imports\n         * @type {Function}\n         */\n        '_': lodash\n      }\n    };\n\n    // Ensure wrappers are instances of `baseLodash`.\n    lodash.prototype = baseLodash.prototype;\n    lodash.prototype.constructor = lodash;\n\n    LodashWrapper.prototype = baseCreate(baseLodash.prototype);\n    LodashWrapper.prototype.constructor = LodashWrapper;\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates a lazy wrapper object which wraps `value` to enable lazy evaluation.\n     *\n     * @private\n     * @constructor\n     * @param {*} value The value to wrap.\n     */\n    function LazyWrapper(value) {\n      this.__wrapped__ = value;\n      this.__actions__ = [];\n      this.__dir__ = 1;\n      this.__filtered__ = false;\n      this.__iteratees__ = [];\n      this.__takeCount__ = MAX_ARRAY_LENGTH;\n      this.__views__ = [];\n    }\n\n    /**\n     * Creates a clone of the lazy wrapper object.\n     *\n     * @private\n     * @name clone\n     * @memberOf LazyWrapper\n     * @returns {Object} Returns the cloned `LazyWrapper` object.\n     */\n    function lazyClone() {\n      var result = new LazyWrapper(this.__wrapped__);\n      result.__actions__ = copyArray(this.__actions__);\n      result.__dir__ = this.__dir__;\n      result.__filtered__ = this.__filtered__;\n      result.__iteratees__ = copyArray(this.__iteratees__);\n      result.__takeCount__ = this.__takeCount__;\n      result.__views__ = copyArray(this.__views__);\n      return result;\n    }\n\n    /**\n     * Reverses the direction of lazy iteration.\n     *\n     * @private\n     * @name reverse\n     * @memberOf LazyWrapper\n     * @returns {Object} Returns the new reversed `LazyWrapper` object.\n     */\n    function lazyReverse() {\n      if (this.__filtered__) {\n        var result = new LazyWrapper(this);\n        result.__dir__ = -1;\n        result.__filtered__ = true;\n      } else {\n        result = this.clone();\n        result.__dir__ *= -1;\n      }\n      return result;\n    }\n\n    /**\n     * Extracts the unwrapped value from its lazy wrapper.\n     *\n     * @private\n     * @name value\n     * @memberOf LazyWrapper\n     * @returns {*} Returns the unwrapped value.\n     */\n    function lazyValue() {\n      var array = this.__wrapped__.value(),\n          dir = this.__dir__,\n          isArr = isArray(array),\n          isRight = dir < 0,\n          arrLength = isArr ? array.length : 0,\n          view = getView(0, arrLength, this.__views__),\n          start = view.start,\n          end = view.end,\n          length = end - start,\n          index = isRight ? end : (start - 1),\n          iteratees = this.__iteratees__,\n          iterLength = iteratees.length,\n          resIndex = 0,\n          takeCount = nativeMin(length, this.__takeCount__);\n\n      if (!isArr || (!isRight && arrLength == length && takeCount == length)) {\n        return baseWrapperValue(array, this.__actions__);\n      }\n      var result = [];\n\n      outer:\n      while (length-- && resIndex < takeCount) {\n        index += dir;\n\n        var iterIndex = -1,\n            value = array[index];\n\n        while (++iterIndex < iterLength) {\n          var data = iteratees[iterIndex],\n              iteratee = data.iteratee,\n              type = data.type,\n              computed = iteratee(value);\n\n          if (type == LAZY_MAP_FLAG) {\n            value = computed;\n          } else if (!computed) {\n            if (type == LAZY_FILTER_FLAG) {\n              continue outer;\n            } else {\n              break outer;\n            }\n          }\n        }\n        result[resIndex++] = value;\n      }\n      return result;\n    }\n\n    // Ensure `LazyWrapper` is an instance of `baseLodash`.\n    LazyWrapper.prototype = baseCreate(baseLodash.prototype);\n    LazyWrapper.prototype.constructor = LazyWrapper;\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates a hash object.\n     *\n     * @private\n     * @constructor\n     * @param {Array} [entries] The key-value pairs to cache.\n     */\n    function Hash(entries) {\n      var index = -1,\n          length = entries == null ? 0 : entries.length;\n\n      this.clear();\n      while (++index < length) {\n        var entry = entries[index];\n        this.set(entry[0], entry[1]);\n      }\n    }\n\n    /**\n     * Removes all key-value entries from the hash.\n     *\n     * @private\n     * @name clear\n     * @memberOf Hash\n     */\n    function hashClear() {\n      this.__data__ = nativeCreate ? nativeCreate(null) : {};\n      this.size = 0;\n    }\n\n    /**\n     * Removes `key` and its value from the hash.\n     *\n     * @private\n     * @name delete\n     * @memberOf Hash\n     * @param {Object} hash The hash to modify.\n     * @param {string} key The key of the value to remove.\n     * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n     */\n    function hashDelete(key) {\n      var result = this.has(key) && delete this.__data__[key];\n      this.size -= result ? 1 : 0;\n      return result;\n    }\n\n    /**\n     * Gets the hash value for `key`.\n     *\n     * @private\n     * @name get\n     * @memberOf Hash\n     * @param {string} key The key of the value to get.\n     * @returns {*} Returns the entry value.\n     */\n    function hashGet(key) {\n      var data = this.__data__;\n      if (nativeCreate) {\n        var result = data[key];\n        return result === HASH_UNDEFINED ? undefined : result;\n      }\n      return hasOwnProperty.call(data, key) ? data[key] : undefined;\n    }\n\n    /**\n     * Checks if a hash value for `key` exists.\n     *\n     * @private\n     * @name has\n     * @memberOf Hash\n     * @param {string} key The key of the entry to check.\n     * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n     */\n    function hashHas(key) {\n      var data = this.__data__;\n      return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key);\n    }\n\n    /**\n     * Sets the hash `key` to `value`.\n     *\n     * @private\n     * @name set\n     * @memberOf Hash\n     * @param {string} key The key of the value to set.\n     * @param {*} value The value to set.\n     * @returns {Object} Returns the hash instance.\n     */\n    function hashSet(key, value) {\n      var data = this.__data__;\n      this.size += this.has(key) ? 0 : 1;\n      data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;\n      return this;\n    }\n\n    // Add methods to `Hash`.\n    Hash.prototype.clear = hashClear;\n    Hash.prototype['delete'] = hashDelete;\n    Hash.prototype.get = hashGet;\n    Hash.prototype.has = hashHas;\n    Hash.prototype.set = hashSet;\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates an list cache object.\n     *\n     * @private\n     * @constructor\n     * @param {Array} [entries] The key-value pairs to cache.\n     */\n    function ListCache(entries) {\n      var index = -1,\n          length = entries == null ? 0 : entries.length;\n\n      this.clear();\n      while (++index < length) {\n        var entry = entries[index];\n        this.set(entry[0], entry[1]);\n      }\n    }\n\n    /**\n     * Removes all key-value entries from the list cache.\n     *\n     * @private\n     * @name clear\n     * @memberOf ListCache\n     */\n    function listCacheClear() {\n      this.__data__ = [];\n      this.size = 0;\n    }\n\n    /**\n     * Removes `key` and its value from the list cache.\n     *\n     * @private\n     * @name delete\n     * @memberOf ListCache\n     * @param {string} key The key of the value to remove.\n     * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n     */\n    function listCacheDelete(key) {\n      var data = this.__data__,\n          index = assocIndexOf(data, key);\n\n      if (index < 0) {\n        return false;\n      }\n      var lastIndex = data.length - 1;\n      if (index == lastIndex) {\n        data.pop();\n      } else {\n        splice.call(data, index, 1);\n      }\n      --this.size;\n      return true;\n    }\n\n    /**\n     * Gets the list cache value for `key`.\n     *\n     * @private\n     * @name get\n     * @memberOf ListCache\n     * @param {string} key The key of the value to get.\n     * @returns {*} Returns the entry value.\n     */\n    function listCacheGet(key) {\n      var data = this.__data__,\n          index = assocIndexOf(data, key);\n\n      return index < 0 ? undefined : data[index][1];\n    }\n\n    /**\n     * Checks if a list cache value for `key` exists.\n     *\n     * @private\n     * @name has\n     * @memberOf ListCache\n     * @param {string} key The key of the entry to check.\n     * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n     */\n    function listCacheHas(key) {\n      return assocIndexOf(this.__data__, key) > -1;\n    }\n\n    /**\n     * Sets the list cache `key` to `value`.\n     *\n     * @private\n     * @name set\n     * @memberOf ListCache\n     * @param {string} key The key of the value to set.\n     * @param {*} value The value to set.\n     * @returns {Object} Returns the list cache instance.\n     */\n    function listCacheSet(key, value) {\n      var data = this.__data__,\n          index = assocIndexOf(data, key);\n\n      if (index < 0) {\n        ++this.size;\n        data.push([key, value]);\n      } else {\n        data[index][1] = value;\n      }\n      return this;\n    }\n\n    // Add methods to `ListCache`.\n    ListCache.prototype.clear = listCacheClear;\n    ListCache.prototype['delete'] = listCacheDelete;\n    ListCache.prototype.get = listCacheGet;\n    ListCache.prototype.has = listCacheHas;\n    ListCache.prototype.set = listCacheSet;\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates a map cache object to store key-value pairs.\n     *\n     * @private\n     * @constructor\n     * @param {Array} [entries] The key-value pairs to cache.\n     */\n    function MapCache(entries) {\n      var index = -1,\n          length = entries == null ? 0 : entries.length;\n\n      this.clear();\n      while (++index < length) {\n        var entry = entries[index];\n        this.set(entry[0], entry[1]);\n      }\n    }\n\n    /**\n     * Removes all key-value entries from the map.\n     *\n     * @private\n     * @name clear\n     * @memberOf MapCache\n     */\n    function mapCacheClear() {\n      this.size = 0;\n      this.__data__ = {\n        'hash': new Hash,\n        'map': new (Map || ListCache),\n        'string': new Hash\n      };\n    }\n\n    /**\n     * Removes `key` and its value from the map.\n     *\n     * @private\n     * @name delete\n     * @memberOf MapCache\n     * @param {string} key The key of the value to remove.\n     * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n     */\n    function mapCacheDelete(key) {\n      var result = getMapData(this, key)['delete'](key);\n      this.size -= result ? 1 : 0;\n      return result;\n    }\n\n    /**\n     * Gets the map value for `key`.\n     *\n     * @private\n     * @name get\n     * @memberOf MapCache\n     * @param {string} key The key of the value to get.\n     * @returns {*} Returns the entry value.\n     */\n    function mapCacheGet(key) {\n      return getMapData(this, key).get(key);\n    }\n\n    /**\n     * Checks if a map value for `key` exists.\n     *\n     * @private\n     * @name has\n     * @memberOf MapCache\n     * @param {string} key The key of the entry to check.\n     * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n     */\n    function mapCacheHas(key) {\n      return getMapData(this, key).has(key);\n    }\n\n    /**\n     * Sets the map `key` to `value`.\n     *\n     * @private\n     * @name set\n     * @memberOf MapCache\n     * @param {string} key The key of the value to set.\n     * @param {*} value The value to set.\n     * @returns {Object} Returns the map cache instance.\n     */\n    function mapCacheSet(key, value) {\n      var data = getMapData(this, key),\n          size = data.size;\n\n      data.set(key, value);\n      this.size += data.size == size ? 0 : 1;\n      return this;\n    }\n\n    // Add methods to `MapCache`.\n    MapCache.prototype.clear = mapCacheClear;\n    MapCache.prototype['delete'] = mapCacheDelete;\n    MapCache.prototype.get = mapCacheGet;\n    MapCache.prototype.has = mapCacheHas;\n    MapCache.prototype.set = mapCacheSet;\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     *\n     * Creates an array cache object to store unique values.\n     *\n     * @private\n     * @constructor\n     * @param {Array} [values] The values to cache.\n     */\n    function SetCache(values) {\n      var index = -1,\n          length = values == null ? 0 : values.length;\n\n      this.__data__ = new MapCache;\n      while (++index < length) {\n        this.add(values[index]);\n      }\n    }\n\n    /**\n     * Adds `value` to the array cache.\n     *\n     * @private\n     * @name add\n     * @memberOf SetCache\n     * @alias push\n     * @param {*} value The value to cache.\n     * @returns {Object} Returns the cache instance.\n     */\n    function setCacheAdd(value) {\n      this.__data__.set(value, HASH_UNDEFINED);\n      return this;\n    }\n\n    /**\n     * Checks if `value` is in the array cache.\n     *\n     * @private\n     * @name has\n     * @memberOf SetCache\n     * @param {*} value The value to search for.\n     * @returns {number} Returns `true` if `value` is found, else `false`.\n     */\n    function setCacheHas(value) {\n      return this.__data__.has(value);\n    }\n\n    // Add methods to `SetCache`.\n    SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;\n    SetCache.prototype.has = setCacheHas;\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates a stack cache object to store key-value pairs.\n     *\n     * @private\n     * @constructor\n     * @param {Array} [entries] The key-value pairs to cache.\n     */\n    function Stack(entries) {\n      var data = this.__data__ = new ListCache(entries);\n      this.size = data.size;\n    }\n\n    /**\n     * Removes all key-value entries from the stack.\n     *\n     * @private\n     * @name clear\n     * @memberOf Stack\n     */\n    function stackClear() {\n      this.__data__ = new ListCache;\n      this.size = 0;\n    }\n\n    /**\n     * Removes `key` and its value from the stack.\n     *\n     * @private\n     * @name delete\n     * @memberOf Stack\n     * @param {string} key The key of the value to remove.\n     * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n     */\n    function stackDelete(key) {\n      var data = this.__data__,\n          result = data['delete'](key);\n\n      this.size = data.size;\n      return result;\n    }\n\n    /**\n     * Gets the stack value for `key`.\n     *\n     * @private\n     * @name get\n     * @memberOf Stack\n     * @param {string} key The key of the value to get.\n     * @returns {*} Returns the entry value.\n     */\n    function stackGet(key) {\n      return this.__data__.get(key);\n    }\n\n    /**\n     * Checks if a stack value for `key` exists.\n     *\n     * @private\n     * @name has\n     * @memberOf Stack\n     * @param {string} key The key of the entry to check.\n     * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n     */\n    function stackHas(key) {\n      return this.__data__.has(key);\n    }\n\n    /**\n     * Sets the stack `key` to `value`.\n     *\n     * @private\n     * @name set\n     * @memberOf Stack\n     * @param {string} key The key of the value to set.\n     * @param {*} value The value to set.\n     * @returns {Object} Returns the stack cache instance.\n     */\n    function stackSet(key, value) {\n      var data = this.__data__;\n      if (data instanceof ListCache) {\n        var pairs = data.__data__;\n        if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {\n          pairs.push([key, value]);\n          this.size = ++data.size;\n          return this;\n        }\n        data = this.__data__ = new MapCache(pairs);\n      }\n      data.set(key, value);\n      this.size = data.size;\n      return this;\n    }\n\n    // Add methods to `Stack`.\n    Stack.prototype.clear = stackClear;\n    Stack.prototype['delete'] = stackDelete;\n    Stack.prototype.get = stackGet;\n    Stack.prototype.has = stackHas;\n    Stack.prototype.set = stackSet;\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates an array of the enumerable property names of the array-like `value`.\n     *\n     * @private\n     * @param {*} value The value to query.\n     * @param {boolean} inherited Specify returning inherited property names.\n     * @returns {Array} Returns the array of property names.\n     */\n    function arrayLikeKeys(value, inherited) {\n      var isArr = isArray(value),\n          isArg = !isArr && isArguments(value),\n          isBuff = !isArr && !isArg && isBuffer(value),\n          isType = !isArr && !isArg && !isBuff && isTypedArray(value),\n          skipIndexes = isArr || isArg || isBuff || isType,\n          result = skipIndexes ? baseTimes(value.length, String) : [],\n          length = result.length;\n\n      for (var key in value) {\n        if ((inherited || hasOwnProperty.call(value, key)) &&\n            !(skipIndexes && (\n               // Safari 9 has enumerable `arguments.length` in strict mode.\n               key == 'length' ||\n               // Node.js 0.10 has enumerable non-index properties on buffers.\n               (isBuff && (key == 'offset' || key == 'parent')) ||\n               // PhantomJS 2 has enumerable non-index properties on typed arrays.\n               (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||\n               // Skip index properties.\n               isIndex(key, length)\n            ))) {\n          result.push(key);\n        }\n      }\n      return result;\n    }\n\n    /**\n     * A specialized version of `_.sample` for arrays.\n     *\n     * @private\n     * @param {Array} array The array to sample.\n     * @returns {*} Returns the random element.\n     */\n    function arraySample(array) {\n      var length = array.length;\n      return length ? array[baseRandom(0, length - 1)] : undefined;\n    }\n\n    /**\n     * A specialized version of `_.sampleSize` for arrays.\n     *\n     * @private\n     * @param {Array} array The array to sample.\n     * @param {number} n The number of elements to sample.\n     * @returns {Array} Returns the random elements.\n     */\n    function arraySampleSize(array, n) {\n      return shuffleSelf(copyArray(array), baseClamp(n, 0, array.length));\n    }\n\n    /**\n     * A specialized version of `_.shuffle` for arrays.\n     *\n     * @private\n     * @param {Array} array The array to shuffle.\n     * @returns {Array} Returns the new shuffled array.\n     */\n    function arrayShuffle(array) {\n      return shuffleSelf(copyArray(array));\n    }\n\n    /**\n     * This function is like `assignValue` except that it doesn't assign\n     * `undefined` values.\n     *\n     * @private\n     * @param {Object} object The object to modify.\n     * @param {string} key The key of the property to assign.\n     * @param {*} value The value to assign.\n     */\n    function assignMergeValue(object, key, value) {\n      if ((value !== undefined && !eq(object[key], value)) ||\n          (value === undefined && !(key in object))) {\n        baseAssignValue(object, key, value);\n      }\n    }\n\n    /**\n     * Assigns `value` to `key` of `object` if the existing value is not equivalent\n     * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n     * for equality comparisons.\n     *\n     * @private\n     * @param {Object} object The object to modify.\n     * @param {string} key The key of the property to assign.\n     * @param {*} value The value to assign.\n     */\n    function assignValue(object, key, value) {\n      var objValue = object[key];\n      if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||\n          (value === undefined && !(key in object))) {\n        baseAssignValue(object, key, value);\n      }\n    }\n\n    /**\n     * Gets the index at which the `key` is found in `array` of key-value pairs.\n     *\n     * @private\n     * @param {Array} array The array to inspect.\n     * @param {*} key The key to search for.\n     * @returns {number} Returns the index of the matched value, else `-1`.\n     */\n    function assocIndexOf(array, key) {\n      var length = array.length;\n      while (length--) {\n        if (eq(array[length][0], key)) {\n          return length;\n        }\n      }\n      return -1;\n    }\n\n    /**\n     * Aggregates elements of `collection` on `accumulator` with keys transformed\n     * by `iteratee` and values set by `setter`.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} setter The function to set `accumulator` values.\n     * @param {Function} iteratee The iteratee to transform keys.\n     * @param {Object} accumulator The initial aggregated object.\n     * @returns {Function} Returns `accumulator`.\n     */\n    function baseAggregator(collection, setter, iteratee, accumulator) {\n      baseEach(collection, function(value, key, collection) {\n        setter(accumulator, value, iteratee(value), collection);\n      });\n      return accumulator;\n    }\n\n    /**\n     * The base implementation of `_.assign` without support for multiple sources\n     * or `customizer` functions.\n     *\n     * @private\n     * @param {Object} object The destination object.\n     * @param {Object} source The source object.\n     * @returns {Object} Returns `object`.\n     */\n    function baseAssign(object, source) {\n      return object && copyObject(source, keys(source), object);\n    }\n\n    /**\n     * The base implementation of `_.assignIn` without support for multiple sources\n     * or `customizer` functions.\n     *\n     * @private\n     * @param {Object} object The destination object.\n     * @param {Object} source The source object.\n     * @returns {Object} Returns `object`.\n     */\n    function baseAssignIn(object, source) {\n      return object && copyObject(source, keysIn(source), object);\n    }\n\n    /**\n     * The base implementation of `assignValue` and `assignMergeValue` without\n     * value checks.\n     *\n     * @private\n     * @param {Object} object The object to modify.\n     * @param {string} key The key of the property to assign.\n     * @param {*} value The value to assign.\n     */\n    function baseAssignValue(object, key, value) {\n      if (key == '__proto__' && defineProperty) {\n        defineProperty(object, key, {\n          'configurable': true,\n          'enumerable': true,\n          'value': value,\n          'writable': true\n        });\n      } else {\n        object[key] = value;\n      }\n    }\n\n    /**\n     * The base implementation of `_.at` without support for individual paths.\n     *\n     * @private\n     * @param {Object} object The object to iterate over.\n     * @param {string[]} paths The property paths to pick.\n     * @returns {Array} Returns the picked elements.\n     */\n    function baseAt(object, paths) {\n      var index = -1,\n          length = paths.length,\n          result = Array(length),\n          skip = object == null;\n\n      while (++index < length) {\n        result[index] = skip ? undefined : get(object, paths[index]);\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.clamp` which doesn't coerce arguments.\n     *\n     * @private\n     * @param {number} number The number to clamp.\n     * @param {number} [lower] The lower bound.\n     * @param {number} upper The upper bound.\n     * @returns {number} Returns the clamped number.\n     */\n    function baseClamp(number, lower, upper) {\n      if (number === number) {\n        if (upper !== undefined) {\n          number = number <= upper ? number : upper;\n        }\n        if (lower !== undefined) {\n          number = number >= lower ? number : lower;\n        }\n      }\n      return number;\n    }\n\n    /**\n     * The base implementation of `_.clone` and `_.cloneDeep` which tracks\n     * traversed objects.\n     *\n     * @private\n     * @param {*} value The value to clone.\n     * @param {boolean} bitmask The bitmask flags.\n     *  1 - Deep clone\n     *  2 - Flatten inherited properties\n     *  4 - Clone symbols\n     * @param {Function} [customizer] The function to customize cloning.\n     * @param {string} [key] The key of `value`.\n     * @param {Object} [object] The parent object of `value`.\n     * @param {Object} [stack] Tracks traversed objects and their clone counterparts.\n     * @returns {*} Returns the cloned value.\n     */\n    function baseClone(value, bitmask, customizer, key, object, stack) {\n      var result,\n          isDeep = bitmask & CLONE_DEEP_FLAG,\n          isFlat = bitmask & CLONE_FLAT_FLAG,\n          isFull = bitmask & CLONE_SYMBOLS_FLAG;\n\n      if (customizer) {\n        result = object ? customizer(value, key, object, stack) : customizer(value);\n      }\n      if (result !== undefined) {\n        return result;\n      }\n      if (!isObject(value)) {\n        return value;\n      }\n      var isArr = isArray(value);\n      if (isArr) {\n        result = initCloneArray(value);\n        if (!isDeep) {\n          return copyArray(value, result);\n        }\n      } else {\n        var tag = getTag(value),\n            isFunc = tag == funcTag || tag == genTag;\n\n        if (isBuffer(value)) {\n          return cloneBuffer(value, isDeep);\n        }\n        if (tag == objectTag || tag == argsTag || (isFunc && !object)) {\n          result = (isFlat || isFunc) ? {} : initCloneObject(value);\n          if (!isDeep) {\n            return isFlat\n              ? copySymbolsIn(value, baseAssignIn(result, value))\n              : copySymbols(value, baseAssign(result, value));\n          }\n        } else {\n          if (!cloneableTags[tag]) {\n            return object ? value : {};\n          }\n          result = initCloneByTag(value, tag, isDeep);\n        }\n      }\n      // Check for circular references and return its corresponding clone.\n      stack || (stack = new Stack);\n      var stacked = stack.get(value);\n      if (stacked) {\n        return stacked;\n      }\n      stack.set(value, result);\n\n      if (isSet(value)) {\n        value.forEach(function(subValue) {\n          result.add(baseClone(subValue, bitmask, customizer, subValue, value, stack));\n        });\n      } else if (isMap(value)) {\n        value.forEach(function(subValue, key) {\n          result.set(key, baseClone(subValue, bitmask, customizer, key, value, stack));\n        });\n      }\n\n      var keysFunc = isFull\n        ? (isFlat ? getAllKeysIn : getAllKeys)\n        : (isFlat ? keysIn : keys);\n\n      var props = isArr ? undefined : keysFunc(value);\n      arrayEach(props || value, function(subValue, key) {\n        if (props) {\n          key = subValue;\n          subValue = value[key];\n        }\n        // Recursively populate clone (susceptible to call stack limits).\n        assignValue(result, key, baseClone(subValue, bitmask, customizer, key, value, stack));\n      });\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.conforms` which doesn't clone `source`.\n     *\n     * @private\n     * @param {Object} source The object of property predicates to conform to.\n     * @returns {Function} Returns the new spec function.\n     */\n    function baseConforms(source) {\n      var props = keys(source);\n      return function(object) {\n        return baseConformsTo(object, source, props);\n      };\n    }\n\n    /**\n     * The base implementation of `_.conformsTo` which accepts `props` to check.\n     *\n     * @private\n     * @param {Object} object The object to inspect.\n     * @param {Object} source The object of property predicates to conform to.\n     * @returns {boolean} Returns `true` if `object` conforms, else `false`.\n     */\n    function baseConformsTo(object, source, props) {\n      var length = props.length;\n      if (object == null) {\n        return !length;\n      }\n      object = Object(object);\n      while (length--) {\n        var key = props[length],\n            predicate = source[key],\n            value = object[key];\n\n        if ((value === undefined && !(key in object)) || !predicate(value)) {\n          return false;\n        }\n      }\n      return true;\n    }\n\n    /**\n     * The base implementation of `_.delay` and `_.defer` which accepts `args`\n     * to provide to `func`.\n     *\n     * @private\n     * @param {Function} func The function to delay.\n     * @param {number} wait The number of milliseconds to delay invocation.\n     * @param {Array} args The arguments to provide to `func`.\n     * @returns {number|Object} Returns the timer id or timeout object.\n     */\n    function baseDelay(func, wait, args) {\n      if (typeof func != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      return setTimeout(function() { func.apply(undefined, args); }, wait);\n    }\n\n    /**\n     * The base implementation of methods like `_.difference` without support\n     * for excluding multiple arrays or iteratee shorthands.\n     *\n     * @private\n     * @param {Array} array The array to inspect.\n     * @param {Array} values The values to exclude.\n     * @param {Function} [iteratee] The iteratee invoked per element.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns the new array of filtered values.\n     */\n    function baseDifference(array, values, iteratee, comparator) {\n      var index = -1,\n          includes = arrayIncludes,\n          isCommon = true,\n          length = array.length,\n          result = [],\n          valuesLength = values.length;\n\n      if (!length) {\n        return result;\n      }\n      if (iteratee) {\n        values = arrayMap(values, baseUnary(iteratee));\n      }\n      if (comparator) {\n        includes = arrayIncludesWith;\n        isCommon = false;\n      }\n      else if (values.length >= LARGE_ARRAY_SIZE) {\n        includes = cacheHas;\n        isCommon = false;\n        values = new SetCache(values);\n      }\n      outer:\n      while (++index < length) {\n        var value = array[index],\n            computed = iteratee == null ? value : iteratee(value);\n\n        value = (comparator || value !== 0) ? value : 0;\n        if (isCommon && computed === computed) {\n          var valuesIndex = valuesLength;\n          while (valuesIndex--) {\n            if (values[valuesIndex] === computed) {\n              continue outer;\n            }\n          }\n          result.push(value);\n        }\n        else if (!includes(values, computed, comparator)) {\n          result.push(value);\n        }\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.forEach` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} iteratee The function invoked per iteration.\n     * @returns {Array|Object} Returns `collection`.\n     */\n    var baseEach = createBaseEach(baseForOwn);\n\n    /**\n     * The base implementation of `_.forEachRight` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} iteratee The function invoked per iteration.\n     * @returns {Array|Object} Returns `collection`.\n     */\n    var baseEachRight = createBaseEach(baseForOwnRight, true);\n\n    /**\n     * The base implementation of `_.every` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} predicate The function invoked per iteration.\n     * @returns {boolean} Returns `true` if all elements pass the predicate check,\n     *  else `false`\n     */\n    function baseEvery(collection, predicate) {\n      var result = true;\n      baseEach(collection, function(value, index, collection) {\n        result = !!predicate(value, index, collection);\n        return result;\n      });\n      return result;\n    }\n\n    /**\n     * The base implementation of methods like `_.max` and `_.min` which accepts a\n     * `comparator` to determine the extremum value.\n     *\n     * @private\n     * @param {Array} array The array to iterate over.\n     * @param {Function} iteratee The iteratee invoked per iteration.\n     * @param {Function} comparator The comparator used to compare values.\n     * @returns {*} Returns the extremum value.\n     */\n    function baseExtremum(array, iteratee, comparator) {\n      var index = -1,\n          length = array.length;\n\n      while (++index < length) {\n        var value = array[index],\n            current = iteratee(value);\n\n        if (current != null && (computed === undefined\n              ? (current === current && !isSymbol(current))\n              : comparator(current, computed)\n            )) {\n          var computed = current,\n              result = value;\n        }\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.fill` without an iteratee call guard.\n     *\n     * @private\n     * @param {Array} array The array to fill.\n     * @param {*} value The value to fill `array` with.\n     * @param {number} [start=0] The start position.\n     * @param {number} [end=array.length] The end position.\n     * @returns {Array} Returns `array`.\n     */\n    function baseFill(array, value, start, end) {\n      var length = array.length;\n\n      start = toInteger(start);\n      if (start < 0) {\n        start = -start > length ? 0 : (length + start);\n      }\n      end = (end === undefined || end > length) ? length : toInteger(end);\n      if (end < 0) {\n        end += length;\n      }\n      end = start > end ? 0 : toLength(end);\n      while (start < end) {\n        array[start++] = value;\n      }\n      return array;\n    }\n\n    /**\n     * The base implementation of `_.filter` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} predicate The function invoked per iteration.\n     * @returns {Array} Returns the new filtered array.\n     */\n    function baseFilter(collection, predicate) {\n      var result = [];\n      baseEach(collection, function(value, index, collection) {\n        if (predicate(value, index, collection)) {\n          result.push(value);\n        }\n      });\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.flatten` with support for restricting flattening.\n     *\n     * @private\n     * @param {Array} array The array to flatten.\n     * @param {number} depth The maximum recursion depth.\n     * @param {boolean} [predicate=isFlattenable] The function invoked per iteration.\n     * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks.\n     * @param {Array} [result=[]] The initial result value.\n     * @returns {Array} Returns the new flattened array.\n     */\n    function baseFlatten(array, depth, predicate, isStrict, result) {\n      var index = -1,\n          length = array.length;\n\n      predicate || (predicate = isFlattenable);\n      result || (result = []);\n\n      while (++index < length) {\n        var value = array[index];\n        if (depth > 0 && predicate(value)) {\n          if (depth > 1) {\n            // Recursively flatten arrays (susceptible to call stack limits).\n            baseFlatten(value, depth - 1, predicate, isStrict, result);\n          } else {\n            arrayPush(result, value);\n          }\n        } else if (!isStrict) {\n          result[result.length] = value;\n        }\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `baseForOwn` which iterates over `object`\n     * properties returned by `keysFunc` and invokes `iteratee` for each property.\n     * Iteratee functions may exit iteration early by explicitly returning `false`.\n     *\n     * @private\n     * @param {Object} object The object to iterate over.\n     * @param {Function} iteratee The function invoked per iteration.\n     * @param {Function} keysFunc The function to get the keys of `object`.\n     * @returns {Object} Returns `object`.\n     */\n    var baseFor = createBaseFor();\n\n    /**\n     * This function is like `baseFor` except that it iterates over properties\n     * in the opposite order.\n     *\n     * @private\n     * @param {Object} object The object to iterate over.\n     * @param {Function} iteratee The function invoked per iteration.\n     * @param {Function} keysFunc The function to get the keys of `object`.\n     * @returns {Object} Returns `object`.\n     */\n    var baseForRight = createBaseFor(true);\n\n    /**\n     * The base implementation of `_.forOwn` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Object} object The object to iterate over.\n     * @param {Function} iteratee The function invoked per iteration.\n     * @returns {Object} Returns `object`.\n     */\n    function baseForOwn(object, iteratee) {\n      return object && baseFor(object, iteratee, keys);\n    }\n\n    /**\n     * The base implementation of `_.forOwnRight` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Object} object The object to iterate over.\n     * @param {Function} iteratee The function invoked per iteration.\n     * @returns {Object} Returns `object`.\n     */\n    function baseForOwnRight(object, iteratee) {\n      return object && baseForRight(object, iteratee, keys);\n    }\n\n    /**\n     * The base implementation of `_.functions` which creates an array of\n     * `object` function property names filtered from `props`.\n     *\n     * @private\n     * @param {Object} object The object to inspect.\n     * @param {Array} props The property names to filter.\n     * @returns {Array} Returns the function names.\n     */\n    function baseFunctions(object, props) {\n      return arrayFilter(props, function(key) {\n        return isFunction(object[key]);\n      });\n    }\n\n    /**\n     * The base implementation of `_.get` without support for default values.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @param {Array|string} path The path of the property to get.\n     * @returns {*} Returns the resolved value.\n     */\n    function baseGet(object, path) {\n      path = castPath(path, object);\n\n      var index = 0,\n          length = path.length;\n\n      while (object != null && index < length) {\n        object = object[toKey(path[index++])];\n      }\n      return (index && index == length) ? object : undefined;\n    }\n\n    /**\n     * The base implementation of `getAllKeys` and `getAllKeysIn` which uses\n     * `keysFunc` and `symbolsFunc` to get the enumerable property names and\n     * symbols of `object`.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @param {Function} keysFunc The function to get the keys of `object`.\n     * @param {Function} symbolsFunc The function to get the symbols of `object`.\n     * @returns {Array} Returns the array of property names and symbols.\n     */\n    function baseGetAllKeys(object, keysFunc, symbolsFunc) {\n      var result = keysFunc(object);\n      return isArray(object) ? result : arrayPush(result, symbolsFunc(object));\n    }\n\n    /**\n     * The base implementation of `getTag` without fallbacks for buggy environments.\n     *\n     * @private\n     * @param {*} value The value to query.\n     * @returns {string} Returns the `toStringTag`.\n     */\n    function baseGetTag(value) {\n      if (value == null) {\n        return value === undefined ? undefinedTag : nullTag;\n      }\n      return (symToStringTag && symToStringTag in Object(value))\n        ? getRawTag(value)\n        : objectToString(value);\n    }\n\n    /**\n     * The base implementation of `_.gt` which doesn't coerce arguments.\n     *\n     * @private\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @returns {boolean} Returns `true` if `value` is greater than `other`,\n     *  else `false`.\n     */\n    function baseGt(value, other) {\n      return value > other;\n    }\n\n    /**\n     * The base implementation of `_.has` without support for deep paths.\n     *\n     * @private\n     * @param {Object} [object] The object to query.\n     * @param {Array|string} key The key to check.\n     * @returns {boolean} Returns `true` if `key` exists, else `false`.\n     */\n    function baseHas(object, key) {\n      return object != null && hasOwnProperty.call(object, key);\n    }\n\n    /**\n     * The base implementation of `_.hasIn` without support for deep paths.\n     *\n     * @private\n     * @param {Object} [object] The object to query.\n     * @param {Array|string} key The key to check.\n     * @returns {boolean} Returns `true` if `key` exists, else `false`.\n     */\n    function baseHasIn(object, key) {\n      return object != null && key in Object(object);\n    }\n\n    /**\n     * The base implementation of `_.inRange` which doesn't coerce arguments.\n     *\n     * @private\n     * @param {number} number The number to check.\n     * @param {number} start The start of the range.\n     * @param {number} end The end of the range.\n     * @returns {boolean} Returns `true` if `number` is in the range, else `false`.\n     */\n    function baseInRange(number, start, end) {\n      return number >= nativeMin(start, end) && number < nativeMax(start, end);\n    }\n\n    /**\n     * The base implementation of methods like `_.intersection`, without support\n     * for iteratee shorthands, that accepts an array of arrays to inspect.\n     *\n     * @private\n     * @param {Array} arrays The arrays to inspect.\n     * @param {Function} [iteratee] The iteratee invoked per element.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns the new array of shared values.\n     */\n    function baseIntersection(arrays, iteratee, comparator) {\n      var includes = comparator ? arrayIncludesWith : arrayIncludes,\n          length = arrays[0].length,\n          othLength = arrays.length,\n          othIndex = othLength,\n          caches = Array(othLength),\n          maxLength = Infinity,\n          result = [];\n\n      while (othIndex--) {\n        var array = arrays[othIndex];\n        if (othIndex && iteratee) {\n          array = arrayMap(array, baseUnary(iteratee));\n        }\n        maxLength = nativeMin(array.length, maxLength);\n        caches[othIndex] = !comparator && (iteratee || (length >= 120 && array.length >= 120))\n          ? new SetCache(othIndex && array)\n          : undefined;\n      }\n      array = arrays[0];\n\n      var index = -1,\n          seen = caches[0];\n\n      outer:\n      while (++index < length && result.length < maxLength) {\n        var value = array[index],\n            computed = iteratee ? iteratee(value) : value;\n\n        value = (comparator || value !== 0) ? value : 0;\n        if (!(seen\n              ? cacheHas(seen, computed)\n              : includes(result, computed, comparator)\n            )) {\n          othIndex = othLength;\n          while (--othIndex) {\n            var cache = caches[othIndex];\n            if (!(cache\n                  ? cacheHas(cache, computed)\n                  : includes(arrays[othIndex], computed, comparator))\n                ) {\n              continue outer;\n            }\n          }\n          if (seen) {\n            seen.push(computed);\n          }\n          result.push(value);\n        }\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.invert` and `_.invertBy` which inverts\n     * `object` with values transformed by `iteratee` and set by `setter`.\n     *\n     * @private\n     * @param {Object} object The object to iterate over.\n     * @param {Function} setter The function to set `accumulator` values.\n     * @param {Function} iteratee The iteratee to transform values.\n     * @param {Object} accumulator The initial inverted object.\n     * @returns {Function} Returns `accumulator`.\n     */\n    function baseInverter(object, setter, iteratee, accumulator) {\n      baseForOwn(object, function(value, key, object) {\n        setter(accumulator, iteratee(value), key, object);\n      });\n      return accumulator;\n    }\n\n    /**\n     * The base implementation of `_.invoke` without support for individual\n     * method arguments.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @param {Array|string} path The path of the method to invoke.\n     * @param {Array} args The arguments to invoke the method with.\n     * @returns {*} Returns the result of the invoked method.\n     */\n    function baseInvoke(object, path, args) {\n      path = castPath(path, object);\n      object = parent(object, path);\n      var func = object == null ? object : object[toKey(last(path))];\n      return func == null ? undefined : apply(func, object, args);\n    }\n\n    /**\n     * The base implementation of `_.isArguments`.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n     */\n    function baseIsArguments(value) {\n      return isObjectLike(value) && baseGetTag(value) == argsTag;\n    }\n\n    /**\n     * The base implementation of `_.isArrayBuffer` without Node.js optimizations.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is an array buffer, else `false`.\n     */\n    function baseIsArrayBuffer(value) {\n      return isObjectLike(value) && baseGetTag(value) == arrayBufferTag;\n    }\n\n    /**\n     * The base implementation of `_.isDate` without Node.js optimizations.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a date object, else `false`.\n     */\n    function baseIsDate(value) {\n      return isObjectLike(value) && baseGetTag(value) == dateTag;\n    }\n\n    /**\n     * The base implementation of `_.isEqual` which supports partial comparisons\n     * and tracks traversed objects.\n     *\n     * @private\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @param {boolean} bitmask The bitmask flags.\n     *  1 - Unordered comparison\n     *  2 - Partial comparison\n     * @param {Function} [customizer] The function to customize comparisons.\n     * @param {Object} [stack] Tracks traversed `value` and `other` objects.\n     * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n     */\n    function baseIsEqual(value, other, bitmask, customizer, stack) {\n      if (value === other) {\n        return true;\n      }\n      if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) {\n        return value !== value && other !== other;\n      }\n      return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);\n    }\n\n    /**\n     * A specialized version of `baseIsEqual` for arrays and objects which performs\n     * deep comparisons and tracks traversed objects enabling objects with circular\n     * references to be compared.\n     *\n     * @private\n     * @param {Object} object The object to compare.\n     * @param {Object} other The other object to compare.\n     * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n     * @param {Function} customizer The function to customize comparisons.\n     * @param {Function} equalFunc The function to determine equivalents of values.\n     * @param {Object} [stack] Tracks traversed `object` and `other` objects.\n     * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n     */\n    function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {\n      var objIsArr = isArray(object),\n          othIsArr = isArray(other),\n          objTag = objIsArr ? arrayTag : getTag(object),\n          othTag = othIsArr ? arrayTag : getTag(other);\n\n      objTag = objTag == argsTag ? objectTag : objTag;\n      othTag = othTag == argsTag ? objectTag : othTag;\n\n      var objIsObj = objTag == objectTag,\n          othIsObj = othTag == objectTag,\n          isSameTag = objTag == othTag;\n\n      if (isSameTag && isBuffer(object)) {\n        if (!isBuffer(other)) {\n          return false;\n        }\n        objIsArr = true;\n        objIsObj = false;\n      }\n      if (isSameTag && !objIsObj) {\n        stack || (stack = new Stack);\n        return (objIsArr || isTypedArray(object))\n          ? equalArrays(object, other, bitmask, customizer, equalFunc, stack)\n          : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);\n      }\n      if (!(bitmask & COMPARE_PARTIAL_FLAG)) {\n        var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),\n            othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');\n\n        if (objIsWrapped || othIsWrapped) {\n          var objUnwrapped = objIsWrapped ? object.value() : object,\n              othUnwrapped = othIsWrapped ? other.value() : other;\n\n          stack || (stack = new Stack);\n          return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);\n        }\n      }\n      if (!isSameTag) {\n        return false;\n      }\n      stack || (stack = new Stack);\n      return equalObjects(object, other, bitmask, customizer, equalFunc, stack);\n    }\n\n    /**\n     * The base implementation of `_.isMap` without Node.js optimizations.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a map, else `false`.\n     */\n    function baseIsMap(value) {\n      return isObjectLike(value) && getTag(value) == mapTag;\n    }\n\n    /**\n     * The base implementation of `_.isMatch` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Object} object The object to inspect.\n     * @param {Object} source The object of property values to match.\n     * @param {Array} matchData The property names, values, and compare flags to match.\n     * @param {Function} [customizer] The function to customize comparisons.\n     * @returns {boolean} Returns `true` if `object` is a match, else `false`.\n     */\n    function baseIsMatch(object, source, matchData, customizer) {\n      var index = matchData.length,\n          length = index,\n          noCustomizer = !customizer;\n\n      if (object == null) {\n        return !length;\n      }\n      object = Object(object);\n      while (index--) {\n        var data = matchData[index];\n        if ((noCustomizer && data[2])\n              ? data[1] !== object[data[0]]\n              : !(data[0] in object)\n            ) {\n          return false;\n        }\n      }\n      while (++index < length) {\n        data = matchData[index];\n        var key = data[0],\n            objValue = object[key],\n            srcValue = data[1];\n\n        if (noCustomizer && data[2]) {\n          if (objValue === undefined && !(key in object)) {\n            return false;\n          }\n        } else {\n          var stack = new Stack;\n          if (customizer) {\n            var result = customizer(objValue, srcValue, key, object, source, stack);\n          }\n          if (!(result === undefined\n                ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG, customizer, stack)\n                : result\n              )) {\n            return false;\n          }\n        }\n      }\n      return true;\n    }\n\n    /**\n     * The base implementation of `_.isNative` without bad shim checks.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a native function,\n     *  else `false`.\n     */\n    function baseIsNative(value) {\n      if (!isObject(value) || isMasked(value)) {\n        return false;\n      }\n      var pattern = isFunction(value) ? reIsNative : reIsHostCtor;\n      return pattern.test(toSource(value));\n    }\n\n    /**\n     * The base implementation of `_.isRegExp` without Node.js optimizations.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a regexp, else `false`.\n     */\n    function baseIsRegExp(value) {\n      return isObjectLike(value) && baseGetTag(value) == regexpTag;\n    }\n\n    /**\n     * The base implementation of `_.isSet` without Node.js optimizations.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a set, else `false`.\n     */\n    function baseIsSet(value) {\n      return isObjectLike(value) && getTag(value) == setTag;\n    }\n\n    /**\n     * The base implementation of `_.isTypedArray` without Node.js optimizations.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n     */\n    function baseIsTypedArray(value) {\n      return isObjectLike(value) &&\n        isLength(value.length) && !!typedArrayTags[baseGetTag(value)];\n    }\n\n    /**\n     * The base implementation of `_.iteratee`.\n     *\n     * @private\n     * @param {*} [value=_.identity] The value to convert to an iteratee.\n     * @returns {Function} Returns the iteratee.\n     */\n    function baseIteratee(value) {\n      // Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9.\n      // See https://bugs.webkit.org/show_bug.cgi?id=156034 for more details.\n      if (typeof value == 'function') {\n        return value;\n      }\n      if (value == null) {\n        return identity;\n      }\n      if (typeof value == 'object') {\n        return isArray(value)\n          ? baseMatchesProperty(value[0], value[1])\n          : baseMatches(value);\n      }\n      return property(value);\n    }\n\n    /**\n     * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the array of property names.\n     */\n    function baseKeys(object) {\n      if (!isPrototype(object)) {\n        return nativeKeys(object);\n      }\n      var result = [];\n      for (var key in Object(object)) {\n        if (hasOwnProperty.call(object, key) && key != 'constructor') {\n          result.push(key);\n        }\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the array of property names.\n     */\n    function baseKeysIn(object) {\n      if (!isObject(object)) {\n        return nativeKeysIn(object);\n      }\n      var isProto = isPrototype(object),\n          result = [];\n\n      for (var key in object) {\n        if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {\n          result.push(key);\n        }\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.lt` which doesn't coerce arguments.\n     *\n     * @private\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @returns {boolean} Returns `true` if `value` is less than `other`,\n     *  else `false`.\n     */\n    function baseLt(value, other) {\n      return value < other;\n    }\n\n    /**\n     * The base implementation of `_.map` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} iteratee The function invoked per iteration.\n     * @returns {Array} Returns the new mapped array.\n     */\n    function baseMap(collection, iteratee) {\n      var index = -1,\n          result = isArrayLike(collection) ? Array(collection.length) : [];\n\n      baseEach(collection, function(value, key, collection) {\n        result[++index] = iteratee(value, key, collection);\n      });\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.matches` which doesn't clone `source`.\n     *\n     * @private\n     * @param {Object} source The object of property values to match.\n     * @returns {Function} Returns the new spec function.\n     */\n    function baseMatches(source) {\n      var matchData = getMatchData(source);\n      if (matchData.length == 1 && matchData[0][2]) {\n        return matchesStrictComparable(matchData[0][0], matchData[0][1]);\n      }\n      return function(object) {\n        return object === source || baseIsMatch(object, source, matchData);\n      };\n    }\n\n    /**\n     * The base implementation of `_.matchesProperty` which doesn't clone `srcValue`.\n     *\n     * @private\n     * @param {string} path The path of the property to get.\n     * @param {*} srcValue The value to match.\n     * @returns {Function} Returns the new spec function.\n     */\n    function baseMatchesProperty(path, srcValue) {\n      if (isKey(path) && isStrictComparable(srcValue)) {\n        return matchesStrictComparable(toKey(path), srcValue);\n      }\n      return function(object) {\n        var objValue = get(object, path);\n        return (objValue === undefined && objValue === srcValue)\n          ? hasIn(object, path)\n          : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);\n      };\n    }\n\n    /**\n     * The base implementation of `_.merge` without support for multiple sources.\n     *\n     * @private\n     * @param {Object} object The destination object.\n     * @param {Object} source The source object.\n     * @param {number} srcIndex The index of `source`.\n     * @param {Function} [customizer] The function to customize merged values.\n     * @param {Object} [stack] Tracks traversed source values and their merged\n     *  counterparts.\n     */\n    function baseMerge(object, source, srcIndex, customizer, stack) {\n      if (object === source) {\n        return;\n      }\n      baseFor(source, function(srcValue, key) {\n        stack || (stack = new Stack);\n        if (isObject(srcValue)) {\n          baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);\n        }\n        else {\n          var newValue = customizer\n            ? customizer(safeGet(object, key), srcValue, (key + ''), object, source, stack)\n            : undefined;\n\n          if (newValue === undefined) {\n            newValue = srcValue;\n          }\n          assignMergeValue(object, key, newValue);\n        }\n      }, keysIn);\n    }\n\n    /**\n     * A specialized version of `baseMerge` for arrays and objects which performs\n     * deep merges and tracks traversed objects enabling objects with circular\n     * references to be merged.\n     *\n     * @private\n     * @param {Object} object The destination object.\n     * @param {Object} source The source object.\n     * @param {string} key The key of the value to merge.\n     * @param {number} srcIndex The index of `source`.\n     * @param {Function} mergeFunc The function to merge values.\n     * @param {Function} [customizer] The function to customize assigned values.\n     * @param {Object} [stack] Tracks traversed source values and their merged\n     *  counterparts.\n     */\n    function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {\n      var objValue = safeGet(object, key),\n          srcValue = safeGet(source, key),\n          stacked = stack.get(srcValue);\n\n      if (stacked) {\n        assignMergeValue(object, key, stacked);\n        return;\n      }\n      var newValue = customizer\n        ? customizer(objValue, srcValue, (key + ''), object, source, stack)\n        : undefined;\n\n      var isCommon = newValue === undefined;\n\n      if (isCommon) {\n        var isArr = isArray(srcValue),\n            isBuff = !isArr && isBuffer(srcValue),\n            isTyped = !isArr && !isBuff && isTypedArray(srcValue);\n\n        newValue = srcValue;\n        if (isArr || isBuff || isTyped) {\n          if (isArray(objValue)) {\n            newValue = objValue;\n          }\n          else if (isArrayLikeObject(objValue)) {\n            newValue = copyArray(objValue);\n          }\n          else if (isBuff) {\n            isCommon = false;\n            newValue = cloneBuffer(srcValue, true);\n          }\n          else if (isTyped) {\n            isCommon = false;\n            newValue = cloneTypedArray(srcValue, true);\n          }\n          else {\n            newValue = [];\n          }\n        }\n        else if (isPlainObject(srcValue) || isArguments(srcValue)) {\n          newValue = objValue;\n          if (isArguments(objValue)) {\n            newValue = toPlainObject(objValue);\n          }\n          else if (!isObject(objValue) || isFunction(objValue)) {\n            newValue = initCloneObject(srcValue);\n          }\n        }\n        else {\n          isCommon = false;\n        }\n      }\n      if (isCommon) {\n        // Recursively merge objects and arrays (susceptible to call stack limits).\n        stack.set(srcValue, newValue);\n        mergeFunc(newValue, srcValue, srcIndex, customizer, stack);\n        stack['delete'](srcValue);\n      }\n      assignMergeValue(object, key, newValue);\n    }\n\n    /**\n     * The base implementation of `_.nth` which doesn't coerce arguments.\n     *\n     * @private\n     * @param {Array} array The array to query.\n     * @param {number} n The index of the element to return.\n     * @returns {*} Returns the nth element of `array`.\n     */\n    function baseNth(array, n) {\n      var length = array.length;\n      if (!length) {\n        return;\n      }\n      n += n < 0 ? length : 0;\n      return isIndex(n, length) ? array[n] : undefined;\n    }\n\n    /**\n     * The base implementation of `_.orderBy` without param guards.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function[]|Object[]|string[]} iteratees The iteratees to sort by.\n     * @param {string[]} orders The sort orders of `iteratees`.\n     * @returns {Array} Returns the new sorted array.\n     */\n    function baseOrderBy(collection, iteratees, orders) {\n      if (iteratees.length) {\n        iteratees = arrayMap(iteratees, function(iteratee) {\n          if (isArray(iteratee)) {\n            return function(value) {\n              return baseGet(value, iteratee.length === 1 ? iteratee[0] : iteratee);\n            }\n          }\n          return iteratee;\n        });\n      } else {\n        iteratees = [identity];\n      }\n\n      var index = -1;\n      iteratees = arrayMap(iteratees, baseUnary(getIteratee()));\n\n      var result = baseMap(collection, function(value, key, collection) {\n        var criteria = arrayMap(iteratees, function(iteratee) {\n          return iteratee(value);\n        });\n        return { 'criteria': criteria, 'index': ++index, 'value': value };\n      });\n\n      return baseSortBy(result, function(object, other) {\n        return compareMultiple(object, other, orders);\n      });\n    }\n\n    /**\n     * The base implementation of `_.pick` without support for individual\n     * property identifiers.\n     *\n     * @private\n     * @param {Object} object The source object.\n     * @param {string[]} paths The property paths to pick.\n     * @returns {Object} Returns the new object.\n     */\n    function basePick(object, paths) {\n      return basePickBy(object, paths, function(value, path) {\n        return hasIn(object, path);\n      });\n    }\n\n    /**\n     * The base implementation of  `_.pickBy` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Object} object The source object.\n     * @param {string[]} paths The property paths to pick.\n     * @param {Function} predicate The function invoked per property.\n     * @returns {Object} Returns the new object.\n     */\n    function basePickBy(object, paths, predicate) {\n      var index = -1,\n          length = paths.length,\n          result = {};\n\n      while (++index < length) {\n        var path = paths[index],\n            value = baseGet(object, path);\n\n        if (predicate(value, path)) {\n          baseSet(result, castPath(path, object), value);\n        }\n      }\n      return result;\n    }\n\n    /**\n     * A specialized version of `baseProperty` which supports deep paths.\n     *\n     * @private\n     * @param {Array|string} path The path of the property to get.\n     * @returns {Function} Returns the new accessor function.\n     */\n    function basePropertyDeep(path) {\n      return function(object) {\n        return baseGet(object, path);\n      };\n    }\n\n    /**\n     * The base implementation of `_.pullAllBy` without support for iteratee\n     * shorthands.\n     *\n     * @private\n     * @param {Array} array The array to modify.\n     * @param {Array} values The values to remove.\n     * @param {Function} [iteratee] The iteratee invoked per element.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns `array`.\n     */\n    function basePullAll(array, values, iteratee, comparator) {\n      var indexOf = comparator ? baseIndexOfWith : baseIndexOf,\n          index = -1,\n          length = values.length,\n          seen = array;\n\n      if (array === values) {\n        values = copyArray(values);\n      }\n      if (iteratee) {\n        seen = arrayMap(array, baseUnary(iteratee));\n      }\n      while (++index < length) {\n        var fromIndex = 0,\n            value = values[index],\n            computed = iteratee ? iteratee(value) : value;\n\n        while ((fromIndex = indexOf(seen, computed, fromIndex, comparator)) > -1) {\n          if (seen !== array) {\n            splice.call(seen, fromIndex, 1);\n          }\n          splice.call(array, fromIndex, 1);\n        }\n      }\n      return array;\n    }\n\n    /**\n     * The base implementation of `_.pullAt` without support for individual\n     * indexes or capturing the removed elements.\n     *\n     * @private\n     * @param {Array} array The array to modify.\n     * @param {number[]} indexes The indexes of elements to remove.\n     * @returns {Array} Returns `array`.\n     */\n    function basePullAt(array, indexes) {\n      var length = array ? indexes.length : 0,\n          lastIndex = length - 1;\n\n      while (length--) {\n        var index = indexes[length];\n        if (length == lastIndex || index !== previous) {\n          var previous = index;\n          if (isIndex(index)) {\n            splice.call(array, index, 1);\n          } else {\n            baseUnset(array, index);\n          }\n        }\n      }\n      return array;\n    }\n\n    /**\n     * The base implementation of `_.random` without support for returning\n     * floating-point numbers.\n     *\n     * @private\n     * @param {number} lower The lower bound.\n     * @param {number} upper The upper bound.\n     * @returns {number} Returns the random number.\n     */\n    function baseRandom(lower, upper) {\n      return lower + nativeFloor(nativeRandom() * (upper - lower + 1));\n    }\n\n    /**\n     * The base implementation of `_.range` and `_.rangeRight` which doesn't\n     * coerce arguments.\n     *\n     * @private\n     * @param {number} start The start of the range.\n     * @param {number} end The end of the range.\n     * @param {number} step The value to increment or decrement by.\n     * @param {boolean} [fromRight] Specify iterating from right to left.\n     * @returns {Array} Returns the range of numbers.\n     */\n    function baseRange(start, end, step, fromRight) {\n      var index = -1,\n          length = nativeMax(nativeCeil((end - start) / (step || 1)), 0),\n          result = Array(length);\n\n      while (length--) {\n        result[fromRight ? length : ++index] = start;\n        start += step;\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.repeat` which doesn't coerce arguments.\n     *\n     * @private\n     * @param {string} string The string to repeat.\n     * @param {number} n The number of times to repeat the string.\n     * @returns {string} Returns the repeated string.\n     */\n    function baseRepeat(string, n) {\n      var result = '';\n      if (!string || n < 1 || n > MAX_SAFE_INTEGER) {\n        return result;\n      }\n      // Leverage the exponentiation by squaring algorithm for a faster repeat.\n      // See https://en.wikipedia.org/wiki/Exponentiation_by_squaring for more details.\n      do {\n        if (n % 2) {\n          result += string;\n        }\n        n = nativeFloor(n / 2);\n        if (n) {\n          string += string;\n        }\n      } while (n);\n\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.rest` which doesn't validate or coerce arguments.\n     *\n     * @private\n     * @param {Function} func The function to apply a rest parameter to.\n     * @param {number} [start=func.length-1] The start position of the rest parameter.\n     * @returns {Function} Returns the new function.\n     */\n    function baseRest(func, start) {\n      return setToString(overRest(func, start, identity), func + '');\n    }\n\n    /**\n     * The base implementation of `_.sample`.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to sample.\n     * @returns {*} Returns the random element.\n     */\n    function baseSample(collection) {\n      return arraySample(values(collection));\n    }\n\n    /**\n     * The base implementation of `_.sampleSize` without param guards.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to sample.\n     * @param {number} n The number of elements to sample.\n     * @returns {Array} Returns the random elements.\n     */\n    function baseSampleSize(collection, n) {\n      var array = values(collection);\n      return shuffleSelf(array, baseClamp(n, 0, array.length));\n    }\n\n    /**\n     * The base implementation of `_.set`.\n     *\n     * @private\n     * @param {Object} object The object to modify.\n     * @param {Array|string} path The path of the property to set.\n     * @param {*} value The value to set.\n     * @param {Function} [customizer] The function to customize path creation.\n     * @returns {Object} Returns `object`.\n     */\n    function baseSet(object, path, value, customizer) {\n      if (!isObject(object)) {\n        return object;\n      }\n      path = castPath(path, object);\n\n      var index = -1,\n          length = path.length,\n          lastIndex = length - 1,\n          nested = object;\n\n      while (nested != null && ++index < length) {\n        var key = toKey(path[index]),\n            newValue = value;\n\n        if (key === '__proto__' || key === 'constructor' || key === 'prototype') {\n          return object;\n        }\n\n        if (index != lastIndex) {\n          var objValue = nested[key];\n          newValue = customizer ? customizer(objValue, key, nested) : undefined;\n          if (newValue === undefined) {\n            newValue = isObject(objValue)\n              ? objValue\n              : (isIndex(path[index + 1]) ? [] : {});\n          }\n        }\n        assignValue(nested, key, newValue);\n        nested = nested[key];\n      }\n      return object;\n    }\n\n    /**\n     * The base implementation of `setData` without support for hot loop shorting.\n     *\n     * @private\n     * @param {Function} func The function to associate metadata with.\n     * @param {*} data The metadata.\n     * @returns {Function} Returns `func`.\n     */\n    var baseSetData = !metaMap ? identity : function(func, data) {\n      metaMap.set(func, data);\n      return func;\n    };\n\n    /**\n     * The base implementation of `setToString` without support for hot loop shorting.\n     *\n     * @private\n     * @param {Function} func The function to modify.\n     * @param {Function} string The `toString` result.\n     * @returns {Function} Returns `func`.\n     */\n    var baseSetToString = !defineProperty ? identity : function(func, string) {\n      return defineProperty(func, 'toString', {\n        'configurable': true,\n        'enumerable': false,\n        'value': constant(string),\n        'writable': true\n      });\n    };\n\n    /**\n     * The base implementation of `_.shuffle`.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to shuffle.\n     * @returns {Array} Returns the new shuffled array.\n     */\n    function baseShuffle(collection) {\n      return shuffleSelf(values(collection));\n    }\n\n    /**\n     * The base implementation of `_.slice` without an iteratee call guard.\n     *\n     * @private\n     * @param {Array} array The array to slice.\n     * @param {number} [start=0] The start position.\n     * @param {number} [end=array.length] The end position.\n     * @returns {Array} Returns the slice of `array`.\n     */\n    function baseSlice(array, start, end) {\n      var index = -1,\n          length = array.length;\n\n      if (start < 0) {\n        start = -start > length ? 0 : (length + start);\n      }\n      end = end > length ? length : end;\n      if (end < 0) {\n        end += length;\n      }\n      length = start > end ? 0 : ((end - start) >>> 0);\n      start >>>= 0;\n\n      var result = Array(length);\n      while (++index < length) {\n        result[index] = array[index + start];\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.some` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} predicate The function invoked per iteration.\n     * @returns {boolean} Returns `true` if any element passes the predicate check,\n     *  else `false`.\n     */\n    function baseSome(collection, predicate) {\n      var result;\n\n      baseEach(collection, function(value, index, collection) {\n        result = predicate(value, index, collection);\n        return !result;\n      });\n      return !!result;\n    }\n\n    /**\n     * The base implementation of `_.sortedIndex` and `_.sortedLastIndex` which\n     * performs a binary search of `array` to determine the index at which `value`\n     * should be inserted into `array` in order to maintain its sort order.\n     *\n     * @private\n     * @param {Array} array The sorted array to inspect.\n     * @param {*} value The value to evaluate.\n     * @param {boolean} [retHighest] Specify returning the highest qualified index.\n     * @returns {number} Returns the index at which `value` should be inserted\n     *  into `array`.\n     */\n    function baseSortedIndex(array, value, retHighest) {\n      var low = 0,\n          high = array == null ? low : array.length;\n\n      if (typeof value == 'number' && value === value && high <= HALF_MAX_ARRAY_LENGTH) {\n        while (low < high) {\n          var mid = (low + high) >>> 1,\n              computed = array[mid];\n\n          if (computed !== null && !isSymbol(computed) &&\n              (retHighest ? (computed <= value) : (computed < value))) {\n            low = mid + 1;\n          } else {\n            high = mid;\n          }\n        }\n        return high;\n      }\n      return baseSortedIndexBy(array, value, identity, retHighest);\n    }\n\n    /**\n     * The base implementation of `_.sortedIndexBy` and `_.sortedLastIndexBy`\n     * which invokes `iteratee` for `value` and each element of `array` to compute\n     * their sort ranking. The iteratee is invoked with one argument; (value).\n     *\n     * @private\n     * @param {Array} array The sorted array to inspect.\n     * @param {*} value The value to evaluate.\n     * @param {Function} iteratee The iteratee invoked per element.\n     * @param {boolean} [retHighest] Specify returning the highest qualified index.\n     * @returns {number} Returns the index at which `value` should be inserted\n     *  into `array`.\n     */\n    function baseSortedIndexBy(array, value, iteratee, retHighest) {\n      var low = 0,\n          high = array == null ? 0 : array.length;\n      if (high === 0) {\n        return 0;\n      }\n\n      value = iteratee(value);\n      var valIsNaN = value !== value,\n          valIsNull = value === null,\n          valIsSymbol = isSymbol(value),\n          valIsUndefined = value === undefined;\n\n      while (low < high) {\n        var mid = nativeFloor((low + high) / 2),\n            computed = iteratee(array[mid]),\n            othIsDefined = computed !== undefined,\n            othIsNull = computed === null,\n            othIsReflexive = computed === computed,\n            othIsSymbol = isSymbol(computed);\n\n        if (valIsNaN) {\n          var setLow = retHighest || othIsReflexive;\n        } else if (valIsUndefined) {\n          setLow = othIsReflexive && (retHighest || othIsDefined);\n        } else if (valIsNull) {\n          setLow = othIsReflexive && othIsDefined && (retHighest || !othIsNull);\n        } else if (valIsSymbol) {\n          setLow = othIsReflexive && othIsDefined && !othIsNull && (retHighest || !othIsSymbol);\n        } else if (othIsNull || othIsSymbol) {\n          setLow = false;\n        } else {\n          setLow = retHighest ? (computed <= value) : (computed < value);\n        }\n        if (setLow) {\n          low = mid + 1;\n        } else {\n          high = mid;\n        }\n      }\n      return nativeMin(high, MAX_ARRAY_INDEX);\n    }\n\n    /**\n     * The base implementation of `_.sortedUniq` and `_.sortedUniqBy` without\n     * support for iteratee shorthands.\n     *\n     * @private\n     * @param {Array} array The array to inspect.\n     * @param {Function} [iteratee] The iteratee invoked per element.\n     * @returns {Array} Returns the new duplicate free array.\n     */\n    function baseSortedUniq(array, iteratee) {\n      var index = -1,\n          length = array.length,\n          resIndex = 0,\n          result = [];\n\n      while (++index < length) {\n        var value = array[index],\n            computed = iteratee ? iteratee(value) : value;\n\n        if (!index || !eq(computed, seen)) {\n          var seen = computed;\n          result[resIndex++] = value === 0 ? 0 : value;\n        }\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.toNumber` which doesn't ensure correct\n     * conversions of binary, hexadecimal, or octal string values.\n     *\n     * @private\n     * @param {*} value The value to process.\n     * @returns {number} Returns the number.\n     */\n    function baseToNumber(value) {\n      if (typeof value == 'number') {\n        return value;\n      }\n      if (isSymbol(value)) {\n        return NAN;\n      }\n      return +value;\n    }\n\n    /**\n     * The base implementation of `_.toString` which doesn't convert nullish\n     * values to empty strings.\n     *\n     * @private\n     * @param {*} value The value to process.\n     * @returns {string} Returns the string.\n     */\n    function baseToString(value) {\n      // Exit early for strings to avoid a performance hit in some environments.\n      if (typeof value == 'string') {\n        return value;\n      }\n      if (isArray(value)) {\n        // Recursively convert values (susceptible to call stack limits).\n        return arrayMap(value, baseToString) + '';\n      }\n      if (isSymbol(value)) {\n        return symbolToString ? symbolToString.call(value) : '';\n      }\n      var result = (value + '');\n      return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;\n    }\n\n    /**\n     * The base implementation of `_.uniqBy` without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Array} array The array to inspect.\n     * @param {Function} [iteratee] The iteratee invoked per element.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns the new duplicate free array.\n     */\n    function baseUniq(array, iteratee, comparator) {\n      var index = -1,\n          includes = arrayIncludes,\n          length = array.length,\n          isCommon = true,\n          result = [],\n          seen = result;\n\n      if (comparator) {\n        isCommon = false;\n        includes = arrayIncludesWith;\n      }\n      else if (length >= LARGE_ARRAY_SIZE) {\n        var set = iteratee ? null : createSet(array);\n        if (set) {\n          return setToArray(set);\n        }\n        isCommon = false;\n        includes = cacheHas;\n        seen = new SetCache;\n      }\n      else {\n        seen = iteratee ? [] : result;\n      }\n      outer:\n      while (++index < length) {\n        var value = array[index],\n            computed = iteratee ? iteratee(value) : value;\n\n        value = (comparator || value !== 0) ? value : 0;\n        if (isCommon && computed === computed) {\n          var seenIndex = seen.length;\n          while (seenIndex--) {\n            if (seen[seenIndex] === computed) {\n              continue outer;\n            }\n          }\n          if (iteratee) {\n            seen.push(computed);\n          }\n          result.push(value);\n        }\n        else if (!includes(seen, computed, comparator)) {\n          if (seen !== result) {\n            seen.push(computed);\n          }\n          result.push(value);\n        }\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.unset`.\n     *\n     * @private\n     * @param {Object} object The object to modify.\n     * @param {Array|string} path The property path to unset.\n     * @returns {boolean} Returns `true` if the property is deleted, else `false`.\n     */\n    function baseUnset(object, path) {\n      path = castPath(path, object);\n      object = parent(object, path);\n      return object == null || delete object[toKey(last(path))];\n    }\n\n    /**\n     * The base implementation of `_.update`.\n     *\n     * @private\n     * @param {Object} object The object to modify.\n     * @param {Array|string} path The path of the property to update.\n     * @param {Function} updater The function to produce the updated value.\n     * @param {Function} [customizer] The function to customize path creation.\n     * @returns {Object} Returns `object`.\n     */\n    function baseUpdate(object, path, updater, customizer) {\n      return baseSet(object, path, updater(baseGet(object, path)), customizer);\n    }\n\n    /**\n     * The base implementation of methods like `_.dropWhile` and `_.takeWhile`\n     * without support for iteratee shorthands.\n     *\n     * @private\n     * @param {Array} array The array to query.\n     * @param {Function} predicate The function invoked per iteration.\n     * @param {boolean} [isDrop] Specify dropping elements instead of taking them.\n     * @param {boolean} [fromRight] Specify iterating from right to left.\n     * @returns {Array} Returns the slice of `array`.\n     */\n    function baseWhile(array, predicate, isDrop, fromRight) {\n      var length = array.length,\n          index = fromRight ? length : -1;\n\n      while ((fromRight ? index-- : ++index < length) &&\n        predicate(array[index], index, array)) {}\n\n      return isDrop\n        ? baseSlice(array, (fromRight ? 0 : index), (fromRight ? index + 1 : length))\n        : baseSlice(array, (fromRight ? index + 1 : 0), (fromRight ? length : index));\n    }\n\n    /**\n     * The base implementation of `wrapperValue` which returns the result of\n     * performing a sequence of actions on the unwrapped `value`, where each\n     * successive action is supplied the return value of the previous.\n     *\n     * @private\n     * @param {*} value The unwrapped value.\n     * @param {Array} actions Actions to perform to resolve the unwrapped value.\n     * @returns {*} Returns the resolved value.\n     */\n    function baseWrapperValue(value, actions) {\n      var result = value;\n      if (result instanceof LazyWrapper) {\n        result = result.value();\n      }\n      return arrayReduce(actions, function(result, action) {\n        return action.func.apply(action.thisArg, arrayPush([result], action.args));\n      }, result);\n    }\n\n    /**\n     * The base implementation of methods like `_.xor`, without support for\n     * iteratee shorthands, that accepts an array of arrays to inspect.\n     *\n     * @private\n     * @param {Array} arrays The arrays to inspect.\n     * @param {Function} [iteratee] The iteratee invoked per element.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns the new array of values.\n     */\n    function baseXor(arrays, iteratee, comparator) {\n      var length = arrays.length;\n      if (length < 2) {\n        return length ? baseUniq(arrays[0]) : [];\n      }\n      var index = -1,\n          result = Array(length);\n\n      while (++index < length) {\n        var array = arrays[index],\n            othIndex = -1;\n\n        while (++othIndex < length) {\n          if (othIndex != index) {\n            result[index] = baseDifference(result[index] || array, arrays[othIndex], iteratee, comparator);\n          }\n        }\n      }\n      return baseUniq(baseFlatten(result, 1), iteratee, comparator);\n    }\n\n    /**\n     * This base implementation of `_.zipObject` which assigns values using `assignFunc`.\n     *\n     * @private\n     * @param {Array} props The property identifiers.\n     * @param {Array} values The property values.\n     * @param {Function} assignFunc The function to assign values.\n     * @returns {Object} Returns the new object.\n     */\n    function baseZipObject(props, values, assignFunc) {\n      var index = -1,\n          length = props.length,\n          valsLength = values.length,\n          result = {};\n\n      while (++index < length) {\n        var value = index < valsLength ? values[index] : undefined;\n        assignFunc(result, props[index], value);\n      }\n      return result;\n    }\n\n    /**\n     * Casts `value` to an empty array if it's not an array like object.\n     *\n     * @private\n     * @param {*} value The value to inspect.\n     * @returns {Array|Object} Returns the cast array-like object.\n     */\n    function castArrayLikeObject(value) {\n      return isArrayLikeObject(value) ? value : [];\n    }\n\n    /**\n     * Casts `value` to `identity` if it's not a function.\n     *\n     * @private\n     * @param {*} value The value to inspect.\n     * @returns {Function} Returns cast function.\n     */\n    function castFunction(value) {\n      return typeof value == 'function' ? value : identity;\n    }\n\n    /**\n     * Casts `value` to a path array if it's not one.\n     *\n     * @private\n     * @param {*} value The value to inspect.\n     * @param {Object} [object] The object to query keys on.\n     * @returns {Array} Returns the cast property path array.\n     */\n    function castPath(value, object) {\n      if (isArray(value)) {\n        return value;\n      }\n      return isKey(value, object) ? [value] : stringToPath(toString(value));\n    }\n\n    /**\n     * A `baseRest` alias which can be replaced with `identity` by module\n     * replacement plugins.\n     *\n     * @private\n     * @type {Function}\n     * @param {Function} func The function to apply a rest parameter to.\n     * @returns {Function} Returns the new function.\n     */\n    var castRest = baseRest;\n\n    /**\n     * Casts `array` to a slice if it's needed.\n     *\n     * @private\n     * @param {Array} array The array to inspect.\n     * @param {number} start The start position.\n     * @param {number} [end=array.length] The end position.\n     * @returns {Array} Returns the cast slice.\n     */\n    function castSlice(array, start, end) {\n      var length = array.length;\n      end = end === undefined ? length : end;\n      return (!start && end >= length) ? array : baseSlice(array, start, end);\n    }\n\n    /**\n     * A simple wrapper around the global [`clearTimeout`](https://mdn.io/clearTimeout).\n     *\n     * @private\n     * @param {number|Object} id The timer id or timeout object of the timer to clear.\n     */\n    var clearTimeout = ctxClearTimeout || function(id) {\n      return root.clearTimeout(id);\n    };\n\n    /**\n     * Creates a clone of  `buffer`.\n     *\n     * @private\n     * @param {Buffer} buffer The buffer to clone.\n     * @param {boolean} [isDeep] Specify a deep clone.\n     * @returns {Buffer} Returns the cloned buffer.\n     */\n    function cloneBuffer(buffer, isDeep) {\n      if (isDeep) {\n        return buffer.slice();\n      }\n      var length = buffer.length,\n          result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);\n\n      buffer.copy(result);\n      return result;\n    }\n\n    /**\n     * Creates a clone of `arrayBuffer`.\n     *\n     * @private\n     * @param {ArrayBuffer} arrayBuffer The array buffer to clone.\n     * @returns {ArrayBuffer} Returns the cloned array buffer.\n     */\n    function cloneArrayBuffer(arrayBuffer) {\n      var result = new arrayBuffer.constructor(arrayBuffer.byteLength);\n      new Uint8Array(result).set(new Uint8Array(arrayBuffer));\n      return result;\n    }\n\n    /**\n     * Creates a clone of `dataView`.\n     *\n     * @private\n     * @param {Object} dataView The data view to clone.\n     * @param {boolean} [isDeep] Specify a deep clone.\n     * @returns {Object} Returns the cloned data view.\n     */\n    function cloneDataView(dataView, isDeep) {\n      var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;\n      return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);\n    }\n\n    /**\n     * Creates a clone of `regexp`.\n     *\n     * @private\n     * @param {Object} regexp The regexp to clone.\n     * @returns {Object} Returns the cloned regexp.\n     */\n    function cloneRegExp(regexp) {\n      var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));\n      result.lastIndex = regexp.lastIndex;\n      return result;\n    }\n\n    /**\n     * Creates a clone of the `symbol` object.\n     *\n     * @private\n     * @param {Object} symbol The symbol object to clone.\n     * @returns {Object} Returns the cloned symbol object.\n     */\n    function cloneSymbol(symbol) {\n      return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};\n    }\n\n    /**\n     * Creates a clone of `typedArray`.\n     *\n     * @private\n     * @param {Object} typedArray The typed array to clone.\n     * @param {boolean} [isDeep] Specify a deep clone.\n     * @returns {Object} Returns the cloned typed array.\n     */\n    function cloneTypedArray(typedArray, isDeep) {\n      var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;\n      return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);\n    }\n\n    /**\n     * Compares values to sort them in ascending order.\n     *\n     * @private\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @returns {number} Returns the sort order indicator for `value`.\n     */\n    function compareAscending(value, other) {\n      if (value !== other) {\n        var valIsDefined = value !== undefined,\n            valIsNull = value === null,\n            valIsReflexive = value === value,\n            valIsSymbol = isSymbol(value);\n\n        var othIsDefined = other !== undefined,\n            othIsNull = other === null,\n            othIsReflexive = other === other,\n            othIsSymbol = isSymbol(other);\n\n        if ((!othIsNull && !othIsSymbol && !valIsSymbol && value > other) ||\n            (valIsSymbol && othIsDefined && othIsReflexive && !othIsNull && !othIsSymbol) ||\n            (valIsNull && othIsDefined && othIsReflexive) ||\n            (!valIsDefined && othIsReflexive) ||\n            !valIsReflexive) {\n          return 1;\n        }\n        if ((!valIsNull && !valIsSymbol && !othIsSymbol && value < other) ||\n            (othIsSymbol && valIsDefined && valIsReflexive && !valIsNull && !valIsSymbol) ||\n            (othIsNull && valIsDefined && valIsReflexive) ||\n            (!othIsDefined && valIsReflexive) ||\n            !othIsReflexive) {\n          return -1;\n        }\n      }\n      return 0;\n    }\n\n    /**\n     * Used by `_.orderBy` to compare multiple properties of a value to another\n     * and stable sort them.\n     *\n     * If `orders` is unspecified, all values are sorted in ascending order. Otherwise,\n     * specify an order of \"desc\" for descending or \"asc\" for ascending sort order\n     * of corresponding values.\n     *\n     * @private\n     * @param {Object} object The object to compare.\n     * @param {Object} other The other object to compare.\n     * @param {boolean[]|string[]} orders The order to sort by for each property.\n     * @returns {number} Returns the sort order indicator for `object`.\n     */\n    function compareMultiple(object, other, orders) {\n      var index = -1,\n          objCriteria = object.criteria,\n          othCriteria = other.criteria,\n          length = objCriteria.length,\n          ordersLength = orders.length;\n\n      while (++index < length) {\n        var result = compareAscending(objCriteria[index], othCriteria[index]);\n        if (result) {\n          if (index >= ordersLength) {\n            return result;\n          }\n          var order = orders[index];\n          return result * (order == 'desc' ? -1 : 1);\n        }\n      }\n      // Fixes an `Array#sort` bug in the JS engine embedded in Adobe applications\n      // that causes it, under certain circumstances, to provide the same value for\n      // `object` and `other`. See https://github.com/jashkenas/underscore/pull/1247\n      // for more details.\n      //\n      // This also ensures a stable sort in V8 and other engines.\n      // See https://bugs.chromium.org/p/v8/issues/detail?id=90 for more details.\n      return object.index - other.index;\n    }\n\n    /**\n     * Creates an array that is the composition of partially applied arguments,\n     * placeholders, and provided arguments into a single array of arguments.\n     *\n     * @private\n     * @param {Array} args The provided arguments.\n     * @param {Array} partials The arguments to prepend to those provided.\n     * @param {Array} holders The `partials` placeholder indexes.\n     * @params {boolean} [isCurried] Specify composing for a curried function.\n     * @returns {Array} Returns the new array of composed arguments.\n     */\n    function composeArgs(args, partials, holders, isCurried) {\n      var argsIndex = -1,\n          argsLength = args.length,\n          holdersLength = holders.length,\n          leftIndex = -1,\n          leftLength = partials.length,\n          rangeLength = nativeMax(argsLength - holdersLength, 0),\n          result = Array(leftLength + rangeLength),\n          isUncurried = !isCurried;\n\n      while (++leftIndex < leftLength) {\n        result[leftIndex] = partials[leftIndex];\n      }\n      while (++argsIndex < holdersLength) {\n        if (isUncurried || argsIndex < argsLength) {\n          result[holders[argsIndex]] = args[argsIndex];\n        }\n      }\n      while (rangeLength--) {\n        result[leftIndex++] = args[argsIndex++];\n      }\n      return result;\n    }\n\n    /**\n     * This function is like `composeArgs` except that the arguments composition\n     * is tailored for `_.partialRight`.\n     *\n     * @private\n     * @param {Array} args The provided arguments.\n     * @param {Array} partials The arguments to append to those provided.\n     * @param {Array} holders The `partials` placeholder indexes.\n     * @params {boolean} [isCurried] Specify composing for a curried function.\n     * @returns {Array} Returns the new array of composed arguments.\n     */\n    function composeArgsRight(args, partials, holders, isCurried) {\n      var argsIndex = -1,\n          argsLength = args.length,\n          holdersIndex = -1,\n          holdersLength = holders.length,\n          rightIndex = -1,\n          rightLength = partials.length,\n          rangeLength = nativeMax(argsLength - holdersLength, 0),\n          result = Array(rangeLength + rightLength),\n          isUncurried = !isCurried;\n\n      while (++argsIndex < rangeLength) {\n        result[argsIndex] = args[argsIndex];\n      }\n      var offset = argsIndex;\n      while (++rightIndex < rightLength) {\n        result[offset + rightIndex] = partials[rightIndex];\n      }\n      while (++holdersIndex < holdersLength) {\n        if (isUncurried || argsIndex < argsLength) {\n          result[offset + holders[holdersIndex]] = args[argsIndex++];\n        }\n      }\n      return result;\n    }\n\n    /**\n     * Copies the values of `source` to `array`.\n     *\n     * @private\n     * @param {Array} source The array to copy values from.\n     * @param {Array} [array=[]] The array to copy values to.\n     * @returns {Array} Returns `array`.\n     */\n    function copyArray(source, array) {\n      var index = -1,\n          length = source.length;\n\n      array || (array = Array(length));\n      while (++index < length) {\n        array[index] = source[index];\n      }\n      return array;\n    }\n\n    /**\n     * Copies properties of `source` to `object`.\n     *\n     * @private\n     * @param {Object} source The object to copy properties from.\n     * @param {Array} props The property identifiers to copy.\n     * @param {Object} [object={}] The object to copy properties to.\n     * @param {Function} [customizer] The function to customize copied values.\n     * @returns {Object} Returns `object`.\n     */\n    function copyObject(source, props, object, customizer) {\n      var isNew = !object;\n      object || (object = {});\n\n      var index = -1,\n          length = props.length;\n\n      while (++index < length) {\n        var key = props[index];\n\n        var newValue = customizer\n          ? customizer(object[key], source[key], key, object, source)\n          : undefined;\n\n        if (newValue === undefined) {\n          newValue = source[key];\n        }\n        if (isNew) {\n          baseAssignValue(object, key, newValue);\n        } else {\n          assignValue(object, key, newValue);\n        }\n      }\n      return object;\n    }\n\n    /**\n     * Copies own symbols of `source` to `object`.\n     *\n     * @private\n     * @param {Object} source The object to copy symbols from.\n     * @param {Object} [object={}] The object to copy symbols to.\n     * @returns {Object} Returns `object`.\n     */\n    function copySymbols(source, object) {\n      return copyObject(source, getSymbols(source), object);\n    }\n\n    /**\n     * Copies own and inherited symbols of `source` to `object`.\n     *\n     * @private\n     * @param {Object} source The object to copy symbols from.\n     * @param {Object} [object={}] The object to copy symbols to.\n     * @returns {Object} Returns `object`.\n     */\n    function copySymbolsIn(source, object) {\n      return copyObject(source, getSymbolsIn(source), object);\n    }\n\n    /**\n     * Creates a function like `_.groupBy`.\n     *\n     * @private\n     * @param {Function} setter The function to set accumulator values.\n     * @param {Function} [initializer] The accumulator object initializer.\n     * @returns {Function} Returns the new aggregator function.\n     */\n    function createAggregator(setter, initializer) {\n      return function(collection, iteratee) {\n        var func = isArray(collection) ? arrayAggregator : baseAggregator,\n            accumulator = initializer ? initializer() : {};\n\n        return func(collection, setter, getIteratee(iteratee, 2), accumulator);\n      };\n    }\n\n    /**\n     * Creates a function like `_.assign`.\n     *\n     * @private\n     * @param {Function} assigner The function to assign values.\n     * @returns {Function} Returns the new assigner function.\n     */\n    function createAssigner(assigner) {\n      return baseRest(function(object, sources) {\n        var index = -1,\n            length = sources.length,\n            customizer = length > 1 ? sources[length - 1] : undefined,\n            guard = length > 2 ? sources[2] : undefined;\n\n        customizer = (assigner.length > 3 && typeof customizer == 'function')\n          ? (length--, customizer)\n          : undefined;\n\n        if (guard && isIterateeCall(sources[0], sources[1], guard)) {\n          customizer = length < 3 ? undefined : customizer;\n          length = 1;\n        }\n        object = Object(object);\n        while (++index < length) {\n          var source = sources[index];\n          if (source) {\n            assigner(object, source, index, customizer);\n          }\n        }\n        return object;\n      });\n    }\n\n    /**\n     * Creates a `baseEach` or `baseEachRight` function.\n     *\n     * @private\n     * @param {Function} eachFunc The function to iterate over a collection.\n     * @param {boolean} [fromRight] Specify iterating from right to left.\n     * @returns {Function} Returns the new base function.\n     */\n    function createBaseEach(eachFunc, fromRight) {\n      return function(collection, iteratee) {\n        if (collection == null) {\n          return collection;\n        }\n        if (!isArrayLike(collection)) {\n          return eachFunc(collection, iteratee);\n        }\n        var length = collection.length,\n            index = fromRight ? length : -1,\n            iterable = Object(collection);\n\n        while ((fromRight ? index-- : ++index < length)) {\n          if (iteratee(iterable[index], index, iterable) === false) {\n            break;\n          }\n        }\n        return collection;\n      };\n    }\n\n    /**\n     * Creates a base function for methods like `_.forIn` and `_.forOwn`.\n     *\n     * @private\n     * @param {boolean} [fromRight] Specify iterating from right to left.\n     * @returns {Function} Returns the new base function.\n     */\n    function createBaseFor(fromRight) {\n      return function(object, iteratee, keysFunc) {\n        var index = -1,\n            iterable = Object(object),\n            props = keysFunc(object),\n            length = props.length;\n\n        while (length--) {\n          var key = props[fromRight ? length : ++index];\n          if (iteratee(iterable[key], key, iterable) === false) {\n            break;\n          }\n        }\n        return object;\n      };\n    }\n\n    /**\n     * Creates a function that wraps `func` to invoke it with the optional `this`\n     * binding of `thisArg`.\n     *\n     * @private\n     * @param {Function} func The function to wrap.\n     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n     * @param {*} [thisArg] The `this` binding of `func`.\n     * @returns {Function} Returns the new wrapped function.\n     */\n    function createBind(func, bitmask, thisArg) {\n      var isBind = bitmask & WRAP_BIND_FLAG,\n          Ctor = createCtor(func);\n\n      function wrapper() {\n        var fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;\n        return fn.apply(isBind ? thisArg : this, arguments);\n      }\n      return wrapper;\n    }\n\n    /**\n     * Creates a function like `_.lowerFirst`.\n     *\n     * @private\n     * @param {string} methodName The name of the `String` case method to use.\n     * @returns {Function} Returns the new case function.\n     */\n    function createCaseFirst(methodName) {\n      return function(string) {\n        string = toString(string);\n\n        var strSymbols = hasUnicode(string)\n          ? stringToArray(string)\n          : undefined;\n\n        var chr = strSymbols\n          ? strSymbols[0]\n          : string.charAt(0);\n\n        var trailing = strSymbols\n          ? castSlice(strSymbols, 1).join('')\n          : string.slice(1);\n\n        return chr[methodName]() + trailing;\n      };\n    }\n\n    /**\n     * Creates a function like `_.camelCase`.\n     *\n     * @private\n     * @param {Function} callback The function to combine each word.\n     * @returns {Function} Returns the new compounder function.\n     */\n    function createCompounder(callback) {\n      return function(string) {\n        return arrayReduce(words(deburr(string).replace(reApos, '')), callback, '');\n      };\n    }\n\n    /**\n     * Creates a function that produces an instance of `Ctor` regardless of\n     * whether it was invoked as part of a `new` expression or by `call` or `apply`.\n     *\n     * @private\n     * @param {Function} Ctor The constructor to wrap.\n     * @returns {Function} Returns the new wrapped function.\n     */\n    function createCtor(Ctor) {\n      return function() {\n        // Use a `switch` statement to work with class constructors. See\n        // http://ecma-international.org/ecma-262/7.0/#sec-ecmascript-function-objects-call-thisargument-argumentslist\n        // for more details.\n        var args = arguments;\n        switch (args.length) {\n          case 0: return new Ctor;\n          case 1: return new Ctor(args[0]);\n          case 2: return new Ctor(args[0], args[1]);\n          case 3: return new Ctor(args[0], args[1], args[2]);\n          case 4: return new Ctor(args[0], args[1], args[2], args[3]);\n          case 5: return new Ctor(args[0], args[1], args[2], args[3], args[4]);\n          case 6: return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5]);\n          case 7: return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5], args[6]);\n        }\n        var thisBinding = baseCreate(Ctor.prototype),\n            result = Ctor.apply(thisBinding, args);\n\n        // Mimic the constructor's `return` behavior.\n        // See https://es5.github.io/#x13.2.2 for more details.\n        return isObject(result) ? result : thisBinding;\n      };\n    }\n\n    /**\n     * Creates a function that wraps `func` to enable currying.\n     *\n     * @private\n     * @param {Function} func The function to wrap.\n     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n     * @param {number} arity The arity of `func`.\n     * @returns {Function} Returns the new wrapped function.\n     */\n    function createCurry(func, bitmask, arity) {\n      var Ctor = createCtor(func);\n\n      function wrapper() {\n        var length = arguments.length,\n            args = Array(length),\n            index = length,\n            placeholder = getHolder(wrapper);\n\n        while (index--) {\n          args[index] = arguments[index];\n        }\n        var holders = (length < 3 && args[0] !== placeholder && args[length - 1] !== placeholder)\n          ? []\n          : replaceHolders(args, placeholder);\n\n        length -= holders.length;\n        if (length < arity) {\n          return createRecurry(\n            func, bitmask, createHybrid, wrapper.placeholder, undefined,\n            args, holders, undefined, undefined, arity - length);\n        }\n        var fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;\n        return apply(fn, this, args);\n      }\n      return wrapper;\n    }\n\n    /**\n     * Creates a `_.find` or `_.findLast` function.\n     *\n     * @private\n     * @param {Function} findIndexFunc The function to find the collection index.\n     * @returns {Function} Returns the new find function.\n     */\n    function createFind(findIndexFunc) {\n      return function(collection, predicate, fromIndex) {\n        var iterable = Object(collection);\n        if (!isArrayLike(collection)) {\n          var iteratee = getIteratee(predicate, 3);\n          collection = keys(collection);\n          predicate = function(key) { return iteratee(iterable[key], key, iterable); };\n        }\n        var index = findIndexFunc(collection, predicate, fromIndex);\n        return index > -1 ? iterable[iteratee ? collection[index] : index] : undefined;\n      };\n    }\n\n    /**\n     * Creates a `_.flow` or `_.flowRight` function.\n     *\n     * @private\n     * @param {boolean} [fromRight] Specify iterating from right to left.\n     * @returns {Function} Returns the new flow function.\n     */\n    function createFlow(fromRight) {\n      return flatRest(function(funcs) {\n        var length = funcs.length,\n            index = length,\n            prereq = LodashWrapper.prototype.thru;\n\n        if (fromRight) {\n          funcs.reverse();\n        }\n        while (index--) {\n          var func = funcs[index];\n          if (typeof func != 'function') {\n            throw new TypeError(FUNC_ERROR_TEXT);\n          }\n          if (prereq && !wrapper && getFuncName(func) == 'wrapper') {\n            var wrapper = new LodashWrapper([], true);\n          }\n        }\n        index = wrapper ? index : length;\n        while (++index < length) {\n          func = funcs[index];\n\n          var funcName = getFuncName(func),\n              data = funcName == 'wrapper' ? getData(func) : undefined;\n\n          if (data && isLaziable(data[0]) &&\n                data[1] == (WRAP_ARY_FLAG | WRAP_CURRY_FLAG | WRAP_PARTIAL_FLAG | WRAP_REARG_FLAG) &&\n                !data[4].length && data[9] == 1\n              ) {\n            wrapper = wrapper[getFuncName(data[0])].apply(wrapper, data[3]);\n          } else {\n            wrapper = (func.length == 1 && isLaziable(func))\n              ? wrapper[funcName]()\n              : wrapper.thru(func);\n          }\n        }\n        return function() {\n          var args = arguments,\n              value = args[0];\n\n          if (wrapper && args.length == 1 && isArray(value)) {\n            return wrapper.plant(value).value();\n          }\n          var index = 0,\n              result = length ? funcs[index].apply(this, args) : value;\n\n          while (++index < length) {\n            result = funcs[index].call(this, result);\n          }\n          return result;\n        };\n      });\n    }\n\n    /**\n     * Creates a function that wraps `func` to invoke it with optional `this`\n     * binding of `thisArg`, partial application, and currying.\n     *\n     * @private\n     * @param {Function|string} func The function or method name to wrap.\n     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n     * @param {*} [thisArg] The `this` binding of `func`.\n     * @param {Array} [partials] The arguments to prepend to those provided to\n     *  the new function.\n     * @param {Array} [holders] The `partials` placeholder indexes.\n     * @param {Array} [partialsRight] The arguments to append to those provided\n     *  to the new function.\n     * @param {Array} [holdersRight] The `partialsRight` placeholder indexes.\n     * @param {Array} [argPos] The argument positions of the new function.\n     * @param {number} [ary] The arity cap of `func`.\n     * @param {number} [arity] The arity of `func`.\n     * @returns {Function} Returns the new wrapped function.\n     */\n    function createHybrid(func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, argPos, ary, arity) {\n      var isAry = bitmask & WRAP_ARY_FLAG,\n          isBind = bitmask & WRAP_BIND_FLAG,\n          isBindKey = bitmask & WRAP_BIND_KEY_FLAG,\n          isCurried = bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG),\n          isFlip = bitmask & WRAP_FLIP_FLAG,\n          Ctor = isBindKey ? undefined : createCtor(func);\n\n      function wrapper() {\n        var length = arguments.length,\n            args = Array(length),\n            index = length;\n\n        while (index--) {\n          args[index] = arguments[index];\n        }\n        if (isCurried) {\n          var placeholder = getHolder(wrapper),\n              holdersCount = countHolders(args, placeholder);\n        }\n        if (partials) {\n          args = composeArgs(args, partials, holders, isCurried);\n        }\n        if (partialsRight) {\n          args = composeArgsRight(args, partialsRight, holdersRight, isCurried);\n        }\n        length -= holdersCount;\n        if (isCurried && length < arity) {\n          var newHolders = replaceHolders(args, placeholder);\n          return createRecurry(\n            func, bitmask, createHybrid, wrapper.placeholder, thisArg,\n            args, newHolders, argPos, ary, arity - length\n          );\n        }\n        var thisBinding = isBind ? thisArg : this,\n            fn = isBindKey ? thisBinding[func] : func;\n\n        length = args.length;\n        if (argPos) {\n          args = reorder(args, argPos);\n        } else if (isFlip && length > 1) {\n          args.reverse();\n        }\n        if (isAry && ary < length) {\n          args.length = ary;\n        }\n        if (this && this !== root && this instanceof wrapper) {\n          fn = Ctor || createCtor(fn);\n        }\n        return fn.apply(thisBinding, args);\n      }\n      return wrapper;\n    }\n\n    /**\n     * Creates a function like `_.invertBy`.\n     *\n     * @private\n     * @param {Function} setter The function to set accumulator values.\n     * @param {Function} toIteratee The function to resolve iteratees.\n     * @returns {Function} Returns the new inverter function.\n     */\n    function createInverter(setter, toIteratee) {\n      return function(object, iteratee) {\n        return baseInverter(object, setter, toIteratee(iteratee), {});\n      };\n    }\n\n    /**\n     * Creates a function that performs a mathematical operation on two values.\n     *\n     * @private\n     * @param {Function} operator The function to perform the operation.\n     * @param {number} [defaultValue] The value used for `undefined` arguments.\n     * @returns {Function} Returns the new mathematical operation function.\n     */\n    function createMathOperation(operator, defaultValue) {\n      return function(value, other) {\n        var result;\n        if (value === undefined && other === undefined) {\n          return defaultValue;\n        }\n        if (value !== undefined) {\n          result = value;\n        }\n        if (other !== undefined) {\n          if (result === undefined) {\n            return other;\n          }\n          if (typeof value == 'string' || typeof other == 'string') {\n            value = baseToString(value);\n            other = baseToString(other);\n          } else {\n            value = baseToNumber(value);\n            other = baseToNumber(other);\n          }\n          result = operator(value, other);\n        }\n        return result;\n      };\n    }\n\n    /**\n     * Creates a function like `_.over`.\n     *\n     * @private\n     * @param {Function} arrayFunc The function to iterate over iteratees.\n     * @returns {Function} Returns the new over function.\n     */\n    function createOver(arrayFunc) {\n      return flatRest(function(iteratees) {\n        iteratees = arrayMap(iteratees, baseUnary(getIteratee()));\n        return baseRest(function(args) {\n          var thisArg = this;\n          return arrayFunc(iteratees, function(iteratee) {\n            return apply(iteratee, thisArg, args);\n          });\n        });\n      });\n    }\n\n    /**\n     * Creates the padding for `string` based on `length`. The `chars` string\n     * is truncated if the number of characters exceeds `length`.\n     *\n     * @private\n     * @param {number} length The padding length.\n     * @param {string} [chars=' '] The string used as padding.\n     * @returns {string} Returns the padding for `string`.\n     */\n    function createPadding(length, chars) {\n      chars = chars === undefined ? ' ' : baseToString(chars);\n\n      var charsLength = chars.length;\n      if (charsLength < 2) {\n        return charsLength ? baseRepeat(chars, length) : chars;\n      }\n      var result = baseRepeat(chars, nativeCeil(length / stringSize(chars)));\n      return hasUnicode(chars)\n        ? castSlice(stringToArray(result), 0, length).join('')\n        : result.slice(0, length);\n    }\n\n    /**\n     * Creates a function that wraps `func` to invoke it with the `this` binding\n     * of `thisArg` and `partials` prepended to the arguments it receives.\n     *\n     * @private\n     * @param {Function} func The function to wrap.\n     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n     * @param {*} thisArg The `this` binding of `func`.\n     * @param {Array} partials The arguments to prepend to those provided to\n     *  the new function.\n     * @returns {Function} Returns the new wrapped function.\n     */\n    function createPartial(func, bitmask, thisArg, partials) {\n      var isBind = bitmask & WRAP_BIND_FLAG,\n          Ctor = createCtor(func);\n\n      function wrapper() {\n        var argsIndex = -1,\n            argsLength = arguments.length,\n            leftIndex = -1,\n            leftLength = partials.length,\n            args = Array(leftLength + argsLength),\n            fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;\n\n        while (++leftIndex < leftLength) {\n          args[leftIndex] = partials[leftIndex];\n        }\n        while (argsLength--) {\n          args[leftIndex++] = arguments[++argsIndex];\n        }\n        return apply(fn, isBind ? thisArg : this, args);\n      }\n      return wrapper;\n    }\n\n    /**\n     * Creates a `_.range` or `_.rangeRight` function.\n     *\n     * @private\n     * @param {boolean} [fromRight] Specify iterating from right to left.\n     * @returns {Function} Returns the new range function.\n     */\n    function createRange(fromRight) {\n      return function(start, end, step) {\n        if (step && typeof step != 'number' && isIterateeCall(start, end, step)) {\n          end = step = undefined;\n        }\n        // Ensure the sign of `-0` is preserved.\n        start = toFinite(start);\n        if (end === undefined) {\n          end = start;\n          start = 0;\n        } else {\n          end = toFinite(end);\n        }\n        step = step === undefined ? (start < end ? 1 : -1) : toFinite(step);\n        return baseRange(start, end, step, fromRight);\n      };\n    }\n\n    /**\n     * Creates a function that performs a relational operation on two values.\n     *\n     * @private\n     * @param {Function} operator The function to perform the operation.\n     * @returns {Function} Returns the new relational operation function.\n     */\n    function createRelationalOperation(operator) {\n      return function(value, other) {\n        if (!(typeof value == 'string' && typeof other == 'string')) {\n          value = toNumber(value);\n          other = toNumber(other);\n        }\n        return operator(value, other);\n      };\n    }\n\n    /**\n     * Creates a function that wraps `func` to continue currying.\n     *\n     * @private\n     * @param {Function} func The function to wrap.\n     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n     * @param {Function} wrapFunc The function to create the `func` wrapper.\n     * @param {*} placeholder The placeholder value.\n     * @param {*} [thisArg] The `this` binding of `func`.\n     * @param {Array} [partials] The arguments to prepend to those provided to\n     *  the new function.\n     * @param {Array} [holders] The `partials` placeholder indexes.\n     * @param {Array} [argPos] The argument positions of the new function.\n     * @param {number} [ary] The arity cap of `func`.\n     * @param {number} [arity] The arity of `func`.\n     * @returns {Function} Returns the new wrapped function.\n     */\n    function createRecurry(func, bitmask, wrapFunc, placeholder, thisArg, partials, holders, argPos, ary, arity) {\n      var isCurry = bitmask & WRAP_CURRY_FLAG,\n          newHolders = isCurry ? holders : undefined,\n          newHoldersRight = isCurry ? undefined : holders,\n          newPartials = isCurry ? partials : undefined,\n          newPartialsRight = isCurry ? undefined : partials;\n\n      bitmask |= (isCurry ? WRAP_PARTIAL_FLAG : WRAP_PARTIAL_RIGHT_FLAG);\n      bitmask &= ~(isCurry ? WRAP_PARTIAL_RIGHT_FLAG : WRAP_PARTIAL_FLAG);\n\n      if (!(bitmask & WRAP_CURRY_BOUND_FLAG)) {\n        bitmask &= ~(WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG);\n      }\n      var newData = [\n        func, bitmask, thisArg, newPartials, newHolders, newPartialsRight,\n        newHoldersRight, argPos, ary, arity\n      ];\n\n      var result = wrapFunc.apply(undefined, newData);\n      if (isLaziable(func)) {\n        setData(result, newData);\n      }\n      result.placeholder = placeholder;\n      return setWrapToString(result, func, bitmask);\n    }\n\n    /**\n     * Creates a function like `_.round`.\n     *\n     * @private\n     * @param {string} methodName The name of the `Math` method to use when rounding.\n     * @returns {Function} Returns the new round function.\n     */\n    function createRound(methodName) {\n      var func = Math[methodName];\n      return function(number, precision) {\n        number = toNumber(number);\n        precision = precision == null ? 0 : nativeMin(toInteger(precision), 292);\n        if (precision && nativeIsFinite(number)) {\n          // Shift with exponential notation to avoid floating-point issues.\n          // See [MDN](https://mdn.io/round#Examples) for more details.\n          var pair = (toString(number) + 'e').split('e'),\n              value = func(pair[0] + 'e' + (+pair[1] + precision));\n\n          pair = (toString(value) + 'e').split('e');\n          return +(pair[0] + 'e' + (+pair[1] - precision));\n        }\n        return func(number);\n      };\n    }\n\n    /**\n     * Creates a set object of `values`.\n     *\n     * @private\n     * @param {Array} values The values to add to the set.\n     * @returns {Object} Returns the new set.\n     */\n    var createSet = !(Set && (1 / setToArray(new Set([,-0]))[1]) == INFINITY) ? noop : function(values) {\n      return new Set(values);\n    };\n\n    /**\n     * Creates a `_.toPairs` or `_.toPairsIn` function.\n     *\n     * @private\n     * @param {Function} keysFunc The function to get the keys of a given object.\n     * @returns {Function} Returns the new pairs function.\n     */\n    function createToPairs(keysFunc) {\n      return function(object) {\n        var tag = getTag(object);\n        if (tag == mapTag) {\n          return mapToArray(object);\n        }\n        if (tag == setTag) {\n          return setToPairs(object);\n        }\n        return baseToPairs(object, keysFunc(object));\n      };\n    }\n\n    /**\n     * Creates a function that either curries or invokes `func` with optional\n     * `this` binding and partially applied arguments.\n     *\n     * @private\n     * @param {Function|string} func The function or method name to wrap.\n     * @param {number} bitmask The bitmask flags.\n     *    1 - `_.bind`\n     *    2 - `_.bindKey`\n     *    4 - `_.curry` or `_.curryRight` of a bound function\n     *    8 - `_.curry`\n     *   16 - `_.curryRight`\n     *   32 - `_.partial`\n     *   64 - `_.partialRight`\n     *  128 - `_.rearg`\n     *  256 - `_.ary`\n     *  512 - `_.flip`\n     * @param {*} [thisArg] The `this` binding of `func`.\n     * @param {Array} [partials] The arguments to be partially applied.\n     * @param {Array} [holders] The `partials` placeholder indexes.\n     * @param {Array} [argPos] The argument positions of the new function.\n     * @param {number} [ary] The arity cap of `func`.\n     * @param {number} [arity] The arity of `func`.\n     * @returns {Function} Returns the new wrapped function.\n     */\n    function createWrap(func, bitmask, thisArg, partials, holders, argPos, ary, arity) {\n      var isBindKey = bitmask & WRAP_BIND_KEY_FLAG;\n      if (!isBindKey && typeof func != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      var length = partials ? partials.length : 0;\n      if (!length) {\n        bitmask &= ~(WRAP_PARTIAL_FLAG | WRAP_PARTIAL_RIGHT_FLAG);\n        partials = holders = undefined;\n      }\n      ary = ary === undefined ? ary : nativeMax(toInteger(ary), 0);\n      arity = arity === undefined ? arity : toInteger(arity);\n      length -= holders ? holders.length : 0;\n\n      if (bitmask & WRAP_PARTIAL_RIGHT_FLAG) {\n        var partialsRight = partials,\n            holdersRight = holders;\n\n        partials = holders = undefined;\n      }\n      var data = isBindKey ? undefined : getData(func);\n\n      var newData = [\n        func, bitmask, thisArg, partials, holders, partialsRight, holdersRight,\n        argPos, ary, arity\n      ];\n\n      if (data) {\n        mergeData(newData, data);\n      }\n      func = newData[0];\n      bitmask = newData[1];\n      thisArg = newData[2];\n      partials = newData[3];\n      holders = newData[4];\n      arity = newData[9] = newData[9] === undefined\n        ? (isBindKey ? 0 : func.length)\n        : nativeMax(newData[9] - length, 0);\n\n      if (!arity && bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG)) {\n        bitmask &= ~(WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG);\n      }\n      if (!bitmask || bitmask == WRAP_BIND_FLAG) {\n        var result = createBind(func, bitmask, thisArg);\n      } else if (bitmask == WRAP_CURRY_FLAG || bitmask == WRAP_CURRY_RIGHT_FLAG) {\n        result = createCurry(func, bitmask, arity);\n      } else if ((bitmask == WRAP_PARTIAL_FLAG || bitmask == (WRAP_BIND_FLAG | WRAP_PARTIAL_FLAG)) && !holders.length) {\n        result = createPartial(func, bitmask, thisArg, partials);\n      } else {\n        result = createHybrid.apply(undefined, newData);\n      }\n      var setter = data ? baseSetData : setData;\n      return setWrapToString(setter(result, newData), func, bitmask);\n    }\n\n    /**\n     * Used by `_.defaults` to customize its `_.assignIn` use to assign properties\n     * of source objects to the destination object for all destination properties\n     * that resolve to `undefined`.\n     *\n     * @private\n     * @param {*} objValue The destination value.\n     * @param {*} srcValue The source value.\n     * @param {string} key The key of the property to assign.\n     * @param {Object} object The parent object of `objValue`.\n     * @returns {*} Returns the value to assign.\n     */\n    function customDefaultsAssignIn(objValue, srcValue, key, object) {\n      if (objValue === undefined ||\n          (eq(objValue, objectProto[key]) && !hasOwnProperty.call(object, key))) {\n        return srcValue;\n      }\n      return objValue;\n    }\n\n    /**\n     * Used by `_.defaultsDeep` to customize its `_.merge` use to merge source\n     * objects into destination objects that are passed thru.\n     *\n     * @private\n     * @param {*} objValue The destination value.\n     * @param {*} srcValue The source value.\n     * @param {string} key The key of the property to merge.\n     * @param {Object} object The parent object of `objValue`.\n     * @param {Object} source The parent object of `srcValue`.\n     * @param {Object} [stack] Tracks traversed source values and their merged\n     *  counterparts.\n     * @returns {*} Returns the value to assign.\n     */\n    function customDefaultsMerge(objValue, srcValue, key, object, source, stack) {\n      if (isObject(objValue) && isObject(srcValue)) {\n        // Recursively merge objects and arrays (susceptible to call stack limits).\n        stack.set(srcValue, objValue);\n        baseMerge(objValue, srcValue, undefined, customDefaultsMerge, stack);\n        stack['delete'](srcValue);\n      }\n      return objValue;\n    }\n\n    /**\n     * Used by `_.omit` to customize its `_.cloneDeep` use to only clone plain\n     * objects.\n     *\n     * @private\n     * @param {*} value The value to inspect.\n     * @param {string} key The key of the property to inspect.\n     * @returns {*} Returns the uncloned value or `undefined` to defer cloning to `_.cloneDeep`.\n     */\n    function customOmitClone(value) {\n      return isPlainObject(value) ? undefined : value;\n    }\n\n    /**\n     * A specialized version of `baseIsEqualDeep` for arrays with support for\n     * partial deep comparisons.\n     *\n     * @private\n     * @param {Array} array The array to compare.\n     * @param {Array} other The other array to compare.\n     * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n     * @param {Function} customizer The function to customize comparisons.\n     * @param {Function} equalFunc The function to determine equivalents of values.\n     * @param {Object} stack Tracks traversed `array` and `other` objects.\n     * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.\n     */\n    function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {\n      var isPartial = bitmask & COMPARE_PARTIAL_FLAG,\n          arrLength = array.length,\n          othLength = other.length;\n\n      if (arrLength != othLength && !(isPartial && othLength > arrLength)) {\n        return false;\n      }\n      // Check that cyclic values are equal.\n      var arrStacked = stack.get(array);\n      var othStacked = stack.get(other);\n      if (arrStacked && othStacked) {\n        return arrStacked == other && othStacked == array;\n      }\n      var index = -1,\n          result = true,\n          seen = (bitmask & COMPARE_UNORDERED_FLAG) ? new SetCache : undefined;\n\n      stack.set(array, other);\n      stack.set(other, array);\n\n      // Ignore non-index properties.\n      while (++index < arrLength) {\n        var arrValue = array[index],\n            othValue = other[index];\n\n        if (customizer) {\n          var compared = isPartial\n            ? customizer(othValue, arrValue, index, other, array, stack)\n            : customizer(arrValue, othValue, index, array, other, stack);\n        }\n        if (compared !== undefined) {\n          if (compared) {\n            continue;\n          }\n          result = false;\n          break;\n        }\n        // Recursively compare arrays (susceptible to call stack limits).\n        if (seen) {\n          if (!arraySome(other, function(othValue, othIndex) {\n                if (!cacheHas(seen, othIndex) &&\n                    (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {\n                  return seen.push(othIndex);\n                }\n              })) {\n            result = false;\n            break;\n          }\n        } else if (!(\n              arrValue === othValue ||\n                equalFunc(arrValue, othValue, bitmask, customizer, stack)\n            )) {\n          result = false;\n          break;\n        }\n      }\n      stack['delete'](array);\n      stack['delete'](other);\n      return result;\n    }\n\n    /**\n     * A specialized version of `baseIsEqualDeep` for comparing objects of\n     * the same `toStringTag`.\n     *\n     * **Note:** This function only supports comparing values with tags of\n     * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.\n     *\n     * @private\n     * @param {Object} object The object to compare.\n     * @param {Object} other The other object to compare.\n     * @param {string} tag The `toStringTag` of the objects to compare.\n     * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n     * @param {Function} customizer The function to customize comparisons.\n     * @param {Function} equalFunc The function to determine equivalents of values.\n     * @param {Object} stack Tracks traversed `object` and `other` objects.\n     * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n     */\n    function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {\n      switch (tag) {\n        case dataViewTag:\n          if ((object.byteLength != other.byteLength) ||\n              (object.byteOffset != other.byteOffset)) {\n            return false;\n          }\n          object = object.buffer;\n          other = other.buffer;\n\n        case arrayBufferTag:\n          if ((object.byteLength != other.byteLength) ||\n              !equalFunc(new Uint8Array(object), new Uint8Array(other))) {\n            return false;\n          }\n          return true;\n\n        case boolTag:\n        case dateTag:\n        case numberTag:\n          // Coerce booleans to `1` or `0` and dates to milliseconds.\n          // Invalid dates are coerced to `NaN`.\n          return eq(+object, +other);\n\n        case errorTag:\n          return object.name == other.name && object.message == other.message;\n\n        case regexpTag:\n        case stringTag:\n          // Coerce regexes to strings and treat strings, primitives and objects,\n          // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring\n          // for more details.\n          return object == (other + '');\n\n        case mapTag:\n          var convert = mapToArray;\n\n        case setTag:\n          var isPartial = bitmask & COMPARE_PARTIAL_FLAG;\n          convert || (convert = setToArray);\n\n          if (object.size != other.size && !isPartial) {\n            return false;\n          }\n          // Assume cyclic values are equal.\n          var stacked = stack.get(object);\n          if (stacked) {\n            return stacked == other;\n          }\n          bitmask |= COMPARE_UNORDERED_FLAG;\n\n          // Recursively compare objects (susceptible to call stack limits).\n          stack.set(object, other);\n          var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);\n          stack['delete'](object);\n          return result;\n\n        case symbolTag:\n          if (symbolValueOf) {\n            return symbolValueOf.call(object) == symbolValueOf.call(other);\n          }\n      }\n      return false;\n    }\n\n    /**\n     * A specialized version of `baseIsEqualDeep` for objects with support for\n     * partial deep comparisons.\n     *\n     * @private\n     * @param {Object} object The object to compare.\n     * @param {Object} other The other object to compare.\n     * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n     * @param {Function} customizer The function to customize comparisons.\n     * @param {Function} equalFunc The function to determine equivalents of values.\n     * @param {Object} stack Tracks traversed `object` and `other` objects.\n     * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n     */\n    function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {\n      var isPartial = bitmask & COMPARE_PARTIAL_FLAG,\n          objProps = getAllKeys(object),\n          objLength = objProps.length,\n          othProps = getAllKeys(other),\n          othLength = othProps.length;\n\n      if (objLength != othLength && !isPartial) {\n        return false;\n      }\n      var index = objLength;\n      while (index--) {\n        var key = objProps[index];\n        if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {\n          return false;\n        }\n      }\n      // Check that cyclic values are equal.\n      var objStacked = stack.get(object);\n      var othStacked = stack.get(other);\n      if (objStacked && othStacked) {\n        return objStacked == other && othStacked == object;\n      }\n      var result = true;\n      stack.set(object, other);\n      stack.set(other, object);\n\n      var skipCtor = isPartial;\n      while (++index < objLength) {\n        key = objProps[index];\n        var objValue = object[key],\n            othValue = other[key];\n\n        if (customizer) {\n          var compared = isPartial\n            ? customizer(othValue, objValue, key, other, object, stack)\n            : customizer(objValue, othValue, key, object, other, stack);\n        }\n        // Recursively compare objects (susceptible to call stack limits).\n        if (!(compared === undefined\n              ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack))\n              : compared\n            )) {\n          result = false;\n          break;\n        }\n        skipCtor || (skipCtor = key == 'constructor');\n      }\n      if (result && !skipCtor) {\n        var objCtor = object.constructor,\n            othCtor = other.constructor;\n\n        // Non `Object` object instances with different constructors are not equal.\n        if (objCtor != othCtor &&\n            ('constructor' in object && 'constructor' in other) &&\n            !(typeof objCtor == 'function' && objCtor instanceof objCtor &&\n              typeof othCtor == 'function' && othCtor instanceof othCtor)) {\n          result = false;\n        }\n      }\n      stack['delete'](object);\n      stack['delete'](other);\n      return result;\n    }\n\n    /**\n     * A specialized version of `baseRest` which flattens the rest array.\n     *\n     * @private\n     * @param {Function} func The function to apply a rest parameter to.\n     * @returns {Function} Returns the new function.\n     */\n    function flatRest(func) {\n      return setToString(overRest(func, undefined, flatten), func + '');\n    }\n\n    /**\n     * Creates an array of own enumerable property names and symbols of `object`.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the array of property names and symbols.\n     */\n    function getAllKeys(object) {\n      return baseGetAllKeys(object, keys, getSymbols);\n    }\n\n    /**\n     * Creates an array of own and inherited enumerable property names and\n     * symbols of `object`.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the array of property names and symbols.\n     */\n    function getAllKeysIn(object) {\n      return baseGetAllKeys(object, keysIn, getSymbolsIn);\n    }\n\n    /**\n     * Gets metadata for `func`.\n     *\n     * @private\n     * @param {Function} func The function to query.\n     * @returns {*} Returns the metadata for `func`.\n     */\n    var getData = !metaMap ? noop : function(func) {\n      return metaMap.get(func);\n    };\n\n    /**\n     * Gets the name of `func`.\n     *\n     * @private\n     * @param {Function} func The function to query.\n     * @returns {string} Returns the function name.\n     */\n    function getFuncName(func) {\n      var result = (func.name + ''),\n          array = realNames[result],\n          length = hasOwnProperty.call(realNames, result) ? array.length : 0;\n\n      while (length--) {\n        var data = array[length],\n            otherFunc = data.func;\n        if (otherFunc == null || otherFunc == func) {\n          return data.name;\n        }\n      }\n      return result;\n    }\n\n    /**\n     * Gets the argument placeholder value for `func`.\n     *\n     * @private\n     * @param {Function} func The function to inspect.\n     * @returns {*} Returns the placeholder value.\n     */\n    function getHolder(func) {\n      var object = hasOwnProperty.call(lodash, 'placeholder') ? lodash : func;\n      return object.placeholder;\n    }\n\n    /**\n     * Gets the appropriate \"iteratee\" function. If `_.iteratee` is customized,\n     * this function returns the custom method, otherwise it returns `baseIteratee`.\n     * If arguments are provided, the chosen function is invoked with them and\n     * its result is returned.\n     *\n     * @private\n     * @param {*} [value] The value to convert to an iteratee.\n     * @param {number} [arity] The arity of the created iteratee.\n     * @returns {Function} Returns the chosen function or its result.\n     */\n    function getIteratee() {\n      var result = lodash.iteratee || iteratee;\n      result = result === iteratee ? baseIteratee : result;\n      return arguments.length ? result(arguments[0], arguments[1]) : result;\n    }\n\n    /**\n     * Gets the data for `map`.\n     *\n     * @private\n     * @param {Object} map The map to query.\n     * @param {string} key The reference key.\n     * @returns {*} Returns the map data.\n     */\n    function getMapData(map, key) {\n      var data = map.__data__;\n      return isKeyable(key)\n        ? data[typeof key == 'string' ? 'string' : 'hash']\n        : data.map;\n    }\n\n    /**\n     * Gets the property names, values, and compare flags of `object`.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the match data of `object`.\n     */\n    function getMatchData(object) {\n      var result = keys(object),\n          length = result.length;\n\n      while (length--) {\n        var key = result[length],\n            value = object[key];\n\n        result[length] = [key, value, isStrictComparable(value)];\n      }\n      return result;\n    }\n\n    /**\n     * Gets the native function at `key` of `object`.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @param {string} key The key of the method to get.\n     * @returns {*} Returns the function if it's native, else `undefined`.\n     */\n    function getNative(object, key) {\n      var value = getValue(object, key);\n      return baseIsNative(value) ? value : undefined;\n    }\n\n    /**\n     * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\n     *\n     * @private\n     * @param {*} value The value to query.\n     * @returns {string} Returns the raw `toStringTag`.\n     */\n    function getRawTag(value) {\n      var isOwn = hasOwnProperty.call(value, symToStringTag),\n          tag = value[symToStringTag];\n\n      try {\n        value[symToStringTag] = undefined;\n        var unmasked = true;\n      } catch (e) {}\n\n      var result = nativeObjectToString.call(value);\n      if (unmasked) {\n        if (isOwn) {\n          value[symToStringTag] = tag;\n        } else {\n          delete value[symToStringTag];\n        }\n      }\n      return result;\n    }\n\n    /**\n     * Creates an array of the own enumerable symbols of `object`.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the array of symbols.\n     */\n    var getSymbols = !nativeGetSymbols ? stubArray : function(object) {\n      if (object == null) {\n        return [];\n      }\n      object = Object(object);\n      return arrayFilter(nativeGetSymbols(object), function(symbol) {\n        return propertyIsEnumerable.call(object, symbol);\n      });\n    };\n\n    /**\n     * Creates an array of the own and inherited enumerable symbols of `object`.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the array of symbols.\n     */\n    var getSymbolsIn = !nativeGetSymbols ? stubArray : function(object) {\n      var result = [];\n      while (object) {\n        arrayPush(result, getSymbols(object));\n        object = getPrototype(object);\n      }\n      return result;\n    };\n\n    /**\n     * Gets the `toStringTag` of `value`.\n     *\n     * @private\n     * @param {*} value The value to query.\n     * @returns {string} Returns the `toStringTag`.\n     */\n    var getTag = baseGetTag;\n\n    // Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.\n    if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||\n        (Map && getTag(new Map) != mapTag) ||\n        (Promise && getTag(Promise.resolve()) != promiseTag) ||\n        (Set && getTag(new Set) != setTag) ||\n        (WeakMap && getTag(new WeakMap) != weakMapTag)) {\n      getTag = function(value) {\n        var result = baseGetTag(value),\n            Ctor = result == objectTag ? value.constructor : undefined,\n            ctorString = Ctor ? toSource(Ctor) : '';\n\n        if (ctorString) {\n          switch (ctorString) {\n            case dataViewCtorString: return dataViewTag;\n            case mapCtorString: return mapTag;\n            case promiseCtorString: return promiseTag;\n            case setCtorString: return setTag;\n            case weakMapCtorString: return weakMapTag;\n          }\n        }\n        return result;\n      };\n    }\n\n    /**\n     * Gets the view, applying any `transforms` to the `start` and `end` positions.\n     *\n     * @private\n     * @param {number} start The start of the view.\n     * @param {number} end The end of the view.\n     * @param {Array} transforms The transformations to apply to the view.\n     * @returns {Object} Returns an object containing the `start` and `end`\n     *  positions of the view.\n     */\n    function getView(start, end, transforms) {\n      var index = -1,\n          length = transforms.length;\n\n      while (++index < length) {\n        var data = transforms[index],\n            size = data.size;\n\n        switch (data.type) {\n          case 'drop':      start += size; break;\n          case 'dropRight': end -= size; break;\n          case 'take':      end = nativeMin(end, start + size); break;\n          case 'takeRight': start = nativeMax(start, end - size); break;\n        }\n      }\n      return { 'start': start, 'end': end };\n    }\n\n    /**\n     * Extracts wrapper details from the `source` body comment.\n     *\n     * @private\n     * @param {string} source The source to inspect.\n     * @returns {Array} Returns the wrapper details.\n     */\n    function getWrapDetails(source) {\n      var match = source.match(reWrapDetails);\n      return match ? match[1].split(reSplitDetails) : [];\n    }\n\n    /**\n     * Checks if `path` exists on `object`.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @param {Array|string} path The path to check.\n     * @param {Function} hasFunc The function to check properties.\n     * @returns {boolean} Returns `true` if `path` exists, else `false`.\n     */\n    function hasPath(object, path, hasFunc) {\n      path = castPath(path, object);\n\n      var index = -1,\n          length = path.length,\n          result = false;\n\n      while (++index < length) {\n        var key = toKey(path[index]);\n        if (!(result = object != null && hasFunc(object, key))) {\n          break;\n        }\n        object = object[key];\n      }\n      if (result || ++index != length) {\n        return result;\n      }\n      length = object == null ? 0 : object.length;\n      return !!length && isLength(length) && isIndex(key, length) &&\n        (isArray(object) || isArguments(object));\n    }\n\n    /**\n     * Initializes an array clone.\n     *\n     * @private\n     * @param {Array} array The array to clone.\n     * @returns {Array} Returns the initialized clone.\n     */\n    function initCloneArray(array) {\n      var length = array.length,\n          result = new array.constructor(length);\n\n      // Add properties assigned by `RegExp#exec`.\n      if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) {\n        result.index = array.index;\n        result.input = array.input;\n      }\n      return result;\n    }\n\n    /**\n     * Initializes an object clone.\n     *\n     * @private\n     * @param {Object} object The object to clone.\n     * @returns {Object} Returns the initialized clone.\n     */\n    function initCloneObject(object) {\n      return (typeof object.constructor == 'function' && !isPrototype(object))\n        ? baseCreate(getPrototype(object))\n        : {};\n    }\n\n    /**\n     * Initializes an object clone based on its `toStringTag`.\n     *\n     * **Note:** This function only supports cloning values with tags of\n     * `Boolean`, `Date`, `Error`, `Map`, `Number`, `RegExp`, `Set`, or `String`.\n     *\n     * @private\n     * @param {Object} object The object to clone.\n     * @param {string} tag The `toStringTag` of the object to clone.\n     * @param {boolean} [isDeep] Specify a deep clone.\n     * @returns {Object} Returns the initialized clone.\n     */\n    function initCloneByTag(object, tag, isDeep) {\n      var Ctor = object.constructor;\n      switch (tag) {\n        case arrayBufferTag:\n          return cloneArrayBuffer(object);\n\n        case boolTag:\n        case dateTag:\n          return new Ctor(+object);\n\n        case dataViewTag:\n          return cloneDataView(object, isDeep);\n\n        case float32Tag: case float64Tag:\n        case int8Tag: case int16Tag: case int32Tag:\n        case uint8Tag: case uint8ClampedTag: case uint16Tag: case uint32Tag:\n          return cloneTypedArray(object, isDeep);\n\n        case mapTag:\n          return new Ctor;\n\n        case numberTag:\n        case stringTag:\n          return new Ctor(object);\n\n        case regexpTag:\n          return cloneRegExp(object);\n\n        case setTag:\n          return new Ctor;\n\n        case symbolTag:\n          return cloneSymbol(object);\n      }\n    }\n\n    /**\n     * Inserts wrapper `details` in a comment at the top of the `source` body.\n     *\n     * @private\n     * @param {string} source The source to modify.\n     * @returns {Array} details The details to insert.\n     * @returns {string} Returns the modified source.\n     */\n    function insertWrapDetails(source, details) {\n      var length = details.length;\n      if (!length) {\n        return source;\n      }\n      var lastIndex = length - 1;\n      details[lastIndex] = (length > 1 ? '& ' : '') + details[lastIndex];\n      details = details.join(length > 2 ? ', ' : ' ');\n      return source.replace(reWrapComment, '{\\n/* [wrapped with ' + details + '] */\\n');\n    }\n\n    /**\n     * Checks if `value` is a flattenable `arguments` object or array.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is flattenable, else `false`.\n     */\n    function isFlattenable(value) {\n      return isArray(value) || isArguments(value) ||\n        !!(spreadableSymbol && value && value[spreadableSymbol]);\n    }\n\n    /**\n     * Checks if `value` is a valid array-like index.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.\n     * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.\n     */\n    function isIndex(value, length) {\n      var type = typeof value;\n      length = length == null ? MAX_SAFE_INTEGER : length;\n\n      return !!length &&\n        (type == 'number' ||\n          (type != 'symbol' && reIsUint.test(value))) &&\n            (value > -1 && value % 1 == 0 && value < length);\n    }\n\n    /**\n     * Checks if the given arguments are from an iteratee call.\n     *\n     * @private\n     * @param {*} value The potential iteratee value argument.\n     * @param {*} index The potential iteratee index or key argument.\n     * @param {*} object The potential iteratee object argument.\n     * @returns {boolean} Returns `true` if the arguments are from an iteratee call,\n     *  else `false`.\n     */\n    function isIterateeCall(value, index, object) {\n      if (!isObject(object)) {\n        return false;\n      }\n      var type = typeof index;\n      if (type == 'number'\n            ? (isArrayLike(object) && isIndex(index, object.length))\n            : (type == 'string' && index in object)\n          ) {\n        return eq(object[index], value);\n      }\n      return false;\n    }\n\n    /**\n     * Checks if `value` is a property name and not a property path.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @param {Object} [object] The object to query keys on.\n     * @returns {boolean} Returns `true` if `value` is a property name, else `false`.\n     */\n    function isKey(value, object) {\n      if (isArray(value)) {\n        return false;\n      }\n      var type = typeof value;\n      if (type == 'number' || type == 'symbol' || type == 'boolean' ||\n          value == null || isSymbol(value)) {\n        return true;\n      }\n      return reIsPlainProp.test(value) || !reIsDeepProp.test(value) ||\n        (object != null && value in Object(object));\n    }\n\n    /**\n     * Checks if `value` is suitable for use as unique object key.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is suitable, else `false`.\n     */\n    function isKeyable(value) {\n      var type = typeof value;\n      return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')\n        ? (value !== '__proto__')\n        : (value === null);\n    }\n\n    /**\n     * Checks if `func` has a lazy counterpart.\n     *\n     * @private\n     * @param {Function} func The function to check.\n     * @returns {boolean} Returns `true` if `func` has a lazy counterpart,\n     *  else `false`.\n     */\n    function isLaziable(func) {\n      var funcName = getFuncName(func),\n          other = lodash[funcName];\n\n      if (typeof other != 'function' || !(funcName in LazyWrapper.prototype)) {\n        return false;\n      }\n      if (func === other) {\n        return true;\n      }\n      var data = getData(other);\n      return !!data && func === data[0];\n    }\n\n    /**\n     * Checks if `func` has its source masked.\n     *\n     * @private\n     * @param {Function} func The function to check.\n     * @returns {boolean} Returns `true` if `func` is masked, else `false`.\n     */\n    function isMasked(func) {\n      return !!maskSrcKey && (maskSrcKey in func);\n    }\n\n    /**\n     * Checks if `func` is capable of being masked.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `func` is maskable, else `false`.\n     */\n    var isMaskable = coreJsData ? isFunction : stubFalse;\n\n    /**\n     * Checks if `value` is likely a prototype object.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.\n     */\n    function isPrototype(value) {\n      var Ctor = value && value.constructor,\n          proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;\n\n      return value === proto;\n    }\n\n    /**\n     * Checks if `value` is suitable for strict equality comparisons, i.e. `===`.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` if suitable for strict\n     *  equality comparisons, else `false`.\n     */\n    function isStrictComparable(value) {\n      return value === value && !isObject(value);\n    }\n\n    /**\n     * A specialized version of `matchesProperty` for source values suitable\n     * for strict equality comparisons, i.e. `===`.\n     *\n     * @private\n     * @param {string} key The key of the property to get.\n     * @param {*} srcValue The value to match.\n     * @returns {Function} Returns the new spec function.\n     */\n    function matchesStrictComparable(key, srcValue) {\n      return function(object) {\n        if (object == null) {\n          return false;\n        }\n        return object[key] === srcValue &&\n          (srcValue !== undefined || (key in Object(object)));\n      };\n    }\n\n    /**\n     * A specialized version of `_.memoize` which clears the memoized function's\n     * cache when it exceeds `MAX_MEMOIZE_SIZE`.\n     *\n     * @private\n     * @param {Function} func The function to have its output memoized.\n     * @returns {Function} Returns the new memoized function.\n     */\n    function memoizeCapped(func) {\n      var result = memoize(func, function(key) {\n        if (cache.size === MAX_MEMOIZE_SIZE) {\n          cache.clear();\n        }\n        return key;\n      });\n\n      var cache = result.cache;\n      return result;\n    }\n\n    /**\n     * Merges the function metadata of `source` into `data`.\n     *\n     * Merging metadata reduces the number of wrappers used to invoke a function.\n     * This is possible because methods like `_.bind`, `_.curry`, and `_.partial`\n     * may be applied regardless of execution order. Methods like `_.ary` and\n     * `_.rearg` modify function arguments, making the order in which they are\n     * executed important, preventing the merging of metadata. However, we make\n     * an exception for a safe combined case where curried functions have `_.ary`\n     * and or `_.rearg` applied.\n     *\n     * @private\n     * @param {Array} data The destination metadata.\n     * @param {Array} source The source metadata.\n     * @returns {Array} Returns `data`.\n     */\n    function mergeData(data, source) {\n      var bitmask = data[1],\n          srcBitmask = source[1],\n          newBitmask = bitmask | srcBitmask,\n          isCommon = newBitmask < (WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG | WRAP_ARY_FLAG);\n\n      var isCombo =\n        ((srcBitmask == WRAP_ARY_FLAG) && (bitmask == WRAP_CURRY_FLAG)) ||\n        ((srcBitmask == WRAP_ARY_FLAG) && (bitmask == WRAP_REARG_FLAG) && (data[7].length <= source[8])) ||\n        ((srcBitmask == (WRAP_ARY_FLAG | WRAP_REARG_FLAG)) && (source[7].length <= source[8]) && (bitmask == WRAP_CURRY_FLAG));\n\n      // Exit early if metadata can't be merged.\n      if (!(isCommon || isCombo)) {\n        return data;\n      }\n      // Use source `thisArg` if available.\n      if (srcBitmask & WRAP_BIND_FLAG) {\n        data[2] = source[2];\n        // Set when currying a bound function.\n        newBitmask |= bitmask & WRAP_BIND_FLAG ? 0 : WRAP_CURRY_BOUND_FLAG;\n      }\n      // Compose partial arguments.\n      var value = source[3];\n      if (value) {\n        var partials = data[3];\n        data[3] = partials ? composeArgs(partials, value, source[4]) : value;\n        data[4] = partials ? replaceHolders(data[3], PLACEHOLDER) : source[4];\n      }\n      // Compose partial right arguments.\n      value = source[5];\n      if (value) {\n        partials = data[5];\n        data[5] = partials ? composeArgsRight(partials, value, source[6]) : value;\n        data[6] = partials ? replaceHolders(data[5], PLACEHOLDER) : source[6];\n      }\n      // Use source `argPos` if available.\n      value = source[7];\n      if (value) {\n        data[7] = value;\n      }\n      // Use source `ary` if it's smaller.\n      if (srcBitmask & WRAP_ARY_FLAG) {\n        data[8] = data[8] == null ? source[8] : nativeMin(data[8], source[8]);\n      }\n      // Use source `arity` if one is not provided.\n      if (data[9] == null) {\n        data[9] = source[9];\n      }\n      // Use source `func` and merge bitmasks.\n      data[0] = source[0];\n      data[1] = newBitmask;\n\n      return data;\n    }\n\n    /**\n     * This function is like\n     * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n     * except that it includes inherited enumerable properties.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the array of property names.\n     */\n    function nativeKeysIn(object) {\n      var result = [];\n      if (object != null) {\n        for (var key in Object(object)) {\n          result.push(key);\n        }\n      }\n      return result;\n    }\n\n    /**\n     * Converts `value` to a string using `Object.prototype.toString`.\n     *\n     * @private\n     * @param {*} value The value to convert.\n     * @returns {string} Returns the converted string.\n     */\n    function objectToString(value) {\n      return nativeObjectToString.call(value);\n    }\n\n    /**\n     * A specialized version of `baseRest` which transforms the rest array.\n     *\n     * @private\n     * @param {Function} func The function to apply a rest parameter to.\n     * @param {number} [start=func.length-1] The start position of the rest parameter.\n     * @param {Function} transform The rest array transform.\n     * @returns {Function} Returns the new function.\n     */\n    function overRest(func, start, transform) {\n      start = nativeMax(start === undefined ? (func.length - 1) : start, 0);\n      return function() {\n        var args = arguments,\n            index = -1,\n            length = nativeMax(args.length - start, 0),\n            array = Array(length);\n\n        while (++index < length) {\n          array[index] = args[start + index];\n        }\n        index = -1;\n        var otherArgs = Array(start + 1);\n        while (++index < start) {\n          otherArgs[index] = args[index];\n        }\n        otherArgs[start] = transform(array);\n        return apply(func, this, otherArgs);\n      };\n    }\n\n    /**\n     * Gets the parent value at `path` of `object`.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @param {Array} path The path to get the parent value of.\n     * @returns {*} Returns the parent value.\n     */\n    function parent(object, path) {\n      return path.length < 2 ? object : baseGet(object, baseSlice(path, 0, -1));\n    }\n\n    /**\n     * Reorder `array` according to the specified indexes where the element at\n     * the first index is assigned as the first element, the element at\n     * the second index is assigned as the second element, and so on.\n     *\n     * @private\n     * @param {Array} array The array to reorder.\n     * @param {Array} indexes The arranged array indexes.\n     * @returns {Array} Returns `array`.\n     */\n    function reorder(array, indexes) {\n      var arrLength = array.length,\n          length = nativeMin(indexes.length, arrLength),\n          oldArray = copyArray(array);\n\n      while (length--) {\n        var index = indexes[length];\n        array[length] = isIndex(index, arrLength) ? oldArray[index] : undefined;\n      }\n      return array;\n    }\n\n    /**\n     * Gets the value at `key`, unless `key` is \"__proto__\" or \"constructor\".\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @param {string} key The key of the property to get.\n     * @returns {*} Returns the property value.\n     */\n    function safeGet(object, key) {\n      if (key === 'constructor' && typeof object[key] === 'function') {\n        return;\n      }\n\n      if (key == '__proto__') {\n        return;\n      }\n\n      return object[key];\n    }\n\n    /**\n     * Sets metadata for `func`.\n     *\n     * **Note:** If this function becomes hot, i.e. is invoked a lot in a short\n     * period of time, it will trip its breaker and transition to an identity\n     * function to avoid garbage collection pauses in V8. See\n     * [V8 issue 2070](https://bugs.chromium.org/p/v8/issues/detail?id=2070)\n     * for more details.\n     *\n     * @private\n     * @param {Function} func The function to associate metadata with.\n     * @param {*} data The metadata.\n     * @returns {Function} Returns `func`.\n     */\n    var setData = shortOut(baseSetData);\n\n    /**\n     * A simple wrapper around the global [`setTimeout`](https://mdn.io/setTimeout).\n     *\n     * @private\n     * @param {Function} func The function to delay.\n     * @param {number} wait The number of milliseconds to delay invocation.\n     * @returns {number|Object} Returns the timer id or timeout object.\n     */\n    var setTimeout = ctxSetTimeout || function(func, wait) {\n      return root.setTimeout(func, wait);\n    };\n\n    /**\n     * Sets the `toString` method of `func` to return `string`.\n     *\n     * @private\n     * @param {Function} func The function to modify.\n     * @param {Function} string The `toString` result.\n     * @returns {Function} Returns `func`.\n     */\n    var setToString = shortOut(baseSetToString);\n\n    /**\n     * Sets the `toString` method of `wrapper` to mimic the source of `reference`\n     * with wrapper details in a comment at the top of the source body.\n     *\n     * @private\n     * @param {Function} wrapper The function to modify.\n     * @param {Function} reference The reference function.\n     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n     * @returns {Function} Returns `wrapper`.\n     */\n    function setWrapToString(wrapper, reference, bitmask) {\n      var source = (reference + '');\n      return setToString(wrapper, insertWrapDetails(source, updateWrapDetails(getWrapDetails(source), bitmask)));\n    }\n\n    /**\n     * Creates a function that'll short out and invoke `identity` instead\n     * of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN`\n     * milliseconds.\n     *\n     * @private\n     * @param {Function} func The function to restrict.\n     * @returns {Function} Returns the new shortable function.\n     */\n    function shortOut(func) {\n      var count = 0,\n          lastCalled = 0;\n\n      return function() {\n        var stamp = nativeNow(),\n            remaining = HOT_SPAN - (stamp - lastCalled);\n\n        lastCalled = stamp;\n        if (remaining > 0) {\n          if (++count >= HOT_COUNT) {\n            return arguments[0];\n          }\n        } else {\n          count = 0;\n        }\n        return func.apply(undefined, arguments);\n      };\n    }\n\n    /**\n     * A specialized version of `_.shuffle` which mutates and sets the size of `array`.\n     *\n     * @private\n     * @param {Array} array The array to shuffle.\n     * @param {number} [size=array.length] The size of `array`.\n     * @returns {Array} Returns `array`.\n     */\n    function shuffleSelf(array, size) {\n      var index = -1,\n          length = array.length,\n          lastIndex = length - 1;\n\n      size = size === undefined ? length : size;\n      while (++index < size) {\n        var rand = baseRandom(index, lastIndex),\n            value = array[rand];\n\n        array[rand] = array[index];\n        array[index] = value;\n      }\n      array.length = size;\n      return array;\n    }\n\n    /**\n     * Converts `string` to a property path array.\n     *\n     * @private\n     * @param {string} string The string to convert.\n     * @returns {Array} Returns the property path array.\n     */\n    var stringToPath = memoizeCapped(function(string) {\n      var result = [];\n      if (string.charCodeAt(0) === 46 /* . */) {\n        result.push('');\n      }\n      string.replace(rePropName, function(match, number, quote, subString) {\n        result.push(quote ? subString.replace(reEscapeChar, '$1') : (number || match));\n      });\n      return result;\n    });\n\n    /**\n     * Converts `value` to a string key if it's not a string or symbol.\n     *\n     * @private\n     * @param {*} value The value to inspect.\n     * @returns {string|symbol} Returns the key.\n     */\n    function toKey(value) {\n      if (typeof value == 'string' || isSymbol(value)) {\n        return value;\n      }\n      var result = (value + '');\n      return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;\n    }\n\n    /**\n     * Converts `func` to its source code.\n     *\n     * @private\n     * @param {Function} func The function to convert.\n     * @returns {string} Returns the source code.\n     */\n    function toSource(func) {\n      if (func != null) {\n        try {\n          return funcToString.call(func);\n        } catch (e) {}\n        try {\n          return (func + '');\n        } catch (e) {}\n      }\n      return '';\n    }\n\n    /**\n     * Updates wrapper `details` based on `bitmask` flags.\n     *\n     * @private\n     * @returns {Array} details The details to modify.\n     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n     * @returns {Array} Returns `details`.\n     */\n    function updateWrapDetails(details, bitmask) {\n      arrayEach(wrapFlags, function(pair) {\n        var value = '_.' + pair[0];\n        if ((bitmask & pair[1]) && !arrayIncludes(details, value)) {\n          details.push(value);\n        }\n      });\n      return details.sort();\n    }\n\n    /**\n     * Creates a clone of `wrapper`.\n     *\n     * @private\n     * @param {Object} wrapper The wrapper to clone.\n     * @returns {Object} Returns the cloned wrapper.\n     */\n    function wrapperClone(wrapper) {\n      if (wrapper instanceof LazyWrapper) {\n        return wrapper.clone();\n      }\n      var result = new LodashWrapper(wrapper.__wrapped__, wrapper.__chain__);\n      result.__actions__ = copyArray(wrapper.__actions__);\n      result.__index__  = wrapper.__index__;\n      result.__values__ = wrapper.__values__;\n      return result;\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates an array of elements split into groups the length of `size`.\n     * If `array` can't be split evenly, the final chunk will be the remaining\n     * elements.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The array to process.\n     * @param {number} [size=1] The length of each chunk\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Array} Returns the new array of chunks.\n     * @example\n     *\n     * _.chunk(['a', 'b', 'c', 'd'], 2);\n     * // => [['a', 'b'], ['c', 'd']]\n     *\n     * _.chunk(['a', 'b', 'c', 'd'], 3);\n     * // => [['a', 'b', 'c'], ['d']]\n     */\n    function chunk(array, size, guard) {\n      if ((guard ? isIterateeCall(array, size, guard) : size === undefined)) {\n        size = 1;\n      } else {\n        size = nativeMax(toInteger(size), 0);\n      }\n      var length = array == null ? 0 : array.length;\n      if (!length || size < 1) {\n        return [];\n      }\n      var index = 0,\n          resIndex = 0,\n          result = Array(nativeCeil(length / size));\n\n      while (index < length) {\n        result[resIndex++] = baseSlice(array, index, (index += size));\n      }\n      return result;\n    }\n\n    /**\n     * Creates an array with all falsey values removed. The values `false`, `null`,\n     * `0`, `\"\"`, `undefined`, and `NaN` are falsey.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The array to compact.\n     * @returns {Array} Returns the new array of filtered values.\n     * @example\n     *\n     * _.compact([0, 1, false, 2, '', 3]);\n     * // => [1, 2, 3]\n     */\n    function compact(array) {\n      var index = -1,\n          length = array == null ? 0 : array.length,\n          resIndex = 0,\n          result = [];\n\n      while (++index < length) {\n        var value = array[index];\n        if (value) {\n          result[resIndex++] = value;\n        }\n      }\n      return result;\n    }\n\n    /**\n     * Creates a new array concatenating `array` with any additional arrays\n     * and/or values.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to concatenate.\n     * @param {...*} [values] The values to concatenate.\n     * @returns {Array} Returns the new concatenated array.\n     * @example\n     *\n     * var array = [1];\n     * var other = _.concat(array, 2, [3], [[4]]);\n     *\n     * console.log(other);\n     * // => [1, 2, 3, [4]]\n     *\n     * console.log(array);\n     * // => [1]\n     */\n    function concat() {\n      var length = arguments.length;\n      if (!length) {\n        return [];\n      }\n      var args = Array(length - 1),\n          array = arguments[0],\n          index = length;\n\n      while (index--) {\n        args[index - 1] = arguments[index];\n      }\n      return arrayPush(isArray(array) ? copyArray(array) : [array], baseFlatten(args, 1));\n    }\n\n    /**\n     * Creates an array of `array` values not included in the other given arrays\n     * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n     * for equality comparisons. The order and references of result values are\n     * determined by the first array.\n     *\n     * **Note:** Unlike `_.pullAll`, this method returns a new array.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {...Array} [values] The values to exclude.\n     * @returns {Array} Returns the new array of filtered values.\n     * @see _.without, _.xor\n     * @example\n     *\n     * _.difference([2, 1], [2, 3]);\n     * // => [1]\n     */\n    var difference = baseRest(function(array, values) {\n      return isArrayLikeObject(array)\n        ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true))\n        : [];\n    });\n\n    /**\n     * This method is like `_.difference` except that it accepts `iteratee` which\n     * is invoked for each element of `array` and `values` to generate the criterion\n     * by which they're compared. The order and references of result values are\n     * determined by the first array. The iteratee is invoked with one argument:\n     * (value).\n     *\n     * **Note:** Unlike `_.pullAllBy`, this method returns a new array.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {...Array} [values] The values to exclude.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {Array} Returns the new array of filtered values.\n     * @example\n     *\n     * _.differenceBy([2.1, 1.2], [2.3, 3.4], Math.floor);\n     * // => [1.2]\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.differenceBy([{ 'x': 2 }, { 'x': 1 }], [{ 'x': 1 }], 'x');\n     * // => [{ 'x': 2 }]\n     */\n    var differenceBy = baseRest(function(array, values) {\n      var iteratee = last(values);\n      if (isArrayLikeObject(iteratee)) {\n        iteratee = undefined;\n      }\n      return isArrayLikeObject(array)\n        ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true), getIteratee(iteratee, 2))\n        : [];\n    });\n\n    /**\n     * This method is like `_.difference` except that it accepts `comparator`\n     * which is invoked to compare elements of `array` to `values`. The order and\n     * references of result values are determined by the first array. The comparator\n     * is invoked with two arguments: (arrVal, othVal).\n     *\n     * **Note:** Unlike `_.pullAllWith`, this method returns a new array.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {...Array} [values] The values to exclude.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns the new array of filtered values.\n     * @example\n     *\n     * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];\n     *\n     * _.differenceWith(objects, [{ 'x': 1, 'y': 2 }], _.isEqual);\n     * // => [{ 'x': 2, 'y': 1 }]\n     */\n    var differenceWith = baseRest(function(array, values) {\n      var comparator = last(values);\n      if (isArrayLikeObject(comparator)) {\n        comparator = undefined;\n      }\n      return isArrayLikeObject(array)\n        ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true), undefined, comparator)\n        : [];\n    });\n\n    /**\n     * Creates a slice of `array` with `n` elements dropped from the beginning.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.5.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {number} [n=1] The number of elements to drop.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * _.drop([1, 2, 3]);\n     * // => [2, 3]\n     *\n     * _.drop([1, 2, 3], 2);\n     * // => [3]\n     *\n     * _.drop([1, 2, 3], 5);\n     * // => []\n     *\n     * _.drop([1, 2, 3], 0);\n     * // => [1, 2, 3]\n     */\n    function drop(array, n, guard) {\n      var length = array == null ? 0 : array.length;\n      if (!length) {\n        return [];\n      }\n      n = (guard || n === undefined) ? 1 : toInteger(n);\n      return baseSlice(array, n < 0 ? 0 : n, length);\n    }\n\n    /**\n     * Creates a slice of `array` with `n` elements dropped from the end.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {number} [n=1] The number of elements to drop.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * _.dropRight([1, 2, 3]);\n     * // => [1, 2]\n     *\n     * _.dropRight([1, 2, 3], 2);\n     * // => [1]\n     *\n     * _.dropRight([1, 2, 3], 5);\n     * // => []\n     *\n     * _.dropRight([1, 2, 3], 0);\n     * // => [1, 2, 3]\n     */\n    function dropRight(array, n, guard) {\n      var length = array == null ? 0 : array.length;\n      if (!length) {\n        return [];\n      }\n      n = (guard || n === undefined) ? 1 : toInteger(n);\n      n = length - n;\n      return baseSlice(array, 0, n < 0 ? 0 : n);\n    }\n\n    /**\n     * Creates a slice of `array` excluding elements dropped from the end.\n     * Elements are dropped until `predicate` returns falsey. The predicate is\n     * invoked with three arguments: (value, index, array).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney',  'active': true },\n     *   { 'user': 'fred',    'active': false },\n     *   { 'user': 'pebbles', 'active': false }\n     * ];\n     *\n     * _.dropRightWhile(users, function(o) { return !o.active; });\n     * // => objects for ['barney']\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.dropRightWhile(users, { 'user': 'pebbles', 'active': false });\n     * // => objects for ['barney', 'fred']\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.dropRightWhile(users, ['active', false]);\n     * // => objects for ['barney']\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.dropRightWhile(users, 'active');\n     * // => objects for ['barney', 'fred', 'pebbles']\n     */\n    function dropRightWhile(array, predicate) {\n      return (array && array.length)\n        ? baseWhile(array, getIteratee(predicate, 3), true, true)\n        : [];\n    }\n\n    /**\n     * Creates a slice of `array` excluding elements dropped from the beginning.\n     * Elements are dropped until `predicate` returns falsey. The predicate is\n     * invoked with three arguments: (value, index, array).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney',  'active': false },\n     *   { 'user': 'fred',    'active': false },\n     *   { 'user': 'pebbles', 'active': true }\n     * ];\n     *\n     * _.dropWhile(users, function(o) { return !o.active; });\n     * // => objects for ['pebbles']\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.dropWhile(users, { 'user': 'barney', 'active': false });\n     * // => objects for ['fred', 'pebbles']\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.dropWhile(users, ['active', false]);\n     * // => objects for ['pebbles']\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.dropWhile(users, 'active');\n     * // => objects for ['barney', 'fred', 'pebbles']\n     */\n    function dropWhile(array, predicate) {\n      return (array && array.length)\n        ? baseWhile(array, getIteratee(predicate, 3), true)\n        : [];\n    }\n\n    /**\n     * Fills elements of `array` with `value` from `start` up to, but not\n     * including, `end`.\n     *\n     * **Note:** This method mutates `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.2.0\n     * @category Array\n     * @param {Array} array The array to fill.\n     * @param {*} value The value to fill `array` with.\n     * @param {number} [start=0] The start position.\n     * @param {number} [end=array.length] The end position.\n     * @returns {Array} Returns `array`.\n     * @example\n     *\n     * var array = [1, 2, 3];\n     *\n     * _.fill(array, 'a');\n     * console.log(array);\n     * // => ['a', 'a', 'a']\n     *\n     * _.fill(Array(3), 2);\n     * // => [2, 2, 2]\n     *\n     * _.fill([4, 6, 8, 10], '*', 1, 3);\n     * // => [4, '*', '*', 10]\n     */\n    function fill(array, value, start, end) {\n      var length = array == null ? 0 : array.length;\n      if (!length) {\n        return [];\n      }\n      if (start && typeof start != 'number' && isIterateeCall(array, value, start)) {\n        start = 0;\n        end = length;\n      }\n      return baseFill(array, value, start, end);\n    }\n\n    /**\n     * This method is like `_.find` except that it returns the index of the first\n     * element `predicate` returns truthy for instead of the element itself.\n     *\n     * @static\n     * @memberOf _\n     * @since 1.1.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @param {number} [fromIndex=0] The index to search from.\n     * @returns {number} Returns the index of the found element, else `-1`.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney',  'active': false },\n     *   { 'user': 'fred',    'active': false },\n     *   { 'user': 'pebbles', 'active': true }\n     * ];\n     *\n     * _.findIndex(users, function(o) { return o.user == 'barney'; });\n     * // => 0\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.findIndex(users, { 'user': 'fred', 'active': false });\n     * // => 1\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.findIndex(users, ['active', false]);\n     * // => 0\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.findIndex(users, 'active');\n     * // => 2\n     */\n    function findIndex(array, predicate, fromIndex) {\n      var length = array == null ? 0 : array.length;\n      if (!length) {\n        return -1;\n      }\n      var index = fromIndex == null ? 0 : toInteger(fromIndex);\n      if (index < 0) {\n        index = nativeMax(length + index, 0);\n      }\n      return baseFindIndex(array, getIteratee(predicate, 3), index);\n    }\n\n    /**\n     * This method is like `_.findIndex` except that it iterates over elements\n     * of `collection` from right to left.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.0.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @param {number} [fromIndex=array.length-1] The index to search from.\n     * @returns {number} Returns the index of the found element, else `-1`.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney',  'active': true },\n     *   { 'user': 'fred',    'active': false },\n     *   { 'user': 'pebbles', 'active': false }\n     * ];\n     *\n     * _.findLastIndex(users, function(o) { return o.user == 'pebbles'; });\n     * // => 2\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.findLastIndex(users, { 'user': 'barney', 'active': true });\n     * // => 0\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.findLastIndex(users, ['active', false]);\n     * // => 2\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.findLastIndex(users, 'active');\n     * // => 0\n     */\n    function findLastIndex(array, predicate, fromIndex) {\n      var length = array == null ? 0 : array.length;\n      if (!length) {\n        return -1;\n      }\n      var index = length - 1;\n      if (fromIndex !== undefined) {\n        index = toInteger(fromIndex);\n        index = fromIndex < 0\n          ? nativeMax(length + index, 0)\n          : nativeMin(index, length - 1);\n      }\n      return baseFindIndex(array, getIteratee(predicate, 3), index, true);\n    }\n\n    /**\n     * Flattens `array` a single level deep.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The array to flatten.\n     * @returns {Array} Returns the new flattened array.\n     * @example\n     *\n     * _.flatten([1, [2, [3, [4]], 5]]);\n     * // => [1, 2, [3, [4]], 5]\n     */\n    function flatten(array) {\n      var length = array == null ? 0 : array.length;\n      return length ? baseFlatten(array, 1) : [];\n    }\n\n    /**\n     * Recursively flattens `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The array to flatten.\n     * @returns {Array} Returns the new flattened array.\n     * @example\n     *\n     * _.flattenDeep([1, [2, [3, [4]], 5]]);\n     * // => [1, 2, 3, 4, 5]\n     */\n    function flattenDeep(array) {\n      var length = array == null ? 0 : array.length;\n      return length ? baseFlatten(array, INFINITY) : [];\n    }\n\n    /**\n     * Recursively flatten `array` up to `depth` times.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.4.0\n     * @category Array\n     * @param {Array} array The array to flatten.\n     * @param {number} [depth=1] The maximum recursion depth.\n     * @returns {Array} Returns the new flattened array.\n     * @example\n     *\n     * var array = [1, [2, [3, [4]], 5]];\n     *\n     * _.flattenDepth(array, 1);\n     * // => [1, 2, [3, [4]], 5]\n     *\n     * _.flattenDepth(array, 2);\n     * // => [1, 2, 3, [4], 5]\n     */\n    function flattenDepth(array, depth) {\n      var length = array == null ? 0 : array.length;\n      if (!length) {\n        return [];\n      }\n      depth = depth === undefined ? 1 : toInteger(depth);\n      return baseFlatten(array, depth);\n    }\n\n    /**\n     * The inverse of `_.toPairs`; this method returns an object composed\n     * from key-value `pairs`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} pairs The key-value pairs.\n     * @returns {Object} Returns the new object.\n     * @example\n     *\n     * _.fromPairs([['a', 1], ['b', 2]]);\n     * // => { 'a': 1, 'b': 2 }\n     */\n    function fromPairs(pairs) {\n      var index = -1,\n          length = pairs == null ? 0 : pairs.length,\n          result = {};\n\n      while (++index < length) {\n        var pair = pairs[index];\n        result[pair[0]] = pair[1];\n      }\n      return result;\n    }\n\n    /**\n     * Gets the first element of `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @alias first\n     * @category Array\n     * @param {Array} array The array to query.\n     * @returns {*} Returns the first element of `array`.\n     * @example\n     *\n     * _.head([1, 2, 3]);\n     * // => 1\n     *\n     * _.head([]);\n     * // => undefined\n     */\n    function head(array) {\n      return (array && array.length) ? array[0] : undefined;\n    }\n\n    /**\n     * Gets the index at which the first occurrence of `value` is found in `array`\n     * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n     * for equality comparisons. If `fromIndex` is negative, it's used as the\n     * offset from the end of `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {*} value The value to search for.\n     * @param {number} [fromIndex=0] The index to search from.\n     * @returns {number} Returns the index of the matched value, else `-1`.\n     * @example\n     *\n     * _.indexOf([1, 2, 1, 2], 2);\n     * // => 1\n     *\n     * // Search from the `fromIndex`.\n     * _.indexOf([1, 2, 1, 2], 2, 2);\n     * // => 3\n     */\n    function indexOf(array, value, fromIndex) {\n      var length = array == null ? 0 : array.length;\n      if (!length) {\n        return -1;\n      }\n      var index = fromIndex == null ? 0 : toInteger(fromIndex);\n      if (index < 0) {\n        index = nativeMax(length + index, 0);\n      }\n      return baseIndexOf(array, value, index);\n    }\n\n    /**\n     * Gets all but the last element of `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * _.initial([1, 2, 3]);\n     * // => [1, 2]\n     */\n    function initial(array) {\n      var length = array == null ? 0 : array.length;\n      return length ? baseSlice(array, 0, -1) : [];\n    }\n\n    /**\n     * Creates an array of unique values that are included in all given arrays\n     * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n     * for equality comparisons. The order and references of result values are\n     * determined by the first array.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to inspect.\n     * @returns {Array} Returns the new array of intersecting values.\n     * @example\n     *\n     * _.intersection([2, 1], [2, 3]);\n     * // => [2]\n     */\n    var intersection = baseRest(function(arrays) {\n      var mapped = arrayMap(arrays, castArrayLikeObject);\n      return (mapped.length && mapped[0] === arrays[0])\n        ? baseIntersection(mapped)\n        : [];\n    });\n\n    /**\n     * This method is like `_.intersection` except that it accepts `iteratee`\n     * which is invoked for each element of each `arrays` to generate the criterion\n     * by which they're compared. The order and references of result values are\n     * determined by the first array. The iteratee is invoked with one argument:\n     * (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to inspect.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {Array} Returns the new array of intersecting values.\n     * @example\n     *\n     * _.intersectionBy([2.1, 1.2], [2.3, 3.4], Math.floor);\n     * // => [2.1]\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.intersectionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');\n     * // => [{ 'x': 1 }]\n     */\n    var intersectionBy = baseRest(function(arrays) {\n      var iteratee = last(arrays),\n          mapped = arrayMap(arrays, castArrayLikeObject);\n\n      if (iteratee === last(mapped)) {\n        iteratee = undefined;\n      } else {\n        mapped.pop();\n      }\n      return (mapped.length && mapped[0] === arrays[0])\n        ? baseIntersection(mapped, getIteratee(iteratee, 2))\n        : [];\n    });\n\n    /**\n     * This method is like `_.intersection` except that it accepts `comparator`\n     * which is invoked to compare elements of `arrays`. The order and references\n     * of result values are determined by the first array. The comparator is\n     * invoked with two arguments: (arrVal, othVal).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to inspect.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns the new array of intersecting values.\n     * @example\n     *\n     * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];\n     * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];\n     *\n     * _.intersectionWith(objects, others, _.isEqual);\n     * // => [{ 'x': 1, 'y': 2 }]\n     */\n    var intersectionWith = baseRest(function(arrays) {\n      var comparator = last(arrays),\n          mapped = arrayMap(arrays, castArrayLikeObject);\n\n      comparator = typeof comparator == 'function' ? comparator : undefined;\n      if (comparator) {\n        mapped.pop();\n      }\n      return (mapped.length && mapped[0] === arrays[0])\n        ? baseIntersection(mapped, undefined, comparator)\n        : [];\n    });\n\n    /**\n     * Converts all elements in `array` into a string separated by `separator`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to convert.\n     * @param {string} [separator=','] The element separator.\n     * @returns {string} Returns the joined string.\n     * @example\n     *\n     * _.join(['a', 'b', 'c'], '~');\n     * // => 'a~b~c'\n     */\n    function join(array, separator) {\n      return array == null ? '' : nativeJoin.call(array, separator);\n    }\n\n    /**\n     * Gets the last element of `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @returns {*} Returns the last element of `array`.\n     * @example\n     *\n     * _.last([1, 2, 3]);\n     * // => 3\n     */\n    function last(array) {\n      var length = array == null ? 0 : array.length;\n      return length ? array[length - 1] : undefined;\n    }\n\n    /**\n     * This method is like `_.indexOf` except that it iterates over elements of\n     * `array` from right to left.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {*} value The value to search for.\n     * @param {number} [fromIndex=array.length-1] The index to search from.\n     * @returns {number} Returns the index of the matched value, else `-1`.\n     * @example\n     *\n     * _.lastIndexOf([1, 2, 1, 2], 2);\n     * // => 3\n     *\n     * // Search from the `fromIndex`.\n     * _.lastIndexOf([1, 2, 1, 2], 2, 2);\n     * // => 1\n     */\n    function lastIndexOf(array, value, fromIndex) {\n      var length = array == null ? 0 : array.length;\n      if (!length) {\n        return -1;\n      }\n      var index = length;\n      if (fromIndex !== undefined) {\n        index = toInteger(fromIndex);\n        index = index < 0 ? nativeMax(length + index, 0) : nativeMin(index, length - 1);\n      }\n      return value === value\n        ? strictLastIndexOf(array, value, index)\n        : baseFindIndex(array, baseIsNaN, index, true);\n    }\n\n    /**\n     * Gets the element at index `n` of `array`. If `n` is negative, the nth\n     * element from the end is returned.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.11.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {number} [n=0] The index of the element to return.\n     * @returns {*} Returns the nth element of `array`.\n     * @example\n     *\n     * var array = ['a', 'b', 'c', 'd'];\n     *\n     * _.nth(array, 1);\n     * // => 'b'\n     *\n     * _.nth(array, -2);\n     * // => 'c';\n     */\n    function nth(array, n) {\n      return (array && array.length) ? baseNth(array, toInteger(n)) : undefined;\n    }\n\n    /**\n     * Removes all given values from `array` using\n     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n     * for equality comparisons.\n     *\n     * **Note:** Unlike `_.without`, this method mutates `array`. Use `_.remove`\n     * to remove elements from an array by predicate.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.0.0\n     * @category Array\n     * @param {Array} array The array to modify.\n     * @param {...*} [values] The values to remove.\n     * @returns {Array} Returns `array`.\n     * @example\n     *\n     * var array = ['a', 'b', 'c', 'a', 'b', 'c'];\n     *\n     * _.pull(array, 'a', 'c');\n     * console.log(array);\n     * // => ['b', 'b']\n     */\n    var pull = baseRest(pullAll);\n\n    /**\n     * This method is like `_.pull` except that it accepts an array of values to remove.\n     *\n     * **Note:** Unlike `_.difference`, this method mutates `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to modify.\n     * @param {Array} values The values to remove.\n     * @returns {Array} Returns `array`.\n     * @example\n     *\n     * var array = ['a', 'b', 'c', 'a', 'b', 'c'];\n     *\n     * _.pullAll(array, ['a', 'c']);\n     * console.log(array);\n     * // => ['b', 'b']\n     */\n    function pullAll(array, values) {\n      return (array && array.length && values && values.length)\n        ? basePullAll(array, values)\n        : array;\n    }\n\n    /**\n     * This method is like `_.pullAll` except that it accepts `iteratee` which is\n     * invoked for each element of `array` and `values` to generate the criterion\n     * by which they're compared. The iteratee is invoked with one argument: (value).\n     *\n     * **Note:** Unlike `_.differenceBy`, this method mutates `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to modify.\n     * @param {Array} values The values to remove.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {Array} Returns `array`.\n     * @example\n     *\n     * var array = [{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'x': 1 }];\n     *\n     * _.pullAllBy(array, [{ 'x': 1 }, { 'x': 3 }], 'x');\n     * console.log(array);\n     * // => [{ 'x': 2 }]\n     */\n    function pullAllBy(array, values, iteratee) {\n      return (array && array.length && values && values.length)\n        ? basePullAll(array, values, getIteratee(iteratee, 2))\n        : array;\n    }\n\n    /**\n     * This method is like `_.pullAll` except that it accepts `comparator` which\n     * is invoked to compare elements of `array` to `values`. The comparator is\n     * invoked with two arguments: (arrVal, othVal).\n     *\n     * **Note:** Unlike `_.differenceWith`, this method mutates `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.6.0\n     * @category Array\n     * @param {Array} array The array to modify.\n     * @param {Array} values The values to remove.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns `array`.\n     * @example\n     *\n     * var array = [{ 'x': 1, 'y': 2 }, { 'x': 3, 'y': 4 }, { 'x': 5, 'y': 6 }];\n     *\n     * _.pullAllWith(array, [{ 'x': 3, 'y': 4 }], _.isEqual);\n     * console.log(array);\n     * // => [{ 'x': 1, 'y': 2 }, { 'x': 5, 'y': 6 }]\n     */\n    function pullAllWith(array, values, comparator) {\n      return (array && array.length && values && values.length)\n        ? basePullAll(array, values, undefined, comparator)\n        : array;\n    }\n\n    /**\n     * Removes elements from `array` corresponding to `indexes` and returns an\n     * array of removed elements.\n     *\n     * **Note:** Unlike `_.at`, this method mutates `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The array to modify.\n     * @param {...(number|number[])} [indexes] The indexes of elements to remove.\n     * @returns {Array} Returns the new array of removed elements.\n     * @example\n     *\n     * var array = ['a', 'b', 'c', 'd'];\n     * var pulled = _.pullAt(array, [1, 3]);\n     *\n     * console.log(array);\n     * // => ['a', 'c']\n     *\n     * console.log(pulled);\n     * // => ['b', 'd']\n     */\n    var pullAt = flatRest(function(array, indexes) {\n      var length = array == null ? 0 : array.length,\n          result = baseAt(array, indexes);\n\n      basePullAt(array, arrayMap(indexes, function(index) {\n        return isIndex(index, length) ? +index : index;\n      }).sort(compareAscending));\n\n      return result;\n    });\n\n    /**\n     * Removes all elements from `array` that `predicate` returns truthy for\n     * and returns an array of the removed elements. The predicate is invoked\n     * with three arguments: (value, index, array).\n     *\n     * **Note:** Unlike `_.filter`, this method mutates `array`. Use `_.pull`\n     * to pull elements from an array by value.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.0.0\n     * @category Array\n     * @param {Array} array The array to modify.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the new array of removed elements.\n     * @example\n     *\n     * var array = [1, 2, 3, 4];\n     * var evens = _.remove(array, function(n) {\n     *   return n % 2 == 0;\n     * });\n     *\n     * console.log(array);\n     * // => [1, 3]\n     *\n     * console.log(evens);\n     * // => [2, 4]\n     */\n    function remove(array, predicate) {\n      var result = [];\n      if (!(array && array.length)) {\n        return result;\n      }\n      var index = -1,\n          indexes = [],\n          length = array.length;\n\n      predicate = getIteratee(predicate, 3);\n      while (++index < length) {\n        var value = array[index];\n        if (predicate(value, index, array)) {\n          result.push(value);\n          indexes.push(index);\n        }\n      }\n      basePullAt(array, indexes);\n      return result;\n    }\n\n    /**\n     * Reverses `array` so that the first element becomes the last, the second\n     * element becomes the second to last, and so on.\n     *\n     * **Note:** This method mutates `array` and is based on\n     * [`Array#reverse`](https://mdn.io/Array/reverse).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to modify.\n     * @returns {Array} Returns `array`.\n     * @example\n     *\n     * var array = [1, 2, 3];\n     *\n     * _.reverse(array);\n     * // => [3, 2, 1]\n     *\n     * console.log(array);\n     * // => [3, 2, 1]\n     */\n    function reverse(array) {\n      return array == null ? array : nativeReverse.call(array);\n    }\n\n    /**\n     * Creates a slice of `array` from `start` up to, but not including, `end`.\n     *\n     * **Note:** This method is used instead of\n     * [`Array#slice`](https://mdn.io/Array/slice) to ensure dense arrays are\n     * returned.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The array to slice.\n     * @param {number} [start=0] The start position.\n     * @param {number} [end=array.length] The end position.\n     * @returns {Array} Returns the slice of `array`.\n     */\n    function slice(array, start, end) {\n      var length = array == null ? 0 : array.length;\n      if (!length) {\n        return [];\n      }\n      if (end && typeof end != 'number' && isIterateeCall(array, start, end)) {\n        start = 0;\n        end = length;\n      }\n      else {\n        start = start == null ? 0 : toInteger(start);\n        end = end === undefined ? length : toInteger(end);\n      }\n      return baseSlice(array, start, end);\n    }\n\n    /**\n     * Uses a binary search to determine the lowest index at which `value`\n     * should be inserted into `array` in order to maintain its sort order.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The sorted array to inspect.\n     * @param {*} value The value to evaluate.\n     * @returns {number} Returns the index at which `value` should be inserted\n     *  into `array`.\n     * @example\n     *\n     * _.sortedIndex([30, 50], 40);\n     * // => 1\n     */\n    function sortedIndex(array, value) {\n      return baseSortedIndex(array, value);\n    }\n\n    /**\n     * This method is like `_.sortedIndex` except that it accepts `iteratee`\n     * which is invoked for `value` and each element of `array` to compute their\n     * sort ranking. The iteratee is invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The sorted array to inspect.\n     * @param {*} value The value to evaluate.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {number} Returns the index at which `value` should be inserted\n     *  into `array`.\n     * @example\n     *\n     * var objects = [{ 'x': 4 }, { 'x': 5 }];\n     *\n     * _.sortedIndexBy(objects, { 'x': 4 }, function(o) { return o.x; });\n     * // => 0\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.sortedIndexBy(objects, { 'x': 4 }, 'x');\n     * // => 0\n     */\n    function sortedIndexBy(array, value, iteratee) {\n      return baseSortedIndexBy(array, value, getIteratee(iteratee, 2));\n    }\n\n    /**\n     * This method is like `_.indexOf` except that it performs a binary\n     * search on a sorted `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {*} value The value to search for.\n     * @returns {number} Returns the index of the matched value, else `-1`.\n     * @example\n     *\n     * _.sortedIndexOf([4, 5, 5, 5, 6], 5);\n     * // => 1\n     */\n    function sortedIndexOf(array, value) {\n      var length = array == null ? 0 : array.length;\n      if (length) {\n        var index = baseSortedIndex(array, value);\n        if (index < length && eq(array[index], value)) {\n          return index;\n        }\n      }\n      return -1;\n    }\n\n    /**\n     * This method is like `_.sortedIndex` except that it returns the highest\n     * index at which `value` should be inserted into `array` in order to\n     * maintain its sort order.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The sorted array to inspect.\n     * @param {*} value The value to evaluate.\n     * @returns {number} Returns the index at which `value` should be inserted\n     *  into `array`.\n     * @example\n     *\n     * _.sortedLastIndex([4, 5, 5, 5, 6], 5);\n     * // => 4\n     */\n    function sortedLastIndex(array, value) {\n      return baseSortedIndex(array, value, true);\n    }\n\n    /**\n     * This method is like `_.sortedLastIndex` except that it accepts `iteratee`\n     * which is invoked for `value` and each element of `array` to compute their\n     * sort ranking. The iteratee is invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The sorted array to inspect.\n     * @param {*} value The value to evaluate.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {number} Returns the index at which `value` should be inserted\n     *  into `array`.\n     * @example\n     *\n     * var objects = [{ 'x': 4 }, { 'x': 5 }];\n     *\n     * _.sortedLastIndexBy(objects, { 'x': 4 }, function(o) { return o.x; });\n     * // => 1\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.sortedLastIndexBy(objects, { 'x': 4 }, 'x');\n     * // => 1\n     */\n    function sortedLastIndexBy(array, value, iteratee) {\n      return baseSortedIndexBy(array, value, getIteratee(iteratee, 2), true);\n    }\n\n    /**\n     * This method is like `_.lastIndexOf` except that it performs a binary\n     * search on a sorted `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {*} value The value to search for.\n     * @returns {number} Returns the index of the matched value, else `-1`.\n     * @example\n     *\n     * _.sortedLastIndexOf([4, 5, 5, 5, 6], 5);\n     * // => 3\n     */\n    function sortedLastIndexOf(array, value) {\n      var length = array == null ? 0 : array.length;\n      if (length) {\n        var index = baseSortedIndex(array, value, true) - 1;\n        if (eq(array[index], value)) {\n          return index;\n        }\n      }\n      return -1;\n    }\n\n    /**\n     * This method is like `_.uniq` except that it's designed and optimized\n     * for sorted arrays.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @returns {Array} Returns the new duplicate free array.\n     * @example\n     *\n     * _.sortedUniq([1, 1, 2]);\n     * // => [1, 2]\n     */\n    function sortedUniq(array) {\n      return (array && array.length)\n        ? baseSortedUniq(array)\n        : [];\n    }\n\n    /**\n     * This method is like `_.uniqBy` except that it's designed and optimized\n     * for sorted arrays.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {Function} [iteratee] The iteratee invoked per element.\n     * @returns {Array} Returns the new duplicate free array.\n     * @example\n     *\n     * _.sortedUniqBy([1.1, 1.2, 2.3, 2.4], Math.floor);\n     * // => [1.1, 2.3]\n     */\n    function sortedUniqBy(array, iteratee) {\n      return (array && array.length)\n        ? baseSortedUniq(array, getIteratee(iteratee, 2))\n        : [];\n    }\n\n    /**\n     * Gets all but the first element of `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * _.tail([1, 2, 3]);\n     * // => [2, 3]\n     */\n    function tail(array) {\n      var length = array == null ? 0 : array.length;\n      return length ? baseSlice(array, 1, length) : [];\n    }\n\n    /**\n     * Creates a slice of `array` with `n` elements taken from the beginning.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {number} [n=1] The number of elements to take.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * _.take([1, 2, 3]);\n     * // => [1]\n     *\n     * _.take([1, 2, 3], 2);\n     * // => [1, 2]\n     *\n     * _.take([1, 2, 3], 5);\n     * // => [1, 2, 3]\n     *\n     * _.take([1, 2, 3], 0);\n     * // => []\n     */\n    function take(array, n, guard) {\n      if (!(array && array.length)) {\n        return [];\n      }\n      n = (guard || n === undefined) ? 1 : toInteger(n);\n      return baseSlice(array, 0, n < 0 ? 0 : n);\n    }\n\n    /**\n     * Creates a slice of `array` with `n` elements taken from the end.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {number} [n=1] The number of elements to take.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * _.takeRight([1, 2, 3]);\n     * // => [3]\n     *\n     * _.takeRight([1, 2, 3], 2);\n     * // => [2, 3]\n     *\n     * _.takeRight([1, 2, 3], 5);\n     * // => [1, 2, 3]\n     *\n     * _.takeRight([1, 2, 3], 0);\n     * // => []\n     */\n    function takeRight(array, n, guard) {\n      var length = array == null ? 0 : array.length;\n      if (!length) {\n        return [];\n      }\n      n = (guard || n === undefined) ? 1 : toInteger(n);\n      n = length - n;\n      return baseSlice(array, n < 0 ? 0 : n, length);\n    }\n\n    /**\n     * Creates a slice of `array` with elements taken from the end. Elements are\n     * taken until `predicate` returns falsey. The predicate is invoked with\n     * three arguments: (value, index, array).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney',  'active': true },\n     *   { 'user': 'fred',    'active': false },\n     *   { 'user': 'pebbles', 'active': false }\n     * ];\n     *\n     * _.takeRightWhile(users, function(o) { return !o.active; });\n     * // => objects for ['fred', 'pebbles']\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.takeRightWhile(users, { 'user': 'pebbles', 'active': false });\n     * // => objects for ['pebbles']\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.takeRightWhile(users, ['active', false]);\n     * // => objects for ['fred', 'pebbles']\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.takeRightWhile(users, 'active');\n     * // => []\n     */\n    function takeRightWhile(array, predicate) {\n      return (array && array.length)\n        ? baseWhile(array, getIteratee(predicate, 3), false, true)\n        : [];\n    }\n\n    /**\n     * Creates a slice of `array` with elements taken from the beginning. Elements\n     * are taken until `predicate` returns falsey. The predicate is invoked with\n     * three arguments: (value, index, array).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney',  'active': false },\n     *   { 'user': 'fred',    'active': false },\n     *   { 'user': 'pebbles', 'active': true }\n     * ];\n     *\n     * _.takeWhile(users, function(o) { return !o.active; });\n     * // => objects for ['barney', 'fred']\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.takeWhile(users, { 'user': 'barney', 'active': false });\n     * // => objects for ['barney']\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.takeWhile(users, ['active', false]);\n     * // => objects for ['barney', 'fred']\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.takeWhile(users, 'active');\n     * // => []\n     */\n    function takeWhile(array, predicate) {\n      return (array && array.length)\n        ? baseWhile(array, getIteratee(predicate, 3))\n        : [];\n    }\n\n    /**\n     * Creates an array of unique values, in order, from all given arrays using\n     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n     * for equality comparisons.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to inspect.\n     * @returns {Array} Returns the new array of combined values.\n     * @example\n     *\n     * _.union([2], [1, 2]);\n     * // => [2, 1]\n     */\n    var union = baseRest(function(arrays) {\n      return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true));\n    });\n\n    /**\n     * This method is like `_.union` except that it accepts `iteratee` which is\n     * invoked for each element of each `arrays` to generate the criterion by\n     * which uniqueness is computed. Result values are chosen from the first\n     * array in which the value occurs. The iteratee is invoked with one argument:\n     * (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to inspect.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {Array} Returns the new array of combined values.\n     * @example\n     *\n     * _.unionBy([2.1], [1.2, 2.3], Math.floor);\n     * // => [2.1, 1.2]\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.unionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');\n     * // => [{ 'x': 1 }, { 'x': 2 }]\n     */\n    var unionBy = baseRest(function(arrays) {\n      var iteratee = last(arrays);\n      if (isArrayLikeObject(iteratee)) {\n        iteratee = undefined;\n      }\n      return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), getIteratee(iteratee, 2));\n    });\n\n    /**\n     * This method is like `_.union` except that it accepts `comparator` which\n     * is invoked to compare elements of `arrays`. Result values are chosen from\n     * the first array in which the value occurs. The comparator is invoked\n     * with two arguments: (arrVal, othVal).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to inspect.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns the new array of combined values.\n     * @example\n     *\n     * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];\n     * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];\n     *\n     * _.unionWith(objects, others, _.isEqual);\n     * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }]\n     */\n    var unionWith = baseRest(function(arrays) {\n      var comparator = last(arrays);\n      comparator = typeof comparator == 'function' ? comparator : undefined;\n      return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), undefined, comparator);\n    });\n\n    /**\n     * Creates a duplicate-free version of an array, using\n     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n     * for equality comparisons, in which only the first occurrence of each element\n     * is kept. The order of result values is determined by the order they occur\n     * in the array.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @returns {Array} Returns the new duplicate free array.\n     * @example\n     *\n     * _.uniq([2, 1, 2]);\n     * // => [2, 1]\n     */\n    function uniq(array) {\n      return (array && array.length) ? baseUniq(array) : [];\n    }\n\n    /**\n     * This method is like `_.uniq` except that it accepts `iteratee` which is\n     * invoked for each element in `array` to generate the criterion by which\n     * uniqueness is computed. The order of result values is determined by the\n     * order they occur in the array. The iteratee is invoked with one argument:\n     * (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {Array} Returns the new duplicate free array.\n     * @example\n     *\n     * _.uniqBy([2.1, 1.2, 2.3], Math.floor);\n     * // => [2.1, 1.2]\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.uniqBy([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');\n     * // => [{ 'x': 1 }, { 'x': 2 }]\n     */\n    function uniqBy(array, iteratee) {\n      return (array && array.length) ? baseUniq(array, getIteratee(iteratee, 2)) : [];\n    }\n\n    /**\n     * This method is like `_.uniq` except that it accepts `comparator` which\n     * is invoked to compare elements of `array`. The order of result values is\n     * determined by the order they occur in the array.The comparator is invoked\n     * with two arguments: (arrVal, othVal).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns the new duplicate free array.\n     * @example\n     *\n     * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }];\n     *\n     * _.uniqWith(objects, _.isEqual);\n     * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]\n     */\n    function uniqWith(array, comparator) {\n      comparator = typeof comparator == 'function' ? comparator : undefined;\n      return (array && array.length) ? baseUniq(array, undefined, comparator) : [];\n    }\n\n    /**\n     * This method is like `_.zip` except that it accepts an array of grouped\n     * elements and creates an array regrouping the elements to their pre-zip\n     * configuration.\n     *\n     * @static\n     * @memberOf _\n     * @since 1.2.0\n     * @category Array\n     * @param {Array} array The array of grouped elements to process.\n     * @returns {Array} Returns the new array of regrouped elements.\n     * @example\n     *\n     * var zipped = _.zip(['a', 'b'], [1, 2], [true, false]);\n     * // => [['a', 1, true], ['b', 2, false]]\n     *\n     * _.unzip(zipped);\n     * // => [['a', 'b'], [1, 2], [true, false]]\n     */\n    function unzip(array) {\n      if (!(array && array.length)) {\n        return [];\n      }\n      var length = 0;\n      array = arrayFilter(array, function(group) {\n        if (isArrayLikeObject(group)) {\n          length = nativeMax(group.length, length);\n          return true;\n        }\n      });\n      return baseTimes(length, function(index) {\n        return arrayMap(array, baseProperty(index));\n      });\n    }\n\n    /**\n     * This method is like `_.unzip` except that it accepts `iteratee` to specify\n     * how regrouped values should be combined. The iteratee is invoked with the\n     * elements of each group: (...group).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.8.0\n     * @category Array\n     * @param {Array} array The array of grouped elements to process.\n     * @param {Function} [iteratee=_.identity] The function to combine\n     *  regrouped values.\n     * @returns {Array} Returns the new array of regrouped elements.\n     * @example\n     *\n     * var zipped = _.zip([1, 2], [10, 20], [100, 200]);\n     * // => [[1, 10, 100], [2, 20, 200]]\n     *\n     * _.unzipWith(zipped, _.add);\n     * // => [3, 30, 300]\n     */\n    function unzipWith(array, iteratee) {\n      if (!(array && array.length)) {\n        return [];\n      }\n      var result = unzip(array);\n      if (iteratee == null) {\n        return result;\n      }\n      return arrayMap(result, function(group) {\n        return apply(iteratee, undefined, group);\n      });\n    }\n\n    /**\n     * Creates an array excluding all given values using\n     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n     * for equality comparisons.\n     *\n     * **Note:** Unlike `_.pull`, this method returns a new array.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {...*} [values] The values to exclude.\n     * @returns {Array} Returns the new array of filtered values.\n     * @see _.difference, _.xor\n     * @example\n     *\n     * _.without([2, 1, 2, 3], 1, 2);\n     * // => [3]\n     */\n    var without = baseRest(function(array, values) {\n      return isArrayLikeObject(array)\n        ? baseDifference(array, values)\n        : [];\n    });\n\n    /**\n     * Creates an array of unique values that is the\n     * [symmetric difference](https://en.wikipedia.org/wiki/Symmetric_difference)\n     * of the given arrays. The order of result values is determined by the order\n     * they occur in the arrays.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.4.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to inspect.\n     * @returns {Array} Returns the new array of filtered values.\n     * @see _.difference, _.without\n     * @example\n     *\n     * _.xor([2, 1], [2, 3]);\n     * // => [1, 3]\n     */\n    var xor = baseRest(function(arrays) {\n      return baseXor(arrayFilter(arrays, isArrayLikeObject));\n    });\n\n    /**\n     * This method is like `_.xor` except that it accepts `iteratee` which is\n     * invoked for each element of each `arrays` to generate the criterion by\n     * which by which they're compared. The order of result values is determined\n     * by the order they occur in the arrays. The iteratee is invoked with one\n     * argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to inspect.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {Array} Returns the new array of filtered values.\n     * @example\n     *\n     * _.xorBy([2.1, 1.2], [2.3, 3.4], Math.floor);\n     * // => [1.2, 3.4]\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.xorBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');\n     * // => [{ 'x': 2 }]\n     */\n    var xorBy = baseRest(function(arrays) {\n      var iteratee = last(arrays);\n      if (isArrayLikeObject(iteratee)) {\n        iteratee = undefined;\n      }\n      return baseXor(arrayFilter(arrays, isArrayLikeObject), getIteratee(iteratee, 2));\n    });\n\n    /**\n     * This method is like `_.xor` except that it accepts `comparator` which is\n     * invoked to compare elements of `arrays`. The order of result values is\n     * determined by the order they occur in the arrays. The comparator is invoked\n     * with two arguments: (arrVal, othVal).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to inspect.\n     * @param {Function} [comparator] The comparator invoked per element.\n     * @returns {Array} Returns the new array of filtered values.\n     * @example\n     *\n     * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];\n     * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];\n     *\n     * _.xorWith(objects, others, _.isEqual);\n     * // => [{ 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }]\n     */\n    var xorWith = baseRest(function(arrays) {\n      var comparator = last(arrays);\n      comparator = typeof comparator == 'function' ? comparator : undefined;\n      return baseXor(arrayFilter(arrays, isArrayLikeObject), undefined, comparator);\n    });\n\n    /**\n     * Creates an array of grouped elements, the first of which contains the\n     * first elements of the given arrays, the second of which contains the\n     * second elements of the given arrays, and so on.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to process.\n     * @returns {Array} Returns the new array of grouped elements.\n     * @example\n     *\n     * _.zip(['a', 'b'], [1, 2], [true, false]);\n     * // => [['a', 1, true], ['b', 2, false]]\n     */\n    var zip = baseRest(unzip);\n\n    /**\n     * This method is like `_.fromPairs` except that it accepts two arrays,\n     * one of property identifiers and one of corresponding values.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.4.0\n     * @category Array\n     * @param {Array} [props=[]] The property identifiers.\n     * @param {Array} [values=[]] The property values.\n     * @returns {Object} Returns the new object.\n     * @example\n     *\n     * _.zipObject(['a', 'b'], [1, 2]);\n     * // => { 'a': 1, 'b': 2 }\n     */\n    function zipObject(props, values) {\n      return baseZipObject(props || [], values || [], assignValue);\n    }\n\n    /**\n     * This method is like `_.zipObject` except that it supports property paths.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.1.0\n     * @category Array\n     * @param {Array} [props=[]] The property identifiers.\n     * @param {Array} [values=[]] The property values.\n     * @returns {Object} Returns the new object.\n     * @example\n     *\n     * _.zipObjectDeep(['a.b[0].c', 'a.b[1].d'], [1, 2]);\n     * // => { 'a': { 'b': [{ 'c': 1 }, { 'd': 2 }] } }\n     */\n    function zipObjectDeep(props, values) {\n      return baseZipObject(props || [], values || [], baseSet);\n    }\n\n    /**\n     * This method is like `_.zip` except that it accepts `iteratee` to specify\n     * how grouped values should be combined. The iteratee is invoked with the\n     * elements of each group: (...group).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.8.0\n     * @category Array\n     * @param {...Array} [arrays] The arrays to process.\n     * @param {Function} [iteratee=_.identity] The function to combine\n     *  grouped values.\n     * @returns {Array} Returns the new array of grouped elements.\n     * @example\n     *\n     * _.zipWith([1, 2], [10, 20], [100, 200], function(a, b, c) {\n     *   return a + b + c;\n     * });\n     * // => [111, 222]\n     */\n    var zipWith = baseRest(function(arrays) {\n      var length = arrays.length,\n          iteratee = length > 1 ? arrays[length - 1] : undefined;\n\n      iteratee = typeof iteratee == 'function' ? (arrays.pop(), iteratee) : undefined;\n      return unzipWith(arrays, iteratee);\n    });\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates a `lodash` wrapper instance that wraps `value` with explicit method\n     * chain sequences enabled. The result of such sequences must be unwrapped\n     * with `_#value`.\n     *\n     * @static\n     * @memberOf _\n     * @since 1.3.0\n     * @category Seq\n     * @param {*} value The value to wrap.\n     * @returns {Object} Returns the new `lodash` wrapper instance.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney',  'age': 36 },\n     *   { 'user': 'fred',    'age': 40 },\n     *   { 'user': 'pebbles', 'age': 1 }\n     * ];\n     *\n     * var youngest = _\n     *   .chain(users)\n     *   .sortBy('age')\n     *   .map(function(o) {\n     *     return o.user + ' is ' + o.age;\n     *   })\n     *   .head()\n     *   .value();\n     * // => 'pebbles is 1'\n     */\n    function chain(value) {\n      var result = lodash(value);\n      result.__chain__ = true;\n      return result;\n    }\n\n    /**\n     * This method invokes `interceptor` and returns `value`. The interceptor\n     * is invoked with one argument; (value). The purpose of this method is to\n     * \"tap into\" a method chain sequence in order to modify intermediate results.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Seq\n     * @param {*} value The value to provide to `interceptor`.\n     * @param {Function} interceptor The function to invoke.\n     * @returns {*} Returns `value`.\n     * @example\n     *\n     * _([1, 2, 3])\n     *  .tap(function(array) {\n     *    // Mutate input array.\n     *    array.pop();\n     *  })\n     *  .reverse()\n     *  .value();\n     * // => [2, 1]\n     */\n    function tap(value, interceptor) {\n      interceptor(value);\n      return value;\n    }\n\n    /**\n     * This method is like `_.tap` except that it returns the result of `interceptor`.\n     * The purpose of this method is to \"pass thru\" values replacing intermediate\n     * results in a method chain sequence.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Seq\n     * @param {*} value The value to provide to `interceptor`.\n     * @param {Function} interceptor The function to invoke.\n     * @returns {*} Returns the result of `interceptor`.\n     * @example\n     *\n     * _('  abc  ')\n     *  .chain()\n     *  .trim()\n     *  .thru(function(value) {\n     *    return [value];\n     *  })\n     *  .value();\n     * // => ['abc']\n     */\n    function thru(value, interceptor) {\n      return interceptor(value);\n    }\n\n    /**\n     * This method is the wrapper version of `_.at`.\n     *\n     * @name at\n     * @memberOf _\n     * @since 1.0.0\n     * @category Seq\n     * @param {...(string|string[])} [paths] The property paths to pick.\n     * @returns {Object} Returns the new `lodash` wrapper instance.\n     * @example\n     *\n     * var object = { 'a': [{ 'b': { 'c': 3 } }, 4] };\n     *\n     * _(object).at(['a[0].b.c', 'a[1]']).value();\n     * // => [3, 4]\n     */\n    var wrapperAt = flatRest(function(paths) {\n      var length = paths.length,\n          start = length ? paths[0] : 0,\n          value = this.__wrapped__,\n          interceptor = function(object) { return baseAt(object, paths); };\n\n      if (length > 1 || this.__actions__.length ||\n          !(value instanceof LazyWrapper) || !isIndex(start)) {\n        return this.thru(interceptor);\n      }\n      value = value.slice(start, +start + (length ? 1 : 0));\n      value.__actions__.push({\n        'func': thru,\n        'args': [interceptor],\n        'thisArg': undefined\n      });\n      return new LodashWrapper(value, this.__chain__).thru(function(array) {\n        if (length && !array.length) {\n          array.push(undefined);\n        }\n        return array;\n      });\n    });\n\n    /**\n     * Creates a `lodash` wrapper instance with explicit method chain sequences enabled.\n     *\n     * @name chain\n     * @memberOf _\n     * @since 0.1.0\n     * @category Seq\n     * @returns {Object} Returns the new `lodash` wrapper instance.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney', 'age': 36 },\n     *   { 'user': 'fred',   'age': 40 }\n     * ];\n     *\n     * // A sequence without explicit chaining.\n     * _(users).head();\n     * // => { 'user': 'barney', 'age': 36 }\n     *\n     * // A sequence with explicit chaining.\n     * _(users)\n     *   .chain()\n     *   .head()\n     *   .pick('user')\n     *   .value();\n     * // => { 'user': 'barney' }\n     */\n    function wrapperChain() {\n      return chain(this);\n    }\n\n    /**\n     * Executes the chain sequence and returns the wrapped result.\n     *\n     * @name commit\n     * @memberOf _\n     * @since 3.2.0\n     * @category Seq\n     * @returns {Object} Returns the new `lodash` wrapper instance.\n     * @example\n     *\n     * var array = [1, 2];\n     * var wrapped = _(array).push(3);\n     *\n     * console.log(array);\n     * // => [1, 2]\n     *\n     * wrapped = wrapped.commit();\n     * console.log(array);\n     * // => [1, 2, 3]\n     *\n     * wrapped.last();\n     * // => 3\n     *\n     * console.log(array);\n     * // => [1, 2, 3]\n     */\n    function wrapperCommit() {\n      return new LodashWrapper(this.value(), this.__chain__);\n    }\n\n    /**\n     * Gets the next value on a wrapped object following the\n     * [iterator protocol](https://mdn.io/iteration_protocols#iterator).\n     *\n     * @name next\n     * @memberOf _\n     * @since 4.0.0\n     * @category Seq\n     * @returns {Object} Returns the next iterator value.\n     * @example\n     *\n     * var wrapped = _([1, 2]);\n     *\n     * wrapped.next();\n     * // => { 'done': false, 'value': 1 }\n     *\n     * wrapped.next();\n     * // => { 'done': false, 'value': 2 }\n     *\n     * wrapped.next();\n     * // => { 'done': true, 'value': undefined }\n     */\n    function wrapperNext() {\n      if (this.__values__ === undefined) {\n        this.__values__ = toArray(this.value());\n      }\n      var done = this.__index__ >= this.__values__.length,\n          value = done ? undefined : this.__values__[this.__index__++];\n\n      return { 'done': done, 'value': value };\n    }\n\n    /**\n     * Enables the wrapper to be iterable.\n     *\n     * @name Symbol.iterator\n     * @memberOf _\n     * @since 4.0.0\n     * @category Seq\n     * @returns {Object} Returns the wrapper object.\n     * @example\n     *\n     * var wrapped = _([1, 2]);\n     *\n     * wrapped[Symbol.iterator]() === wrapped;\n     * // => true\n     *\n     * Array.from(wrapped);\n     * // => [1, 2]\n     */\n    function wrapperToIterator() {\n      return this;\n    }\n\n    /**\n     * Creates a clone of the chain sequence planting `value` as the wrapped value.\n     *\n     * @name plant\n     * @memberOf _\n     * @since 3.2.0\n     * @category Seq\n     * @param {*} value The value to plant.\n     * @returns {Object} Returns the new `lodash` wrapper instance.\n     * @example\n     *\n     * function square(n) {\n     *   return n * n;\n     * }\n     *\n     * var wrapped = _([1, 2]).map(square);\n     * var other = wrapped.plant([3, 4]);\n     *\n     * other.value();\n     * // => [9, 16]\n     *\n     * wrapped.value();\n     * // => [1, 4]\n     */\n    function wrapperPlant(value) {\n      var result,\n          parent = this;\n\n      while (parent instanceof baseLodash) {\n        var clone = wrapperClone(parent);\n        clone.__index__ = 0;\n        clone.__values__ = undefined;\n        if (result) {\n          previous.__wrapped__ = clone;\n        } else {\n          result = clone;\n        }\n        var previous = clone;\n        parent = parent.__wrapped__;\n      }\n      previous.__wrapped__ = value;\n      return result;\n    }\n\n    /**\n     * This method is the wrapper version of `_.reverse`.\n     *\n     * **Note:** This method mutates the wrapped array.\n     *\n     * @name reverse\n     * @memberOf _\n     * @since 0.1.0\n     * @category Seq\n     * @returns {Object} Returns the new `lodash` wrapper instance.\n     * @example\n     *\n     * var array = [1, 2, 3];\n     *\n     * _(array).reverse().value()\n     * // => [3, 2, 1]\n     *\n     * console.log(array);\n     * // => [3, 2, 1]\n     */\n    function wrapperReverse() {\n      var value = this.__wrapped__;\n      if (value instanceof LazyWrapper) {\n        var wrapped = value;\n        if (this.__actions__.length) {\n          wrapped = new LazyWrapper(this);\n        }\n        wrapped = wrapped.reverse();\n        wrapped.__actions__.push({\n          'func': thru,\n          'args': [reverse],\n          'thisArg': undefined\n        });\n        return new LodashWrapper(wrapped, this.__chain__);\n      }\n      return this.thru(reverse);\n    }\n\n    /**\n     * Executes the chain sequence to resolve the unwrapped value.\n     *\n     * @name value\n     * @memberOf _\n     * @since 0.1.0\n     * @alias toJSON, valueOf\n     * @category Seq\n     * @returns {*} Returns the resolved unwrapped value.\n     * @example\n     *\n     * _([1, 2, 3]).value();\n     * // => [1, 2, 3]\n     */\n    function wrapperValue() {\n      return baseWrapperValue(this.__wrapped__, this.__actions__);\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates an object composed of keys generated from the results of running\n     * each element of `collection` thru `iteratee`. The corresponding value of\n     * each key is the number of times the key was returned by `iteratee`. The\n     * iteratee is invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 0.5.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The iteratee to transform keys.\n     * @returns {Object} Returns the composed aggregate object.\n     * @example\n     *\n     * _.countBy([6.1, 4.2, 6.3], Math.floor);\n     * // => { '4': 1, '6': 2 }\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.countBy(['one', 'two', 'three'], 'length');\n     * // => { '3': 2, '5': 1 }\n     */\n    var countBy = createAggregator(function(result, value, key) {\n      if (hasOwnProperty.call(result, key)) {\n        ++result[key];\n      } else {\n        baseAssignValue(result, key, 1);\n      }\n    });\n\n    /**\n     * Checks if `predicate` returns truthy for **all** elements of `collection`.\n     * Iteration is stopped once `predicate` returns falsey. The predicate is\n     * invoked with three arguments: (value, index|key, collection).\n     *\n     * **Note:** This method returns `true` for\n     * [empty collections](https://en.wikipedia.org/wiki/Empty_set) because\n     * [everything is true](https://en.wikipedia.org/wiki/Vacuous_truth) of\n     * elements of empty collections.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {boolean} Returns `true` if all elements pass the predicate check,\n     *  else `false`.\n     * @example\n     *\n     * _.every([true, 1, null, 'yes'], Boolean);\n     * // => false\n     *\n     * var users = [\n     *   { 'user': 'barney', 'age': 36, 'active': false },\n     *   { 'user': 'fred',   'age': 40, 'active': false }\n     * ];\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.every(users, { 'user': 'barney', 'active': false });\n     * // => false\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.every(users, ['active', false]);\n     * // => true\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.every(users, 'active');\n     * // => false\n     */\n    function every(collection, predicate, guard) {\n      var func = isArray(collection) ? arrayEvery : baseEvery;\n      if (guard && isIterateeCall(collection, predicate, guard)) {\n        predicate = undefined;\n      }\n      return func(collection, getIteratee(predicate, 3));\n    }\n\n    /**\n     * Iterates over elements of `collection`, returning an array of all elements\n     * `predicate` returns truthy for. The predicate is invoked with three\n     * arguments: (value, index|key, collection).\n     *\n     * **Note:** Unlike `_.remove`, this method returns a new array.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the new filtered array.\n     * @see _.reject\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney', 'age': 36, 'active': true },\n     *   { 'user': 'fred',   'age': 40, 'active': false }\n     * ];\n     *\n     * _.filter(users, function(o) { return !o.active; });\n     * // => objects for ['fred']\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.filter(users, { 'age': 36, 'active': true });\n     * // => objects for ['barney']\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.filter(users, ['active', false]);\n     * // => objects for ['fred']\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.filter(users, 'active');\n     * // => objects for ['barney']\n     *\n     * // Combining several predicates using `_.overEvery` or `_.overSome`.\n     * _.filter(users, _.overSome([{ 'age': 36 }, ['age', 40]]));\n     * // => objects for ['fred', 'barney']\n     */\n    function filter(collection, predicate) {\n      var func = isArray(collection) ? arrayFilter : baseFilter;\n      return func(collection, getIteratee(predicate, 3));\n    }\n\n    /**\n     * Iterates over elements of `collection`, returning the first element\n     * `predicate` returns truthy for. The predicate is invoked with three\n     * arguments: (value, index|key, collection).\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to inspect.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @param {number} [fromIndex=0] The index to search from.\n     * @returns {*} Returns the matched element, else `undefined`.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney',  'age': 36, 'active': true },\n     *   { 'user': 'fred',    'age': 40, 'active': false },\n     *   { 'user': 'pebbles', 'age': 1,  'active': true }\n     * ];\n     *\n     * _.find(users, function(o) { return o.age < 40; });\n     * // => object for 'barney'\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.find(users, { 'age': 1, 'active': true });\n     * // => object for 'pebbles'\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.find(users, ['active', false]);\n     * // => object for 'fred'\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.find(users, 'active');\n     * // => object for 'barney'\n     */\n    var find = createFind(findIndex);\n\n    /**\n     * This method is like `_.find` except that it iterates over elements of\n     * `collection` from right to left.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.0.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to inspect.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @param {number} [fromIndex=collection.length-1] The index to search from.\n     * @returns {*} Returns the matched element, else `undefined`.\n     * @example\n     *\n     * _.findLast([1, 2, 3, 4], function(n) {\n     *   return n % 2 == 1;\n     * });\n     * // => 3\n     */\n    var findLast = createFind(findLastIndex);\n\n    /**\n     * Creates a flattened array of values by running each element in `collection`\n     * thru `iteratee` and flattening the mapped results. The iteratee is invoked\n     * with three arguments: (value, index|key, collection).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the new flattened array.\n     * @example\n     *\n     * function duplicate(n) {\n     *   return [n, n];\n     * }\n     *\n     * _.flatMap([1, 2], duplicate);\n     * // => [1, 1, 2, 2]\n     */\n    function flatMap(collection, iteratee) {\n      return baseFlatten(map(collection, iteratee), 1);\n    }\n\n    /**\n     * This method is like `_.flatMap` except that it recursively flattens the\n     * mapped results.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.7.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the new flattened array.\n     * @example\n     *\n     * function duplicate(n) {\n     *   return [[[n, n]]];\n     * }\n     *\n     * _.flatMapDeep([1, 2], duplicate);\n     * // => [1, 1, 2, 2]\n     */\n    function flatMapDeep(collection, iteratee) {\n      return baseFlatten(map(collection, iteratee), INFINITY);\n    }\n\n    /**\n     * This method is like `_.flatMap` except that it recursively flattens the\n     * mapped results up to `depth` times.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.7.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @param {number} [depth=1] The maximum recursion depth.\n     * @returns {Array} Returns the new flattened array.\n     * @example\n     *\n     * function duplicate(n) {\n     *   return [[[n, n]]];\n     * }\n     *\n     * _.flatMapDepth([1, 2], duplicate, 2);\n     * // => [[1, 1], [2, 2]]\n     */\n    function flatMapDepth(collection, iteratee, depth) {\n      depth = depth === undefined ? 1 : toInteger(depth);\n      return baseFlatten(map(collection, iteratee), depth);\n    }\n\n    /**\n     * Iterates over elements of `collection` and invokes `iteratee` for each element.\n     * The iteratee is invoked with three arguments: (value, index|key, collection).\n     * Iteratee functions may exit iteration early by explicitly returning `false`.\n     *\n     * **Note:** As with other \"Collections\" methods, objects with a \"length\"\n     * property are iterated like arrays. To avoid this behavior use `_.forIn`\n     * or `_.forOwn` for object iteration.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @alias each\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Array|Object} Returns `collection`.\n     * @see _.forEachRight\n     * @example\n     *\n     * _.forEach([1, 2], function(value) {\n     *   console.log(value);\n     * });\n     * // => Logs `1` then `2`.\n     *\n     * _.forEach({ 'a': 1, 'b': 2 }, function(value, key) {\n     *   console.log(key);\n     * });\n     * // => Logs 'a' then 'b' (iteration order is not guaranteed).\n     */\n    function forEach(collection, iteratee) {\n      var func = isArray(collection) ? arrayEach : baseEach;\n      return func(collection, getIteratee(iteratee, 3));\n    }\n\n    /**\n     * This method is like `_.forEach` except that it iterates over elements of\n     * `collection` from right to left.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.0.0\n     * @alias eachRight\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Array|Object} Returns `collection`.\n     * @see _.forEach\n     * @example\n     *\n     * _.forEachRight([1, 2], function(value) {\n     *   console.log(value);\n     * });\n     * // => Logs `2` then `1`.\n     */\n    function forEachRight(collection, iteratee) {\n      var func = isArray(collection) ? arrayEachRight : baseEachRight;\n      return func(collection, getIteratee(iteratee, 3));\n    }\n\n    /**\n     * Creates an object composed of keys generated from the results of running\n     * each element of `collection` thru `iteratee`. The order of grouped values\n     * is determined by the order they occur in `collection`. The corresponding\n     * value of each key is an array of elements responsible for generating the\n     * key. The iteratee is invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The iteratee to transform keys.\n     * @returns {Object} Returns the composed aggregate object.\n     * @example\n     *\n     * _.groupBy([6.1, 4.2, 6.3], Math.floor);\n     * // => { '4': [4.2], '6': [6.1, 6.3] }\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.groupBy(['one', 'two', 'three'], 'length');\n     * // => { '3': ['one', 'two'], '5': ['three'] }\n     */\n    var groupBy = createAggregator(function(result, value, key) {\n      if (hasOwnProperty.call(result, key)) {\n        result[key].push(value);\n      } else {\n        baseAssignValue(result, key, [value]);\n      }\n    });\n\n    /**\n     * Checks if `value` is in `collection`. If `collection` is a string, it's\n     * checked for a substring of `value`, otherwise\n     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n     * is used for equality comparisons. If `fromIndex` is negative, it's used as\n     * the offset from the end of `collection`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object|string} collection The collection to inspect.\n     * @param {*} value The value to search for.\n     * @param {number} [fromIndex=0] The index to search from.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`.\n     * @returns {boolean} Returns `true` if `value` is found, else `false`.\n     * @example\n     *\n     * _.includes([1, 2, 3], 1);\n     * // => true\n     *\n     * _.includes([1, 2, 3], 1, 2);\n     * // => false\n     *\n     * _.includes({ 'a': 1, 'b': 2 }, 1);\n     * // => true\n     *\n     * _.includes('abcd', 'bc');\n     * // => true\n     */\n    function includes(collection, value, fromIndex, guard) {\n      collection = isArrayLike(collection) ? collection : values(collection);\n      fromIndex = (fromIndex && !guard) ? toInteger(fromIndex) : 0;\n\n      var length = collection.length;\n      if (fromIndex < 0) {\n        fromIndex = nativeMax(length + fromIndex, 0);\n      }\n      return isString(collection)\n        ? (fromIndex <= length && collection.indexOf(value, fromIndex) > -1)\n        : (!!length && baseIndexOf(collection, value, fromIndex) > -1);\n    }\n\n    /**\n     * Invokes the method at `path` of each element in `collection`, returning\n     * an array of the results of each invoked method. Any additional arguments\n     * are provided to each invoked method. If `path` is a function, it's invoked\n     * for, and `this` bound to, each element in `collection`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Array|Function|string} path The path of the method to invoke or\n     *  the function invoked per iteration.\n     * @param {...*} [args] The arguments to invoke each method with.\n     * @returns {Array} Returns the array of results.\n     * @example\n     *\n     * _.invokeMap([[5, 1, 7], [3, 2, 1]], 'sort');\n     * // => [[1, 5, 7], [1, 2, 3]]\n     *\n     * _.invokeMap([123, 456], String.prototype.split, '');\n     * // => [['1', '2', '3'], ['4', '5', '6']]\n     */\n    var invokeMap = baseRest(function(collection, path, args) {\n      var index = -1,\n          isFunc = typeof path == 'function',\n          result = isArrayLike(collection) ? Array(collection.length) : [];\n\n      baseEach(collection, function(value) {\n        result[++index] = isFunc ? apply(path, value, args) : baseInvoke(value, path, args);\n      });\n      return result;\n    });\n\n    /**\n     * Creates an object composed of keys generated from the results of running\n     * each element of `collection` thru `iteratee`. The corresponding value of\n     * each key is the last element responsible for generating the key. The\n     * iteratee is invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The iteratee to transform keys.\n     * @returns {Object} Returns the composed aggregate object.\n     * @example\n     *\n     * var array = [\n     *   { 'dir': 'left', 'code': 97 },\n     *   { 'dir': 'right', 'code': 100 }\n     * ];\n     *\n     * _.keyBy(array, function(o) {\n     *   return String.fromCharCode(o.code);\n     * });\n     * // => { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } }\n     *\n     * _.keyBy(array, 'dir');\n     * // => { 'left': { 'dir': 'left', 'code': 97 }, 'right': { 'dir': 'right', 'code': 100 } }\n     */\n    var keyBy = createAggregator(function(result, value, key) {\n      baseAssignValue(result, key, value);\n    });\n\n    /**\n     * Creates an array of values by running each element in `collection` thru\n     * `iteratee`. The iteratee is invoked with three arguments:\n     * (value, index|key, collection).\n     *\n     * Many lodash methods are guarded to work as iteratees for methods like\n     * `_.every`, `_.filter`, `_.map`, `_.mapValues`, `_.reject`, and `_.some`.\n     *\n     * The guarded methods are:\n     * `ary`, `chunk`, `curry`, `curryRight`, `drop`, `dropRight`, `every`,\n     * `fill`, `invert`, `parseInt`, `random`, `range`, `rangeRight`, `repeat`,\n     * `sampleSize`, `slice`, `some`, `sortBy`, `split`, `take`, `takeRight`,\n     * `template`, `trim`, `trimEnd`, `trimStart`, and `words`\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the new mapped array.\n     * @example\n     *\n     * function square(n) {\n     *   return n * n;\n     * }\n     *\n     * _.map([4, 8], square);\n     * // => [16, 64]\n     *\n     * _.map({ 'a': 4, 'b': 8 }, square);\n     * // => [16, 64] (iteration order is not guaranteed)\n     *\n     * var users = [\n     *   { 'user': 'barney' },\n     *   { 'user': 'fred' }\n     * ];\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.map(users, 'user');\n     * // => ['barney', 'fred']\n     */\n    function map(collection, iteratee) {\n      var func = isArray(collection) ? arrayMap : baseMap;\n      return func(collection, getIteratee(iteratee, 3));\n    }\n\n    /**\n     * This method is like `_.sortBy` except that it allows specifying the sort\n     * orders of the iteratees to sort by. If `orders` is unspecified, all values\n     * are sorted in ascending order. Otherwise, specify an order of \"desc\" for\n     * descending or \"asc\" for ascending sort order of corresponding values.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Array[]|Function[]|Object[]|string[]} [iteratees=[_.identity]]\n     *  The iteratees to sort by.\n     * @param {string[]} [orders] The sort orders of `iteratees`.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`.\n     * @returns {Array} Returns the new sorted array.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'fred',   'age': 48 },\n     *   { 'user': 'barney', 'age': 34 },\n     *   { 'user': 'fred',   'age': 40 },\n     *   { 'user': 'barney', 'age': 36 }\n     * ];\n     *\n     * // Sort by `user` in ascending order and by `age` in descending order.\n     * _.orderBy(users, ['user', 'age'], ['asc', 'desc']);\n     * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]]\n     */\n    function orderBy(collection, iteratees, orders, guard) {\n      if (collection == null) {\n        return [];\n      }\n      if (!isArray(iteratees)) {\n        iteratees = iteratees == null ? [] : [iteratees];\n      }\n      orders = guard ? undefined : orders;\n      if (!isArray(orders)) {\n        orders = orders == null ? [] : [orders];\n      }\n      return baseOrderBy(collection, iteratees, orders);\n    }\n\n    /**\n     * Creates an array of elements split into two groups, the first of which\n     * contains elements `predicate` returns truthy for, the second of which\n     * contains elements `predicate` returns falsey for. The predicate is\n     * invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the array of grouped elements.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney',  'age': 36, 'active': false },\n     *   { 'user': 'fred',    'age': 40, 'active': true },\n     *   { 'user': 'pebbles', 'age': 1,  'active': false }\n     * ];\n     *\n     * _.partition(users, function(o) { return o.active; });\n     * // => objects for [['fred'], ['barney', 'pebbles']]\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.partition(users, { 'age': 1, 'active': false });\n     * // => objects for [['pebbles'], ['barney', 'fred']]\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.partition(users, ['active', false]);\n     * // => objects for [['barney', 'pebbles'], ['fred']]\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.partition(users, 'active');\n     * // => objects for [['fred'], ['barney', 'pebbles']]\n     */\n    var partition = createAggregator(function(result, value, key) {\n      result[key ? 0 : 1].push(value);\n    }, function() { return [[], []]; });\n\n    /**\n     * Reduces `collection` to a value which is the accumulated result of running\n     * each element in `collection` thru `iteratee`, where each successive\n     * invocation is supplied the return value of the previous. If `accumulator`\n     * is not given, the first element of `collection` is used as the initial\n     * value. The iteratee is invoked with four arguments:\n     * (accumulator, value, index|key, collection).\n     *\n     * Many lodash methods are guarded to work as iteratees for methods like\n     * `_.reduce`, `_.reduceRight`, and `_.transform`.\n     *\n     * The guarded methods are:\n     * `assign`, `defaults`, `defaultsDeep`, `includes`, `merge`, `orderBy`,\n     * and `sortBy`\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @param {*} [accumulator] The initial value.\n     * @returns {*} Returns the accumulated value.\n     * @see _.reduceRight\n     * @example\n     *\n     * _.reduce([1, 2], function(sum, n) {\n     *   return sum + n;\n     * }, 0);\n     * // => 3\n     *\n     * _.reduce({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) {\n     *   (result[value] || (result[value] = [])).push(key);\n     *   return result;\n     * }, {});\n     * // => { '1': ['a', 'c'], '2': ['b'] } (iteration order is not guaranteed)\n     */\n    function reduce(collection, iteratee, accumulator) {\n      var func = isArray(collection) ? arrayReduce : baseReduce,\n          initAccum = arguments.length < 3;\n\n      return func(collection, getIteratee(iteratee, 4), accumulator, initAccum, baseEach);\n    }\n\n    /**\n     * This method is like `_.reduce` except that it iterates over elements of\n     * `collection` from right to left.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @param {*} [accumulator] The initial value.\n     * @returns {*} Returns the accumulated value.\n     * @see _.reduce\n     * @example\n     *\n     * var array = [[0, 1], [2, 3], [4, 5]];\n     *\n     * _.reduceRight(array, function(flattened, other) {\n     *   return flattened.concat(other);\n     * }, []);\n     * // => [4, 5, 2, 3, 0, 1]\n     */\n    function reduceRight(collection, iteratee, accumulator) {\n      var func = isArray(collection) ? arrayReduceRight : baseReduce,\n          initAccum = arguments.length < 3;\n\n      return func(collection, getIteratee(iteratee, 4), accumulator, initAccum, baseEachRight);\n    }\n\n    /**\n     * The opposite of `_.filter`; this method returns the elements of `collection`\n     * that `predicate` does **not** return truthy for.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the new filtered array.\n     * @see _.filter\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney', 'age': 36, 'active': false },\n     *   { 'user': 'fred',   'age': 40, 'active': true }\n     * ];\n     *\n     * _.reject(users, function(o) { return !o.active; });\n     * // => objects for ['fred']\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.reject(users, { 'age': 40, 'active': true });\n     * // => objects for ['barney']\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.reject(users, ['active', false]);\n     * // => objects for ['fred']\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.reject(users, 'active');\n     * // => objects for ['barney']\n     */\n    function reject(collection, predicate) {\n      var func = isArray(collection) ? arrayFilter : baseFilter;\n      return func(collection, negate(getIteratee(predicate, 3)));\n    }\n\n    /**\n     * Gets a random element from `collection`.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.0.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to sample.\n     * @returns {*} Returns the random element.\n     * @example\n     *\n     * _.sample([1, 2, 3, 4]);\n     * // => 2\n     */\n    function sample(collection) {\n      var func = isArray(collection) ? arraySample : baseSample;\n      return func(collection);\n    }\n\n    /**\n     * Gets `n` random elements at unique keys from `collection` up to the\n     * size of `collection`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to sample.\n     * @param {number} [n=1] The number of elements to sample.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Array} Returns the random elements.\n     * @example\n     *\n     * _.sampleSize([1, 2, 3], 2);\n     * // => [3, 1]\n     *\n     * _.sampleSize([1, 2, 3], 4);\n     * // => [2, 3, 1]\n     */\n    function sampleSize(collection, n, guard) {\n      if ((guard ? isIterateeCall(collection, n, guard) : n === undefined)) {\n        n = 1;\n      } else {\n        n = toInteger(n);\n      }\n      var func = isArray(collection) ? arraySampleSize : baseSampleSize;\n      return func(collection, n);\n    }\n\n    /**\n     * Creates an array of shuffled values, using a version of the\n     * [Fisher-Yates shuffle](https://en.wikipedia.org/wiki/Fisher-Yates_shuffle).\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to shuffle.\n     * @returns {Array} Returns the new shuffled array.\n     * @example\n     *\n     * _.shuffle([1, 2, 3, 4]);\n     * // => [4, 1, 3, 2]\n     */\n    function shuffle(collection) {\n      var func = isArray(collection) ? arrayShuffle : baseShuffle;\n      return func(collection);\n    }\n\n    /**\n     * Gets the size of `collection` by returning its length for array-like\n     * values or the number of own enumerable string keyed properties for objects.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object|string} collection The collection to inspect.\n     * @returns {number} Returns the collection size.\n     * @example\n     *\n     * _.size([1, 2, 3]);\n     * // => 3\n     *\n     * _.size({ 'a': 1, 'b': 2 });\n     * // => 2\n     *\n     * _.size('pebbles');\n     * // => 7\n     */\n    function size(collection) {\n      if (collection == null) {\n        return 0;\n      }\n      if (isArrayLike(collection)) {\n        return isString(collection) ? stringSize(collection) : collection.length;\n      }\n      var tag = getTag(collection);\n      if (tag == mapTag || tag == setTag) {\n        return collection.size;\n      }\n      return baseKeys(collection).length;\n    }\n\n    /**\n     * Checks if `predicate` returns truthy for **any** element of `collection`.\n     * Iteration is stopped once `predicate` returns truthy. The predicate is\n     * invoked with three arguments: (value, index|key, collection).\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {boolean} Returns `true` if any element passes the predicate check,\n     *  else `false`.\n     * @example\n     *\n     * _.some([null, 0, 'yes', false], Boolean);\n     * // => true\n     *\n     * var users = [\n     *   { 'user': 'barney', 'active': true },\n     *   { 'user': 'fred',   'active': false }\n     * ];\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.some(users, { 'user': 'barney', 'active': false });\n     * // => false\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.some(users, ['active', false]);\n     * // => true\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.some(users, 'active');\n     * // => true\n     */\n    function some(collection, predicate, guard) {\n      var func = isArray(collection) ? arraySome : baseSome;\n      if (guard && isIterateeCall(collection, predicate, guard)) {\n        predicate = undefined;\n      }\n      return func(collection, getIteratee(predicate, 3));\n    }\n\n    /**\n     * Creates an array of elements, sorted in ascending order by the results of\n     * running each element in a collection thru each iteratee. This method\n     * performs a stable sort, that is, it preserves the original sort order of\n     * equal elements. The iteratees are invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Collection\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {...(Function|Function[])} [iteratees=[_.identity]]\n     *  The iteratees to sort by.\n     * @returns {Array} Returns the new sorted array.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'fred',   'age': 48 },\n     *   { 'user': 'barney', 'age': 36 },\n     *   { 'user': 'fred',   'age': 30 },\n     *   { 'user': 'barney', 'age': 34 }\n     * ];\n     *\n     * _.sortBy(users, [function(o) { return o.user; }]);\n     * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 30]]\n     *\n     * _.sortBy(users, ['user', 'age']);\n     * // => objects for [['barney', 34], ['barney', 36], ['fred', 30], ['fred', 48]]\n     */\n    var sortBy = baseRest(function(collection, iteratees) {\n      if (collection == null) {\n        return [];\n      }\n      var length = iteratees.length;\n      if (length > 1 && isIterateeCall(collection, iteratees[0], iteratees[1])) {\n        iteratees = [];\n      } else if (length > 2 && isIterateeCall(iteratees[0], iteratees[1], iteratees[2])) {\n        iteratees = [iteratees[0]];\n      }\n      return baseOrderBy(collection, baseFlatten(iteratees, 1), []);\n    });\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Gets the timestamp of the number of milliseconds that have elapsed since\n     * the Unix epoch (1 January 1970 00:00:00 UTC).\n     *\n     * @static\n     * @memberOf _\n     * @since 2.4.0\n     * @category Date\n     * @returns {number} Returns the timestamp.\n     * @example\n     *\n     * _.defer(function(stamp) {\n     *   console.log(_.now() - stamp);\n     * }, _.now());\n     * // => Logs the number of milliseconds it took for the deferred invocation.\n     */\n    var now = ctxNow || function() {\n      return root.Date.now();\n    };\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * The opposite of `_.before`; this method creates a function that invokes\n     * `func` once it's called `n` or more times.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Function\n     * @param {number} n The number of calls before `func` is invoked.\n     * @param {Function} func The function to restrict.\n     * @returns {Function} Returns the new restricted function.\n     * @example\n     *\n     * var saves = ['profile', 'settings'];\n     *\n     * var done = _.after(saves.length, function() {\n     *   console.log('done saving!');\n     * });\n     *\n     * _.forEach(saves, function(type) {\n     *   asyncSave({ 'type': type, 'complete': done });\n     * });\n     * // => Logs 'done saving!' after the two async saves have completed.\n     */\n    function after(n, func) {\n      if (typeof func != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      n = toInteger(n);\n      return function() {\n        if (--n < 1) {\n          return func.apply(this, arguments);\n        }\n      };\n    }\n\n    /**\n     * Creates a function that invokes `func`, with up to `n` arguments,\n     * ignoring any additional arguments.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Function\n     * @param {Function} func The function to cap arguments for.\n     * @param {number} [n=func.length] The arity cap.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Function} Returns the new capped function.\n     * @example\n     *\n     * _.map(['6', '8', '10'], _.ary(parseInt, 1));\n     * // => [6, 8, 10]\n     */\n    function ary(func, n, guard) {\n      n = guard ? undefined : n;\n      n = (func && n == null) ? func.length : n;\n      return createWrap(func, WRAP_ARY_FLAG, undefined, undefined, undefined, undefined, n);\n    }\n\n    /**\n     * Creates a function that invokes `func`, with the `this` binding and arguments\n     * of the created function, while it's called less than `n` times. Subsequent\n     * calls to the created function return the result of the last `func` invocation.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Function\n     * @param {number} n The number of calls at which `func` is no longer invoked.\n     * @param {Function} func The function to restrict.\n     * @returns {Function} Returns the new restricted function.\n     * @example\n     *\n     * jQuery(element).on('click', _.before(5, addContactToList));\n     * // => Allows adding up to 4 contacts to the list.\n     */\n    function before(n, func) {\n      var result;\n      if (typeof func != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      n = toInteger(n);\n      return function() {\n        if (--n > 0) {\n          result = func.apply(this, arguments);\n        }\n        if (n <= 1) {\n          func = undefined;\n        }\n        return result;\n      };\n    }\n\n    /**\n     * Creates a function that invokes `func` with the `this` binding of `thisArg`\n     * and `partials` prepended to the arguments it receives.\n     *\n     * The `_.bind.placeholder` value, which defaults to `_` in monolithic builds,\n     * may be used as a placeholder for partially applied arguments.\n     *\n     * **Note:** Unlike native `Function#bind`, this method doesn't set the \"length\"\n     * property of bound functions.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Function\n     * @param {Function} func The function to bind.\n     * @param {*} thisArg The `this` binding of `func`.\n     * @param {...*} [partials] The arguments to be partially applied.\n     * @returns {Function} Returns the new bound function.\n     * @example\n     *\n     * function greet(greeting, punctuation) {\n     *   return greeting + ' ' + this.user + punctuation;\n     * }\n     *\n     * var object = { 'user': 'fred' };\n     *\n     * var bound = _.bind(greet, object, 'hi');\n     * bound('!');\n     * // => 'hi fred!'\n     *\n     * // Bound with placeholders.\n     * var bound = _.bind(greet, object, _, '!');\n     * bound('hi');\n     * // => 'hi fred!'\n     */\n    var bind = baseRest(function(func, thisArg, partials) {\n      var bitmask = WRAP_BIND_FLAG;\n      if (partials.length) {\n        var holders = replaceHolders(partials, getHolder(bind));\n        bitmask |= WRAP_PARTIAL_FLAG;\n      }\n      return createWrap(func, bitmask, thisArg, partials, holders);\n    });\n\n    /**\n     * Creates a function that invokes the method at `object[key]` with `partials`\n     * prepended to the arguments it receives.\n     *\n     * This method differs from `_.bind` by allowing bound functions to reference\n     * methods that may be redefined or don't yet exist. See\n     * [Peter Michaux's article](http://peter.michaux.ca/articles/lazy-function-definition-pattern)\n     * for more details.\n     *\n     * The `_.bindKey.placeholder` value, which defaults to `_` in monolithic\n     * builds, may be used as a placeholder for partially applied arguments.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.10.0\n     * @category Function\n     * @param {Object} object The object to invoke the method on.\n     * @param {string} key The key of the method.\n     * @param {...*} [partials] The arguments to be partially applied.\n     * @returns {Function} Returns the new bound function.\n     * @example\n     *\n     * var object = {\n     *   'user': 'fred',\n     *   'greet': function(greeting, punctuation) {\n     *     return greeting + ' ' + this.user + punctuation;\n     *   }\n     * };\n     *\n     * var bound = _.bindKey(object, 'greet', 'hi');\n     * bound('!');\n     * // => 'hi fred!'\n     *\n     * object.greet = function(greeting, punctuation) {\n     *   return greeting + 'ya ' + this.user + punctuation;\n     * };\n     *\n     * bound('!');\n     * // => 'hiya fred!'\n     *\n     * // Bound with placeholders.\n     * var bound = _.bindKey(object, 'greet', _, '!');\n     * bound('hi');\n     * // => 'hiya fred!'\n     */\n    var bindKey = baseRest(function(object, key, partials) {\n      var bitmask = WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG;\n      if (partials.length) {\n        var holders = replaceHolders(partials, getHolder(bindKey));\n        bitmask |= WRAP_PARTIAL_FLAG;\n      }\n      return createWrap(key, bitmask, object, partials, holders);\n    });\n\n    /**\n     * Creates a function that accepts arguments of `func` and either invokes\n     * `func` returning its result, if at least `arity` number of arguments have\n     * been provided, or returns a function that accepts the remaining `func`\n     * arguments, and so on. The arity of `func` may be specified if `func.length`\n     * is not sufficient.\n     *\n     * The `_.curry.placeholder` value, which defaults to `_` in monolithic builds,\n     * may be used as a placeholder for provided arguments.\n     *\n     * **Note:** This method doesn't set the \"length\" property of curried functions.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.0.0\n     * @category Function\n     * @param {Function} func The function to curry.\n     * @param {number} [arity=func.length] The arity of `func`.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Function} Returns the new curried function.\n     * @example\n     *\n     * var abc = function(a, b, c) {\n     *   return [a, b, c];\n     * };\n     *\n     * var curried = _.curry(abc);\n     *\n     * curried(1)(2)(3);\n     * // => [1, 2, 3]\n     *\n     * curried(1, 2)(3);\n     * // => [1, 2, 3]\n     *\n     * curried(1, 2, 3);\n     * // => [1, 2, 3]\n     *\n     * // Curried with placeholders.\n     * curried(1)(_, 3)(2);\n     * // => [1, 2, 3]\n     */\n    function curry(func, arity, guard) {\n      arity = guard ? undefined : arity;\n      var result = createWrap(func, WRAP_CURRY_FLAG, undefined, undefined, undefined, undefined, undefined, arity);\n      result.placeholder = curry.placeholder;\n      return result;\n    }\n\n    /**\n     * This method is like `_.curry` except that arguments are applied to `func`\n     * in the manner of `_.partialRight` instead of `_.partial`.\n     *\n     * The `_.curryRight.placeholder` value, which defaults to `_` in monolithic\n     * builds, may be used as a placeholder for provided arguments.\n     *\n     * **Note:** This method doesn't set the \"length\" property of curried functions.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Function\n     * @param {Function} func The function to curry.\n     * @param {number} [arity=func.length] The arity of `func`.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Function} Returns the new curried function.\n     * @example\n     *\n     * var abc = function(a, b, c) {\n     *   return [a, b, c];\n     * };\n     *\n     * var curried = _.curryRight(abc);\n     *\n     * curried(3)(2)(1);\n     * // => [1, 2, 3]\n     *\n     * curried(2, 3)(1);\n     * // => [1, 2, 3]\n     *\n     * curried(1, 2, 3);\n     * // => [1, 2, 3]\n     *\n     * // Curried with placeholders.\n     * curried(3)(1, _)(2);\n     * // => [1, 2, 3]\n     */\n    function curryRight(func, arity, guard) {\n      arity = guard ? undefined : arity;\n      var result = createWrap(func, WRAP_CURRY_RIGHT_FLAG, undefined, undefined, undefined, undefined, undefined, arity);\n      result.placeholder = curryRight.placeholder;\n      return result;\n    }\n\n    /**\n     * Creates a debounced function that delays invoking `func` until after `wait`\n     * milliseconds have elapsed since the last time the debounced function was\n     * invoked. The debounced function comes with a `cancel` method to cancel\n     * delayed `func` invocations and a `flush` method to immediately invoke them.\n     * Provide `options` to indicate whether `func` should be invoked on the\n     * leading and/or trailing edge of the `wait` timeout. The `func` is invoked\n     * with the last arguments provided to the debounced function. Subsequent\n     * calls to the debounced function return the result of the last `func`\n     * invocation.\n     *\n     * **Note:** If `leading` and `trailing` options are `true`, `func` is\n     * invoked on the trailing edge of the timeout only if the debounced function\n     * is invoked more than once during the `wait` timeout.\n     *\n     * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n     * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n     *\n     * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n     * for details over the differences between `_.debounce` and `_.throttle`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Function\n     * @param {Function} func The function to debounce.\n     * @param {number} [wait=0] The number of milliseconds to delay.\n     * @param {Object} [options={}] The options object.\n     * @param {boolean} [options.leading=false]\n     *  Specify invoking on the leading edge of the timeout.\n     * @param {number} [options.maxWait]\n     *  The maximum time `func` is allowed to be delayed before it's invoked.\n     * @param {boolean} [options.trailing=true]\n     *  Specify invoking on the trailing edge of the timeout.\n     * @returns {Function} Returns the new debounced function.\n     * @example\n     *\n     * // Avoid costly calculations while the window size is in flux.\n     * jQuery(window).on('resize', _.debounce(calculateLayout, 150));\n     *\n     * // Invoke `sendMail` when clicked, debouncing subsequent calls.\n     * jQuery(element).on('click', _.debounce(sendMail, 300, {\n     *   'leading': true,\n     *   'trailing': false\n     * }));\n     *\n     * // Ensure `batchLog` is invoked once after 1 second of debounced calls.\n     * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });\n     * var source = new EventSource('/stream');\n     * jQuery(source).on('message', debounced);\n     *\n     * // Cancel the trailing debounced invocation.\n     * jQuery(window).on('popstate', debounced.cancel);\n     */\n    function debounce(func, wait, options) {\n      var lastArgs,\n          lastThis,\n          maxWait,\n          result,\n          timerId,\n          lastCallTime,\n          lastInvokeTime = 0,\n          leading = false,\n          maxing = false,\n          trailing = true;\n\n      if (typeof func != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      wait = toNumber(wait) || 0;\n      if (isObject(options)) {\n        leading = !!options.leading;\n        maxing = 'maxWait' in options;\n        maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;\n        trailing = 'trailing' in options ? !!options.trailing : trailing;\n      }\n\n      function invokeFunc(time) {\n        var args = lastArgs,\n            thisArg = lastThis;\n\n        lastArgs = lastThis = undefined;\n        lastInvokeTime = time;\n        result = func.apply(thisArg, args);\n        return result;\n      }\n\n      function leadingEdge(time) {\n        // Reset any `maxWait` timer.\n        lastInvokeTime = time;\n        // Start the timer for the trailing edge.\n        timerId = setTimeout(timerExpired, wait);\n        // Invoke the leading edge.\n        return leading ? invokeFunc(time) : result;\n      }\n\n      function remainingWait(time) {\n        var timeSinceLastCall = time - lastCallTime,\n            timeSinceLastInvoke = time - lastInvokeTime,\n            timeWaiting = wait - timeSinceLastCall;\n\n        return maxing\n          ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke)\n          : timeWaiting;\n      }\n\n      function shouldInvoke(time) {\n        var timeSinceLastCall = time - lastCallTime,\n            timeSinceLastInvoke = time - lastInvokeTime;\n\n        // Either this is the first call, activity has stopped and we're at the\n        // trailing edge, the system time has gone backwards and we're treating\n        // it as the trailing edge, or we've hit the `maxWait` limit.\n        return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||\n          (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));\n      }\n\n      function timerExpired() {\n        var time = now();\n        if (shouldInvoke(time)) {\n          return trailingEdge(time);\n        }\n        // Restart the timer.\n        timerId = setTimeout(timerExpired, remainingWait(time));\n      }\n\n      function trailingEdge(time) {\n        timerId = undefined;\n\n        // Only invoke if we have `lastArgs` which means `func` has been\n        // debounced at least once.\n        if (trailing && lastArgs) {\n          return invokeFunc(time);\n        }\n        lastArgs = lastThis = undefined;\n        return result;\n      }\n\n      function cancel() {\n        if (timerId !== undefined) {\n          clearTimeout(timerId);\n        }\n        lastInvokeTime = 0;\n        lastArgs = lastCallTime = lastThis = timerId = undefined;\n      }\n\n      function flush() {\n        return timerId === undefined ? result : trailingEdge(now());\n      }\n\n      function debounced() {\n        var time = now(),\n            isInvoking = shouldInvoke(time);\n\n        lastArgs = arguments;\n        lastThis = this;\n        lastCallTime = time;\n\n        if (isInvoking) {\n          if (timerId === undefined) {\n            return leadingEdge(lastCallTime);\n          }\n          if (maxing) {\n            // Handle invocations in a tight loop.\n            clearTimeout(timerId);\n            timerId = setTimeout(timerExpired, wait);\n            return invokeFunc(lastCallTime);\n          }\n        }\n        if (timerId === undefined) {\n          timerId = setTimeout(timerExpired, wait);\n        }\n        return result;\n      }\n      debounced.cancel = cancel;\n      debounced.flush = flush;\n      return debounced;\n    }\n\n    /**\n     * Defers invoking the `func` until the current call stack has cleared. Any\n     * additional arguments are provided to `func` when it's invoked.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Function\n     * @param {Function} func The function to defer.\n     * @param {...*} [args] The arguments to invoke `func` with.\n     * @returns {number} Returns the timer id.\n     * @example\n     *\n     * _.defer(function(text) {\n     *   console.log(text);\n     * }, 'deferred');\n     * // => Logs 'deferred' after one millisecond.\n     */\n    var defer = baseRest(function(func, args) {\n      return baseDelay(func, 1, args);\n    });\n\n    /**\n     * Invokes `func` after `wait` milliseconds. Any additional arguments are\n     * provided to `func` when it's invoked.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Function\n     * @param {Function} func The function to delay.\n     * @param {number} wait The number of milliseconds to delay invocation.\n     * @param {...*} [args] The arguments to invoke `func` with.\n     * @returns {number} Returns the timer id.\n     * @example\n     *\n     * _.delay(function(text) {\n     *   console.log(text);\n     * }, 1000, 'later');\n     * // => Logs 'later' after one second.\n     */\n    var delay = baseRest(function(func, wait, args) {\n      return baseDelay(func, toNumber(wait) || 0, args);\n    });\n\n    /**\n     * Creates a function that invokes `func` with arguments reversed.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Function\n     * @param {Function} func The function to flip arguments for.\n     * @returns {Function} Returns the new flipped function.\n     * @example\n     *\n     * var flipped = _.flip(function() {\n     *   return _.toArray(arguments);\n     * });\n     *\n     * flipped('a', 'b', 'c', 'd');\n     * // => ['d', 'c', 'b', 'a']\n     */\n    function flip(func) {\n      return createWrap(func, WRAP_FLIP_FLAG);\n    }\n\n    /**\n     * Creates a function that memoizes the result of `func`. If `resolver` is\n     * provided, it determines the cache key for storing the result based on the\n     * arguments provided to the memoized function. By default, the first argument\n     * provided to the memoized function is used as the map cache key. The `func`\n     * is invoked with the `this` binding of the memoized function.\n     *\n     * **Note:** The cache is exposed as the `cache` property on the memoized\n     * function. Its creation may be customized by replacing the `_.memoize.Cache`\n     * constructor with one whose instances implement the\n     * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)\n     * method interface of `clear`, `delete`, `get`, `has`, and `set`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Function\n     * @param {Function} func The function to have its output memoized.\n     * @param {Function} [resolver] The function to resolve the cache key.\n     * @returns {Function} Returns the new memoized function.\n     * @example\n     *\n     * var object = { 'a': 1, 'b': 2 };\n     * var other = { 'c': 3, 'd': 4 };\n     *\n     * var values = _.memoize(_.values);\n     * values(object);\n     * // => [1, 2]\n     *\n     * values(other);\n     * // => [3, 4]\n     *\n     * object.a = 2;\n     * values(object);\n     * // => [1, 2]\n     *\n     * // Modify the result cache.\n     * values.cache.set(object, ['a', 'b']);\n     * values(object);\n     * // => ['a', 'b']\n     *\n     * // Replace `_.memoize.Cache`.\n     * _.memoize.Cache = WeakMap;\n     */\n    function memoize(func, resolver) {\n      if (typeof func != 'function' || (resolver != null && typeof resolver != 'function')) {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      var memoized = function() {\n        var args = arguments,\n            key = resolver ? resolver.apply(this, args) : args[0],\n            cache = memoized.cache;\n\n        if (cache.has(key)) {\n          return cache.get(key);\n        }\n        var result = func.apply(this, args);\n        memoized.cache = cache.set(key, result) || cache;\n        return result;\n      };\n      memoized.cache = new (memoize.Cache || MapCache);\n      return memoized;\n    }\n\n    // Expose `MapCache`.\n    memoize.Cache = MapCache;\n\n    /**\n     * Creates a function that negates the result of the predicate `func`. The\n     * `func` predicate is invoked with the `this` binding and arguments of the\n     * created function.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Function\n     * @param {Function} predicate The predicate to negate.\n     * @returns {Function} Returns the new negated function.\n     * @example\n     *\n     * function isEven(n) {\n     *   return n % 2 == 0;\n     * }\n     *\n     * _.filter([1, 2, 3, 4, 5, 6], _.negate(isEven));\n     * // => [1, 3, 5]\n     */\n    function negate(predicate) {\n      if (typeof predicate != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      return function() {\n        var args = arguments;\n        switch (args.length) {\n          case 0: return !predicate.call(this);\n          case 1: return !predicate.call(this, args[0]);\n          case 2: return !predicate.call(this, args[0], args[1]);\n          case 3: return !predicate.call(this, args[0], args[1], args[2]);\n        }\n        return !predicate.apply(this, args);\n      };\n    }\n\n    /**\n     * Creates a function that is restricted to invoking `func` once. Repeat calls\n     * to the function return the value of the first invocation. The `func` is\n     * invoked with the `this` binding and arguments of the created function.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Function\n     * @param {Function} func The function to restrict.\n     * @returns {Function} Returns the new restricted function.\n     * @example\n     *\n     * var initialize = _.once(createApplication);\n     * initialize();\n     * initialize();\n     * // => `createApplication` is invoked once\n     */\n    function once(func) {\n      return before(2, func);\n    }\n\n    /**\n     * Creates a function that invokes `func` with its arguments transformed.\n     *\n     * @static\n     * @since 4.0.0\n     * @memberOf _\n     * @category Function\n     * @param {Function} func The function to wrap.\n     * @param {...(Function|Function[])} [transforms=[_.identity]]\n     *  The argument transforms.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * function doubled(n) {\n     *   return n * 2;\n     * }\n     *\n     * function square(n) {\n     *   return n * n;\n     * }\n     *\n     * var func = _.overArgs(function(x, y) {\n     *   return [x, y];\n     * }, [square, doubled]);\n     *\n     * func(9, 3);\n     * // => [81, 6]\n     *\n     * func(10, 5);\n     * // => [100, 10]\n     */\n    var overArgs = castRest(function(func, transforms) {\n      transforms = (transforms.length == 1 && isArray(transforms[0]))\n        ? arrayMap(transforms[0], baseUnary(getIteratee()))\n        : arrayMap(baseFlatten(transforms, 1), baseUnary(getIteratee()));\n\n      var funcsLength = transforms.length;\n      return baseRest(function(args) {\n        var index = -1,\n            length = nativeMin(args.length, funcsLength);\n\n        while (++index < length) {\n          args[index] = transforms[index].call(this, args[index]);\n        }\n        return apply(func, this, args);\n      });\n    });\n\n    /**\n     * Creates a function that invokes `func` with `partials` prepended to the\n     * arguments it receives. This method is like `_.bind` except it does **not**\n     * alter the `this` binding.\n     *\n     * The `_.partial.placeholder` value, which defaults to `_` in monolithic\n     * builds, may be used as a placeholder for partially applied arguments.\n     *\n     * **Note:** This method doesn't set the \"length\" property of partially\n     * applied functions.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.2.0\n     * @category Function\n     * @param {Function} func The function to partially apply arguments to.\n     * @param {...*} [partials] The arguments to be partially applied.\n     * @returns {Function} Returns the new partially applied function.\n     * @example\n     *\n     * function greet(greeting, name) {\n     *   return greeting + ' ' + name;\n     * }\n     *\n     * var sayHelloTo = _.partial(greet, 'hello');\n     * sayHelloTo('fred');\n     * // => 'hello fred'\n     *\n     * // Partially applied with placeholders.\n     * var greetFred = _.partial(greet, _, 'fred');\n     * greetFred('hi');\n     * // => 'hi fred'\n     */\n    var partial = baseRest(function(func, partials) {\n      var holders = replaceHolders(partials, getHolder(partial));\n      return createWrap(func, WRAP_PARTIAL_FLAG, undefined, partials, holders);\n    });\n\n    /**\n     * This method is like `_.partial` except that partially applied arguments\n     * are appended to the arguments it receives.\n     *\n     * The `_.partialRight.placeholder` value, which defaults to `_` in monolithic\n     * builds, may be used as a placeholder for partially applied arguments.\n     *\n     * **Note:** This method doesn't set the \"length\" property of partially\n     * applied functions.\n     *\n     * @static\n     * @memberOf _\n     * @since 1.0.0\n     * @category Function\n     * @param {Function} func The function to partially apply arguments to.\n     * @param {...*} [partials] The arguments to be partially applied.\n     * @returns {Function} Returns the new partially applied function.\n     * @example\n     *\n     * function greet(greeting, name) {\n     *   return greeting + ' ' + name;\n     * }\n     *\n     * var greetFred = _.partialRight(greet, 'fred');\n     * greetFred('hi');\n     * // => 'hi fred'\n     *\n     * // Partially applied with placeholders.\n     * var sayHelloTo = _.partialRight(greet, 'hello', _);\n     * sayHelloTo('fred');\n     * // => 'hello fred'\n     */\n    var partialRight = baseRest(function(func, partials) {\n      var holders = replaceHolders(partials, getHolder(partialRight));\n      return createWrap(func, WRAP_PARTIAL_RIGHT_FLAG, undefined, partials, holders);\n    });\n\n    /**\n     * Creates a function that invokes `func` with arguments arranged according\n     * to the specified `indexes` where the argument value at the first index is\n     * provided as the first argument, the argument value at the second index is\n     * provided as the second argument, and so on.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Function\n     * @param {Function} func The function to rearrange arguments for.\n     * @param {...(number|number[])} indexes The arranged argument indexes.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * var rearged = _.rearg(function(a, b, c) {\n     *   return [a, b, c];\n     * }, [2, 0, 1]);\n     *\n     * rearged('b', 'c', 'a')\n     * // => ['a', 'b', 'c']\n     */\n    var rearg = flatRest(function(func, indexes) {\n      return createWrap(func, WRAP_REARG_FLAG, undefined, undefined, undefined, indexes);\n    });\n\n    /**\n     * Creates a function that invokes `func` with the `this` binding of the\n     * created function and arguments from `start` and beyond provided as\n     * an array.\n     *\n     * **Note:** This method is based on the\n     * [rest parameter](https://mdn.io/rest_parameters).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Function\n     * @param {Function} func The function to apply a rest parameter to.\n     * @param {number} [start=func.length-1] The start position of the rest parameter.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * var say = _.rest(function(what, names) {\n     *   return what + ' ' + _.initial(names).join(', ') +\n     *     (_.size(names) > 1 ? ', & ' : '') + _.last(names);\n     * });\n     *\n     * say('hello', 'fred', 'barney', 'pebbles');\n     * // => 'hello fred, barney, & pebbles'\n     */\n    function rest(func, start) {\n      if (typeof func != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      start = start === undefined ? start : toInteger(start);\n      return baseRest(func, start);\n    }\n\n    /**\n     * Creates a function that invokes `func` with the `this` binding of the\n     * create function and an array of arguments much like\n     * [`Function#apply`](http://www.ecma-international.org/ecma-262/7.0/#sec-function.prototype.apply).\n     *\n     * **Note:** This method is based on the\n     * [spread operator](https://mdn.io/spread_operator).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.2.0\n     * @category Function\n     * @param {Function} func The function to spread arguments over.\n     * @param {number} [start=0] The start position of the spread.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * var say = _.spread(function(who, what) {\n     *   return who + ' says ' + what;\n     * });\n     *\n     * say(['fred', 'hello']);\n     * // => 'fred says hello'\n     *\n     * var numbers = Promise.all([\n     *   Promise.resolve(40),\n     *   Promise.resolve(36)\n     * ]);\n     *\n     * numbers.then(_.spread(function(x, y) {\n     *   return x + y;\n     * }));\n     * // => a Promise of 76\n     */\n    function spread(func, start) {\n      if (typeof func != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      start = start == null ? 0 : nativeMax(toInteger(start), 0);\n      return baseRest(function(args) {\n        var array = args[start],\n            otherArgs = castSlice(args, 0, start);\n\n        if (array) {\n          arrayPush(otherArgs, array);\n        }\n        return apply(func, this, otherArgs);\n      });\n    }\n\n    /**\n     * Creates a throttled function that only invokes `func` at most once per\n     * every `wait` milliseconds. The throttled function comes with a `cancel`\n     * method to cancel delayed `func` invocations and a `flush` method to\n     * immediately invoke them. Provide `options` to indicate whether `func`\n     * should be invoked on the leading and/or trailing edge of the `wait`\n     * timeout. The `func` is invoked with the last arguments provided to the\n     * throttled function. Subsequent calls to the throttled function return the\n     * result of the last `func` invocation.\n     *\n     * **Note:** If `leading` and `trailing` options are `true`, `func` is\n     * invoked on the trailing edge of the timeout only if the throttled function\n     * is invoked more than once during the `wait` timeout.\n     *\n     * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n     * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n     *\n     * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n     * for details over the differences between `_.throttle` and `_.debounce`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Function\n     * @param {Function} func The function to throttle.\n     * @param {number} [wait=0] The number of milliseconds to throttle invocations to.\n     * @param {Object} [options={}] The options object.\n     * @param {boolean} [options.leading=true]\n     *  Specify invoking on the leading edge of the timeout.\n     * @param {boolean} [options.trailing=true]\n     *  Specify invoking on the trailing edge of the timeout.\n     * @returns {Function} Returns the new throttled function.\n     * @example\n     *\n     * // Avoid excessively updating the position while scrolling.\n     * jQuery(window).on('scroll', _.throttle(updatePosition, 100));\n     *\n     * // Invoke `renewToken` when the click event is fired, but not more than once every 5 minutes.\n     * var throttled = _.throttle(renewToken, 300000, { 'trailing': false });\n     * jQuery(element).on('click', throttled);\n     *\n     * // Cancel the trailing throttled invocation.\n     * jQuery(window).on('popstate', throttled.cancel);\n     */\n    function throttle(func, wait, options) {\n      var leading = true,\n          trailing = true;\n\n      if (typeof func != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      if (isObject(options)) {\n        leading = 'leading' in options ? !!options.leading : leading;\n        trailing = 'trailing' in options ? !!options.trailing : trailing;\n      }\n      return debounce(func, wait, {\n        'leading': leading,\n        'maxWait': wait,\n        'trailing': trailing\n      });\n    }\n\n    /**\n     * Creates a function that accepts up to one argument, ignoring any\n     * additional arguments.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Function\n     * @param {Function} func The function to cap arguments for.\n     * @returns {Function} Returns the new capped function.\n     * @example\n     *\n     * _.map(['6', '8', '10'], _.unary(parseInt));\n     * // => [6, 8, 10]\n     */\n    function unary(func) {\n      return ary(func, 1);\n    }\n\n    /**\n     * Creates a function that provides `value` to `wrapper` as its first\n     * argument. Any additional arguments provided to the function are appended\n     * to those provided to the `wrapper`. The wrapper is invoked with the `this`\n     * binding of the created function.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Function\n     * @param {*} value The value to wrap.\n     * @param {Function} [wrapper=identity] The wrapper function.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * var p = _.wrap(_.escape, function(func, text) {\n     *   return '<p>' + func(text) + '</p>';\n     * });\n     *\n     * p('fred, barney, & pebbles');\n     * // => '<p>fred, barney, &amp; pebbles</p>'\n     */\n    function wrap(value, wrapper) {\n      return partial(castFunction(wrapper), value);\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Casts `value` as an array if it's not one.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.4.0\n     * @category Lang\n     * @param {*} value The value to inspect.\n     * @returns {Array} Returns the cast array.\n     * @example\n     *\n     * _.castArray(1);\n     * // => [1]\n     *\n     * _.castArray({ 'a': 1 });\n     * // => [{ 'a': 1 }]\n     *\n     * _.castArray('abc');\n     * // => ['abc']\n     *\n     * _.castArray(null);\n     * // => [null]\n     *\n     * _.castArray(undefined);\n     * // => [undefined]\n     *\n     * _.castArray();\n     * // => []\n     *\n     * var array = [1, 2, 3];\n     * console.log(_.castArray(array) === array);\n     * // => true\n     */\n    function castArray() {\n      if (!arguments.length) {\n        return [];\n      }\n      var value = arguments[0];\n      return isArray(value) ? value : [value];\n    }\n\n    /**\n     * Creates a shallow clone of `value`.\n     *\n     * **Note:** This method is loosely based on the\n     * [structured clone algorithm](https://mdn.io/Structured_clone_algorithm)\n     * and supports cloning arrays, array buffers, booleans, date objects, maps,\n     * numbers, `Object` objects, regexes, sets, strings, symbols, and typed\n     * arrays. The own enumerable properties of `arguments` objects are cloned\n     * as plain objects. An empty object is returned for uncloneable values such\n     * as error objects, functions, DOM nodes, and WeakMaps.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to clone.\n     * @returns {*} Returns the cloned value.\n     * @see _.cloneDeep\n     * @example\n     *\n     * var objects = [{ 'a': 1 }, { 'b': 2 }];\n     *\n     * var shallow = _.clone(objects);\n     * console.log(shallow[0] === objects[0]);\n     * // => true\n     */\n    function clone(value) {\n      return baseClone(value, CLONE_SYMBOLS_FLAG);\n    }\n\n    /**\n     * This method is like `_.clone` except that it accepts `customizer` which\n     * is invoked to produce the cloned value. If `customizer` returns `undefined`,\n     * cloning is handled by the method instead. The `customizer` is invoked with\n     * up to four arguments; (value [, index|key, object, stack]).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to clone.\n     * @param {Function} [customizer] The function to customize cloning.\n     * @returns {*} Returns the cloned value.\n     * @see _.cloneDeepWith\n     * @example\n     *\n     * function customizer(value) {\n     *   if (_.isElement(value)) {\n     *     return value.cloneNode(false);\n     *   }\n     * }\n     *\n     * var el = _.cloneWith(document.body, customizer);\n     *\n     * console.log(el === document.body);\n     * // => false\n     * console.log(el.nodeName);\n     * // => 'BODY'\n     * console.log(el.childNodes.length);\n     * // => 0\n     */\n    function cloneWith(value, customizer) {\n      customizer = typeof customizer == 'function' ? customizer : undefined;\n      return baseClone(value, CLONE_SYMBOLS_FLAG, customizer);\n    }\n\n    /**\n     * This method is like `_.clone` except that it recursively clones `value`.\n     *\n     * @static\n     * @memberOf _\n     * @since 1.0.0\n     * @category Lang\n     * @param {*} value The value to recursively clone.\n     * @returns {*} Returns the deep cloned value.\n     * @see _.clone\n     * @example\n     *\n     * var objects = [{ 'a': 1 }, { 'b': 2 }];\n     *\n     * var deep = _.cloneDeep(objects);\n     * console.log(deep[0] === objects[0]);\n     * // => false\n     */\n    function cloneDeep(value) {\n      return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG);\n    }\n\n    /**\n     * This method is like `_.cloneWith` except that it recursively clones `value`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to recursively clone.\n     * @param {Function} [customizer] The function to customize cloning.\n     * @returns {*} Returns the deep cloned value.\n     * @see _.cloneWith\n     * @example\n     *\n     * function customizer(value) {\n     *   if (_.isElement(value)) {\n     *     return value.cloneNode(true);\n     *   }\n     * }\n     *\n     * var el = _.cloneDeepWith(document.body, customizer);\n     *\n     * console.log(el === document.body);\n     * // => false\n     * console.log(el.nodeName);\n     * // => 'BODY'\n     * console.log(el.childNodes.length);\n     * // => 20\n     */\n    function cloneDeepWith(value, customizer) {\n      customizer = typeof customizer == 'function' ? customizer : undefined;\n      return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG, customizer);\n    }\n\n    /**\n     * Checks if `object` conforms to `source` by invoking the predicate\n     * properties of `source` with the corresponding property values of `object`.\n     *\n     * **Note:** This method is equivalent to `_.conforms` when `source` is\n     * partially applied.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.14.0\n     * @category Lang\n     * @param {Object} object The object to inspect.\n     * @param {Object} source The object of property predicates to conform to.\n     * @returns {boolean} Returns `true` if `object` conforms, else `false`.\n     * @example\n     *\n     * var object = { 'a': 1, 'b': 2 };\n     *\n     * _.conformsTo(object, { 'b': function(n) { return n > 1; } });\n     * // => true\n     *\n     * _.conformsTo(object, { 'b': function(n) { return n > 2; } });\n     * // => false\n     */\n    function conformsTo(object, source) {\n      return source == null || baseConformsTo(object, source, keys(source));\n    }\n\n    /**\n     * Performs a\n     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n     * comparison between two values to determine if they are equivalent.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n     * @example\n     *\n     * var object = { 'a': 1 };\n     * var other = { 'a': 1 };\n     *\n     * _.eq(object, object);\n     * // => true\n     *\n     * _.eq(object, other);\n     * // => false\n     *\n     * _.eq('a', 'a');\n     * // => true\n     *\n     * _.eq('a', Object('a'));\n     * // => false\n     *\n     * _.eq(NaN, NaN);\n     * // => true\n     */\n    function eq(value, other) {\n      return value === other || (value !== value && other !== other);\n    }\n\n    /**\n     * Checks if `value` is greater than `other`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.9.0\n     * @category Lang\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @returns {boolean} Returns `true` if `value` is greater than `other`,\n     *  else `false`.\n     * @see _.lt\n     * @example\n     *\n     * _.gt(3, 1);\n     * // => true\n     *\n     * _.gt(3, 3);\n     * // => false\n     *\n     * _.gt(1, 3);\n     * // => false\n     */\n    var gt = createRelationalOperation(baseGt);\n\n    /**\n     * Checks if `value` is greater than or equal to `other`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.9.0\n     * @category Lang\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @returns {boolean} Returns `true` if `value` is greater than or equal to\n     *  `other`, else `false`.\n     * @see _.lte\n     * @example\n     *\n     * _.gte(3, 1);\n     * // => true\n     *\n     * _.gte(3, 3);\n     * // => true\n     *\n     * _.gte(1, 3);\n     * // => false\n     */\n    var gte = createRelationalOperation(function(value, other) {\n      return value >= other;\n    });\n\n    /**\n     * Checks if `value` is likely an `arguments` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n     *  else `false`.\n     * @example\n     *\n     * _.isArguments(function() { return arguments; }());\n     * // => true\n     *\n     * _.isArguments([1, 2, 3]);\n     * // => false\n     */\n    var isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {\n      return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&\n        !propertyIsEnumerable.call(value, 'callee');\n    };\n\n    /**\n     * Checks if `value` is classified as an `Array` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is an array, else `false`.\n     * @example\n     *\n     * _.isArray([1, 2, 3]);\n     * // => true\n     *\n     * _.isArray(document.body.children);\n     * // => false\n     *\n     * _.isArray('abc');\n     * // => false\n     *\n     * _.isArray(_.noop);\n     * // => false\n     */\n    var isArray = Array.isArray;\n\n    /**\n     * Checks if `value` is classified as an `ArrayBuffer` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.3.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is an array buffer, else `false`.\n     * @example\n     *\n     * _.isArrayBuffer(new ArrayBuffer(2));\n     * // => true\n     *\n     * _.isArrayBuffer(new Array(2));\n     * // => false\n     */\n    var isArrayBuffer = nodeIsArrayBuffer ? baseUnary(nodeIsArrayBuffer) : baseIsArrayBuffer;\n\n    /**\n     * Checks if `value` is array-like. A value is considered array-like if it's\n     * not a function and has a `value.length` that's an integer greater than or\n     * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n     * @example\n     *\n     * _.isArrayLike([1, 2, 3]);\n     * // => true\n     *\n     * _.isArrayLike(document.body.children);\n     * // => true\n     *\n     * _.isArrayLike('abc');\n     * // => true\n     *\n     * _.isArrayLike(_.noop);\n     * // => false\n     */\n    function isArrayLike(value) {\n      return value != null && isLength(value.length) && !isFunction(value);\n    }\n\n    /**\n     * This method is like `_.isArrayLike` except that it also checks if `value`\n     * is an object.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is an array-like object,\n     *  else `false`.\n     * @example\n     *\n     * _.isArrayLikeObject([1, 2, 3]);\n     * // => true\n     *\n     * _.isArrayLikeObject(document.body.children);\n     * // => true\n     *\n     * _.isArrayLikeObject('abc');\n     * // => false\n     *\n     * _.isArrayLikeObject(_.noop);\n     * // => false\n     */\n    function isArrayLikeObject(value) {\n      return isObjectLike(value) && isArrayLike(value);\n    }\n\n    /**\n     * Checks if `value` is classified as a boolean primitive or object.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a boolean, else `false`.\n     * @example\n     *\n     * _.isBoolean(false);\n     * // => true\n     *\n     * _.isBoolean(null);\n     * // => false\n     */\n    function isBoolean(value) {\n      return value === true || value === false ||\n        (isObjectLike(value) && baseGetTag(value) == boolTag);\n    }\n\n    /**\n     * Checks if `value` is a buffer.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.3.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.\n     * @example\n     *\n     * _.isBuffer(new Buffer(2));\n     * // => true\n     *\n     * _.isBuffer(new Uint8Array(2));\n     * // => false\n     */\n    var isBuffer = nativeIsBuffer || stubFalse;\n\n    /**\n     * Checks if `value` is classified as a `Date` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a date object, else `false`.\n     * @example\n     *\n     * _.isDate(new Date);\n     * // => true\n     *\n     * _.isDate('Mon April 23 2012');\n     * // => false\n     */\n    var isDate = nodeIsDate ? baseUnary(nodeIsDate) : baseIsDate;\n\n    /**\n     * Checks if `value` is likely a DOM element.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a DOM element, else `false`.\n     * @example\n     *\n     * _.isElement(document.body);\n     * // => true\n     *\n     * _.isElement('<body>');\n     * // => false\n     */\n    function isElement(value) {\n      return isObjectLike(value) && value.nodeType === 1 && !isPlainObject(value);\n    }\n\n    /**\n     * Checks if `value` is an empty object, collection, map, or set.\n     *\n     * Objects are considered empty if they have no own enumerable string keyed\n     * properties.\n     *\n     * Array-like values such as `arguments` objects, arrays, buffers, strings, or\n     * jQuery-like collections are considered empty if they have a `length` of `0`.\n     * Similarly, maps and sets are considered empty if they have a `size` of `0`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is empty, else `false`.\n     * @example\n     *\n     * _.isEmpty(null);\n     * // => true\n     *\n     * _.isEmpty(true);\n     * // => true\n     *\n     * _.isEmpty(1);\n     * // => true\n     *\n     * _.isEmpty([1, 2, 3]);\n     * // => false\n     *\n     * _.isEmpty({ 'a': 1 });\n     * // => false\n     */\n    function isEmpty(value) {\n      if (value == null) {\n        return true;\n      }\n      if (isArrayLike(value) &&\n          (isArray(value) || typeof value == 'string' || typeof value.splice == 'function' ||\n            isBuffer(value) || isTypedArray(value) || isArguments(value))) {\n        return !value.length;\n      }\n      var tag = getTag(value);\n      if (tag == mapTag || tag == setTag) {\n        return !value.size;\n      }\n      if (isPrototype(value)) {\n        return !baseKeys(value).length;\n      }\n      for (var key in value) {\n        if (hasOwnProperty.call(value, key)) {\n          return false;\n        }\n      }\n      return true;\n    }\n\n    /**\n     * Performs a deep comparison between two values to determine if they are\n     * equivalent.\n     *\n     * **Note:** This method supports comparing arrays, array buffers, booleans,\n     * date objects, error objects, maps, numbers, `Object` objects, regexes,\n     * sets, strings, symbols, and typed arrays. `Object` objects are compared\n     * by their own, not inherited, enumerable properties. Functions and DOM\n     * nodes are compared by strict equality, i.e. `===`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n     * @example\n     *\n     * var object = { 'a': 1 };\n     * var other = { 'a': 1 };\n     *\n     * _.isEqual(object, other);\n     * // => true\n     *\n     * object === other;\n     * // => false\n     */\n    function isEqual(value, other) {\n      return baseIsEqual(value, other);\n    }\n\n    /**\n     * This method is like `_.isEqual` except that it accepts `customizer` which\n     * is invoked to compare values. If `customizer` returns `undefined`, comparisons\n     * are handled by the method instead. The `customizer` is invoked with up to\n     * six arguments: (objValue, othValue [, index|key, object, other, stack]).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @param {Function} [customizer] The function to customize comparisons.\n     * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n     * @example\n     *\n     * function isGreeting(value) {\n     *   return /^h(?:i|ello)$/.test(value);\n     * }\n     *\n     * function customizer(objValue, othValue) {\n     *   if (isGreeting(objValue) && isGreeting(othValue)) {\n     *     return true;\n     *   }\n     * }\n     *\n     * var array = ['hello', 'goodbye'];\n     * var other = ['hi', 'goodbye'];\n     *\n     * _.isEqualWith(array, other, customizer);\n     * // => true\n     */\n    function isEqualWith(value, other, customizer) {\n      customizer = typeof customizer == 'function' ? customizer : undefined;\n      var result = customizer ? customizer(value, other) : undefined;\n      return result === undefined ? baseIsEqual(value, other, undefined, customizer) : !!result;\n    }\n\n    /**\n     * Checks if `value` is an `Error`, `EvalError`, `RangeError`, `ReferenceError`,\n     * `SyntaxError`, `TypeError`, or `URIError` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is an error object, else `false`.\n     * @example\n     *\n     * _.isError(new Error);\n     * // => true\n     *\n     * _.isError(Error);\n     * // => false\n     */\n    function isError(value) {\n      if (!isObjectLike(value)) {\n        return false;\n      }\n      var tag = baseGetTag(value);\n      return tag == errorTag || tag == domExcTag ||\n        (typeof value.message == 'string' && typeof value.name == 'string' && !isPlainObject(value));\n    }\n\n    /**\n     * Checks if `value` is a finite primitive number.\n     *\n     * **Note:** This method is based on\n     * [`Number.isFinite`](https://mdn.io/Number/isFinite).\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a finite number, else `false`.\n     * @example\n     *\n     * _.isFinite(3);\n     * // => true\n     *\n     * _.isFinite(Number.MIN_VALUE);\n     * // => true\n     *\n     * _.isFinite(Infinity);\n     * // => false\n     *\n     * _.isFinite('3');\n     * // => false\n     */\n    function isFinite(value) {\n      return typeof value == 'number' && nativeIsFinite(value);\n    }\n\n    /**\n     * Checks if `value` is classified as a `Function` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a function, else `false`.\n     * @example\n     *\n     * _.isFunction(_);\n     * // => true\n     *\n     * _.isFunction(/abc/);\n     * // => false\n     */\n    function isFunction(value) {\n      if (!isObject(value)) {\n        return false;\n      }\n      // The use of `Object#toString` avoids issues with the `typeof` operator\n      // in Safari 9 which returns 'object' for typed arrays and other constructors.\n      var tag = baseGetTag(value);\n      return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;\n    }\n\n    /**\n     * Checks if `value` is an integer.\n     *\n     * **Note:** This method is based on\n     * [`Number.isInteger`](https://mdn.io/Number/isInteger).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is an integer, else `false`.\n     * @example\n     *\n     * _.isInteger(3);\n     * // => true\n     *\n     * _.isInteger(Number.MIN_VALUE);\n     * // => false\n     *\n     * _.isInteger(Infinity);\n     * // => false\n     *\n     * _.isInteger('3');\n     * // => false\n     */\n    function isInteger(value) {\n      return typeof value == 'number' && value == toInteger(value);\n    }\n\n    /**\n     * Checks if `value` is a valid array-like length.\n     *\n     * **Note:** This method is loosely based on\n     * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\n     * @example\n     *\n     * _.isLength(3);\n     * // => true\n     *\n     * _.isLength(Number.MIN_VALUE);\n     * // => false\n     *\n     * _.isLength(Infinity);\n     * // => false\n     *\n     * _.isLength('3');\n     * // => false\n     */\n    function isLength(value) {\n      return typeof value == 'number' &&\n        value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n    }\n\n    /**\n     * Checks if `value` is the\n     * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n     * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n     * @example\n     *\n     * _.isObject({});\n     * // => true\n     *\n     * _.isObject([1, 2, 3]);\n     * // => true\n     *\n     * _.isObject(_.noop);\n     * // => true\n     *\n     * _.isObject(null);\n     * // => false\n     */\n    function isObject(value) {\n      var type = typeof value;\n      return value != null && (type == 'object' || type == 'function');\n    }\n\n    /**\n     * Checks if `value` is object-like. A value is object-like if it's not `null`\n     * and has a `typeof` result of \"object\".\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n     * @example\n     *\n     * _.isObjectLike({});\n     * // => true\n     *\n     * _.isObjectLike([1, 2, 3]);\n     * // => true\n     *\n     * _.isObjectLike(_.noop);\n     * // => false\n     *\n     * _.isObjectLike(null);\n     * // => false\n     */\n    function isObjectLike(value) {\n      return value != null && typeof value == 'object';\n    }\n\n    /**\n     * Checks if `value` is classified as a `Map` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.3.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a map, else `false`.\n     * @example\n     *\n     * _.isMap(new Map);\n     * // => true\n     *\n     * _.isMap(new WeakMap);\n     * // => false\n     */\n    var isMap = nodeIsMap ? baseUnary(nodeIsMap) : baseIsMap;\n\n    /**\n     * Performs a partial deep comparison between `object` and `source` to\n     * determine if `object` contains equivalent property values.\n     *\n     * **Note:** This method is equivalent to `_.matches` when `source` is\n     * partially applied.\n     *\n     * Partial comparisons will match empty array and empty object `source`\n     * values against any array or object value, respectively. See `_.isEqual`\n     * for a list of supported value comparisons.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Lang\n     * @param {Object} object The object to inspect.\n     * @param {Object} source The object of property values to match.\n     * @returns {boolean} Returns `true` if `object` is a match, else `false`.\n     * @example\n     *\n     * var object = { 'a': 1, 'b': 2 };\n     *\n     * _.isMatch(object, { 'b': 2 });\n     * // => true\n     *\n     * _.isMatch(object, { 'b': 1 });\n     * // => false\n     */\n    function isMatch(object, source) {\n      return object === source || baseIsMatch(object, source, getMatchData(source));\n    }\n\n    /**\n     * This method is like `_.isMatch` except that it accepts `customizer` which\n     * is invoked to compare values. If `customizer` returns `undefined`, comparisons\n     * are handled by the method instead. The `customizer` is invoked with five\n     * arguments: (objValue, srcValue, index|key, object, source).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {Object} object The object to inspect.\n     * @param {Object} source The object of property values to match.\n     * @param {Function} [customizer] The function to customize comparisons.\n     * @returns {boolean} Returns `true` if `object` is a match, else `false`.\n     * @example\n     *\n     * function isGreeting(value) {\n     *   return /^h(?:i|ello)$/.test(value);\n     * }\n     *\n     * function customizer(objValue, srcValue) {\n     *   if (isGreeting(objValue) && isGreeting(srcValue)) {\n     *     return true;\n     *   }\n     * }\n     *\n     * var object = { 'greeting': 'hello' };\n     * var source = { 'greeting': 'hi' };\n     *\n     * _.isMatchWith(object, source, customizer);\n     * // => true\n     */\n    function isMatchWith(object, source, customizer) {\n      customizer = typeof customizer == 'function' ? customizer : undefined;\n      return baseIsMatch(object, source, getMatchData(source), customizer);\n    }\n\n    /**\n     * Checks if `value` is `NaN`.\n     *\n     * **Note:** This method is based on\n     * [`Number.isNaN`](https://mdn.io/Number/isNaN) and is not the same as\n     * global [`isNaN`](https://mdn.io/isNaN) which returns `true` for\n     * `undefined` and other non-number values.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.\n     * @example\n     *\n     * _.isNaN(NaN);\n     * // => true\n     *\n     * _.isNaN(new Number(NaN));\n     * // => true\n     *\n     * isNaN(undefined);\n     * // => true\n     *\n     * _.isNaN(undefined);\n     * // => false\n     */\n    function isNaN(value) {\n      // An `NaN` primitive is the only value that is not equal to itself.\n      // Perform the `toStringTag` check first to avoid errors with some\n      // ActiveX objects in IE.\n      return isNumber(value) && value != +value;\n    }\n\n    /**\n     * Checks if `value` is a pristine native function.\n     *\n     * **Note:** This method can't reliably detect native functions in the presence\n     * of the core-js package because core-js circumvents this kind of detection.\n     * Despite multiple requests, the core-js maintainer has made it clear: any\n     * attempt to fix the detection will be obstructed. As a result, we're left\n     * with little choice but to throw an error. Unfortunately, this also affects\n     * packages, like [babel-polyfill](https://www.npmjs.com/package/babel-polyfill),\n     * which rely on core-js.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a native function,\n     *  else `false`.\n     * @example\n     *\n     * _.isNative(Array.prototype.push);\n     * // => true\n     *\n     * _.isNative(_);\n     * // => false\n     */\n    function isNative(value) {\n      if (isMaskable(value)) {\n        throw new Error(CORE_ERROR_TEXT);\n      }\n      return baseIsNative(value);\n    }\n\n    /**\n     * Checks if `value` is `null`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is `null`, else `false`.\n     * @example\n     *\n     * _.isNull(null);\n     * // => true\n     *\n     * _.isNull(void 0);\n     * // => false\n     */\n    function isNull(value) {\n      return value === null;\n    }\n\n    /**\n     * Checks if `value` is `null` or `undefined`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is nullish, else `false`.\n     * @example\n     *\n     * _.isNil(null);\n     * // => true\n     *\n     * _.isNil(void 0);\n     * // => true\n     *\n     * _.isNil(NaN);\n     * // => false\n     */\n    function isNil(value) {\n      return value == null;\n    }\n\n    /**\n     * Checks if `value` is classified as a `Number` primitive or object.\n     *\n     * **Note:** To exclude `Infinity`, `-Infinity`, and `NaN`, which are\n     * classified as numbers, use the `_.isFinite` method.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a number, else `false`.\n     * @example\n     *\n     * _.isNumber(3);\n     * // => true\n     *\n     * _.isNumber(Number.MIN_VALUE);\n     * // => true\n     *\n     * _.isNumber(Infinity);\n     * // => true\n     *\n     * _.isNumber('3');\n     * // => false\n     */\n    function isNumber(value) {\n      return typeof value == 'number' ||\n        (isObjectLike(value) && baseGetTag(value) == numberTag);\n    }\n\n    /**\n     * Checks if `value` is a plain object, that is, an object created by the\n     * `Object` constructor or one with a `[[Prototype]]` of `null`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.8.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     * }\n     *\n     * _.isPlainObject(new Foo);\n     * // => false\n     *\n     * _.isPlainObject([1, 2, 3]);\n     * // => false\n     *\n     * _.isPlainObject({ 'x': 0, 'y': 0 });\n     * // => true\n     *\n     * _.isPlainObject(Object.create(null));\n     * // => true\n     */\n    function isPlainObject(value) {\n      if (!isObjectLike(value) || baseGetTag(value) != objectTag) {\n        return false;\n      }\n      var proto = getPrototype(value);\n      if (proto === null) {\n        return true;\n      }\n      var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;\n      return typeof Ctor == 'function' && Ctor instanceof Ctor &&\n        funcToString.call(Ctor) == objectCtorString;\n    }\n\n    /**\n     * Checks if `value` is classified as a `RegExp` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.1.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a regexp, else `false`.\n     * @example\n     *\n     * _.isRegExp(/abc/);\n     * // => true\n     *\n     * _.isRegExp('/abc/');\n     * // => false\n     */\n    var isRegExp = nodeIsRegExp ? baseUnary(nodeIsRegExp) : baseIsRegExp;\n\n    /**\n     * Checks if `value` is a safe integer. An integer is safe if it's an IEEE-754\n     * double precision number which isn't the result of a rounded unsafe integer.\n     *\n     * **Note:** This method is based on\n     * [`Number.isSafeInteger`](https://mdn.io/Number/isSafeInteger).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a safe integer, else `false`.\n     * @example\n     *\n     * _.isSafeInteger(3);\n     * // => true\n     *\n     * _.isSafeInteger(Number.MIN_VALUE);\n     * // => false\n     *\n     * _.isSafeInteger(Infinity);\n     * // => false\n     *\n     * _.isSafeInteger('3');\n     * // => false\n     */\n    function isSafeInteger(value) {\n      return isInteger(value) && value >= -MAX_SAFE_INTEGER && value <= MAX_SAFE_INTEGER;\n    }\n\n    /**\n     * Checks if `value` is classified as a `Set` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.3.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a set, else `false`.\n     * @example\n     *\n     * _.isSet(new Set);\n     * // => true\n     *\n     * _.isSet(new WeakSet);\n     * // => false\n     */\n    var isSet = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet;\n\n    /**\n     * Checks if `value` is classified as a `String` primitive or object.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a string, else `false`.\n     * @example\n     *\n     * _.isString('abc');\n     * // => true\n     *\n     * _.isString(1);\n     * // => false\n     */\n    function isString(value) {\n      return typeof value == 'string' ||\n        (!isArray(value) && isObjectLike(value) && baseGetTag(value) == stringTag);\n    }\n\n    /**\n     * Checks if `value` is classified as a `Symbol` primitive or object.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n     * @example\n     *\n     * _.isSymbol(Symbol.iterator);\n     * // => true\n     *\n     * _.isSymbol('abc');\n     * // => false\n     */\n    function isSymbol(value) {\n      return typeof value == 'symbol' ||\n        (isObjectLike(value) && baseGetTag(value) == symbolTag);\n    }\n\n    /**\n     * Checks if `value` is classified as a typed array.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n     * @example\n     *\n     * _.isTypedArray(new Uint8Array);\n     * // => true\n     *\n     * _.isTypedArray([]);\n     * // => false\n     */\n    var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;\n\n    /**\n     * Checks if `value` is `undefined`.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is `undefined`, else `false`.\n     * @example\n     *\n     * _.isUndefined(void 0);\n     * // => true\n     *\n     * _.isUndefined(null);\n     * // => false\n     */\n    function isUndefined(value) {\n      return value === undefined;\n    }\n\n    /**\n     * Checks if `value` is classified as a `WeakMap` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.3.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a weak map, else `false`.\n     * @example\n     *\n     * _.isWeakMap(new WeakMap);\n     * // => true\n     *\n     * _.isWeakMap(new Map);\n     * // => false\n     */\n    function isWeakMap(value) {\n      return isObjectLike(value) && getTag(value) == weakMapTag;\n    }\n\n    /**\n     * Checks if `value` is classified as a `WeakSet` object.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.3.0\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a weak set, else `false`.\n     * @example\n     *\n     * _.isWeakSet(new WeakSet);\n     * // => true\n     *\n     * _.isWeakSet(new Set);\n     * // => false\n     */\n    function isWeakSet(value) {\n      return isObjectLike(value) && baseGetTag(value) == weakSetTag;\n    }\n\n    /**\n     * Checks if `value` is less than `other`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.9.0\n     * @category Lang\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @returns {boolean} Returns `true` if `value` is less than `other`,\n     *  else `false`.\n     * @see _.gt\n     * @example\n     *\n     * _.lt(1, 3);\n     * // => true\n     *\n     * _.lt(3, 3);\n     * // => false\n     *\n     * _.lt(3, 1);\n     * // => false\n     */\n    var lt = createRelationalOperation(baseLt);\n\n    /**\n     * Checks if `value` is less than or equal to `other`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.9.0\n     * @category Lang\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @returns {boolean} Returns `true` if `value` is less than or equal to\n     *  `other`, else `false`.\n     * @see _.gte\n     * @example\n     *\n     * _.lte(1, 3);\n     * // => true\n     *\n     * _.lte(3, 3);\n     * // => true\n     *\n     * _.lte(3, 1);\n     * // => false\n     */\n    var lte = createRelationalOperation(function(value, other) {\n      return value <= other;\n    });\n\n    /**\n     * Converts `value` to an array.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Lang\n     * @param {*} value The value to convert.\n     * @returns {Array} Returns the converted array.\n     * @example\n     *\n     * _.toArray({ 'a': 1, 'b': 2 });\n     * // => [1, 2]\n     *\n     * _.toArray('abc');\n     * // => ['a', 'b', 'c']\n     *\n     * _.toArray(1);\n     * // => []\n     *\n     * _.toArray(null);\n     * // => []\n     */\n    function toArray(value) {\n      if (!value) {\n        return [];\n      }\n      if (isArrayLike(value)) {\n        return isString(value) ? stringToArray(value) : copyArray(value);\n      }\n      if (symIterator && value[symIterator]) {\n        return iteratorToArray(value[symIterator]());\n      }\n      var tag = getTag(value),\n          func = tag == mapTag ? mapToArray : (tag == setTag ? setToArray : values);\n\n      return func(value);\n    }\n\n    /**\n     * Converts `value` to a finite number.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.12.0\n     * @category Lang\n     * @param {*} value The value to convert.\n     * @returns {number} Returns the converted number.\n     * @example\n     *\n     * _.toFinite(3.2);\n     * // => 3.2\n     *\n     * _.toFinite(Number.MIN_VALUE);\n     * // => 5e-324\n     *\n     * _.toFinite(Infinity);\n     * // => 1.7976931348623157e+308\n     *\n     * _.toFinite('3.2');\n     * // => 3.2\n     */\n    function toFinite(value) {\n      if (!value) {\n        return value === 0 ? value : 0;\n      }\n      value = toNumber(value);\n      if (value === INFINITY || value === -INFINITY) {\n        var sign = (value < 0 ? -1 : 1);\n        return sign * MAX_INTEGER;\n      }\n      return value === value ? value : 0;\n    }\n\n    /**\n     * Converts `value` to an integer.\n     *\n     * **Note:** This method is loosely based on\n     * [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to convert.\n     * @returns {number} Returns the converted integer.\n     * @example\n     *\n     * _.toInteger(3.2);\n     * // => 3\n     *\n     * _.toInteger(Number.MIN_VALUE);\n     * // => 0\n     *\n     * _.toInteger(Infinity);\n     * // => 1.7976931348623157e+308\n     *\n     * _.toInteger('3.2');\n     * // => 3\n     */\n    function toInteger(value) {\n      var result = toFinite(value),\n          remainder = result % 1;\n\n      return result === result ? (remainder ? result - remainder : result) : 0;\n    }\n\n    /**\n     * Converts `value` to an integer suitable for use as the length of an\n     * array-like object.\n     *\n     * **Note:** This method is based on\n     * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to convert.\n     * @returns {number} Returns the converted integer.\n     * @example\n     *\n     * _.toLength(3.2);\n     * // => 3\n     *\n     * _.toLength(Number.MIN_VALUE);\n     * // => 0\n     *\n     * _.toLength(Infinity);\n     * // => 4294967295\n     *\n     * _.toLength('3.2');\n     * // => 3\n     */\n    function toLength(value) {\n      return value ? baseClamp(toInteger(value), 0, MAX_ARRAY_LENGTH) : 0;\n    }\n\n    /**\n     * Converts `value` to a number.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to process.\n     * @returns {number} Returns the number.\n     * @example\n     *\n     * _.toNumber(3.2);\n     * // => 3.2\n     *\n     * _.toNumber(Number.MIN_VALUE);\n     * // => 5e-324\n     *\n     * _.toNumber(Infinity);\n     * // => Infinity\n     *\n     * _.toNumber('3.2');\n     * // => 3.2\n     */\n    function toNumber(value) {\n      if (typeof value == 'number') {\n        return value;\n      }\n      if (isSymbol(value)) {\n        return NAN;\n      }\n      if (isObject(value)) {\n        var other = typeof value.valueOf == 'function' ? value.valueOf() : value;\n        value = isObject(other) ? (other + '') : other;\n      }\n      if (typeof value != 'string') {\n        return value === 0 ? value : +value;\n      }\n      value = baseTrim(value);\n      var isBinary = reIsBinary.test(value);\n      return (isBinary || reIsOctal.test(value))\n        ? freeParseInt(value.slice(2), isBinary ? 2 : 8)\n        : (reIsBadHex.test(value) ? NAN : +value);\n    }\n\n    /**\n     * Converts `value` to a plain object flattening inherited enumerable string\n     * keyed properties of `value` to own properties of the plain object.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Lang\n     * @param {*} value The value to convert.\n     * @returns {Object} Returns the converted plain object.\n     * @example\n     *\n     * function Foo() {\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.assign({ 'a': 1 }, new Foo);\n     * // => { 'a': 1, 'b': 2 }\n     *\n     * _.assign({ 'a': 1 }, _.toPlainObject(new Foo));\n     * // => { 'a': 1, 'b': 2, 'c': 3 }\n     */\n    function toPlainObject(value) {\n      return copyObject(value, keysIn(value));\n    }\n\n    /**\n     * Converts `value` to a safe integer. A safe integer can be compared and\n     * represented correctly.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to convert.\n     * @returns {number} Returns the converted integer.\n     * @example\n     *\n     * _.toSafeInteger(3.2);\n     * // => 3\n     *\n     * _.toSafeInteger(Number.MIN_VALUE);\n     * // => 0\n     *\n     * _.toSafeInteger(Infinity);\n     * // => 9007199254740991\n     *\n     * _.toSafeInteger('3.2');\n     * // => 3\n     */\n    function toSafeInteger(value) {\n      return value\n        ? baseClamp(toInteger(value), -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER)\n        : (value === 0 ? value : 0);\n    }\n\n    /**\n     * Converts `value` to a string. An empty string is returned for `null`\n     * and `undefined` values. The sign of `-0` is preserved.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Lang\n     * @param {*} value The value to convert.\n     * @returns {string} Returns the converted string.\n     * @example\n     *\n     * _.toString(null);\n     * // => ''\n     *\n     * _.toString(-0);\n     * // => '-0'\n     *\n     * _.toString([1, 2, 3]);\n     * // => '1,2,3'\n     */\n    function toString(value) {\n      return value == null ? '' : baseToString(value);\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Assigns own enumerable string keyed properties of source objects to the\n     * destination object. Source objects are applied from left to right.\n     * Subsequent sources overwrite property assignments of previous sources.\n     *\n     * **Note:** This method mutates `object` and is loosely based on\n     * [`Object.assign`](https://mdn.io/Object/assign).\n     *\n     * @static\n     * @memberOf _\n     * @since 0.10.0\n     * @category Object\n     * @param {Object} object The destination object.\n     * @param {...Object} [sources] The source objects.\n     * @returns {Object} Returns `object`.\n     * @see _.assignIn\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     * }\n     *\n     * function Bar() {\n     *   this.c = 3;\n     * }\n     *\n     * Foo.prototype.b = 2;\n     * Bar.prototype.d = 4;\n     *\n     * _.assign({ 'a': 0 }, new Foo, new Bar);\n     * // => { 'a': 1, 'c': 3 }\n     */\n    var assign = createAssigner(function(object, source) {\n      if (isPrototype(source) || isArrayLike(source)) {\n        copyObject(source, keys(source), object);\n        return;\n      }\n      for (var key in source) {\n        if (hasOwnProperty.call(source, key)) {\n          assignValue(object, key, source[key]);\n        }\n      }\n    });\n\n    /**\n     * This method is like `_.assign` except that it iterates over own and\n     * inherited source properties.\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @alias extend\n     * @category Object\n     * @param {Object} object The destination object.\n     * @param {...Object} [sources] The source objects.\n     * @returns {Object} Returns `object`.\n     * @see _.assign\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     * }\n     *\n     * function Bar() {\n     *   this.c = 3;\n     * }\n     *\n     * Foo.prototype.b = 2;\n     * Bar.prototype.d = 4;\n     *\n     * _.assignIn({ 'a': 0 }, new Foo, new Bar);\n     * // => { 'a': 1, 'b': 2, 'c': 3, 'd': 4 }\n     */\n    var assignIn = createAssigner(function(object, source) {\n      copyObject(source, keysIn(source), object);\n    });\n\n    /**\n     * This method is like `_.assignIn` except that it accepts `customizer`\n     * which is invoked to produce the assigned values. If `customizer` returns\n     * `undefined`, assignment is handled by the method instead. The `customizer`\n     * is invoked with five arguments: (objValue, srcValue, key, object, source).\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @alias extendWith\n     * @category Object\n     * @param {Object} object The destination object.\n     * @param {...Object} sources The source objects.\n     * @param {Function} [customizer] The function to customize assigned values.\n     * @returns {Object} Returns `object`.\n     * @see _.assignWith\n     * @example\n     *\n     * function customizer(objValue, srcValue) {\n     *   return _.isUndefined(objValue) ? srcValue : objValue;\n     * }\n     *\n     * var defaults = _.partialRight(_.assignInWith, customizer);\n     *\n     * defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });\n     * // => { 'a': 1, 'b': 2 }\n     */\n    var assignInWith = createAssigner(function(object, source, srcIndex, customizer) {\n      copyObject(source, keysIn(source), object, customizer);\n    });\n\n    /**\n     * This method is like `_.assign` except that it accepts `customizer`\n     * which is invoked to produce the assigned values. If `customizer` returns\n     * `undefined`, assignment is handled by the method instead. The `customizer`\n     * is invoked with five arguments: (objValue, srcValue, key, object, source).\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Object\n     * @param {Object} object The destination object.\n     * @param {...Object} sources The source objects.\n     * @param {Function} [customizer] The function to customize assigned values.\n     * @returns {Object} Returns `object`.\n     * @see _.assignInWith\n     * @example\n     *\n     * function customizer(objValue, srcValue) {\n     *   return _.isUndefined(objValue) ? srcValue : objValue;\n     * }\n     *\n     * var defaults = _.partialRight(_.assignWith, customizer);\n     *\n     * defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });\n     * // => { 'a': 1, 'b': 2 }\n     */\n    var assignWith = createAssigner(function(object, source, srcIndex, customizer) {\n      copyObject(source, keys(source), object, customizer);\n    });\n\n    /**\n     * Creates an array of values corresponding to `paths` of `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 1.0.0\n     * @category Object\n     * @param {Object} object The object to iterate over.\n     * @param {...(string|string[])} [paths] The property paths to pick.\n     * @returns {Array} Returns the picked values.\n     * @example\n     *\n     * var object = { 'a': [{ 'b': { 'c': 3 } }, 4] };\n     *\n     * _.at(object, ['a[0].b.c', 'a[1]']);\n     * // => [3, 4]\n     */\n    var at = flatRest(baseAt);\n\n    /**\n     * Creates an object that inherits from the `prototype` object. If a\n     * `properties` object is given, its own enumerable string keyed properties\n     * are assigned to the created object.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.3.0\n     * @category Object\n     * @param {Object} prototype The object to inherit from.\n     * @param {Object} [properties] The properties to assign to the object.\n     * @returns {Object} Returns the new object.\n     * @example\n     *\n     * function Shape() {\n     *   this.x = 0;\n     *   this.y = 0;\n     * }\n     *\n     * function Circle() {\n     *   Shape.call(this);\n     * }\n     *\n     * Circle.prototype = _.create(Shape.prototype, {\n     *   'constructor': Circle\n     * });\n     *\n     * var circle = new Circle;\n     * circle instanceof Circle;\n     * // => true\n     *\n     * circle instanceof Shape;\n     * // => true\n     */\n    function create(prototype, properties) {\n      var result = baseCreate(prototype);\n      return properties == null ? result : baseAssign(result, properties);\n    }\n\n    /**\n     * Assigns own and inherited enumerable string keyed properties of source\n     * objects to the destination object for all destination properties that\n     * resolve to `undefined`. Source objects are applied from left to right.\n     * Once a property is set, additional values of the same property are ignored.\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The destination object.\n     * @param {...Object} [sources] The source objects.\n     * @returns {Object} Returns `object`.\n     * @see _.defaultsDeep\n     * @example\n     *\n     * _.defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });\n     * // => { 'a': 1, 'b': 2 }\n     */\n    var defaults = baseRest(function(object, sources) {\n      object = Object(object);\n\n      var index = -1;\n      var length = sources.length;\n      var guard = length > 2 ? sources[2] : undefined;\n\n      if (guard && isIterateeCall(sources[0], sources[1], guard)) {\n        length = 1;\n      }\n\n      while (++index < length) {\n        var source = sources[index];\n        var props = keysIn(source);\n        var propsIndex = -1;\n        var propsLength = props.length;\n\n        while (++propsIndex < propsLength) {\n          var key = props[propsIndex];\n          var value = object[key];\n\n          if (value === undefined ||\n              (eq(value, objectProto[key]) && !hasOwnProperty.call(object, key))) {\n            object[key] = source[key];\n          }\n        }\n      }\n\n      return object;\n    });\n\n    /**\n     * This method is like `_.defaults` except that it recursively assigns\n     * default properties.\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.10.0\n     * @category Object\n     * @param {Object} object The destination object.\n     * @param {...Object} [sources] The source objects.\n     * @returns {Object} Returns `object`.\n     * @see _.defaults\n     * @example\n     *\n     * _.defaultsDeep({ 'a': { 'b': 2 } }, { 'a': { 'b': 1, 'c': 3 } });\n     * // => { 'a': { 'b': 2, 'c': 3 } }\n     */\n    var defaultsDeep = baseRest(function(args) {\n      args.push(undefined, customDefaultsMerge);\n      return apply(mergeWith, undefined, args);\n    });\n\n    /**\n     * This method is like `_.find` except that it returns the key of the first\n     * element `predicate` returns truthy for instead of the element itself.\n     *\n     * @static\n     * @memberOf _\n     * @since 1.1.0\n     * @category Object\n     * @param {Object} object The object to inspect.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @returns {string|undefined} Returns the key of the matched element,\n     *  else `undefined`.\n     * @example\n     *\n     * var users = {\n     *   'barney':  { 'age': 36, 'active': true },\n     *   'fred':    { 'age': 40, 'active': false },\n     *   'pebbles': { 'age': 1,  'active': true }\n     * };\n     *\n     * _.findKey(users, function(o) { return o.age < 40; });\n     * // => 'barney' (iteration order is not guaranteed)\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.findKey(users, { 'age': 1, 'active': true });\n     * // => 'pebbles'\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.findKey(users, ['active', false]);\n     * // => 'fred'\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.findKey(users, 'active');\n     * // => 'barney'\n     */\n    function findKey(object, predicate) {\n      return baseFindKey(object, getIteratee(predicate, 3), baseForOwn);\n    }\n\n    /**\n     * This method is like `_.findKey` except that it iterates over elements of\n     * a collection in the opposite order.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.0.0\n     * @category Object\n     * @param {Object} object The object to inspect.\n     * @param {Function} [predicate=_.identity] The function invoked per iteration.\n     * @returns {string|undefined} Returns the key of the matched element,\n     *  else `undefined`.\n     * @example\n     *\n     * var users = {\n     *   'barney':  { 'age': 36, 'active': true },\n     *   'fred':    { 'age': 40, 'active': false },\n     *   'pebbles': { 'age': 1,  'active': true }\n     * };\n     *\n     * _.findLastKey(users, function(o) { return o.age < 40; });\n     * // => returns 'pebbles' assuming `_.findKey` returns 'barney'\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.findLastKey(users, { 'age': 36, 'active': true });\n     * // => 'barney'\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.findLastKey(users, ['active', false]);\n     * // => 'fred'\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.findLastKey(users, 'active');\n     * // => 'pebbles'\n     */\n    function findLastKey(object, predicate) {\n      return baseFindKey(object, getIteratee(predicate, 3), baseForOwnRight);\n    }\n\n    /**\n     * Iterates over own and inherited enumerable string keyed properties of an\n     * object and invokes `iteratee` for each property. The iteratee is invoked\n     * with three arguments: (value, key, object). Iteratee functions may exit\n     * iteration early by explicitly returning `false`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.3.0\n     * @category Object\n     * @param {Object} object The object to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Object} Returns `object`.\n     * @see _.forInRight\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.forIn(new Foo, function(value, key) {\n     *   console.log(key);\n     * });\n     * // => Logs 'a', 'b', then 'c' (iteration order is not guaranteed).\n     */\n    function forIn(object, iteratee) {\n      return object == null\n        ? object\n        : baseFor(object, getIteratee(iteratee, 3), keysIn);\n    }\n\n    /**\n     * This method is like `_.forIn` except that it iterates over properties of\n     * `object` in the opposite order.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.0.0\n     * @category Object\n     * @param {Object} object The object to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Object} Returns `object`.\n     * @see _.forIn\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.forInRight(new Foo, function(value, key) {\n     *   console.log(key);\n     * });\n     * // => Logs 'c', 'b', then 'a' assuming `_.forIn` logs 'a', 'b', then 'c'.\n     */\n    function forInRight(object, iteratee) {\n      return object == null\n        ? object\n        : baseForRight(object, getIteratee(iteratee, 3), keysIn);\n    }\n\n    /**\n     * Iterates over own enumerable string keyed properties of an object and\n     * invokes `iteratee` for each property. The iteratee is invoked with three\n     * arguments: (value, key, object). Iteratee functions may exit iteration\n     * early by explicitly returning `false`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.3.0\n     * @category Object\n     * @param {Object} object The object to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Object} Returns `object`.\n     * @see _.forOwnRight\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.forOwn(new Foo, function(value, key) {\n     *   console.log(key);\n     * });\n     * // => Logs 'a' then 'b' (iteration order is not guaranteed).\n     */\n    function forOwn(object, iteratee) {\n      return object && baseForOwn(object, getIteratee(iteratee, 3));\n    }\n\n    /**\n     * This method is like `_.forOwn` except that it iterates over properties of\n     * `object` in the opposite order.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.0.0\n     * @category Object\n     * @param {Object} object The object to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Object} Returns `object`.\n     * @see _.forOwn\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.forOwnRight(new Foo, function(value, key) {\n     *   console.log(key);\n     * });\n     * // => Logs 'b' then 'a' assuming `_.forOwn` logs 'a' then 'b'.\n     */\n    function forOwnRight(object, iteratee) {\n      return object && baseForOwnRight(object, getIteratee(iteratee, 3));\n    }\n\n    /**\n     * Creates an array of function property names from own enumerable properties\n     * of `object`.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The object to inspect.\n     * @returns {Array} Returns the function names.\n     * @see _.functionsIn\n     * @example\n     *\n     * function Foo() {\n     *   this.a = _.constant('a');\n     *   this.b = _.constant('b');\n     * }\n     *\n     * Foo.prototype.c = _.constant('c');\n     *\n     * _.functions(new Foo);\n     * // => ['a', 'b']\n     */\n    function functions(object) {\n      return object == null ? [] : baseFunctions(object, keys(object));\n    }\n\n    /**\n     * Creates an array of function property names from own and inherited\n     * enumerable properties of `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Object\n     * @param {Object} object The object to inspect.\n     * @returns {Array} Returns the function names.\n     * @see _.functions\n     * @example\n     *\n     * function Foo() {\n     *   this.a = _.constant('a');\n     *   this.b = _.constant('b');\n     * }\n     *\n     * Foo.prototype.c = _.constant('c');\n     *\n     * _.functionsIn(new Foo);\n     * // => ['a', 'b', 'c']\n     */\n    function functionsIn(object) {\n      return object == null ? [] : baseFunctions(object, keysIn(object));\n    }\n\n    /**\n     * Gets the value at `path` of `object`. If the resolved value is\n     * `undefined`, the `defaultValue` is returned in its place.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.7.0\n     * @category Object\n     * @param {Object} object The object to query.\n     * @param {Array|string} path The path of the property to get.\n     * @param {*} [defaultValue] The value returned for `undefined` resolved values.\n     * @returns {*} Returns the resolved value.\n     * @example\n     *\n     * var object = { 'a': [{ 'b': { 'c': 3 } }] };\n     *\n     * _.get(object, 'a[0].b.c');\n     * // => 3\n     *\n     * _.get(object, ['a', '0', 'b', 'c']);\n     * // => 3\n     *\n     * _.get(object, 'a.b.c', 'default');\n     * // => 'default'\n     */\n    function get(object, path, defaultValue) {\n      var result = object == null ? undefined : baseGet(object, path);\n      return result === undefined ? defaultValue : result;\n    }\n\n    /**\n     * Checks if `path` is a direct property of `object`.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The object to query.\n     * @param {Array|string} path The path to check.\n     * @returns {boolean} Returns `true` if `path` exists, else `false`.\n     * @example\n     *\n     * var object = { 'a': { 'b': 2 } };\n     * var other = _.create({ 'a': _.create({ 'b': 2 }) });\n     *\n     * _.has(object, 'a');\n     * // => true\n     *\n     * _.has(object, 'a.b');\n     * // => true\n     *\n     * _.has(object, ['a', 'b']);\n     * // => true\n     *\n     * _.has(other, 'a');\n     * // => false\n     */\n    function has(object, path) {\n      return object != null && hasPath(object, path, baseHas);\n    }\n\n    /**\n     * Checks if `path` is a direct or inherited property of `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Object\n     * @param {Object} object The object to query.\n     * @param {Array|string} path The path to check.\n     * @returns {boolean} Returns `true` if `path` exists, else `false`.\n     * @example\n     *\n     * var object = _.create({ 'a': _.create({ 'b': 2 }) });\n     *\n     * _.hasIn(object, 'a');\n     * // => true\n     *\n     * _.hasIn(object, 'a.b');\n     * // => true\n     *\n     * _.hasIn(object, ['a', 'b']);\n     * // => true\n     *\n     * _.hasIn(object, 'b');\n     * // => false\n     */\n    function hasIn(object, path) {\n      return object != null && hasPath(object, path, baseHasIn);\n    }\n\n    /**\n     * Creates an object composed of the inverted keys and values of `object`.\n     * If `object` contains duplicate values, subsequent values overwrite\n     * property assignments of previous values.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.7.0\n     * @category Object\n     * @param {Object} object The object to invert.\n     * @returns {Object} Returns the new inverted object.\n     * @example\n     *\n     * var object = { 'a': 1, 'b': 2, 'c': 1 };\n     *\n     * _.invert(object);\n     * // => { '1': 'c', '2': 'b' }\n     */\n    var invert = createInverter(function(result, value, key) {\n      if (value != null &&\n          typeof value.toString != 'function') {\n        value = nativeObjectToString.call(value);\n      }\n\n      result[value] = key;\n    }, constant(identity));\n\n    /**\n     * This method is like `_.invert` except that the inverted object is generated\n     * from the results of running each element of `object` thru `iteratee`. The\n     * corresponding inverted value of each inverted key is an array of keys\n     * responsible for generating the inverted value. The iteratee is invoked\n     * with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.1.0\n     * @category Object\n     * @param {Object} object The object to invert.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {Object} Returns the new inverted object.\n     * @example\n     *\n     * var object = { 'a': 1, 'b': 2, 'c': 1 };\n     *\n     * _.invertBy(object);\n     * // => { '1': ['a', 'c'], '2': ['b'] }\n     *\n     * _.invertBy(object, function(value) {\n     *   return 'group' + value;\n     * });\n     * // => { 'group1': ['a', 'c'], 'group2': ['b'] }\n     */\n    var invertBy = createInverter(function(result, value, key) {\n      if (value != null &&\n          typeof value.toString != 'function') {\n        value = nativeObjectToString.call(value);\n      }\n\n      if (hasOwnProperty.call(result, value)) {\n        result[value].push(key);\n      } else {\n        result[value] = [key];\n      }\n    }, getIteratee);\n\n    /**\n     * Invokes the method at `path` of `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Object\n     * @param {Object} object The object to query.\n     * @param {Array|string} path The path of the method to invoke.\n     * @param {...*} [args] The arguments to invoke the method with.\n     * @returns {*} Returns the result of the invoked method.\n     * @example\n     *\n     * var object = { 'a': [{ 'b': { 'c': [1, 2, 3, 4] } }] };\n     *\n     * _.invoke(object, 'a[0].b.c.slice', 1, 3);\n     * // => [2, 3]\n     */\n    var invoke = baseRest(baseInvoke);\n\n    /**\n     * Creates an array of the own enumerable property names of `object`.\n     *\n     * **Note:** Non-object values are coerced to objects. See the\n     * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n     * for more details.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the array of property names.\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.keys(new Foo);\n     * // => ['a', 'b'] (iteration order is not guaranteed)\n     *\n     * _.keys('hi');\n     * // => ['0', '1']\n     */\n    function keys(object) {\n      return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);\n    }\n\n    /**\n     * Creates an array of the own and inherited enumerable property names of `object`.\n     *\n     * **Note:** Non-object values are coerced to objects.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Object\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the array of property names.\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.keysIn(new Foo);\n     * // => ['a', 'b', 'c'] (iteration order is not guaranteed)\n     */\n    function keysIn(object) {\n      return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);\n    }\n\n    /**\n     * The opposite of `_.mapValues`; this method creates an object with the\n     * same values as `object` and keys generated by running each own enumerable\n     * string keyed property of `object` thru `iteratee`. The iteratee is invoked\n     * with three arguments: (value, key, object).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.8.0\n     * @category Object\n     * @param {Object} object The object to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Object} Returns the new mapped object.\n     * @see _.mapValues\n     * @example\n     *\n     * _.mapKeys({ 'a': 1, 'b': 2 }, function(value, key) {\n     *   return key + value;\n     * });\n     * // => { 'a1': 1, 'b2': 2 }\n     */\n    function mapKeys(object, iteratee) {\n      var result = {};\n      iteratee = getIteratee(iteratee, 3);\n\n      baseForOwn(object, function(value, key, object) {\n        baseAssignValue(result, iteratee(value, key, object), value);\n      });\n      return result;\n    }\n\n    /**\n     * Creates an object with the same keys as `object` and values generated\n     * by running each own enumerable string keyed property of `object` thru\n     * `iteratee`. The iteratee is invoked with three arguments:\n     * (value, key, object).\n     *\n     * @static\n     * @memberOf _\n     * @since 2.4.0\n     * @category Object\n     * @param {Object} object The object to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Object} Returns the new mapped object.\n     * @see _.mapKeys\n     * @example\n     *\n     * var users = {\n     *   'fred':    { 'user': 'fred',    'age': 40 },\n     *   'pebbles': { 'user': 'pebbles', 'age': 1 }\n     * };\n     *\n     * _.mapValues(users, function(o) { return o.age; });\n     * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.mapValues(users, 'age');\n     * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)\n     */\n    function mapValues(object, iteratee) {\n      var result = {};\n      iteratee = getIteratee(iteratee, 3);\n\n      baseForOwn(object, function(value, key, object) {\n        baseAssignValue(result, key, iteratee(value, key, object));\n      });\n      return result;\n    }\n\n    /**\n     * This method is like `_.assign` except that it recursively merges own and\n     * inherited enumerable string keyed properties of source objects into the\n     * destination object. Source properties that resolve to `undefined` are\n     * skipped if a destination value exists. Array and plain object properties\n     * are merged recursively. Other objects and value types are overridden by\n     * assignment. Source objects are applied from left to right. Subsequent\n     * sources overwrite property assignments of previous sources.\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.5.0\n     * @category Object\n     * @param {Object} object The destination object.\n     * @param {...Object} [sources] The source objects.\n     * @returns {Object} Returns `object`.\n     * @example\n     *\n     * var object = {\n     *   'a': [{ 'b': 2 }, { 'd': 4 }]\n     * };\n     *\n     * var other = {\n     *   'a': [{ 'c': 3 }, { 'e': 5 }]\n     * };\n     *\n     * _.merge(object, other);\n     * // => { 'a': [{ 'b': 2, 'c': 3 }, { 'd': 4, 'e': 5 }] }\n     */\n    var merge = createAssigner(function(object, source, srcIndex) {\n      baseMerge(object, source, srcIndex);\n    });\n\n    /**\n     * This method is like `_.merge` except that it accepts `customizer` which\n     * is invoked to produce the merged values of the destination and source\n     * properties. If `customizer` returns `undefined`, merging is handled by the\n     * method instead. The `customizer` is invoked with six arguments:\n     * (objValue, srcValue, key, object, source, stack).\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Object\n     * @param {Object} object The destination object.\n     * @param {...Object} sources The source objects.\n     * @param {Function} customizer The function to customize assigned values.\n     * @returns {Object} Returns `object`.\n     * @example\n     *\n     * function customizer(objValue, srcValue) {\n     *   if (_.isArray(objValue)) {\n     *     return objValue.concat(srcValue);\n     *   }\n     * }\n     *\n     * var object = { 'a': [1], 'b': [2] };\n     * var other = { 'a': [3], 'b': [4] };\n     *\n     * _.mergeWith(object, other, customizer);\n     * // => { 'a': [1, 3], 'b': [2, 4] }\n     */\n    var mergeWith = createAssigner(function(object, source, srcIndex, customizer) {\n      baseMerge(object, source, srcIndex, customizer);\n    });\n\n    /**\n     * The opposite of `_.pick`; this method creates an object composed of the\n     * own and inherited enumerable property paths of `object` that are not omitted.\n     *\n     * **Note:** This method is considerably slower than `_.pick`.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The source object.\n     * @param {...(string|string[])} [paths] The property paths to omit.\n     * @returns {Object} Returns the new object.\n     * @example\n     *\n     * var object = { 'a': 1, 'b': '2', 'c': 3 };\n     *\n     * _.omit(object, ['a', 'c']);\n     * // => { 'b': '2' }\n     */\n    var omit = flatRest(function(object, paths) {\n      var result = {};\n      if (object == null) {\n        return result;\n      }\n      var isDeep = false;\n      paths = arrayMap(paths, function(path) {\n        path = castPath(path, object);\n        isDeep || (isDeep = path.length > 1);\n        return path;\n      });\n      copyObject(object, getAllKeysIn(object), result);\n      if (isDeep) {\n        result = baseClone(result, CLONE_DEEP_FLAG | CLONE_FLAT_FLAG | CLONE_SYMBOLS_FLAG, customOmitClone);\n      }\n      var length = paths.length;\n      while (length--) {\n        baseUnset(result, paths[length]);\n      }\n      return result;\n    });\n\n    /**\n     * The opposite of `_.pickBy`; this method creates an object composed of\n     * the own and inherited enumerable string keyed properties of `object` that\n     * `predicate` doesn't return truthy for. The predicate is invoked with two\n     * arguments: (value, key).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Object\n     * @param {Object} object The source object.\n     * @param {Function} [predicate=_.identity] The function invoked per property.\n     * @returns {Object} Returns the new object.\n     * @example\n     *\n     * var object = { 'a': 1, 'b': '2', 'c': 3 };\n     *\n     * _.omitBy(object, _.isNumber);\n     * // => { 'b': '2' }\n     */\n    function omitBy(object, predicate) {\n      return pickBy(object, negate(getIteratee(predicate)));\n    }\n\n    /**\n     * Creates an object composed of the picked `object` properties.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The source object.\n     * @param {...(string|string[])} [paths] The property paths to pick.\n     * @returns {Object} Returns the new object.\n     * @example\n     *\n     * var object = { 'a': 1, 'b': '2', 'c': 3 };\n     *\n     * _.pick(object, ['a', 'c']);\n     * // => { 'a': 1, 'c': 3 }\n     */\n    var pick = flatRest(function(object, paths) {\n      return object == null ? {} : basePick(object, paths);\n    });\n\n    /**\n     * Creates an object composed of the `object` properties `predicate` returns\n     * truthy for. The predicate is invoked with two arguments: (value, key).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Object\n     * @param {Object} object The source object.\n     * @param {Function} [predicate=_.identity] The function invoked per property.\n     * @returns {Object} Returns the new object.\n     * @example\n     *\n     * var object = { 'a': 1, 'b': '2', 'c': 3 };\n     *\n     * _.pickBy(object, _.isNumber);\n     * // => { 'a': 1, 'c': 3 }\n     */\n    function pickBy(object, predicate) {\n      if (object == null) {\n        return {};\n      }\n      var props = arrayMap(getAllKeysIn(object), function(prop) {\n        return [prop];\n      });\n      predicate = getIteratee(predicate);\n      return basePickBy(object, props, function(value, path) {\n        return predicate(value, path[0]);\n      });\n    }\n\n    /**\n     * This method is like `_.get` except that if the resolved value is a\n     * function it's invoked with the `this` binding of its parent object and\n     * its result is returned.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The object to query.\n     * @param {Array|string} path The path of the property to resolve.\n     * @param {*} [defaultValue] The value returned for `undefined` resolved values.\n     * @returns {*} Returns the resolved value.\n     * @example\n     *\n     * var object = { 'a': [{ 'b': { 'c1': 3, 'c2': _.constant(4) } }] };\n     *\n     * _.result(object, 'a[0].b.c1');\n     * // => 3\n     *\n     * _.result(object, 'a[0].b.c2');\n     * // => 4\n     *\n     * _.result(object, 'a[0].b.c3', 'default');\n     * // => 'default'\n     *\n     * _.result(object, 'a[0].b.c3', _.constant('default'));\n     * // => 'default'\n     */\n    function result(object, path, defaultValue) {\n      path = castPath(path, object);\n\n      var index = -1,\n          length = path.length;\n\n      // Ensure the loop is entered when path is empty.\n      if (!length) {\n        length = 1;\n        object = undefined;\n      }\n      while (++index < length) {\n        var value = object == null ? undefined : object[toKey(path[index])];\n        if (value === undefined) {\n          index = length;\n          value = defaultValue;\n        }\n        object = isFunction(value) ? value.call(object) : value;\n      }\n      return object;\n    }\n\n    /**\n     * Sets the value at `path` of `object`. If a portion of `path` doesn't exist,\n     * it's created. Arrays are created for missing index properties while objects\n     * are created for all other missing properties. Use `_.setWith` to customize\n     * `path` creation.\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.7.0\n     * @category Object\n     * @param {Object} object The object to modify.\n     * @param {Array|string} path The path of the property to set.\n     * @param {*} value The value to set.\n     * @returns {Object} Returns `object`.\n     * @example\n     *\n     * var object = { 'a': [{ 'b': { 'c': 3 } }] };\n     *\n     * _.set(object, 'a[0].b.c', 4);\n     * console.log(object.a[0].b.c);\n     * // => 4\n     *\n     * _.set(object, ['x', '0', 'y', 'z'], 5);\n     * console.log(object.x[0].y.z);\n     * // => 5\n     */\n    function set(object, path, value) {\n      return object == null ? object : baseSet(object, path, value);\n    }\n\n    /**\n     * This method is like `_.set` except that it accepts `customizer` which is\n     * invoked to produce the objects of `path`.  If `customizer` returns `undefined`\n     * path creation is handled by the method instead. The `customizer` is invoked\n     * with three arguments: (nsValue, key, nsObject).\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Object\n     * @param {Object} object The object to modify.\n     * @param {Array|string} path The path of the property to set.\n     * @param {*} value The value to set.\n     * @param {Function} [customizer] The function to customize assigned values.\n     * @returns {Object} Returns `object`.\n     * @example\n     *\n     * var object = {};\n     *\n     * _.setWith(object, '[0][1]', 'a', Object);\n     * // => { '0': { '1': 'a' } }\n     */\n    function setWith(object, path, value, customizer) {\n      customizer = typeof customizer == 'function' ? customizer : undefined;\n      return object == null ? object : baseSet(object, path, value, customizer);\n    }\n\n    /**\n     * Creates an array of own enumerable string keyed-value pairs for `object`\n     * which can be consumed by `_.fromPairs`. If `object` is a map or set, its\n     * entries are returned.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @alias entries\n     * @category Object\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the key-value pairs.\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.toPairs(new Foo);\n     * // => [['a', 1], ['b', 2]] (iteration order is not guaranteed)\n     */\n    var toPairs = createToPairs(keys);\n\n    /**\n     * Creates an array of own and inherited enumerable string keyed-value pairs\n     * for `object` which can be consumed by `_.fromPairs`. If `object` is a map\n     * or set, its entries are returned.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @alias entriesIn\n     * @category Object\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the key-value pairs.\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.toPairsIn(new Foo);\n     * // => [['a', 1], ['b', 2], ['c', 3]] (iteration order is not guaranteed)\n     */\n    var toPairsIn = createToPairs(keysIn);\n\n    /**\n     * An alternative to `_.reduce`; this method transforms `object` to a new\n     * `accumulator` object which is the result of running each of its own\n     * enumerable string keyed properties thru `iteratee`, with each invocation\n     * potentially mutating the `accumulator` object. If `accumulator` is not\n     * provided, a new object with the same `[[Prototype]]` will be used. The\n     * iteratee is invoked with four arguments: (accumulator, value, key, object).\n     * Iteratee functions may exit iteration early by explicitly returning `false`.\n     *\n     * @static\n     * @memberOf _\n     * @since 1.3.0\n     * @category Object\n     * @param {Object} object The object to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @param {*} [accumulator] The custom accumulator value.\n     * @returns {*} Returns the accumulated value.\n     * @example\n     *\n     * _.transform([2, 3, 4], function(result, n) {\n     *   result.push(n *= n);\n     *   return n % 2 == 0;\n     * }, []);\n     * // => [4, 9]\n     *\n     * _.transform({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) {\n     *   (result[value] || (result[value] = [])).push(key);\n     * }, {});\n     * // => { '1': ['a', 'c'], '2': ['b'] }\n     */\n    function transform(object, iteratee, accumulator) {\n      var isArr = isArray(object),\n          isArrLike = isArr || isBuffer(object) || isTypedArray(object);\n\n      iteratee = getIteratee(iteratee, 4);\n      if (accumulator == null) {\n        var Ctor = object && object.constructor;\n        if (isArrLike) {\n          accumulator = isArr ? new Ctor : [];\n        }\n        else if (isObject(object)) {\n          accumulator = isFunction(Ctor) ? baseCreate(getPrototype(object)) : {};\n        }\n        else {\n          accumulator = {};\n        }\n      }\n      (isArrLike ? arrayEach : baseForOwn)(object, function(value, index, object) {\n        return iteratee(accumulator, value, index, object);\n      });\n      return accumulator;\n    }\n\n    /**\n     * Removes the property at `path` of `object`.\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Object\n     * @param {Object} object The object to modify.\n     * @param {Array|string} path The path of the property to unset.\n     * @returns {boolean} Returns `true` if the property is deleted, else `false`.\n     * @example\n     *\n     * var object = { 'a': [{ 'b': { 'c': 7 } }] };\n     * _.unset(object, 'a[0].b.c');\n     * // => true\n     *\n     * console.log(object);\n     * // => { 'a': [{ 'b': {} }] };\n     *\n     * _.unset(object, ['a', '0', 'b', 'c']);\n     * // => true\n     *\n     * console.log(object);\n     * // => { 'a': [{ 'b': {} }] };\n     */\n    function unset(object, path) {\n      return object == null ? true : baseUnset(object, path);\n    }\n\n    /**\n     * This method is like `_.set` except that accepts `updater` to produce the\n     * value to set. Use `_.updateWith` to customize `path` creation. The `updater`\n     * is invoked with one argument: (value).\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.6.0\n     * @category Object\n     * @param {Object} object The object to modify.\n     * @param {Array|string} path The path of the property to set.\n     * @param {Function} updater The function to produce the updated value.\n     * @returns {Object} Returns `object`.\n     * @example\n     *\n     * var object = { 'a': [{ 'b': { 'c': 3 } }] };\n     *\n     * _.update(object, 'a[0].b.c', function(n) { return n * n; });\n     * console.log(object.a[0].b.c);\n     * // => 9\n     *\n     * _.update(object, 'x[0].y.z', function(n) { return n ? n + 1 : 0; });\n     * console.log(object.x[0].y.z);\n     * // => 0\n     */\n    function update(object, path, updater) {\n      return object == null ? object : baseUpdate(object, path, castFunction(updater));\n    }\n\n    /**\n     * This method is like `_.update` except that it accepts `customizer` which is\n     * invoked to produce the objects of `path`.  If `customizer` returns `undefined`\n     * path creation is handled by the method instead. The `customizer` is invoked\n     * with three arguments: (nsValue, key, nsObject).\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.6.0\n     * @category Object\n     * @param {Object} object The object to modify.\n     * @param {Array|string} path The path of the property to set.\n     * @param {Function} updater The function to produce the updated value.\n     * @param {Function} [customizer] The function to customize assigned values.\n     * @returns {Object} Returns `object`.\n     * @example\n     *\n     * var object = {};\n     *\n     * _.updateWith(object, '[0][1]', _.constant('a'), Object);\n     * // => { '0': { '1': 'a' } }\n     */\n    function updateWith(object, path, updater, customizer) {\n      customizer = typeof customizer == 'function' ? customizer : undefined;\n      return object == null ? object : baseUpdate(object, path, castFunction(updater), customizer);\n    }\n\n    /**\n     * Creates an array of the own enumerable string keyed property values of `object`.\n     *\n     * **Note:** Non-object values are coerced to objects.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the array of property values.\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.values(new Foo);\n     * // => [1, 2] (iteration order is not guaranteed)\n     *\n     * _.values('hi');\n     * // => ['h', 'i']\n     */\n    function values(object) {\n      return object == null ? [] : baseValues(object, keys(object));\n    }\n\n    /**\n     * Creates an array of the own and inherited enumerable string keyed property\n     * values of `object`.\n     *\n     * **Note:** Non-object values are coerced to objects.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Object\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the array of property values.\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.valuesIn(new Foo);\n     * // => [1, 2, 3] (iteration order is not guaranteed)\n     */\n    function valuesIn(object) {\n      return object == null ? [] : baseValues(object, keysIn(object));\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Clamps `number` within the inclusive `lower` and `upper` bounds.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Number\n     * @param {number} number The number to clamp.\n     * @param {number} [lower] The lower bound.\n     * @param {number} upper The upper bound.\n     * @returns {number} Returns the clamped number.\n     * @example\n     *\n     * _.clamp(-10, -5, 5);\n     * // => -5\n     *\n     * _.clamp(10, -5, 5);\n     * // => 5\n     */\n    function clamp(number, lower, upper) {\n      if (upper === undefined) {\n        upper = lower;\n        lower = undefined;\n      }\n      if (upper !== undefined) {\n        upper = toNumber(upper);\n        upper = upper === upper ? upper : 0;\n      }\n      if (lower !== undefined) {\n        lower = toNumber(lower);\n        lower = lower === lower ? lower : 0;\n      }\n      return baseClamp(toNumber(number), lower, upper);\n    }\n\n    /**\n     * Checks if `n` is between `start` and up to, but not including, `end`. If\n     * `end` is not specified, it's set to `start` with `start` then set to `0`.\n     * If `start` is greater than `end` the params are swapped to support\n     * negative ranges.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.3.0\n     * @category Number\n     * @param {number} number The number to check.\n     * @param {number} [start=0] The start of the range.\n     * @param {number} end The end of the range.\n     * @returns {boolean} Returns `true` if `number` is in the range, else `false`.\n     * @see _.range, _.rangeRight\n     * @example\n     *\n     * _.inRange(3, 2, 4);\n     * // => true\n     *\n     * _.inRange(4, 8);\n     * // => true\n     *\n     * _.inRange(4, 2);\n     * // => false\n     *\n     * _.inRange(2, 2);\n     * // => false\n     *\n     * _.inRange(1.2, 2);\n     * // => true\n     *\n     * _.inRange(5.2, 4);\n     * // => false\n     *\n     * _.inRange(-3, -2, -6);\n     * // => true\n     */\n    function inRange(number, start, end) {\n      start = toFinite(start);\n      if (end === undefined) {\n        end = start;\n        start = 0;\n      } else {\n        end = toFinite(end);\n      }\n      number = toNumber(number);\n      return baseInRange(number, start, end);\n    }\n\n    /**\n     * Produces a random number between the inclusive `lower` and `upper` bounds.\n     * If only one argument is provided a number between `0` and the given number\n     * is returned. If `floating` is `true`, or either `lower` or `upper` are\n     * floats, a floating-point number is returned instead of an integer.\n     *\n     * **Note:** JavaScript follows the IEEE-754 standard for resolving\n     * floating-point values which can produce unexpected results.\n     *\n     * @static\n     * @memberOf _\n     * @since 0.7.0\n     * @category Number\n     * @param {number} [lower=0] The lower bound.\n     * @param {number} [upper=1] The upper bound.\n     * @param {boolean} [floating] Specify returning a floating-point number.\n     * @returns {number} Returns the random number.\n     * @example\n     *\n     * _.random(0, 5);\n     * // => an integer between 0 and 5\n     *\n     * _.random(5);\n     * // => also an integer between 0 and 5\n     *\n     * _.random(5, true);\n     * // => a floating-point number between 0 and 5\n     *\n     * _.random(1.2, 5.2);\n     * // => a floating-point number between 1.2 and 5.2\n     */\n    function random(lower, upper, floating) {\n      if (floating && typeof floating != 'boolean' && isIterateeCall(lower, upper, floating)) {\n        upper = floating = undefined;\n      }\n      if (floating === undefined) {\n        if (typeof upper == 'boolean') {\n          floating = upper;\n          upper = undefined;\n        }\n        else if (typeof lower == 'boolean') {\n          floating = lower;\n          lower = undefined;\n        }\n      }\n      if (lower === undefined && upper === undefined) {\n        lower = 0;\n        upper = 1;\n      }\n      else {\n        lower = toFinite(lower);\n        if (upper === undefined) {\n          upper = lower;\n          lower = 0;\n        } else {\n          upper = toFinite(upper);\n        }\n      }\n      if (lower > upper) {\n        var temp = lower;\n        lower = upper;\n        upper = temp;\n      }\n      if (floating || lower % 1 || upper % 1) {\n        var rand = nativeRandom();\n        return nativeMin(lower + (rand * (upper - lower + freeParseFloat('1e-' + ((rand + '').length - 1)))), upper);\n      }\n      return baseRandom(lower, upper);\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Converts `string` to [camel case](https://en.wikipedia.org/wiki/CamelCase).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the camel cased string.\n     * @example\n     *\n     * _.camelCase('Foo Bar');\n     * // => 'fooBar'\n     *\n     * _.camelCase('--foo-bar--');\n     * // => 'fooBar'\n     *\n     * _.camelCase('__FOO_BAR__');\n     * // => 'fooBar'\n     */\n    var camelCase = createCompounder(function(result, word, index) {\n      word = word.toLowerCase();\n      return result + (index ? capitalize(word) : word);\n    });\n\n    /**\n     * Converts the first character of `string` to upper case and the remaining\n     * to lower case.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to capitalize.\n     * @returns {string} Returns the capitalized string.\n     * @example\n     *\n     * _.capitalize('FRED');\n     * // => 'Fred'\n     */\n    function capitalize(string) {\n      return upperFirst(toString(string).toLowerCase());\n    }\n\n    /**\n     * Deburrs `string` by converting\n     * [Latin-1 Supplement](https://en.wikipedia.org/wiki/Latin-1_Supplement_(Unicode_block)#Character_table)\n     * and [Latin Extended-A](https://en.wikipedia.org/wiki/Latin_Extended-A)\n     * letters to basic Latin letters and removing\n     * [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to deburr.\n     * @returns {string} Returns the deburred string.\n     * @example\n     *\n     * _.deburr('déjà vu');\n     * // => 'deja vu'\n     */\n    function deburr(string) {\n      string = toString(string);\n      return string && string.replace(reLatin, deburrLetter).replace(reComboMark, '');\n    }\n\n    /**\n     * Checks if `string` ends with the given target string.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to inspect.\n     * @param {string} [target] The string to search for.\n     * @param {number} [position=string.length] The position to search up to.\n     * @returns {boolean} Returns `true` if `string` ends with `target`,\n     *  else `false`.\n     * @example\n     *\n     * _.endsWith('abc', 'c');\n     * // => true\n     *\n     * _.endsWith('abc', 'b');\n     * // => false\n     *\n     * _.endsWith('abc', 'b', 2);\n     * // => true\n     */\n    function endsWith(string, target, position) {\n      string = toString(string);\n      target = baseToString(target);\n\n      var length = string.length;\n      position = position === undefined\n        ? length\n        : baseClamp(toInteger(position), 0, length);\n\n      var end = position;\n      position -= target.length;\n      return position >= 0 && string.slice(position, end) == target;\n    }\n\n    /**\n     * Converts the characters \"&\", \"<\", \">\", '\"', and \"'\" in `string` to their\n     * corresponding HTML entities.\n     *\n     * **Note:** No other characters are escaped. To escape additional\n     * characters use a third-party library like [_he_](https://mths.be/he).\n     *\n     * Though the \">\" character is escaped for symmetry, characters like\n     * \">\" and \"/\" don't need escaping in HTML and have no special meaning\n     * unless they're part of a tag or unquoted attribute value. See\n     * [Mathias Bynens's article](https://mathiasbynens.be/notes/ambiguous-ampersands)\n     * (under \"semi-related fun fact\") for more details.\n     *\n     * When working with HTML you should always\n     * [quote attribute values](http://wonko.com/post/html-escaping) to reduce\n     * XSS vectors.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category String\n     * @param {string} [string=''] The string to escape.\n     * @returns {string} Returns the escaped string.\n     * @example\n     *\n     * _.escape('fred, barney, & pebbles');\n     * // => 'fred, barney, &amp; pebbles'\n     */\n    function escape(string) {\n      string = toString(string);\n      return (string && reHasUnescapedHtml.test(string))\n        ? string.replace(reUnescapedHtml, escapeHtmlChar)\n        : string;\n    }\n\n    /**\n     * Escapes the `RegExp` special characters \"^\", \"$\", \"\\\", \".\", \"*\", \"+\",\n     * \"?\", \"(\", \")\", \"[\", \"]\", \"{\", \"}\", and \"|\" in `string`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to escape.\n     * @returns {string} Returns the escaped string.\n     * @example\n     *\n     * _.escapeRegExp('[lodash](https://lodash.com/)');\n     * // => '\\[lodash\\]\\(https://lodash\\.com/\\)'\n     */\n    function escapeRegExp(string) {\n      string = toString(string);\n      return (string && reHasRegExpChar.test(string))\n        ? string.replace(reRegExpChar, '\\\\$&')\n        : string;\n    }\n\n    /**\n     * Converts `string` to\n     * [kebab case](https://en.wikipedia.org/wiki/Letter_case#Special_case_styles).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the kebab cased string.\n     * @example\n     *\n     * _.kebabCase('Foo Bar');\n     * // => 'foo-bar'\n     *\n     * _.kebabCase('fooBar');\n     * // => 'foo-bar'\n     *\n     * _.kebabCase('__FOO_BAR__');\n     * // => 'foo-bar'\n     */\n    var kebabCase = createCompounder(function(result, word, index) {\n      return result + (index ? '-' : '') + word.toLowerCase();\n    });\n\n    /**\n     * Converts `string`, as space separated words, to lower case.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the lower cased string.\n     * @example\n     *\n     * _.lowerCase('--Foo-Bar--');\n     * // => 'foo bar'\n     *\n     * _.lowerCase('fooBar');\n     * // => 'foo bar'\n     *\n     * _.lowerCase('__FOO_BAR__');\n     * // => 'foo bar'\n     */\n    var lowerCase = createCompounder(function(result, word, index) {\n      return result + (index ? ' ' : '') + word.toLowerCase();\n    });\n\n    /**\n     * Converts the first character of `string` to lower case.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the converted string.\n     * @example\n     *\n     * _.lowerFirst('Fred');\n     * // => 'fred'\n     *\n     * _.lowerFirst('FRED');\n     * // => 'fRED'\n     */\n    var lowerFirst = createCaseFirst('toLowerCase');\n\n    /**\n     * Pads `string` on the left and right sides if it's shorter than `length`.\n     * Padding characters are truncated if they can't be evenly divided by `length`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to pad.\n     * @param {number} [length=0] The padding length.\n     * @param {string} [chars=' '] The string used as padding.\n     * @returns {string} Returns the padded string.\n     * @example\n     *\n     * _.pad('abc', 8);\n     * // => '  abc   '\n     *\n     * _.pad('abc', 8, '_-');\n     * // => '_-abc_-_'\n     *\n     * _.pad('abc', 3);\n     * // => 'abc'\n     */\n    function pad(string, length, chars) {\n      string = toString(string);\n      length = toInteger(length);\n\n      var strLength = length ? stringSize(string) : 0;\n      if (!length || strLength >= length) {\n        return string;\n      }\n      var mid = (length - strLength) / 2;\n      return (\n        createPadding(nativeFloor(mid), chars) +\n        string +\n        createPadding(nativeCeil(mid), chars)\n      );\n    }\n\n    /**\n     * Pads `string` on the right side if it's shorter than `length`. Padding\n     * characters are truncated if they exceed `length`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to pad.\n     * @param {number} [length=0] The padding length.\n     * @param {string} [chars=' '] The string used as padding.\n     * @returns {string} Returns the padded string.\n     * @example\n     *\n     * _.padEnd('abc', 6);\n     * // => 'abc   '\n     *\n     * _.padEnd('abc', 6, '_-');\n     * // => 'abc_-_'\n     *\n     * _.padEnd('abc', 3);\n     * // => 'abc'\n     */\n    function padEnd(string, length, chars) {\n      string = toString(string);\n      length = toInteger(length);\n\n      var strLength = length ? stringSize(string) : 0;\n      return (length && strLength < length)\n        ? (string + createPadding(length - strLength, chars))\n        : string;\n    }\n\n    /**\n     * Pads `string` on the left side if it's shorter than `length`. Padding\n     * characters are truncated if they exceed `length`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to pad.\n     * @param {number} [length=0] The padding length.\n     * @param {string} [chars=' '] The string used as padding.\n     * @returns {string} Returns the padded string.\n     * @example\n     *\n     * _.padStart('abc', 6);\n     * // => '   abc'\n     *\n     * _.padStart('abc', 6, '_-');\n     * // => '_-_abc'\n     *\n     * _.padStart('abc', 3);\n     * // => 'abc'\n     */\n    function padStart(string, length, chars) {\n      string = toString(string);\n      length = toInteger(length);\n\n      var strLength = length ? stringSize(string) : 0;\n      return (length && strLength < length)\n        ? (createPadding(length - strLength, chars) + string)\n        : string;\n    }\n\n    /**\n     * Converts `string` to an integer of the specified radix. If `radix` is\n     * `undefined` or `0`, a `radix` of `10` is used unless `value` is a\n     * hexadecimal, in which case a `radix` of `16` is used.\n     *\n     * **Note:** This method aligns with the\n     * [ES5 implementation](https://es5.github.io/#x15.1.2.2) of `parseInt`.\n     *\n     * @static\n     * @memberOf _\n     * @since 1.1.0\n     * @category String\n     * @param {string} string The string to convert.\n     * @param {number} [radix=10] The radix to interpret `value` by.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {number} Returns the converted integer.\n     * @example\n     *\n     * _.parseInt('08');\n     * // => 8\n     *\n     * _.map(['6', '08', '10'], _.parseInt);\n     * // => [6, 8, 10]\n     */\n    function parseInt(string, radix, guard) {\n      if (guard || radix == null) {\n        radix = 0;\n      } else if (radix) {\n        radix = +radix;\n      }\n      return nativeParseInt(toString(string).replace(reTrimStart, ''), radix || 0);\n    }\n\n    /**\n     * Repeats the given string `n` times.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to repeat.\n     * @param {number} [n=1] The number of times to repeat the string.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {string} Returns the repeated string.\n     * @example\n     *\n     * _.repeat('*', 3);\n     * // => '***'\n     *\n     * _.repeat('abc', 2);\n     * // => 'abcabc'\n     *\n     * _.repeat('abc', 0);\n     * // => ''\n     */\n    function repeat(string, n, guard) {\n      if ((guard ? isIterateeCall(string, n, guard) : n === undefined)) {\n        n = 1;\n      } else {\n        n = toInteger(n);\n      }\n      return baseRepeat(toString(string), n);\n    }\n\n    /**\n     * Replaces matches for `pattern` in `string` with `replacement`.\n     *\n     * **Note:** This method is based on\n     * [`String#replace`](https://mdn.io/String/replace).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to modify.\n     * @param {RegExp|string} pattern The pattern to replace.\n     * @param {Function|string} replacement The match replacement.\n     * @returns {string} Returns the modified string.\n     * @example\n     *\n     * _.replace('Hi Fred', 'Fred', 'Barney');\n     * // => 'Hi Barney'\n     */\n    function replace() {\n      var args = arguments,\n          string = toString(args[0]);\n\n      return args.length < 3 ? string : string.replace(args[1], args[2]);\n    }\n\n    /**\n     * Converts `string` to\n     * [snake case](https://en.wikipedia.org/wiki/Snake_case).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the snake cased string.\n     * @example\n     *\n     * _.snakeCase('Foo Bar');\n     * // => 'foo_bar'\n     *\n     * _.snakeCase('fooBar');\n     * // => 'foo_bar'\n     *\n     * _.snakeCase('--FOO-BAR--');\n     * // => 'foo_bar'\n     */\n    var snakeCase = createCompounder(function(result, word, index) {\n      return result + (index ? '_' : '') + word.toLowerCase();\n    });\n\n    /**\n     * Splits `string` by `separator`.\n     *\n     * **Note:** This method is based on\n     * [`String#split`](https://mdn.io/String/split).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to split.\n     * @param {RegExp|string} separator The separator pattern to split by.\n     * @param {number} [limit] The length to truncate results to.\n     * @returns {Array} Returns the string segments.\n     * @example\n     *\n     * _.split('a-b-c', '-', 2);\n     * // => ['a', 'b']\n     */\n    function split(string, separator, limit) {\n      if (limit && typeof limit != 'number' && isIterateeCall(string, separator, limit)) {\n        separator = limit = undefined;\n      }\n      limit = limit === undefined ? MAX_ARRAY_LENGTH : limit >>> 0;\n      if (!limit) {\n        return [];\n      }\n      string = toString(string);\n      if (string && (\n            typeof separator == 'string' ||\n            (separator != null && !isRegExp(separator))\n          )) {\n        separator = baseToString(separator);\n        if (!separator && hasUnicode(string)) {\n          return castSlice(stringToArray(string), 0, limit);\n        }\n      }\n      return string.split(separator, limit);\n    }\n\n    /**\n     * Converts `string` to\n     * [start case](https://en.wikipedia.org/wiki/Letter_case#Stylistic_or_specialised_usage).\n     *\n     * @static\n     * @memberOf _\n     * @since 3.1.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the start cased string.\n     * @example\n     *\n     * _.startCase('--foo-bar--');\n     * // => 'Foo Bar'\n     *\n     * _.startCase('fooBar');\n     * // => 'Foo Bar'\n     *\n     * _.startCase('__FOO_BAR__');\n     * // => 'FOO BAR'\n     */\n    var startCase = createCompounder(function(result, word, index) {\n      return result + (index ? ' ' : '') + upperFirst(word);\n    });\n\n    /**\n     * Checks if `string` starts with the given target string.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to inspect.\n     * @param {string} [target] The string to search for.\n     * @param {number} [position=0] The position to search from.\n     * @returns {boolean} Returns `true` if `string` starts with `target`,\n     *  else `false`.\n     * @example\n     *\n     * _.startsWith('abc', 'a');\n     * // => true\n     *\n     * _.startsWith('abc', 'b');\n     * // => false\n     *\n     * _.startsWith('abc', 'b', 1);\n     * // => true\n     */\n    function startsWith(string, target, position) {\n      string = toString(string);\n      position = position == null\n        ? 0\n        : baseClamp(toInteger(position), 0, string.length);\n\n      target = baseToString(target);\n      return string.slice(position, position + target.length) == target;\n    }\n\n    /**\n     * Creates a compiled template function that can interpolate data properties\n     * in \"interpolate\" delimiters, HTML-escape interpolated data properties in\n     * \"escape\" delimiters, and execute JavaScript in \"evaluate\" delimiters. Data\n     * properties may be accessed as free variables in the template. If a setting\n     * object is given, it takes precedence over `_.templateSettings` values.\n     *\n     * **Note:** In the development build `_.template` utilizes\n     * [sourceURLs](http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl)\n     * for easier debugging.\n     *\n     * For more information on precompiling templates see\n     * [lodash's custom builds documentation](https://lodash.com/custom-builds).\n     *\n     * For more information on Chrome extension sandboxes see\n     * [Chrome's extensions documentation](https://developer.chrome.com/extensions/sandboxingEval).\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category String\n     * @param {string} [string=''] The template string.\n     * @param {Object} [options={}] The options object.\n     * @param {RegExp} [options.escape=_.templateSettings.escape]\n     *  The HTML \"escape\" delimiter.\n     * @param {RegExp} [options.evaluate=_.templateSettings.evaluate]\n     *  The \"evaluate\" delimiter.\n     * @param {Object} [options.imports=_.templateSettings.imports]\n     *  An object to import into the template as free variables.\n     * @param {RegExp} [options.interpolate=_.templateSettings.interpolate]\n     *  The \"interpolate\" delimiter.\n     * @param {string} [options.sourceURL='lodash.templateSources[n]']\n     *  The sourceURL of the compiled template.\n     * @param {string} [options.variable='obj']\n     *  The data object variable name.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Function} Returns the compiled template function.\n     * @example\n     *\n     * // Use the \"interpolate\" delimiter to create a compiled template.\n     * var compiled = _.template('hello <%= user %>!');\n     * compiled({ 'user': 'fred' });\n     * // => 'hello fred!'\n     *\n     * // Use the HTML \"escape\" delimiter to escape data property values.\n     * var compiled = _.template('<b><%- value %></b>');\n     * compiled({ 'value': '<script>' });\n     * // => '<b>&lt;script&gt;</b>'\n     *\n     * // Use the \"evaluate\" delimiter to execute JavaScript and generate HTML.\n     * var compiled = _.template('<% _.forEach(users, function(user) { %><li><%- user %></li><% }); %>');\n     * compiled({ 'users': ['fred', 'barney'] });\n     * // => '<li>fred</li><li>barney</li>'\n     *\n     * // Use the internal `print` function in \"evaluate\" delimiters.\n     * var compiled = _.template('<% print(\"hello \" + user); %>!');\n     * compiled({ 'user': 'barney' });\n     * // => 'hello barney!'\n     *\n     * // Use the ES template literal delimiter as an \"interpolate\" delimiter.\n     * // Disable support by replacing the \"interpolate\" delimiter.\n     * var compiled = _.template('hello ${ user }!');\n     * compiled({ 'user': 'pebbles' });\n     * // => 'hello pebbles!'\n     *\n     * // Use backslashes to treat delimiters as plain text.\n     * var compiled = _.template('<%= \"\\\\<%- value %\\\\>\" %>');\n     * compiled({ 'value': 'ignored' });\n     * // => '<%- value %>'\n     *\n     * // Use the `imports` option to import `jQuery` as `jq`.\n     * var text = '<% jq.each(users, function(user) { %><li><%- user %></li><% }); %>';\n     * var compiled = _.template(text, { 'imports': { 'jq': jQuery } });\n     * compiled({ 'users': ['fred', 'barney'] });\n     * // => '<li>fred</li><li>barney</li>'\n     *\n     * // Use the `sourceURL` option to specify a custom sourceURL for the template.\n     * var compiled = _.template('hello <%= user %>!', { 'sourceURL': '/basic/greeting.jst' });\n     * compiled(data);\n     * // => Find the source of \"greeting.jst\" under the Sources tab or Resources panel of the web inspector.\n     *\n     * // Use the `variable` option to ensure a with-statement isn't used in the compiled template.\n     * var compiled = _.template('hi <%= data.user %>!', { 'variable': 'data' });\n     * compiled.source;\n     * // => function(data) {\n     * //   var __t, __p = '';\n     * //   __p += 'hi ' + ((__t = ( data.user )) == null ? '' : __t) + '!';\n     * //   return __p;\n     * // }\n     *\n     * // Use custom template delimiters.\n     * _.templateSettings.interpolate = /{{([\\s\\S]+?)}}/g;\n     * var compiled = _.template('hello {{ user }}!');\n     * compiled({ 'user': 'mustache' });\n     * // => 'hello mustache!'\n     *\n     * // Use the `source` property to inline compiled templates for meaningful\n     * // line numbers in error messages and stack traces.\n     * fs.writeFileSync(path.join(process.cwd(), 'jst.js'), '\\\n     *   var JST = {\\\n     *     \"main\": ' + _.template(mainText).source + '\\\n     *   };\\\n     * ');\n     */\n    function template(string, options, guard) {\n      // Based on John Resig's `tmpl` implementation\n      // (http://ejohn.org/blog/javascript-micro-templating/)\n      // and Laura Doktorova's doT.js (https://github.com/olado/doT).\n      var settings = lodash.templateSettings;\n\n      if (guard && isIterateeCall(string, options, guard)) {\n        options = undefined;\n      }\n      string = toString(string);\n      options = assignInWith({}, options, settings, customDefaultsAssignIn);\n\n      var imports = assignInWith({}, options.imports, settings.imports, customDefaultsAssignIn),\n          importsKeys = keys(imports),\n          importsValues = baseValues(imports, importsKeys);\n\n      var isEscaping,\n          isEvaluating,\n          index = 0,\n          interpolate = options.interpolate || reNoMatch,\n          source = \"__p += '\";\n\n      // Compile the regexp to match each delimiter.\n      var reDelimiters = RegExp(\n        (options.escape || reNoMatch).source + '|' +\n        interpolate.source + '|' +\n        (interpolate === reInterpolate ? reEsTemplate : reNoMatch).source + '|' +\n        (options.evaluate || reNoMatch).source + '|$'\n      , 'g');\n\n      // Use a sourceURL for easier debugging.\n      // The sourceURL gets injected into the source that's eval-ed, so be careful\n      // to normalize all kinds of whitespace, so e.g. newlines (and unicode versions of it) can't sneak in\n      // and escape the comment, thus injecting code that gets evaled.\n      var sourceURL = '//# sourceURL=' +\n        (hasOwnProperty.call(options, 'sourceURL')\n          ? (options.sourceURL + '').replace(/\\s/g, ' ')\n          : ('lodash.templateSources[' + (++templateCounter) + ']')\n        ) + '\\n';\n\n      string.replace(reDelimiters, function(match, escapeValue, interpolateValue, esTemplateValue, evaluateValue, offset) {\n        interpolateValue || (interpolateValue = esTemplateValue);\n\n        // Escape characters that can't be included in string literals.\n        source += string.slice(index, offset).replace(reUnescapedString, escapeStringChar);\n\n        // Replace delimiters with snippets.\n        if (escapeValue) {\n          isEscaping = true;\n          source += \"' +\\n__e(\" + escapeValue + \") +\\n'\";\n        }\n        if (evaluateValue) {\n          isEvaluating = true;\n          source += \"';\\n\" + evaluateValue + \";\\n__p += '\";\n        }\n        if (interpolateValue) {\n          source += \"' +\\n((__t = (\" + interpolateValue + \")) == null ? '' : __t) +\\n'\";\n        }\n        index = offset + match.length;\n\n        // The JS engine embedded in Adobe products needs `match` returned in\n        // order to produce the correct `offset` value.\n        return match;\n      });\n\n      source += \"';\\n\";\n\n      // If `variable` is not specified wrap a with-statement around the generated\n      // code to add the data object to the top of the scope chain.\n      var variable = hasOwnProperty.call(options, 'variable') && options.variable;\n      if (!variable) {\n        source = 'with (obj) {\\n' + source + '\\n}\\n';\n      }\n      // Throw an error if a forbidden character was found in `variable`, to prevent\n      // potential command injection attacks.\n      else if (reForbiddenIdentifierChars.test(variable)) {\n        throw new Error(INVALID_TEMPL_VAR_ERROR_TEXT);\n      }\n\n      // Cleanup code by stripping empty strings.\n      source = (isEvaluating ? source.replace(reEmptyStringLeading, '') : source)\n        .replace(reEmptyStringMiddle, '$1')\n        .replace(reEmptyStringTrailing, '$1;');\n\n      // Frame code as the function body.\n      source = 'function(' + (variable || 'obj') + ') {\\n' +\n        (variable\n          ? ''\n          : 'obj || (obj = {});\\n'\n        ) +\n        \"var __t, __p = ''\" +\n        (isEscaping\n           ? ', __e = _.escape'\n           : ''\n        ) +\n        (isEvaluating\n          ? ', __j = Array.prototype.join;\\n' +\n            \"function print() { __p += __j.call(arguments, '') }\\n\"\n          : ';\\n'\n        ) +\n        source +\n        'return __p\\n}';\n\n      var result = attempt(function() {\n        return Function(importsKeys, sourceURL + 'return ' + source)\n          .apply(undefined, importsValues);\n      });\n\n      // Provide the compiled function's source by its `toString` method or\n      // the `source` property as a convenience for inlining compiled templates.\n      result.source = source;\n      if (isError(result)) {\n        throw result;\n      }\n      return result;\n    }\n\n    /**\n     * Converts `string`, as a whole, to lower case just like\n     * [String#toLowerCase](https://mdn.io/toLowerCase).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the lower cased string.\n     * @example\n     *\n     * _.toLower('--Foo-Bar--');\n     * // => '--foo-bar--'\n     *\n     * _.toLower('fooBar');\n     * // => 'foobar'\n     *\n     * _.toLower('__FOO_BAR__');\n     * // => '__foo_bar__'\n     */\n    function toLower(value) {\n      return toString(value).toLowerCase();\n    }\n\n    /**\n     * Converts `string`, as a whole, to upper case just like\n     * [String#toUpperCase](https://mdn.io/toUpperCase).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the upper cased string.\n     * @example\n     *\n     * _.toUpper('--foo-bar--');\n     * // => '--FOO-BAR--'\n     *\n     * _.toUpper('fooBar');\n     * // => 'FOOBAR'\n     *\n     * _.toUpper('__foo_bar__');\n     * // => '__FOO_BAR__'\n     */\n    function toUpper(value) {\n      return toString(value).toUpperCase();\n    }\n\n    /**\n     * Removes leading and trailing whitespace or specified characters from `string`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to trim.\n     * @param {string} [chars=whitespace] The characters to trim.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {string} Returns the trimmed string.\n     * @example\n     *\n     * _.trim('  abc  ');\n     * // => 'abc'\n     *\n     * _.trim('-_-abc-_-', '_-');\n     * // => 'abc'\n     *\n     * _.map(['  foo  ', '  bar  '], _.trim);\n     * // => ['foo', 'bar']\n     */\n    function trim(string, chars, guard) {\n      string = toString(string);\n      if (string && (guard || chars === undefined)) {\n        return baseTrim(string);\n      }\n      if (!string || !(chars = baseToString(chars))) {\n        return string;\n      }\n      var strSymbols = stringToArray(string),\n          chrSymbols = stringToArray(chars),\n          start = charsStartIndex(strSymbols, chrSymbols),\n          end = charsEndIndex(strSymbols, chrSymbols) + 1;\n\n      return castSlice(strSymbols, start, end).join('');\n    }\n\n    /**\n     * Removes trailing whitespace or specified characters from `string`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to trim.\n     * @param {string} [chars=whitespace] The characters to trim.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {string} Returns the trimmed string.\n     * @example\n     *\n     * _.trimEnd('  abc  ');\n     * // => '  abc'\n     *\n     * _.trimEnd('-_-abc-_-', '_-');\n     * // => '-_-abc'\n     */\n    function trimEnd(string, chars, guard) {\n      string = toString(string);\n      if (string && (guard || chars === undefined)) {\n        return string.slice(0, trimmedEndIndex(string) + 1);\n      }\n      if (!string || !(chars = baseToString(chars))) {\n        return string;\n      }\n      var strSymbols = stringToArray(string),\n          end = charsEndIndex(strSymbols, stringToArray(chars)) + 1;\n\n      return castSlice(strSymbols, 0, end).join('');\n    }\n\n    /**\n     * Removes leading whitespace or specified characters from `string`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to trim.\n     * @param {string} [chars=whitespace] The characters to trim.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {string} Returns the trimmed string.\n     * @example\n     *\n     * _.trimStart('  abc  ');\n     * // => 'abc  '\n     *\n     * _.trimStart('-_-abc-_-', '_-');\n     * // => 'abc-_-'\n     */\n    function trimStart(string, chars, guard) {\n      string = toString(string);\n      if (string && (guard || chars === undefined)) {\n        return string.replace(reTrimStart, '');\n      }\n      if (!string || !(chars = baseToString(chars))) {\n        return string;\n      }\n      var strSymbols = stringToArray(string),\n          start = charsStartIndex(strSymbols, stringToArray(chars));\n\n      return castSlice(strSymbols, start).join('');\n    }\n\n    /**\n     * Truncates `string` if it's longer than the given maximum string length.\n     * The last characters of the truncated string are replaced with the omission\n     * string which defaults to \"...\".\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to truncate.\n     * @param {Object} [options={}] The options object.\n     * @param {number} [options.length=30] The maximum string length.\n     * @param {string} [options.omission='...'] The string to indicate text is omitted.\n     * @param {RegExp|string} [options.separator] The separator pattern to truncate to.\n     * @returns {string} Returns the truncated string.\n     * @example\n     *\n     * _.truncate('hi-diddly-ho there, neighborino');\n     * // => 'hi-diddly-ho there, neighbo...'\n     *\n     * _.truncate('hi-diddly-ho there, neighborino', {\n     *   'length': 24,\n     *   'separator': ' '\n     * });\n     * // => 'hi-diddly-ho there,...'\n     *\n     * _.truncate('hi-diddly-ho there, neighborino', {\n     *   'length': 24,\n     *   'separator': /,? +/\n     * });\n     * // => 'hi-diddly-ho there...'\n     *\n     * _.truncate('hi-diddly-ho there, neighborino', {\n     *   'omission': ' [...]'\n     * });\n     * // => 'hi-diddly-ho there, neig [...]'\n     */\n    function truncate(string, options) {\n      var length = DEFAULT_TRUNC_LENGTH,\n          omission = DEFAULT_TRUNC_OMISSION;\n\n      if (isObject(options)) {\n        var separator = 'separator' in options ? options.separator : separator;\n        length = 'length' in options ? toInteger(options.length) : length;\n        omission = 'omission' in options ? baseToString(options.omission) : omission;\n      }\n      string = toString(string);\n\n      var strLength = string.length;\n      if (hasUnicode(string)) {\n        var strSymbols = stringToArray(string);\n        strLength = strSymbols.length;\n      }\n      if (length >= strLength) {\n        return string;\n      }\n      var end = length - stringSize(omission);\n      if (end < 1) {\n        return omission;\n      }\n      var result = strSymbols\n        ? castSlice(strSymbols, 0, end).join('')\n        : string.slice(0, end);\n\n      if (separator === undefined) {\n        return result + omission;\n      }\n      if (strSymbols) {\n        end += (result.length - end);\n      }\n      if (isRegExp(separator)) {\n        if (string.slice(end).search(separator)) {\n          var match,\n              substring = result;\n\n          if (!separator.global) {\n            separator = RegExp(separator.source, toString(reFlags.exec(separator)) + 'g');\n          }\n          separator.lastIndex = 0;\n          while ((match = separator.exec(substring))) {\n            var newEnd = match.index;\n          }\n          result = result.slice(0, newEnd === undefined ? end : newEnd);\n        }\n      } else if (string.indexOf(baseToString(separator), end) != end) {\n        var index = result.lastIndexOf(separator);\n        if (index > -1) {\n          result = result.slice(0, index);\n        }\n      }\n      return result + omission;\n    }\n\n    /**\n     * The inverse of `_.escape`; this method converts the HTML entities\n     * `&amp;`, `&lt;`, `&gt;`, `&quot;`, and `&#39;` in `string` to\n     * their corresponding characters.\n     *\n     * **Note:** No other HTML entities are unescaped. To unescape additional\n     * HTML entities use a third-party library like [_he_](https://mths.be/he).\n     *\n     * @static\n     * @memberOf _\n     * @since 0.6.0\n     * @category String\n     * @param {string} [string=''] The string to unescape.\n     * @returns {string} Returns the unescaped string.\n     * @example\n     *\n     * _.unescape('fred, barney, &amp; pebbles');\n     * // => 'fred, barney, & pebbles'\n     */\n    function unescape(string) {\n      string = toString(string);\n      return (string && reHasEscapedHtml.test(string))\n        ? string.replace(reEscapedHtml, unescapeHtmlChar)\n        : string;\n    }\n\n    /**\n     * Converts `string`, as space separated words, to upper case.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the upper cased string.\n     * @example\n     *\n     * _.upperCase('--foo-bar');\n     * // => 'FOO BAR'\n     *\n     * _.upperCase('fooBar');\n     * // => 'FOO BAR'\n     *\n     * _.upperCase('__foo_bar__');\n     * // => 'FOO BAR'\n     */\n    var upperCase = createCompounder(function(result, word, index) {\n      return result + (index ? ' ' : '') + word.toUpperCase();\n    });\n\n    /**\n     * Converts the first character of `string` to upper case.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the converted string.\n     * @example\n     *\n     * _.upperFirst('fred');\n     * // => 'Fred'\n     *\n     * _.upperFirst('FRED');\n     * // => 'FRED'\n     */\n    var upperFirst = createCaseFirst('toUpperCase');\n\n    /**\n     * Splits `string` into an array of its words.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category String\n     * @param {string} [string=''] The string to inspect.\n     * @param {RegExp|string} [pattern] The pattern to match words.\n     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n     * @returns {Array} Returns the words of `string`.\n     * @example\n     *\n     * _.words('fred, barney, & pebbles');\n     * // => ['fred', 'barney', 'pebbles']\n     *\n     * _.words('fred, barney, & pebbles', /[^, ]+/g);\n     * // => ['fred', 'barney', '&', 'pebbles']\n     */\n    function words(string, pattern, guard) {\n      string = toString(string);\n      pattern = guard ? undefined : pattern;\n\n      if (pattern === undefined) {\n        return hasUnicodeWord(string) ? unicodeWords(string) : asciiWords(string);\n      }\n      return string.match(pattern) || [];\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Attempts to invoke `func`, returning either the result or the caught error\n     * object. Any additional arguments are provided to `func` when it's invoked.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Util\n     * @param {Function} func The function to attempt.\n     * @param {...*} [args] The arguments to invoke `func` with.\n     * @returns {*} Returns the `func` result or error object.\n     * @example\n     *\n     * // Avoid throwing errors for invalid selectors.\n     * var elements = _.attempt(function(selector) {\n     *   return document.querySelectorAll(selector);\n     * }, '>_>');\n     *\n     * if (_.isError(elements)) {\n     *   elements = [];\n     * }\n     */\n    var attempt = baseRest(function(func, args) {\n      try {\n        return apply(func, undefined, args);\n      } catch (e) {\n        return isError(e) ? e : new Error(e);\n      }\n    });\n\n    /**\n     * Binds methods of an object to the object itself, overwriting the existing\n     * method.\n     *\n     * **Note:** This method doesn't set the \"length\" property of bound functions.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Util\n     * @param {Object} object The object to bind and assign the bound methods to.\n     * @param {...(string|string[])} methodNames The object method names to bind.\n     * @returns {Object} Returns `object`.\n     * @example\n     *\n     * var view = {\n     *   'label': 'docs',\n     *   'click': function() {\n     *     console.log('clicked ' + this.label);\n     *   }\n     * };\n     *\n     * _.bindAll(view, ['click']);\n     * jQuery(element).on('click', view.click);\n     * // => Logs 'clicked docs' when clicked.\n     */\n    var bindAll = flatRest(function(object, methodNames) {\n      arrayEach(methodNames, function(key) {\n        key = toKey(key);\n        baseAssignValue(object, key, bind(object[key], object));\n      });\n      return object;\n    });\n\n    /**\n     * Creates a function that iterates over `pairs` and invokes the corresponding\n     * function of the first predicate to return truthy. The predicate-function\n     * pairs are invoked with the `this` binding and arguments of the created\n     * function.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Util\n     * @param {Array} pairs The predicate-function pairs.\n     * @returns {Function} Returns the new composite function.\n     * @example\n     *\n     * var func = _.cond([\n     *   [_.matches({ 'a': 1 }),           _.constant('matches A')],\n     *   [_.conforms({ 'b': _.isNumber }), _.constant('matches B')],\n     *   [_.stubTrue,                      _.constant('no match')]\n     * ]);\n     *\n     * func({ 'a': 1, 'b': 2 });\n     * // => 'matches A'\n     *\n     * func({ 'a': 0, 'b': 1 });\n     * // => 'matches B'\n     *\n     * func({ 'a': '1', 'b': '2' });\n     * // => 'no match'\n     */\n    function cond(pairs) {\n      var length = pairs == null ? 0 : pairs.length,\n          toIteratee = getIteratee();\n\n      pairs = !length ? [] : arrayMap(pairs, function(pair) {\n        if (typeof pair[1] != 'function') {\n          throw new TypeError(FUNC_ERROR_TEXT);\n        }\n        return [toIteratee(pair[0]), pair[1]];\n      });\n\n      return baseRest(function(args) {\n        var index = -1;\n        while (++index < length) {\n          var pair = pairs[index];\n          if (apply(pair[0], this, args)) {\n            return apply(pair[1], this, args);\n          }\n        }\n      });\n    }\n\n    /**\n     * Creates a function that invokes the predicate properties of `source` with\n     * the corresponding property values of a given object, returning `true` if\n     * all predicates return truthy, else `false`.\n     *\n     * **Note:** The created function is equivalent to `_.conformsTo` with\n     * `source` partially applied.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Util\n     * @param {Object} source The object of property predicates to conform to.\n     * @returns {Function} Returns the new spec function.\n     * @example\n     *\n     * var objects = [\n     *   { 'a': 2, 'b': 1 },\n     *   { 'a': 1, 'b': 2 }\n     * ];\n     *\n     * _.filter(objects, _.conforms({ 'b': function(n) { return n > 1; } }));\n     * // => [{ 'a': 1, 'b': 2 }]\n     */\n    function conforms(source) {\n      return baseConforms(baseClone(source, CLONE_DEEP_FLAG));\n    }\n\n    /**\n     * Creates a function that returns `value`.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.4.0\n     * @category Util\n     * @param {*} value The value to return from the new function.\n     * @returns {Function} Returns the new constant function.\n     * @example\n     *\n     * var objects = _.times(2, _.constant({ 'a': 1 }));\n     *\n     * console.log(objects);\n     * // => [{ 'a': 1 }, { 'a': 1 }]\n     *\n     * console.log(objects[0] === objects[1]);\n     * // => true\n     */\n    function constant(value) {\n      return function() {\n        return value;\n      };\n    }\n\n    /**\n     * Checks `value` to determine whether a default value should be returned in\n     * its place. The `defaultValue` is returned if `value` is `NaN`, `null`,\n     * or `undefined`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.14.0\n     * @category Util\n     * @param {*} value The value to check.\n     * @param {*} defaultValue The default value.\n     * @returns {*} Returns the resolved value.\n     * @example\n     *\n     * _.defaultTo(1, 10);\n     * // => 1\n     *\n     * _.defaultTo(undefined, 10);\n     * // => 10\n     */\n    function defaultTo(value, defaultValue) {\n      return (value == null || value !== value) ? defaultValue : value;\n    }\n\n    /**\n     * Creates a function that returns the result of invoking the given functions\n     * with the `this` binding of the created function, where each successive\n     * invocation is supplied the return value of the previous.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Util\n     * @param {...(Function|Function[])} [funcs] The functions to invoke.\n     * @returns {Function} Returns the new composite function.\n     * @see _.flowRight\n     * @example\n     *\n     * function square(n) {\n     *   return n * n;\n     * }\n     *\n     * var addSquare = _.flow([_.add, square]);\n     * addSquare(1, 2);\n     * // => 9\n     */\n    var flow = createFlow();\n\n    /**\n     * This method is like `_.flow` except that it creates a function that\n     * invokes the given functions from right to left.\n     *\n     * @static\n     * @since 3.0.0\n     * @memberOf _\n     * @category Util\n     * @param {...(Function|Function[])} [funcs] The functions to invoke.\n     * @returns {Function} Returns the new composite function.\n     * @see _.flow\n     * @example\n     *\n     * function square(n) {\n     *   return n * n;\n     * }\n     *\n     * var addSquare = _.flowRight([square, _.add]);\n     * addSquare(1, 2);\n     * // => 9\n     */\n    var flowRight = createFlow(true);\n\n    /**\n     * This method returns the first argument it receives.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Util\n     * @param {*} value Any value.\n     * @returns {*} Returns `value`.\n     * @example\n     *\n     * var object = { 'a': 1 };\n     *\n     * console.log(_.identity(object) === object);\n     * // => true\n     */\n    function identity(value) {\n      return value;\n    }\n\n    /**\n     * Creates a function that invokes `func` with the arguments of the created\n     * function. If `func` is a property name, the created function returns the\n     * property value for a given element. If `func` is an array or object, the\n     * created function returns `true` for elements that contain the equivalent\n     * source properties, otherwise it returns `false`.\n     *\n     * @static\n     * @since 4.0.0\n     * @memberOf _\n     * @category Util\n     * @param {*} [func=_.identity] The value to convert to a callback.\n     * @returns {Function} Returns the callback.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney', 'age': 36, 'active': true },\n     *   { 'user': 'fred',   'age': 40, 'active': false }\n     * ];\n     *\n     * // The `_.matches` iteratee shorthand.\n     * _.filter(users, _.iteratee({ 'user': 'barney', 'active': true }));\n     * // => [{ 'user': 'barney', 'age': 36, 'active': true }]\n     *\n     * // The `_.matchesProperty` iteratee shorthand.\n     * _.filter(users, _.iteratee(['user', 'fred']));\n     * // => [{ 'user': 'fred', 'age': 40 }]\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.map(users, _.iteratee('user'));\n     * // => ['barney', 'fred']\n     *\n     * // Create custom iteratee shorthands.\n     * _.iteratee = _.wrap(_.iteratee, function(iteratee, func) {\n     *   return !_.isRegExp(func) ? iteratee(func) : function(string) {\n     *     return func.test(string);\n     *   };\n     * });\n     *\n     * _.filter(['abc', 'def'], /ef/);\n     * // => ['def']\n     */\n    function iteratee(func) {\n      return baseIteratee(typeof func == 'function' ? func : baseClone(func, CLONE_DEEP_FLAG));\n    }\n\n    /**\n     * Creates a function that performs a partial deep comparison between a given\n     * object and `source`, returning `true` if the given object has equivalent\n     * property values, else `false`.\n     *\n     * **Note:** The created function is equivalent to `_.isMatch` with `source`\n     * partially applied.\n     *\n     * Partial comparisons will match empty array and empty object `source`\n     * values against any array or object value, respectively. See `_.isEqual`\n     * for a list of supported value comparisons.\n     *\n     * **Note:** Multiple values can be checked by combining several matchers\n     * using `_.overSome`\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Util\n     * @param {Object} source The object of property values to match.\n     * @returns {Function} Returns the new spec function.\n     * @example\n     *\n     * var objects = [\n     *   { 'a': 1, 'b': 2, 'c': 3 },\n     *   { 'a': 4, 'b': 5, 'c': 6 }\n     * ];\n     *\n     * _.filter(objects, _.matches({ 'a': 4, 'c': 6 }));\n     * // => [{ 'a': 4, 'b': 5, 'c': 6 }]\n     *\n     * // Checking for several possible values\n     * _.filter(objects, _.overSome([_.matches({ 'a': 1 }), _.matches({ 'a': 4 })]));\n     * // => [{ 'a': 1, 'b': 2, 'c': 3 }, { 'a': 4, 'b': 5, 'c': 6 }]\n     */\n    function matches(source) {\n      return baseMatches(baseClone(source, CLONE_DEEP_FLAG));\n    }\n\n    /**\n     * Creates a function that performs a partial deep comparison between the\n     * value at `path` of a given object to `srcValue`, returning `true` if the\n     * object value is equivalent, else `false`.\n     *\n     * **Note:** Partial comparisons will match empty array and empty object\n     * `srcValue` values against any array or object value, respectively. See\n     * `_.isEqual` for a list of supported value comparisons.\n     *\n     * **Note:** Multiple values can be checked by combining several matchers\n     * using `_.overSome`\n     *\n     * @static\n     * @memberOf _\n     * @since 3.2.0\n     * @category Util\n     * @param {Array|string} path The path of the property to get.\n     * @param {*} srcValue The value to match.\n     * @returns {Function} Returns the new spec function.\n     * @example\n     *\n     * var objects = [\n     *   { 'a': 1, 'b': 2, 'c': 3 },\n     *   { 'a': 4, 'b': 5, 'c': 6 }\n     * ];\n     *\n     * _.find(objects, _.matchesProperty('a', 4));\n     * // => { 'a': 4, 'b': 5, 'c': 6 }\n     *\n     * // Checking for several possible values\n     * _.filter(objects, _.overSome([_.matchesProperty('a', 1), _.matchesProperty('a', 4)]));\n     * // => [{ 'a': 1, 'b': 2, 'c': 3 }, { 'a': 4, 'b': 5, 'c': 6 }]\n     */\n    function matchesProperty(path, srcValue) {\n      return baseMatchesProperty(path, baseClone(srcValue, CLONE_DEEP_FLAG));\n    }\n\n    /**\n     * Creates a function that invokes the method at `path` of a given object.\n     * Any additional arguments are provided to the invoked method.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.7.0\n     * @category Util\n     * @param {Array|string} path The path of the method to invoke.\n     * @param {...*} [args] The arguments to invoke the method with.\n     * @returns {Function} Returns the new invoker function.\n     * @example\n     *\n     * var objects = [\n     *   { 'a': { 'b': _.constant(2) } },\n     *   { 'a': { 'b': _.constant(1) } }\n     * ];\n     *\n     * _.map(objects, _.method('a.b'));\n     * // => [2, 1]\n     *\n     * _.map(objects, _.method(['a', 'b']));\n     * // => [2, 1]\n     */\n    var method = baseRest(function(path, args) {\n      return function(object) {\n        return baseInvoke(object, path, args);\n      };\n    });\n\n    /**\n     * The opposite of `_.method`; this method creates a function that invokes\n     * the method at a given path of `object`. Any additional arguments are\n     * provided to the invoked method.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.7.0\n     * @category Util\n     * @param {Object} object The object to query.\n     * @param {...*} [args] The arguments to invoke the method with.\n     * @returns {Function} Returns the new invoker function.\n     * @example\n     *\n     * var array = _.times(3, _.constant),\n     *     object = { 'a': array, 'b': array, 'c': array };\n     *\n     * _.map(['a[2]', 'c[0]'], _.methodOf(object));\n     * // => [2, 0]\n     *\n     * _.map([['a', '2'], ['c', '0']], _.methodOf(object));\n     * // => [2, 0]\n     */\n    var methodOf = baseRest(function(object, args) {\n      return function(path) {\n        return baseInvoke(object, path, args);\n      };\n    });\n\n    /**\n     * Adds all own enumerable string keyed function properties of a source\n     * object to the destination object. If `object` is a function, then methods\n     * are added to its prototype as well.\n     *\n     * **Note:** Use `_.runInContext` to create a pristine `lodash` function to\n     * avoid conflicts caused by modifying the original.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Util\n     * @param {Function|Object} [object=lodash] The destination object.\n     * @param {Object} source The object of functions to add.\n     * @param {Object} [options={}] The options object.\n     * @param {boolean} [options.chain=true] Specify whether mixins are chainable.\n     * @returns {Function|Object} Returns `object`.\n     * @example\n     *\n     * function vowels(string) {\n     *   return _.filter(string, function(v) {\n     *     return /[aeiou]/i.test(v);\n     *   });\n     * }\n     *\n     * _.mixin({ 'vowels': vowels });\n     * _.vowels('fred');\n     * // => ['e']\n     *\n     * _('fred').vowels().value();\n     * // => ['e']\n     *\n     * _.mixin({ 'vowels': vowels }, { 'chain': false });\n     * _('fred').vowels();\n     * // => ['e']\n     */\n    function mixin(object, source, options) {\n      var props = keys(source),\n          methodNames = baseFunctions(source, props);\n\n      if (options == null &&\n          !(isObject(source) && (methodNames.length || !props.length))) {\n        options = source;\n        source = object;\n        object = this;\n        methodNames = baseFunctions(source, keys(source));\n      }\n      var chain = !(isObject(options) && 'chain' in options) || !!options.chain,\n          isFunc = isFunction(object);\n\n      arrayEach(methodNames, function(methodName) {\n        var func = source[methodName];\n        object[methodName] = func;\n        if (isFunc) {\n          object.prototype[methodName] = function() {\n            var chainAll = this.__chain__;\n            if (chain || chainAll) {\n              var result = object(this.__wrapped__),\n                  actions = result.__actions__ = copyArray(this.__actions__);\n\n              actions.push({ 'func': func, 'args': arguments, 'thisArg': object });\n              result.__chain__ = chainAll;\n              return result;\n            }\n            return func.apply(object, arrayPush([this.value()], arguments));\n          };\n        }\n      });\n\n      return object;\n    }\n\n    /**\n     * Reverts the `_` variable to its previous value and returns a reference to\n     * the `lodash` function.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Util\n     * @returns {Function} Returns the `lodash` function.\n     * @example\n     *\n     * var lodash = _.noConflict();\n     */\n    function noConflict() {\n      if (root._ === this) {\n        root._ = oldDash;\n      }\n      return this;\n    }\n\n    /**\n     * This method returns `undefined`.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.3.0\n     * @category Util\n     * @example\n     *\n     * _.times(2, _.noop);\n     * // => [undefined, undefined]\n     */\n    function noop() {\n      // No operation performed.\n    }\n\n    /**\n     * Creates a function that gets the argument at index `n`. If `n` is negative,\n     * the nth argument from the end is returned.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Util\n     * @param {number} [n=0] The index of the argument to return.\n     * @returns {Function} Returns the new pass-thru function.\n     * @example\n     *\n     * var func = _.nthArg(1);\n     * func('a', 'b', 'c', 'd');\n     * // => 'b'\n     *\n     * var func = _.nthArg(-2);\n     * func('a', 'b', 'c', 'd');\n     * // => 'c'\n     */\n    function nthArg(n) {\n      n = toInteger(n);\n      return baseRest(function(args) {\n        return baseNth(args, n);\n      });\n    }\n\n    /**\n     * Creates a function that invokes `iteratees` with the arguments it receives\n     * and returns their results.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Util\n     * @param {...(Function|Function[])} [iteratees=[_.identity]]\n     *  The iteratees to invoke.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * var func = _.over([Math.max, Math.min]);\n     *\n     * func(1, 2, 3, 4);\n     * // => [4, 1]\n     */\n    var over = createOver(arrayMap);\n\n    /**\n     * Creates a function that checks if **all** of the `predicates` return\n     * truthy when invoked with the arguments it receives.\n     *\n     * Following shorthands are possible for providing predicates.\n     * Pass an `Object` and it will be used as an parameter for `_.matches` to create the predicate.\n     * Pass an `Array` of parameters for `_.matchesProperty` and the predicate will be created using them.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Util\n     * @param {...(Function|Function[])} [predicates=[_.identity]]\n     *  The predicates to check.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * var func = _.overEvery([Boolean, isFinite]);\n     *\n     * func('1');\n     * // => true\n     *\n     * func(null);\n     * // => false\n     *\n     * func(NaN);\n     * // => false\n     */\n    var overEvery = createOver(arrayEvery);\n\n    /**\n     * Creates a function that checks if **any** of the `predicates` return\n     * truthy when invoked with the arguments it receives.\n     *\n     * Following shorthands are possible for providing predicates.\n     * Pass an `Object` and it will be used as an parameter for `_.matches` to create the predicate.\n     * Pass an `Array` of parameters for `_.matchesProperty` and the predicate will be created using them.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Util\n     * @param {...(Function|Function[])} [predicates=[_.identity]]\n     *  The predicates to check.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * var func = _.overSome([Boolean, isFinite]);\n     *\n     * func('1');\n     * // => true\n     *\n     * func(null);\n     * // => true\n     *\n     * func(NaN);\n     * // => false\n     *\n     * var matchesFunc = _.overSome([{ 'a': 1 }, { 'a': 2 }])\n     * var matchesPropertyFunc = _.overSome([['a', 1], ['a', 2]])\n     */\n    var overSome = createOver(arraySome);\n\n    /**\n     * Creates a function that returns the value at `path` of a given object.\n     *\n     * @static\n     * @memberOf _\n     * @since 2.4.0\n     * @category Util\n     * @param {Array|string} path The path of the property to get.\n     * @returns {Function} Returns the new accessor function.\n     * @example\n     *\n     * var objects = [\n     *   { 'a': { 'b': 2 } },\n     *   { 'a': { 'b': 1 } }\n     * ];\n     *\n     * _.map(objects, _.property('a.b'));\n     * // => [2, 1]\n     *\n     * _.map(_.sortBy(objects, _.property(['a', 'b'])), 'a.b');\n     * // => [1, 2]\n     */\n    function property(path) {\n      return isKey(path) ? baseProperty(toKey(path)) : basePropertyDeep(path);\n    }\n\n    /**\n     * The opposite of `_.property`; this method creates a function that returns\n     * the value at a given path of `object`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.0.0\n     * @category Util\n     * @param {Object} object The object to query.\n     * @returns {Function} Returns the new accessor function.\n     * @example\n     *\n     * var array = [0, 1, 2],\n     *     object = { 'a': array, 'b': array, 'c': array };\n     *\n     * _.map(['a[2]', 'c[0]'], _.propertyOf(object));\n     * // => [2, 0]\n     *\n     * _.map([['a', '2'], ['c', '0']], _.propertyOf(object));\n     * // => [2, 0]\n     */\n    function propertyOf(object) {\n      return function(path) {\n        return object == null ? undefined : baseGet(object, path);\n      };\n    }\n\n    /**\n     * Creates an array of numbers (positive and/or negative) progressing from\n     * `start` up to, but not including, `end`. A step of `-1` is used if a negative\n     * `start` is specified without an `end` or `step`. If `end` is not specified,\n     * it's set to `start` with `start` then set to `0`.\n     *\n     * **Note:** JavaScript follows the IEEE-754 standard for resolving\n     * floating-point values which can produce unexpected results.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Util\n     * @param {number} [start=0] The start of the range.\n     * @param {number} end The end of the range.\n     * @param {number} [step=1] The value to increment or decrement by.\n     * @returns {Array} Returns the range of numbers.\n     * @see _.inRange, _.rangeRight\n     * @example\n     *\n     * _.range(4);\n     * // => [0, 1, 2, 3]\n     *\n     * _.range(-4);\n     * // => [0, -1, -2, -3]\n     *\n     * _.range(1, 5);\n     * // => [1, 2, 3, 4]\n     *\n     * _.range(0, 20, 5);\n     * // => [0, 5, 10, 15]\n     *\n     * _.range(0, -4, -1);\n     * // => [0, -1, -2, -3]\n     *\n     * _.range(1, 4, 0);\n     * // => [1, 1, 1]\n     *\n     * _.range(0);\n     * // => []\n     */\n    var range = createRange();\n\n    /**\n     * This method is like `_.range` except that it populates values in\n     * descending order.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Util\n     * @param {number} [start=0] The start of the range.\n     * @param {number} end The end of the range.\n     * @param {number} [step=1] The value to increment or decrement by.\n     * @returns {Array} Returns the range of numbers.\n     * @see _.inRange, _.range\n     * @example\n     *\n     * _.rangeRight(4);\n     * // => [3, 2, 1, 0]\n     *\n     * _.rangeRight(-4);\n     * // => [-3, -2, -1, 0]\n     *\n     * _.rangeRight(1, 5);\n     * // => [4, 3, 2, 1]\n     *\n     * _.rangeRight(0, 20, 5);\n     * // => [15, 10, 5, 0]\n     *\n     * _.rangeRight(0, -4, -1);\n     * // => [-3, -2, -1, 0]\n     *\n     * _.rangeRight(1, 4, 0);\n     * // => [1, 1, 1]\n     *\n     * _.rangeRight(0);\n     * // => []\n     */\n    var rangeRight = createRange(true);\n\n    /**\n     * This method returns a new empty array.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.13.0\n     * @category Util\n     * @returns {Array} Returns the new empty array.\n     * @example\n     *\n     * var arrays = _.times(2, _.stubArray);\n     *\n     * console.log(arrays);\n     * // => [[], []]\n     *\n     * console.log(arrays[0] === arrays[1]);\n     * // => false\n     */\n    function stubArray() {\n      return [];\n    }\n\n    /**\n     * This method returns `false`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.13.0\n     * @category Util\n     * @returns {boolean} Returns `false`.\n     * @example\n     *\n     * _.times(2, _.stubFalse);\n     * // => [false, false]\n     */\n    function stubFalse() {\n      return false;\n    }\n\n    /**\n     * This method returns a new empty object.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.13.0\n     * @category Util\n     * @returns {Object} Returns the new empty object.\n     * @example\n     *\n     * var objects = _.times(2, _.stubObject);\n     *\n     * console.log(objects);\n     * // => [{}, {}]\n     *\n     * console.log(objects[0] === objects[1]);\n     * // => false\n     */\n    function stubObject() {\n      return {};\n    }\n\n    /**\n     * This method returns an empty string.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.13.0\n     * @category Util\n     * @returns {string} Returns the empty string.\n     * @example\n     *\n     * _.times(2, _.stubString);\n     * // => ['', '']\n     */\n    function stubString() {\n      return '';\n    }\n\n    /**\n     * This method returns `true`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.13.0\n     * @category Util\n     * @returns {boolean} Returns `true`.\n     * @example\n     *\n     * _.times(2, _.stubTrue);\n     * // => [true, true]\n     */\n    function stubTrue() {\n      return true;\n    }\n\n    /**\n     * Invokes the iteratee `n` times, returning an array of the results of\n     * each invocation. The iteratee is invoked with one argument; (index).\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Util\n     * @param {number} n The number of times to invoke `iteratee`.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @returns {Array} Returns the array of results.\n     * @example\n     *\n     * _.times(3, String);\n     * // => ['0', '1', '2']\n     *\n     *  _.times(4, _.constant(0));\n     * // => [0, 0, 0, 0]\n     */\n    function times(n, iteratee) {\n      n = toInteger(n);\n      if (n < 1 || n > MAX_SAFE_INTEGER) {\n        return [];\n      }\n      var index = MAX_ARRAY_LENGTH,\n          length = nativeMin(n, MAX_ARRAY_LENGTH);\n\n      iteratee = getIteratee(iteratee);\n      n -= MAX_ARRAY_LENGTH;\n\n      var result = baseTimes(length, iteratee);\n      while (++index < n) {\n        iteratee(index);\n      }\n      return result;\n    }\n\n    /**\n     * Converts `value` to a property path array.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Util\n     * @param {*} value The value to convert.\n     * @returns {Array} Returns the new property path array.\n     * @example\n     *\n     * _.toPath('a.b.c');\n     * // => ['a', 'b', 'c']\n     *\n     * _.toPath('a[0].b.c');\n     * // => ['a', '0', 'b', 'c']\n     */\n    function toPath(value) {\n      if (isArray(value)) {\n        return arrayMap(value, toKey);\n      }\n      return isSymbol(value) ? [value] : copyArray(stringToPath(toString(value)));\n    }\n\n    /**\n     * Generates a unique ID. If `prefix` is given, the ID is appended to it.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Util\n     * @param {string} [prefix=''] The value to prefix the ID with.\n     * @returns {string} Returns the unique ID.\n     * @example\n     *\n     * _.uniqueId('contact_');\n     * // => 'contact_104'\n     *\n     * _.uniqueId();\n     * // => '105'\n     */\n    function uniqueId(prefix) {\n      var id = ++idCounter;\n      return toString(prefix) + id;\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Adds two numbers.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.4.0\n     * @category Math\n     * @param {number} augend The first number in an addition.\n     * @param {number} addend The second number in an addition.\n     * @returns {number} Returns the total.\n     * @example\n     *\n     * _.add(6, 4);\n     * // => 10\n     */\n    var add = createMathOperation(function(augend, addend) {\n      return augend + addend;\n    }, 0);\n\n    /**\n     * Computes `number` rounded up to `precision`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.10.0\n     * @category Math\n     * @param {number} number The number to round up.\n     * @param {number} [precision=0] The precision to round up to.\n     * @returns {number} Returns the rounded up number.\n     * @example\n     *\n     * _.ceil(4.006);\n     * // => 5\n     *\n     * _.ceil(6.004, 2);\n     * // => 6.01\n     *\n     * _.ceil(6040, -2);\n     * // => 6100\n     */\n    var ceil = createRound('ceil');\n\n    /**\n     * Divide two numbers.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.7.0\n     * @category Math\n     * @param {number} dividend The first number in a division.\n     * @param {number} divisor The second number in a division.\n     * @returns {number} Returns the quotient.\n     * @example\n     *\n     * _.divide(6, 4);\n     * // => 1.5\n     */\n    var divide = createMathOperation(function(dividend, divisor) {\n      return dividend / divisor;\n    }, 1);\n\n    /**\n     * Computes `number` rounded down to `precision`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.10.0\n     * @category Math\n     * @param {number} number The number to round down.\n     * @param {number} [precision=0] The precision to round down to.\n     * @returns {number} Returns the rounded down number.\n     * @example\n     *\n     * _.floor(4.006);\n     * // => 4\n     *\n     * _.floor(0.046, 2);\n     * // => 0.04\n     *\n     * _.floor(4060, -2);\n     * // => 4000\n     */\n    var floor = createRound('floor');\n\n    /**\n     * Computes the maximum value of `array`. If `array` is empty or falsey,\n     * `undefined` is returned.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Math\n     * @param {Array} array The array to iterate over.\n     * @returns {*} Returns the maximum value.\n     * @example\n     *\n     * _.max([4, 2, 8, 6]);\n     * // => 8\n     *\n     * _.max([]);\n     * // => undefined\n     */\n    function max(array) {\n      return (array && array.length)\n        ? baseExtremum(array, identity, baseGt)\n        : undefined;\n    }\n\n    /**\n     * This method is like `_.max` except that it accepts `iteratee` which is\n     * invoked for each element in `array` to generate the criterion by which\n     * the value is ranked. The iteratee is invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Math\n     * @param {Array} array The array to iterate over.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {*} Returns the maximum value.\n     * @example\n     *\n     * var objects = [{ 'n': 1 }, { 'n': 2 }];\n     *\n     * _.maxBy(objects, function(o) { return o.n; });\n     * // => { 'n': 2 }\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.maxBy(objects, 'n');\n     * // => { 'n': 2 }\n     */\n    function maxBy(array, iteratee) {\n      return (array && array.length)\n        ? baseExtremum(array, getIteratee(iteratee, 2), baseGt)\n        : undefined;\n    }\n\n    /**\n     * Computes the mean of the values in `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Math\n     * @param {Array} array The array to iterate over.\n     * @returns {number} Returns the mean.\n     * @example\n     *\n     * _.mean([4, 2, 8, 6]);\n     * // => 5\n     */\n    function mean(array) {\n      return baseMean(array, identity);\n    }\n\n    /**\n     * This method is like `_.mean` except that it accepts `iteratee` which is\n     * invoked for each element in `array` to generate the value to be averaged.\n     * The iteratee is invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.7.0\n     * @category Math\n     * @param {Array} array The array to iterate over.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {number} Returns the mean.\n     * @example\n     *\n     * var objects = [{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }];\n     *\n     * _.meanBy(objects, function(o) { return o.n; });\n     * // => 5\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.meanBy(objects, 'n');\n     * // => 5\n     */\n    function meanBy(array, iteratee) {\n      return baseMean(array, getIteratee(iteratee, 2));\n    }\n\n    /**\n     * Computes the minimum value of `array`. If `array` is empty or falsey,\n     * `undefined` is returned.\n     *\n     * @static\n     * @since 0.1.0\n     * @memberOf _\n     * @category Math\n     * @param {Array} array The array to iterate over.\n     * @returns {*} Returns the minimum value.\n     * @example\n     *\n     * _.min([4, 2, 8, 6]);\n     * // => 2\n     *\n     * _.min([]);\n     * // => undefined\n     */\n    function min(array) {\n      return (array && array.length)\n        ? baseExtremum(array, identity, baseLt)\n        : undefined;\n    }\n\n    /**\n     * This method is like `_.min` except that it accepts `iteratee` which is\n     * invoked for each element in `array` to generate the criterion by which\n     * the value is ranked. The iteratee is invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Math\n     * @param {Array} array The array to iterate over.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {*} Returns the minimum value.\n     * @example\n     *\n     * var objects = [{ 'n': 1 }, { 'n': 2 }];\n     *\n     * _.minBy(objects, function(o) { return o.n; });\n     * // => { 'n': 1 }\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.minBy(objects, 'n');\n     * // => { 'n': 1 }\n     */\n    function minBy(array, iteratee) {\n      return (array && array.length)\n        ? baseExtremum(array, getIteratee(iteratee, 2), baseLt)\n        : undefined;\n    }\n\n    /**\n     * Multiply two numbers.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.7.0\n     * @category Math\n     * @param {number} multiplier The first number in a multiplication.\n     * @param {number} multiplicand The second number in a multiplication.\n     * @returns {number} Returns the product.\n     * @example\n     *\n     * _.multiply(6, 4);\n     * // => 24\n     */\n    var multiply = createMathOperation(function(multiplier, multiplicand) {\n      return multiplier * multiplicand;\n    }, 1);\n\n    /**\n     * Computes `number` rounded to `precision`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.10.0\n     * @category Math\n     * @param {number} number The number to round.\n     * @param {number} [precision=0] The precision to round to.\n     * @returns {number} Returns the rounded number.\n     * @example\n     *\n     * _.round(4.006);\n     * // => 4\n     *\n     * _.round(4.006, 2);\n     * // => 4.01\n     *\n     * _.round(4060, -2);\n     * // => 4100\n     */\n    var round = createRound('round');\n\n    /**\n     * Subtract two numbers.\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Math\n     * @param {number} minuend The first number in a subtraction.\n     * @param {number} subtrahend The second number in a subtraction.\n     * @returns {number} Returns the difference.\n     * @example\n     *\n     * _.subtract(6, 4);\n     * // => 2\n     */\n    var subtract = createMathOperation(function(minuend, subtrahend) {\n      return minuend - subtrahend;\n    }, 0);\n\n    /**\n     * Computes the sum of the values in `array`.\n     *\n     * @static\n     * @memberOf _\n     * @since 3.4.0\n     * @category Math\n     * @param {Array} array The array to iterate over.\n     * @returns {number} Returns the sum.\n     * @example\n     *\n     * _.sum([4, 2, 8, 6]);\n     * // => 20\n     */\n    function sum(array) {\n      return (array && array.length)\n        ? baseSum(array, identity)\n        : 0;\n    }\n\n    /**\n     * This method is like `_.sum` except that it accepts `iteratee` which is\n     * invoked for each element in `array` to generate the value to be summed.\n     * The iteratee is invoked with one argument: (value).\n     *\n     * @static\n     * @memberOf _\n     * @since 4.0.0\n     * @category Math\n     * @param {Array} array The array to iterate over.\n     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n     * @returns {number} Returns the sum.\n     * @example\n     *\n     * var objects = [{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }];\n     *\n     * _.sumBy(objects, function(o) { return o.n; });\n     * // => 20\n     *\n     * // The `_.property` iteratee shorthand.\n     * _.sumBy(objects, 'n');\n     * // => 20\n     */\n    function sumBy(array, iteratee) {\n      return (array && array.length)\n        ? baseSum(array, getIteratee(iteratee, 2))\n        : 0;\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    // Add methods that return wrapped values in chain sequences.\n    lodash.after = after;\n    lodash.ary = ary;\n    lodash.assign = assign;\n    lodash.assignIn = assignIn;\n    lodash.assignInWith = assignInWith;\n    lodash.assignWith = assignWith;\n    lodash.at = at;\n    lodash.before = before;\n    lodash.bind = bind;\n    lodash.bindAll = bindAll;\n    lodash.bindKey = bindKey;\n    lodash.castArray = castArray;\n    lodash.chain = chain;\n    lodash.chunk = chunk;\n    lodash.compact = compact;\n    lodash.concat = concat;\n    lodash.cond = cond;\n    lodash.conforms = conforms;\n    lodash.constant = constant;\n    lodash.countBy = countBy;\n    lodash.create = create;\n    lodash.curry = curry;\n    lodash.curryRight = curryRight;\n    lodash.debounce = debounce;\n    lodash.defaults = defaults;\n    lodash.defaultsDeep = defaultsDeep;\n    lodash.defer = defer;\n    lodash.delay = delay;\n    lodash.difference = difference;\n    lodash.differenceBy = differenceBy;\n    lodash.differenceWith = differenceWith;\n    lodash.drop = drop;\n    lodash.dropRight = dropRight;\n    lodash.dropRightWhile = dropRightWhile;\n    lodash.dropWhile = dropWhile;\n    lodash.fill = fill;\n    lodash.filter = filter;\n    lodash.flatMap = flatMap;\n    lodash.flatMapDeep = flatMapDeep;\n    lodash.flatMapDepth = flatMapDepth;\n    lodash.flatten = flatten;\n    lodash.flattenDeep = flattenDeep;\n    lodash.flattenDepth = flattenDepth;\n    lodash.flip = flip;\n    lodash.flow = flow;\n    lodash.flowRight = flowRight;\n    lodash.fromPairs = fromPairs;\n    lodash.functions = functions;\n    lodash.functionsIn = functionsIn;\n    lodash.groupBy = groupBy;\n    lodash.initial = initial;\n    lodash.intersection = intersection;\n    lodash.intersectionBy = intersectionBy;\n    lodash.intersectionWith = intersectionWith;\n    lodash.invert = invert;\n    lodash.invertBy = invertBy;\n    lodash.invokeMap = invokeMap;\n    lodash.iteratee = iteratee;\n    lodash.keyBy = keyBy;\n    lodash.keys = keys;\n    lodash.keysIn = keysIn;\n    lodash.map = map;\n    lodash.mapKeys = mapKeys;\n    lodash.mapValues = mapValues;\n    lodash.matches = matches;\n    lodash.matchesProperty = matchesProperty;\n    lodash.memoize = memoize;\n    lodash.merge = merge;\n    lodash.mergeWith = mergeWith;\n    lodash.method = method;\n    lodash.methodOf = methodOf;\n    lodash.mixin = mixin;\n    lodash.negate = negate;\n    lodash.nthArg = nthArg;\n    lodash.omit = omit;\n    lodash.omitBy = omitBy;\n    lodash.once = once;\n    lodash.orderBy = orderBy;\n    lodash.over = over;\n    lodash.overArgs = overArgs;\n    lodash.overEvery = overEvery;\n    lodash.overSome = overSome;\n    lodash.partial = partial;\n    lodash.partialRight = partialRight;\n    lodash.partition = partition;\n    lodash.pick = pick;\n    lodash.pickBy = pickBy;\n    lodash.property = property;\n    lodash.propertyOf = propertyOf;\n    lodash.pull = pull;\n    lodash.pullAll = pullAll;\n    lodash.pullAllBy = pullAllBy;\n    lodash.pullAllWith = pullAllWith;\n    lodash.pullAt = pullAt;\n    lodash.range = range;\n    lodash.rangeRight = rangeRight;\n    lodash.rearg = rearg;\n    lodash.reject = reject;\n    lodash.remove = remove;\n    lodash.rest = rest;\n    lodash.reverse = reverse;\n    lodash.sampleSize = sampleSize;\n    lodash.set = set;\n    lodash.setWith = setWith;\n    lodash.shuffle = shuffle;\n    lodash.slice = slice;\n    lodash.sortBy = sortBy;\n    lodash.sortedUniq = sortedUniq;\n    lodash.sortedUniqBy = sortedUniqBy;\n    lodash.split = split;\n    lodash.spread = spread;\n    lodash.tail = tail;\n    lodash.take = take;\n    lodash.takeRight = takeRight;\n    lodash.takeRightWhile = takeRightWhile;\n    lodash.takeWhile = takeWhile;\n    lodash.tap = tap;\n    lodash.throttle = throttle;\n    lodash.thru = thru;\n    lodash.toArray = toArray;\n    lodash.toPairs = toPairs;\n    lodash.toPairsIn = toPairsIn;\n    lodash.toPath = toPath;\n    lodash.toPlainObject = toPlainObject;\n    lodash.transform = transform;\n    lodash.unary = unary;\n    lodash.union = union;\n    lodash.unionBy = unionBy;\n    lodash.unionWith = unionWith;\n    lodash.uniq = uniq;\n    lodash.uniqBy = uniqBy;\n    lodash.uniqWith = uniqWith;\n    lodash.unset = unset;\n    lodash.unzip = unzip;\n    lodash.unzipWith = unzipWith;\n    lodash.update = update;\n    lodash.updateWith = updateWith;\n    lodash.values = values;\n    lodash.valuesIn = valuesIn;\n    lodash.without = without;\n    lodash.words = words;\n    lodash.wrap = wrap;\n    lodash.xor = xor;\n    lodash.xorBy = xorBy;\n    lodash.xorWith = xorWith;\n    lodash.zip = zip;\n    lodash.zipObject = zipObject;\n    lodash.zipObjectDeep = zipObjectDeep;\n    lodash.zipWith = zipWith;\n\n    // Add aliases.\n    lodash.entries = toPairs;\n    lodash.entriesIn = toPairsIn;\n    lodash.extend = assignIn;\n    lodash.extendWith = assignInWith;\n\n    // Add methods to `lodash.prototype`.\n    mixin(lodash, lodash);\n\n    /*------------------------------------------------------------------------*/\n\n    // Add methods that return unwrapped values in chain sequences.\n    lodash.add = add;\n    lodash.attempt = attempt;\n    lodash.camelCase = camelCase;\n    lodash.capitalize = capitalize;\n    lodash.ceil = ceil;\n    lodash.clamp = clamp;\n    lodash.clone = clone;\n    lodash.cloneDeep = cloneDeep;\n    lodash.cloneDeepWith = cloneDeepWith;\n    lodash.cloneWith = cloneWith;\n    lodash.conformsTo = conformsTo;\n    lodash.deburr = deburr;\n    lodash.defaultTo = defaultTo;\n    lodash.divide = divide;\n    lodash.endsWith = endsWith;\n    lodash.eq = eq;\n    lodash.escape = escape;\n    lodash.escapeRegExp = escapeRegExp;\n    lodash.every = every;\n    lodash.find = find;\n    lodash.findIndex = findIndex;\n    lodash.findKey = findKey;\n    lodash.findLast = findLast;\n    lodash.findLastIndex = findLastIndex;\n    lodash.findLastKey = findLastKey;\n    lodash.floor = floor;\n    lodash.forEach = forEach;\n    lodash.forEachRight = forEachRight;\n    lodash.forIn = forIn;\n    lodash.forInRight = forInRight;\n    lodash.forOwn = forOwn;\n    lodash.forOwnRight = forOwnRight;\n    lodash.get = get;\n    lodash.gt = gt;\n    lodash.gte = gte;\n    lodash.has = has;\n    lodash.hasIn = hasIn;\n    lodash.head = head;\n    lodash.identity = identity;\n    lodash.includes = includes;\n    lodash.indexOf = indexOf;\n    lodash.inRange = inRange;\n    lodash.invoke = invoke;\n    lodash.isArguments = isArguments;\n    lodash.isArray = isArray;\n    lodash.isArrayBuffer = isArrayBuffer;\n    lodash.isArrayLike = isArrayLike;\n    lodash.isArrayLikeObject = isArrayLikeObject;\n    lodash.isBoolean = isBoolean;\n    lodash.isBuffer = isBuffer;\n    lodash.isDate = isDate;\n    lodash.isElement = isElement;\n    lodash.isEmpty = isEmpty;\n    lodash.isEqual = isEqual;\n    lodash.isEqualWith = isEqualWith;\n    lodash.isError = isError;\n    lodash.isFinite = isFinite;\n    lodash.isFunction = isFunction;\n    lodash.isInteger = isInteger;\n    lodash.isLength = isLength;\n    lodash.isMap = isMap;\n    lodash.isMatch = isMatch;\n    lodash.isMatchWith = isMatchWith;\n    lodash.isNaN = isNaN;\n    lodash.isNative = isNative;\n    lodash.isNil = isNil;\n    lodash.isNull = isNull;\n    lodash.isNumber = isNumber;\n    lodash.isObject = isObject;\n    lodash.isObjectLike = isObjectLike;\n    lodash.isPlainObject = isPlainObject;\n    lodash.isRegExp = isRegExp;\n    lodash.isSafeInteger = isSafeInteger;\n    lodash.isSet = isSet;\n    lodash.isString = isString;\n    lodash.isSymbol = isSymbol;\n    lodash.isTypedArray = isTypedArray;\n    lodash.isUndefined = isUndefined;\n    lodash.isWeakMap = isWeakMap;\n    lodash.isWeakSet = isWeakSet;\n    lodash.join = join;\n    lodash.kebabCase = kebabCase;\n    lodash.last = last;\n    lodash.lastIndexOf = lastIndexOf;\n    lodash.lowerCase = lowerCase;\n    lodash.lowerFirst = lowerFirst;\n    lodash.lt = lt;\n    lodash.lte = lte;\n    lodash.max = max;\n    lodash.maxBy = maxBy;\n    lodash.mean = mean;\n    lodash.meanBy = meanBy;\n    lodash.min = min;\n    lodash.minBy = minBy;\n    lodash.stubArray = stubArray;\n    lodash.stubFalse = stubFalse;\n    lodash.stubObject = stubObject;\n    lodash.stubString = stubString;\n    lodash.stubTrue = stubTrue;\n    lodash.multiply = multiply;\n    lodash.nth = nth;\n    lodash.noConflict = noConflict;\n    lodash.noop = noop;\n    lodash.now = now;\n    lodash.pad = pad;\n    lodash.padEnd = padEnd;\n    lodash.padStart = padStart;\n    lodash.parseInt = parseInt;\n    lodash.random = random;\n    lodash.reduce = reduce;\n    lodash.reduceRight = reduceRight;\n    lodash.repeat = repeat;\n    lodash.replace = replace;\n    lodash.result = result;\n    lodash.round = round;\n    lodash.runInContext = runInContext;\n    lodash.sample = sample;\n    lodash.size = size;\n    lodash.snakeCase = snakeCase;\n    lodash.some = some;\n    lodash.sortedIndex = sortedIndex;\n    lodash.sortedIndexBy = sortedIndexBy;\n    lodash.sortedIndexOf = sortedIndexOf;\n    lodash.sortedLastIndex = sortedLastIndex;\n    lodash.sortedLastIndexBy = sortedLastIndexBy;\n    lodash.sortedLastIndexOf = sortedLastIndexOf;\n    lodash.startCase = startCase;\n    lodash.startsWith = startsWith;\n    lodash.subtract = subtract;\n    lodash.sum = sum;\n    lodash.sumBy = sumBy;\n    lodash.template = template;\n    lodash.times = times;\n    lodash.toFinite = toFinite;\n    lodash.toInteger = toInteger;\n    lodash.toLength = toLength;\n    lodash.toLower = toLower;\n    lodash.toNumber = toNumber;\n    lodash.toSafeInteger = toSafeInteger;\n    lodash.toString = toString;\n    lodash.toUpper = toUpper;\n    lodash.trim = trim;\n    lodash.trimEnd = trimEnd;\n    lodash.trimStart = trimStart;\n    lodash.truncate = truncate;\n    lodash.unescape = unescape;\n    lodash.uniqueId = uniqueId;\n    lodash.upperCase = upperCase;\n    lodash.upperFirst = upperFirst;\n\n    // Add aliases.\n    lodash.each = forEach;\n    lodash.eachRight = forEachRight;\n    lodash.first = head;\n\n    mixin(lodash, (function() {\n      var source = {};\n      baseForOwn(lodash, function(func, methodName) {\n        if (!hasOwnProperty.call(lodash.prototype, methodName)) {\n          source[methodName] = func;\n        }\n      });\n      return source;\n    }()), { 'chain': false });\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * The semantic version number.\n     *\n     * @static\n     * @memberOf _\n     * @type {string}\n     */\n    lodash.VERSION = VERSION;\n\n    // Assign default placeholders.\n    arrayEach(['bind', 'bindKey', 'curry', 'curryRight', 'partial', 'partialRight'], function(methodName) {\n      lodash[methodName].placeholder = lodash;\n    });\n\n    // Add `LazyWrapper` methods for `_.drop` and `_.take` variants.\n    arrayEach(['drop', 'take'], function(methodName, index) {\n      LazyWrapper.prototype[methodName] = function(n) {\n        n = n === undefined ? 1 : nativeMax(toInteger(n), 0);\n\n        var result = (this.__filtered__ && !index)\n          ? new LazyWrapper(this)\n          : this.clone();\n\n        if (result.__filtered__) {\n          result.__takeCount__ = nativeMin(n, result.__takeCount__);\n        } else {\n          result.__views__.push({\n            'size': nativeMin(n, MAX_ARRAY_LENGTH),\n            'type': methodName + (result.__dir__ < 0 ? 'Right' : '')\n          });\n        }\n        return result;\n      };\n\n      LazyWrapper.prototype[methodName + 'Right'] = function(n) {\n        return this.reverse()[methodName](n).reverse();\n      };\n    });\n\n    // Add `LazyWrapper` methods that accept an `iteratee` value.\n    arrayEach(['filter', 'map', 'takeWhile'], function(methodName, index) {\n      var type = index + 1,\n          isFilter = type == LAZY_FILTER_FLAG || type == LAZY_WHILE_FLAG;\n\n      LazyWrapper.prototype[methodName] = function(iteratee) {\n        var result = this.clone();\n        result.__iteratees__.push({\n          'iteratee': getIteratee(iteratee, 3),\n          'type': type\n        });\n        result.__filtered__ = result.__filtered__ || isFilter;\n        return result;\n      };\n    });\n\n    // Add `LazyWrapper` methods for `_.head` and `_.last`.\n    arrayEach(['head', 'last'], function(methodName, index) {\n      var takeName = 'take' + (index ? 'Right' : '');\n\n      LazyWrapper.prototype[methodName] = function() {\n        return this[takeName](1).value()[0];\n      };\n    });\n\n    // Add `LazyWrapper` methods for `_.initial` and `_.tail`.\n    arrayEach(['initial', 'tail'], function(methodName, index) {\n      var dropName = 'drop' + (index ? '' : 'Right');\n\n      LazyWrapper.prototype[methodName] = function() {\n        return this.__filtered__ ? new LazyWrapper(this) : this[dropName](1);\n      };\n    });\n\n    LazyWrapper.prototype.compact = function() {\n      return this.filter(identity);\n    };\n\n    LazyWrapper.prototype.find = function(predicate) {\n      return this.filter(predicate).head();\n    };\n\n    LazyWrapper.prototype.findLast = function(predicate) {\n      return this.reverse().find(predicate);\n    };\n\n    LazyWrapper.prototype.invokeMap = baseRest(function(path, args) {\n      if (typeof path == 'function') {\n        return new LazyWrapper(this);\n      }\n      return this.map(function(value) {\n        return baseInvoke(value, path, args);\n      });\n    });\n\n    LazyWrapper.prototype.reject = function(predicate) {\n      return this.filter(negate(getIteratee(predicate)));\n    };\n\n    LazyWrapper.prototype.slice = function(start, end) {\n      start = toInteger(start);\n\n      var result = this;\n      if (result.__filtered__ && (start > 0 || end < 0)) {\n        return new LazyWrapper(result);\n      }\n      if (start < 0) {\n        result = result.takeRight(-start);\n      } else if (start) {\n        result = result.drop(start);\n      }\n      if (end !== undefined) {\n        end = toInteger(end);\n        result = end < 0 ? result.dropRight(-end) : result.take(end - start);\n      }\n      return result;\n    };\n\n    LazyWrapper.prototype.takeRightWhile = function(predicate) {\n      return this.reverse().takeWhile(predicate).reverse();\n    };\n\n    LazyWrapper.prototype.toArray = function() {\n      return this.take(MAX_ARRAY_LENGTH);\n    };\n\n    // Add `LazyWrapper` methods to `lodash.prototype`.\n    baseForOwn(LazyWrapper.prototype, function(func, methodName) {\n      var checkIteratee = /^(?:filter|find|map|reject)|While$/.test(methodName),\n          isTaker = /^(?:head|last)$/.test(methodName),\n          lodashFunc = lodash[isTaker ? ('take' + (methodName == 'last' ? 'Right' : '')) : methodName],\n          retUnwrapped = isTaker || /^find/.test(methodName);\n\n      if (!lodashFunc) {\n        return;\n      }\n      lodash.prototype[methodName] = function() {\n        var value = this.__wrapped__,\n            args = isTaker ? [1] : arguments,\n            isLazy = value instanceof LazyWrapper,\n            iteratee = args[0],\n            useLazy = isLazy || isArray(value);\n\n        var interceptor = function(value) {\n          var result = lodashFunc.apply(lodash, arrayPush([value], args));\n          return (isTaker && chainAll) ? result[0] : result;\n        };\n\n        if (useLazy && checkIteratee && typeof iteratee == 'function' && iteratee.length != 1) {\n          // Avoid lazy use if the iteratee has a \"length\" value other than `1`.\n          isLazy = useLazy = false;\n        }\n        var chainAll = this.__chain__,\n            isHybrid = !!this.__actions__.length,\n            isUnwrapped = retUnwrapped && !chainAll,\n            onlyLazy = isLazy && !isHybrid;\n\n        if (!retUnwrapped && useLazy) {\n          value = onlyLazy ? value : new LazyWrapper(this);\n          var result = func.apply(value, args);\n          result.__actions__.push({ 'func': thru, 'args': [interceptor], 'thisArg': undefined });\n          return new LodashWrapper(result, chainAll);\n        }\n        if (isUnwrapped && onlyLazy) {\n          return func.apply(this, args);\n        }\n        result = this.thru(interceptor);\n        return isUnwrapped ? (isTaker ? result.value()[0] : result.value()) : result;\n      };\n    });\n\n    // Add `Array` methods to `lodash.prototype`.\n    arrayEach(['pop', 'push', 'shift', 'sort', 'splice', 'unshift'], function(methodName) {\n      var func = arrayProto[methodName],\n          chainName = /^(?:push|sort|unshift)$/.test(methodName) ? 'tap' : 'thru',\n          retUnwrapped = /^(?:pop|shift)$/.test(methodName);\n\n      lodash.prototype[methodName] = function() {\n        var args = arguments;\n        if (retUnwrapped && !this.__chain__) {\n          var value = this.value();\n          return func.apply(isArray(value) ? value : [], args);\n        }\n        return this[chainName](function(value) {\n          return func.apply(isArray(value) ? value : [], args);\n        });\n      };\n    });\n\n    // Map minified method names to their real names.\n    baseForOwn(LazyWrapper.prototype, function(func, methodName) {\n      var lodashFunc = lodash[methodName];\n      if (lodashFunc) {\n        var key = lodashFunc.name + '';\n        if (!hasOwnProperty.call(realNames, key)) {\n          realNames[key] = [];\n        }\n        realNames[key].push({ 'name': methodName, 'func': lodashFunc });\n      }\n    });\n\n    realNames[createHybrid(undefined, WRAP_BIND_KEY_FLAG).name] = [{\n      'name': 'wrapper',\n      'func': undefined\n    }];\n\n    // Add methods to `LazyWrapper`.\n    LazyWrapper.prototype.clone = lazyClone;\n    LazyWrapper.prototype.reverse = lazyReverse;\n    LazyWrapper.prototype.value = lazyValue;\n\n    // Add chain sequence methods to the `lodash` wrapper.\n    lodash.prototype.at = wrapperAt;\n    lodash.prototype.chain = wrapperChain;\n    lodash.prototype.commit = wrapperCommit;\n    lodash.prototype.next = wrapperNext;\n    lodash.prototype.plant = wrapperPlant;\n    lodash.prototype.reverse = wrapperReverse;\n    lodash.prototype.toJSON = lodash.prototype.valueOf = lodash.prototype.value = wrapperValue;\n\n    // Add lazy aliases.\n    lodash.prototype.first = lodash.prototype.head;\n\n    if (symIterator) {\n      lodash.prototype[symIterator] = wrapperToIterator;\n    }\n    return lodash;\n  });\n\n  /*--------------------------------------------------------------------------*/\n\n  // Export lodash.\n  var _ = runInContext();\n\n  // Some AMD build optimizers, like r.js, check for condition patterns like:\n  if (typeof define == 'function' && typeof define.amd == 'object' && define.amd) {\n    // Expose Lodash on the global object to prevent errors when Lodash is\n    // loaded by a script tag in the presence of an AMD loader.\n    // See http://requirejs.org/docs/errors.html#mismatch for more details.\n    // Use `_.noConflict` to remove Lodash from the global object.\n    root._ = _;\n\n    // Define as an anonymous module so, through path mapping, it can be\n    // referenced as the \"underscore\" module.\n    define(function() {\n      return _;\n    });\n  }\n  // Check for `exports` after `define` in case a build optimizer adds it.\n  else if (freeModule) {\n    // Export for Node.js.\n    (freeModule.exports = _)._ = _;\n    // Export for CommonJS support.\n    freeExports._ = _;\n  }\n  else {\n    // Export to the global object.\n    root._ = _;\n  }\n}.call(this));\n","'use strict';\n\n/** @type {import('./abs')} */\nmodule.exports = Math.abs;\n","'use strict';\n\n/** @type {import('./floor')} */\nmodule.exports = Math.floor;\n","'use strict';\n\n/** @type {import('./isNaN')} */\nmodule.exports = Number.isNaN || function isNaN(a) {\n\treturn a !== a;\n};\n","'use strict';\n\n/** @type {import('./max')} */\nmodule.exports = Math.max;\n","'use strict';\n\n/** @type {import('./min')} */\nmodule.exports = Math.min;\n","'use strict';\n\n/** @type {import('./pow')} */\nmodule.exports = Math.pow;\n","'use strict';\n\n/** @type {import('./round')} */\nmodule.exports = Math.round;\n","'use strict';\n\nvar $isNaN = require('./isNaN');\n\n/** @type {import('./sign')} */\nmodule.exports = function sign(number) {\n\tif ($isNaN(number) || number === 0) {\n\t\treturn number;\n\t}\n\treturn number < 0 ? -1 : +1;\n};\n","(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c=\"function\"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error(\"Cannot find module '\"+i+\"'\");throw a.code=\"MODULE_NOT_FOUND\",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u=\"function\"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()","/*\nCopyright 2021-2022 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { IEncryptedFile, IEncryptedFileJWK } from '.';\n\nexport async function encryptAttachment(plaintextBuffer: ArrayBuffer): Promise<{\n    data: ArrayBuffer;\n    info: IEncryptedFile;\n}> {\n    // Generate an IV where the first 8 bytes are random and the high 8 bytes\n    // are zero. We set the counter low bits to 0 since it makes it unlikely\n    // that the 64 bit counter will overflow.\n    const ivArray = new Uint8Array(16); // Uint8Array of AES IV\n    window.crypto.getRandomValues(ivArray.subarray(0, 8));\n    // Load the encryption key.\n    const cryptoKey = await window.crypto.subtle.generateKey(\n        { 'name': 'AES-CTR', 'length': 256 }, true, ['encrypt', 'decrypt'],\n    );\n    // Export the Key as JWK.\n    const exportedKey = await window.crypto.subtle.exportKey('jwk', cryptoKey);\n    // Encrypt the input ArrayBuffer.\n    // Use half of the iv as the counter by setting the \"length\" to 64.\n    const ciphertextBuffer = await window.crypto.subtle.encrypt(\n        { name: 'AES-CTR', counter: ivArray, length: 64 }, cryptoKey, plaintextBuffer,\n    );\n    // SHA-256 the encrypted data.\n    const sha256Buffer = await window.crypto.subtle.digest('SHA-256', ciphertextBuffer);\n    return {\n        data: ciphertextBuffer,\n        info: {\n            v: 'v2',\n            key: exportedKey as IEncryptedFileJWK,\n            iv: encodeBase64(ivArray),\n            hashes: {\n                sha256: encodeBase64(new Uint8Array(sha256Buffer)),\n            },\n        },\n    };\n}\n\nexport async function decryptAttachment(ciphertextBuffer: ArrayBuffer, info: IEncryptedFile): Promise<ArrayBuffer> {\n    if (info === undefined || info.key === undefined || info.iv === undefined\n        || info.hashes === undefined || info.hashes.sha256 === undefined) {\n        throw new Error('Invalid info. Missing info.key, info.iv or info.hashes.sha256 key');\n    }\n\n    if (info.v && !info.v.match(/^v[1-2]$/)) {\n        throw new Error(`Unsupported protocol version: ${info.v}`);\n    }\n\n    const ivArray = decodeBase64(info.iv);\n    const expectedSha256base64 = info.hashes.sha256;\n    // Load the AES from the \"key\" key of the inf bao object.\n    const cryptoKey = await window.crypto.subtle.importKey(\n        'jwk', info.key, { 'name': 'AES-CTR' }, false, ['encrypt', 'decrypt'],\n    );\n    const digestResult = await window.crypto.subtle.digest('SHA-256', ciphertextBuffer);\n    if (encodeBase64(new Uint8Array(digestResult)) != expectedSha256base64) {\n        throw new Error('Mismatched SHA-256 digest');\n    }\n    let counterLength: number;\n    if (info.v == 'v1' || info.v == 'v2') {\n        // Version 1 and 2 use a 64 bit counter.\n        counterLength = 64;\n    } else {\n        // Version 0 uses a 128 bit counter.\n        counterLength = 128;\n    }\n    return window.crypto.subtle.decrypt(\n        { name: 'AES-CTR', counter: ivArray, length: counterLength }, cryptoKey, ciphertextBuffer,\n    );\n}\n\nexport function encodeBase64(uint8Array: Uint8Array): string {\n    // Misinterpt the Uint8Array as Latin-1.\n    // window.btoa expects a unicode string with codepoints in the range 0-255.\n    const latin1String = String.fromCharCode.apply(null, uint8Array);\n    // Use the builtin base64 encoder.\n    const paddedBase64 = window.btoa(latin1String);\n    // Calculate the unpadded length.\n    const inputLength = uint8Array.length;\n    const outputLength = 4 * Math.floor((inputLength + 2) / 3) + (inputLength + 2) % 3 - 2;\n    // Return the unpadded base64.\n    return paddedBase64.slice(0, outputLength);\n}\n\nexport function decodeBase64(base64: string): Uint8Array {\n    // Pad the base64 up to the next multiple of 4.\n    const paddedBase64 = base64 + '==='.slice(0, (4 - base64.length % 4) % 4);\n    // Decode the base64 as a misinterpreted Latin-1 string.\n    // window.atob returns a unicode string with codepoints in the range 0-255.\n    const latin1String = window.atob(paddedBase64);\n    // Encode the string as a Uint8Array as Latin-1.\n    const uint8Array = new Uint8Array(latin1String.length);\n    for (let i = 0; i < latin1String.length; i++) {\n        uint8Array[i] = latin1String.charCodeAt(i);\n    }\n    return uint8Array;\n}\n\nexport default {\n    encryptAttachment,\n    decryptAttachment,\n    encodeBase64,\n    decodeBase64,\n};\n","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.ExtensibleEvents = void 0;\n\nvar _NamespacedMap = require(\"./NamespacedMap\");\n\nvar _InvalidEventError = require(\"./InvalidEventError\");\n\nvar _MRoomMessage = require(\"./interpreters/legacy/MRoomMessage\");\n\nvar _MMessage = require(\"./interpreters/modern/MMessage\");\n\nvar _message_types = require(\"./events/message_types\");\n\nvar _poll_types = require(\"./events/poll_types\");\n\nvar _MPoll = require(\"./interpreters/modern/MPoll\");\n\nfunction _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== \"undefined\" && o[Symbol.iterator] || o[\"@@iterator\"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it[\"return\"] != null) it[\"return\"](); } finally { if (didErr) throw err; } } }; }\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 _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\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\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\n/**\n * Utility class for parsing and identifying event types in a renderable form. An\n * instance of this class can be created to change rendering preference depending\n * on use-case.\n */\nvar ExtensibleEvents = /*#__PURE__*/function () {\n  function ExtensibleEvents() {\n    _classCallCheck(this, ExtensibleEvents);\n\n    _defineProperty(this, \"interpreters\", new _NamespacedMap.NamespacedMap([// Remember to add your unit test when adding to this! (\"known events\" test description)\n    [_MRoomMessage.LEGACY_M_ROOM_MESSAGE, _MRoomMessage.parseMRoomMessage], [_message_types.M_MESSAGE, _MMessage.parseMMessage], [_message_types.M_EMOTE, _MMessage.parseMMessage], [_message_types.M_NOTICE, _MMessage.parseMMessage], [_poll_types.M_POLL_START, _MPoll.parseMPoll], [_poll_types.M_POLL_RESPONSE, _MPoll.parseMPoll], [_poll_types.M_POLL_END, _MPoll.parseMPoll]]));\n\n    _defineProperty(this, \"_unknownInterpretOrder\", [_message_types.M_MESSAGE]);\n  }\n  /**\n   * Gets the default instance for all extensible event parsing.\n   */\n\n\n  _createClass(ExtensibleEvents, [{\n    key: \"unknownInterpretOrder\",\n    get:\n    /**\n     * Gets the order the internal processor will use for unknown primary\n     * event types.\n     */\n    function get() {\n      var _this$_unknownInterpr;\n\n      return (_this$_unknownInterpr = this._unknownInterpretOrder) !== null && _this$_unknownInterpr !== void 0 ? _this$_unknownInterpr : [];\n    }\n    /**\n     * Sets the order the internal processor will use for unknown primary\n     * event types.\n     * @param {NamespacedValue<string, string>[]} val The parsing order.\n     */\n    ,\n    set: function set(val) {\n      this._unknownInterpretOrder = val;\n    }\n    /**\n     * Gets the order the internal processor will use for unknown primary\n     * event types.\n     */\n\n  }, {\n    key: \"registerInterpreter\",\n    value:\n    /**\n     * Registers a primary event type interpreter. Note that the interpreter might be\n     * called with non-primary events if the event is being parsed as a fallback.\n     * @param {NamespacedValue<string, string>} wireEventType The event type.\n     * @param {EventInterpreter} interpreter The interpreter.\n     */\n    function registerInterpreter(wireEventType, interpreter) {\n      this.interpreters.set(wireEventType, interpreter);\n    }\n    /**\n     * Registers a primary event type interpreter. Note that the interpreter might be\n     * called with non-primary events if the event is being parsed as a fallback.\n     * @param {NamespacedValue<string, string>} wireEventType The event type.\n     * @param {EventInterpreter} interpreter The interpreter.\n     */\n\n  }, {\n    key: \"parse\",\n    value:\n    /**\n     * Parses an event, trying the primary event type first. If the primary type is not known\n     * then the content will be inspected to find the most suitable fallback.\n     *\n     * If the parsing failed or was a completely unknown type, this will return falsy.\n     * @param {IPartialEvent<object>} wireFormat The event to parse.\n     * @returns {Optional<ExtensibleEvent>} The parsed extensible event.\n     */\n    function parse(wireFormat) {\n      try {\n        if (this.interpreters.hasNamespaced(wireFormat.type)) {\n          return this.interpreters.getNamespaced(wireFormat.type)(wireFormat);\n        }\n\n        var _iterator = _createForOfIteratorHelper(this.unknownInterpretOrder),\n            _step;\n\n        try {\n          for (_iterator.s(); !(_step = _iterator.n()).done;) {\n            var tryType = _step.value;\n\n            if (this.interpreters.has(tryType)) {\n              var val = this.interpreters.get(tryType)(wireFormat);\n              if (val) return val;\n            }\n          }\n        } catch (err) {\n          _iterator.e(err);\n        } finally {\n          _iterator.f();\n        }\n\n        return null; // cannot be parsed\n      } catch (e) {\n        if (e instanceof _InvalidEventError.InvalidEventError) {\n          return null; // fail parsing and move on\n        }\n\n        throw e; // re-throw everything else\n      }\n    }\n    /**\n     * Parses an event, trying the primary event type first. If the primary type is not known\n     * then the content will be inspected to find the most suitable fallback.\n     *\n     * If the parsing failed or was a completely unknown type, this will return falsy.\n     * @param {IPartialEvent<object>} wireFormat The event to parse.\n     * @returns {Optional<ExtensibleEvent>} The parsed extensible event.\n     */\n\n  }], [{\n    key: \"defaultInstance\",\n    get: function get() {\n      return ExtensibleEvents._defaultInstance;\n    }\n  }, {\n    key: \"unknownInterpretOrder\",\n    get: function get() {\n      return ExtensibleEvents.defaultInstance.unknownInterpretOrder;\n    }\n    /**\n     * Sets the order the internal processor will use for unknown primary\n     * event types.\n     * @param {NamespacedValue<string, string>[]} val The parsing order.\n     */\n    ,\n    set: function set(val) {\n      ExtensibleEvents.defaultInstance.unknownInterpretOrder = val;\n    }\n  }, {\n    key: \"registerInterpreter\",\n    value: function registerInterpreter(wireEventType, interpreter) {\n      ExtensibleEvents.defaultInstance.registerInterpreter(wireEventType, interpreter);\n    }\n  }, {\n    key: \"parse\",\n    value: function parse(wireFormat) {\n      return ExtensibleEvents.defaultInstance.parse(wireFormat);\n    }\n  }]);\n\n  return ExtensibleEvents;\n}();\n\nexports.ExtensibleEvents = ExtensibleEvents;\n\n_defineProperty(ExtensibleEvents, \"_defaultInstance\", new ExtensibleEvents());","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});","\"use strict\";\n\nfunction _typeof(obj) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }, _typeof(obj); }\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.InvalidEventError = void 0;\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\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function\"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, \"prototype\", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }\n\nfunction _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }\n\nfunction _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) { return call; } else if (call !== void 0) { throw new TypeError(\"Derived constructors may only return object or undefined\"); } return _assertThisInitialized(self); }\n\nfunction _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return self; }\n\nfunction _wrapNativeSuper(Class) { var _cache = typeof Map === \"function\" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== \"function\") { throw new TypeError(\"Super expression must either be null or a function\"); } if (typeof _cache !== \"undefined\") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }\n\nfunction _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }\n\nfunction _isNativeReflectConstruct() { if (typeof Reflect === \"undefined\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \"function\") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }\n\nfunction _isNativeFunction(fn) { return Function.toString.call(fn).indexOf(\"[native code]\") !== -1; }\n\nfunction _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }\n\nfunction _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }\n\n/*\nCopyright 2022 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\n/**\n * Thrown when an event is unforgivably unparsable.\n */\nvar InvalidEventError = /*#__PURE__*/function (_Error) {\n  _inherits(InvalidEventError, _Error);\n\n  var _super = _createSuper(InvalidEventError);\n\n  function InvalidEventError(message) {\n    _classCallCheck(this, InvalidEventError);\n\n    return _super.call(this, message);\n  }\n\n  return _createClass(InvalidEventError);\n}( /*#__PURE__*/_wrapNativeSuper(Error));\n\nexports.InvalidEventError = InvalidEventError;","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.NamespacedMap = void 0;\n\nfunction _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== \"undefined\" && o[Symbol.iterator] || o[\"@@iterator\"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it[\"return\"] != null) it[\"return\"](); } finally { if (didErr) throw err; } } }; }\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 _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\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\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\n/**\n * A `Map` implementation which accepts a NamespacedValue as a key, and arbitrary value. The\n * namespaced value must be a string type.\n */\nvar NamespacedMap = /*#__PURE__*/function () {\n  // protected to make tests happy for access\n\n  /**\n   * Creates a new map with optional seed data.\n   * @param {Array<[NS, V]>} initial The seed data.\n   */\n  function NamespacedMap(initial) {\n    _classCallCheck(this, NamespacedMap);\n\n    _defineProperty(this, \"internalMap\", new Map());\n\n    if (initial) {\n      var _iterator = _createForOfIteratorHelper(initial),\n          _step;\n\n      try {\n        for (_iterator.s(); !(_step = _iterator.n()).done;) {\n          var val = _step.value;\n          this.set(val[0], val[1]);\n        }\n      } catch (err) {\n        _iterator.e(err);\n      } finally {\n        _iterator.f();\n      }\n    }\n  }\n  /**\n   * Gets a value from the map. If the value does not exist under\n   * either namespace option, falsy is returned.\n   * @param {NS} key The key.\n   * @returns {Optional<V>} The value, or falsy.\n   */\n\n\n  _createClass(NamespacedMap, [{\n    key: \"get\",\n    value: function get(key) {\n      if (key.name && this.internalMap.has(key.name)) {\n        return this.internalMap.get(key.name);\n      }\n\n      if (key.altName && this.internalMap.has(key.altName)) {\n        return this.internalMap.get(key.altName);\n      }\n\n      return null;\n    }\n    /**\n     * Sets a value in the map.\n     * @param {NS} key The key.\n     * @param {V} val The value.\n     */\n\n  }, {\n    key: \"set\",\n    value: function set(key, val) {\n      if (key.name) {\n        this.internalMap.set(key.name, val);\n      }\n\n      if (key.altName) {\n        this.internalMap.set(key.altName, val);\n      }\n    }\n    /**\n     * Determines if any of the valid namespaced values are present\n     * in the map.\n     * @param {NS} key The key.\n     * @returns {boolean} True if present.\n     */\n\n  }, {\n    key: \"has\",\n    value: function has(key) {\n      return !!this.get(key);\n    }\n    /**\n     * Removes all the namespaced values from the map.\n     * @param {NS} key The key.\n     */\n\n  }, {\n    key: \"delete\",\n    value: function _delete(key) {\n      if (key.name) {\n        this.internalMap[\"delete\"](key.name);\n      }\n\n      if (key.altName) {\n        this.internalMap[\"delete\"](key.altName);\n      }\n    }\n    /**\n     * Determines if the map contains a specific namespaced value\n     * instead of the parent NS type.\n     * @param {string} key The key.\n     * @returns {boolean} True if present.\n     */\n\n  }, {\n    key: \"hasNamespaced\",\n    value: function hasNamespaced(key) {\n      return this.internalMap.has(key);\n    }\n    /**\n     * Gets a specific namespaced value from the map instead of the\n     * parent NS type. Returns falsy if not found.\n     * @param {string} key The key.\n     * @returns {Optional<V>} The value, or falsy.\n     */\n\n  }, {\n    key: \"getNamespaced\",\n    value: function getNamespaced(key) {\n      return this.internalMap.get(key);\n    }\n  }]);\n\n  return NamespacedMap;\n}();\n\nexports.NamespacedMap = NamespacedMap;","\"use strict\";\n\nfunction _typeof(obj) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }, _typeof(obj); }\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.UnstableValue = exports.NamespacedValue = void 0;\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function\"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, \"prototype\", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }\n\nfunction _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }\n\nfunction _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }\n\nfunction _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) { return call; } else if (call !== void 0) { throw new TypeError(\"Derived constructors may only return object or undefined\"); } return _assertThisInitialized(self); }\n\nfunction _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return self; }\n\nfunction _isNativeReflectConstruct() { if (typeof Reflect === \"undefined\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \"function\") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }\n\nfunction _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\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/*\nCopyright 2021 - 2022 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\n/**\n * Represents a simple Matrix namespaced value. This will assume that if a stable prefix\n * is provided that the stable prefix should be used when representing the identifier.\n */\nvar NamespacedValue = /*#__PURE__*/function () {\n  // Stable is optional, but one of the two parameters is required, hence the weird-looking types.\n  // Goal is to have developers explicitly say there is no stable value (if applicable).\n  function NamespacedValue(stable, unstable) {\n    _classCallCheck(this, NamespacedValue);\n\n    this.stable = stable;\n    this.unstable = unstable;\n\n    if (!this.unstable && !this.stable) {\n      throw new Error(\"One of stable or unstable values must be supplied\");\n    }\n  }\n\n  _createClass(NamespacedValue, [{\n    key: \"name\",\n    get: function get() {\n      if (this.stable) {\n        return this.stable;\n      }\n\n      return this.unstable;\n    }\n  }, {\n    key: \"altName\",\n    get: function get() {\n      if (!this.stable) {\n        return null;\n      }\n\n      return this.unstable;\n    }\n  }, {\n    key: \"matches\",\n    value: function matches(val) {\n      return !!this.name && this.name === val || !!this.altName && this.altName === val;\n    } // this desperately wants https://github.com/microsoft/TypeScript/pull/26349 at the top level of the class\n    // so we can instantiate `NamespacedValue<string, _, _>` as a default type for that namespace.\n\n  }, {\n    key: \"findIn\",\n    value: function findIn(obj) {\n      var val;\n\n      if (this.name) {\n        val = obj === null || obj === void 0 ? void 0 : obj[this.name];\n      }\n\n      if (!val && this.altName) {\n        val = obj === null || obj === void 0 ? void 0 : obj[this.altName];\n      }\n\n      return val;\n    }\n  }, {\n    key: \"includedIn\",\n    value: function includedIn(arr) {\n      var included = false;\n\n      if (this.name) {\n        included = arr.includes(this.name);\n      }\n\n      if (!included && this.altName) {\n        included = arr.includes(this.altName);\n      }\n\n      return included;\n    }\n  }]);\n\n  return NamespacedValue;\n}();\n/**\n * Represents a namespaced value which prioritizes the unstable value over the stable\n * value.\n */\n\n\nexports.NamespacedValue = NamespacedValue;\n\nvar UnstableValue = /*#__PURE__*/function (_NamespacedValue) {\n  _inherits(UnstableValue, _NamespacedValue);\n\n  var _super = _createSuper(UnstableValue);\n\n  // Note: Constructor difference is that `unstable` is *required*.\n  function UnstableValue(stable, unstable) {\n    var _this;\n\n    _classCallCheck(this, UnstableValue);\n\n    _this = _super.call(this, stable, unstable);\n\n    if (!_this.unstable) {\n      throw new Error(\"Unstable value must be supplied\");\n    }\n\n    return _this;\n  }\n\n  _createClass(UnstableValue, [{\n    key: \"name\",\n    get: function get() {\n      return this.unstable;\n    }\n  }, {\n    key: \"altName\",\n    get: function get() {\n      return this.stable;\n    }\n  }]);\n\n  return UnstableValue;\n}(NamespacedValue);\n\nexports.UnstableValue = UnstableValue;","\"use strict\";\n\nfunction _typeof(obj) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }, _typeof(obj); }\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.EmoteEvent = void 0;\n\nvar _MessageEvent2 = require(\"./MessageEvent\");\n\nvar _message_types = require(\"./message_types\");\n\nvar _events = require(\"../utility/events\");\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\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\nfunction _get() { if (typeof Reflect !== \"undefined\" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(arguments.length < 3 ? target : receiver); } return desc.value; }; } return _get.apply(this, arguments); }\n\nfunction _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function\"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, \"prototype\", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }\n\nfunction _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }\n\nfunction _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }\n\nfunction _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) { return call; } else if (call !== void 0) { throw new TypeError(\"Derived constructors may only return object or undefined\"); } return _assertThisInitialized(self); }\n\nfunction _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return self; }\n\nfunction _isNativeReflectConstruct() { if (typeof Reflect === \"undefined\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \"function\") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }\n\nfunction _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }\n\n// Emote events are just decorated message events\n\n/**\n * Represents an emote. This is essentially a MessageEvent with\n * emote characteristics considered.\n */\nvar EmoteEvent = /*#__PURE__*/function (_MessageEvent) {\n  _inherits(EmoteEvent, _MessageEvent);\n\n  var _super = _createSuper(EmoteEvent);\n\n  function EmoteEvent(wireFormat) {\n    _classCallCheck(this, EmoteEvent);\n\n    return _super.call(this, wireFormat);\n  }\n\n  _createClass(EmoteEvent, [{\n    key: \"isEmote\",\n    get: function get() {\n      return true; // override\n    }\n  }, {\n    key: \"isEquivalentTo\",\n    value: function isEquivalentTo(primaryEventType) {\n      return (0, _events.isEventTypeSame)(primaryEventType, _message_types.M_EMOTE) || _get(_getPrototypeOf(EmoteEvent.prototype), \"isEquivalentTo\", this).call(this, primaryEventType);\n    }\n  }, {\n    key: \"serialize\",\n    value: function serialize() {\n      var message = _get(_getPrototypeOf(EmoteEvent.prototype), \"serialize\", this).call(this);\n\n      message.content['msgtype'] = \"m.emote\";\n      return message;\n    }\n    /**\n     * Creates a new EmoteEvent from text and HTML.\n     * @param {string} text The text.\n     * @param {string} html Optional HTML.\n     * @returns {MessageEvent} The representative message event.\n     */\n\n  }], [{\n    key: \"from\",\n    value: function from(text, html) {\n      var _content;\n\n      return new EmoteEvent({\n        type: _message_types.M_EMOTE.name,\n        content: (_content = {}, _defineProperty(_content, _message_types.M_TEXT.name, text), _defineProperty(_content, _message_types.M_HTML.name, html), _content)\n      });\n    }\n  }]);\n\n  return EmoteEvent;\n}(_MessageEvent2.MessageEvent);\n\nexports.EmoteEvent = EmoteEvent;","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.ExtensibleEvent = void 0;\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\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/*\nCopyright 2021 - 2022 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\n/**\n * Represents an Extensible Event in Matrix.\n */\nvar ExtensibleEvent = /*#__PURE__*/function () {\n  function ExtensibleEvent(wireFormat) {\n    _classCallCheck(this, ExtensibleEvent);\n\n    this.wireFormat = wireFormat;\n  }\n  /**\n   * Shortcut to wireFormat.content\n   */\n\n\n  _createClass(ExtensibleEvent, [{\n    key: \"wireContent\",\n    get: function get() {\n      return this.wireFormat.content;\n    }\n    /**\n     * Serializes the event into a format which can be used to send the\n     * event to the room.\n     * @returns {IPartialEvent<object>} The serialized event.\n     */\n\n  }]);\n\n  return ExtensibleEvent;\n}();\n\nexports.ExtensibleEvent = ExtensibleEvent;","\"use strict\";\n\nfunction _typeof(obj) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }, _typeof(obj); }\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.MessageEvent = void 0;\n\nvar _ExtensibleEvent2 = require(\"./ExtensibleEvent\");\n\nvar _types = require(\"../types\");\n\nvar _InvalidEventError = require(\"../InvalidEventError\");\n\nvar _message_types = require(\"./message_types\");\n\nvar _events = require(\"../utility/events\");\n\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\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\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function\"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, \"prototype\", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }\n\nfunction _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }\n\nfunction _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }\n\nfunction _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) { return call; } else if (call !== void 0) { throw new TypeError(\"Derived constructors may only return object or undefined\"); } return _assertThisInitialized(self); }\n\nfunction _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return self; }\n\nfunction _isNativeReflectConstruct() { if (typeof Reflect === \"undefined\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \"function\") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }\n\nfunction _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\n/**\n * Represents a message event. Message events are the simplest form of event with\n * just text (optionally of different mimetypes, like HTML).\n *\n * Message events can additionally be an Emote or Notice, though typically those\n * are represented as EmoteEvent and NoticeEvent respectively.\n */\nvar MessageEvent = /*#__PURE__*/function (_ExtensibleEvent) {\n  _inherits(MessageEvent, _ExtensibleEvent);\n\n  var _super = _createSuper(MessageEvent);\n\n  /**\n   * The default text for the event.\n   */\n\n  /**\n   * The default HTML for the event, if provided.\n   */\n\n  /**\n   * All the different renderings of the message. Note that this is the same\n   * format as an m.message body but may contain elements not found directly\n   * in the event content: this is because this is interpreted based off the\n   * other information available in the event.\n   */\n\n  /**\n   * Creates a new MessageEvent from a pure format. Note that the event is\n   * *not* parsed here: it will be treated as a literal m.message primary\n   * typed event.\n   * @param {IPartialEvent<M_MESSAGE_EVENT_CONTENT>} wireFormat The event.\n   */\n  function MessageEvent(wireFormat) {\n    var _this;\n\n    _classCallCheck(this, MessageEvent);\n\n    _this = _super.call(this, wireFormat);\n\n    _defineProperty(_assertThisInitialized(_this), \"text\", void 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"html\", void 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"renderings\", void 0);\n\n    var mmessage = _message_types.M_MESSAGE.findIn(_this.wireContent);\n\n    var mtext = _message_types.M_TEXT.findIn(_this.wireContent);\n\n    var mhtml = _message_types.M_HTML.findIn(_this.wireContent);\n\n    if ((0, _types.isProvided)(mmessage)) {\n      if (!Array.isArray(mmessage)) {\n        throw new _InvalidEventError.InvalidEventError(\"m.message contents must be an array\");\n      }\n\n      var text = mmessage.find(function (r) {\n        return !(0, _types.isProvided)(r.mimetype) || r.mimetype === \"text/plain\";\n      });\n      var html = mmessage.find(function (r) {\n        return r.mimetype === \"text/html\";\n      });\n      if (!text) throw new _InvalidEventError.InvalidEventError(\"m.message is missing a plain text representation\");\n      _this.text = text.body;\n      _this.html = html === null || html === void 0 ? void 0 : html.body;\n      _this.renderings = mmessage;\n    } else if ((0, _types.isOptionalAString)(mtext)) {\n      _this.text = mtext;\n      _this.html = mhtml;\n      _this.renderings = [{\n        body: mtext,\n        mimetype: \"text/plain\"\n      }];\n\n      if (_this.html) {\n        _this.renderings.push({\n          body: _this.html,\n          mimetype: \"text/html\"\n        });\n      }\n    } else {\n      throw new _InvalidEventError.InvalidEventError(\"Missing textual representation for event\");\n    }\n\n    return _this;\n  }\n  /**\n   * Gets whether this message is considered an \"emote\". Note that a message\n   * might be an emote and notice at the same time: while technically possible,\n   * the event should be interpreted as one or the other.\n   */\n\n\n  _createClass(MessageEvent, [{\n    key: \"isEmote\",\n    get: function get() {\n      return _message_types.M_EMOTE.matches(this.wireFormat.type) || (0, _types.isProvided)(_message_types.M_EMOTE.findIn(this.wireFormat.content));\n    }\n    /**\n     * Gets whether this message is considered a \"notice\". Note that a message\n     * might be an emote and notice at the same time: while technically possible,\n     * the event should be interpreted as one or the other.\n     */\n\n  }, {\n    key: \"isNotice\",\n    get: function get() {\n      return _message_types.M_NOTICE.matches(this.wireFormat.type) || (0, _types.isProvided)(_message_types.M_NOTICE.findIn(this.wireFormat.content));\n    }\n  }, {\n    key: \"isEquivalentTo\",\n    value: function isEquivalentTo(primaryEventType) {\n      return (0, _events.isEventTypeSame)(primaryEventType, _message_types.M_MESSAGE);\n    }\n  }, {\n    key: \"serializeMMessageOnly\",\n    value: function serializeMMessageOnly() {\n      var messageRendering = _defineProperty({}, _message_types.M_MESSAGE.name, this.renderings); // Use the shorthand if it's just a simple text event\n\n\n      if (this.renderings.length === 1) {\n        var mime = this.renderings[0].mimetype;\n\n        if (mime === undefined || mime === \"text/plain\") {\n          messageRendering = _defineProperty({}, _message_types.M_TEXT.name, this.renderings[0].body);\n        }\n      }\n\n      return messageRendering;\n    }\n  }, {\n    key: \"serialize\",\n    value: function serialize() {\n      var _this$html;\n\n      return {\n        type: \"m.room.message\",\n        content: _objectSpread(_objectSpread({}, this.serializeMMessageOnly()), {}, {\n          body: this.text,\n          msgtype: \"m.text\",\n          format: this.html ? \"org.matrix.custom.html\" : undefined,\n          formatted_body: (_this$html = this.html) !== null && _this$html !== void 0 ? _this$html : undefined\n        })\n      };\n    }\n    /**\n     * Creates a new MessageEvent from text and HTML.\n     * @param {string} text The text.\n     * @param {string} html Optional HTML.\n     * @returns {MessageEvent} The representative message event.\n     */\n\n  }], [{\n    key: \"from\",\n    value: function from(text, html) {\n      var _content;\n\n      return new MessageEvent({\n        type: _message_types.M_MESSAGE.name,\n        content: (_content = {}, _defineProperty(_content, _message_types.M_TEXT.name, text), _defineProperty(_content, _message_types.M_HTML.name, html), _content)\n      });\n    }\n  }]);\n\n  return MessageEvent;\n}(_ExtensibleEvent2.ExtensibleEvent);\n\nexports.MessageEvent = MessageEvent;","\"use strict\";\n\nfunction _typeof(obj) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }, _typeof(obj); }\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.NoticeEvent = void 0;\n\nvar _MessageEvent2 = require(\"./MessageEvent\");\n\nvar _message_types = require(\"./message_types\");\n\nvar _events = require(\"../utility/events\");\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\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\nfunction _get() { if (typeof Reflect !== \"undefined\" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(arguments.length < 3 ? target : receiver); } return desc.value; }; } return _get.apply(this, arguments); }\n\nfunction _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function\"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, \"prototype\", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }\n\nfunction _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }\n\nfunction _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }\n\nfunction _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) { return call; } else if (call !== void 0) { throw new TypeError(\"Derived constructors may only return object or undefined\"); } return _assertThisInitialized(self); }\n\nfunction _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return self; }\n\nfunction _isNativeReflectConstruct() { if (typeof Reflect === \"undefined\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \"function\") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }\n\nfunction _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }\n\n// Notice events are just decorated message events\n\n/**\n * Represents a notice. This is essentially a MessageEvent with\n * notice characteristics considered.\n */\nvar NoticeEvent = /*#__PURE__*/function (_MessageEvent) {\n  _inherits(NoticeEvent, _MessageEvent);\n\n  var _super = _createSuper(NoticeEvent);\n\n  function NoticeEvent(wireFormat) {\n    _classCallCheck(this, NoticeEvent);\n\n    return _super.call(this, wireFormat);\n  }\n\n  _createClass(NoticeEvent, [{\n    key: \"isNotice\",\n    get: function get() {\n      return true; // override\n    }\n  }, {\n    key: \"isEquivalentTo\",\n    value: function isEquivalentTo(primaryEventType) {\n      return (0, _events.isEventTypeSame)(primaryEventType, _message_types.M_NOTICE) || _get(_getPrototypeOf(NoticeEvent.prototype), \"isEquivalentTo\", this).call(this, primaryEventType);\n    }\n  }, {\n    key: \"serialize\",\n    value: function serialize() {\n      var message = _get(_getPrototypeOf(NoticeEvent.prototype), \"serialize\", this).call(this);\n\n      message.content['msgtype'] = \"m.notice\";\n      return message;\n    }\n    /**\n     * Creates a new NoticeEvent from text and HTML.\n     * @param {string} text The text.\n     * @param {string} html Optional HTML.\n     * @returns {MessageEvent} The representative message event.\n     */\n\n  }], [{\n    key: \"from\",\n    value: function from(text, html) {\n      var _content;\n\n      return new NoticeEvent({\n        type: _message_types.M_NOTICE.name,\n        content: (_content = {}, _defineProperty(_content, _message_types.M_TEXT.name, text), _defineProperty(_content, _message_types.M_HTML.name, html), _content)\n      });\n    }\n  }]);\n\n  return NoticeEvent;\n}(_MessageEvent2.MessageEvent);\n\nexports.NoticeEvent = NoticeEvent;","\"use strict\";\n\nfunction _typeof(obj) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }, _typeof(obj); }\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.PollEndEvent = void 0;\n\nvar _poll_types = require(\"./poll_types\");\n\nvar _InvalidEventError = require(\"../InvalidEventError\");\n\nvar _relationship_types = require(\"./relationship_types\");\n\nvar _MessageEvent = require(\"./MessageEvent\");\n\nvar _message_types = require(\"./message_types\");\n\nvar _events = require(\"../utility/events\");\n\nvar _ExtensibleEvent2 = require(\"./ExtensibleEvent\");\n\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\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\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function\"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, \"prototype\", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }\n\nfunction _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }\n\nfunction _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }\n\nfunction _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) { return call; } else if (call !== void 0) { throw new TypeError(\"Derived constructors may only return object or undefined\"); } return _assertThisInitialized(self); }\n\nfunction _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return self; }\n\nfunction _isNativeReflectConstruct() { if (typeof Reflect === \"undefined\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \"function\") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }\n\nfunction _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\n/**\n * Represents a poll end/closure event.\n */\nvar PollEndEvent = /*#__PURE__*/function (_ExtensibleEvent) {\n  _inherits(PollEndEvent, _ExtensibleEvent);\n\n  var _super = _createSuper(PollEndEvent);\n\n  /**\n   * The poll start event ID referenced by the response.\n   */\n\n  /**\n   * The closing message for the event.\n   */\n\n  /**\n   * Creates a new PollEndEvent from a pure format. Note that the event is *not*\n   * parsed here: it will be treated as a literal m.poll.response primary typed event.\n   * @param {IPartialEvent<M_POLL_END_EVENT_CONTENT>} wireFormat The event.\n   */\n  function PollEndEvent(wireFormat) {\n    var _this;\n\n    _classCallCheck(this, PollEndEvent);\n\n    _this = _super.call(this, wireFormat);\n\n    _defineProperty(_assertThisInitialized(_this), \"pollEventId\", void 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"closingMessage\", void 0);\n\n    var rel = _this.wireContent[\"m.relates_to\"];\n\n    if (!_relationship_types.REFERENCE_RELATION.matches(rel === null || rel === void 0 ? void 0 : rel.rel_type) || typeof (rel === null || rel === void 0 ? void 0 : rel.event_id) !== \"string\") {\n      throw new _InvalidEventError.InvalidEventError(\"Relationship must be a reference to an event\");\n    }\n\n    _this.pollEventId = rel.event_id;\n    _this.closingMessage = new _MessageEvent.MessageEvent(_this.wireFormat);\n    return _this;\n  }\n\n  _createClass(PollEndEvent, [{\n    key: \"isEquivalentTo\",\n    value: function isEquivalentTo(primaryEventType) {\n      return (0, _events.isEventTypeSame)(primaryEventType, _poll_types.M_POLL_END);\n    }\n  }, {\n    key: \"serialize\",\n    value: function serialize() {\n      return {\n        type: _poll_types.M_POLL_END.name,\n        content: _objectSpread(_defineProperty({\n          \"m.relates_to\": {\n            rel_type: _relationship_types.REFERENCE_RELATION.name,\n            event_id: this.pollEventId\n          }\n        }, _poll_types.M_POLL_END.name, {}), this.closingMessage.serialize().content)\n      };\n    }\n    /**\n     * Creates a new PollEndEvent from a poll event ID.\n     * @param {string} pollEventId The poll start event ID.\n     * @param {string} message A closing message, typically revealing the top answer.\n     * @returns {PollStartEvent} The representative poll closure event.\n     */\n\n  }], [{\n    key: \"from\",\n    value: function from(pollEventId, message) {\n      var _content;\n\n      return new PollEndEvent({\n        type: _poll_types.M_POLL_END.name,\n        content: (_content = {\n          \"m.relates_to\": {\n            rel_type: _relationship_types.REFERENCE_RELATION.name,\n            event_id: pollEventId\n          }\n        }, _defineProperty(_content, _poll_types.M_POLL_END.name, {}), _defineProperty(_content, _message_types.M_TEXT.name, message), _content)\n      });\n    }\n  }]);\n\n  return PollEndEvent;\n}(_ExtensibleEvent2.ExtensibleEvent);\n\nexports.PollEndEvent = PollEndEvent;","\"use strict\";\n\nfunction _typeof(obj) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }, _typeof(obj); }\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.PollResponseEvent = void 0;\n\nvar _ExtensibleEvent2 = require(\"./ExtensibleEvent\");\n\nvar _poll_types = require(\"./poll_types\");\n\nvar _InvalidEventError = require(\"../InvalidEventError\");\n\nvar _relationship_types = require(\"./relationship_types\");\n\nvar _events = require(\"../utility/events\");\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\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\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function\"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, \"prototype\", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }\n\nfunction _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }\n\nfunction _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }\n\nfunction _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) { return call; } else if (call !== void 0) { throw new TypeError(\"Derived constructors may only return object or undefined\"); } return _assertThisInitialized(self); }\n\nfunction _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return self; }\n\nfunction _isNativeReflectConstruct() { if (typeof Reflect === \"undefined\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \"function\") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }\n\nfunction _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\n/**\n * Represents a poll response event.\n */\nvar PollResponseEvent = /*#__PURE__*/function (_ExtensibleEvent) {\n  _inherits(PollResponseEvent, _ExtensibleEvent);\n\n  var _super = _createSuper(PollResponseEvent);\n\n  /**\n   * Creates a new PollResponseEvent from a pure format. Note that the event is *not*\n   * parsed here: it will be treated as a literal m.poll.response primary typed event.\n   *\n   * To validate the response against a poll, call `validateAgainst` after creation.\n   * @param {IPartialEvent<M_POLL_RESPONSE_EVENT_CONTENT>} wireFormat The event.\n   */\n  function PollResponseEvent(wireFormat) {\n    var _this;\n\n    _classCallCheck(this, PollResponseEvent);\n\n    _this = _super.call(this, wireFormat);\n\n    _defineProperty(_assertThisInitialized(_this), \"internalAnswerIds\", void 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"internalSpoiled\", void 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"pollEventId\", void 0);\n\n    var rel = _this.wireContent[\"m.relates_to\"];\n\n    if (!_relationship_types.REFERENCE_RELATION.matches(rel === null || rel === void 0 ? void 0 : rel.rel_type) || typeof (rel === null || rel === void 0 ? void 0 : rel.event_id) !== \"string\") {\n      throw new _InvalidEventError.InvalidEventError(\"Relationship must be a reference to an event\");\n    }\n\n    _this.pollEventId = rel.event_id;\n\n    _this.validateAgainst(null);\n\n    return _this;\n  }\n  /**\n   * Validates the poll response using the poll start event as a frame of reference. This\n   * is used to determine if the vote is spoiled, whether the answers are valid, etc.\n   * @param {PollStartEvent} poll The poll start event.\n   */\n\n\n  _createClass(PollResponseEvent, [{\n    key: \"answerIds\",\n    get:\n    /**\n     * The provided answers for the poll. Note that this may be falsy/unpredictable if\n     * the `spoiled` property is true.\n     */\n    function get() {\n      return this.internalAnswerIds;\n    }\n    /**\n     * The poll start event ID referenced by the response.\n     */\n\n  }, {\n    key: \"spoiled\",\n    get:\n    /**\n     * Whether the vote is spoiled.\n     */\n    function get() {\n      return this.internalSpoiled;\n    }\n  }, {\n    key: \"validateAgainst\",\n    value: function validateAgainst(poll) {\n      var response = _poll_types.M_POLL_RESPONSE.findIn(this.wireContent);\n\n      if (!Array.isArray(response === null || response === void 0 ? void 0 : response.answers)) {\n        this.internalSpoiled = true;\n        this.internalAnswerIds = [];\n        return;\n      }\n\n      var answers = response.answers;\n\n      if (answers.some(function (a) {\n        return typeof a !== \"string\";\n      }) || answers.length === 0) {\n        this.internalSpoiled = true;\n        this.internalAnswerIds = [];\n        return;\n      }\n\n      if (poll) {\n        if (answers.some(function (a) {\n          return !poll.answers.some(function (pa) {\n            return pa.id === a;\n          });\n        })) {\n          this.internalSpoiled = true;\n          this.internalAnswerIds = [];\n          return;\n        }\n\n        answers = answers.slice(0, poll.maxSelections);\n      }\n\n      this.internalAnswerIds = answers;\n      this.internalSpoiled = false;\n    }\n  }, {\n    key: \"isEquivalentTo\",\n    value: function isEquivalentTo(primaryEventType) {\n      return (0, _events.isEventTypeSame)(primaryEventType, _poll_types.M_POLL_RESPONSE);\n    }\n  }, {\n    key: \"serialize\",\n    value: function serialize() {\n      return {\n        type: _poll_types.M_POLL_RESPONSE.name,\n        content: _defineProperty({\n          \"m.relates_to\": {\n            rel_type: _relationship_types.REFERENCE_RELATION.name,\n            event_id: this.pollEventId\n          }\n        }, _poll_types.M_POLL_RESPONSE.name, {\n          answers: this.spoiled ? undefined : this.answerIds\n        })\n      };\n    }\n    /**\n     * Creates a new PollResponseEvent from a set of answers. To spoil the vote, pass an empty\n     * answers array.\n     * @param {string} answers The user's answers. Should be valid from a poll's answer IDs.\n     * @param {string} pollEventId The poll start event ID.\n     * @returns {PollStartEvent} The representative poll response event.\n     */\n\n  }], [{\n    key: \"from\",\n    value: function from(answers, pollEventId) {\n      return new PollResponseEvent({\n        type: _poll_types.M_POLL_RESPONSE.name,\n        content: _defineProperty({\n          \"m.relates_to\": {\n            rel_type: _relationship_types.REFERENCE_RELATION.name,\n            event_id: pollEventId\n          }\n        }, _poll_types.M_POLL_RESPONSE.name, {\n          answers: answers\n        })\n      });\n    }\n  }]);\n\n  return PollResponseEvent;\n}(_ExtensibleEvent2.ExtensibleEvent);\n\nexports.PollResponseEvent = PollResponseEvent;","\"use strict\";\n\nfunction _typeof(obj) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }, _typeof(obj); }\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.PollStartEvent = exports.PollAnswerSubevent = void 0;\n\nvar _poll_types = require(\"./poll_types\");\n\nvar _MessageEvent2 = require(\"./MessageEvent\");\n\nvar _message_types = require(\"./message_types\");\n\nvar _InvalidEventError = require(\"../InvalidEventError\");\n\nvar _NamespacedValue = require(\"../NamespacedValue\");\n\nvar _events = require(\"../utility/events\");\n\nvar _ExtensibleEvent2 = require(\"./ExtensibleEvent\");\n\nfunction _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }\n\nfunction _nonIterableSpread() { throw new TypeError(\"Invalid attempt to spread 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 _iterableToArray(iter) { if (typeof Symbol !== \"undefined\" && iter[Symbol.iterator] != null || iter[\"@@iterator\"] != null) return Array.from(iter); }\n\nfunction _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }\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 ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\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\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function\"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, \"prototype\", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }\n\nfunction _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }\n\nfunction _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }\n\nfunction _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) { return call; } else if (call !== void 0) { throw new TypeError(\"Derived constructors may only return object or undefined\"); } return _assertThisInitialized(self); }\n\nfunction _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return self; }\n\nfunction _isNativeReflectConstruct() { if (typeof Reflect === \"undefined\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \"function\") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }\n\nfunction _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\n/**\n * Represents a poll answer. Note that this is represented as a subtype and is\n * not registered as a parsable event - it is implied for usage exclusively\n * within the PollStartEvent parsing.\n */\nvar PollAnswerSubevent = /*#__PURE__*/function (_MessageEvent) {\n  _inherits(PollAnswerSubevent, _MessageEvent);\n\n  var _super = _createSuper(PollAnswerSubevent);\n\n  /**\n   * The answer ID.\n   */\n  function PollAnswerSubevent(wireFormat) {\n    var _this;\n\n    _classCallCheck(this, PollAnswerSubevent);\n\n    _this = _super.call(this, wireFormat);\n\n    _defineProperty(_assertThisInitialized(_this), \"id\", void 0);\n\n    var id = wireFormat.content.id;\n\n    if (!id || typeof id !== \"string\") {\n      throw new _InvalidEventError.InvalidEventError(\"Answer ID must be a non-empty string\");\n    }\n\n    _this.id = id;\n    return _this;\n  }\n\n  _createClass(PollAnswerSubevent, [{\n    key: \"serialize\",\n    value: function serialize() {\n      return {\n        type: \"org.matrix.sdk.poll.answer\",\n        content: _objectSpread({\n          id: this.id\n        }, this.serializeMMessageOnly())\n      };\n    }\n    /**\n     * Creates a new PollAnswerSubevent from ID and text.\n     * @param {string} id The answer ID (unique within the poll).\n     * @param {string} text The text.\n     * @returns {PollAnswerSubevent} The representative answer.\n     */\n\n  }], [{\n    key: \"from\",\n    value: function from(id, text) {\n      return new PollAnswerSubevent({\n        type: \"org.matrix.sdk.poll.answer\",\n        content: _defineProperty({\n          id: id\n        }, _message_types.M_TEXT.name, text)\n      });\n    }\n  }]);\n\n  return PollAnswerSubevent;\n}(_MessageEvent2.MessageEvent);\n/**\n * Represents a poll start event.\n */\n\n\nexports.PollAnswerSubevent = PollAnswerSubevent;\n\nvar PollStartEvent = /*#__PURE__*/function (_ExtensibleEvent) {\n  _inherits(PollStartEvent, _ExtensibleEvent);\n\n  var _super2 = _createSuper(PollStartEvent);\n\n  /**\n   * The question being asked, as a MessageEvent node.\n   */\n\n  /**\n   * The interpreted kind of poll. Note that this will infer a value that is known to the\n   * SDK rather than verbatim - this means unknown types will be represented as undisclosed\n   * polls.\n   *\n   * To get the raw kind, use rawKind.\n   */\n\n  /**\n   * The true kind as provided by the event sender. Might not be valid.\n   */\n\n  /**\n   * The maximum number of selections a user is allowed to make.\n   */\n\n  /**\n   * The possible answers for the poll.\n   */\n\n  /**\n   * Creates a new PollStartEvent from a pure format. Note that the event is *not*\n   * parsed here: it will be treated as a literal m.poll.start primary typed event.\n   * @param {IPartialEvent<M_POLL_START_EVENT_CONTENT>} wireFormat The event.\n   */\n  function PollStartEvent(wireFormat) {\n    var _this2;\n\n    _classCallCheck(this, PollStartEvent);\n\n    _this2 = _super2.call(this, wireFormat);\n\n    _defineProperty(_assertThisInitialized(_this2), \"question\", void 0);\n\n    _defineProperty(_assertThisInitialized(_this2), \"kind\", void 0);\n\n    _defineProperty(_assertThisInitialized(_this2), \"rawKind\", void 0);\n\n    _defineProperty(_assertThisInitialized(_this2), \"maxSelections\", void 0);\n\n    _defineProperty(_assertThisInitialized(_this2), \"answers\", void 0);\n\n    var poll = _poll_types.M_POLL_START.findIn(_this2.wireContent);\n\n    if (!poll.question) {\n      throw new _InvalidEventError.InvalidEventError(\"A question is required\");\n    }\n\n    _this2.question = new _MessageEvent2.MessageEvent({\n      type: \"org.matrix.sdk.poll.question\",\n      content: poll.question\n    });\n    _this2.rawKind = poll.kind;\n\n    if (_poll_types.M_POLL_KIND_DISCLOSED.matches(_this2.rawKind)) {\n      _this2.kind = _poll_types.M_POLL_KIND_DISCLOSED;\n    } else {\n      _this2.kind = _poll_types.M_POLL_KIND_UNDISCLOSED; // default & assumed value\n    }\n\n    _this2.maxSelections = Number.isFinite(poll.max_selections) && poll.max_selections > 0 ? poll.max_selections : 1;\n\n    if (!Array.isArray(poll.answers)) {\n      throw new _InvalidEventError.InvalidEventError(\"Poll answers must be an array\");\n    }\n\n    var answers = poll.answers.slice(0, 20).map(function (a) {\n      return new PollAnswerSubevent({\n        type: \"org.matrix.sdk.poll.answer\",\n        content: a\n      });\n    });\n\n    if (answers.length <= 0) {\n      throw new _InvalidEventError.InvalidEventError(\"No answers available\");\n    }\n\n    _this2.answers = answers;\n    return _this2;\n  }\n\n  _createClass(PollStartEvent, [{\n    key: \"isEquivalentTo\",\n    value: function isEquivalentTo(primaryEventType) {\n      return (0, _events.isEventTypeSame)(primaryEventType, _poll_types.M_POLL_START);\n    }\n  }, {\n    key: \"serialize\",\n    value: function serialize() {\n      var _content2;\n\n      return {\n        type: _poll_types.M_POLL_START.name,\n        content: (_content2 = {}, _defineProperty(_content2, _poll_types.M_POLL_START.name, {\n          question: this.question.serialize().content,\n          kind: this.rawKind,\n          max_selections: this.maxSelections,\n          answers: this.answers.map(function (a) {\n            return a.serialize().content;\n          })\n        }), _defineProperty(_content2, _message_types.M_TEXT.name, \"\".concat(this.question.text, \"\\n\").concat(this.answers.map(function (a, i) {\n          return \"\".concat(i + 1, \". \").concat(a.text);\n        }).join(\"\\n\"))), _content2)\n      };\n    }\n    /**\n     * Creates a new PollStartEvent from question, answers, and metadata.\n     * @param {string} question The question to ask.\n     * @param {string} answers The answers. Should be unique within each other.\n     * @param {KNOWN_POLL_KIND|string} kind The kind of poll.\n     * @param {number} maxSelections The maximum number of selections. Must be 1 or higher.\n     * @returns {PollStartEvent} The representative poll start event.\n     */\n\n  }], [{\n    key: \"from\",\n    value: function from(question, answers, kind) {\n      var _content3;\n\n      var maxSelections = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 1;\n      return new PollStartEvent({\n        type: _poll_types.M_POLL_START.name,\n        content: (_content3 = {}, _defineProperty(_content3, _message_types.M_TEXT.name, question), _defineProperty(_content3, _poll_types.M_POLL_START.name, {\n          question: _defineProperty({}, _message_types.M_TEXT.name, question),\n          kind: kind instanceof _NamespacedValue.NamespacedValue ? kind.name : kind,\n          max_selections: maxSelections,\n          answers: answers.map(function (a) {\n            return _defineProperty({\n              id: makeId()\n            }, _message_types.M_TEXT.name, a);\n          })\n        }), _content3)\n      });\n    }\n  }]);\n\n  return PollStartEvent;\n}(_ExtensibleEvent2.ExtensibleEvent);\n\nexports.PollStartEvent = PollStartEvent;\nvar LETTERS = \"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789\";\n\nfunction makeId() {\n  return _toConsumableArray(Array(16)).map(function () {\n    return LETTERS.charAt(Math.floor(Math.random() * LETTERS.length));\n  }).join('');\n}","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.M_TEXT = exports.M_NOTICE = exports.M_MESSAGE = exports.M_HTML = exports.M_EMOTE = void 0;\n\nvar _NamespacedValue = require(\"../NamespacedValue\");\n\n/*\nCopyright 2022 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\n/**\n * The namespaced value for m.message\n */\nvar M_MESSAGE = new _NamespacedValue.UnstableValue(\"m.message\", \"org.matrix.msc1767.message\");\n/**\n * An m.message event rendering\n */\n\nexports.M_MESSAGE = M_MESSAGE;\n\n/**\n * The namespaced value for m.text\n */\nvar M_TEXT = new _NamespacedValue.UnstableValue(\"m.text\", \"org.matrix.msc1767.text\");\n/**\n * The content for an m.text event\n */\n\nexports.M_TEXT = M_TEXT;\n\n/**\n * The namespaced value for m.html\n */\nvar M_HTML = new _NamespacedValue.UnstableValue(\"m.html\", \"org.matrix.msc1767.html\");\n/**\n * The content for an m.html event\n */\n\nexports.M_HTML = M_HTML;\n\n/**\n * The namespaced value for m.emote\n */\nvar M_EMOTE = new _NamespacedValue.UnstableValue(\"m.emote\", \"org.matrix.msc1767.emote\");\n/**\n * The event definition for an m.emote event (in content)\n */\n\nexports.M_EMOTE = M_EMOTE;\n\n/**\n * The namespaced value for m.notice\n */\nvar M_NOTICE = new _NamespacedValue.UnstableValue(\"m.notice\", \"org.matrix.msc1767.notice\");\n/**\n * The event definition for an m.notice event (in content)\n */\n\nexports.M_NOTICE = M_NOTICE;","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.M_POLL_START = exports.M_POLL_RESPONSE = exports.M_POLL_KIND_UNDISCLOSED = exports.M_POLL_KIND_DISCLOSED = exports.M_POLL_END = void 0;\n\nvar _NamespacedValue = require(\"../NamespacedValue\");\n\n/*\nCopyright 2022 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\n/**\n * Identifier for a disclosed poll.\n */\nvar M_POLL_KIND_DISCLOSED = new _NamespacedValue.UnstableValue(\"m.poll.disclosed\", \"org.matrix.msc3381.poll.disclosed\");\n/**\n * Identifier for an undisclosed poll.\n */\n\nexports.M_POLL_KIND_DISCLOSED = M_POLL_KIND_DISCLOSED;\nvar M_POLL_KIND_UNDISCLOSED = new _NamespacedValue.UnstableValue(\"m.poll.undisclosed\", \"org.matrix.msc3381.poll.undisclosed\");\n/**\n * Any poll kind.\n */\n\nexports.M_POLL_KIND_UNDISCLOSED = M_POLL_KIND_UNDISCLOSED;\n\n/**\n * The namespaced value for m.poll.start\n */\nvar M_POLL_START = new _NamespacedValue.UnstableValue(\"m.poll.start\", \"org.matrix.msc3381.poll.start\");\n/**\n * The m.poll.start type within event content\n */\n\nexports.M_POLL_START = M_POLL_START;\n\n/**\n * The namespaced value for m.poll.response\n */\nvar M_POLL_RESPONSE = new _NamespacedValue.UnstableValue(\"m.poll.response\", \"org.matrix.msc3381.poll.response\");\n/**\n * The m.poll.response type within event content\n */\n\nexports.M_POLL_RESPONSE = M_POLL_RESPONSE;\n\n/**\n * The namespaced value for m.poll.end\n */\nvar M_POLL_END = new _NamespacedValue.UnstableValue(\"m.poll.end\", \"org.matrix.msc3381.poll.end\");\n/**\n * The event definition for an m.poll.end event (in content)\n */\n\nexports.M_POLL_END = M_POLL_END;","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.REFERENCE_RELATION = void 0;\n\nvar _NamespacedValue = require(\"../NamespacedValue\");\n\n/*\nCopyright 2022 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\n/**\n * The namespaced value for an m.reference relation\n */\nvar REFERENCE_RELATION = new _NamespacedValue.NamespacedValue(\"m.reference\");\n/**\n * Represents any relation type\n */\n\nexports.REFERENCE_RELATION = REFERENCE_RELATION;","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _ExtensibleEvents = require(\"./ExtensibleEvents\");\n\nObject.keys(_ExtensibleEvents).forEach(function (key) {\n  if (key === \"default\" || key === \"__esModule\") return;\n  if (key in exports && exports[key] === _ExtensibleEvents[key]) return;\n  Object.defineProperty(exports, key, {\n    enumerable: true,\n    get: function get() {\n      return _ExtensibleEvents[key];\n    }\n  });\n});\n\nvar _IPartialEvent = require(\"./IPartialEvent\");\n\nObject.keys(_IPartialEvent).forEach(function (key) {\n  if (key === \"default\" || key === \"__esModule\") return;\n  if (key in exports && exports[key] === _IPartialEvent[key]) return;\n  Object.defineProperty(exports, key, {\n    enumerable: true,\n    get: function get() {\n      return _IPartialEvent[key];\n    }\n  });\n});\n\nvar _InvalidEventError = require(\"./InvalidEventError\");\n\nObject.keys(_InvalidEventError).forEach(function (key) {\n  if (key === \"default\" || key === \"__esModule\") return;\n  if (key in exports && exports[key] === _InvalidEventError[key]) return;\n  Object.defineProperty(exports, key, {\n    enumerable: true,\n    get: function get() {\n      return _InvalidEventError[key];\n    }\n  });\n});\n\nvar _NamespacedValue = require(\"./NamespacedValue\");\n\nObject.keys(_NamespacedValue).forEach(function (key) {\n  if (key === \"default\" || key === \"__esModule\") return;\n  if (key in exports && exports[key] === _NamespacedValue[key]) return;\n  Object.defineProperty(exports, key, {\n    enumerable: true,\n    get: function get() {\n      return _NamespacedValue[key];\n    }\n  });\n});\n\nvar _NamespacedMap = require(\"./NamespacedMap\");\n\nObject.keys(_NamespacedMap).forEach(function (key) {\n  if (key === \"default\" || key === \"__esModule\") return;\n  if (key in exports && exports[key] === _NamespacedMap[key]) return;\n  Object.defineProperty(exports, key, {\n    enumerable: true,\n    get: function get() {\n      return _NamespacedMap[key];\n    }\n  });\n});\n\nvar _types = require(\"./types\");\n\nObject.keys(_types).forEach(function (key) {\n  if (key === \"default\" || key === \"__esModule\") return;\n  if (key in exports && exports[key] === _types[key]) return;\n  Object.defineProperty(exports, key, {\n    enumerable: true,\n    get: function get() {\n      return _types[key];\n    }\n  });\n});\n\nvar _MessageMatchers = require(\"./utility/MessageMatchers\");\n\nObject.keys(_MessageMatchers).forEach(function (key) {\n  if (key === \"default\" || key === \"__esModule\") return;\n  if (key in exports && exports[key] === _MessageMatchers[key]) return;\n  Object.defineProperty(exports, key, {\n    enumerable: true,\n    get: function get() {\n      return _MessageMatchers[key];\n    }\n  });\n});\n\nvar _events = require(\"./utility/events\");\n\nObject.keys(_events).forEach(function (key) {\n  if (key === \"default\" || key === \"__esModule\") return;\n  if (key in exports && exports[key] === _events[key]) return;\n  Object.defineProperty(exports, key, {\n    enumerable: true,\n    get: function get() {\n      return _events[key];\n    }\n  });\n});\n\nvar _MRoomMessage = require(\"./interpreters/legacy/MRoomMessage\");\n\nObject.keys(_MRoomMessage).forEach(function (key) {\n  if (key === \"default\" || key === \"__esModule\") return;\n  if (key in exports && exports[key] === _MRoomMessage[key]) return;\n  Object.defineProperty(exports, key, {\n    enumerable: true,\n    get: function get() {\n      return _MRoomMessage[key];\n    }\n  });\n});\n\nvar _MMessage = require(\"./interpreters/modern/MMessage\");\n\nObject.keys(_MMessage).forEach(function (key) {\n  if (key === \"default\" || key === \"__esModule\") return;\n  if (key in exports && exports[key] === _MMessage[key]) return;\n  Object.defineProperty(exports, key, {\n    enumerable: true,\n    get: function get() {\n      return _MMessage[key];\n    }\n  });\n});\n\nvar _MPoll = require(\"./interpreters/modern/MPoll\");\n\nObject.keys(_MPoll).forEach(function (key) {\n  if (key === \"default\" || key === \"__esModule\") return;\n  if (key in exports && exports[key] === _MPoll[key]) return;\n  Object.defineProperty(exports, key, {\n    enumerable: true,\n    get: function get() {\n      return _MPoll[key];\n    }\n  });\n});\n\nvar _relationship_types = require(\"./events/relationship_types\");\n\nObject.keys(_relationship_types).forEach(function (key) {\n  if (key === \"default\" || key === \"__esModule\") return;\n  if (key in exports && exports[key] === _relationship_types[key]) return;\n  Object.defineProperty(exports, key, {\n    enumerable: true,\n    get: function get() {\n      return _relationship_types[key];\n    }\n  });\n});\n\nvar _ExtensibleEvent = require(\"./events/ExtensibleEvent\");\n\nObject.keys(_ExtensibleEvent).forEach(function (key) {\n  if (key === \"default\" || key === \"__esModule\") return;\n  if (key in exports && exports[key] === _ExtensibleEvent[key]) return;\n  Object.defineProperty(exports, key, {\n    enumerable: true,\n    get: function get() {\n      return _ExtensibleEvent[key];\n    }\n  });\n});\n\nvar _message_types = require(\"./events/message_types\");\n\nObject.keys(_message_types).forEach(function (key) {\n  if (key === \"default\" || key === \"__esModule\") return;\n  if (key in exports && exports[key] === _message_types[key]) return;\n  Object.defineProperty(exports, key, {\n    enumerable: true,\n    get: function get() {\n      return _message_types[key];\n    }\n  });\n});\n\nvar _MessageEvent = require(\"./events/MessageEvent\");\n\nObject.keys(_MessageEvent).forEach(function (key) {\n  if (key === \"default\" || key === \"__esModule\") return;\n  if (key in exports && exports[key] === _MessageEvent[key]) return;\n  Object.defineProperty(exports, key, {\n    enumerable: true,\n    get: function get() {\n      return _MessageEvent[key];\n    }\n  });\n});\n\nvar _EmoteEvent = require(\"./events/EmoteEvent\");\n\nObject.keys(_EmoteEvent).forEach(function (key) {\n  if (key === \"default\" || key === \"__esModule\") return;\n  if (key in exports && exports[key] === _EmoteEvent[key]) return;\n  Object.defineProperty(exports, key, {\n    enumerable: true,\n    get: function get() {\n      return _EmoteEvent[key];\n    }\n  });\n});\n\nvar _NoticeEvent = require(\"./events/NoticeEvent\");\n\nObject.keys(_NoticeEvent).forEach(function (key) {\n  if (key === \"default\" || key === \"__esModule\") return;\n  if (key in exports && exports[key] === _NoticeEvent[key]) return;\n  Object.defineProperty(exports, key, {\n    enumerable: true,\n    get: function get() {\n      return _NoticeEvent[key];\n    }\n  });\n});\n\nvar _poll_types = require(\"./events/poll_types\");\n\nObject.keys(_poll_types).forEach(function (key) {\n  if (key === \"default\" || key === \"__esModule\") return;\n  if (key in exports && exports[key] === _poll_types[key]) return;\n  Object.defineProperty(exports, key, {\n    enumerable: true,\n    get: function get() {\n      return _poll_types[key];\n    }\n  });\n});\n\nvar _PollStartEvent = require(\"./events/PollStartEvent\");\n\nObject.keys(_PollStartEvent).forEach(function (key) {\n  if (key === \"default\" || key === \"__esModule\") return;\n  if (key in exports && exports[key] === _PollStartEvent[key]) return;\n  Object.defineProperty(exports, key, {\n    enumerable: true,\n    get: function get() {\n      return _PollStartEvent[key];\n    }\n  });\n});\n\nvar _PollResponseEvent = require(\"./events/PollResponseEvent\");\n\nObject.keys(_PollResponseEvent).forEach(function (key) {\n  if (key === \"default\" || key === \"__esModule\") return;\n  if (key in exports && exports[key] === _PollResponseEvent[key]) return;\n  Object.defineProperty(exports, key, {\n    enumerable: true,\n    get: function get() {\n      return _PollResponseEvent[key];\n    }\n  });\n});\n\nvar _PollEndEvent = require(\"./events/PollEndEvent\");\n\nObject.keys(_PollEndEvent).forEach(function (key) {\n  if (key === \"default\" || key === \"__esModule\") return;\n  if (key in exports && exports[key] === _PollEndEvent[key]) return;\n  Object.defineProperty(exports, key, {\n    enumerable: true,\n    get: function get() {\n      return _PollEndEvent[key];\n    }\n  });\n});","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.LEGACY_M_ROOM_MESSAGE = void 0;\nexports.parseMRoomMessage = parseMRoomMessage;\n\nvar _MessageEvent = require(\"../../events/MessageEvent\");\n\nvar _NoticeEvent = require(\"../../events/NoticeEvent\");\n\nvar _EmoteEvent = require(\"../../events/EmoteEvent\");\n\nvar _NamespacedValue = require(\"../../NamespacedValue\");\n\nvar _message_types = require(\"../../events/message_types\");\n\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nvar LEGACY_M_ROOM_MESSAGE = new _NamespacedValue.NamespacedValue(\"m.room.message\");\nexports.LEGACY_M_ROOM_MESSAGE = LEGACY_M_ROOM_MESSAGE;\n\nfunction parseMRoomMessage(wireEvent) {\n  var _wireEvent$content, _wireEvent$content2, _wireEvent$content3;\n\n  if (_message_types.M_MESSAGE.findIn(wireEvent.content) || _message_types.M_TEXT.findIn(wireEvent.content)) {\n    // We know enough about the event to coerce it into the right type\n    return new _MessageEvent.MessageEvent(wireEvent);\n  }\n\n  var msgtype = (_wireEvent$content = wireEvent.content) === null || _wireEvent$content === void 0 ? void 0 : _wireEvent$content.msgtype;\n  var text = (_wireEvent$content2 = wireEvent.content) === null || _wireEvent$content2 === void 0 ? void 0 : _wireEvent$content2.body;\n  var html = ((_wireEvent$content3 = wireEvent.content) === null || _wireEvent$content3 === void 0 ? void 0 : _wireEvent$content3.format) === \"org.matrix.custom.html\" ? wireEvent.content.formatted_body : null;\n\n  if (msgtype === \"m.text\") {\n    var _objectSpread2;\n\n    return new _MessageEvent.MessageEvent(_objectSpread(_objectSpread({}, wireEvent), {}, {\n      content: _objectSpread(_objectSpread({}, wireEvent.content), {}, (_objectSpread2 = {}, _defineProperty(_objectSpread2, _message_types.M_TEXT.name, text), _defineProperty(_objectSpread2, _message_types.M_HTML.name, html), _objectSpread2))\n    }));\n  } else if (msgtype === \"m.notice\") {\n    var _objectSpread3;\n\n    return new _NoticeEvent.NoticeEvent(_objectSpread(_objectSpread({}, wireEvent), {}, {\n      content: _objectSpread(_objectSpread({}, wireEvent.content), {}, (_objectSpread3 = {}, _defineProperty(_objectSpread3, _message_types.M_TEXT.name, text), _defineProperty(_objectSpread3, _message_types.M_HTML.name, html), _objectSpread3))\n    }));\n  } else if (msgtype === \"m.emote\") {\n    var _objectSpread4;\n\n    return new _EmoteEvent.EmoteEvent(_objectSpread(_objectSpread({}, wireEvent), {}, {\n      content: _objectSpread(_objectSpread({}, wireEvent.content), {}, (_objectSpread4 = {}, _defineProperty(_objectSpread4, _message_types.M_TEXT.name, text), _defineProperty(_objectSpread4, _message_types.M_HTML.name, html), _objectSpread4))\n    }));\n  } else {\n    // TODO: Handle other types\n    return null;\n  }\n}","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.parseMMessage = parseMMessage;\n\nvar _MessageEvent = require(\"../../events/MessageEvent\");\n\nvar _message_types = require(\"../../events/message_types\");\n\nvar _EmoteEvent = require(\"../../events/EmoteEvent\");\n\nvar _NoticeEvent = require(\"../../events/NoticeEvent\");\n\n/*\nCopyright 2022 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\nfunction parseMMessage(wireEvent) {\n  if (_message_types.M_EMOTE.matches(wireEvent.type)) {\n    return new _EmoteEvent.EmoteEvent(wireEvent);\n  } else if (_message_types.M_NOTICE.matches(wireEvent.type)) {\n    return new _NoticeEvent.NoticeEvent(wireEvent);\n  } // default: return a generic message\n\n\n  return new _MessageEvent.MessageEvent(wireEvent);\n}","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.parseMPoll = parseMPoll;\n\nvar _poll_types = require(\"../../events/poll_types\");\n\nvar _PollStartEvent = require(\"../../events/PollStartEvent\");\n\nvar _PollResponseEvent = require(\"../../events/PollResponseEvent\");\n\nvar _PollEndEvent = require(\"../../events/PollEndEvent\");\n\n/*\nCopyright 2022 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\nfunction parseMPoll(wireEvent) {\n  if (_poll_types.M_POLL_START.matches(wireEvent.type)) {\n    return new _PollStartEvent.PollStartEvent(wireEvent);\n  } else if (_poll_types.M_POLL_RESPONSE.matches(wireEvent.type)) {\n    return new _PollResponseEvent.PollResponseEvent(wireEvent);\n  } else if (_poll_types.M_POLL_END.matches(wireEvent.type)) {\n    return new _PollEndEvent.PollEndEvent(wireEvent);\n  }\n\n  return null; // not a poll event\n}","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.isOptionalAString = isOptionalAString;\nexports.isProvided = isProvided;\n\n/*\nCopyright 2021 - 2022 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\n/**\n * Represents an optional type: can either be T or a falsy value.\n */\n\n/**\n * Determines if the given optional string is a defined string.\n * @param {Optional<string>} s The input string.\n * @returns {boolean} True if the input is a defined string.\n */\nfunction isOptionalAString(s) {\n  return isProvided(s) && typeof s === 'string';\n}\n/**\n * Determines if the given optional was provided a value.\n * @param {Optional<T>} s The optional to test.\n * @returns {boolean} True if the value is defined.\n */\n\n\nfunction isProvided(s) {\n  return s !== null && s !== undefined;\n}\n/**\n * Represents either just T1, just T2, or T1 and T2 mixed.\n */","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.LegacyMsgType = void 0;\nexports.isEventLike = isEventLike;\n\nvar _message_types = require(\"../events/message_types\");\n\n/*\nCopyright 2022 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\n/**\n * Represents a legacy m.room.message msgtype\n */\nvar LegacyMsgType;\n/**\n * Determines if the given partial event looks similar enough to the given legacy msgtype\n * to count as that message type.\n * @param {IPartialEvent<EitherAnd<IPartialLegacyContent, M_MESSAGE_EVENT_CONTENT>>} event The event.\n * @param {LegacyMsgType} msgtype The message type to compare for.\n * @returns {boolean} True if the event appears to look similar enough to the msgtype.\n */\n\nexports.LegacyMsgType = LegacyMsgType;\n\n(function (LegacyMsgType) {\n  LegacyMsgType[\"Text\"] = \"m.text\";\n  LegacyMsgType[\"Notice\"] = \"m.notice\";\n  LegacyMsgType[\"Emote\"] = \"m.emote\";\n})(LegacyMsgType || (exports.LegacyMsgType = LegacyMsgType = {}));\n\nfunction isEventLike(event, msgtype) {\n  var content = event.content;\n\n  if (msgtype === LegacyMsgType.Text) {\n    return _message_types.M_MESSAGE.matches(event.type) || event.type === \"m.room.message\" && (content === null || content === void 0 ? void 0 : content['msgtype']) === \"m.text\";\n  } else if (msgtype === LegacyMsgType.Emote) {\n    return _message_types.M_EMOTE.matches(event.type) || event.type === \"m.room.message\" && (content === null || content === void 0 ? void 0 : content['msgtype']) === \"m.emote\";\n  } else if (msgtype === LegacyMsgType.Notice) {\n    return _message_types.M_NOTICE.matches(event.type) || event.type === \"m.room.message\" && (content === null || content === void 0 ? void 0 : content['msgtype']) === \"m.notice\";\n  }\n\n  return false;\n}","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.isEventTypeSame = isEventTypeSame;\n\n/*\nCopyright 2022 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\n/**\n * Represents a potentially namespaced event type.\n */\n\n/**\n * Determines if two event types are the same, including namespaces.\n * @param {EventType} given The given event type. This will be compared\n * against the expected type.\n * @param {EventType} expected The expected event type.\n * @returns {boolean} True if the given type matches the expected type.\n */\nfunction isEventTypeSame(given, expected) {\n  if (typeof given === \"string\") {\n    if (typeof expected === \"string\") {\n      return expected === given;\n    } else {\n      return expected.matches(given);\n    }\n  } else {\n    if (typeof expected === \"string\") {\n      return given.matches(expected);\n    } else {\n      var expectedNs = expected;\n      var givenNs = given;\n      return expectedNs.matches(givenNs.name) || expectedNs.matches(givenNs.altName);\n    }\n  }\n}","/*\nCopyright 2021 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\n// allow camelcase as these are things that go onto the wire\n/* eslint-disable camelcase */\n\nexport enum PushRuleActionName {\n    DontNotify = \"dont_notify\",\n    Notify = \"notify\",\n    Coalesce = \"coalesce\",\n}\n\nexport enum TweakName {\n    Highlight = \"highlight\",\n    Sound = \"sound\",\n}\n\nexport type Tweak<N extends TweakName, V> = {\n    set_tweak: N;\n    value?: V;\n};\n\nexport type TweakHighlight = Tweak<TweakName.Highlight, boolean>;\nexport type TweakSound = Tweak<TweakName.Sound, string>;\n\nexport type Tweaks = TweakHighlight | TweakSound;\n\nexport enum ConditionOperator {\n    ExactEquals = \"==\",\n    LessThan = \"<\",\n    GreaterThan = \">\",\n    GreaterThanOrEqual = \">=\",\n    LessThanOrEqual = \"<=\",\n}\n\nexport type PushRuleAction = Tweaks | PushRuleActionName;\n\nexport type MemberCountCondition<N extends number, Op extends ConditionOperator = ConditionOperator.ExactEquals> =\n    | `${Op}${N}`\n    | (Op extends ConditionOperator.ExactEquals ? `${N}` : never);\n\nexport type AnyMemberCountCondition = MemberCountCondition<number, ConditionOperator>;\n\nexport const DMMemberCountCondition: MemberCountCondition<2> = \"2\";\n\nexport function isDmMemberCountCondition(condition: AnyMemberCountCondition): boolean {\n    return condition === \"==2\" || condition === \"2\";\n}\n\nexport enum ConditionKind {\n    EventMatch = \"event_match\",\n    EventPropertyIs = \"event_property_is\",\n    EventPropertyContains = \"event_property_contains\",\n    ContainsDisplayName = \"contains_display_name\",\n    RoomMemberCount = \"room_member_count\",\n    SenderNotificationPermission = \"sender_notification_permission\",\n    CallStarted = \"call_started\",\n    CallStartedPrefix = \"org.matrix.msc3914.call_started\",\n}\n\nexport interface IPushRuleCondition<N extends ConditionKind | string> {\n    [k: string]: any; // for custom conditions, there can be other fields here\n    kind: N;\n}\n\nexport interface IEventMatchCondition extends IPushRuleCondition<ConditionKind.EventMatch> {\n    key: string;\n    pattern?: string;\n    // Note that value property is an optimization for patterns which do not do\n    // any globbing and when the key is not \"content.body\".\n    value?: string;\n}\n\nexport interface IEventPropertyIsCondition extends IPushRuleCondition<ConditionKind.EventPropertyIs> {\n    key: string;\n    value: string | boolean | null | number;\n}\n\nexport interface IEventPropertyContainsCondition extends IPushRuleCondition<ConditionKind.EventPropertyContains> {\n    key: string;\n    value: string | boolean | null | number;\n}\n\nexport interface IContainsDisplayNameCondition extends IPushRuleCondition<ConditionKind.ContainsDisplayName> {\n    // no additional fields\n}\n\nexport interface IRoomMemberCountCondition extends IPushRuleCondition<ConditionKind.RoomMemberCount> {\n    is: AnyMemberCountCondition;\n}\n\nexport interface ISenderNotificationPermissionCondition\n    extends IPushRuleCondition<ConditionKind.SenderNotificationPermission> {\n    key: string;\n}\n\nexport interface ICallStartedCondition extends IPushRuleCondition<ConditionKind.CallStarted> {\n    // no additional fields\n}\n\nexport interface ICallStartedPrefixCondition extends IPushRuleCondition<ConditionKind.CallStartedPrefix> {\n    // no additional fields\n}\n\n// XXX: custom conditions are possible but always fail, and break the typescript discriminated union so ignore them here\n// IPushRuleCondition<Exclude<string, ConditionKind>> unfortunately does not resolve this at the time of writing.\nexport type PushRuleCondition =\n    | IEventMatchCondition\n    | IEventPropertyIsCondition\n    | IEventPropertyContainsCondition\n    | IContainsDisplayNameCondition\n    | IRoomMemberCountCondition\n    | ISenderNotificationPermissionCondition\n    | ICallStartedCondition\n    | ICallStartedPrefixCondition;\n\nexport enum PushRuleKind {\n    Override = \"override\",\n    ContentSpecific = \"content\",\n    RoomSpecific = \"room\",\n    SenderSpecific = \"sender\",\n    Underride = \"underride\",\n}\n\nexport enum RuleId {\n    Master = \".m.rule.master\",\n    IsUserMention = \".m.rule.is_user_mention\",\n    IsRoomMention = \".m.rule.is_room_mention\",\n    ContainsDisplayName = \".m.rule.contains_display_name\",\n    ContainsUserName = \".m.rule.contains_user_name\",\n    AtRoomNotification = \".m.rule.roomnotif\",\n    DM = \".m.rule.room_one_to_one\",\n    EncryptedDM = \".m.rule.encrypted_room_one_to_one\",\n    Message = \".m.rule.message\",\n    EncryptedMessage = \".m.rule.encrypted\",\n    InviteToSelf = \".m.rule.invite_for_me\",\n    MemberEvent = \".m.rule.member_event\",\n    IncomingCall = \".m.rule.call\",\n    SuppressNotices = \".m.rule.suppress_notices\",\n    Tombstone = \".m.rule.tombstone\",\n    PollStart = \".m.rule.poll_start\",\n    PollStartUnstable = \".org.matrix.msc3930.rule.poll_start\",\n    PollEnd = \".m.rule.poll_end\",\n    PollEndUnstable = \".org.matrix.msc3930.rule.poll_end\",\n    PollStartOneToOne = \".m.rule.poll_start_one_to_one\",\n    PollStartOneToOneUnstable = \".org.matrix.msc3930.rule.poll_start_one_to_one\",\n    PollEndOneToOne = \".m.rule.poll_end_one_to_one\",\n    PollEndOneToOneUnstable = \".org.matrix.msc3930.rule.poll_end_one_to_one\",\n}\n\nexport type PushRuleSet = {\n    [k in PushRuleKind]?: IPushRule[];\n};\n\nexport interface IPushRule {\n    actions: PushRuleAction[];\n    conditions?: PushRuleCondition[];\n    default: boolean;\n    enabled: boolean;\n    pattern?: string;\n    rule_id: RuleId | string;\n}\n\nexport interface IAnnotatedPushRule extends IPushRule {\n    kind: PushRuleKind;\n}\n\nexport interface IPushRules {\n    global: PushRuleSet;\n    device?: PushRuleSet;\n}\n\nexport interface IPusher {\n    \"app_display_name\": string;\n    \"app_id\": string;\n    \"data\": {\n        format?: string;\n        url?: string; // TODO: Required if kind==http\n        brand?: string; // TODO: For email notifications only? Unspecced field\n    };\n    \"device_display_name\": string;\n    \"kind\": \"http\" | string;\n    \"lang\": string;\n    \"profile_tag\"?: string;\n    \"pushkey\": string;\n    \"enabled\"?: boolean | null;\n    \"org.matrix.msc3881.enabled\"?: boolean | null;\n    \"device_id\"?: string | null;\n    \"org.matrix.msc3881.device_id\"?: string | null;\n}\n\nexport interface IPusherRequest extends Omit<IPusher, \"device_id\" | \"org.matrix.msc3881.device_id\"> {\n    append?: boolean;\n}\n\n/* eslint-enable camelcase */\n","/*\nCopyright 2022 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { type RelatesToRelationship, type REFERENCE_RELATION } from \"./extensible_events.ts\";\nimport { UnstableValue } from \"../NamespacedValue.ts\";\nimport { type MAssetEvent, type MLocationEvent, type MTimestampEvent } from \"./location.ts\";\n\n/**\n * Beacon info and beacon event types as described in MSC3672\n * https://github.com/matrix-org/matrix-spec-proposals/pull/3672\n */\n\n/**\n * Beacon info events are state events.\n * We have two requirements for these events:\n * 1. they can only be written by their owner\n * 2. a user can have an arbitrary number of beacon_info events\n *\n * 1. is achieved by setting the state_key to the owners mxid.\n * Event keys in room state are a combination of `type` + `state_key`.\n * To achieve an arbitrary number of only owner-writable state events\n * we introduce a variable suffix to the event type\n *\n * @example\n * ```\n * {\n *      \"type\": \"m.beacon_info.@matthew:matrix.org.1\",\n *      \"state_key\": \"@matthew:matrix.org\",\n *      \"content\": {\n *          \"m.beacon_info\": {\n *              \"description\": \"The Matthew Tracker\",\n *              \"timeout\": 86400000,\n *          },\n *          // more content as described below\n *      }\n * },\n * {\n *      \"type\": \"m.beacon_info.@matthew:matrix.org.2\",\n *      \"state_key\": \"@matthew:matrix.org\",\n *      \"content\": {\n *          \"m.beacon_info\": {\n *              \"description\": \"Another different Matthew tracker\",\n *              \"timeout\": 400000,\n *          },\n *          // more content as described below\n *      }\n * }\n * ```\n */\n\n/**\n * Non-variable type for m.beacon_info event content\n */\nexport const M_BEACON_INFO = new UnstableValue(\"m.beacon_info\", \"org.matrix.msc3672.beacon_info\");\nexport const M_BEACON = new UnstableValue(\"m.beacon\", \"org.matrix.msc3672.beacon\");\n\nexport type MBeaconInfoContent = {\n    description?: string;\n    // how long from the last event until we consider the beacon inactive in milliseconds\n    timeout: number;\n    // true when this is a live location beacon\n    // https://github.com/matrix-org/matrix-spec-proposals/pull/3672\n    live?: boolean;\n};\n\n/**\n * m.beacon_info Event example from the spec\n * https://github.com/matrix-org/matrix-spec-proposals/pull/3672\n * @example\n * ```\n * {\n *   \"type\": \"m.beacon_info\",\n *   \"state_key\": \"@matthew:matrix.org\",\n *   \"content\": {\n *     \"m.beacon_info\": {\n *       \"description\": \"The Matthew Tracker\", // same as an `m.location` description\n *       \"timeout\": 86400000, // how long from the last event until we consider the beacon inactive in milliseconds\n *     },\n *     \"m.ts\": 1436829458432, // creation timestamp of the beacon on the client\n *     \"m.asset\": {\n *       \"type\": \"m.self\" // the type of asset being tracked as per MSC3488\n *     }\n *   }\n * }\n * ```\n */\n\n/**\n * m.beacon_info.* event content\n */\nexport type MBeaconInfoEventContent = MBeaconInfoContent &\n    // creation timestamp of the beacon on the client\n    MTimestampEvent &\n    // the type of asset being tracked as per MSC3488\n    MAssetEvent;\n\n/**\n * m.beacon event example\n * https://github.com/matrix-org/matrix-spec-proposals/pull/3672\n * @example\n * ```\n * {\n *   \"type\": \"m.beacon\",\n *   \"sender\": \"@matthew:matrix.org\",\n *   \"content\": {\n *       \"m.relates_to\": { // from MSC2674: https://github.com/matrix-org/matrix-doc/pull/2674\n *           \"rel_type\": \"m.reference\", // from MSC3267: https://github.com/matrix-org/matrix-doc/pull/3267\n *           \"event_id\": \"$beacon_info\"\n *       },\n *       \"m.location\": {\n *           \"uri\": \"geo:51.5008,0.1247;u=35\",\n *           \"description\": \"Arbitrary beacon information\"\n *       },\n *       \"m.ts\": 1636829458432,\n *   }\n * }\n * ```\n */\n\n/**\n * Content of an m.beacon event\n */\nexport type MBeaconEventContent = MLocationEvent &\n    // timestamp when location was taken\n    MTimestampEvent &\n    // relates to a beacon_info event\n    RelatesToRelationship<typeof REFERENCE_RELATION>;\n","/*\nCopyright 2020 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { NamespacedValue, UnstableValue } from \"../NamespacedValue.ts\";\nimport {\n    type PolicyRuleEventContent,\n    type RoomAvatarEventContent,\n    type RoomCanonicalAliasEventContent,\n    type RoomCreateEventContent,\n    type RoomEncryptionEventContent,\n    type RoomGuestAccessEventContent,\n    type RoomHistoryVisibilityEventContent,\n    type RoomJoinRulesEventContent,\n    type RoomMemberEventContent,\n    type RoomNameEventContent,\n    type RoomPinnedEventsEventContent,\n    type RoomPowerLevelsEventContent,\n    type RoomServerAclEventContent,\n    type RoomThirdPartyInviteEventContent,\n    type RoomTombstoneEventContent,\n    type RoomTopicEventContent,\n    type SpaceChildEventContent,\n    type SpaceParentEventContent,\n} from \"./state_events.ts\";\nimport { type IGroupCallRoomMemberState, type IGroupCallRoomState } from \"../webrtc/groupCall.ts\";\nimport { type MSC3089EventContent } from \"../models/MSC3089Branch.ts\";\nimport { type M_BEACON, type M_BEACON_INFO, type MBeaconEventContent, type MBeaconInfoEventContent } from \"./beacon.ts\";\nimport { type EmptyObject } from \"./common.ts\";\nimport { type ReactionEventContent, type RoomMessageEventContent, type StickerEventContent } from \"./events.ts\";\nimport {\n    type MCallAnswer,\n    type MCallBase,\n    type MCallCandidates,\n    type MCallHangupReject,\n    type MCallInviteNegotiate,\n    type MCallReplacesEvent,\n    type MCallSelectAnswer,\n    type SDPStreamMetadata,\n    type SDPStreamMetadataKey,\n} from \"../webrtc/callEventTypes.ts\";\nimport { type EncryptionKeysEventContent, type ICallNotifyContent } from \"../matrixrtc/types.ts\";\nimport { type M_POLL_END, type M_POLL_START, type PollEndEventContent, type PollStartEventContent } from \"./polls.ts\";\nimport { type SessionMembershipData } from \"../matrixrtc/CallMembership.ts\";\nimport { type LocalNotificationSettings } from \"./local_notifications.ts\";\nimport { type IPushRules } from \"./PushRules.ts\";\nimport { type SecretInfo, type SecretStorageKeyDescription } from \"../secret-storage.ts\";\nimport { type POLICIES_ACCOUNT_EVENT_TYPE } from \"../models/invites-ignorer-types.ts\";\n\nexport enum EventType {\n    // Room state events\n    RoomCanonicalAlias = \"m.room.canonical_alias\",\n    RoomCreate = \"m.room.create\",\n    RoomJoinRules = \"m.room.join_rules\",\n    RoomMember = \"m.room.member\",\n    RoomThirdPartyInvite = \"m.room.third_party_invite\",\n    RoomPowerLevels = \"m.room.power_levels\",\n    RoomName = \"m.room.name\",\n    RoomTopic = \"m.room.topic\",\n    RoomAvatar = \"m.room.avatar\",\n    RoomPinnedEvents = \"m.room.pinned_events\",\n    RoomEncryption = \"m.room.encryption\",\n    RoomHistoryVisibility = \"m.room.history_visibility\",\n    RoomGuestAccess = \"m.room.guest_access\",\n    RoomServerAcl = \"m.room.server_acl\",\n    RoomTombstone = \"m.room.tombstone\",\n    RoomPredecessor = \"org.matrix.msc3946.room_predecessor\",\n\n    // Moderation policy lists\n    PolicyRuleUser = \"m.policy.rule.user\",\n    PolicyRuleRoom = \"m.policy.rule.room\",\n    PolicyRuleServer = \"m.policy.rule.server\",\n\n    SpaceChild = \"m.space.child\",\n    SpaceParent = \"m.space.parent\",\n\n    // Room timeline events\n    RoomRedaction = \"m.room.redaction\",\n    RoomMessage = \"m.room.message\",\n    RoomMessageEncrypted = \"m.room.encrypted\",\n    Sticker = \"m.sticker\",\n    CallInvite = \"m.call.invite\",\n    CallCandidates = \"m.call.candidates\",\n    CallAnswer = \"m.call.answer\",\n    CallHangup = \"m.call.hangup\",\n    CallReject = \"m.call.reject\",\n    CallSelectAnswer = \"m.call.select_answer\",\n    CallNegotiate = \"m.call.negotiate\",\n    CallSDPStreamMetadataChanged = \"m.call.sdp_stream_metadata_changed\",\n    CallSDPStreamMetadataChangedPrefix = \"org.matrix.call.sdp_stream_metadata_changed\",\n    CallReplaces = \"m.call.replaces\",\n    CallAssertedIdentity = \"m.call.asserted_identity\",\n    CallAssertedIdentityPrefix = \"org.matrix.call.asserted_identity\",\n    CallEncryptionKeysPrefix = \"io.element.call.encryption_keys\",\n    KeyVerificationRequest = \"m.key.verification.request\",\n    KeyVerificationStart = \"m.key.verification.start\",\n    KeyVerificationCancel = \"m.key.verification.cancel\",\n    KeyVerificationMac = \"m.key.verification.mac\",\n    KeyVerificationDone = \"m.key.verification.done\",\n    KeyVerificationKey = \"m.key.verification.key\",\n    KeyVerificationAccept = \"m.key.verification.accept\",\n    // Not used directly - see READY_TYPE in VerificationRequest.\n    KeyVerificationReady = \"m.key.verification.ready\",\n    // use of this is discouraged https://matrix.org/docs/spec/client_server/r0.6.1#m-room-message-feedback\n    RoomMessageFeedback = \"m.room.message.feedback\",\n    Reaction = \"m.reaction\",\n    PollStart = \"org.matrix.msc3381.poll.start\",\n\n    // Room ephemeral events\n    Typing = \"m.typing\",\n    Receipt = \"m.receipt\",\n    Presence = \"m.presence\",\n\n    // Room account_data events\n    FullyRead = \"m.fully_read\",\n    Tag = \"m.tag\",\n    SpaceOrder = \"org.matrix.msc3230.space_order\", // MSC3230\n\n    // User account_data events\n    PushRules = \"m.push_rules\",\n    Direct = \"m.direct\",\n    IgnoredUserList = \"m.ignored_user_list\",\n\n    // to_device events\n    RoomKey = \"m.room_key\",\n    RoomKeyRequest = \"m.room_key_request\",\n    ForwardedRoomKey = \"m.forwarded_room_key\",\n    Dummy = \"m.dummy\",\n    SecretRequest = \"m.secret.request\",\n    SecretSend = \"m.secret.send\",\n\n    // Group call events\n    GroupCallPrefix = \"org.matrix.msc3401.call\",\n    GroupCallMemberPrefix = \"org.matrix.msc3401.call.member\",\n\n    // MatrixRTC events\n    CallNotify = \"org.matrix.msc4075.call.notify\",\n}\n\nexport enum RelationType {\n    Annotation = \"m.annotation\",\n    Replace = \"m.replace\",\n    Reference = \"m.reference\",\n\n    // Don't use this yet: it's only the stable version. The code still assumes we support the unstable prefix and,\n    // moreover, our tests currently use the unstable prefix. Use THREAD_RELATION_TYPE.name.\n    // Once we support *only* the stable prefix, THREAD_RELATION_TYPE can die and we can switch to this.\n    Thread = \"m.thread\",\n}\n\nexport enum MsgType {\n    Text = \"m.text\",\n    Emote = \"m.emote\",\n    Notice = \"m.notice\",\n    Image = \"m.image\",\n    File = \"m.file\",\n    Audio = \"m.audio\",\n    Location = \"m.location\",\n    Video = \"m.video\",\n    KeyVerificationRequest = \"m.key.verification.request\",\n}\n\nexport const RoomCreateTypeField = \"type\";\n\nexport enum RoomType {\n    Space = \"m.space\",\n    UnstableCall = \"org.matrix.msc3417.call\",\n    ElementVideo = \"io.element.video\",\n}\n\nexport const ToDeviceMessageId = \"org.matrix.msgid\";\n\n/**\n * Identifier for an [MSC3088](https://github.com/matrix-org/matrix-doc/pull/3088)\n * room purpose. Note that this reference is UNSTABLE and subject to breaking changes,\n * including its eventual removal.\n */\nexport const UNSTABLE_MSC3088_PURPOSE = new UnstableValue(\"m.room.purpose\", \"org.matrix.msc3088.purpose\");\n\n/**\n * Enabled flag for an [MSC3088](https://github.com/matrix-org/matrix-doc/pull/3088)\n * room purpose. Note that this reference is UNSTABLE and subject to breaking changes,\n * including its eventual removal.\n */\nexport const UNSTABLE_MSC3088_ENABLED = new UnstableValue(\"m.enabled\", \"org.matrix.msc3088.enabled\");\n\n/**\n * Subtype for an [MSC3089](https://github.com/matrix-org/matrix-doc/pull/3089) space-room.\n * Note that this reference is UNSTABLE and subject to breaking changes, including its\n * eventual removal.\n */\nexport const UNSTABLE_MSC3089_TREE_SUBTYPE = new UnstableValue(\"m.data_tree\", \"org.matrix.msc3089.data_tree\");\n\n/**\n * Leaf type for an event in a [MSC3089](https://github.com/matrix-org/matrix-doc/pull/3089) space-room.\n * Note that this reference is UNSTABLE and subject to breaking changes, including its\n * eventual removal.\n */\nexport const UNSTABLE_MSC3089_LEAF = new UnstableValue(\"m.leaf\", \"org.matrix.msc3089.leaf\");\n\n/**\n * Branch (Leaf Reference) type for the index approach in a\n * [MSC3089](https://github.com/matrix-org/matrix-doc/pull/3089) space-room. Note that this reference is\n * UNSTABLE and subject to breaking changes, including its eventual removal.\n */\nexport const UNSTABLE_MSC3089_BRANCH = new UnstableValue(\"m.branch\", \"org.matrix.msc3089.branch\");\n\n/**\n * Marker event type to point back at imported historical content in a room. See\n * [MSC2716](https://github.com/matrix-org/matrix-spec-proposals/pull/2716).\n * Note that this reference is UNSTABLE and subject to breaking changes,\n * including its eventual removal.\n */\nexport const UNSTABLE_MSC2716_MARKER = new UnstableValue(\"m.room.marker\", \"org.matrix.msc2716.marker\");\n\n/**\n * Name of the request property for relation based redactions.\n * {@link https://github.com/matrix-org/matrix-spec-proposals/pull/3912}\n */\nexport const MSC3912_RELATION_BASED_REDACTIONS_PROP = new UnstableValue(\n    \"with_rel_types\",\n    \"org.matrix.msc3912.with_relations\",\n);\n\n/**\n * Functional members type for declaring a purpose of room members (e.g. helpful bots).\n * Note that this reference is UNSTABLE and subject to breaking changes, including its\n * eventual removal.\n *\n * Schema (TypeScript):\n * ```\n * {\n *   service_members?: string[]\n * }\n * ```\n *\n * @example\n * ```\n * {\n *   \"service_members\": [\n *     \"@helperbot:localhost\",\n *     \"@reminderbot:alice.tdl\"\n *   ]\n * }\n * ```\n */\nexport const UNSTABLE_ELEMENT_FUNCTIONAL_USERS = new UnstableValue(\n    \"io.element.functional_members\",\n    \"io.element.functional_members\",\n);\n\n/**\n * A type of message that affects visibility of a message,\n * as per https://github.com/matrix-org/matrix-doc/pull/3531\n *\n * @experimental\n */\nexport const EVENT_VISIBILITY_CHANGE_TYPE = new UnstableValue(\"m.visibility\", \"org.matrix.msc3531.visibility\");\n\n/**\n * https://github.com/matrix-org/matrix-doc/pull/3881\n *\n * @experimental\n */\nexport const PUSHER_ENABLED = new UnstableValue(\"enabled\", \"org.matrix.msc3881.enabled\");\n\n/**\n * https://github.com/matrix-org/matrix-doc/pull/3881\n *\n * @experimental\n */\nexport const PUSHER_DEVICE_ID = new UnstableValue(\"device_id\", \"org.matrix.msc3881.device_id\");\n\n/**\n * https://github.com/matrix-org/matrix-doc/pull/3890\n *\n * @experimental\n */\nexport const LOCAL_NOTIFICATION_SETTINGS_PREFIX = new UnstableValue(\n    \"m.local_notification_settings\",\n    \"org.matrix.msc3890.local_notification_settings\",\n);\n\n/**\n * https://github.com/matrix-org/matrix-doc/pull/4023\n *\n * @experimental\n */\nexport const UNSIGNED_THREAD_ID_FIELD = new UnstableValue(\"thread_id\", \"org.matrix.msc4023.thread_id\");\n\n/**\n * https://github.com/matrix-org/matrix-spec-proposals/pull/4115\n *\n * @experimental\n */\nexport const UNSIGNED_MEMBERSHIP_FIELD = new NamespacedValue(\"membership\", \"io.element.msc4115.membership\");\n\n/**\n * Mapped type from event type to content type for all specified non-state room events.\n */\nexport interface TimelineEvents {\n    [EventType.RoomMessage]: RoomMessageEventContent;\n    [EventType.Sticker]: StickerEventContent;\n    [EventType.Reaction]: ReactionEventContent;\n    [EventType.CallReplaces]: MCallReplacesEvent;\n    [EventType.CallAnswer]: MCallAnswer;\n    [EventType.CallSelectAnswer]: MCallSelectAnswer;\n    [EventType.CallNegotiate]: Omit<MCallInviteNegotiate, \"offer\">;\n    [EventType.CallInvite]: MCallInviteNegotiate;\n    [EventType.CallCandidates]: MCallCandidates;\n    [EventType.CallHangup]: MCallHangupReject;\n    [EventType.CallReject]: MCallHangupReject;\n    [EventType.CallSDPStreamMetadataChangedPrefix]: MCallBase & { [SDPStreamMetadataKey]: SDPStreamMetadata };\n    [EventType.CallEncryptionKeysPrefix]: EncryptionKeysEventContent;\n    [EventType.CallNotify]: ICallNotifyContent;\n    [M_BEACON.name]: MBeaconEventContent;\n    [M_POLL_START.name]: PollStartEventContent;\n    [M_POLL_END.name]: PollEndEventContent;\n}\n\n/**\n * Mapped type from event type to content type for all specified room state events.\n */\nexport interface StateEvents {\n    [EventType.RoomCanonicalAlias]: RoomCanonicalAliasEventContent;\n    [EventType.RoomCreate]: RoomCreateEventContent;\n    [EventType.RoomJoinRules]: RoomJoinRulesEventContent;\n    [EventType.RoomMember]: RoomMemberEventContent;\n    // XXX: Spec says this event has 3 required fields but kicking such an invitation requires sending `{}`\n    [EventType.RoomThirdPartyInvite]: RoomThirdPartyInviteEventContent | EmptyObject;\n    [EventType.RoomPowerLevels]: RoomPowerLevelsEventContent;\n    [EventType.RoomName]: RoomNameEventContent;\n    [EventType.RoomTopic]: RoomTopicEventContent;\n    [EventType.RoomAvatar]: RoomAvatarEventContent;\n    [EventType.RoomPinnedEvents]: RoomPinnedEventsEventContent;\n    [EventType.RoomEncryption]: RoomEncryptionEventContent;\n    [EventType.RoomHistoryVisibility]: RoomHistoryVisibilityEventContent;\n    [EventType.RoomGuestAccess]: RoomGuestAccessEventContent;\n    [EventType.RoomServerAcl]: RoomServerAclEventContent;\n    [EventType.RoomTombstone]: RoomTombstoneEventContent;\n    [EventType.SpaceChild]: SpaceChildEventContent;\n    [EventType.SpaceParent]: SpaceParentEventContent;\n\n    [EventType.PolicyRuleUser]: PolicyRuleEventContent | EmptyObject;\n    [EventType.PolicyRuleRoom]: PolicyRuleEventContent | EmptyObject;\n    [EventType.PolicyRuleServer]: PolicyRuleEventContent | EmptyObject;\n\n    // MSC3401\n    [EventType.GroupCallPrefix]: IGroupCallRoomState;\n    [EventType.GroupCallMemberPrefix]: IGroupCallRoomMemberState | SessionMembershipData | EmptyObject;\n\n    // MSC3089\n    [UNSTABLE_MSC3089_BRANCH.name]: MSC3089EventContent;\n\n    // MSC3672\n    [M_BEACON_INFO.name]: MBeaconInfoEventContent;\n}\n\n/**\n * Mapped type from event type to content type for all specified global account_data events.\n */\nexport interface AccountDataEvents extends SecretStorageAccountDataEvents {\n    [EventType.PushRules]: IPushRules;\n    [EventType.Direct]: { [userId: string]: string[] };\n    [EventType.IgnoredUserList]: { ignored_users: { [userId: string]: EmptyObject } };\n    \"m.secret_storage.default_key\": { key: string };\n    // Flag set by the rust SDK (Element X) and also used by us to mark that the user opted out of backup\n    // (I don't know why it's m.org.matrix...)\n    \"m.org.matrix.custom.backup_disabled\": { disabled: boolean };\n    \"m.identity_server\": { base_url: string | null };\n    [key: `${typeof LOCAL_NOTIFICATION_SETTINGS_PREFIX.name}.${string}`]: LocalNotificationSettings;\n    [key: `m.secret_storage.key.${string}`]: SecretStorageKeyDescription;\n\n    // Invites-ignorer events\n    [POLICIES_ACCOUNT_EVENT_TYPE.name]: { [key: string]: any };\n    [POLICIES_ACCOUNT_EVENT_TYPE.altName]: { [key: string]: any };\n}\n\n/**\n * Mapped type from event type to content type for all specified global events encrypted by secret storage.\n *\n * See https://spec.matrix.org/v1.13/client-server-api/#msecret_storagev1aes-hmac-sha2-1\n */\nexport interface SecretStorageAccountDataEvents {\n    \"m.megolm_backup.v1\": SecretInfo;\n    \"m.cross_signing.master\": SecretInfo;\n    \"m.cross_signing.self_signing\": SecretInfo;\n    \"m.cross_signing.user_signing\": SecretInfo;\n    \"org.matrix.msc3814\": SecretInfo;\n}\n","/*\nCopyright 2021 - 2023 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { type EitherAnd, NamespacedValue, type Optional, UnstableValue } from \"matrix-events-sdk\";\n\nimport { isProvided } from \"../extensible_events_v1/utilities.ts\";\n\n// Types and utilities for MSC1767: Extensible events (version 1) in Matrix\n\n/**\n * Represents the stable and unstable values of a given namespace.\n */\nexport type TSNamespace<N> =\n    N extends NamespacedValue<infer S, infer U> ? TSNamespaceValue<S> | TSNamespaceValue<U> : never;\n\n/**\n * Represents a namespaced value, if the value is a string. Used to extract provided types\n * from a TSNamespace<N> (in cases where only stable *or* unstable is provided).\n */\nexport type TSNamespaceValue<V> = V extends string ? V : never;\n\n/**\n * Creates a type which is V when T is `never`, otherwise T.\n */\n// See https://github.com/microsoft/TypeScript/issues/23182#issuecomment-379091887 for details on the array syntax.\nexport type DefaultNever<T, V> = [T] extends [never] ? V : T;\n\n/**\n * The namespaced value for m.message\n */\nexport const M_MESSAGE = new UnstableValue(\"m.message\", \"org.matrix.msc1767.message\");\n\n/**\n * An m.message event rendering\n */\nexport interface IMessageRendering {\n    body: string;\n    mimetype?: string;\n}\n\n/**\n * The content for an m.message event\n */\nexport type ExtensibleMessageEventContent = EitherAnd<\n    { [M_MESSAGE.name]: IMessageRendering[] },\n    { [M_MESSAGE.altName]: IMessageRendering[] }\n>;\n\n/**\n * The namespaced value for m.text\n */\nexport const M_TEXT = new UnstableValue(\"m.text\", \"org.matrix.msc1767.text\");\n\n/**\n * The content for an m.text event\n */\nexport type TextEventContent = EitherAnd<{ [M_TEXT.name]: string }, { [M_TEXT.altName]: string }>;\n\n/**\n * The namespaced value for m.html\n */\nexport const M_HTML = new UnstableValue(\"m.html\", \"org.matrix.msc1767.html\");\n\n/**\n * The content for an m.html event\n */\nexport type HtmlEventContent = EitherAnd<{ [M_HTML.name]: string }, { [M_HTML.altName]: string }>;\n\n/**\n * The content for an m.message, m.text, or m.html event\n */\nexport type ExtensibleAnyMessageEventContent = ExtensibleMessageEventContent | TextEventContent | HtmlEventContent;\n\n/**\n * The namespaced value for an m.reference relation\n */\nexport const REFERENCE_RELATION = new NamespacedValue(\"m.reference\");\n\n/**\n * Represents any relation type\n */\nexport type AnyRelation = TSNamespace<typeof REFERENCE_RELATION> | string;\n\n/**\n * An m.relates_to relationship\n */\nexport type RelatesToRelationship<R = never> = {\n    \"m.relates_to\": {\n        // See https://github.com/microsoft/TypeScript/issues/23182#issuecomment-379091887 for array syntax\n        rel_type: [R] extends [never] ? AnyRelation : TSNamespace<R>;\n        event_id: string;\n    };\n};\n\n/**\n * Partial types for a Matrix Event.\n */\nexport interface IPartialEvent<TContent> {\n    type: string;\n    content: TContent;\n}\n\n/**\n * Represents a potentially namespaced event type.\n */\nexport type ExtensibleEventType = NamespacedValue<string, string> | string;\n\n/**\n * Determines if two event types are the same, including namespaces.\n * @param given - The given event type. This will be compared\n * against the expected type.\n * @param expected - The expected event type.\n * @returns True if the given type matches the expected type.\n */\nexport function isEventTypeSame(\n    given: Optional<ExtensibleEventType>,\n    expected: Optional<ExtensibleEventType>,\n): boolean {\n    if (typeof given === \"string\") {\n        if (typeof expected === \"string\") {\n            return expected === given;\n        } else {\n            return (expected as NamespacedValue<string, string>).matches(given as string);\n        }\n    } else {\n        if (typeof expected === \"string\") {\n            return (given as NamespacedValue<string, string>).matches(expected as string);\n        } else {\n            const expectedNs = expected as NamespacedValue<string, string>;\n            const givenNs = given as NamespacedValue<string, string>;\n            return (\n                expectedNs.matches(givenNs.name) ||\n                (isProvided(givenNs.altName) && expectedNs.matches(givenNs.altName!))\n            );\n        }\n    }\n}\n","/*\nCopyright 2024 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\n/**\n * Well-known values (from the spec or MSCs) that are allowed in the\n * {@link Membership} type.\n */\nexport enum KnownMembership {\n    /**\n     * The user has been banned from the room, and is no longer allowed to join\n     * it until they are un-banned from the room (by having their membership\n     * state set to a value other than ban).\n     */\n    Ban = \"ban\",\n    /**\n     * The user has been invited to join a room, but has not yet joined it.\n     * They may not participate in the room until they join.\n     * */\n    Invite = \"invite\",\n    /**\n     * The user has joined the room (possibly after accepting an invite), and\n     * may participate in it.\n     */\n    Join = \"join\",\n    /**\n     * The user has knocked on the room, requesting permission to participate.\n     * They may not participate in the room until they join.\n     */\n    Knock = \"knock\",\n    /**\n     * The user was once joined to the room, but has since left (possibly by\n     * choice, or possibly by being kicked).\n     */\n    Leave = \"leave\",\n}\n\n/**\n * The membership state for a user in a room [1]. A value from\n * {@link KnownMembership} should be used where available, but all string values\n * are allowed to provide flexibility for upcoming spec changes or proposals.\n *\n * [1] https://spec.matrix.org/latest/client-server-api/#mroommember\n */\nexport type Membership = KnownMembership | string;\n","/*\nCopyright 2021 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nexport enum Visibility {\n    Public = \"public\",\n    Private = \"private\",\n}\n\nexport enum Preset {\n    PrivateChat = \"private_chat\",\n    TrustedPrivateChat = \"trusted_private_chat\",\n    PublicChat = \"public_chat\",\n}\n\nexport type ResizeMethod = \"crop\" | \"scale\";\n\nexport type IdServerUnbindResult = \"no-support\" | \"success\";\n\n// Knock and private are reserved keywords which are not yet implemented.\nexport enum JoinRule {\n    Public = \"public\",\n    Invite = \"invite\",\n    /**\n     * @deprecated Reserved keyword. Should not be used. Not yet implemented.\n     */\n    Private = \"private\",\n    Knock = \"knock\",\n    Restricted = \"restricted\",\n}\n\nexport enum RestrictedAllowType {\n    RoomMembership = \"m.room_membership\",\n}\n\nexport enum GuestAccess {\n    CanJoin = \"can_join\",\n    Forbidden = \"forbidden\",\n}\n\nexport enum HistoryVisibility {\n    Invited = \"invited\",\n    Joined = \"joined\",\n    Shared = \"shared\",\n    WorldReadable = \"world_readable\",\n}\n\nexport interface IUsageLimit {\n    // \"hs_disabled\" is NOT a specced string, but is used in Synapse\n    // This is tracked over at https://github.com/matrix-org/synapse/issues/9237\n    // eslint-disable-next-line camelcase\n    limit_type: \"monthly_active_user\" | \"hs_disabled\" | string;\n    // eslint-disable-next-line camelcase\n    admin_contact?: string;\n}\n\n/**\n * A policy name & url in a specific internationalisation\n * @see https://spec.matrix.org/v1.13/identity-service-api/#get_matrixidentityv2terms_response-200_internationalised-policy\n */\nexport interface InternationalisedPolicy {\n    name: string;\n    url: string;\n}\n\n/**\n * A versioned policy with internationalised variants\n * @see https://spec.matrix.org/v1.13/identity-service-api/#get_matrixidentityv2terms_response-200_policy-object\n */\nexport interface Policy {\n    /**\n     * The version for the policy.\n     * There are no requirements on what this might be and could be “alpha”, semantically versioned, or arbitrary.\n     */\n    version: string;\n    /**\n     * The policy information for the specified language.\n     * @remarks the type has to include a union with string due to limitations in the type system.\n     */\n    [lang: string]: InternationalisedPolicy | string;\n}\n\n/**\n * Response from the Terms API for Identity servers\n * @see https://spec.matrix.org/v1.13/identity-service-api/#get_matrixidentityv2terms\n */\nexport interface Terms {\n    policies: {\n        [policyName: string]: Policy;\n    };\n}\n","/*\nCopyright 2022 - 2023 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { type EitherAnd, UnstableValue } from \"matrix-events-sdk\";\n\nimport {\n    type ExtensibleAnyMessageEventContent,\n    type REFERENCE_RELATION,\n    type RelatesToRelationship,\n    type TSNamespace,\n} from \"./extensible_events.ts\";\nimport { type EmptyObject } from \"./common.ts\";\n\n/**\n * Identifier for a disclosed poll.\n */\nexport const M_POLL_KIND_DISCLOSED = new UnstableValue(\"m.poll.disclosed\", \"org.matrix.msc3381.poll.disclosed\");\n\n/**\n * Identifier for an undisclosed poll.\n */\nexport const M_POLL_KIND_UNDISCLOSED = new UnstableValue(\"m.poll.undisclosed\", \"org.matrix.msc3381.poll.undisclosed\");\n\n/**\n * Any poll kind.\n */\nexport type PollKind = TSNamespace<typeof M_POLL_KIND_DISCLOSED> | TSNamespace<typeof M_POLL_KIND_UNDISCLOSED> | string;\n\n/**\n * Known poll kind namespaces.\n */\nexport type KnownPollKind = typeof M_POLL_KIND_DISCLOSED | typeof M_POLL_KIND_UNDISCLOSED;\n\n/**\n * The namespaced value for m.poll.start\n */\nexport const M_POLL_START = new UnstableValue(\"m.poll.start\", \"org.matrix.msc3381.poll.start\");\n\n/**\n * The m.poll.start type within event content\n */\nexport type PollStartSubtype = {\n    question: ExtensibleAnyMessageEventContent;\n    kind: PollKind;\n    max_selections?: number; // default 1, always positive\n    answers: PollAnswer[];\n};\n\n/**\n * A poll answer.\n */\nexport type PollAnswer = ExtensibleAnyMessageEventContent & { id: string };\n\n/**\n * The event definition for an m.poll.start event (in content)\n */\nexport type PollStartEvent = EitherAnd<\n    { [M_POLL_START.name]: PollStartSubtype },\n    { [M_POLL_START.altName]: PollStartSubtype }\n>;\n\n/**\n * The content for an m.poll.start event\n */\nexport type PollStartEventContent = PollStartEvent & ExtensibleAnyMessageEventContent;\n\n/**\n * The namespaced value for m.poll.response\n */\nexport const M_POLL_RESPONSE = new UnstableValue(\"m.poll.response\", \"org.matrix.msc3381.poll.response\");\n\n/**\n * The m.poll.response type within event content\n */\nexport type PollResponseSubtype = {\n    answers: string[];\n};\n\n/**\n * The event definition for an m.poll.response event (in content)\n */\nexport type PollResponseEvent = EitherAnd<\n    { [M_POLL_RESPONSE.name]: PollResponseSubtype },\n    { [M_POLL_RESPONSE.altName]: PollResponseSubtype }\n>;\n\n/**\n * The content for an m.poll.response event\n */\nexport type PollResponseEventContent = PollResponseEvent & RelatesToRelationship<typeof REFERENCE_RELATION>;\n\n/**\n * The namespaced value for m.poll.end\n */\nexport const M_POLL_END = new UnstableValue(\"m.poll.end\", \"org.matrix.msc3381.poll.end\");\n\n/**\n * The event definition for an m.poll.end event (in content)\n */\nexport type PollEndEvent = EitherAnd<{ [M_POLL_END.name]: EmptyObject }, { [M_POLL_END.altName]: EmptyObject }>;\n\n/**\n * The content for an m.poll.end event\n */\nexport type PollEndEventContent = PollEndEvent &\n    RelatesToRelationship<typeof REFERENCE_RELATION> &\n    ExtensibleAnyMessageEventContent;\n","/*\nCopyright 2021 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { type IContent, type IEvent } from \"../models/event.ts\";\nimport { type Preset, type Visibility } from \"./partials.ts\";\nimport { type IEventWithRoomId, type SearchKey } from \"./search.ts\";\nimport { type IRoomEventFilter } from \"../filter.ts\";\nimport { type Direction } from \"../models/event-timeline.ts\";\nimport { type PushRuleAction } from \"./PushRules.ts\";\nimport { type IRoomEvent } from \"../sync-accumulator.ts\";\nimport { type EventType, type RelationType, type RoomType } from \"./event.ts\";\n\n// allow camelcase as these are things that go onto the wire\n/* eslint-disable camelcase */\n\nexport interface IJoinRoomOpts {\n    /**\n     * True to do a room initial sync on the resulting\n     * room. If false, the <strong>returned Room object will have no current state.\n     * </strong> Default: true.\n     */\n    syncRoom?: boolean;\n\n    /**\n     * If the caller has a keypair 3pid invite, the signing URL is passed in this parameter.\n     */\n    inviteSignUrl?: string;\n\n    /**\n     * The server names to try and join through in addition to those that are automatically chosen.\n     */\n    viaServers?: string[];\n}\n\nexport interface KnockRoomOpts {\n    /**\n     * The reason for the knock.\n     */\n    reason?: string;\n\n    /**\n     * The server names to try and knock through in addition to those that are automatically chosen.\n     */\n    viaServers?: string | string[];\n}\n\nexport interface IRedactOpts {\n    reason?: string;\n    /**\n     * If specified, then any events which relate to the event being redacted with\n     * any of the relationship types listed will also be redacted.\n     * Provide a \"*\" list item to tell the server to redact relations of any type.\n     *\n     * <b>Raises an Error if the server does not support it.</b>\n     * Check for server-side support before using this param with\n     * <code>client.canSupport.get(Feature.RelationBasedRedactions)</code>.\n     * {@link https://github.com/matrix-org/matrix-spec-proposals/pull/3912}\n     */\n    with_rel_types?: Array<RelationType | \"*\">;\n}\n\nexport interface ISendEventResponse {\n    event_id: string;\n}\n\nexport type TimeoutDelay = {\n    delay: number;\n};\n\nexport type ParentDelayId = {\n    parent_delay_id: string;\n};\n\nexport type SendTimeoutDelayedEventRequestOpts = TimeoutDelay & Partial<ParentDelayId>;\nexport type SendActionDelayedEventRequestOpts = ParentDelayId;\n\nexport type SendDelayedEventRequestOpts = SendTimeoutDelayedEventRequestOpts | SendActionDelayedEventRequestOpts;\n\nexport type SendDelayedEventResponse = {\n    delay_id: string;\n};\n\nexport enum UpdateDelayedEventAction {\n    Cancel = \"cancel\",\n    Restart = \"restart\",\n    Send = \"send\",\n}\n\nexport type UpdateDelayedEventRequestOpts = SendDelayedEventResponse & {\n    action: UpdateDelayedEventAction;\n};\n\ntype DelayedPartialTimelineEvent = {\n    room_id: string;\n    type: string;\n    content: IContent;\n};\n\ntype DelayedPartialStateEvent = DelayedPartialTimelineEvent & {\n    state_key: string;\n};\n\ntype DelayedPartialEvent = DelayedPartialTimelineEvent | DelayedPartialStateEvent;\n\nexport type DelayedEventInfo = {\n    delayed_events: (DelayedPartialEvent &\n        SendDelayedEventResponse &\n        SendDelayedEventRequestOpts & {\n            running_since: number;\n        })[];\n    next_batch?: string;\n};\n\nexport interface IPresenceOpts {\n    // One of \"online\", \"offline\" or \"unavailable\"\n    presence: \"online\" | \"offline\" | \"unavailable\";\n    // The status message to attach.\n    status_msg?: string;\n}\n\nexport interface IPaginateOpts {\n    // true to fill backwards, false to go forwards\n    backwards?: boolean;\n    // number of events to request\n    limit?: number;\n}\n\nexport interface IGuestAccessOpts {\n    /**\n     * True to allow guests to join this room. This\n     * implicitly gives guests write access. If false or not given, guests are\n     * explicitly forbidden from joining the room.\n     */\n    allowJoin: boolean;\n    /**\n     * True to set history visibility to\n     * be world_readable. This gives guests read access *from this point forward*.\n     * If false or not given, history visibility is not modified.\n     */\n    allowRead: boolean;\n}\n\nexport interface ISearchOpts {\n    keys?: SearchKey[];\n    query: string;\n}\n\nexport interface IEventSearchOpts {\n    // a JSON filter object to pass in the request\n    filter?: IRoomEventFilter;\n    // the term to search for\n    term: string;\n}\n\nexport interface IInvite3PID {\n    id_server: string;\n    id_access_token?: string; // this gets injected by the js-sdk\n    medium: string;\n    address: string;\n}\n\nexport interface ICreateRoomStateEvent {\n    type: string;\n    state_key?: string; // defaults to an empty string\n    content: IContent;\n}\n\nexport interface ICreateRoomOpts {\n    // The alias localpart to assign to this room.\n    room_alias_name?: string;\n    // Either 'public' or 'private'.\n    visibility?: Visibility;\n    // The name to give this room.\n    name?: string;\n    // The topic to give this room.\n    topic?: string;\n    preset?: Preset;\n    power_level_content_override?: {\n        ban?: number;\n        events?: Record<EventType | string, number>;\n        events_default?: number;\n        invite?: number;\n        kick?: number;\n        notifications?: Record<string, number>;\n        redact?: number;\n        state_default?: number;\n        users?: Record<string, number>;\n        users_default?: number;\n    };\n    creation_content?: object;\n    initial_state?: ICreateRoomStateEvent[];\n    // A list of user IDs to invite to this room.\n    invite?: string[];\n    invite_3pid?: IInvite3PID[];\n    is_direct?: boolean;\n    room_version?: string;\n}\n\nexport interface IRoomDirectoryOptions {\n    /**\n     * The remote server to query for the room list.\n     * Optional. If unspecified, get the local homeserver's public room list.\n     */\n    server?: string;\n    /**\n     * Maximum number of entries to return\n     */\n    limit?: number;\n    /**\n     * Token to paginate from\n     */\n    since?: string;\n\n    /** Filter parameters */\n    filter?: {\n        // String to search for\n        generic_search_term?: string;\n        room_types?: Array<RoomType | null>;\n    };\n    include_all_networks?: boolean;\n    third_party_instance_id?: string;\n}\n\nexport interface IAddThreePidOnlyBody {\n    auth?: {\n        type: string;\n        session?: string;\n    };\n    client_secret: string;\n    sid: string;\n}\n\nexport interface IBindThreePidBody {\n    client_secret: string;\n    id_server: string;\n    // Some older identity servers have no auth enabled\n    id_access_token: string | null;\n    sid: string;\n}\n\nexport interface IRelationsRequestOpts {\n    from?: string;\n    to?: string;\n    limit?: number;\n    dir?: Direction;\n    recurse?: boolean; // MSC3981 Relations Recursion https://github.com/matrix-org/matrix-spec-proposals/pull/3981\n}\n\nexport interface IRelationsResponse {\n    chunk: IEvent[];\n    next_batch?: string;\n    prev_batch?: string;\n}\n\nexport interface IContextResponse {\n    end: string;\n    start: string;\n    state: IEventWithRoomId[];\n    events_before: IEventWithRoomId[];\n    events_after: IEventWithRoomId[];\n    event: IEventWithRoomId;\n}\n\nexport interface IEventsResponse {\n    chunk: IEventWithRoomId[];\n    end: string;\n    start: string;\n}\n\nexport interface INotification {\n    actions: PushRuleAction[];\n    event: IRoomEvent;\n    profile_tag?: string;\n    read: boolean;\n    room_id: string;\n    ts: number;\n}\n\nexport interface INotificationsResponse {\n    next_token: string;\n    notifications: INotification[];\n}\n\nexport interface IFilterResponse {\n    filter_id: string;\n}\n\nexport interface ITagsResponse {\n    tags: {\n        [tagId: string]: {\n            order: number;\n        };\n    };\n}\n\nexport interface IStatusResponse extends IPresenceOpts {\n    currently_active?: boolean;\n    last_active_ago?: number;\n}\n\n/* eslint-enable camelcase */\n","/*\nCopyright 2021 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\n// Types relating to the /search API\n\nimport { type IRoomEvent, type IStateEvent } from \"../sync-accumulator.ts\";\nimport { type IRoomEventFilter } from \"../filter.ts\";\nimport { type SearchResult } from \"../models/search-result.ts\";\n\n/* eslint-disable camelcase */\nexport interface IEventWithRoomId extends IRoomEvent {\n    room_id: string;\n}\n\nexport interface IStateEventWithRoomId extends IStateEvent {\n    room_id: string;\n}\n\nexport interface IMatrixProfile {\n    avatar_url?: string;\n    displayname?: string;\n}\n\nexport interface IResultContext {\n    events_before: IEventWithRoomId[];\n    events_after: IEventWithRoomId[];\n    profile_info: Record<string, IMatrixProfile>;\n    start?: string;\n    end?: string;\n}\n\nexport interface ISearchResult {\n    rank: number;\n    result: IEventWithRoomId;\n    context: IResultContext;\n}\n\nenum GroupKey {\n    RoomId = \"room_id\",\n    Sender = \"sender\",\n}\n\nexport interface IResultRoomEvents {\n    count?: number;\n    highlights?: string[];\n    results?: ISearchResult[];\n    state?: { [roomId: string]: IStateEventWithRoomId[] };\n    groups?: {\n        [groupKey in GroupKey]: {\n            [value: string]: {\n                next_batch?: string;\n                order: number;\n                results: string[];\n            };\n        };\n    };\n    next_batch?: string;\n}\n\ninterface IResultCategories {\n    room_events: IResultRoomEvents;\n}\n\nexport type SearchKey = \"content.body\" | \"content.name\" | \"content.topic\";\n\nexport enum SearchOrderBy {\n    Recent = \"recent\",\n    Rank = \"rank\",\n}\n\nexport interface ISearchRequestBody {\n    search_categories: {\n        room_events: {\n            search_term: string;\n            keys?: SearchKey[];\n            filter?: IRoomEventFilter;\n            order_by?: SearchOrderBy;\n            event_context?: {\n                before_limit?: number;\n                after_limit?: number;\n                include_profile?: boolean;\n            };\n            include_state?: boolean;\n            groupings?: {\n                group_by: {\n                    key: GroupKey;\n                }[];\n            };\n        };\n    };\n}\n\nexport interface ISearchResponse {\n    search_categories: IResultCategories;\n}\n\nexport interface ISearchResults {\n    _query?: ISearchRequestBody;\n    results: SearchResult[];\n    highlights: string[];\n    count?: number;\n    next_batch?: string;\n    pendingRequest?: Promise<ISearchResults>;\n    abortSignal?: AbortSignal;\n}\n/* eslint-enable camelcase */\n","/*\nCopyright 2022 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { ServerControlledNamespacedValue } from \"../NamespacedValue.ts\";\n\n/**\n * https://github.com/matrix-org/matrix-doc/pull/3773\n *\n * @experimental\n */\nexport const UNREAD_THREAD_NOTIFICATIONS = new ServerControlledNamespacedValue(\n    \"unread_thread_notifications\",\n    \"org.matrix.msc3773.unread_thread_notifications\",\n);\n","/*\nCopyright 2022 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\nimport { UnstableValue } from \"../NamespacedValue.ts\";\nimport { type IMessageRendering } from \"./extensible_events.ts\";\n\n/**\n * Extensible topic event type based on MSC3765\n * https://github.com/matrix-org/matrix-spec-proposals/pull/3765\n *\n * @example\n * ```\n * {\n *      \"type\": \"m.room.topic,\n *      \"state_key\": \"\",\n *      \"content\": {\n *          \"topic\": \"All about **pizza**\",\n *          \"m.topic\": [{\n *              \"body\": \"All about **pizza**\",\n *              \"mimetype\": \"text/plain\",\n *          }, {\n *              \"body\": \"All about <b>pizza</b>\",\n *              \"mimetype\": \"text/html\",\n *          }],\n *      }\n * }\n * ```\n */\n\n/**\n * The event type for an m.topic event (in content)\n */\nexport const M_TOPIC = new UnstableValue(\"m.topic\", \"org.matrix.msc3765.topic\");\n\n/**\n * The event content for an m.topic event (in content)\n */\nexport type MTopicContent = IMessageRendering[];\n\ntype MTopicStable = { [M_TOPIC.altName]: MTopicContent };\ntype MTopicUnstable = { [M_TOPIC.name]: MTopicContent };\n\n/**\n * The event definition for an m.topic event (in content)\n */\nexport type MTopicEvent = (MTopicStable & MTopicUnstable) | MTopicStable | MTopicUnstable;\n\n/**\n * The event content for an m.room.topic event\n */\nexport type MRoomTopicEventContent = {\n    topic: string | null | undefined;\n} & Partial<MTopicEvent>;\n","/*\nCopyright 2015, 2016 OpenMarket Ltd\nCopyright 2017 Vector Creations Ltd\nCopyright 2017 New Vector Ltd\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\n// eslint-disable-next-line no-restricted-imports\nimport { type EventEmitter } from \"events\";\n\nimport { type ListenerMap, type TypedEventEmitter } from \"./models/typed-event-emitter.ts\";\n\nexport class ReEmitter {\n    public constructor(private readonly target: EventEmitter) {}\n\n    // Map from emitter to event name to re-emitter\n    private reEmitters = new WeakMap<EventEmitter, Map<string, (...args: any[]) => void>>();\n\n    public reEmit(source: EventEmitter, eventNames: string[]): void {\n        let reEmittersByEvent = this.reEmitters.get(source);\n        if (!reEmittersByEvent) {\n            reEmittersByEvent = new Map();\n            this.reEmitters.set(source, reEmittersByEvent);\n        }\n\n        for (const eventName of eventNames) {\n            if (reEmittersByEvent.has(eventName)) continue;\n\n            // We include the source as the last argument for event handlers which may need it,\n            // such as read receipt listeners on the client class which won't have the context\n            // of the room.\n            const forSource = (...args: any[]): void => {\n                // EventEmitter special cases 'error' to make the emit function throw if no\n                // handler is attached, which sort of makes sense for making sure that something\n                // handles an error, but for re-emitting, there could be a listener on the original\n                // source object so the test doesn't really work. We *could* try to replicate the\n                // same logic and throw if there is no listener on either the source or the target,\n                // but this behaviour is fairly undesireable for us anyway: the main place we throw\n                // 'error' events is for calls, where error events are usually emitted some time\n                // later by a different part of the code where 'emit' throwing because the app hasn't\n                // added an error handler isn't terribly helpful. (A better fix in retrospect may\n                // have been to just avoid using the event name 'error', but backwards compat...)\n                if (eventName === \"error\" && this.target.listenerCount(\"error\") === 0) return;\n                this.target.emit(eventName, ...args, source);\n            };\n            source.on(eventName, forSource);\n            reEmittersByEvent.set(eventName, forSource);\n        }\n    }\n\n    public stopReEmitting(source: EventEmitter, eventNames: string[]): void {\n        const reEmittersByEvent = this.reEmitters.get(source);\n        if (!reEmittersByEvent) return; // We were never re-emitting these events in the first place\n\n        for (const eventName of eventNames) {\n            source.off(eventName, reEmittersByEvent.get(eventName)!);\n            reEmittersByEvent.delete(eventName);\n        }\n\n        if (reEmittersByEvent.size === 0) this.reEmitters.delete(source);\n    }\n}\n\nexport class TypedReEmitter<Events extends string, Arguments extends ListenerMap<Events>> extends ReEmitter {\n    public constructor(target: TypedEventEmitter<Events, Arguments>) {\n        super(target);\n    }\n\n    public reEmit<ReEmittedEvents extends string, T extends Events & ReEmittedEvents>(\n        source: TypedEventEmitter<ReEmittedEvents, any>,\n        eventNames: T[],\n    ): void {\n        super.reEmit(source, eventNames);\n    }\n\n    public stopReEmitting<ReEmittedEvents extends string, T extends Events & ReEmittedEvents>(\n        source: TypedEventEmitter<ReEmittedEvents, any>,\n        eventNames: T[],\n    ): void {\n        super.stopReEmitting(source, eventNames);\n    }\n}\n","/*\nCopyright 2018 New Vector Ltd\nCopyright 2019 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { type IClientWellKnown, type IWellKnownConfig, type IServerVersions } from \"./client.ts\";\nimport { logger } from \"./logger.ts\";\nimport { type MatrixError, Method, timeoutSignal } from \"./http-api/index.ts\";\nimport { SUPPORTED_MATRIX_VERSIONS } from \"./version-support.ts\";\n\n// Dev note: Auto discovery is part of the spec.\n// See: https://matrix.org/docs/spec/client_server/r0.4.0.html#server-discovery\n\nexport enum AutoDiscoveryAction {\n    SUCCESS = \"SUCCESS\",\n    IGNORE = \"IGNORE\",\n    PROMPT = \"PROMPT\",\n    FAIL_PROMPT = \"FAIL_PROMPT\",\n    FAIL_ERROR = \"FAIL_ERROR\",\n}\n\nexport enum AutoDiscoveryError {\n    Invalid = \"Invalid homeserver discovery response\",\n    GenericFailure = \"Failed to get autodiscovery configuration from server\",\n    InvalidHsBaseUrl = \"Invalid base_url for m.homeserver\",\n    InvalidHomeserver = \"Homeserver URL does not appear to be a valid Matrix homeserver\",\n    InvalidIsBaseUrl = \"Invalid base_url for m.identity_server\",\n    InvalidIdentityServer = \"Identity server URL does not appear to be a valid identity server\",\n    InvalidIs = \"Invalid identity server discovery response\",\n    MissingWellknown = \"No .well-known JSON file found\",\n    InvalidJson = \"Invalid JSON\",\n    UnsupportedHomeserverSpecVersion = \"The homeserver does not meet the version requirements\",\n\n    // TODO: Implement when Sydent supports the `/versions` endpoint - https://github.com/matrix-org/sydent/issues/424\n    //IdentityServerTooOld = \"The identity server does not meet the minimum version requirements\",\n}\n\ninterface AutoDiscoveryState {\n    state: AutoDiscoveryAction;\n    error?: IWellKnownConfig[\"error\"] | null;\n}\ninterface WellKnownConfig extends Omit<IWellKnownConfig, \"error\">, AutoDiscoveryState {}\n\nexport interface ClientConfig extends Omit<IClientWellKnown, \"m.homeserver\" | \"m.identity_server\"> {\n    \"m.homeserver\": WellKnownConfig;\n    \"m.identity_server\": WellKnownConfig;\n}\n\n/**\n * Utilities for automatically discovery resources, such as homeservers\n * for users to log in to.\n */\nexport class AutoDiscovery {\n    // Dev note: the constants defined here are related to but not\n    // exactly the same as those in the spec. This is to hopefully\n    // translate the meaning of the states in the spec, but also\n    // support our own if needed.\n\n    public static readonly ERROR_INVALID = AutoDiscoveryError.Invalid;\n\n    public static readonly ERROR_GENERIC_FAILURE = AutoDiscoveryError.GenericFailure;\n\n    public static readonly ERROR_INVALID_HS_BASE_URL = AutoDiscoveryError.InvalidHsBaseUrl;\n\n    public static readonly ERROR_INVALID_HOMESERVER = AutoDiscoveryError.InvalidHomeserver;\n\n    public static readonly ERROR_INVALID_IS_BASE_URL = AutoDiscoveryError.InvalidIsBaseUrl;\n\n    public static readonly ERROR_INVALID_IDENTITY_SERVER = AutoDiscoveryError.InvalidIdentityServer;\n\n    public static readonly ERROR_INVALID_IS = AutoDiscoveryError.InvalidIs;\n\n    public static readonly ERROR_MISSING_WELLKNOWN = AutoDiscoveryError.MissingWellknown;\n\n    public static readonly ERROR_INVALID_JSON = AutoDiscoveryError.InvalidJson;\n\n    public static readonly ERROR_UNSUPPORTED_HOMESERVER_SPEC_VERSION =\n        AutoDiscoveryError.UnsupportedHomeserverSpecVersion;\n\n    public static readonly ALL_ERRORS = Object.keys(AutoDiscoveryError) as AutoDiscoveryError[];\n\n    /**\n     * The auto discovery failed. The client is expected to communicate\n     * the error to the user and refuse logging in.\n     */\n    public static readonly FAIL_ERROR = AutoDiscoveryAction.FAIL_ERROR;\n\n    /**\n     * The auto discovery failed, however the client may still recover\n     * from the problem. The client is recommended to that the same\n     * action it would for PROMPT while also warning the user about\n     * what went wrong. The client may also treat this the same as\n     * a FAIL_ERROR state.\n     */\n    public static readonly FAIL_PROMPT = AutoDiscoveryAction.FAIL_PROMPT;\n\n    /**\n     * The auto discovery didn't fail but did not find anything of\n     * interest. The client is expected to prompt the user for more\n     * information, or fail if it prefers.\n     */\n    public static readonly PROMPT = AutoDiscoveryAction.PROMPT;\n\n    /**\n     * The auto discovery was successful.\n     */\n    public static readonly SUCCESS = AutoDiscoveryAction.SUCCESS;\n\n    /**\n     * Validates and verifies client configuration information for purposes\n     * of logging in. Such information includes the homeserver URL\n     * and identity server URL the client would want. Additional details\n     * may also be included, and will be transparently brought into the\n     * response object unaltered.\n     * @param wellknown - The configuration object itself, as returned\n     * by the .well-known auto-discovery endpoint.\n     * @returns Promise which resolves to the verified\n     * configuration, which may include error states. Rejects on unexpected\n     * failure, not when verification fails.\n     */\n    public static async fromDiscoveryConfig(wellknown?: IClientWellKnown): Promise<ClientConfig> {\n        // Step 1 is to get the config, which is provided to us here.\n\n        // We default to an error state to make the first few checks easier to\n        // write. We'll update the properties of this object over the duration\n        // of this function.\n        const clientConfig: ClientConfig = {\n            \"m.homeserver\": {\n                state: AutoDiscovery.FAIL_ERROR,\n                error: AutoDiscovery.ERROR_INVALID,\n                base_url: null,\n            },\n            \"m.identity_server\": {\n                // Technically, we don't have a problem with the identity server\n                // config at this point.\n                state: AutoDiscovery.PROMPT,\n                error: null,\n                base_url: null,\n            },\n        };\n\n        if (!wellknown?.[\"m.homeserver\"]) {\n            logger.error(\"No m.homeserver key in config\");\n\n            clientConfig[\"m.homeserver\"].state = AutoDiscovery.FAIL_PROMPT;\n            clientConfig[\"m.homeserver\"].error = AutoDiscovery.ERROR_INVALID;\n\n            return Promise.resolve(clientConfig);\n        }\n\n        if (!wellknown[\"m.homeserver\"][\"base_url\"]) {\n            logger.error(\"No m.homeserver base_url in config\");\n\n            clientConfig[\"m.homeserver\"].state = AutoDiscovery.FAIL_PROMPT;\n            clientConfig[\"m.homeserver\"].error = AutoDiscovery.ERROR_INVALID_HS_BASE_URL;\n\n            return Promise.resolve(clientConfig);\n        }\n\n        // Step 2: Make sure the homeserver URL is valid *looking*. We'll make\n        // sure it points to a homeserver in Step 3.\n        const hsUrl = this.sanitizeWellKnownUrl(wellknown[\"m.homeserver\"][\"base_url\"]);\n        if (!hsUrl) {\n            logger.error(\"Invalid base_url for m.homeserver\");\n            clientConfig[\"m.homeserver\"].error = AutoDiscovery.ERROR_INVALID_HS_BASE_URL;\n            return Promise.resolve(clientConfig);\n        }\n\n        // Step 3: Make sure the homeserver URL points to a homeserver.\n        const hsVersions = await this.fetchWellKnownObject<IServerVersions>(`${hsUrl}/_matrix/client/versions`);\n        if (!hsVersions || !Array.isArray(hsVersions.raw?.[\"versions\"])) {\n            logger.error(\"Invalid /versions response\");\n            clientConfig[\"m.homeserver\"].error = AutoDiscovery.ERROR_INVALID_HOMESERVER;\n\n            // Supply the base_url to the caller because they may be ignoring liveliness\n            // errors, like this one.\n            clientConfig[\"m.homeserver\"].base_url = hsUrl;\n\n            return Promise.resolve(clientConfig);\n        }\n\n        // Step 3.1: Non-spec check to ensure the server will actually work for us. We need to check if\n        // any of the versions in `SUPPORTED_MATRIX_VERSIONS` are listed in the /versions response.\n        const hsVersionSet = new Set(hsVersions.raw![\"versions\"]);\n        let supportedVersionFound = false;\n        for (const version of SUPPORTED_MATRIX_VERSIONS) {\n            if (hsVersionSet.has(version)) {\n                supportedVersionFound = true;\n                break;\n            }\n        }\n        if (!supportedVersionFound) {\n            logger.error(\"Homeserver does not meet version requirements\");\n            clientConfig[\"m.homeserver\"].error = AutoDiscovery.ERROR_UNSUPPORTED_HOMESERVER_SPEC_VERSION;\n\n            // Supply the base_url to the caller because they may be ignoring liveliness\n            // errors, like this one.\n            clientConfig[\"m.homeserver\"].base_url = hsUrl;\n\n            return Promise.resolve(clientConfig);\n        }\n\n        // Step 4: Now that the homeserver looks valid, update our client config.\n        clientConfig[\"m.homeserver\"] = {\n            state: AutoDiscovery.SUCCESS,\n            error: null,\n            base_url: hsUrl,\n        };\n\n        // Step 5: Try to pull out the identity server configuration\n        let isUrl: string | boolean = \"\";\n        if (wellknown[\"m.identity_server\"]) {\n            // We prepare a failing identity server response to save lines later\n            // in this branch.\n            const failingClientConfig: ClientConfig = {\n                \"m.homeserver\": clientConfig[\"m.homeserver\"],\n                \"m.identity_server\": {\n                    state: AutoDiscovery.FAIL_PROMPT,\n                    error: AutoDiscovery.ERROR_INVALID_IS,\n                    base_url: null,\n                },\n            };\n\n            // Step 5a: Make sure the URL is valid *looking*. We'll make sure it\n            // points to an identity server in Step 5b.\n            isUrl = this.sanitizeWellKnownUrl(wellknown[\"m.identity_server\"][\"base_url\"]);\n            if (!isUrl) {\n                logger.error(\"Invalid base_url for m.identity_server\");\n                failingClientConfig[\"m.identity_server\"].error = AutoDiscovery.ERROR_INVALID_IS_BASE_URL;\n                return Promise.resolve(failingClientConfig);\n            }\n\n            // Step 5b: Verify there is an identity server listening on the provided\n            // URL.\n            const isResponse = await this.fetchWellKnownObject(`${isUrl}/_matrix/identity/v2`);\n            if (!isResponse?.raw || isResponse.action !== AutoDiscoveryAction.SUCCESS) {\n                logger.error(\"Invalid /v2 response\");\n                failingClientConfig[\"m.identity_server\"].error = AutoDiscovery.ERROR_INVALID_IDENTITY_SERVER;\n\n                // Supply the base_url to the caller because they may be ignoring\n                // liveliness errors, like this one.\n                failingClientConfig[\"m.identity_server\"].base_url = isUrl;\n\n                return Promise.resolve(failingClientConfig);\n            }\n        }\n\n        // Step 6: Now that the identity server is valid, or never existed,\n        // populate the IS section.\n        if (isUrl && isUrl.toString().length > 0) {\n            clientConfig[\"m.identity_server\"] = {\n                state: AutoDiscovery.SUCCESS,\n                error: null,\n                base_url: isUrl,\n            };\n        }\n\n        // Step 7: Copy any other keys directly into the clientConfig. This is for\n        // things like custom configuration of services.\n        Object.keys(wellknown).forEach((k: keyof IClientWellKnown) => {\n            if (k === \"m.homeserver\" || k === \"m.identity_server\") {\n                // Only copy selected parts of the config to avoid overwriting\n                // properties computed by the validation logic above.\n                const notProps = [\"error\", \"state\", \"base_url\"];\n                for (const prop of Object.keys(wellknown[k]!)) {\n                    if (notProps.includes(prop)) continue;\n                    type Prop = Exclude<keyof IWellKnownConfig, \"error\" | \"state\" | \"base_url\">;\n                    // @ts-ignore - ts gets unhappy as we're mixing types here\n                    clientConfig[k][prop as Prop] = wellknown[k]![prop as Prop];\n                }\n            } else {\n                // Just copy the whole thing over otherwise\n                clientConfig[k] = wellknown[k];\n            }\n        });\n\n        // Step 8: Give the config to the caller (finally)\n        return Promise.resolve(clientConfig);\n    }\n\n    /**\n     * Attempts to automatically discover client configuration information\n     * prior to logging in. Such information includes the homeserver URL\n     * and identity server URL the client would want. Additional details\n     * may also be discovered, and will be transparently included in the\n     * response object unaltered.\n     * @param domain - The homeserver domain to perform discovery\n     * on. For example, \"matrix.org\".\n     * @returns Promise which resolves to the discovered\n     * configuration, which may include error states. Rejects on unexpected\n     * failure, not when discovery fails.\n     */\n    public static async findClientConfig(domain: string): Promise<ClientConfig> {\n        if (!domain || typeof domain !== \"string\" || domain.length === 0) {\n            throw new Error(\"'domain' must be a string of non-zero length\");\n        }\n\n        // We use a .well-known lookup for all cases. According to the spec, we\n        // can do other discovery mechanisms if we want such as custom lookups\n        // however we won't bother with that here (mostly because the spec only\n        // supports .well-known right now).\n        //\n        // By using .well-known, we need to ensure we at least pull out a URL\n        // for the homeserver. We don't really need an identity server configuration\n        // but will return one anyways (with state PROMPT) to make development\n        // easier for clients. If we can't get a homeserver URL, all bets are\n        // off on the rest of the config and we'll assume it is invalid too.\n\n        // We default to an error state to make the first few checks easier to\n        // write. We'll update the properties of this object over the duration\n        // of this function.\n        const clientConfig: ClientConfig = {\n            \"m.homeserver\": {\n                state: AutoDiscovery.FAIL_ERROR,\n                error: AutoDiscovery.ERROR_INVALID,\n                base_url: null,\n            },\n            \"m.identity_server\": {\n                // Technically, we don't have a problem with the identity server\n                // config at this point.\n                state: AutoDiscovery.PROMPT,\n                error: null,\n                base_url: null,\n            },\n        };\n\n        // Step 1: Actually request the .well-known JSON file and make sure it\n        // at least has a homeserver definition.\n        const domainWithProtocol = domain.includes(\"://\") ? domain : `https://${domain}`;\n        const wellknown = await this.fetchWellKnownObject(`${domainWithProtocol}/.well-known/matrix/client`);\n        if (!wellknown || wellknown.action !== AutoDiscoveryAction.SUCCESS) {\n            logger.error(\"No response or error when parsing .well-known\");\n            if (wellknown.reason) logger.error(wellknown.reason);\n            if (wellknown.action === AutoDiscoveryAction.IGNORE) {\n                clientConfig[\"m.homeserver\"] = {\n                    state: AutoDiscovery.PROMPT,\n                    error: null,\n                    base_url: null,\n                };\n            } else {\n                // this can only ever be FAIL_PROMPT at this point.\n                clientConfig[\"m.homeserver\"].state = AutoDiscovery.FAIL_PROMPT;\n                clientConfig[\"m.homeserver\"].error = AutoDiscovery.ERROR_INVALID;\n            }\n            return Promise.resolve(clientConfig);\n        }\n\n        // Step 2: Validate and parse the config\n        return AutoDiscovery.fromDiscoveryConfig(wellknown.raw!);\n    }\n\n    /**\n     * Gets the raw discovery client configuration for the given domain name.\n     * Should only be used if there's no validation to be done on the resulting\n     * object, otherwise use findClientConfig().\n     * @param domain - The domain to get the client config for.\n     * @returns Promise which resolves to the domain's client config. Can\n     * be an empty object.\n     */\n    public static async getRawClientConfig(domain?: string): Promise<IClientWellKnown> {\n        if (!domain || typeof domain !== \"string\" || domain.length === 0) {\n            throw new Error(\"'domain' must be a string of non-zero length\");\n        }\n\n        const response = await this.fetchWellKnownObject(`https://${domain}/.well-known/matrix/client`);\n        if (!response) return {};\n        return response.raw ?? {};\n    }\n\n    /**\n     * Sanitizes a given URL to ensure it is either an HTTP or HTTP URL and\n     * is suitable for the requirements laid out by .well-known auto discovery.\n     * If valid, the URL will also be stripped of any trailing slashes.\n     * @param url - The potentially invalid URL to sanitize.\n     * @returns The sanitized URL or a falsey value if the URL is invalid.\n     * @internal\n     */\n    private static sanitizeWellKnownUrl(url?: string | null): string | false {\n        if (!url) return false;\n\n        try {\n            let parsed: URL | undefined;\n            try {\n                parsed = new URL(url);\n            } catch (e) {\n                logger.error(\"Could not parse url\", e);\n            }\n\n            if (!parsed?.hostname) return false;\n            if (parsed.protocol !== \"http:\" && parsed.protocol !== \"https:\") return false;\n\n            const port = parsed.port ? `:${parsed.port}` : \"\";\n            const path = parsed.pathname ? parsed.pathname : \"\";\n            let saferUrl = `${parsed.protocol}//${parsed.hostname}${port}${path}`;\n            if (saferUrl.endsWith(\"/\")) {\n                saferUrl = saferUrl.substring(0, saferUrl.length - 1);\n            }\n            return saferUrl;\n        } catch (e) {\n            logger.error(e);\n            return false;\n        }\n    }\n\n    private static fetch(resource: URL | string, options?: RequestInit): ReturnType<typeof globalThis.fetch> {\n        if (this.fetchFn) {\n            return this.fetchFn(resource, options);\n        }\n        return globalThis.fetch(resource, options);\n    }\n\n    private static fetchFn?: typeof globalThis.fetch;\n\n    public static setFetchFn(fetchFn: typeof globalThis.fetch): void {\n        AutoDiscovery.fetchFn = fetchFn;\n    }\n\n    /**\n     * Fetches a JSON object from a given URL, as expected by all .well-known\n     * related lookups. If the server gives a 404 then the `action` will be\n     * IGNORE. If the server returns something that isn't JSON, the `action`\n     * will be FAIL_PROMPT. For any other failure the `action` will be FAIL_PROMPT.\n     *\n     * The returned object will be a result of the call in object form with\n     * the following properties:\n     *   raw: The JSON object returned by the server.\n     *   action: One of SUCCESS, IGNORE, or FAIL_PROMPT.\n     *   reason: Relatively human-readable description of what went wrong.\n     *   error: The actual Error, if one exists.\n     * @param url - The URL to fetch a JSON object from.\n     * @returns Promise which resolves to the returned state.\n     * @internal\n     */\n    private static async fetchWellKnownObject<T = IWellKnownConfig>(\n        url: string,\n    ): Promise<IWellKnownConfig<Partial<T>>> {\n        let response: Response;\n\n        try {\n            response = await AutoDiscovery.fetch(url, {\n                method: Method.Get,\n                signal: timeoutSignal(5000),\n            });\n\n            if (response.status === 404) {\n                return {\n                    raw: {},\n                    action: AutoDiscoveryAction.IGNORE,\n                    reason: AutoDiscovery.ERROR_MISSING_WELLKNOWN,\n                };\n            }\n\n            if (!response.ok) {\n                return {\n                    raw: {},\n                    action: AutoDiscoveryAction.FAIL_PROMPT,\n                    reason: \"General failure\",\n                };\n            }\n        } catch (err) {\n            const error = err as AutoDiscoveryError | string | undefined;\n            let reason = \"\";\n            if (typeof error === \"object\") {\n                reason = (<Error>error)?.message;\n            }\n\n            return {\n                error,\n                raw: {},\n                action: AutoDiscoveryAction.FAIL_PROMPT,\n                reason: reason || \"General failure\",\n            };\n        }\n\n        try {\n            return {\n                raw: await response.json(),\n                action: AutoDiscoveryAction.SUCCESS,\n            };\n        } catch (err) {\n            const error = err as Error;\n            return {\n                error,\n                raw: {},\n                action: AutoDiscoveryAction.FAIL_PROMPT,\n                reason:\n                    (error as MatrixError)?.name === \"SyntaxError\"\n                        ? AutoDiscovery.ERROR_INVALID_JSON\n                        : AutoDiscovery.ERROR_INVALID,\n            };\n        }\n    }\n}\n","/*\nCopyright 2023 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\n/**\n * Base64 encoding and decoding utilities\n */\n\nfunction toBase64(uint8Array: Uint8Array, options: Uint8ArrayToBase64Options): string {\n    if (typeof uint8Array.toBase64 === \"function\") {\n        // Currently this is only supported in Firefox,\n        // but we match the options in the hope in the future we can rely on it for all environments.\n        // https://tc39.es/proposal-arraybuffer-base64/spec/#sec-uint8array.prototype.tobase64\n        return uint8Array.toBase64(options);\n    }\n\n    let base64 = btoa(uint8Array.reduce((acc, current) => acc + String.fromCharCode(current), \"\"));\n    if (options.omitPadding) {\n        base64 = base64.replace(/={1,2}$/, \"\");\n    }\n    if (options.alphabet === \"base64url\") {\n        base64 = base64.replace(/\\+/g, \"-\").replace(/\\//g, \"_\");\n    }\n\n    return base64;\n}\n\n/**\n * Encode a typed array of uint8 as base64.\n * @param uint8Array - The data to encode.\n * @returns The base64.\n */\nexport function encodeBase64(uint8Array: Uint8Array): string {\n    return toBase64(uint8Array, { alphabet: \"base64\", omitPadding: false });\n}\n\n/**\n * Encode a typed array of uint8 as unpadded base64.\n * @param uint8Array - The data to encode.\n * @returns The unpadded base64.\n */\nexport function encodeUnpaddedBase64(uint8Array: Uint8Array): string {\n    return toBase64(uint8Array, { alphabet: \"base64\", omitPadding: true });\n}\n\n/**\n * Encode a typed array of uint8 as unpadded base64 using the URL-safe encoding.\n * @param uint8Array - The data to encode.\n * @returns The unpadded base64.\n */\nexport function encodeUnpaddedBase64Url(uint8Array: Uint8Array): string {\n    return toBase64(uint8Array, { alphabet: \"base64url\", omitPadding: true });\n}\n\nfunction fromBase64(base64: string, options: Uint8ArrayFromBase64Options): Uint8Array {\n    if (typeof Uint8Array.fromBase64 === \"function\") {\n        // Currently this is only supported in Firefox,\n        // but we match the options in the hope in the future we can rely on it for all environments.\n        // https://tc39.es/proposal-arraybuffer-base64/spec/#sec-uint8array.frombase64\n        return Uint8Array.fromBase64(base64, options);\n    }\n\n    return Uint8Array.from(atob(base64), (c) => c.charCodeAt(0));\n}\n\n/**\n * Decode a base64 (or base64url) string to a typed array of uint8.\n * @param base64 - The base64 to decode.\n * @returns The decoded data.\n */\nexport function decodeBase64(base64: string): Uint8Array {\n    // The function requires us to select an alphabet, but we don't know if base64url was used so we convert.\n    return fromBase64(base64.replace(/-/g, \"+\").replace(/_/g, \"/\"), { alphabet: \"base64\", lastChunkHandling: \"loose\" });\n}\n","/*\nCopyright 2015 - 2021 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\n/**\n * This is an internal module.\n */\n\nimport { type EventType } from \"../@types/event.ts\";\nimport { type Room } from \"../models/room.ts\";\nimport { type User } from \"../models/user.ts\";\nimport { type IEvent, type MatrixEvent } from \"../models/event.ts\";\nimport { type Filter } from \"../filter.ts\";\nimport { type ISavedSync, type IStore, type UserCreator } from \"./index.ts\";\nimport { type RoomSummary } from \"../models/room-summary.ts\";\nimport { type ISyncResponse } from \"../sync-accumulator.ts\";\nimport { type IStateEventWithRoomId } from \"../@types/search.ts\";\nimport { type IndexedToDeviceBatch, type ToDeviceBatch } from \"../models/ToDeviceMessage.ts\";\nimport { type IStoredClientOpts } from \"../client.ts\";\n\n/**\n * Construct a stub store. This does no-ops on most store methods.\n */\nexport class StubStore implements IStore {\n    public readonly accountData = new Map(); // stub\n    private fromToken: string | null = null;\n\n    /** @returns whether or not the database was newly created in this session. */\n    public isNewlyCreated(): Promise<boolean> {\n        return Promise.resolve(true);\n    }\n\n    /**\n     * Get the sync token.\n     */\n    public getSyncToken(): string | null {\n        return this.fromToken;\n    }\n\n    /**\n     * Set the sync token.\n     */\n    public setSyncToken(token: string): void {\n        this.fromToken = token;\n    }\n\n    /**\n     * No-op.\n     */\n    public storeRoom(room: Room): void {}\n\n    /**\n     * No-op.\n     */\n    public getRoom(roomId: string): Room | null {\n        return null;\n    }\n\n    /**\n     * No-op.\n     * @returns An empty array.\n     */\n    public getRooms(): Room[] {\n        return [];\n    }\n\n    /**\n     * Permanently delete a room.\n     */\n    public removeRoom(roomId: string): void {\n        return;\n    }\n\n    /**\n     * No-op.\n     * @returns An empty array.\n     */\n    public getRoomSummaries(): RoomSummary[] {\n        return [];\n    }\n\n    /**\n     * No-op.\n     */\n    public storeUser(user: User): void {}\n\n    /**\n     * No-op.\n     */\n    public getUser(userId: string): User | null {\n        return null;\n    }\n\n    /**\n     * No-op.\n     */\n    public getUsers(): User[] {\n        return [];\n    }\n\n    /**\n     * No-op.\n     */\n    public scrollback(room: Room, limit: number): MatrixEvent[] {\n        return [];\n    }\n\n    /**\n     * No-op.\n     */\n    public setUserCreator(creator: UserCreator): void {\n        return;\n    }\n\n    /**\n     * Store events for a room.\n     * @param room - The room to store events for.\n     * @param events - The events to store.\n     * @param token - The token associated with these events.\n     * @param toStart - True if these are paginated results.\n     */\n    public storeEvents(room: Room, events: MatrixEvent[], token: string | null, toStart: boolean): void {}\n\n    /**\n     * Store a filter.\n     */\n    public storeFilter(filter: Filter): void {}\n\n    /**\n     * Retrieve a filter.\n     * @returns A filter or null.\n     */\n    public getFilter(userId: string, filterId: string): Filter | null {\n        return null;\n    }\n\n    /**\n     * Retrieve a filter ID with the given name.\n     * @param filterName - The filter name.\n     * @returns The filter ID or null.\n     */\n    public getFilterIdByName(filterName: string): string | null {\n        return null;\n    }\n\n    /**\n     * Set a filter name to ID mapping.\n     */\n    public setFilterIdByName(filterName: string, filterId?: string): void {}\n\n    /**\n     * Store user-scoped account data events\n     * @param events - The events to store.\n     */\n    public storeAccountDataEvents(events: MatrixEvent[]): void {}\n\n    /**\n     * Get account data event by event type\n     * @param eventType - The event type being queried\n     */\n    public getAccountData(eventType: EventType | string): MatrixEvent | undefined {\n        return undefined;\n    }\n\n    /**\n     * setSyncData does nothing as there is no backing data store.\n     *\n     * @param syncData - The sync data\n     * @returns An immediately resolved promise.\n     */\n    public setSyncData(syncData: ISyncResponse): Promise<void> {\n        return Promise.resolve();\n    }\n\n    /**\n     * We never want to save because we have nothing to save to.\n     *\n     * @returns If the store wants to save\n     */\n    public wantsSave(): boolean {\n        return false;\n    }\n\n    /**\n     * Save does nothing as there is no backing data store.\n     */\n    public save(): Promise<void> {\n        return Promise.resolve();\n    }\n\n    /**\n     * Startup does nothing.\n     * @returns An immediately resolved promise.\n     */\n    public startup(): Promise<void> {\n        return Promise.resolve();\n    }\n\n    /**\n     * @returns Promise which resolves with a sync response to restore the\n     * client state to where it was at the last save, or null if there\n     * is no saved sync data.\n     */\n    public getSavedSync(): Promise<ISavedSync | null> {\n        return Promise.resolve(null);\n    }\n\n    /**\n     * @returns If there is a saved sync, the nextBatch token\n     * for this sync, otherwise null.\n     */\n    public getSavedSyncToken(): Promise<string | null> {\n        return Promise.resolve(null);\n    }\n\n    /**\n     * Delete all data from this store. Does nothing since this store\n     * doesn't store anything.\n     * @returns An immediately resolved promise.\n     */\n    public deleteAllData(): Promise<void> {\n        return Promise.resolve();\n    }\n\n    public getOutOfBandMembers(): Promise<IStateEventWithRoomId[] | null> {\n        return Promise.resolve(null);\n    }\n\n    public setOutOfBandMembers(roomId: string, membershipEvents: IStateEventWithRoomId[]): Promise<void> {\n        return Promise.resolve();\n    }\n\n    public clearOutOfBandMembers(): Promise<void> {\n        return Promise.resolve();\n    }\n\n    public getClientOptions(): Promise<IStoredClientOpts | undefined> {\n        return Promise.resolve(undefined);\n    }\n\n    public storeClientOptions(options: IStoredClientOpts): Promise<void> {\n        return Promise.resolve();\n    }\n\n    public async getPendingEvents(roomId: string): Promise<Partial<IEvent>[]> {\n        return [];\n    }\n\n    public setPendingEvents(roomId: string, events: Partial<IEvent>[]): Promise<void> {\n        return Promise.resolve();\n    }\n\n    public async saveToDeviceBatches(batch: ToDeviceBatch[]): Promise<void> {\n        return Promise.resolve();\n    }\n\n    public getOldestToDeviceBatch(): Promise<IndexedToDeviceBatch | null> {\n        return Promise.resolve(null);\n    }\n\n    public async removeToDeviceBatch(id: number): Promise<void> {\n        return Promise.resolve();\n    }\n\n    public async destroy(): Promise<void> {\n        // Nothing to do\n    }\n}\n","/*\nCopyright 2021 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { type MatrixClient } from \"../client.ts\";\nimport { RelationType, UNSTABLE_MSC3089_BRANCH } from \"../@types/event.ts\";\nimport { type IContent, type MatrixEvent } from \"./event.ts\";\nimport { type MSC3089TreeSpace } from \"./MSC3089TreeSpace.ts\";\nimport { EventTimeline } from \"./event-timeline.ts\";\nimport { type FileType } from \"../http-api/index.ts\";\nimport type { ISendEventResponse } from \"../@types/requests.ts\";\nimport { type EncryptedFile } from \"../@types/media.ts\";\n\nexport interface MSC3089EventContent {\n    active?: boolean;\n    name?: string;\n    locked?: boolean;\n    version?: number;\n}\n\nexport interface MSC3089EventContent {\n    active?: boolean;\n    name?: string;\n    locked?: boolean;\n    version?: number;\n}\n\n/**\n * Represents a [MSC3089](https://github.com/matrix-org/matrix-doc/pull/3089) branch - a reference\n * to a file (leaf) in the tree. Note that this is UNSTABLE and subject to breaking changes\n * without notice.\n */\nexport class MSC3089Branch {\n    public constructor(\n        private client: MatrixClient,\n        public readonly indexEvent: MatrixEvent,\n        public readonly directory: MSC3089TreeSpace,\n    ) {\n        // Nothing to do\n    }\n\n    /**\n     * The file ID.\n     */\n    public get id(): string {\n        const stateKey = this.indexEvent.getStateKey();\n        if (!stateKey) {\n            throw new Error(\"State key not found for branch\");\n        }\n        return stateKey;\n    }\n\n    /**\n     * Whether this branch is active/valid.\n     */\n    public get isActive(): boolean {\n        return this.indexEvent.getContent()[\"active\"] === true;\n    }\n\n    /**\n     * Version for the file, one-indexed.\n     */\n    public get version(): number {\n        return this.indexEvent.getContent()[\"version\"] ?? 1;\n    }\n\n    private get roomId(): string {\n        return this.indexEvent.getRoomId()!;\n    }\n\n    /**\n     * Deletes the file from the tree, including all prior edits/versions.\n     * @returns Promise which resolves when complete.\n     */\n    public async delete(): Promise<void> {\n        await this.client.sendStateEvent(this.roomId, UNSTABLE_MSC3089_BRANCH.name, {}, this.id);\n        await this.client.redactEvent(this.roomId, this.id);\n\n        const nextVersion = (await this.getVersionHistory())[1]; // [0] will be us\n        if (nextVersion) await nextVersion.delete(); // implicit recursion\n    }\n\n    /**\n     * Gets the name for this file.\n     * @returns The name, or \"Unnamed File\" if unknown.\n     */\n    public getName(): string {\n        return this.indexEvent.getContent()[\"name\"] || \"Unnamed File\";\n    }\n\n    /**\n     * Sets the name for this file.\n     * @param name - The new name for this file.\n     * @returns Promise which resolves when complete.\n     */\n    public async setName(name: string): Promise<void> {\n        await this.client.sendStateEvent(\n            this.roomId,\n            UNSTABLE_MSC3089_BRANCH.name,\n            {\n                ...this.indexEvent.getContent(),\n                name: name,\n            },\n            this.id,\n        );\n    }\n\n    /**\n     * Gets whether or not a file is locked.\n     * @returns True if locked, false otherwise.\n     */\n    public isLocked(): boolean {\n        return this.indexEvent.getContent()[\"locked\"] || false;\n    }\n\n    /**\n     * Sets a file as locked or unlocked.\n     * @param locked - True to lock the file, false otherwise.\n     * @returns Promise which resolves when complete.\n     */\n    public async setLocked(locked: boolean): Promise<void> {\n        await this.client.sendStateEvent(\n            this.roomId,\n            UNSTABLE_MSC3089_BRANCH.name,\n            {\n                ...this.indexEvent.getContent(),\n                locked: locked,\n            },\n            this.id,\n        );\n    }\n\n    /**\n     * Gets information about the file needed to download it.\n     * @returns Information about the file.\n     */\n    public async getFileInfo(): Promise<{ info: EncryptedFile; httpUrl: string }> {\n        const event = await this.getFileEvent();\n\n        const file = event.getOriginalContent()[\"file\"];\n        const httpUrl = this.client.mxcUrlToHttp(file[\"url\"]);\n\n        if (!httpUrl) {\n            throw new Error(`No HTTP URL available for ${file[\"url\"]}`);\n        }\n\n        return { info: file, httpUrl: httpUrl };\n    }\n\n    /**\n     * Gets the event the file points to.\n     * @returns Promise which resolves to the file's event.\n     */\n    public async getFileEvent(): Promise<MatrixEvent> {\n        const room = this.client.getRoom(this.roomId);\n        if (!room) throw new Error(\"Unknown room\");\n\n        let event: MatrixEvent | undefined = room.getUnfilteredTimelineSet().findEventById(this.id);\n\n        // keep scrolling back if needed until we find the event or reach the start of the room:\n        while (!event && room.getLiveTimeline().getState(EventTimeline.BACKWARDS)!.paginationToken) {\n            await this.client.scrollback(room, 100);\n            event = room.getUnfilteredTimelineSet().findEventById(this.id);\n        }\n\n        if (!event) throw new Error(\"Failed to find event\");\n\n        // Sometimes the event isn't decrypted for us, so do that.\n        await this.client.decryptEventIfNeeded(event);\n\n        return event;\n    }\n\n    /**\n     * Creates a new version of this file with contents in a type that is compatible with MatrixClient.uploadContent().\n     * @param name - The name of the file.\n     * @param encryptedContents - The encrypted contents.\n     * @param info - The encrypted file information.\n     * @param additionalContent - Optional event content fields to include in the message.\n     * @returns Promise which resolves to the file event's sent response.\n     */\n    public async createNewVersion(\n        name: string,\n        encryptedContents: FileType,\n        info: EncryptedFile,\n        additionalContent?: IContent,\n    ): Promise<ISendEventResponse> {\n        const fileEventResponse = await this.directory.createFile(name, encryptedContents, info, {\n            ...(additionalContent ?? {}),\n            \"m.new_content\": true,\n            \"m.relates_to\": {\n                rel_type: RelationType.Replace,\n                event_id: this.id,\n            },\n        });\n\n        // Update the version of the new event\n        await this.client.sendStateEvent(\n            this.roomId,\n            UNSTABLE_MSC3089_BRANCH.name,\n            {\n                active: true,\n                name: name,\n                version: this.version + 1,\n            },\n            fileEventResponse[\"event_id\"],\n        );\n\n        // Deprecate ourselves\n        await this.client.sendStateEvent(\n            this.roomId,\n            UNSTABLE_MSC3089_BRANCH.name,\n            {\n                ...this.indexEvent.getContent(),\n                active: false,\n            },\n            this.id,\n        );\n\n        return fileEventResponse;\n    }\n\n    /**\n     * Gets the file's version history, starting at this file.\n     * @returns Promise which resolves to the file's version history, with the\n     * first element being the current version and the last element being the first version.\n     */\n    public async getVersionHistory(): Promise<MSC3089Branch[]> {\n        const fileHistory: MSC3089Branch[] = [];\n        fileHistory.push(this); // start with ourselves\n\n        const room = this.client.getRoom(this.roomId);\n        if (!room) throw new Error(\"Invalid or unknown room\");\n\n        // Clone the timeline to reverse it, getting most-recent-first ordering, hopefully\n        // shortening the awful loop below. Without the clone, we can unintentionally mutate\n        // the timeline.\n        const timelineEvents = [...room.getLiveTimeline().getEvents()].reverse();\n\n        // XXX: This is a very inefficient search, but it's the best we can do with the\n        // relations structure we have in the SDK. As of writing, it is not worth the\n        // investment in improving the structure.\n        let childEvent: MatrixEvent | undefined;\n        let parentEvent = await this.getFileEvent();\n        do {\n            childEvent = timelineEvents.find((e) => e.replacingEventId() === parentEvent.getId());\n            if (childEvent) {\n                const branch = this.directory.getFile(childEvent.getId()!);\n                if (branch) {\n                    fileHistory.push(branch);\n                    parentEvent = childEvent;\n                } else {\n                    break; // prevent infinite loop\n                }\n            }\n        } while (childEvent);\n\n        return fileHistory;\n    }\n}\n","/*\nCopyright 2021 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport promiseRetry from \"p-retry\";\n\nimport { type MatrixClient } from \"../client.ts\";\nimport { EventType, MsgType, UNSTABLE_MSC3089_BRANCH, UNSTABLE_MSC3089_LEAF } from \"../@types/event.ts\";\nimport { type Room } from \"./room.ts\";\nimport { logger } from \"../logger.ts\";\nimport { type IContent, type MatrixEvent } from \"./event.ts\";\nimport {\n    averageBetweenStrings,\n    DEFAULT_ALPHABET,\n    lexicographicCompare,\n    nextString,\n    prevString,\n    simpleRetryOperation,\n} from \"../utils.ts\";\nimport { MSC3089Branch } from \"./MSC3089Branch.ts\";\nimport { type ISendEventResponse } from \"../@types/requests.ts\";\nimport { type FileType } from \"../http-api/index.ts\";\nimport { KnownMembership } from \"../@types/membership.ts\";\nimport { type RoomPowerLevelsEventContent, type SpaceChildEventContent } from \"../@types/state_events.ts\";\nimport type { EncryptedFile, FileContent } from \"../@types/media.ts\";\nimport { type EmptyObject } from \"../@types/common.ts\";\n\n/**\n * The recommended defaults for a tree space's power levels. Note that this\n * is UNSTABLE and subject to breaking changes without notice.\n */\nexport const DEFAULT_TREE_POWER_LEVELS_TEMPLATE = {\n    // Owner\n    invite: 100,\n    kick: 100,\n    ban: 100,\n\n    // Editor\n    redact: 50,\n    state_default: 50,\n    events_default: 50,\n\n    // Viewer\n    users_default: 0,\n\n    // Mixed\n    events: {\n        [EventType.RoomPowerLevels]: 100,\n        [EventType.RoomHistoryVisibility]: 100,\n        [EventType.RoomTombstone]: 100,\n        [EventType.RoomEncryption]: 100,\n        [EventType.RoomName]: 50,\n        [EventType.RoomMessage]: 50,\n        [EventType.RoomMessageEncrypted]: 50,\n        [EventType.Sticker]: 50,\n    },\n\n    users: {}, // defined by calling code\n};\n\n/**\n * Ease-of-use representation for power levels represented as simple roles.\n * Note that this is UNSTABLE and subject to breaking changes without notice.\n */\nexport enum TreePermissions {\n    Viewer = \"viewer\", // Default\n    Editor = \"editor\", // \"Moderator\" or ~PL50\n    Owner = \"owner\", // \"Admin\" or PL100\n}\n\ndeclare module \"../@types/media\" {\n    interface FileContent {\n        [UNSTABLE_MSC3089_LEAF.name]?: EmptyObject;\n    }\n}\n\n/**\n * Represents a [MSC3089](https://github.com/matrix-org/matrix-doc/pull/3089)\n * file tree Space. Note that this is UNSTABLE and subject to breaking changes\n * without notice.\n */\nexport class MSC3089TreeSpace {\n    public readonly room: Room;\n\n    public constructor(\n        private client: MatrixClient,\n        public readonly roomId: string,\n    ) {\n        this.room = this.client.getRoom(this.roomId)!;\n\n        if (!this.room) throw new Error(\"Unknown room\");\n    }\n\n    /**\n     * Syntactic sugar for room ID of the Space.\n     */\n    public get id(): string {\n        return this.roomId;\n    }\n\n    /**\n     * Whether or not this is a top level space.\n     */\n    public get isTopLevel(): boolean {\n        // XXX: This is absolutely not how you find out if the space is top level\n        // but is safe for a managed usecase like we offer in the SDK.\n        const parentEvents = this.room.currentState.getStateEvents(EventType.SpaceParent);\n        if (!parentEvents?.length) return true;\n        return parentEvents.every((e) => !e.getContent()?.[\"via\"]);\n    }\n\n    /**\n     * Sets the name of the tree space.\n     * @param name - The new name for the space.\n     * @returns Promise which resolves when complete.\n     */\n    public async setName(name: string): Promise<void> {\n        await this.client.sendStateEvent(this.roomId, EventType.RoomName, { name }, \"\");\n    }\n\n    /**\n     * Invites a user to the tree space. They will be given the default Viewer\n     * permission level unless specified elsewhere.\n     * @param userId - The user ID to invite.\n     * @param andSubspaces - True (default) to invite the user to all\n     * directories/subspaces too, recursively.\n     * @returns Promise which resolves when complete.\n     */\n    public async invite(userId: string, andSubspaces = true): Promise<void> {\n        const promises: Promise<void>[] = [this.retryInvite(userId)];\n        if (andSubspaces) {\n            promises.push(...this.getDirectories().map((d) => d.invite(userId, andSubspaces)));\n        }\n        await Promise.all(promises);\n    }\n\n    private retryInvite(userId: string): Promise<void> {\n        return simpleRetryOperation(async () => {\n            await this.client.invite(this.roomId, userId).catch((e) => {\n                // We don't want to retry permission errors forever...\n                if (e?.errcode === \"M_FORBIDDEN\") {\n                    throw new promiseRetry.AbortError(e);\n                }\n                throw e;\n            });\n        });\n    }\n\n    /**\n     * Sets the permissions of a user to the given role. Note that if setting a user\n     * to Owner then they will NOT be able to be demoted. If the user does not have\n     * permission to change the power level of the target, an error will be thrown.\n     * @param userId - The user ID to change the role of.\n     * @param role - The role to assign.\n     * @returns Promise which resolves when complete.\n     */\n    public async setPermissions(userId: string, role: TreePermissions): Promise<void> {\n        const currentPls = this.room.currentState.getStateEvents(EventType.RoomPowerLevels, \"\");\n        if (Array.isArray(currentPls)) throw new Error(\"Unexpected return type for power levels\");\n\n        const pls = currentPls?.getContent<RoomPowerLevelsEventContent>() || {};\n        const viewLevel = pls[\"users_default\"] || 0;\n        const editLevel = pls[\"events_default\"] || 50;\n        const adminLevel = pls[\"events\"]?.[EventType.RoomPowerLevels] || 100;\n\n        const users = pls[\"users\"] || {};\n        switch (role) {\n            case TreePermissions.Viewer:\n                users[userId] = viewLevel;\n                break;\n            case TreePermissions.Editor:\n                users[userId] = editLevel;\n                break;\n            case TreePermissions.Owner:\n                users[userId] = adminLevel;\n                break;\n            default:\n                throw new Error(\"Invalid role: \" + role);\n        }\n        pls[\"users\"] = users;\n\n        await this.client.sendStateEvent(this.roomId, EventType.RoomPowerLevels, pls, \"\");\n    }\n\n    /**\n     * Gets the current permissions of a user. Note that any users missing explicit permissions (or not\n     * in the space) will be considered Viewers. Appropriate membership checks need to be performed\n     * elsewhere.\n     * @param userId - The user ID to check permissions of.\n     * @returns The permissions for the user, defaulting to Viewer.\n     */\n    public getPermissions(userId: string): TreePermissions {\n        const currentPls = this.room.currentState.getStateEvents(EventType.RoomPowerLevels, \"\");\n        if (Array.isArray(currentPls)) throw new Error(\"Unexpected return type for power levels\");\n\n        const pls = currentPls?.getContent() || {};\n        const viewLevel = pls[\"users_default\"] || 0;\n        const editLevel = pls[\"events_default\"] || 50;\n        const adminLevel = pls[\"events\"]?.[EventType.RoomPowerLevels] || 100;\n\n        const userLevel = pls[\"users\"]?.[userId] || viewLevel;\n        if (userLevel >= adminLevel) return TreePermissions.Owner;\n        if (userLevel >= editLevel) return TreePermissions.Editor;\n        return TreePermissions.Viewer;\n    }\n\n    /**\n     * Creates a directory under this tree space, represented as another tree space.\n     * @param name - The name for the directory.\n     * @returns Promise which resolves to the created directory.\n     */\n    public async createDirectory(name: string): Promise<MSC3089TreeSpace> {\n        const directory = await this.client.unstableCreateFileTree(name);\n\n        await this.client.sendStateEvent(\n            this.roomId,\n            EventType.SpaceChild,\n            {\n                via: [this.client.getDomain()!],\n            },\n            directory.roomId,\n        );\n\n        await this.client.sendStateEvent(\n            directory.roomId,\n            EventType.SpaceParent,\n            {\n                via: [this.client.getDomain()!],\n            },\n            this.roomId,\n        );\n\n        return directory;\n    }\n\n    /**\n     * Gets a list of all known immediate subdirectories to this tree space.\n     * @returns The tree spaces (directories). May be empty, but not null.\n     */\n    public getDirectories(): MSC3089TreeSpace[] {\n        const trees: MSC3089TreeSpace[] = [];\n        const children = this.room.currentState.getStateEvents(EventType.SpaceChild);\n        for (const child of children) {\n            try {\n                const stateKey = child.getStateKey();\n                if (stateKey) {\n                    const tree = this.client.unstableGetFileTreeSpace(stateKey);\n                    if (tree) trees.push(tree);\n                }\n            } catch (e) {\n                logger.warn(\"Unable to create tree space instance for listing. Are we joined?\", e);\n            }\n        }\n        return trees;\n    }\n\n    /**\n     * Gets a subdirectory of a given ID under this tree space. Note that this will not recurse\n     * into children and instead only look one level deep.\n     * @param roomId - The room ID (directory ID) to find.\n     * @returns The directory, or undefined if not found.\n     */\n    public getDirectory(roomId: string): MSC3089TreeSpace | undefined {\n        return this.getDirectories().find((r) => r.roomId === roomId);\n    }\n\n    /**\n     * Deletes the tree, kicking all members and deleting **all subdirectories**.\n     * @returns Promise which resolves when complete.\n     */\n    public async delete(): Promise<void> {\n        const subdirectories = this.getDirectories();\n        for (const dir of subdirectories) {\n            await dir.delete();\n        }\n\n        const kickMemberships = [KnownMembership.Invite, KnownMembership.Knock, KnownMembership.Join];\n        const members = this.room.currentState.getStateEvents(EventType.RoomMember);\n        for (const member of members) {\n            const isNotUs = member.getStateKey() !== this.client.getUserId();\n            if (isNotUs && kickMemberships.includes(member.getContent().membership! as KnownMembership)) {\n                const stateKey = member.getStateKey();\n                if (!stateKey) {\n                    throw new Error(\"State key not found for branch\");\n                }\n                await this.client.kick(this.roomId, stateKey, \"Room deleted\");\n            }\n        }\n\n        await this.client.leave(this.roomId);\n    }\n\n    private getOrderedChildren(children: MatrixEvent[]): { roomId: string; order: string }[] {\n        const ordered: { roomId: string; order: string }[] = children\n            .map((c) => ({ roomId: c.getStateKey(), order: c.getContent()[\"order\"] }))\n            .filter((c) => c.roomId) as { roomId: string; order: string }[];\n        ordered.sort((a, b) => {\n            if (a.order && !b.order) {\n                return -1;\n            } else if (!a.order && b.order) {\n                return 1;\n            } else if (!a.order && !b.order) {\n                const roomA = this.client.getRoom(a.roomId);\n                const roomB = this.client.getRoom(b.roomId);\n                if (!roomA || !roomB) {\n                    // just don't bother trying to do more partial sorting\n                    return lexicographicCompare(a.roomId, b.roomId);\n                }\n\n                const createTsA = roomA.currentState.getStateEvents(EventType.RoomCreate, \"\")?.getTs() ?? 0;\n                const createTsB = roomB.currentState.getStateEvents(EventType.RoomCreate, \"\")?.getTs() ?? 0;\n                if (createTsA === createTsB) {\n                    return lexicographicCompare(a.roomId, b.roomId);\n                }\n                return createTsA - createTsB;\n            } else {\n                // both not-null orders\n                return lexicographicCompare(a.order, b.order);\n            }\n        });\n        return ordered;\n    }\n\n    private getParentRoom(): Room {\n        const parents = this.room.currentState.getStateEvents(EventType.SpaceParent);\n        const parent = parents[0]; // XXX: Wild assumption\n        if (!parent) throw new Error(\"Expected to have a parent in a non-top level space\");\n\n        // XXX: We are assuming the parent is a valid tree space.\n        // We probably don't need to validate the parent room state for this usecase though.\n        const stateKey = parent.getStateKey();\n        if (!stateKey) throw new Error(\"No state key found for parent\");\n        const parentRoom = this.client.getRoom(stateKey);\n        if (!parentRoom) throw new Error(\"Unable to locate room for parent\");\n\n        return parentRoom;\n    }\n\n    /**\n     * Gets the current order index for this directory. Note that if this is the top level space\n     * then -1 will be returned.\n     * @returns The order index of this space.\n     */\n    public getOrder(): number {\n        if (this.isTopLevel) return -1;\n\n        const parentRoom = this.getParentRoom();\n        const children = parentRoom.currentState.getStateEvents(EventType.SpaceChild);\n        const ordered = this.getOrderedChildren(children);\n\n        return ordered.findIndex((c) => c.roomId === this.roomId);\n    }\n\n    /**\n     * Sets the order index for this directory within its parent. Note that if this is a top level\n     * space then an error will be thrown. -1 can be used to move the child to the start, and numbers\n     * larger than the number of children can be used to move the child to the end.\n     * @param index - The new order index for this space.\n     * @returns Promise which resolves when complete.\n     * @throws Throws if this is a top level space.\n     */\n    public async setOrder(index: number): Promise<void> {\n        if (this.isTopLevel) throw new Error(\"Cannot set order of top level spaces currently\");\n\n        const parentRoom = this.getParentRoom();\n        const children = parentRoom.currentState.getStateEvents(EventType.SpaceChild);\n        const ordered = this.getOrderedChildren(children);\n        index = Math.max(Math.min(index, ordered.length - 1), 0);\n\n        const currentIndex = this.getOrder();\n        const movingUp = currentIndex < index;\n        if (movingUp && index === ordered.length - 1) {\n            index--;\n        } else if (!movingUp && index === 0) {\n            index++;\n        }\n\n        const prev = ordered[movingUp ? index : index - 1];\n        const next = ordered[movingUp ? index + 1 : index];\n\n        let newOrder = DEFAULT_ALPHABET[0];\n        let ensureBeforeIsSane = false;\n        if (!prev) {\n            // Move to front\n            if (next?.order) {\n                newOrder = prevString(next.order);\n            }\n        } else if (index === ordered.length - 1) {\n            // Move to back\n            if (next?.order) {\n                newOrder = nextString(next.order);\n            }\n        } else {\n            // Move somewhere in the middle\n            const startOrder = prev?.order;\n            const endOrder = next?.order;\n            if (startOrder && endOrder) {\n                if (startOrder === endOrder) {\n                    // Error case: just move +1 to break out of awful math\n                    newOrder = nextString(startOrder);\n                } else {\n                    newOrder = averageBetweenStrings(startOrder, endOrder);\n                }\n            } else {\n                if (startOrder) {\n                    // We're at the end (endOrder is null, so no explicit order)\n                    newOrder = nextString(startOrder);\n                } else if (endOrder) {\n                    // We're at the start (startOrder is null, so nothing before us)\n                    newOrder = prevString(endOrder);\n                } else {\n                    // Both points are unknown. We're likely in a range where all the children\n                    // don't have particular order values, so we may need to update them too.\n                    // The other possibility is there's only us as a child, but we should have\n                    // shown up in the other states.\n                    ensureBeforeIsSane = true;\n                }\n            }\n        }\n\n        if (ensureBeforeIsSane) {\n            // We were asked by the order algorithm to prepare the moving space for a landing\n            // in the undefined order part of the order array, which means we need to update the\n            // spaces that come before it with a stable order value.\n            let lastOrder: string | undefined;\n            for (let i = 0; i <= index; i++) {\n                const target = ordered[i];\n                if (i === 0) {\n                    lastOrder = target.order;\n                }\n                if (!target.order) {\n                    // XXX: We should be creating gaps to avoid conflicts\n                    lastOrder = lastOrder ? nextString(lastOrder) : DEFAULT_ALPHABET[0];\n                    const currentChild = parentRoom.currentState.getStateEvents(EventType.SpaceChild, target.roomId);\n                    const content = currentChild?.getContent<SpaceChildEventContent>() ?? {\n                        via: [this.client.getDomain()!],\n                    };\n                    await this.client.sendStateEvent(\n                        parentRoom.roomId,\n                        EventType.SpaceChild,\n                        {\n                            ...content,\n                            order: lastOrder,\n                        },\n                        target.roomId,\n                    );\n                } else {\n                    lastOrder = target.order;\n                }\n            }\n            if (lastOrder) {\n                newOrder = nextString(lastOrder);\n            }\n        }\n\n        // TODO: Deal with order conflicts by reordering\n\n        // Now we can finally update our own order state\n        const currentChild = parentRoom.currentState.getStateEvents(EventType.SpaceChild, this.roomId);\n        const content = currentChild?.getContent<SpaceChildEventContent>() ?? { via: [this.client.getDomain()!] };\n        await this.client.sendStateEvent(\n            parentRoom.roomId,\n            EventType.SpaceChild,\n            {\n                ...content,\n\n                // TODO: Safely constrain to 50 character limit required by spaces.\n                order: newOrder,\n            },\n            this.roomId,\n        );\n    }\n\n    /**\n     * Creates (uploads) a new file to this tree. The file must have already been encrypted for the room.\n     * The file contents are in a type that is compatible with MatrixClient.uploadContent().\n     * @param name - The name of the file.\n     * @param encryptedContents - The encrypted contents.\n     * @param info - The encrypted file information.\n     * @param additionalContent - Optional event content fields to include in the message.\n     * @returns Promise which resolves to the file event's sent response.\n     */\n    public async createFile(\n        name: string,\n        encryptedContents: FileType,\n        info: EncryptedFile,\n        additionalContent?: IContent,\n    ): Promise<ISendEventResponse> {\n        const { content_uri: mxc } = await this.client.uploadContent(encryptedContents, {\n            includeFilename: false,\n        });\n        info.url = mxc;\n\n        const fileContent: FileContent = {\n            msgtype: MsgType.File,\n            body: name,\n            url: mxc,\n            file: info,\n        };\n\n        additionalContent = additionalContent ?? {};\n        if (additionalContent[\"m.new_content\"]) {\n            // We do the right thing according to the spec, but due to how relations are\n            // handled we also end up duplicating this information to the regular `content`\n            // as well.\n            additionalContent[\"m.new_content\"] = fileContent;\n        }\n\n        const res = await this.client.sendMessage(this.roomId, {\n            ...additionalContent,\n            ...fileContent,\n            [UNSTABLE_MSC3089_LEAF.name]: {},\n        } as FileContent);\n\n        await this.client.sendStateEvent(\n            this.roomId,\n            UNSTABLE_MSC3089_BRANCH.name,\n            {\n                active: true,\n                name: name,\n            },\n            res[\"event_id\"],\n        );\n\n        return res;\n    }\n\n    /**\n     * Retrieves a file from the tree.\n     * @param fileEventId - The event ID of the file.\n     * @returns The file, or null if not found.\n     */\n    public getFile(fileEventId: string): MSC3089Branch | null {\n        const branch = this.room.currentState.getStateEvents(UNSTABLE_MSC3089_BRANCH.name, fileEventId);\n        return branch ? new MSC3089Branch(this.client, branch, this) : null;\n    }\n\n    /**\n     * Gets an array of all known files for the tree.\n     * @returns The known files. May be empty, but not null.\n     */\n    public listFiles(): MSC3089Branch[] {\n        return this.listAllFiles().filter((b) => b.isActive);\n    }\n\n    /**\n     * Gets an array of all known files for the tree, including inactive/invalid ones.\n     * @returns The known files. May be empty, but not null.\n     */\n    public listAllFiles(): MSC3089Branch[] {\n        const branches = this.room.currentState.getStateEvents(UNSTABLE_MSC3089_BRANCH.name) ?? [];\n        return branches.map((e) => new MSC3089Branch(this.client, e, this));\n    }\n}\n","/*\nCopyright 2022 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { ToDeviceMessageId } from \"./@types/event.ts\";\nimport { logger } from \"./logger.ts\";\nimport { type MatrixClient, ClientEvent } from \"./client.ts\";\nimport { type MatrixError } from \"./http-api/index.ts\";\nimport {\n    type IndexedToDeviceBatch,\n    type ToDeviceBatch,\n    type ToDeviceBatchWithTxnId,\n    type ToDevicePayload,\n} from \"./models/ToDeviceMessage.ts\";\nimport { MatrixScheduler } from \"./scheduler.ts\";\nimport { SyncState } from \"./sync.ts\";\nimport { MapWithDefault } from \"./utils.ts\";\n\nconst MAX_BATCH_SIZE = 20;\n\n/**\n * Maintains a queue of outgoing to-device messages, sending them\n * as soon as the homeserver is reachable.\n */\nexport class ToDeviceMessageQueue {\n    private sending = false;\n    private running = true;\n    private retryTimeout: ReturnType<typeof setTimeout> | null = null;\n    private retryAttempts = 0;\n\n    public constructor(private client: MatrixClient) {}\n\n    public start(): void {\n        this.running = true;\n        this.sendQueue();\n        this.client.on(ClientEvent.Sync, this.onResumedSync);\n    }\n\n    public stop(): void {\n        this.running = false;\n        if (this.retryTimeout !== null) clearTimeout(this.retryTimeout);\n        this.retryTimeout = null;\n        this.client.removeListener(ClientEvent.Sync, this.onResumedSync);\n    }\n\n    public async queueBatch(batch: ToDeviceBatch): Promise<void> {\n        const batches: ToDeviceBatchWithTxnId[] = [];\n        for (let i = 0; i < batch.batch.length; i += MAX_BATCH_SIZE) {\n            const batchWithTxnId = {\n                eventType: batch.eventType,\n                batch: batch.batch.slice(i, i + MAX_BATCH_SIZE),\n                txnId: this.client.makeTxnId(),\n            };\n            batches.push(batchWithTxnId);\n            const msgmap = batchWithTxnId.batch.map(\n                (msg) => `${msg.userId}/${msg.deviceId} (msgid ${msg.payload[ToDeviceMessageId]})`,\n            );\n            logger.info(\n                `Enqueuing batch of to-device messages. type=${batch.eventType} txnid=${batchWithTxnId.txnId}`,\n                msgmap,\n            );\n        }\n\n        await this.client.store.saveToDeviceBatches(batches);\n        this.sendQueue();\n    }\n\n    public sendQueue = async (): Promise<void> => {\n        if (this.retryTimeout !== null) clearTimeout(this.retryTimeout);\n        this.retryTimeout = null;\n\n        if (this.sending || !this.running) return;\n\n        logger.debug(\"Attempting to send queued to-device messages\");\n\n        this.sending = true;\n        let headBatch: IndexedToDeviceBatch | null;\n        try {\n            while (this.running) {\n                headBatch = await this.client.store.getOldestToDeviceBatch();\n                if (headBatch === null) break;\n                await this.sendBatch(headBatch);\n                await this.client.store.removeToDeviceBatch(headBatch.id);\n                this.retryAttempts = 0;\n            }\n\n            // Make sure we're still running after the async tasks: if not, stop.\n            if (!this.running) return;\n\n            logger.debug(\"All queued to-device messages sent\");\n        } catch (e) {\n            ++this.retryAttempts;\n            // eslint-disable-next-line @typescript-eslint/naming-convention\n            // eslint-disable-next-line new-cap\n            const retryDelay = MatrixScheduler.RETRY_BACKOFF_RATELIMIT(null, this.retryAttempts, <MatrixError>e);\n            if (retryDelay === -1) {\n                // the scheduler function doesn't differentiate between fatal errors and just getting\n                // bored and giving up for now\n                if (Math.floor((<MatrixError>e).httpStatus! / 100) === 4) {\n                    logger.error(\"Fatal error when sending to-device message - dropping to-device batch!\", e);\n                    await this.client.store.removeToDeviceBatch(headBatch!.id);\n                } else {\n                    logger.info(\"Automatic retry limit reached for to-device messages.\");\n                }\n                return;\n            }\n\n            logger.info(`Failed to send batch of to-device messages. Will retry in ${retryDelay}ms`, e);\n            this.retryTimeout = setTimeout(this.sendQueue, retryDelay);\n        } finally {\n            this.sending = false;\n        }\n    };\n\n    /**\n     * Attempts to send a batch of to-device messages.\n     */\n    private async sendBatch(batch: IndexedToDeviceBatch): Promise<void> {\n        const contentMap: MapWithDefault<string, Map<string, ToDevicePayload>> = new MapWithDefault(() => new Map());\n        for (const item of batch.batch) {\n            contentMap.getOrCreate(item.userId).set(item.deviceId, item.payload);\n        }\n\n        logger.info(\n            `Sending batch of ${batch.batch.length} to-device messages with ID ${batch.id} and txnId ${batch.txnId}`,\n        );\n\n        await this.client.sendToDevice(batch.eventType, contentMap, batch.txnId);\n    }\n\n    /**\n     * Listen to sync state changes and automatically resend any pending events\n     * once syncing is resumed\n     */\n    private onResumedSync = (state: SyncState | null, oldState: SyncState | null): void => {\n        if (state === SyncState.Syncing && oldState !== SyncState.Syncing) {\n            logger.info(`Resuming queue after resumed sync`);\n            this.sendQueue();\n        }\n    };\n}\n","/*\nCopyright 2022 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\n/** The prefix used on indexeddbs created by rust-crypto */\nexport const RUST_SDK_STORE_PREFIX = \"matrix-js-sdk\";\n","/*\nCopyright 2023 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { THREAD_RELATION_TYPE } from \"./models/thread.ts\";\nimport { type IEvent } from \"./models/event.ts\";\n\n/**\n * Returns a filter function for the /relations endpoint to filter out relations directly\n * to the thread root event that should not live in the thread timeline\n *\n * @param threadId - the thread ID (ie. the event ID of the root event of the thread)\n * @returns the filtered list of events\n */\nexport function getRelationsThreadFilter(threadId: string): (e: Partial<IEvent>) => boolean {\n    return (e: Partial<IEvent>) =>\n        e.content?.[\"m.relates_to\"]?.event_id !== threadId ||\n        e.content?.[\"m.relates_to\"]?.rel_type === THREAD_RELATION_TYPE.name;\n}\n","/*\nCopyright 2015-2023 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\n/**\n * This is an internal module. See {@link MatrixClient} for the public class.\n */\n\nimport { type Optional } from \"matrix-events-sdk\";\n\nimport type { IDeviceKeys, IOneTimeKey } from \"./@types/crypto.ts\";\nimport { type ISyncStateData, type SetPresence, SyncApi, type SyncApiOptions, SyncState } from \"./sync.ts\";\nimport {\n    EventStatus,\n    type IContent,\n    type IDecryptOptions,\n    type IEvent,\n    MatrixEvent,\n    MatrixEventEvent,\n    type MatrixEventHandlerMap,\n    type PushDetails,\n} from \"./models/event.ts\";\nimport { StubStore } from \"./store/stub.ts\";\nimport {\n    type CallEvent,\n    type CallEventHandlerMap,\n    createNewMatrixCall,\n    type MatrixCall,\n    supportsMatrixCall,\n} from \"./webrtc/call.ts\";\nimport { Filter, type IFilterDefinition, type IRoomEventFilter } from \"./filter.ts\";\nimport {\n    CallEventHandler,\n    type CallEventHandlerEvent,\n    type CallEventHandlerEventHandlerMap,\n} from \"./webrtc/callEventHandler.ts\";\nimport {\n    GroupCallEventHandler,\n    type GroupCallEventHandlerEvent,\n    type GroupCallEventHandlerEventHandlerMap,\n} from \"./webrtc/groupCallEventHandler.ts\";\nimport * as utils from \"./utils.ts\";\nimport { deepCompare, defer, noUnsafeEventProps, type QueryDict, replaceParam, safeSet, sleep } from \"./utils.ts\";\nimport { Direction, EventTimeline } from \"./models/event-timeline.ts\";\nimport { type IActionsObject, PushProcessor } from \"./pushprocessor.ts\";\nimport { AutoDiscovery, type AutoDiscoveryAction } from \"./autodiscovery.ts\";\nimport { encodeUnpaddedBase64Url } from \"./base64.ts\";\nimport { TypedReEmitter } from \"./ReEmitter.ts\";\nimport { logger, type Logger } from \"./logger.ts\";\nimport { SERVICE_TYPES } from \"./service-types.ts\";\nimport {\n    type Body,\n    ClientPrefix,\n    type FileType,\n    type HttpApiEvent,\n    type HttpApiEventHandlerMap,\n    type HTTPError,\n    IdentityPrefix,\n    type IHttpOpts,\n    type IRequestOpts,\n    MatrixError,\n    MatrixHttpApi,\n    MediaPrefix,\n    Method,\n    retryNetworkOperation,\n    type TokenRefreshFunction,\n    type Upload,\n    type UploadOpts,\n    type UploadResponse,\n} from \"./http-api/index.ts\";\nimport { User, UserEvent, type UserEventHandlerMap } from \"./models/user.ts\";\nimport { getHttpUriForMxc } from \"./content-repo.ts\";\nimport { SearchResult } from \"./models/search-result.ts\";\nimport { type IIdentityServerProvider } from \"./@types/IIdentityServerProvider.ts\";\nimport { type MatrixScheduler } from \"./scheduler.ts\";\nimport { type BeaconEvent, type BeaconEventHandlerMap } from \"./models/beacon.ts\";\nimport { type AuthDict } from \"./interactive-auth.ts\";\nimport { type IMinimalEvent, type IRoomEvent, type IStateEvent } from \"./sync-accumulator.ts\";\nimport type { EventTimelineSet } from \"./models/event-timeline-set.ts\";\nimport * as ContentHelpers from \"./content-helpers.ts\";\nimport {\n    NotificationCountType,\n    type Room,\n    type RoomEvent,\n    type RoomEventHandlerMap,\n    type RoomNameState,\n} from \"./models/room.ts\";\nimport { RoomMemberEvent, type RoomMemberEventHandlerMap } from \"./models/room-member.ts\";\nimport { type IPowerLevelsContent, type RoomStateEvent, type RoomStateEventHandlerMap } from \"./models/room-state.ts\";\nimport {\n    type DelayedEventInfo,\n    type IAddThreePidOnlyBody,\n    type IBindThreePidBody,\n    type IContextResponse,\n    type ICreateRoomOpts,\n    type IEventSearchOpts,\n    type IFilterResponse,\n    type IGuestAccessOpts,\n    type IJoinRoomOpts,\n    type INotificationsResponse,\n    type IPaginateOpts,\n    type IPresenceOpts,\n    type IRedactOpts,\n    type IRelationsRequestOpts,\n    type IRelationsResponse,\n    type IRoomDirectoryOptions,\n    type ISearchOpts,\n    type ISendEventResponse,\n    type IStatusResponse,\n    type ITagsResponse,\n    type KnockRoomOpts,\n    type SendDelayedEventRequestOpts,\n    type SendDelayedEventResponse,\n    type UpdateDelayedEventAction,\n} from \"./@types/requests.ts\";\nimport {\n    type AccountDataEvents,\n    EventType,\n    LOCAL_NOTIFICATION_SETTINGS_PREFIX,\n    MSC3912_RELATION_BASED_REDACTIONS_PROP,\n    MsgType,\n    PUSHER_ENABLED,\n    RelationType,\n    RoomCreateTypeField,\n    RoomType,\n    type StateEvents,\n    type TimelineEvents,\n    UNSTABLE_MSC3088_ENABLED,\n    UNSTABLE_MSC3088_PURPOSE,\n    UNSTABLE_MSC3089_TREE_SUBTYPE,\n} from \"./@types/event.ts\";\nimport {\n    GuestAccess,\n    HistoryVisibility,\n    type IdServerUnbindResult,\n    type JoinRule,\n    Preset,\n    type Terms,\n    type Visibility,\n} from \"./@types/partials.ts\";\nimport { type EventMapper, eventMapperFor, type MapperOpts } from \"./event-mapper.ts\";\nimport { secureRandomString } from \"./randomstring.ts\";\nimport { DEFAULT_TREE_POWER_LEVELS_TEMPLATE, MSC3089TreeSpace } from \"./models/MSC3089TreeSpace.ts\";\nimport { type ISignatures } from \"./@types/signed.ts\";\nimport { type IStore } from \"./store/index.ts\";\nimport {\n    type IEventWithRoomId,\n    type ISearchRequestBody,\n    type ISearchResponse,\n    type ISearchResults,\n    type IStateEventWithRoomId,\n    SearchOrderBy,\n} from \"./@types/search.ts\";\nimport { type ISynapseAdminDeactivateResponse, type ISynapseAdminWhoisResponse } from \"./@types/synapse.ts\";\nimport { type IHierarchyRoom } from \"./@types/spaces.ts\";\nimport {\n    type IPusher,\n    type IPusherRequest,\n    type IPushRule,\n    type IPushRules,\n    type PushRuleAction,\n    PushRuleActionName,\n    PushRuleKind,\n    type RuleId,\n} from \"./@types/PushRules.ts\";\nimport { type IThreepid } from \"./@types/threepids.ts\";\nimport { type CryptoStore } from \"./crypto/store/base.ts\";\nimport {\n    GroupCall,\n    type GroupCallIntent,\n    type GroupCallType,\n    type IGroupCallDataChannelOptions,\n} from \"./webrtc/groupCall.ts\";\nimport { MediaHandler } from \"./webrtc/mediaHandler.ts\";\nimport {\n    type ILoginFlowsResponse,\n    type IRefreshTokenResponse,\n    type LoginRequest,\n    type LoginResponse,\n    type LoginTokenPostResponse,\n    type SSOAction,\n} from \"./@types/auth.ts\";\nimport { TypedEventEmitter } from \"./models/typed-event-emitter.ts\";\nimport { MAIN_ROOM_TIMELINE, ReceiptType } from \"./@types/read_receipts.ts\";\nimport { type MSC3575SlidingSyncRequest, type MSC3575SlidingSyncResponse, type SlidingSync } from \"./sliding-sync.ts\";\nimport { SlidingSyncSdk } from \"./sliding-sync-sdk.ts\";\nimport {\n    determineFeatureSupport,\n    FeatureSupport,\n    Thread,\n    THREAD_RELATION_TYPE,\n    ThreadFilterType,\n    threadFilterTypeToFilter,\n} from \"./models/thread.ts\";\nimport { M_BEACON_INFO, type MBeaconInfoEventContent } from \"./@types/beacon.ts\";\nimport { NamespacedValue, UnstableValue } from \"./NamespacedValue.ts\";\nimport { ToDeviceMessageQueue } from \"./ToDeviceMessageQueue.ts\";\nimport { type ToDeviceBatch } from \"./models/ToDeviceMessage.ts\";\nimport { IgnoredInvites } from \"./models/invites-ignorer.ts\";\nimport { type UIARequest } from \"./@types/uia.ts\";\nimport { type LocalNotificationSettings } from \"./@types/local_notifications.ts\";\nimport { buildFeatureSupportMap, Feature, ServerSupport } from \"./feature.ts\";\nimport { type CryptoBackend } from \"./common-crypto/CryptoBackend.ts\";\nimport { RUST_SDK_STORE_PREFIX } from \"./rust-crypto/constants.ts\";\nimport {\n    type CrossSigningKeyInfo,\n    type CryptoApi,\n    CryptoEvent,\n    type CryptoEventHandlerMap,\n    type CryptoCallbacks,\n} from \"./crypto-api/index.ts\";\nimport {\n    type SecretStorageKeyDescription,\n    type ServerSideSecretStorage,\n    ServerSideSecretStorageImpl,\n} from \"./secret-storage.ts\";\nimport { type RegisterRequest, type RegisterResponse } from \"./@types/registration.ts\";\nimport { MatrixRTCSessionManager } from \"./matrixrtc/MatrixRTCSessionManager.ts\";\nimport { getRelationsThreadFilter } from \"./thread-utils.ts\";\nimport { KnownMembership, type Membership } from \"./@types/membership.ts\";\nimport { type RoomMessageEventContent, type StickerEventContent } from \"./@types/events.ts\";\nimport { type ImageInfo } from \"./@types/media.ts\";\nimport { type Capabilities, ServerCapabilities } from \"./serverCapabilities.ts\";\nimport { sha256 } from \"./digest.ts\";\nimport {\n    discoverAndValidateOIDCIssuerWellKnown,\n    type OidcClientConfig,\n    validateAuthMetadataAndKeys,\n} from \"./oidc/index.ts\";\nimport { type EmptyObject } from \"./@types/common.ts\";\nimport { UnsupportedDelayedEventsEndpointError } from \"./errors.ts\";\n\nexport type Store = IStore;\n\nexport type ResetTimelineCallback = (roomId: string) => boolean;\n\nconst SCROLLBACK_DELAY_MS = 3000;\n\nconst TURN_CHECK_INTERVAL = 10 * 60 * 1000; // poll for turn credentials every 10 minutes\n\nexport const UNSTABLE_MSC3852_LAST_SEEN_UA = new UnstableValue(\n    \"last_seen_user_agent\",\n    \"org.matrix.msc3852.last_seen_user_agent\",\n);\n\nexport interface IKeysUploadResponse {\n    one_time_key_counts: {\n        // eslint-disable-line camelcase\n        [algorithm: string]: number;\n    };\n}\n\nexport interface ICreateClientOpts {\n    baseUrl: string;\n\n    idBaseUrl?: string;\n\n    /**\n     * The data store used for sync data from the homeserver. If not specified,\n     * this client will not store any HTTP responses. The `createClient` helper\n     * will create a default store if needed.\n     */\n    store?: Store;\n\n    /**\n     * A store to be used for end-to-end crypto session data.\n     * The `createClient` helper will create a default store if needed. Calls the factory supplied to\n     * {@link setCryptoStoreFactory} if unspecified; or if no factory has been\n     * specified, uses a default implementation (indexeddb in the browser,\n     * in-memory otherwise).\n     *\n     * This is only used for the legacy crypto implementation,\n     * but if you use the rust crypto implementation ({@link MatrixClient#initRustCrypto}) and the device\n     * previously used legacy crypto (so must be migrated), then this must still be provided, so that the\n     * data can be migrated from the legacy store.\n     */\n    cryptoStore?: CryptoStore;\n\n    /**\n     * The scheduler to use. If not\n     * specified, this client will not retry requests on failure. This client\n     * will supply its own processing function to\n     * {@link MatrixScheduler#setProcessFunction}.\n     */\n    scheduler?: MatrixScheduler;\n\n    /**\n     * The function to invoke for HTTP requests.\n     * Most supported environments have a global `fetch` registered to which this will fall back.\n     */\n    fetchFn?: typeof globalThis.fetch;\n\n    userId?: string;\n\n    /**\n     * A unique identifier for this device; used for tracking things like crypto\n     * keys and access tokens. If not specified, end-to-end encryption will be\n     * disabled.\n     */\n    deviceId?: string;\n\n    accessToken?: string;\n    refreshToken?: string;\n\n    /**\n     * Function used to attempt refreshing access and refresh tokens\n     * Called by http-api when a possibly expired token is encountered\n     * and a refreshToken is found\n     */\n    tokenRefreshFunction?: TokenRefreshFunction;\n\n    /**\n     * Identity server provider to retrieve the user's access token when accessing\n     * the identity server. See also https://github.com/vector-im/element-web/issues/10615\n     * which seeks to replace the previous approach of manual access tokens params\n     * with this callback throughout the SDK.\n     */\n    identityServer?: IIdentityServerProvider;\n\n    /**\n     * The default maximum amount of\n     * time to wait before timing out HTTP requests. If not specified, there is no timeout.\n     */\n    localTimeoutMs?: number;\n\n    /**\n     * Set to false to send the access token to the server via a query parameter rather\n     * than the Authorization HTTP header.\n     *\n     * Note that as of v1.11 of the Matrix spec, sending the access token via a query\n     * is deprecated.\n     *\n     * Default true.\n     */\n    useAuthorizationHeader?: boolean;\n\n    /**\n     * Set to true to enable\n     * improved timeline support, see {@link MatrixClient#getEventTimeline}.\n     * It is disabled by default for compatibility with older clients - in particular to\n     * maintain support for back-paginating the live timeline after a '/sync'\n     * result with a gap.\n     */\n    timelineSupport?: boolean;\n\n    /**\n     * Extra query parameters to append\n     * to all requests with this client. Useful for application services which require\n     * `?user_id=`.\n     */\n    queryParams?: Record<string, string>;\n\n    /**\n     * Encryption key used for encrypting sensitive data (such as e2ee keys) in {@link ICreateClientOpts#cryptoStore}.\n     *\n     * This must be set to the same value every time the client is initialised for the same device.\n     *\n     * This is only used for the legacy crypto implementation,\n     * but if you use the rust crypto implementation ({@link MatrixClient#initRustCrypto}) and the device\n     * previously used legacy crypto (so must be migrated), then this must still be provided, so that the\n     * data can be migrated from the legacy store.\n     */\n    pickleKey?: string;\n\n    /**\n     * Verification methods we should offer to the other side when performing an interactive verification.\n     * If unset, we will offer all known methods. Currently these are: showing a QR code, scanning a QR code, and SAS\n     * (aka \"emojis\").\n     *\n     * See {@link types.VerificationMethod} for a set of useful constants for this parameter.\n     */\n    verificationMethods?: Array<string>;\n\n    /**\n     * Whether relaying calls through a TURN server should be forced. Default false.\n     */\n    forceTURN?: boolean;\n\n    /**\n     * Up to this many ICE candidates will be gathered when an incoming call arrives.\n     * Gathering does not send data to the caller, but will communicate with the configured TURN\n     * server. Default 0.\n     */\n    iceCandidatePoolSize?: number;\n\n    /**\n     * True to advertise support for call transfers to other parties on Matrix calls. Default false.\n     */\n    supportsCallTransfer?: boolean;\n\n    /**\n     * Whether to allow a fallback ICE server should be used for negotiating a\n     * WebRTC connection if the homeserver doesn't provide any servers. Defaults to false.\n     */\n    fallbackICEServerAllowed?: boolean;\n\n    /**\n     * If true, to-device signalling for group calls will be encrypted\n     * with Olm. Default: true.\n     */\n    useE2eForGroupCall?: boolean;\n\n    livekitServiceURL?: string;\n\n    /**\n     * Crypto callbacks provided by the application\n     */\n    cryptoCallbacks?: CryptoCallbacks;\n\n    /**\n     * Method to generate room names for empty rooms and rooms names based on membership.\n     * Defaults to a built-in English handler with basic pluralisation.\n     */\n    roomNameGenerator?: (roomId: string, state: RoomNameState) => string | null;\n\n    /**\n     * If true, participant can join group call without video and audio this has to be allowed. By default, a local\n     * media stream is needed to establish a group call.\n     * Default: false.\n     */\n    isVoipWithNoMediaAllowed?: boolean;\n\n    /**\n     * If true, group calls will not establish media connectivity and only create the signaling events,\n     * so that livekit media can be used in the application layert (js-sdk contains no livekit code).\n     */\n    useLivekitForGroupCalls?: boolean;\n\n    /**\n     * A logger to associate with this MatrixClient.\n     * Defaults to the built-in global logger.\n     */\n    logger?: Logger;\n}\n\nexport interface IMatrixClientCreateOpts extends ICreateClientOpts {\n    /**\n     * Whether to allow sending messages to encrypted rooms when encryption\n     * is not available internally within this SDK. This is useful if you are using an external\n     * E2E proxy, for example. Defaults to false.\n     */\n    usingExternalCrypto?: boolean;\n}\n\nexport enum PendingEventOrdering {\n    Chronological = \"chronological\",\n    Detached = \"detached\",\n}\n\nexport interface IStartClientOpts {\n    /**\n     * The event `limit=` to apply to initial sync. Default: 8.\n     */\n    initialSyncLimit?: number;\n\n    /**\n     * True to put `archived=true</code> on the <code>/initialSync` request. Default: false.\n     */\n    includeArchivedRooms?: boolean;\n\n    /**\n     * True to do /profile requests on every invite event if the displayname/avatar_url is not known for this user ID. Default: false.\n     */\n    resolveInvitesToProfiles?: boolean;\n\n    /**\n     * Controls where pending messages appear in a room's timeline. If \"<b>chronological</b>\", messages will\n     * appear in the timeline when the call to `sendEvent` was made. If \"<b>detached</b>\",\n     * pending messages will appear in a separate list, accessible via {@link Room#getPendingEvents}.\n     * Default: \"chronological\".\n     */\n    pendingEventOrdering?: PendingEventOrdering;\n\n    /**\n     * The number of milliseconds to wait on /sync. Default: 30000 (30 seconds).\n     */\n    pollTimeout?: number;\n\n    /**\n     * The filter to apply to /sync calls.\n     */\n    filter?: Filter;\n\n    /**\n     * True to perform syncing without automatically updating presence.\n     */\n    disablePresence?: boolean;\n\n    /**\n     * True to not load all membership events during initial sync but fetch them when needed by calling\n     * `loadOutOfBandMembers` This will override the filter option at this moment.\n     */\n    lazyLoadMembers?: boolean;\n\n    /**\n     * The number of seconds between polls to /.well-known/matrix/client, undefined to disable.\n     * This should be in the order of hours. Default: undefined.\n     */\n    clientWellKnownPollPeriod?: number;\n\n    /**\n     * Will organises events in threaded conversations when\n     * a thread relation is encountered\n     */\n    threadSupport?: boolean;\n\n    /**\n     * @experimental\n     */\n    slidingSync?: SlidingSync;\n}\n\nexport interface IStoredClientOpts extends IStartClientOpts {}\n\nexport const GET_LOGIN_TOKEN_CAPABILITY = new NamespacedValue(\n    \"m.get_login_token\",\n    \"org.matrix.msc3882.get_login_token\",\n);\n\nexport const UNSTABLE_MSC2666_SHARED_ROOMS = \"uk.half-shot.msc2666\";\nexport const UNSTABLE_MSC2666_MUTUAL_ROOMS = \"uk.half-shot.msc2666.mutual_rooms\";\nexport const UNSTABLE_MSC2666_QUERY_MUTUAL_ROOMS = \"uk.half-shot.msc2666.query_mutual_rooms\";\n\nexport const UNSTABLE_MSC4140_DELAYED_EVENTS = \"org.matrix.msc4140\";\n\nexport const UNSTABLE_MSC4133_EXTENDED_PROFILES = \"uk.tcpip.msc4133\";\n\nenum CrossSigningKeyType {\n    MasterKey = \"master_key\",\n    SelfSigningKey = \"self_signing_key\",\n    UserSigningKey = \"user_signing_key\",\n}\n\nexport type CrossSigningKeys = Record<CrossSigningKeyType, CrossSigningKeyInfo>;\n\nexport type SendToDeviceContentMap = Map<string, Map<string, Record<string, any>>>;\n\nexport interface ISignedKey {\n    keys: Record<string, string>;\n    signatures: ISignatures;\n    user_id: string;\n    algorithms: string[];\n    device_id: string;\n}\n\nexport type KeySignatures = Record<string, Record<string, CrossSigningKeyInfo | ISignedKey>>;\nexport interface IUploadKeySignaturesResponse {\n    failures: Record<\n        string,\n        Record<\n            string,\n            {\n                errcode: string;\n                error: string;\n            }\n        >\n    >;\n}\n\nexport interface IPreviewUrlResponse {\n    [key: string]: undefined | string | number;\n    \"og:title\": string;\n    \"og:type\": string;\n    \"og:url\": string;\n    \"og:image\"?: string;\n    \"og:image:type\"?: string;\n    \"og:image:height\"?: number;\n    \"og:image:width\"?: number;\n    \"og:description\"?: string;\n    \"matrix:image:size\"?: number;\n}\n\nexport interface ITurnServerResponse {\n    uris: string[];\n    username: string;\n    password: string;\n    ttl: number;\n}\n\nexport interface ITurnServer {\n    urls: string[];\n    username: string;\n    credential: string;\n}\n\nexport interface IServerVersions {\n    versions: string[];\n    unstable_features: Record<string, boolean>;\n}\n\nexport interface IClientWellKnown {\n    [key: string]: any;\n    \"m.homeserver\"?: IWellKnownConfig;\n    \"m.identity_server\"?: IWellKnownConfig;\n}\n\nexport interface IWellKnownConfig<T = IClientWellKnown> {\n    raw?: T;\n    action?: AutoDiscoveryAction;\n    reason?: string;\n    error?: Error | string;\n    // eslint-disable-next-line\n    base_url?: string | null;\n    // XXX: this is undocumented\n    server_name?: string;\n}\n\ninterface IKeyBackupPath {\n    path: string;\n    queryData?: {\n        version: string;\n    };\n}\n\ninterface IMediaConfig {\n    [key: string]: any; // extensible\n    \"m.upload.size\"?: number;\n}\n\ninterface IThirdPartySigned {\n    sender: string;\n    mxid: string;\n    token: string;\n    signatures: ISignatures;\n}\n\ninterface IJoinRequestBody {\n    third_party_signed?: IThirdPartySigned;\n}\n\ninterface ITagMetadata {\n    [key: string]: any;\n    order?: number;\n}\n\ninterface IMessagesResponse {\n    start?: string;\n    end?: string;\n    chunk: IRoomEvent[];\n    state?: IStateEvent[];\n}\n\ninterface IThreadedMessagesResponse {\n    prev_batch: string;\n    next_batch: string;\n    chunk: IRoomEvent[];\n    state: IStateEvent[];\n}\n\nexport interface IRequestTokenResponse {\n    sid: string;\n    submit_url?: string;\n}\n\nexport interface IRequestMsisdnTokenResponse extends IRequestTokenResponse {\n    msisdn: string;\n    success: boolean;\n    intl_fmt: string;\n}\n\nexport interface IUploadKeysRequest {\n    \"device_keys\"?: Required<IDeviceKeys>;\n    \"one_time_keys\"?: Record<string, IOneTimeKey>;\n    \"org.matrix.msc2732.fallback_keys\"?: Record<string, IOneTimeKey>;\n}\n\nexport interface IQueryKeysRequest {\n    device_keys: { [userId: string]: string[] };\n    timeout?: number;\n    token?: string;\n}\n\nexport interface IClaimKeysRequest {\n    one_time_keys: { [userId: string]: { [deviceId: string]: string } };\n    timeout?: number;\n}\n\nexport interface IOpenIDToken {\n    access_token: string;\n    token_type: \"Bearer\" | string;\n    matrix_server_name: string;\n    expires_in: number;\n}\n\ninterface IRoomInitialSyncResponse {\n    room_id: string;\n    membership: Membership;\n    messages?: {\n        start?: string;\n        end?: string;\n        chunk: IEventWithRoomId[];\n    };\n    state?: IStateEventWithRoomId[];\n    visibility: Visibility;\n    account_data?: IMinimalEvent[];\n    presence: Partial<IEvent>; // legacy and undocumented, api is deprecated so this won't get attention\n}\n\ninterface IJoinedRoomsResponse {\n    joined_rooms: string[];\n}\n\ninterface IJoinedMembersResponse {\n    joined: {\n        [userId: string]: {\n            display_name: string;\n            avatar_url: string;\n        };\n    };\n}\n\n// Re-export for backwards compatibility\nexport type IRegisterRequestParams = RegisterRequest;\n\nexport interface IPublicRoomsChunkRoom {\n    room_id: string;\n    name?: string;\n    avatar_url?: string;\n    topic?: string;\n    canonical_alias?: string;\n    aliases?: string[];\n    world_readable: boolean;\n    guest_can_join: boolean;\n    num_joined_members: number;\n    room_type?: RoomType | string; // Added by MSC3827\n    join_rule?: JoinRule.Knock | JoinRule.Public; // Added by MSC2403\n}\n\ninterface IPublicRoomsResponse {\n    chunk: IPublicRoomsChunkRoom[];\n    next_batch?: string;\n    prev_batch?: string;\n    total_room_count_estimate?: number;\n}\n\ninterface IUserDirectoryResponse {\n    results: {\n        user_id: string;\n        display_name?: string;\n        avatar_url?: string;\n    }[];\n    limited: boolean;\n}\n\nexport interface IMyDevice {\n    \"device_id\": string;\n    \"display_name\"?: string;\n    \"last_seen_ip\"?: string;\n    \"last_seen_ts\"?: number;\n    // UNSTABLE_MSC3852_LAST_SEEN_UA\n    \"last_seen_user_agent\"?: string;\n    \"org.matrix.msc3852.last_seen_user_agent\"?: string;\n}\n\nexport interface Keys {\n    keys: { [keyId: string]: string };\n    usage: string[];\n    user_id: string;\n}\n\nexport interface SigningKeys extends Keys {\n    signatures: ISignatures;\n}\n\nexport interface DeviceKeys {\n    [deviceId: string]: IDeviceKeys & {\n        unsigned?: {\n            device_display_name: string;\n        };\n    };\n}\n\nexport interface IDownloadKeyResult {\n    failures: { [serverName: string]: object };\n    device_keys: { [userId: string]: DeviceKeys };\n    // the following three fields were added in 1.1\n    master_keys?: { [userId: string]: Keys };\n    self_signing_keys?: { [userId: string]: SigningKeys };\n    user_signing_keys?: { [userId: string]: SigningKeys };\n}\n\nexport interface IClaimOTKsResult {\n    failures: { [serverName: string]: object };\n    one_time_keys: {\n        [userId: string]: {\n            [deviceId: string]: {\n                [keyId: string]: {\n                    key: string;\n                    signatures: ISignatures;\n                };\n            };\n        };\n    };\n}\n\nexport interface IFieldType {\n    regexp: string;\n    placeholder: string;\n}\n\nexport interface IInstance {\n    desc: string;\n    icon?: string;\n    fields: object;\n    network_id: string;\n    // XXX: this is undocumented but we rely on it: https://github.com/matrix-org/matrix-doc/issues/3203\n    instance_id: string;\n}\n\nexport interface IProtocol {\n    user_fields: string[];\n    location_fields: string[];\n    icon: string;\n    field_types: Record<string, IFieldType>;\n    instances: IInstance[];\n}\n\ninterface IThirdPartyLocation {\n    alias: string;\n    protocol: string;\n    fields: object;\n}\n\ninterface IThirdPartyUser {\n    userid: string;\n    protocol: string;\n    fields: object;\n}\n\n/**\n * The summary of a room as defined by an initial version of MSC3266 and implemented in Synapse\n * Proposed at https://github.com/matrix-org/matrix-doc/pull/3266\n */\nexport interface RoomSummary extends Omit<IPublicRoomsChunkRoom, \"canonical_alias\" | \"aliases\"> {\n    /**\n     * The current membership of this user in the room.\n     * Usually \"leave\" if the room is fetched over federation.\n     */\n    \"membership\"?: Membership;\n    /**\n     * Version of the room.\n     */\n    \"im.nheko.summary.room_version\"?: string;\n    /**\n     * The encryption algorithm used for this room, if the room is encrypted.\n     */\n    \"im.nheko.summary.encryption\"?: string;\n}\n\ninterface IRoomHierarchy {\n    rooms: IHierarchyRoom[];\n    next_batch?: string;\n}\n\nexport interface TimestampToEventResponse {\n    event_id: string;\n    origin_server_ts: number;\n}\n\ninterface IWhoamiResponse {\n    user_id: string;\n    device_id?: string;\n    is_guest?: boolean;\n}\n/* eslint-enable camelcase */\n\n// We're using this constant for methods overloading and inspect whether a variable\n// contains an eventId or not. This was required to ensure backwards compatibility\n// of methods for threads\n// Probably not the most graceful solution but does a good enough job for now\nconst EVENT_ID_PREFIX = \"$\";\n\nexport enum ClientEvent {\n    Sync = \"sync\",\n    Event = \"event\",\n    ToDeviceEvent = \"toDeviceEvent\",\n    AccountData = \"accountData\",\n    Room = \"Room\",\n    DeleteRoom = \"deleteRoom\",\n    SyncUnexpectedError = \"sync.unexpectedError\",\n    ClientWellKnown = \"WellKnown.client\",\n    ReceivedVoipEvent = \"received_voip_event\",\n    UndecryptableToDeviceEvent = \"toDeviceEvent.undecryptable\",\n    TurnServers = \"turnServers\",\n    TurnServersError = \"turnServers.error\",\n}\n\ntype RoomEvents =\n    | RoomEvent.Name\n    | RoomEvent.Redaction\n    | RoomEvent.RedactionCancelled\n    | RoomEvent.Receipt\n    | RoomEvent.Tags\n    | RoomEvent.LocalEchoUpdated\n    | RoomEvent.HistoryImportedWithinTimeline\n    | RoomEvent.AccountData\n    | RoomEvent.MyMembership\n    | RoomEvent.Timeline\n    | RoomEvent.TimelineReset;\n\ntype RoomStateEvents =\n    | RoomStateEvent.Events\n    | RoomStateEvent.Members\n    | RoomStateEvent.NewMember\n    | RoomStateEvent.Update\n    | RoomStateEvent.Marker;\n\ntype CryptoEvents = (typeof CryptoEvent)[keyof typeof CryptoEvent];\n\ntype MatrixEventEvents = MatrixEventEvent.Decrypted | MatrixEventEvent.Replaced | MatrixEventEvent.VisibilityChange;\n\ntype RoomMemberEvents =\n    | RoomMemberEvent.Name\n    | RoomMemberEvent.Typing\n    | RoomMemberEvent.PowerLevel\n    | RoomMemberEvent.Membership;\n\ntype UserEvents =\n    | UserEvent.AvatarUrl\n    | UserEvent.DisplayName\n    | UserEvent.Presence\n    | UserEvent.CurrentlyActive\n    | UserEvent.LastPresenceTs;\n\nexport type EmittedEvents =\n    | ClientEvent\n    | RoomEvents\n    | RoomStateEvents\n    | CryptoEvents\n    | MatrixEventEvents\n    | RoomMemberEvents\n    | UserEvents\n    | CallEvent // re-emitted by call.ts using Object.values\n    | CallEventHandlerEvent.Incoming\n    | GroupCallEventHandlerEvent.Incoming\n    | GroupCallEventHandlerEvent.Outgoing\n    | GroupCallEventHandlerEvent.Ended\n    | GroupCallEventHandlerEvent.Participants\n    | HttpApiEvent.SessionLoggedOut\n    | HttpApiEvent.NoConsent\n    | BeaconEvent;\n\nexport type ClientEventHandlerMap = {\n    /**\n     * Fires whenever the SDK's syncing state is updated. The state can be one of:\n     * <ul>\n     *\n     * <li>PREPARED: The client has synced with the server at least once and is\n     * ready for methods to be called on it. This will be immediately followed by\n     * a state of SYNCING. <i>This is the equivalent of \"syncComplete\" in the\n     * previous API.</i></li>\n     *\n     * <li>CATCHUP: The client has detected the connection to the server might be\n     * available again and will now try to do a sync again. As this sync might take\n     * a long time (depending how long ago was last synced, and general server\n     * performance) the client is put in this mode so the UI can reflect trying\n     * to catch up with the server after losing connection.</li>\n     *\n     * <li>SYNCING : The client is currently polling for new events from the server.\n     * This will be called <i>after</i> processing latest events from a sync.</li>\n     *\n     * <li>ERROR : The client has had a problem syncing with the server. If this is\n     * called <i>before</i> PREPARED then there was a problem performing the initial\n     * sync. If this is called <i>after</i> PREPARED then there was a problem polling\n     * the server for updates. This may be called multiple times even if the state is\n     * already ERROR. <i>This is the equivalent of \"syncError\" in the previous\n     * API.</i></li>\n     *\n     * <li>RECONNECTING: The sync connection has dropped, but not (yet) in a way that\n     * should be considered erroneous.\n     * </li>\n     *\n     * <li>STOPPED: The client has stopped syncing with server due to stopClient\n     * being called.\n     * </li>\n     * </ul>\n     * State transition diagram:\n     * ```\n     *                                          +---->STOPPED\n     *                                          |\n     *              +----->PREPARED -------> SYNCING <--+\n     *              |                        ^  |  ^    |\n     *              |      CATCHUP ----------+  |  |    |\n     *              |        ^                  V  |    |\n     *   null ------+        |  +------- RECONNECTING   |\n     *              |        V  V                       |\n     *              +------->ERROR ---------------------+\n     *\n     * NB: 'null' will never be emitted by this event.\n     *\n     * ```\n     * Transitions:\n     * <ul>\n     *\n     * <li>`null -> PREPARED` : Occurs when the initial sync is completed\n     * first time. This involves setting up filters and obtaining push rules.\n     *\n     * <li>`null -> ERROR` : Occurs when the initial sync failed first time.\n     *\n     * <li>`ERROR -> PREPARED` : Occurs when the initial sync succeeds\n     * after previously failing.\n     *\n     * <li>`PREPARED -> SYNCING` : Occurs immediately after transitioning\n     * to PREPARED. Starts listening for live updates rather than catching up.\n     *\n     * <li>`SYNCING -> RECONNECTING` : Occurs when the live update fails.\n     *\n     * <li>`RECONNECTING -> RECONNECTING` : Can occur if the update calls\n     * continue to fail, but the keepalive calls (to /versions) succeed.\n     *\n     * <li>`RECONNECTING -> ERROR` : Occurs when the keepalive call also fails\n     *\n     * <li>`ERROR -> SYNCING` : Occurs when the client has performed a\n     * live update after having previously failed.\n     *\n     * <li>`ERROR -> ERROR` : Occurs when the client has failed to keepalive\n     * for a second time or more.</li>\n     *\n     * <li>`SYNCING -> SYNCING` : Occurs when the client has performed a live\n     * update. This is called <i>after</i> processing.</li>\n     *\n     * <li>`* -> STOPPED` : Occurs once the client has stopped syncing or\n     * trying to sync after stopClient has been called.</li>\n     * </ul>\n     *\n     * @param state - An enum representing the syncing state. One of \"PREPARED\",\n     * \"SYNCING\", \"ERROR\", \"STOPPED\".\n     *\n     * @param prevState - An enum representing the previous syncing state.\n     * One of \"PREPARED\", \"SYNCING\", \"ERROR\", \"STOPPED\" <b>or null</b>.\n     *\n     * @param data - Data about this transition.\n     *\n     * @example\n     * ```\n     * matrixClient.on(\"sync\", function(state, prevState, data) {\n     *   switch (state) {\n     *     case \"ERROR\":\n     *       // update UI to say \"Connection Lost\"\n     *       break;\n     *     case \"SYNCING\":\n     *       // update UI to remove any \"Connection Lost\" message\n     *       break;\n     *     case \"PREPARED\":\n     *       // the client instance is ready to be queried.\n     *       var rooms = matrixClient.getRooms();\n     *       break;\n     *   }\n     * });\n     * ```\n     */\n    [ClientEvent.Sync]: (state: SyncState, prevState: SyncState | null, data?: ISyncStateData) => void;\n    /**\n     * Fires whenever the SDK receives a new event.\n     * <p>\n     * This is only fired for live events received via /sync - it is not fired for\n     * events received over context, search, or pagination APIs.\n     *\n     * @param event - The matrix event which caused this event to fire.\n     * @example\n     * ```\n     * matrixClient.on(\"event\", function(event){\n     *   var sender = event.getSender();\n     * });\n     * ```\n     */\n    [ClientEvent.Event]: (event: MatrixEvent) => void;\n    /**\n     * Fires whenever the SDK receives a new to-device event.\n     * @param event - The matrix event which caused this event to fire.\n     * @example\n     * ```\n     * matrixClient.on(\"toDeviceEvent\", function(event){\n     *   var sender = event.getSender();\n     * });\n     * ```\n     */\n    [ClientEvent.ToDeviceEvent]: (event: MatrixEvent) => void;\n    /**\n     * Fires if a to-device event is received that cannot be decrypted.\n     * Encrypted to-device events will (generally) use plain Olm encryption,\n     * in which case decryption failures are fatal: the event will never be\n     * decryptable, unlike Megolm encrypted events where the key may simply\n     * arrive later.\n     *\n     * An undecryptable to-device event is therefore likely to indicate problems.\n     *\n     * @param event - The undecyptable to-device event\n     */\n    [ClientEvent.UndecryptableToDeviceEvent]: (event: MatrixEvent) => void;\n    /**\n     * Fires whenever new user-scoped account_data is added.\n     * @param event - The event describing the account_data just added\n     * @param event - The previous account data, if known.\n     * @example\n     * ```\n     * matrixClient.on(\"accountData\", function(event, oldEvent){\n     *   myAccountData[event.type] = event.content;\n     * });\n     * ```\n     */\n    [ClientEvent.AccountData]: (event: MatrixEvent, lastEvent?: MatrixEvent) => void;\n    /**\n     * Fires whenever a new Room is added. This will fire when you are invited to a\n     * room, as well as when you join a room. <strong>This event is experimental and\n     * may change.</strong>\n     * @param room - The newly created, fully populated room.\n     * @example\n     * ```\n     * matrixClient.on(\"Room\", function(room){\n     *   var roomId = room.roomId;\n     * });\n     * ```\n     */\n    [ClientEvent.Room]: (room: Room) => void;\n    /**\n     * Fires whenever a Room is removed. This will fire when you forget a room.\n     * <strong>This event is experimental and may change.</strong>\n     * @param roomId - The deleted room ID.\n     * @example\n     * ```\n     * matrixClient.on(\"deleteRoom\", function(roomId){\n     *   // update UI from getRooms()\n     * });\n     * ```\n     */\n    [ClientEvent.DeleteRoom]: (roomId: string) => void;\n    [ClientEvent.SyncUnexpectedError]: (error: Error) => void;\n    /**\n     * Fires when the client .well-known info is fetched.\n     *\n     * @param data - The JSON object returned by the server\n     */\n    [ClientEvent.ClientWellKnown]: (data: IClientWellKnown) => void;\n    [ClientEvent.ReceivedVoipEvent]: (event: MatrixEvent) => void;\n    [ClientEvent.TurnServers]: (servers: ITurnServer[]) => void;\n    [ClientEvent.TurnServersError]: (error: Error, fatal: boolean) => void;\n} & RoomEventHandlerMap &\n    RoomStateEventHandlerMap &\n    CryptoEventHandlerMap &\n    MatrixEventHandlerMap &\n    RoomMemberEventHandlerMap &\n    UserEventHandlerMap &\n    CallEventHandlerEventHandlerMap &\n    GroupCallEventHandlerEventHandlerMap &\n    CallEventHandlerMap &\n    HttpApiEventHandlerMap &\n    BeaconEventHandlerMap;\n\nconst SSO_ACTION_PARAM = new UnstableValue(\"action\", \"org.matrix.msc3824.action\");\n\n/**\n * Represents a Matrix Client. Only directly construct this if you want to use\n * custom modules. Normally, {@link createClient} should be used\n * as it specifies 'sensible' defaults for these modules.\n */\nexport class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHandlerMap> {\n    public static readonly RESTORE_BACKUP_ERROR_BAD_KEY = \"RESTORE_BACKUP_ERROR_BAD_KEY\";\n\n    private readonly logger: Logger;\n\n    public reEmitter = new TypedReEmitter<EmittedEvents, ClientEventHandlerMap>(this);\n    public olmVersion: [number, number, number] | null = null; // populated after initLegacyCrypto\n    public usingExternalCrypto = false;\n    private _store!: Store;\n    public deviceId: string | null;\n    public credentials: { userId: string | null };\n\n    /**\n     * Encryption key used for encrypting sensitive data (such as e2ee keys) in storage.\n     *\n     * As supplied in the constructor via {@link IMatrixClientCreateOpts#pickleKey}.\n     * Used for migration from the legacy crypto to the rust crypto\n     */\n    private readonly legacyPickleKey?: string;\n\n    public scheduler?: MatrixScheduler;\n    public clientRunning = false;\n    public timelineSupport = false;\n    public urlPreviewCache: { [key: string]: Promise<IPreviewUrlResponse> } = {};\n    public identityServer?: IIdentityServerProvider;\n    public http: MatrixHttpApi<IHttpOpts & { onlyData: true }>; // XXX: Intended private, used in code.\n\n    private cryptoBackend?: CryptoBackend; // one of crypto or rustCrypto\n    public cryptoCallbacks: CryptoCallbacks; // XXX: Intended private, used in code.\n    public callEventHandler?: CallEventHandler; // XXX: Intended private, used in code.\n    public groupCallEventHandler?: GroupCallEventHandler;\n    public supportsCallTransfer = false; // XXX: Intended private, used in code.\n    public forceTURN = false; // XXX: Intended private, used in code.\n    public iceCandidatePoolSize = 0; // XXX: Intended private, used in code.\n    public idBaseUrl?: string;\n    public baseUrl: string;\n    public readonly isVoipWithNoMediaAllowed;\n\n    public useLivekitForGroupCalls: boolean;\n\n    // Note: these are all `protected` to let downstream consumers make mistakes if they want to.\n    // We don't technically support this usage, but have reasons to do this.\n\n    protected canSupportVoip = false;\n    protected peekSync: SyncApi | null = null;\n    protected isGuestAccount = false;\n    protected ongoingScrollbacks: { [roomId: string]: { promise?: Promise<Room>; errorTs?: number } } = {};\n    protected notifTimelineSet: EventTimelineSet | null = null;\n\n    /**\n     * Legacy crypto store used for migration from the legacy crypto to the rust crypto\n     * @private\n     */\n    private readonly legacyCryptoStore?: CryptoStore;\n    protected verificationMethods?: string[];\n    protected fallbackICEServerAllowed = false;\n    protected syncApi?: SlidingSyncSdk | SyncApi;\n    public roomNameGenerator?: ICreateClientOpts[\"roomNameGenerator\"];\n    public pushRules?: IPushRules;\n    protected syncLeftRoomsPromise?: Promise<Room[]>;\n    protected syncedLeftRooms = false;\n    protected clientOpts?: IStoredClientOpts;\n    protected clientWellKnownIntervalID?: ReturnType<typeof setInterval>;\n    protected canResetTimelineCallback?: ResetTimelineCallback;\n\n    public canSupport = new Map<Feature, ServerSupport>();\n\n    // The pushprocessor caches useful things, so keep one and re-use it\n    protected pushProcessor = new PushProcessor(this);\n\n    // Promise to a response of the server's /versions response\n    // TODO: This should expire: https://github.com/matrix-org/matrix-js-sdk/issues/1020\n    protected serverVersionsPromise?: Promise<IServerVersions>;\n\n    protected clientWellKnown?: IClientWellKnown;\n    protected clientWellKnownPromise?: Promise<IClientWellKnown>;\n    protected turnServers: ITurnServer[] = [];\n    protected turnServersExpiry = 0;\n    protected checkTurnServersIntervalID?: ReturnType<typeof setInterval>;\n    protected txnCtr = 0;\n    protected mediaHandler = new MediaHandler(this);\n    protected sessionId: string;\n\n    /** IDs of events which are currently being encrypted.\n     *\n     * This is part of the cancellation mechanism: if the event is no longer listed here when encryption completes,\n     * that tells us that it has been cancelled, and we should not send it.\n     */\n    private eventsBeingEncrypted = new Set<string>();\n\n    private useE2eForGroupCall = true;\n    private toDeviceMessageQueue: ToDeviceMessageQueue;\n    public livekitServiceURL?: string;\n\n    private _secretStorage: ServerSideSecretStorageImpl;\n\n    // A manager for determining which invites should be ignored.\n    public readonly ignoredInvites: IgnoredInvites;\n\n    public readonly matrixRTC: MatrixRTCSessionManager;\n\n    private serverCapabilitiesService: ServerCapabilities;\n\n    public constructor(opts: IMatrixClientCreateOpts) {\n        super();\n\n        // If a custom logger is provided, use it. Otherwise, default to the global\n        // one in logger.ts.\n        this.logger = opts.logger ?? logger;\n\n        opts.baseUrl = utils.ensureNoTrailingSlash(opts.baseUrl);\n        opts.idBaseUrl = utils.ensureNoTrailingSlash(opts.idBaseUrl);\n\n        this.baseUrl = opts.baseUrl;\n        this.idBaseUrl = opts.idBaseUrl;\n        this.identityServer = opts.identityServer;\n\n        this.usingExternalCrypto = opts.usingExternalCrypto ?? false;\n        this.store = opts.store || new StubStore();\n        this.deviceId = opts.deviceId || null;\n        this.sessionId = secureRandomString(10);\n\n        const userId = opts.userId || null;\n        this.credentials = { userId };\n\n        this.http = new MatrixHttpApi(this as ConstructorParameters<typeof MatrixHttpApi>[0], {\n            fetchFn: opts.fetchFn,\n            baseUrl: opts.baseUrl,\n            idBaseUrl: opts.idBaseUrl,\n            accessToken: opts.accessToken,\n            refreshToken: opts.refreshToken,\n            tokenRefreshFunction: opts.tokenRefreshFunction,\n            prefix: ClientPrefix.V3,\n            onlyData: true,\n            extraParams: opts.queryParams,\n            localTimeoutMs: opts.localTimeoutMs,\n            useAuthorizationHeader: opts.useAuthorizationHeader,\n            logger: this.logger,\n        });\n\n        if (opts.pickleKey) {\n            this.legacyPickleKey = opts.pickleKey;\n        }\n\n        this.useLivekitForGroupCalls = Boolean(opts.useLivekitForGroupCalls);\n\n        this.scheduler = opts.scheduler;\n        if (this.scheduler) {\n            this.scheduler.setProcessFunction(async (eventToSend: MatrixEvent) => {\n                const room = this.getRoom(eventToSend.getRoomId());\n                if (eventToSend.status !== EventStatus.SENDING) {\n                    this.updatePendingEventStatus(room, eventToSend, EventStatus.SENDING);\n                }\n                const res = await this.sendEventHttpRequest(eventToSend);\n                if (room) {\n                    // ensure we update pending event before the next scheduler run so that any listeners to event id\n                    // updates on the synchronous event emitter get a chance to run first.\n                    room.updatePendingEvent(eventToSend, EventStatus.SENT, res.event_id);\n                }\n                return res;\n            });\n        }\n\n        if (supportsMatrixCall()) {\n            this.callEventHandler = new CallEventHandler(this);\n            this.groupCallEventHandler = new GroupCallEventHandler(this);\n            this.canSupportVoip = true;\n            // Start listening for calls after the initial sync is done\n            // We do not need to backfill the call event buffer\n            // with encrypted events that might never get decrypted\n            this.on(ClientEvent.Sync, this.startCallEventHandler);\n        }\n\n        // NB. We initialise MatrixRTC whether we have call support or not: this is just\n        // the underlying session management and doesn't use any actual media capabilities\n        this.matrixRTC = new MatrixRTCSessionManager(this);\n\n        this.serverCapabilitiesService = new ServerCapabilities(this.http);\n\n        this.on(ClientEvent.Sync, this.fixupRoomNotifications);\n\n        this.timelineSupport = Boolean(opts.timelineSupport);\n\n        this.legacyCryptoStore = opts.cryptoStore;\n        this.verificationMethods = opts.verificationMethods;\n        this.cryptoCallbacks = opts.cryptoCallbacks || {};\n\n        this.forceTURN = opts.forceTURN || false;\n        this.iceCandidatePoolSize = opts.iceCandidatePoolSize === undefined ? 0 : opts.iceCandidatePoolSize;\n        this.supportsCallTransfer = opts.supportsCallTransfer || false;\n        this.fallbackICEServerAllowed = opts.fallbackICEServerAllowed || false;\n        this.isVoipWithNoMediaAllowed = opts.isVoipWithNoMediaAllowed || false;\n\n        if (opts.useE2eForGroupCall !== undefined) this.useE2eForGroupCall = opts.useE2eForGroupCall;\n\n        this.livekitServiceURL = opts.livekitServiceURL;\n\n        this.roomNameGenerator = opts.roomNameGenerator;\n\n        this.toDeviceMessageQueue = new ToDeviceMessageQueue(this);\n\n        // The SDK doesn't really provide a clean way for events to recalculate the push\n        // actions for themselves, so we have to kinda help them out when they are encrypted.\n        // We do this so that push rules are correctly executed on events in their decrypted\n        // state, such as highlights when the user's name is mentioned.\n        this.on(MatrixEventEvent.Decrypted, (event) => {\n            fixNotificationCountOnDecryption(this, event);\n        });\n\n        this.ignoredInvites = new IgnoredInvites(this);\n        this._secretStorage = new ServerSideSecretStorageImpl(this, opts.cryptoCallbacks ?? {});\n\n        // having lots of event listeners is not unusual. 0 means \"unlimited\".\n        this.setMaxListeners(0);\n    }\n\n    public set store(newStore: Store) {\n        this._store = newStore;\n        this._store.setUserCreator((userId) => User.createUser(userId, this));\n    }\n\n    public get store(): Store {\n        return this._store;\n    }\n\n    /**\n     * High level helper method to begin syncing and poll for new events. To listen for these\n     * events, add a listener for {@link ClientEvent.Event}\n     * via {@link MatrixClient#on}. Alternatively, listen for specific\n     * state change events.\n     * @param opts - Options to apply when syncing.\n     */\n    public async startClient(opts?: IStartClientOpts): Promise<void> {\n        if (this.clientRunning) {\n            // client is already running.\n            return;\n        }\n        this.clientRunning = true;\n\n        this.on(ClientEvent.Sync, this.startMatrixRTC);\n\n        // Create our own user object artificially (instead of waiting for sync)\n        // so it's always available, even if the user is not in any rooms etc.\n        const userId = this.getUserId();\n        if (userId) {\n            this.store.storeUser(new User(userId));\n        }\n\n        // periodically poll for turn servers if we support voip\n        if (this.canSupportVoip) {\n            this.checkTurnServersIntervalID = setInterval(() => {\n                this.checkTurnServers();\n            }, TURN_CHECK_INTERVAL);\n            // noinspection ES6MissingAwait\n            this.checkTurnServers();\n        }\n\n        if (this.syncApi) {\n            // This shouldn't happen since we thought the client was not running\n            this.logger.error(\"Still have sync object whilst not running: stopping old one\");\n            this.syncApi.stop();\n        }\n\n        try {\n            await this.getVersions();\n\n            // This should be done with `canSupport`\n            // TODO: https://github.com/vector-im/element-web/issues/23643\n            const { threads, list, fwdPagination } = await this.doesServerSupportThread();\n            Thread.setServerSideSupport(threads);\n            Thread.setServerSideListSupport(list);\n            Thread.setServerSideFwdPaginationSupport(fwdPagination);\n        } catch (e) {\n            this.logger.error(\n                \"Can't fetch server versions, continuing to initialise sync, this will be retried later\",\n                e,\n            );\n        }\n\n        this.clientOpts = opts ?? {};\n        if (this.clientOpts.slidingSync) {\n            this.syncApi = new SlidingSyncSdk(\n                this.clientOpts.slidingSync,\n                this,\n                this.clientOpts,\n                this.buildSyncApiOptions(),\n            );\n        } else {\n            this.syncApi = new SyncApi(this, this.clientOpts, this.buildSyncApiOptions());\n        }\n\n        this.syncApi.sync().catch((e) => this.logger.info(\"Sync startup aborted with an error:\", e));\n\n        if (this.clientOpts.clientWellKnownPollPeriod !== undefined) {\n            this.clientWellKnownIntervalID = setInterval(() => {\n                this.fetchClientWellKnown();\n            }, 1000 * this.clientOpts.clientWellKnownPollPeriod);\n            this.fetchClientWellKnown();\n        }\n\n        this.toDeviceMessageQueue.start();\n        this.serverCapabilitiesService.start();\n    }\n\n    /**\n     * Construct a SyncApiOptions for this client, suitable for passing into the SyncApi constructor\n     */\n    protected buildSyncApiOptions(): SyncApiOptions {\n        return {\n            cryptoCallbacks: this.cryptoBackend,\n            canResetEntireTimeline: (roomId: string): boolean => {\n                if (!this.canResetTimelineCallback) {\n                    return false;\n                }\n                return this.canResetTimelineCallback(roomId);\n            },\n        };\n    }\n\n    /**\n     * High level helper method to stop the client from polling and allow a\n     * clean shutdown.\n     */\n    public stopClient(): void {\n        this.cryptoBackend?.stop(); // crypto might have been initialised even if the client wasn't fully started\n\n        this.off(ClientEvent.Sync, this.startMatrixRTC);\n\n        if (!this.clientRunning) return; // already stopped\n\n        this.logger.debug(\"stopping MatrixClient\");\n\n        this.clientRunning = false;\n\n        this.syncApi?.stop();\n        this.syncApi = undefined;\n\n        this.peekSync?.stopPeeking();\n\n        this.callEventHandler?.stop();\n        this.groupCallEventHandler?.stop();\n        this.callEventHandler = undefined;\n        this.groupCallEventHandler = undefined;\n\n        globalThis.clearInterval(this.checkTurnServersIntervalID);\n        this.checkTurnServersIntervalID = undefined;\n\n        if (this.clientWellKnownIntervalID !== undefined) {\n            globalThis.clearInterval(this.clientWellKnownIntervalID);\n        }\n\n        this.toDeviceMessageQueue.stop();\n\n        this.matrixRTC.stop();\n\n        this.serverCapabilitiesService.stop();\n    }\n\n    /**\n     * Clear any data out of the persistent stores used by the client.\n     *\n     * @returns Promise which resolves when the stores have been cleared.\n     */\n    public clearStores(): Promise<void> {\n        if (this.clientRunning) {\n            throw new Error(\"Cannot clear stores while client is running\");\n        }\n\n        const promises: Promise<void>[] = [];\n\n        promises.push(this.store.deleteAllData());\n        if (this.legacyCryptoStore) {\n            promises.push(this.legacyCryptoStore.deleteAllData());\n        }\n\n        // delete the stores used by the rust matrix-sdk-crypto, in case they were used\n        const deleteRustSdkStore = async (): Promise<void> => {\n            let indexedDB: IDBFactory;\n            try {\n                indexedDB = globalThis.indexedDB;\n                if (!indexedDB) return; // No indexedDB support\n            } catch {\n                // No indexedDB support\n                return;\n            }\n            for (const dbname of [\n                `${RUST_SDK_STORE_PREFIX}::matrix-sdk-crypto`,\n                `${RUST_SDK_STORE_PREFIX}::matrix-sdk-crypto-meta`,\n            ]) {\n                const prom = new Promise((resolve, reject) => {\n                    this.logger.info(`Removing IndexedDB instance ${dbname}`);\n                    const req = indexedDB.deleteDatabase(dbname);\n                    req.onsuccess = (_): void => {\n                        this.logger.info(`Removed IndexedDB instance ${dbname}`);\n                        resolve(0);\n                    };\n                    req.onerror = (e): void => {\n                        // In private browsing, Firefox has a globalThis.indexedDB, but attempts to delete an indexeddb\n                        // (even a non-existent one) fail with \"DOMException: A mutation operation was attempted on a\n                        // database that did not allow mutations.\"\n                        //\n                        // it seems like the only thing we can really do is ignore the error.\n                        this.logger.warn(`Failed to remove IndexedDB instance ${dbname}:`, e);\n                        resolve(0);\n                    };\n                    req.onblocked = (e): void => {\n                        this.logger.info(`cannot yet remove IndexedDB instance ${dbname}`);\n                    };\n                });\n                await prom;\n            }\n        };\n        promises.push(deleteRustSdkStore());\n\n        return Promise.all(promises).then(); // .then to fix types\n    }\n\n    /**\n     * Get the user-id of the logged-in user\n     *\n     * @returns MXID for the logged-in user, or null if not logged in\n     */\n    public getUserId(): string | null {\n        return this.credentials?.userId ?? null;\n    }\n\n    /**\n     * Get the user-id of the logged-in user\n     *\n     * @returns MXID for the logged-in user\n     * @throws Error if not logged in\n     */\n    public getSafeUserId(): string {\n        const userId = this.getUserId();\n        if (!userId) {\n            throw new Error(\"Expected logged in user but found none.\");\n        }\n        return userId;\n    }\n\n    /**\n     * Get the domain for this client's MXID\n     * @returns Domain of this MXID\n     */\n    public getDomain(): string | null {\n        if (this.credentials?.userId) {\n            return this.credentials.userId.replace(/^.*?:/, \"\");\n        }\n        return null;\n    }\n\n    /**\n     * Get the local part of the current user ID e.g. \"foo\" in \"\\@foo:bar\".\n     * @returns The user ID localpart or null.\n     */\n    public getUserIdLocalpart(): string | null {\n        return this.credentials?.userId?.split(\":\")[0].substring(1) ?? null;\n    }\n\n    /**\n     * Get the device ID of this client\n     * @returns device ID\n     */\n    public getDeviceId(): string | null {\n        return this.deviceId;\n    }\n\n    /**\n     * Get the session ID of this client\n     * @returns session ID\n     */\n    public getSessionId(): string {\n        return this.sessionId;\n    }\n\n    /**\n     * Check if the runtime environment supports VoIP calling.\n     * @returns True if VoIP is supported.\n     */\n    public supportsVoip(): boolean {\n        return this.canSupportVoip;\n    }\n\n    /**\n     * @returns\n     */\n    public getMediaHandler(): MediaHandler {\n        return this.mediaHandler;\n    }\n\n    /**\n     * Set whether VoIP calls are forced to use only TURN\n     * candidates. This is the same as the forceTURN option\n     * when creating the client.\n     * @param force - True to force use of TURN servers\n     */\n    public setForceTURN(force: boolean): void {\n        this.forceTURN = force;\n    }\n\n    /**\n     * Set whether to advertise transfer support to other parties on Matrix calls.\n     * @param support - True to advertise the 'm.call.transferee' capability\n     */\n    public setSupportsCallTransfer(support: boolean): void {\n        this.supportsCallTransfer = support;\n    }\n\n    /**\n     * Returns true if to-device signalling for group calls will be encrypted with Olm.\n     * If false, it will be sent unencrypted.\n     * @returns boolean Whether group call signalling will be encrypted\n     */\n    public getUseE2eForGroupCall(): boolean {\n        return this.useE2eForGroupCall;\n    }\n\n    /**\n     * Creates a new call.\n     * The place*Call methods on the returned call can be used to actually place a call\n     *\n     * @param roomId - The room the call is to be placed in.\n     * @returns the call or null if the browser doesn't support calling.\n     */\n    public createCall(roomId: string): MatrixCall | null {\n        return createNewMatrixCall(this, roomId);\n    }\n\n    /**\n     * Creates a new group call and sends the associated state event\n     * to alert other members that the room now has a group call.\n     *\n     * @param roomId - The room the call is to be placed in.\n     */\n    public async createGroupCall(\n        roomId: string,\n        type: GroupCallType,\n        isPtt: boolean,\n        intent: GroupCallIntent,\n        dataChannelsEnabled?: boolean,\n        dataChannelOptions?: IGroupCallDataChannelOptions,\n    ): Promise<GroupCall> {\n        if (this.getGroupCallForRoom(roomId)) {\n            throw new Error(`${roomId} already has an existing group call`);\n        }\n\n        const room = this.getRoom(roomId);\n\n        if (!room) {\n            throw new Error(`Cannot find room ${roomId}`);\n        }\n\n        // Because without Media section a WebRTC connection is not possible, so need a RTCDataChannel to set up a\n        // no media WebRTC connection anyway.\n        return new GroupCall(\n            this,\n            room,\n            type,\n            isPtt,\n            intent,\n            undefined,\n            dataChannelsEnabled || this.isVoipWithNoMediaAllowed,\n            dataChannelOptions,\n            this.isVoipWithNoMediaAllowed,\n            this.useLivekitForGroupCalls,\n            this.livekitServiceURL,\n        ).create();\n    }\n\n    public getLivekitServiceURL(): string | undefined {\n        return this.livekitServiceURL;\n    }\n\n    // This shouldn't need to exist, but the widget API has startup ordering problems that\n    // mean it doesn't know the livekit URL fast enough: remove this once this is fixed.\n    public setLivekitServiceURL(newURL: string): void {\n        this.livekitServiceURL = newURL;\n    }\n\n    /**\n     * Wait until an initial state for the given room has been processed by the\n     * client and the client is aware of any ongoing group calls. Awaiting on\n     * the promise returned by this method before calling getGroupCallForRoom()\n     * avoids races where getGroupCallForRoom is called before the state for that\n     * room has been processed. It does not, however, fix other races, eg. two\n     * clients both creating a group call at the same time.\n     * @param roomId - The room ID to wait for\n     * @returns A promise that resolves once existing group calls in the room\n     *          have been processed.\n     */\n    public waitUntilRoomReadyForGroupCalls(roomId: string): Promise<void> {\n        return this.groupCallEventHandler!.waitUntilRoomReadyForGroupCalls(roomId);\n    }\n\n    /**\n     * Get an existing group call for the provided room.\n     * @returns The group call or null if it doesn't already exist.\n     */\n    public getGroupCallForRoom(roomId: string): GroupCall | null {\n        return this.groupCallEventHandler!.groupCalls.get(roomId) || null;\n    }\n\n    /**\n     * Get the current sync state.\n     * @returns the sync state, which may be null.\n     * @see MatrixClient#event:\"sync\"\n     */\n    public getSyncState(): SyncState | null {\n        return this.syncApi?.getSyncState() ?? null;\n    }\n\n    /**\n     * Returns the additional data object associated with\n     * the current sync state, or null if there is no\n     * such data.\n     * Sync errors, if available, are put in the 'error' key of\n     * this object.\n     */\n    public getSyncStateData(): ISyncStateData | null {\n        if (!this.syncApi) {\n            return null;\n        }\n        return this.syncApi.getSyncStateData();\n    }\n\n    /**\n     * Whether the initial sync has completed.\n     * @returns True if at least one sync has happened.\n     */\n    public isInitialSyncComplete(): boolean {\n        const state = this.getSyncState();\n        if (!state) {\n            return false;\n        }\n        return state === SyncState.Prepared || state === SyncState.Syncing;\n    }\n\n    /**\n     * Return whether the client is configured for a guest account.\n     * @returns True if this is a guest access_token (or no token is supplied).\n     */\n    public isGuest(): boolean {\n        return this.isGuestAccount;\n    }\n\n    /**\n     * Set whether this client is a guest account. <b>This method is experimental\n     * and may change without warning.</b>\n     * @param guest - True if this is a guest account.\n     * @experimental if the token is a macaroon, it should be encoded in it that it is a 'guest'\n     * access token, which means that the SDK can determine this entirely without\n     * the dev manually flipping this flag.\n     */\n    public setGuest(guest: boolean): void {\n        this.isGuestAccount = guest;\n    }\n\n    /**\n     * Return the provided scheduler, if any.\n     * @returns The scheduler or undefined\n     */\n    public getScheduler(): MatrixScheduler | undefined {\n        return this.scheduler;\n    }\n\n    /**\n     * Retry a backed off syncing request immediately. This should only be used when\n     * the user <b>explicitly</b> attempts to retry their lost connection.\n     * Will also retry any outbound to-device messages currently in the queue to be sent\n     * (retries of regular outgoing events are handled separately, per-event).\n     * @returns True if this resulted in a request being retried.\n     */\n    public retryImmediately(): boolean {\n        // don't await for this promise: we just want to kick it off\n        this.toDeviceMessageQueue.sendQueue();\n        return this.syncApi?.retryImmediately() ?? false;\n    }\n\n    /**\n     * Return the global notification EventTimelineSet, if any\n     *\n     * @returns the globl notification EventTimelineSet\n     */\n    public getNotifTimelineSet(): EventTimelineSet | null {\n        return this.notifTimelineSet;\n    }\n\n    /**\n     * Set the global notification EventTimelineSet\n     *\n     */\n    public setNotifTimelineSet(set: EventTimelineSet): void {\n        this.notifTimelineSet = set;\n    }\n\n    /**\n     * Gets the cached capabilities of the homeserver, returning cached ones if available.\n     * If there are no cached capabilities and none can be fetched, throw an exception.\n     *\n     * @returns Promise resolving with The capabilities of the homeserver\n     */\n    public async getCapabilities(): Promise<Capabilities> {\n        const caps = this.serverCapabilitiesService.getCachedCapabilities();\n        if (caps) return caps;\n        return this.serverCapabilitiesService.fetchCapabilities();\n    }\n\n    /**\n     * Gets the cached capabilities of the homeserver. If none have been fetched yet,\n     * return undefined.\n     *\n     * @returns The capabilities of the homeserver\n     */\n    public getCachedCapabilities(): Capabilities | undefined {\n        return this.serverCapabilitiesService.getCachedCapabilities();\n    }\n\n    /**\n     * Fetches the latest capabilities from the homeserver, ignoring any cached\n     * versions. The newly returned version is cached.\n     *\n     * @returns A promise which resolves to the capabilities of the homeserver\n     */\n    public fetchCapabilities(): Promise<Capabilities> {\n        return this.serverCapabilitiesService.fetchCapabilities();\n    }\n\n    /**\n     * Initialise support for end-to-end encryption in this client, using the rust matrix-sdk-crypto.\n     *\n     * **WARNING**: the cryptography stack is not thread-safe. Having multiple `MatrixClient` instances connected to\n     * the same Indexed DB will cause data corruption and decryption failures. The application layer is responsible for\n     * ensuring that only one `MatrixClient` issue is instantiated at a time.\n     *\n     * @param args.useIndexedDB - True to use an indexeddb store, false to use an in-memory store. Defaults to 'true'.\n     * @param args.storageKey - A key with which to encrypt the indexeddb store. If provided, it must be exactly\n     *    32 bytes of data, and must be the same each time the client is initialised for a given device.\n     *    If both this and `storagePassword` are unspecified, the store will be unencrypted.\n     * @param args.storagePassword - An alternative to `storageKey`. A password which will be used to derive a key to\n     *    encrypt the store with. Deriving a key from a password is (deliberately) a slow operation, so prefer\n     *    to pass a `storageKey` directly where possible.\n     *\n     * @returns a Promise which will resolve when the crypto layer has been\n     *    successfully initialised.\n     */\n    public async initRustCrypto(\n        args: {\n            useIndexedDB?: boolean;\n            storageKey?: Uint8Array;\n            storagePassword?: string;\n        } = {},\n    ): Promise<void> {\n        if (this.cryptoBackend) {\n            this.logger.warn(\"Attempt to re-initialise e2e encryption on MatrixClient\");\n            return;\n        }\n\n        const userId = this.getUserId();\n        if (userId === null) {\n            throw new Error(\n                `Cannot enable encryption on MatrixClient with unknown userId: ` +\n                    `ensure userId is passed in createClient().`,\n            );\n        }\n        const deviceId = this.getDeviceId();\n        if (deviceId === null) {\n            throw new Error(\n                `Cannot enable encryption on MatrixClient with unknown deviceId: ` +\n                    `ensure deviceId is passed in createClient().`,\n            );\n        }\n\n        // importing rust-crypto will download the webassembly, so we delay it until we know it will be\n        // needed.\n        this.logger.debug(\"Downloading Rust crypto library\");\n        const RustCrypto = await import(\"./rust-crypto/index.ts\");\n\n        const rustCrypto = await RustCrypto.initRustCrypto({\n            logger: this.logger,\n            http: this.http,\n            userId: userId,\n            deviceId: deviceId,\n            secretStorage: this.secretStorage,\n            cryptoCallbacks: this.cryptoCallbacks,\n            storePrefix: args.useIndexedDB === false ? null : RUST_SDK_STORE_PREFIX,\n            storeKey: args.storageKey,\n            storePassphrase: args.storagePassword,\n\n            legacyCryptoStore: this.legacyCryptoStore,\n            legacyPickleKey: this.legacyPickleKey ?? \"DEFAULT_KEY\",\n            legacyMigrationProgressListener: (progress: number, total: number): void => {\n                this.emit(CryptoEvent.LegacyCryptoStoreMigrationProgress, progress, total);\n            },\n        });\n\n        rustCrypto.setSupportedVerificationMethods(this.verificationMethods);\n\n        this.cryptoBackend = rustCrypto;\n\n        // attach the event listeners needed by RustCrypto\n        this.on(RoomMemberEvent.Membership, rustCrypto.onRoomMembership.bind(rustCrypto));\n        this.on(ClientEvent.Event, (event) => {\n            rustCrypto.onLiveEventFromSync(event);\n        });\n\n        // re-emit the events emitted by the crypto impl\n        this.reEmitter.reEmit(rustCrypto, [\n            CryptoEvent.VerificationRequestReceived,\n            CryptoEvent.UserTrustStatusChanged,\n            CryptoEvent.KeyBackupStatus,\n            CryptoEvent.KeyBackupSessionsRemaining,\n            CryptoEvent.KeyBackupFailed,\n            CryptoEvent.KeyBackupDecryptionKeyCached,\n            CryptoEvent.KeysChanged,\n            CryptoEvent.DevicesUpdated,\n            CryptoEvent.WillUpdateDevices,\n            CryptoEvent.DehydratedDeviceCreated,\n            CryptoEvent.DehydratedDeviceUploaded,\n            CryptoEvent.RehydrationStarted,\n            CryptoEvent.RehydrationProgress,\n            CryptoEvent.RehydrationCompleted,\n            CryptoEvent.RehydrationError,\n            CryptoEvent.DehydrationKeyCached,\n            CryptoEvent.DehydratedDeviceRotationError,\n        ]);\n    }\n\n    /**\n     * Access the server-side secret storage API for this client.\n     */\n    public get secretStorage(): ServerSideSecretStorage {\n        return this._secretStorage;\n    }\n\n    /**\n     * Access the crypto API for this client.\n     *\n     * If end-to-end encryption has been enabled for this client (via {@link initRustCrypto}),\n     * returns an object giving access to the crypto API. Otherwise, returns `undefined`.\n     */\n    public getCrypto(): CryptoApi | undefined {\n        return this.cryptoBackend;\n    }\n\n    /**\n     * Whether encryption is enabled for a room.\n     * @param roomId - the room id to query.\n     * @returns whether encryption is enabled.\n     *\n     * @deprecated Not correctly supported for Rust Cryptography. Use {@link CryptoApi.isEncryptionEnabledInRoom} and/or\n     *    {@link Room.hasEncryptionStateEvent}.\n     */\n    public isRoomEncrypted(roomId: string): boolean {\n        const room = this.getRoom(roomId);\n        if (!room) {\n            // we don't know about this room, so can't determine if it should be\n            // encrypted. Let's assume not.\n            return false;\n        }\n\n        // if there is an 'm.room.encryption' event in this room, it should be\n        // encrypted (independently of whether we actually support encryption)\n        return room.hasEncryptionStateEvent();\n    }\n\n    /**\n     * Check whether the key backup private key is stored in secret storage.\n     * @returns map of key name to key info the secret is\n     *     encrypted with, or null if it is not present or not encrypted with a\n     *     trusted key\n     */\n    public isKeyBackupKeyStored(): Promise<Record<string, SecretStorageKeyDescription> | null> {\n        return Promise.resolve(this.secretStorage.isStored(\"m.megolm_backup.v1\"));\n    }\n\n    private makeKeyBackupPath(roomId?: string, sessionId?: string, version?: string): IKeyBackupPath {\n        let path: string;\n        if (sessionId !== undefined) {\n            path = utils.encodeUri(\"/room_keys/keys/$roomId/$sessionId\", {\n                $roomId: roomId!,\n                $sessionId: sessionId,\n            });\n        } else if (roomId !== undefined) {\n            path = utils.encodeUri(\"/room_keys/keys/$roomId\", {\n                $roomId: roomId,\n            });\n        } else {\n            path = \"/room_keys/keys\";\n        }\n        const queryData = version === undefined ? undefined : { version };\n        return { path, queryData };\n    }\n\n    public deleteKeysFromBackup(roomId: undefined, sessionId: undefined, version?: string): Promise<void>;\n    public deleteKeysFromBackup(roomId: string, sessionId: undefined, version?: string): Promise<void>;\n    public deleteKeysFromBackup(roomId: string, sessionId: string, version?: string): Promise<void>;\n    public async deleteKeysFromBackup(roomId?: string, sessionId?: string, version?: string): Promise<void> {\n        const path = this.makeKeyBackupPath(roomId!, sessionId!, version);\n        await this.http.authedRequest(Method.Delete, path.path, path.queryData, undefined, { prefix: ClientPrefix.V3 });\n    }\n\n    /**\n     * Get the config for the media repository.\n     * @returns Promise which resolves with an object containing the config.\n     */\n    public getMediaConfig(): Promise<IMediaConfig> {\n        return this.http.authedRequest(Method.Get, \"/config\", undefined, undefined, {\n            prefix: MediaPrefix.V3,\n        });\n    }\n\n    /**\n     * Get the room for the given room ID.\n     * This function will return a valid room for any room for which a Room event\n     * has been emitted. Note in particular that other events, eg. RoomState.members\n     * will be emitted for a room before this function will return the given room.\n     * @param roomId - The room ID\n     * @returns The Room or null if it doesn't exist or there is no data store.\n     */\n    public getRoom(roomId: string | undefined): Room | null {\n        if (!roomId) {\n            return null;\n        }\n        return this.store.getRoom(roomId);\n    }\n\n    /**\n     * Retrieve all known rooms.\n     * @returns A list of rooms, or an empty list if there is no data store.\n     */\n    public getRooms(): Room[] {\n        return this.store.getRooms();\n    }\n\n    /**\n     * Retrieve all rooms that should be displayed to the user\n     * This is essentially getRooms() with some rooms filtered out, eg. old versions\n     * of rooms that have been replaced or (in future) other rooms that have been\n     * marked at the protocol level as not to be displayed to the user.\n     *\n     * @param msc3946ProcessDynamicPredecessor - if true, look for an\n     *                                           m.room.predecessor state event and\n     *                                           use it if found (MSC3946).\n     * @returns A list of rooms, or an empty list if there is no data store.\n     */\n    public getVisibleRooms(msc3946ProcessDynamicPredecessor = false): Room[] {\n        const allRooms = this.store.getRooms();\n\n        const replacedRooms = new Set();\n        for (const r of allRooms) {\n            const predecessor = r.findPredecessor(msc3946ProcessDynamicPredecessor)?.roomId;\n            if (predecessor) {\n                replacedRooms.add(predecessor);\n            }\n        }\n\n        return allRooms.filter((r) => {\n            const tombstone = r.currentState.getStateEvents(EventType.RoomTombstone, \"\");\n            if (tombstone && replacedRooms.has(r.roomId)) {\n                return false;\n            }\n            return true;\n        });\n    }\n\n    /**\n     * Retrieve a user.\n     * @param userId - The user ID to retrieve.\n     * @returns A user or null if there is no data store or the user does\n     * not exist.\n     */\n    public getUser(userId: string): User | null {\n        return this.store.getUser(userId);\n    }\n\n    /**\n     * Retrieve all known users.\n     * @returns A list of users, or an empty list if there is no data store.\n     */\n    public getUsers(): User[] {\n        return this.store.getUsers();\n    }\n\n    /**\n     * Set account data event for the current user, and wait for the result to be echoed over `/sync`.\n     *\n     * Waiting for the remote echo ensures that a subsequent call to {@link getAccountData} will return the updated\n     * value.\n     *\n     * If called before the client is started with {@link startClient}, logs a warning and falls back to\n     * {@link setAccountDataRaw}.\n     *\n     * Retries the request up to 5 times in the case of an {@link ConnectionError}.\n     *\n     * @param eventType - The event type\n     * @param content - the contents object for the event\n     */\n    public async setAccountData<K extends keyof AccountDataEvents>(\n        eventType: K,\n        content: AccountDataEvents[K] | Record<string, never>,\n    ): Promise<EmptyObject> {\n        // If the sync loop is not running, fall back to setAccountDataRaw.\n        if (!this.clientRunning) {\n            logger.warn(\n                \"Calling `setAccountData` before the client is started: `getAccountData` may return inconsistent results.\",\n            );\n            return await retryNetworkOperation(5, () => this.setAccountDataRaw(eventType, content));\n        }\n\n        // If the account data is already correct, then we cannot expect an update over sync, and the operation\n        // is, in any case, a no-op.\n        //\n        // NB that we rely on this operation being synchronous to avoid a race condition: there must be no `await`\n        // between here and `this.addListener` below, in case we miss an update.\n        const existingData = this.store.getAccountData(eventType);\n        if (existingData && deepCompare(existingData.event.content, content)) return {};\n\n        // Create a promise which will resolve when the update is received\n        const updatedDefer = defer<void>();\n        function accountDataListener(event: MatrixEvent): void {\n            // Note that we cannot safely check that the content matches what we expected, because there is a race:\n            //   * We set the new content\n            //   * Another client sets alternative content\n            //   * Then /sync returns, but only reflects the latest content.\n            //\n            // Of course there is room for debate over what we should actually do in that case -- a subsequent\n            // `getAccountData` isn't going to return the expected value, but whose fault is that? Databases are hard.\n            //\n            // Anyway, what we *shouldn't* do is get stuck in a loop. I think the best we can do is check that the event\n            // type matches.\n            if (event.getType() === eventType) updatedDefer.resolve();\n        }\n        this.addListener(ClientEvent.AccountData, accountDataListener);\n\n        try {\n            const result = await retryNetworkOperation(5, () => this.setAccountDataRaw(eventType, content));\n            await updatedDefer.promise;\n            return result;\n        } finally {\n            this.removeListener(ClientEvent.AccountData, accountDataListener);\n        }\n    }\n\n    /**\n     * Set account data event for the current user, without waiting for the remote echo.\n     *\n     * @param eventType - The event type\n     * @param content - the contents object for the event\n     */\n    public setAccountDataRaw<K extends keyof AccountDataEvents>(\n        eventType: K,\n        content: AccountDataEvents[K] | Record<string, never>,\n    ): Promise<EmptyObject> {\n        const path = utils.encodeUri(\"/user/$userId/account_data/$type\", {\n            $userId: this.credentials.userId!,\n            $type: eventType,\n        });\n\n        return this.http.authedRequest(Method.Put, path, undefined, content);\n    }\n\n    /**\n     * Get account data event of given type for the current user.\n     * @param eventType - The event type\n     * @returns The contents of the given account data event\n     */\n    public getAccountData<K extends keyof AccountDataEvents>(eventType: K): MatrixEvent | undefined {\n        return this.store.getAccountData(eventType);\n    }\n\n    /**\n     * Get account data event of given type for the current user. This variant\n     * gets account data directly from the homeserver if the local store is not\n     * ready, which can be useful very early in startup before the initial sync.\n     * @param eventType - The event type\n     * @returns Promise which resolves: The contents of the given account data event.\n     * @returns Rejects: with an error response.\n     */\n    public async getAccountDataFromServer<K extends keyof AccountDataEvents>(\n        eventType: K,\n    ): Promise<AccountDataEvents[K] | null> {\n        if (this.isInitialSyncComplete()) {\n            const event = this.store.getAccountData(eventType);\n            if (!event) {\n                return null;\n            }\n            // The network version below returns just the content, so this branch\n            // does the same to match.\n            return event.getContent<AccountDataEvents[K]>();\n        }\n        const path = utils.encodeUri(\"/user/$userId/account_data/$type\", {\n            $userId: this.credentials.userId!,\n            $type: eventType,\n        });\n        try {\n            return await this.http.authedRequest(Method.Get, path);\n        } catch (e) {\n            if ((<MatrixError>e).data?.errcode === \"M_NOT_FOUND\") {\n                return null;\n            }\n            throw e;\n        }\n    }\n\n    public async deleteAccountData(eventType: keyof AccountDataEvents): Promise<void> {\n        const msc3391DeleteAccountDataServerSupport = this.canSupport.get(Feature.AccountDataDeletion);\n        // if deletion is not supported overwrite with empty content\n        if (msc3391DeleteAccountDataServerSupport === ServerSupport.Unsupported) {\n            await this.setAccountData(eventType, {});\n            return;\n        }\n        const path = utils.encodeUri(\"/user/$userId/account_data/$type\", {\n            $userId: this.getSafeUserId(),\n            $type: eventType,\n        });\n        const options =\n            msc3391DeleteAccountDataServerSupport === ServerSupport.Unstable\n                ? { prefix: \"/_matrix/client/unstable/org.matrix.msc3391\" }\n                : undefined;\n        return await this.http.authedRequest(Method.Delete, path, undefined, undefined, options);\n    }\n\n    /**\n     * Gets the users that are ignored by this client\n     * @returns The array of users that are ignored (empty if none)\n     */\n    public getIgnoredUsers(): string[] {\n        const event = this.getAccountData(EventType.IgnoredUserList);\n        if (!event?.getContent()[\"ignored_users\"]) return [];\n        return Object.keys(event.getContent()[\"ignored_users\"]);\n    }\n\n    /**\n     * Sets the users that the current user should ignore.\n     * @param userIds - the user IDs to ignore\n     * @returns Promise which resolves: an empty object\n     * @returns Rejects: with an error response.\n     */\n    public setIgnoredUsers(userIds: string[]): Promise<EmptyObject> {\n        const content = { ignored_users: {} as Record<string, EmptyObject> };\n        userIds.forEach((u) => {\n            content.ignored_users[u] = {};\n        });\n        return this.setAccountData(EventType.IgnoredUserList, content);\n    }\n\n    /**\n     * Gets whether or not a specific user is being ignored by this client.\n     * @param userId - the user ID to check\n     * @returns true if the user is ignored, false otherwise\n     */\n    public isUserIgnored(userId: string): boolean {\n        return this.getIgnoredUsers().includes(userId);\n    }\n\n    /**\n     * Join a room. If you have already joined the room, this will no-op.\n     * @param roomIdOrAlias - The room ID or room alias to join.\n     * @param opts - Options when joining the room.\n     * @returns Promise which resolves: Room object.\n     * @returns Rejects: with an error response.\n     */\n    public async joinRoom(roomIdOrAlias: string, opts: IJoinRoomOpts = {}): Promise<Room> {\n        if (opts.syncRoom === undefined) {\n            opts.syncRoom = true;\n        }\n\n        const room = this.getRoom(roomIdOrAlias);\n        if (room?.hasMembershipState(this.credentials.userId!, KnownMembership.Join)) return room;\n\n        let signPromise: Promise<IThirdPartySigned | void> = Promise.resolve();\n\n        if (opts.inviteSignUrl) {\n            const url = new URL(opts.inviteSignUrl);\n            url.searchParams.set(\"mxid\", this.credentials.userId!);\n            signPromise = this.http.requestOtherUrl<IThirdPartySigned>(Method.Post, url);\n        }\n\n        const queryParams: QueryDict = {};\n        if (opts.viaServers) {\n            // server_name has been deprecated in favour of via with Matrix >1.11 (MSC4156)\n            queryParams.server_name = opts.viaServers;\n            queryParams.via = opts.viaServers;\n        }\n\n        const data: IJoinRequestBody = {};\n        const signedInviteObj = await signPromise;\n        if (signedInviteObj) {\n            data.third_party_signed = signedInviteObj;\n        }\n\n        const path = utils.encodeUri(\"/join/$roomid\", { $roomid: roomIdOrAlias });\n        const res = await this.http.authedRequest<{ room_id: string }>(Method.Post, path, queryParams, data);\n\n        const roomId = res.room_id;\n        // In case we were originally given an alias, check the room cache again\n        // with the resolved ID - this method is supposed to no-op if we already\n        // were in the room, after all.\n        const resolvedRoom = this.getRoom(roomId);\n        if (resolvedRoom?.hasMembershipState(this.credentials.userId!, KnownMembership.Join)) return resolvedRoom;\n\n        const syncApi = new SyncApi(this, this.clientOpts, this.buildSyncApiOptions());\n        const syncRoom = syncApi.createRoom(roomId);\n        if (opts.syncRoom) {\n            // v2 will do this for us\n            // return syncApi.syncRoom(room);\n        }\n        return syncRoom;\n    }\n\n    /**\n     * Knock a room. If you have already knocked the room, this will no-op.\n     * @param roomIdOrAlias - The room ID or room alias to knock.\n     * @param opts - Options when knocking the room.\n     * @returns Promise which resolves: `{room_id: {string}}`\n     * @returns Rejects: with an error response.\n     */\n    public knockRoom(roomIdOrAlias: string, opts: KnockRoomOpts = {}): Promise<{ room_id: string }> {\n        const room = this.getRoom(roomIdOrAlias);\n        if (room?.hasMembershipState(this.credentials.userId!, KnownMembership.Knock)) {\n            return Promise.resolve({ room_id: room.roomId });\n        }\n\n        const path = utils.encodeUri(\"/knock/$roomIdOrAlias\", { $roomIdOrAlias: roomIdOrAlias });\n\n        const queryParams: QueryDict = {};\n        if (opts.viaServers) {\n            // server_name has been deprecated in favour of via with Matrix >1.11 (MSC4156)\n            queryParams.server_name = opts.viaServers;\n            queryParams.via = opts.viaServers;\n        }\n\n        const body: Record<string, string> = {};\n        if (opts.reason) {\n            body.reason = opts.reason;\n        }\n\n        return this.http.authedRequest(Method.Post, path, queryParams, body);\n    }\n\n    /**\n     * Resend an event. Will also retry any to-device messages waiting to be sent.\n     * @param event - The event to resend.\n     * @param room - Optional. The room the event is in. Will update the\n     * timeline entry if provided.\n     * @returns Promise which resolves: to an ISendEventResponse object\n     * @returns Rejects: with an error response.\n     */\n    public resendEvent(event: MatrixEvent, room: Room): Promise<ISendEventResponse> {\n        // also kick the to-device queue to retry\n        this.toDeviceMessageQueue.sendQueue();\n\n        this.updatePendingEventStatus(room, event, EventStatus.SENDING);\n        return this.encryptAndSendEvent(room, event);\n    }\n\n    /**\n     * Cancel a queued or unsent event.\n     *\n     * @param event -   Event to cancel\n     * @throws Error if the event is not in QUEUED, NOT_SENT or ENCRYPTING state\n     */\n    public cancelPendingEvent(event: MatrixEvent): void {\n        if (![EventStatus.QUEUED, EventStatus.NOT_SENT, EventStatus.ENCRYPTING].includes(event.status!)) {\n            throw new Error(\"cannot cancel an event with status \" + event.status);\n        }\n\n        // If the event is currently being encrypted then remove it from the pending list, to indicate that it should\n        // not be sent.\n        if (event.status === EventStatus.ENCRYPTING) {\n            this.eventsBeingEncrypted.delete(event.getId()!);\n        } else if (this.scheduler && event.status === EventStatus.QUEUED) {\n            // tell the scheduler to forget about it, if it's queued\n            this.scheduler.removeEventFromQueue(event);\n        }\n\n        // then tell the room about the change of state, which will remove it\n        // from the room's list of pending events.\n        const room = this.getRoom(event.getRoomId());\n        this.updatePendingEventStatus(room, event, EventStatus.CANCELLED);\n    }\n\n    /**\n     * @returns Promise which resolves: TODO\n     * @returns Rejects: with an error response.\n     */\n    public setRoomName(roomId: string, name: string): Promise<ISendEventResponse> {\n        return this.sendStateEvent(roomId, EventType.RoomName, { name: name });\n    }\n\n    /**\n     * @param roomId - The room to update the topic in.\n     * @param topic - The plaintext topic. May be empty to remove the topic.\n     * @param htmlTopic - Optional.\n     * @returns Promise which resolves: TODO\n     * @returns Rejects: with an error response.\n     */\n    public setRoomTopic(roomId: string, topic?: string, htmlTopic?: string): Promise<ISendEventResponse> {\n        const content = ContentHelpers.makeTopicContent(topic, htmlTopic);\n        return this.sendStateEvent(roomId, EventType.RoomTopic, content);\n    }\n\n    /**\n     * @returns Promise which resolves: to an object keyed by tagId with objects containing a numeric order field.\n     * @returns Rejects: with an error response.\n     */\n    public getRoomTags(roomId: string): Promise<ITagsResponse> {\n        const path = utils.encodeUri(\"/user/$userId/rooms/$roomId/tags\", {\n            $userId: this.credentials.userId!,\n            $roomId: roomId,\n        });\n        return this.http.authedRequest(Method.Get, path);\n    }\n\n    /**\n     * @param tagName - name of room tag to be set\n     * @param metadata - associated with that tag to be stored\n     * @returns Promise which resolves: to an empty object\n     * @returns Rejects: with an error response.\n     */\n    public setRoomTag(roomId: string, tagName: string, metadata: ITagMetadata = {}): Promise<EmptyObject> {\n        const path = utils.encodeUri(\"/user/$userId/rooms/$roomId/tags/$tag\", {\n            $userId: this.credentials.userId!,\n            $roomId: roomId,\n            $tag: tagName,\n        });\n        return this.http.authedRequest(Method.Put, path, undefined, metadata);\n    }\n\n    /**\n     * @param tagName - name of room tag to be removed\n     * @returns Promise which resolves: to an empty object\n     * @returns Rejects: with an error response.\n     */\n    public deleteRoomTag(roomId: string, tagName: string): Promise<EmptyObject> {\n        const path = utils.encodeUri(\"/user/$userId/rooms/$roomId/tags/$tag\", {\n            $userId: this.credentials.userId!,\n            $roomId: roomId,\n            $tag: tagName,\n        });\n        return this.http.authedRequest(Method.Delete, path);\n    }\n\n    /**\n     * @param eventType - event type to be set\n     * @param content - event content\n     * @returns Promise which resolves: to an empty object `{}`\n     * @returns Rejects: with an error response.\n     */\n    public setRoomAccountData(roomId: string, eventType: string, content: Record<string, any>): Promise<EmptyObject> {\n        const path = utils.encodeUri(\"/user/$userId/rooms/$roomId/account_data/$type\", {\n            $userId: this.credentials.userId!,\n            $roomId: roomId,\n            $type: eventType,\n        });\n        return this.http.authedRequest(Method.Put, path, undefined, content);\n    }\n\n    /**\n     * Set a power level to one or multiple users.\n     * Will apply changes atop of current power level event from local state if running & synced, falling back\n     * to fetching latest from the `/state/` API.\n     * @param roomId - the room to update power levels in\n     * @param userId - the ID of the user or users to update power levels of\n     * @param powerLevel - the numeric power level to update given users to\n     * @returns Promise which resolves: to an ISendEventResponse object\n     * @returns Rejects: with an error response.\n     */\n    public async setPowerLevel(\n        roomId: string,\n        userId: string | string[],\n        powerLevel: number | undefined,\n    ): Promise<ISendEventResponse> {\n        let content: IPowerLevelsContent | undefined;\n        if (this.clientRunning && this.isInitialSyncComplete()) {\n            content = this.getRoom(roomId)?.currentState?.getStateEvents(EventType.RoomPowerLevels, \"\")?.getContent();\n        }\n        if (!content) {\n            try {\n                content = await this.getStateEvent(roomId, EventType.RoomPowerLevels, \"\");\n            } catch (e) {\n                // It is possible for a Matrix room to not have a power levels event\n                if (e instanceof MatrixError && e.errcode === \"M_NOT_FOUND\") {\n                    content = {};\n                } else {\n                    throw e;\n                }\n            }\n        }\n\n        // take a copy of the content to ensure we don't corrupt\n        // existing client state with a failed power level change\n        content = utils.deepCopy(content);\n\n        if (!content?.users) {\n            content.users = {};\n        }\n        const users = Array.isArray(userId) ? userId : [userId];\n        for (const user of users) {\n            if (powerLevel == null) {\n                delete content.users[user];\n            } else {\n                content.users[user] = powerLevel;\n            }\n        }\n\n        return this.sendStateEvent(roomId, EventType.RoomPowerLevels, content, \"\");\n    }\n\n    /**\n     * Create an m.beacon_info event\n     * @returns\n     */\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    public async unstable_createLiveBeacon(\n        roomId: Room[\"roomId\"],\n        beaconInfoContent: MBeaconInfoEventContent,\n    ): Promise<ISendEventResponse> {\n        return this.unstable_setLiveBeacon(roomId, beaconInfoContent);\n    }\n\n    /**\n     * Upsert a live beacon event\n     * using a specific m.beacon_info.* event variable type\n     * @param roomId - string\n     * @returns\n     */\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    public async unstable_setLiveBeacon(\n        roomId: string,\n        beaconInfoContent: MBeaconInfoEventContent,\n    ): Promise<ISendEventResponse> {\n        return this.sendStateEvent(roomId, M_BEACON_INFO.name, beaconInfoContent, this.getUserId()!);\n    }\n\n    public sendEvent<K extends keyof TimelineEvents>(\n        roomId: string,\n        eventType: K,\n        content: TimelineEvents[K],\n        txnId?: string,\n    ): Promise<ISendEventResponse>;\n    public sendEvent<K extends keyof TimelineEvents>(\n        roomId: string,\n        threadId: string | null,\n        eventType: K,\n        content: TimelineEvents[K],\n        txnId?: string,\n    ): Promise<ISendEventResponse>;\n    public sendEvent(\n        roomId: string,\n        threadIdOrEventType: string | null,\n        eventTypeOrContent: string | IContent,\n        contentOrTxnId?: IContent | string,\n        txnIdOrVoid?: string,\n    ): Promise<ISendEventResponse> {\n        let threadId: string | null;\n        let eventType: string;\n        let content: IContent;\n        let txnId: string | undefined;\n        if (!threadIdOrEventType?.startsWith(EVENT_ID_PREFIX) && threadIdOrEventType !== null) {\n            txnId = contentOrTxnId as string;\n            content = eventTypeOrContent as IContent;\n            eventType = threadIdOrEventType;\n            threadId = null;\n        } else {\n            txnId = txnIdOrVoid;\n            content = contentOrTxnId as IContent;\n            eventType = eventTypeOrContent as string;\n            threadId = threadIdOrEventType;\n        }\n\n        this.addThreadRelationIfNeeded(content, threadId, roomId);\n        return this.sendCompleteEvent(roomId, threadId, { type: eventType, content }, txnId);\n    }\n\n    /**\n     * If we expect that an event is part of a thread but is missing the relation\n     * we need to add it manually, as well as the reply fallback\n     */\n    private addThreadRelationIfNeeded(content: IContent, threadId: string | null, roomId: string): void {\n        if (threadId && !content[\"m.relates_to\"]?.rel_type) {\n            const isReply = !!content[\"m.relates_to\"]?.[\"m.in_reply_to\"];\n            content[\"m.relates_to\"] = {\n                ...content[\"m.relates_to\"],\n                rel_type: THREAD_RELATION_TYPE.name,\n                event_id: threadId,\n                // Set is_falling_back to true unless this is actually intended to be a reply\n                is_falling_back: !isReply,\n            };\n            const thread = this.getRoom(roomId)?.getThread(threadId);\n            if (thread && !isReply) {\n                content[\"m.relates_to\"][\"m.in_reply_to\"] = {\n                    event_id:\n                        thread\n                            .lastReply((ev: MatrixEvent) => {\n                                return ev.isRelation(THREAD_RELATION_TYPE.name) && !ev.status;\n                            })\n                            ?.getId() ?? threadId,\n                };\n            }\n        }\n    }\n\n    /**\n     * @param eventObject - An object with the partial structure of an event, to which event_id, user_id, room_id and origin_server_ts will be added.\n     * @param txnId - Optional.\n     * @returns Promise which resolves: to an empty object `{}`\n     * @returns Rejects: with an error response.\n     */\n    private sendCompleteEvent(\n        roomId: string,\n        threadId: string | null,\n        eventObject: Partial<IEvent>,\n        txnId?: string,\n    ): Promise<ISendEventResponse>;\n    /**\n     * Sends a delayed event (MSC4140).\n     * @param eventObject - An object with the partial structure of an event, to which event_id, user_id, room_id and origin_server_ts will be added.\n     * @param delayOpts - Properties of the delay for this event.\n     * @param txnId - Optional.\n     * @returns Promise which resolves: to an empty object `{}`\n     * @returns Rejects: with an error response.\n     */\n    private sendCompleteEvent(\n        roomId: string,\n        threadId: string | null,\n        eventObject: Partial<IEvent>,\n        delayOpts: SendDelayedEventRequestOpts,\n        txnId?: string,\n    ): Promise<SendDelayedEventResponse>;\n    private sendCompleteEvent(\n        roomId: string,\n        threadId: string | null,\n        eventObject: Partial<IEvent>,\n        delayOptsOrTxnId?: SendDelayedEventRequestOpts | string,\n        txnIdOrVoid?: string,\n    ): Promise<ISendEventResponse | SendDelayedEventResponse> {\n        let delayOpts: SendDelayedEventRequestOpts | undefined;\n        let txnId: string | undefined;\n        if (typeof delayOptsOrTxnId === \"string\") {\n            txnId = delayOptsOrTxnId;\n        } else {\n            delayOpts = delayOptsOrTxnId;\n            txnId = txnIdOrVoid;\n        }\n\n        if (!txnId) {\n            txnId = this.makeTxnId();\n        }\n\n        // We always construct a MatrixEvent when sending because the store and scheduler use them.\n        // We'll extract the params back out if it turns out the client has no scheduler or store.\n        const localEvent = new MatrixEvent(\n            Object.assign(eventObject, {\n                event_id: \"~\" + roomId + \":\" + txnId,\n                user_id: this.credentials.userId,\n                sender: this.credentials.userId,\n                room_id: roomId,\n                origin_server_ts: new Date().getTime(),\n            }),\n        );\n\n        const room = this.getRoom(roomId);\n        const thread = threadId ? room?.getThread(threadId) : undefined;\n        if (thread) {\n            localEvent.setThread(thread);\n        }\n\n        if (!delayOpts) {\n            // set up re-emitter for this new event - this is normally the job of EventMapper but we don't use it here\n            this.reEmitter.reEmit(localEvent, [MatrixEventEvent.Replaced, MatrixEventEvent.VisibilityChange]);\n            room?.reEmitter.reEmit(localEvent, [MatrixEventEvent.BeforeRedaction]);\n        }\n\n        // if this is a relation or redaction of an event\n        // that hasn't been sent yet (e.g. with a local id starting with a ~)\n        // then listen for the remote echo of that event so that by the time\n        // this event does get sent, we have the correct event_id\n        const targetId = localEvent.getAssociatedId();\n        if (targetId?.startsWith(\"~\")) {\n            const target = room?.getPendingEvents().find((e) => e.getId() === targetId);\n            target?.once(MatrixEventEvent.LocalEventIdReplaced, () => {\n                localEvent.updateAssociatedId(target.getId()!);\n            });\n        }\n\n        const type = localEvent.getType();\n        this.logger.debug(\n            `sendEvent of type ${type} in ${roomId} with txnId ${txnId}${delayOpts ? \" (delayed event)\" : \"\"}`,\n        );\n\n        localEvent.setTxnId(txnId);\n        localEvent.setStatus(EventStatus.SENDING);\n\n        // TODO: separate store for delayed events?\n        if (!delayOpts) {\n            // add this event immediately to the local store as 'sending'.\n            room?.addPendingEvent(localEvent, txnId);\n\n            // addPendingEvent can change the state to NOT_SENT if it believes\n            // that there's other events that have failed. We won't bother to\n            // try sending the event if the state has changed as such.\n            if (localEvent.status === EventStatus.NOT_SENT) {\n                return Promise.reject(new Error(\"Event blocked by other events not yet sent\"));\n            }\n\n            return this.encryptAndSendEvent(room, localEvent);\n        } else {\n            return this.encryptAndSendEvent(room, localEvent, delayOpts);\n        }\n    }\n\n    /**\n     * encrypts the event if necessary; adds the event to the queue, or sends it; marks the event as sent/unsent\n     * @returns returns a promise which resolves with the result of the send request\n     */\n    protected async encryptAndSendEvent(room: Room | null, event: MatrixEvent): Promise<ISendEventResponse>;\n    /**\n     * Simply sends a delayed event without encrypting it.\n     * TODO: Allow encrypted delayed events, and encrypt them properly\n     * @param delayOpts - Properties of the delay for this event.\n     * @returns returns a promise which resolves with the result of the delayed send request\n     */\n    protected async encryptAndSendEvent(\n        room: Room | null,\n        event: MatrixEvent,\n        delayOpts: SendDelayedEventRequestOpts,\n    ): Promise<SendDelayedEventResponse>;\n    protected async encryptAndSendEvent(\n        room: Room | null,\n        event: MatrixEvent,\n        delayOpts?: SendDelayedEventRequestOpts,\n    ): Promise<ISendEventResponse | SendDelayedEventResponse> {\n        if (delayOpts) {\n            return this.sendEventHttpRequest(event, delayOpts);\n        }\n\n        try {\n            let cancelled: boolean;\n            this.eventsBeingEncrypted.add(event.getId()!);\n            try {\n                await this.encryptEventIfNeeded(event, room ?? undefined);\n            } finally {\n                cancelled = !this.eventsBeingEncrypted.delete(event.getId()!);\n            }\n\n            if (cancelled) {\n                // cancelled via MatrixClient::cancelPendingEvent\n                return {} as ISendEventResponse;\n            }\n\n            // encryptEventIfNeeded may have updated the status from SENDING to ENCRYPTING. If so, we need\n            // to put it back.\n            if (event.status === EventStatus.ENCRYPTING) {\n                this.updatePendingEventStatus(room, event, EventStatus.SENDING);\n            }\n\n            let promise: Promise<ISendEventResponse> | null = null;\n            if (this.scheduler) {\n                // if this returns a promise then the scheduler has control now and will\n                // resolve/reject when it is done. Internally, the scheduler will invoke\n                // processFn which is set to this._sendEventHttpRequest so the same code\n                // path is executed regardless.\n                promise = this.scheduler.queueEvent(event);\n                if (promise && this.scheduler.getQueueForEvent(event)!.length > 1) {\n                    // event is processed FIFO so if the length is 2 or more we know\n                    // this event is stuck behind an earlier event.\n                    this.updatePendingEventStatus(room, event, EventStatus.QUEUED);\n                }\n            }\n\n            if (!promise) {\n                promise = this.sendEventHttpRequest(event);\n                if (room) {\n                    promise = promise.then((res) => {\n                        room.updatePendingEvent(event, EventStatus.SENT, res[\"event_id\"]);\n                        return res;\n                    });\n                }\n            }\n\n            return await promise;\n        } catch (err) {\n            this.logger.error(\"Error sending event\", err);\n            try {\n                // set the error on the event before we update the status:\n                // updating the status emits the event, so the state should be\n                // consistent at that point.\n                event.error = <MatrixError>err;\n                this.updatePendingEventStatus(room, event, EventStatus.NOT_SENT);\n            } catch (e) {\n                this.logger.error(\"Exception in error handler!\", e);\n            }\n            if (err instanceof MatrixError) {\n                err.event = event;\n            }\n            throw err;\n        }\n    }\n\n    private async encryptEventIfNeeded(event: MatrixEvent, room?: Room): Promise<void> {\n        // If the room is unknown, we cannot encrypt for it\n        if (!room) return;\n\n        if (!(await this.shouldEncryptEventForRoom(event, room))) return;\n\n        if (!this.cryptoBackend && this.usingExternalCrypto) {\n            // The client has opted to allow sending messages to encrypted\n            // rooms even if the room is encrypted, and we haven't set up\n            // crypto. This is useful for users of matrix-org/pantalaimon\n            return;\n        }\n\n        if (!this.cryptoBackend) {\n            throw new Error(\"This room is configured to use encryption, but your client does not support encryption.\");\n        }\n\n        this.updatePendingEventStatus(room, event, EventStatus.ENCRYPTING);\n        await this.cryptoBackend.encryptEvent(event, room);\n    }\n\n    /**\n     * Determine whether a given event should be encrypted when we send it to the given room.\n     *\n     * This takes into account event type and room configuration.\n     */\n    private async shouldEncryptEventForRoom(event: MatrixEvent, room: Room): Promise<boolean> {\n        if (event.isEncrypted()) {\n            // this event has already been encrypted; this happens if the\n            // encryption step succeeded, but the send step failed on the first\n            // attempt.\n            return false;\n        }\n\n        if (event.getType() === EventType.Reaction) {\n            // For reactions, there is a very little gained by encrypting the entire\n            // event, as relation data is already kept in the clear. Event\n            // encryption for a reaction effectively only obscures the event type,\n            // but the purpose is still obvious from the relation data, so nothing\n            // is really gained. It also causes quite a few problems, such as:\n            //   * triggers notifications via default push rules\n            //   * prevents server-side bundling for reactions\n            // The reaction key / content / emoji value does warrant encrypting, but\n            // this will be handled separately by encrypting just this value.\n            // See https://github.com/matrix-org/matrix-doc/pull/1849#pullrequestreview-248763642\n            return false;\n        }\n\n        if (event.isRedaction()) {\n            // Redactions do not support encryption in the spec at this time.\n            // Whilst it mostly worked in some clients, it wasn't compliant.\n            return false;\n        }\n\n        // If the room has an m.room.encryption event, we should encrypt.\n        if (room.hasEncryptionStateEvent()) return true;\n\n        // If we have a crypto impl, and *it* thinks we should encrypt, then we should.\n        if (await this.cryptoBackend?.isEncryptionEnabledInRoom(room.roomId)) return true;\n\n        // Otherwise, no need to encrypt.\n        return false;\n    }\n\n    /**\n     * Returns the eventType that should be used taking encryption into account\n     * for a given eventType.\n     * @param roomId - the room for the events `eventType` relates to\n     * @param eventType - the event type\n     * @returns the event type taking encryption into account\n     */\n    private getEncryptedIfNeededEventType(\n        roomId: string,\n        eventType?: EventType | string | null,\n    ): EventType | string | null | undefined {\n        if (eventType === EventType.Reaction) return eventType;\n        return this.getRoom(roomId)?.hasEncryptionStateEvent() ? EventType.RoomMessageEncrypted : eventType;\n    }\n\n    protected updatePendingEventStatus(room: Room | null, event: MatrixEvent, newStatus: EventStatus): void {\n        if (room) {\n            room.updatePendingEvent(event, newStatus);\n        } else {\n            event.setStatus(newStatus);\n        }\n    }\n\n    private sendEventHttpRequest(event: MatrixEvent): Promise<ISendEventResponse>;\n    private sendEventHttpRequest(\n        event: MatrixEvent,\n        delayOpts: SendDelayedEventRequestOpts,\n    ): Promise<SendDelayedEventResponse>;\n    private sendEventHttpRequest(\n        event: MatrixEvent,\n        delayOpts?: SendDelayedEventRequestOpts,\n    ): Promise<ISendEventResponse | SendDelayedEventResponse> {\n        let txnId = event.getTxnId();\n        if (!txnId) {\n            txnId = this.makeTxnId();\n            event.setTxnId(txnId);\n        }\n\n        const pathParams = {\n            $roomId: event.getRoomId()!,\n            $eventType: event.getWireType(),\n            $stateKey: event.getStateKey()!,\n            $txnId: txnId,\n        };\n\n        let path: string;\n\n        if (event.isState()) {\n            let pathTemplate = \"/rooms/$roomId/state/$eventType\";\n            if (event.getStateKey() && event.getStateKey()!.length > 0) {\n                pathTemplate = \"/rooms/$roomId/state/$eventType/$stateKey\";\n            }\n            path = utils.encodeUri(pathTemplate, pathParams);\n        } else if (event.isRedaction() && event.event.redacts) {\n            const pathTemplate = `/rooms/$roomId/redact/$redactsEventId/$txnId`;\n            path = utils.encodeUri(pathTemplate, {\n                $redactsEventId: event.event.redacts,\n                ...pathParams,\n            });\n        } else {\n            path = utils.encodeUri(\"/rooms/$roomId/send/$eventType/$txnId\", pathParams);\n        }\n\n        const content = event.getWireContent();\n        if (!delayOpts) {\n            return this.http.authedRequest<ISendEventResponse>(Method.Put, path, undefined, content).then((res) => {\n                this.logger.debug(`Event sent to ${event.getRoomId()} with event id ${res.event_id}`);\n                return res;\n            });\n        } else {\n            return this.http.authedRequest<SendDelayedEventResponse>(\n                Method.Put,\n                path,\n                getUnstableDelayQueryOpts(delayOpts),\n                content,\n            );\n        }\n    }\n\n    /**\n     * @param txnId -  transaction id. One will be made up if not supplied.\n     * @param opts - Redact options\n     * @returns Promise which resolves: TODO\n     * @returns Rejects: with an error response.\n     * @throws Error if called with `with_rel_types` (MSC3912) but the server does not support it.\n     *         Callers should check whether the server supports MSC3912 via `MatrixClient.canSupport`.\n     */\n    public redactEvent(\n        roomId: string,\n        eventId: string,\n        txnId?: string | undefined,\n        opts?: IRedactOpts,\n    ): Promise<ISendEventResponse>;\n    public redactEvent(\n        roomId: string,\n        threadId: string | null,\n        eventId: string,\n        txnId?: string | undefined,\n        opts?: IRedactOpts,\n    ): Promise<ISendEventResponse>;\n    public redactEvent(\n        roomId: string,\n        threadId: string | null,\n        eventId?: string,\n        txnId?: string | IRedactOpts,\n        opts?: IRedactOpts,\n    ): Promise<ISendEventResponse> {\n        if (!eventId?.startsWith(EVENT_ID_PREFIX)) {\n            opts = txnId as IRedactOpts;\n            txnId = eventId;\n            eventId = threadId!;\n            threadId = null;\n        }\n        const reason = opts?.reason;\n        const content: IContent = { reason };\n\n        if (opts?.with_rel_types !== undefined) {\n            if (this.canSupport.get(Feature.RelationBasedRedactions) === ServerSupport.Unsupported) {\n                throw new Error(\n                    \"Server does not support relation based redactions \" +\n                        `roomId ${roomId} eventId ${eventId} txnId: ${txnId as string} threadId ${threadId}`,\n                );\n            }\n\n            const withRelTypesPropName =\n                this.canSupport.get(Feature.RelationBasedRedactions) === ServerSupport.Stable\n                    ? MSC3912_RELATION_BASED_REDACTIONS_PROP.stable!\n                    : MSC3912_RELATION_BASED_REDACTIONS_PROP.unstable!;\n\n            content[withRelTypesPropName] = opts.with_rel_types;\n        }\n\n        return this.sendCompleteEvent(\n            roomId,\n            threadId,\n            {\n                type: EventType.RoomRedaction,\n                content,\n                redacts: eventId,\n            },\n            txnId as string,\n        );\n    }\n\n    /**\n     * @param txnId - Optional.\n     * @returns Promise which resolves: to an ISendEventResponse object\n     * @returns Rejects: with an error response.\n     */\n    public sendMessage(roomId: string, content: RoomMessageEventContent, txnId?: string): Promise<ISendEventResponse>;\n    public sendMessage(\n        roomId: string,\n        threadId: string | null,\n        content: RoomMessageEventContent,\n        txnId?: string,\n    ): Promise<ISendEventResponse>;\n    public sendMessage(\n        roomId: string,\n        threadId: string | null | RoomMessageEventContent,\n        content?: RoomMessageEventContent | string,\n        txnId?: string,\n    ): Promise<ISendEventResponse> {\n        if (typeof threadId !== \"string\" && threadId !== null) {\n            txnId = content as string;\n            content = threadId as RoomMessageEventContent;\n            threadId = null;\n        }\n\n        const eventType = EventType.RoomMessage;\n        const sendContent = content as RoomMessageEventContent;\n\n        return this.sendEvent(roomId, threadId as string | null, eventType, sendContent, txnId);\n    }\n\n    /**\n     * @param txnId - Optional.\n     * @returns\n     * @returns Rejects: with an error response.\n     */\n    public sendTextMessage(roomId: string, body: string, txnId?: string): Promise<ISendEventResponse>;\n    public sendTextMessage(\n        roomId: string,\n        threadId: string | null,\n        body: string,\n        txnId?: string,\n    ): Promise<ISendEventResponse>;\n    public sendTextMessage(\n        roomId: string,\n        threadId: string | null,\n        body: string,\n        txnId?: string,\n    ): Promise<ISendEventResponse> {\n        if (!threadId?.startsWith(EVENT_ID_PREFIX) && threadId !== null) {\n            txnId = body;\n            body = threadId;\n            threadId = null;\n        }\n        const content = ContentHelpers.makeTextMessage(body);\n        return this.sendMessage(roomId, threadId, content, txnId);\n    }\n\n    /**\n     * @param txnId - Optional.\n     * @returns Promise which resolves: to a ISendEventResponse object\n     * @returns Rejects: with an error response.\n     */\n    public sendNotice(roomId: string, body: string, txnId?: string): Promise<ISendEventResponse>;\n    public sendNotice(\n        roomId: string,\n        threadId: string | null,\n        body: string,\n        txnId?: string,\n    ): Promise<ISendEventResponse>;\n    public sendNotice(\n        roomId: string,\n        threadId: string | null,\n        body: string,\n        txnId?: string,\n    ): Promise<ISendEventResponse> {\n        if (!threadId?.startsWith(EVENT_ID_PREFIX) && threadId !== null) {\n            txnId = body;\n            body = threadId;\n            threadId = null;\n        }\n        const content = ContentHelpers.makeNotice(body);\n        return this.sendMessage(roomId, threadId, content, txnId);\n    }\n\n    /**\n     * @param txnId - Optional.\n     * @returns Promise which resolves: to a ISendEventResponse object\n     * @returns Rejects: with an error response.\n     */\n    public sendEmoteMessage(roomId: string, body: string, txnId?: string): Promise<ISendEventResponse>;\n    public sendEmoteMessage(\n        roomId: string,\n        threadId: string | null,\n        body: string,\n        txnId?: string,\n    ): Promise<ISendEventResponse>;\n    public sendEmoteMessage(\n        roomId: string,\n        threadId: string | null,\n        body: string,\n        txnId?: string,\n    ): Promise<ISendEventResponse> {\n        if (!threadId?.startsWith(EVENT_ID_PREFIX) && threadId !== null) {\n            txnId = body;\n            body = threadId;\n            threadId = null;\n        }\n        const content = ContentHelpers.makeEmoteMessage(body);\n        return this.sendMessage(roomId, threadId, content, txnId);\n    }\n\n    /**\n     * @returns Promise which resolves: to a ISendEventResponse object\n     * @returns Rejects: with an error response.\n     */\n    public sendImageMessage(roomId: string, url: string, info?: ImageInfo, text?: string): Promise<ISendEventResponse>;\n    public sendImageMessage(\n        roomId: string,\n        threadId: string | null,\n        url: string,\n        info?: ImageInfo,\n        text?: string,\n    ): Promise<ISendEventResponse>;\n    public sendImageMessage(\n        roomId: string,\n        threadId: string | null,\n        url?: string | ImageInfo,\n        info?: ImageInfo | string,\n        text = \"Image\",\n    ): Promise<ISendEventResponse> {\n        if (!threadId?.startsWith(EVENT_ID_PREFIX) && threadId !== null) {\n            text = (info as string) || \"Image\";\n            info = url as ImageInfo;\n            url = threadId as string;\n            threadId = null;\n        }\n        const content = {\n            msgtype: MsgType.Image,\n            url: url as string,\n            info: info as ImageInfo,\n            body: text,\n        } satisfies RoomMessageEventContent;\n        return this.sendMessage(roomId, threadId, content);\n    }\n\n    /**\n     * @returns Promise which resolves: to a ISendEventResponse object\n     * @returns Rejects: with an error response.\n     */\n    public sendStickerMessage(\n        roomId: string,\n        url: string,\n        info?: ImageInfo,\n        text?: string,\n    ): Promise<ISendEventResponse>;\n    public sendStickerMessage(\n        roomId: string,\n        threadId: string | null,\n        url: string,\n        info?: ImageInfo,\n        text?: string,\n    ): Promise<ISendEventResponse>;\n    public sendStickerMessage(\n        roomId: string,\n        threadId: string | null,\n        url?: string | ImageInfo,\n        info?: ImageInfo | string,\n        text = \"Sticker\",\n    ): Promise<ISendEventResponse> {\n        if (!threadId?.startsWith(EVENT_ID_PREFIX) && threadId !== null) {\n            text = (info as string) || \"Sticker\";\n            info = url as ImageInfo;\n            url = threadId as string;\n            threadId = null;\n        }\n        const content = {\n            url: url as string,\n            info: info as ImageInfo,\n            body: text,\n        } satisfies StickerEventContent;\n\n        return this.sendEvent(roomId, threadId, EventType.Sticker, content);\n    }\n\n    /**\n     * @returns Promise which resolves: to a ISendEventResponse object\n     * @returns Rejects: with an error response.\n     */\n    public sendHtmlMessage(roomId: string, body: string, htmlBody: string): Promise<ISendEventResponse>;\n    public sendHtmlMessage(\n        roomId: string,\n        threadId: string | null,\n        body: string,\n        htmlBody: string,\n    ): Promise<ISendEventResponse>;\n    public sendHtmlMessage(\n        roomId: string,\n        threadId: string | null,\n        body: string,\n        htmlBody?: string,\n    ): Promise<ISendEventResponse> {\n        if (!threadId?.startsWith(EVENT_ID_PREFIX) && threadId !== null) {\n            htmlBody = body as string;\n            body = threadId;\n            threadId = null;\n        }\n        const content = ContentHelpers.makeHtmlMessage(body, htmlBody!);\n        return this.sendMessage(roomId, threadId, content);\n    }\n\n    /**\n     * @returns Promise which resolves: to a ISendEventResponse object\n     * @returns Rejects: with an error response.\n     */\n    public sendHtmlNotice(roomId: string, body: string, htmlBody: string): Promise<ISendEventResponse>;\n    public sendHtmlNotice(\n        roomId: string,\n        threadId: string | null,\n        body: string,\n        htmlBody: string,\n    ): Promise<ISendEventResponse>;\n    public sendHtmlNotice(\n        roomId: string,\n        threadId: string | null,\n        body: string,\n        htmlBody?: string,\n    ): Promise<ISendEventResponse> {\n        if (!threadId?.startsWith(EVENT_ID_PREFIX) && threadId !== null) {\n            htmlBody = body as string;\n            body = threadId;\n            threadId = null;\n        }\n        const content = ContentHelpers.makeHtmlNotice(body, htmlBody!);\n        return this.sendMessage(roomId, threadId, content);\n    }\n\n    /**\n     * @returns Promise which resolves: to a ISendEventResponse object\n     * @returns Rejects: with an error response.\n     */\n    public sendHtmlEmote(roomId: string, body: string, htmlBody: string): Promise<ISendEventResponse>;\n    public sendHtmlEmote(\n        roomId: string,\n        threadId: string | null,\n        body: string,\n        htmlBody: string,\n    ): Promise<ISendEventResponse>;\n    public sendHtmlEmote(\n        roomId: string,\n        threadId: string | null,\n        body: string,\n        htmlBody?: string,\n    ): Promise<ISendEventResponse> {\n        if (!threadId?.startsWith(EVENT_ID_PREFIX) && threadId !== null) {\n            htmlBody = body as string;\n            body = threadId;\n            threadId = null;\n        }\n        const content = ContentHelpers.makeHtmlEmote(body, htmlBody!);\n        return this.sendMessage(roomId, threadId, content);\n    }\n\n    /**\n     * Send a delayed timeline event.\n     *\n     * Note: This endpoint is unstable, and can throw an `Error`.\n     *   Check progress on [MSC4140](https://github.com/matrix-org/matrix-spec-proposals/pull/4140) for more details.\n     */\n    // eslint-disable-next-line\n    public async _unstable_sendDelayedEvent<K extends keyof TimelineEvents>(\n        roomId: string,\n        delayOpts: SendDelayedEventRequestOpts,\n        threadId: string | null,\n        eventType: K,\n        content: TimelineEvents[K],\n        txnId?: string,\n    ): Promise<SendDelayedEventResponse> {\n        if (!(await this.doesServerSupportUnstableFeature(UNSTABLE_MSC4140_DELAYED_EVENTS))) {\n            throw new UnsupportedDelayedEventsEndpointError(\n                \"Server does not support the delayed events API\",\n                \"sendDelayedEvent\",\n            );\n        }\n\n        this.addThreadRelationIfNeeded(content, threadId, roomId);\n        return this.sendCompleteEvent(roomId, threadId, { type: eventType, content }, delayOpts, txnId);\n    }\n\n    /**\n     * Send a delayed state event.\n     *\n     * Note: This endpoint is unstable, and can throw an `Error`.\n     *   Check progress on [MSC4140](https://github.com/matrix-org/matrix-spec-proposals/pull/4140) for more details.\n     */\n    // eslint-disable-next-line\n    public async _unstable_sendDelayedStateEvent<K extends keyof StateEvents>(\n        roomId: string,\n        delayOpts: SendDelayedEventRequestOpts,\n        eventType: K,\n        content: StateEvents[K],\n        stateKey = \"\",\n        opts: IRequestOpts = {},\n    ): Promise<SendDelayedEventResponse> {\n        if (!(await this.doesServerSupportUnstableFeature(UNSTABLE_MSC4140_DELAYED_EVENTS))) {\n            throw new UnsupportedDelayedEventsEndpointError(\n                \"Server does not support the delayed events API\",\n                \"sendDelayedStateEvent\",\n            );\n        }\n\n        const pathParams = {\n            $roomId: roomId,\n            $eventType: eventType,\n            $stateKey: stateKey,\n        };\n        let path = utils.encodeUri(\"/rooms/$roomId/state/$eventType\", pathParams);\n        if (stateKey !== undefined) {\n            path = utils.encodeUri(path + \"/$stateKey\", pathParams);\n        }\n        return this.http.authedRequest(Method.Put, path, getUnstableDelayQueryOpts(delayOpts), content as Body, opts);\n    }\n\n    /**\n     * Get all pending delayed events for the calling user.\n     *\n     * Note: This endpoint is unstable, and can throw an `Error`.\n     *   Check progress on [MSC4140](https://github.com/matrix-org/matrix-spec-proposals/pull/4140) for more details.\n     */\n    // eslint-disable-next-line\n    public async _unstable_getDelayedEvents(fromToken?: string): Promise<DelayedEventInfo> {\n        if (!(await this.doesServerSupportUnstableFeature(UNSTABLE_MSC4140_DELAYED_EVENTS))) {\n            throw new UnsupportedDelayedEventsEndpointError(\n                \"Server does not support the delayed events API\",\n                \"getDelayedEvents\",\n            );\n        }\n\n        const queryDict = fromToken ? { from: fromToken } : undefined;\n        return await this.http.authedRequest(Method.Get, \"/delayed_events\", queryDict, undefined, {\n            prefix: `${ClientPrefix.Unstable}/${UNSTABLE_MSC4140_DELAYED_EVENTS}`,\n        });\n    }\n\n    /**\n     * Manage a delayed event associated with the given delay_id.\n     *\n     * Note: This endpoint is unstable, and can throw an `Error`.\n     *   Check progress on [MSC4140](https://github.com/matrix-org/matrix-spec-proposals/pull/4140) for more details.\n     */\n    // eslint-disable-next-line\n    public async _unstable_updateDelayedEvent(\n        delayId: string,\n        action: UpdateDelayedEventAction,\n        requestOptions: IRequestOpts = {},\n    ): Promise<EmptyObject> {\n        if (!(await this.doesServerSupportUnstableFeature(UNSTABLE_MSC4140_DELAYED_EVENTS))) {\n            throw new UnsupportedDelayedEventsEndpointError(\n                \"Server does not support the delayed events API\",\n                \"updateDelayedEvent\",\n            );\n        }\n\n        const path = utils.encodeUri(\"/delayed_events/$delayId\", {\n            $delayId: delayId,\n        });\n        const data = {\n            action,\n        };\n        return await this.http.authedRequest(Method.Post, path, undefined, data, {\n            ...requestOptions,\n            prefix: `${ClientPrefix.Unstable}/${UNSTABLE_MSC4140_DELAYED_EVENTS}`,\n        });\n    }\n\n    /**\n     * Send a receipt.\n     * @param event - The event being acknowledged\n     * @param receiptType - The kind of receipt e.g. \"m.read\". Other than\n     * ReceiptType.Read are experimental!\n     * @param body - Additional content to send alongside the receipt.\n     * @param unthreaded - An unthreaded receipt will clear room+thread notifications\n     * @returns Promise which resolves: to an empty object `{}`\n     * @returns Rejects: with an error response.\n     */\n    public async sendReceipt(\n        event: MatrixEvent,\n        receiptType: ReceiptType,\n        body?: Record<string, any>,\n        unthreaded = false,\n    ): Promise<EmptyObject> {\n        if (this.isGuest()) {\n            return Promise.resolve({}); // guests cannot send receipts so don't bother.\n        }\n\n        const path = utils.encodeUri(\"/rooms/$roomId/receipt/$receiptType/$eventId\", {\n            $roomId: event.getRoomId()!,\n            $receiptType: receiptType,\n            $eventId: event.getId()!,\n        });\n\n        // Unless we're explicitly making an unthreaded receipt or we don't\n        // support threads, include the `thread_id` property in the body.\n        const shouldAddThreadId = !unthreaded && this.supportsThreads();\n        const fullBody = shouldAddThreadId ? { ...body, thread_id: threadIdForReceipt(event) } : body;\n\n        const promise = this.http.authedRequest<EmptyObject>(Method.Post, path, undefined, fullBody || {});\n\n        const room = this.getRoom(event.getRoomId());\n        if (room && this.credentials.userId) {\n            room.addLocalEchoReceipt(this.credentials.userId, event, receiptType, unthreaded);\n        }\n        return promise;\n    }\n\n    /**\n     * Send a read receipt.\n     * @param event - The event that has been read.\n     * @param receiptType - other than ReceiptType.Read are experimental! Optional.\n     * @returns Promise which resolves: to an empty object `{}`\n     * @returns Rejects: with an error response.\n     */\n    public async sendReadReceipt(\n        event: MatrixEvent | null,\n        receiptType = ReceiptType.Read,\n        unthreaded = false,\n    ): Promise<EmptyObject | undefined> {\n        if (!event) return;\n        const eventId = event.getId()!;\n        const room = this.getRoom(event.getRoomId());\n        if (room?.hasPendingEvent(eventId)) {\n            throw new Error(`Cannot set read receipt to a pending event (${eventId})`);\n        }\n\n        return this.sendReceipt(event, receiptType, {}, unthreaded);\n    }\n\n    /**\n     * Set a marker to indicate the point in a room before which the user has read every\n     * event. This can be retrieved from room account data (the event type is `m.fully_read`)\n     * and displayed as a horizontal line in the timeline that is visually distinct to the\n     * position of the user's own read receipt.\n     * @param roomId - ID of the room that has been read\n     * @param rmEventId - ID of the event that has been read\n     * @param rrEvent - the event tracked by the read receipt. This is here for\n     * convenience because the RR and the RM are commonly updated at the same time as each\n     * other. The local echo of this receipt will be done if set. Optional.\n     * @param rpEvent - the m.read.private read receipt event for when we don't\n     * want other users to see the read receipts. This is experimental. Optional.\n     * @returns Promise which resolves: the empty object, `{}`.\n     */\n    public async setRoomReadMarkers(\n        roomId: string,\n        rmEventId: string,\n        rrEvent?: MatrixEvent,\n        rpEvent?: MatrixEvent,\n    ): Promise<EmptyObject> {\n        const room = this.getRoom(roomId);\n        if (room?.hasPendingEvent(rmEventId)) {\n            throw new Error(`Cannot set read marker to a pending event (${rmEventId})`);\n        }\n\n        // Add the optional RR update, do local echo like `sendReceipt`\n        let rrEventId: string | undefined;\n        if (rrEvent) {\n            rrEventId = rrEvent.getId()!;\n            if (room?.hasPendingEvent(rrEventId)) {\n                throw new Error(`Cannot set read receipt to a pending event (${rrEventId})`);\n            }\n            room?.addLocalEchoReceipt(this.credentials.userId!, rrEvent, ReceiptType.Read);\n        }\n\n        // Add the optional private RR update, do local echo like `sendReceipt`\n        let rpEventId: string | undefined;\n        if (rpEvent) {\n            rpEventId = rpEvent.getId()!;\n            if (room?.hasPendingEvent(rpEventId)) {\n                throw new Error(`Cannot set read receipt to a pending event (${rpEventId})`);\n            }\n            room?.addLocalEchoReceipt(this.credentials.userId!, rpEvent, ReceiptType.ReadPrivate);\n        }\n\n        return await this.setRoomReadMarkersHttpRequest(roomId, rmEventId, rrEventId, rpEventId);\n    }\n\n    /**\n     * Get a preview of the given URL as of (roughly) the given point in time,\n     * described as an object with OpenGraph keys and associated values.\n     * Attributes may be synthesized where actual OG metadata is lacking.\n     * Caches results to prevent hammering the server.\n     * @param url - The URL to get preview data for\n     * @param ts - The preferred point in time that the preview should\n     * describe (ms since epoch).  The preview returned will either be the most\n     * recent one preceding this timestamp if available, or failing that the next\n     * most recent available preview.\n     * @returns Promise which resolves: Object of OG metadata.\n     * @returns Rejects: with an error response.\n     * May return synthesized attributes if the URL lacked OG meta.\n     */\n    public getUrlPreview(url: string, ts: number): Promise<IPreviewUrlResponse> {\n        // bucket the timestamp to the nearest minute to prevent excessive spam to the server\n        // Surely 60-second accuracy is enough for anyone.\n        ts = Math.floor(ts / 60000) * 60000;\n\n        const parsed = new URL(url);\n        parsed.hash = \"\"; // strip the hash as it won't affect the preview\n        url = parsed.toString();\n\n        const key = ts + \"_\" + url;\n\n        // If there's already a request in flight (or we've handled it), return that instead.\n        if (key in this.urlPreviewCache) {\n            return this.urlPreviewCache[key];\n        }\n\n        const resp = this.http.authedRequest<IPreviewUrlResponse>(\n            Method.Get,\n            \"/preview_url\",\n            {\n                url,\n                ts: ts.toString(),\n            },\n            undefined,\n            {\n                prefix: MediaPrefix.V3,\n                priority: \"low\",\n            },\n        );\n        // TODO: Expire the URL preview cache sometimes\n        this.urlPreviewCache[key] = resp;\n        return resp;\n    }\n\n    /**\n     * @returns Promise which resolves: to an empty object `{}`\n     * @returns Rejects: with an error response.\n     */\n    public sendTyping(roomId: string, isTyping: boolean, timeoutMs: number): Promise<EmptyObject> {\n        if (this.isGuest()) {\n            return Promise.resolve({}); // guests cannot send typing notifications so don't bother.\n        }\n\n        const path = utils.encodeUri(\"/rooms/$roomId/typing/$userId\", {\n            $roomId: roomId,\n            $userId: this.getUserId()!,\n        });\n        const data: QueryDict = {\n            typing: isTyping,\n        };\n        if (isTyping) {\n            data.timeout = timeoutMs ? timeoutMs : 20000;\n        }\n        return this.http.authedRequest(Method.Put, path, undefined, data);\n    }\n\n    /**\n     * Determines the history of room upgrades for a given room, as far as the\n     * client can see. Returns an array of Rooms where the first entry is the\n     * oldest and the last entry is the newest (likely current) room. If the\n     * provided room is not found, this returns an empty list. This works in\n     * both directions, looking for older and newer rooms of the given room.\n     * @param roomId - The room ID to search from\n     * @param verifyLinks - If true, the function will only return rooms\n     * which can be proven to be linked. For example, rooms which have a create\n     * event pointing to an old room which the client is not aware of or doesn't\n     * have a matching tombstone would not be returned.\n     * @param msc3946ProcessDynamicPredecessor - if true, look for\n     * m.room.predecessor state events as well as create events, and prefer\n     * predecessor events where they exist (MSC3946).\n     * @returns An array of rooms representing the upgrade\n     * history.\n     */\n    public getRoomUpgradeHistory(\n        roomId: string,\n        verifyLinks = false,\n        msc3946ProcessDynamicPredecessor = false,\n    ): Room[] {\n        const currentRoom = this.getRoom(roomId);\n        if (!currentRoom) return [];\n\n        const before = this.findPredecessorRooms(currentRoom, verifyLinks, msc3946ProcessDynamicPredecessor);\n        const after = this.findSuccessorRooms(currentRoom, verifyLinks, msc3946ProcessDynamicPredecessor);\n\n        return [...before, currentRoom, ...after];\n    }\n\n    private findPredecessorRooms(room: Room, verifyLinks: boolean, msc3946ProcessDynamicPredecessor: boolean): Room[] {\n        const ret: Room[] = [];\n        const seenRoomIDs = new Set<string>([room.roomId]);\n\n        // Work backwards from newer to older rooms\n        let predecessorRoomId = room.findPredecessor(msc3946ProcessDynamicPredecessor)?.roomId;\n        while (predecessorRoomId !== null) {\n            if (predecessorRoomId) {\n                if (seenRoomIDs.has(predecessorRoomId)) break;\n                seenRoomIDs.add(predecessorRoomId);\n            }\n            const predecessorRoom = this.getRoom(predecessorRoomId);\n            if (predecessorRoom === null) {\n                break;\n            }\n            if (verifyLinks) {\n                const tombstone = predecessorRoom.currentState.getStateEvents(EventType.RoomTombstone, \"\");\n                if (!tombstone || tombstone.getContent()[\"replacement_room\"] !== room.roomId) {\n                    break;\n                }\n            }\n\n            // Insert at the front because we're working backwards from the currentRoom\n            ret.splice(0, 0, predecessorRoom);\n\n            room = predecessorRoom;\n            predecessorRoomId = room.findPredecessor(msc3946ProcessDynamicPredecessor)?.roomId;\n        }\n        return ret;\n    }\n\n    private findSuccessorRooms(room: Room, verifyLinks: boolean, msc3946ProcessDynamicPredecessor: boolean): Room[] {\n        const ret: Room[] = [];\n\n        // Work forwards, looking at tombstone events\n        let tombstoneEvent = room.currentState.getStateEvents(EventType.RoomTombstone, \"\");\n        while (tombstoneEvent) {\n            const successorRoom = this.getRoom(tombstoneEvent.getContent()[\"replacement_room\"]);\n            if (!successorRoom) break; // end of the chain\n            if (successorRoom.roomId === room.roomId) break; // Tombstone is referencing its own room\n\n            if (verifyLinks) {\n                const predecessorRoomId = successorRoom.findPredecessor(msc3946ProcessDynamicPredecessor)?.roomId;\n                if (!predecessorRoomId || predecessorRoomId !== room.roomId) {\n                    break;\n                }\n            }\n\n            // Push to the end because we're looking forwards\n            ret.push(successorRoom);\n            const roomIds = new Set(ret.map((ref) => ref.roomId));\n            if (roomIds.size < ret.length) {\n                // The last room added to the list introduced a previous roomId\n                // To avoid recursion, return the last rooms - 1\n                return ret.slice(0, ret.length - 1);\n            }\n\n            // Set the current room to the reference room so we know where we're at\n            room = successorRoom;\n            tombstoneEvent = room.currentState.getStateEvents(EventType.RoomTombstone, \"\");\n        }\n        return ret;\n    }\n\n    /**\n     * @param reason - Optional.\n     * @returns Promise which resolves: `{}` an empty object.\n     * @returns Rejects: with an error response.\n     */\n    public invite(roomId: string, userId: string, reason?: string): Promise<EmptyObject> {\n        return this.membershipChange(roomId, userId, KnownMembership.Invite, reason);\n    }\n\n    /**\n     * Invite a user to a room based on their email address.\n     * @param roomId - The room to invite the user to.\n     * @param email - The email address to invite.\n     * @returns Promise which resolves: `{}` an empty object.\n     * @returns Rejects: with an error response.\n     */\n    public inviteByEmail(roomId: string, email: string): Promise<EmptyObject> {\n        return this.inviteByThreePid(roomId, \"email\", email);\n    }\n\n    /**\n     * Invite a user to a room based on a third-party identifier.\n     * @param roomId - The room to invite the user to.\n     * @param medium - The medium to invite the user e.g. \"email\".\n     * @param address - The address for the specified medium.\n     * @returns Promise which resolves: `{}` an empty object.\n     * @returns Rejects: with an error response.\n     */\n    public async inviteByThreePid(roomId: string, medium: string, address: string): Promise<EmptyObject> {\n        const path = utils.encodeUri(\"/rooms/$roomId/invite\", { $roomId: roomId });\n\n        const identityServerUrl = this.getIdentityServerUrl(true);\n        if (!identityServerUrl) {\n            return Promise.reject(\n                new MatrixError({\n                    error: \"No supplied identity server URL\",\n                    errcode: \"ORG.MATRIX.JSSDK_MISSING_PARAM\",\n                }),\n            );\n        }\n        const params: Record<string, string> = {\n            id_server: identityServerUrl,\n            medium: medium,\n            address: address,\n        };\n\n        if (this.identityServer?.getAccessToken) {\n            const identityAccessToken = await this.identityServer.getAccessToken();\n            if (identityAccessToken) {\n                params[\"id_access_token\"] = identityAccessToken;\n            }\n        }\n\n        return this.http.authedRequest(Method.Post, path, undefined, params);\n    }\n\n    /**\n     * @returns Promise which resolves: `{}` an empty object.\n     * @returns Rejects: with an error response.\n     */\n    public leave(roomId: string): Promise<EmptyObject> {\n        return this.membershipChange(roomId, undefined, KnownMembership.Leave);\n    }\n\n    /**\n     * Leaves all rooms in the chain of room upgrades based on the given room. By\n     * default, this will leave all the previous and upgraded rooms, including the\n     * given room. To only leave the given room and any previous rooms, keeping the\n     * upgraded (modern) rooms untouched supply `false` to `includeFuture`.\n     * @param roomId - The room ID to start leaving at\n     * @param includeFuture - If true, the whole chain (past and future) of\n     * upgraded rooms will be left.\n     * @returns Promise which resolves when completed with an object keyed\n     * by room ID and value of the error encountered when leaving or null.\n     */\n    public leaveRoomChain(\n        roomId: string,\n        includeFuture = true,\n    ): Promise<{ [roomId: string]: Error | MatrixError | null }> {\n        const upgradeHistory = this.getRoomUpgradeHistory(roomId);\n\n        let eligibleToLeave = upgradeHistory;\n        if (!includeFuture) {\n            eligibleToLeave = [];\n            for (const room of upgradeHistory) {\n                eligibleToLeave.push(room);\n                if (room.roomId === roomId) {\n                    break;\n                }\n            }\n        }\n\n        const populationResults: { [roomId: string]: Error } = {};\n        const promises: Promise<unknown>[] = [];\n\n        const doLeave = (roomId: string): Promise<void> => {\n            return this.leave(roomId)\n                .then(() => {\n                    delete populationResults[roomId];\n                })\n                .catch((err) => {\n                    // suppress error\n                    populationResults[roomId] = err;\n                });\n        };\n\n        for (const room of eligibleToLeave) {\n            promises.push(doLeave(room.roomId));\n        }\n\n        return Promise.all(promises).then(() => populationResults);\n    }\n\n    /**\n     * @param reason - Optional.\n     * @returns Promise which resolves: TODO\n     * @returns Rejects: with an error response.\n     */\n    public ban(roomId: string, userId: string, reason?: string): Promise<EmptyObject> {\n        return this.membershipChange(roomId, userId, KnownMembership.Ban, reason);\n    }\n\n    /**\n     * @param deleteRoom - True to delete the room from the store on success.\n     * Default: true.\n     * @returns Promise which resolves: `{}` an empty object.\n     * @returns Rejects: with an error response.\n     */\n    public async forget(roomId: string, deleteRoom = true): Promise<EmptyObject> {\n        // API returns an empty object\n        const path = utils.encodeUri(\"/rooms/$room_id/forget\", {\n            $room_id: roomId,\n        });\n        const response = await this.http.authedRequest<EmptyObject>(Method.Post, path);\n        if (deleteRoom) {\n            this.store.removeRoom(roomId);\n            this.emit(ClientEvent.DeleteRoom, roomId);\n        }\n        return response;\n    }\n\n    /**\n     * @returns Promise which resolves: Object (currently empty)\n     * @returns Rejects: with an error response.\n     */\n    public unban(roomId: string, userId: string): Promise<EmptyObject> {\n        // unbanning != set their state to leave: this used to be\n        // the case, but was then changed so that leaving was always\n        // a revoking of privilege, otherwise two people racing to\n        // kick / ban someone could end up banning and then un-banning\n        // them.\n        const path = utils.encodeUri(\"/rooms/$roomId/unban\", {\n            $roomId: roomId,\n        });\n        const data = {\n            user_id: userId,\n        };\n        return this.http.authedRequest(Method.Post, path, undefined, data);\n    }\n\n    /**\n     * @param reason - Optional.\n     * @returns Promise which resolves: `{}` an empty object.\n     * @returns Rejects: with an error response.\n     */\n    public kick(roomId: string, userId: string, reason?: string): Promise<EmptyObject> {\n        const path = utils.encodeUri(\"/rooms/$roomId/kick\", {\n            $roomId: roomId,\n        });\n        const data = {\n            user_id: userId,\n            reason: reason,\n        };\n        return this.http.authedRequest(Method.Post, path, undefined, data);\n    }\n\n    private membershipChange(\n        roomId: string,\n        userId: string | undefined,\n        membership: Membership,\n        reason?: string,\n    ): Promise<EmptyObject> {\n        // API returns an empty object\n        const path = utils.encodeUri(\"/rooms/$room_id/$membership\", {\n            $room_id: roomId,\n            $membership: membership,\n        });\n        return this.http.authedRequest(Method.Post, path, undefined, {\n            user_id: userId, // may be undefined e.g. on leave\n            reason: reason,\n        });\n    }\n\n    /**\n     * Obtain a dict of actions which should be performed for this event according\n     * to the push rules for this user.  Caches the dict on the event.\n     * @param event - The event to get push actions for.\n     * @param forceRecalculate - forces to recalculate actions for an event\n     * Useful when an event just got decrypted\n     * @returns A dict of actions to perform.\n     */\n    public getPushActionsForEvent(event: MatrixEvent, forceRecalculate = false): IActionsObject | null {\n        if (!event.getPushActions() || forceRecalculate) {\n            const { actions, rule } = this.pushProcessor.actionsAndRuleForEvent(event);\n            event.setPushDetails(actions, rule);\n        }\n        return event.getPushActions();\n    }\n\n    /**\n     * Obtain a dict of actions which should be performed for this event according\n     * to the push rules for this user.  Caches the dict on the event.\n     * @param event - The event to get push actions for.\n     * @param forceRecalculate - forces to recalculate actions for an event\n     * Useful when an event just got decrypted\n     * @returns A dict of actions to perform.\n     */\n    public getPushDetailsForEvent(event: MatrixEvent, forceRecalculate = false): PushDetails | null {\n        if (!event.getPushDetails() || forceRecalculate) {\n            const { actions, rule } = this.pushProcessor.actionsAndRuleForEvent(event);\n            event.setPushDetails(actions, rule);\n        }\n        return event.getPushDetails();\n    }\n\n    /**\n     * @param info - The kind of info to set (e.g. 'avatar_url')\n     * @param data - The JSON object to set.\n     * @returns\n     * @returns Rejects: with an error response.\n     */\n    // eslint-disable-next-line camelcase\n    public setProfileInfo(info: \"avatar_url\", data: { avatar_url: string }): Promise<EmptyObject>;\n    public setProfileInfo(info: \"displayname\", data: { displayname: string }): Promise<EmptyObject>;\n    public setProfileInfo(info: \"avatar_url\" | \"displayname\", data: object): Promise<EmptyObject> {\n        const path = utils.encodeUri(\"/profile/$userId/$info\", {\n            $userId: this.credentials.userId!,\n            $info: info,\n        });\n        return this.http.authedRequest(Method.Put, path, undefined, data);\n    }\n\n    /**\n     * @returns Promise which resolves: `{}` an empty object.\n     * @returns Rejects: with an error response.\n     */\n    public async setDisplayName(name: string): Promise<EmptyObject> {\n        const prom = await this.setProfileInfo(\"displayname\", { displayname: name });\n        // XXX: synthesise a profile update for ourselves because Synapse is broken and won't\n        const user = this.getUser(this.getUserId()!);\n        if (user) {\n            user.displayName = name;\n            user.emit(UserEvent.DisplayName, user.events.presence, user);\n        }\n        return prom;\n    }\n\n    /**\n     * @returns Promise which resolves: `{}` an empty object.\n     * @returns Rejects: with an error response.\n     */\n    public async setAvatarUrl(url: string): Promise<EmptyObject> {\n        const prom = await this.setProfileInfo(\"avatar_url\", { avatar_url: url });\n        // XXX: synthesise a profile update for ourselves because Synapse is broken and won't\n        const user = this.getUser(this.getUserId()!);\n        if (user) {\n            user.avatarUrl = url;\n            user.emit(UserEvent.AvatarUrl, user.events.presence, user);\n        }\n        return prom;\n    }\n\n    /**\n     * Turn an MXC URL into an HTTP one. <strong>This method is experimental and\n     * may change.</strong>\n     * @param mxcUrl - The MXC URL\n     * @param width - The desired width of the thumbnail.\n     * @param height - The desired height of the thumbnail.\n     * @param resizeMethod - The thumbnail resize method to use, either\n     * \"crop\" or \"scale\".\n     * @param allowDirectLinks - If true, return any non-mxc URLs\n     * directly. Fetching such URLs will leak information about the user to\n     * anyone they share a room with. If false, will return null for such URLs.\n     * @param allowRedirects - If true, the caller supports the URL being 307 or\n     * 308 redirected to another resource upon request. If false, redirects\n     * are not expected. Implied `true` when `useAuthentication` is `true`.\n     * @param useAuthentication - If true, the caller supports authenticated\n     * media and wants an authentication-required URL. Note that server support\n     * for authenticated media will *not* be checked - it is the caller's responsibility\n     * to do so before calling this function. Note also that `useAuthentication`\n     * implies `allowRedirects`. Defaults to false (unauthenticated endpoints).\n     * @returns the avatar URL or null.\n     */\n    public mxcUrlToHttp(\n        mxcUrl: string,\n        width?: number,\n        height?: number,\n        resizeMethod?: string,\n        allowDirectLinks?: boolean,\n        allowRedirects?: boolean,\n        useAuthentication?: boolean,\n    ): string | null {\n        return getHttpUriForMxc(\n            this.baseUrl,\n            mxcUrl,\n            width,\n            height,\n            resizeMethod,\n            allowDirectLinks,\n            allowRedirects,\n            useAuthentication,\n        );\n    }\n\n    /**\n     * Specify the set_presence value to be used for subsequent calls to the Sync API.\n     * This has an advantage over calls to the PUT /presence API in that it\n     * doesn't clobber status_msg set by other devices.\n     * @param presence - the presence to specify to set_presence of sync calls\n     */\n    public async setSyncPresence(presence?: SetPresence): Promise<void> {\n        this.syncApi?.setPresence(presence);\n    }\n\n    /**\n     * @param opts - Options to apply\n     * @returns Promise which resolves\n     * @returns Rejects: with an error response.\n     * @throws If 'presence' isn't a valid presence enum value.\n     */\n    public async setPresence(opts: IPresenceOpts): Promise<void> {\n        const path = utils.encodeUri(\"/presence/$userId/status\", {\n            $userId: this.credentials.userId!,\n        });\n\n        const validStates = [\"offline\", \"online\", \"unavailable\"];\n        if (validStates.indexOf(opts.presence) === -1) {\n            throw new Error(\"Bad presence value: \" + opts.presence);\n        }\n        await this.http.authedRequest(Method.Put, path, undefined, opts);\n    }\n\n    /**\n     * @param userId - The user to get presence for\n     * @returns Promise which resolves: The presence state for this user.\n     * @returns Rejects: with an error response.\n     */\n    public getPresence(userId: string): Promise<IStatusResponse> {\n        const path = utils.encodeUri(\"/presence/$userId/status\", {\n            $userId: userId,\n        });\n\n        return this.http.authedRequest(Method.Get, path);\n    }\n\n    /**\n     * Retrieve older messages from the given room and put them in the timeline.\n     *\n     * If this is called multiple times whilst a request is ongoing, the <i>same</i>\n     * Promise will be returned. If there was a problem requesting scrollback, there\n     * will be a small delay before another request can be made (to prevent tight-looping\n     * when there is no connection).\n     *\n     * @param room - The room to get older messages in.\n     * @param limit - Optional. The maximum number of previous events to\n     * pull in. Default: 30.\n     * @returns Promise which resolves: Room. If you are at the beginning\n     * of the timeline, `Room.oldState.paginationToken` will be\n     * `null`.\n     * @returns Rejects: with an error response.\n     */\n    public scrollback(room: Room, limit = 30): Promise<Room> {\n        let timeToWaitMs = 0;\n\n        let info = this.ongoingScrollbacks[room.roomId] || {};\n        if (info.promise) {\n            return info.promise;\n        } else if (info.errorTs) {\n            const timeWaitedMs = Date.now() - info.errorTs;\n            timeToWaitMs = Math.max(SCROLLBACK_DELAY_MS - timeWaitedMs, 0);\n        }\n\n        if (room.oldState.paginationToken === null) {\n            return Promise.resolve(room); // already at the start.\n        }\n        // attempt to grab more events from the store first\n        const numAdded = this.store.scrollback(room, limit).length;\n        if (numAdded === limit) {\n            // store contained everything we needed.\n            return Promise.resolve(room);\n        }\n        // reduce the required number of events appropriately\n        limit = limit - numAdded;\n\n        const promise = new Promise<Room>((resolve, reject) => {\n            // wait for a time before doing this request\n            // (which may be 0 in order not to special case the code paths)\n            sleep(timeToWaitMs)\n                .then(() => {\n                    return this.createMessagesRequest(\n                        room.roomId,\n                        room.oldState.paginationToken,\n                        limit,\n                        Direction.Backward,\n                    );\n                })\n                .then((res: IMessagesResponse) => {\n                    const matrixEvents = res.chunk.map(this.getEventMapper());\n                    if (res.state) {\n                        const stateEvents = res.state.map(this.getEventMapper());\n                        room.currentState.setUnknownStateEvents(stateEvents);\n                    }\n\n                    const [timelineEvents, threadedEvents, unknownRelations] =\n                        room.partitionThreadedEvents(matrixEvents);\n\n                    this.processAggregatedTimelineEvents(room, timelineEvents);\n                    room.addEventsToTimeline(timelineEvents, true, true, room.getLiveTimeline());\n                    this.processThreadEvents(room, threadedEvents, true);\n                    unknownRelations.forEach((event) => room.relations.aggregateChildEvent(event));\n\n                    room.oldState.paginationToken = res.end ?? null;\n                    if (res.chunk.length === 0) {\n                        room.oldState.paginationToken = null;\n                    }\n                    this.store.storeEvents(room, matrixEvents, res.end ?? null, true);\n                    delete this.ongoingScrollbacks[room.roomId];\n                    resolve(room);\n                })\n                .catch((err) => {\n                    this.ongoingScrollbacks[room.roomId] = {\n                        errorTs: Date.now(),\n                    };\n                    reject(err);\n                });\n        });\n\n        info = { promise };\n\n        this.ongoingScrollbacks[room.roomId] = info;\n        return promise;\n    }\n\n    public getEventMapper(options?: MapperOpts): EventMapper {\n        return eventMapperFor(this, options || {});\n    }\n\n    /**\n     * Get an EventTimeline for the given event\n     *\n     * <p>If the EventTimelineSet object already has the given event in its store, the\n     * corresponding timeline will be returned. Otherwise, a /context request is\n     * made, and used to construct an EventTimeline.\n     * If the event does not belong to this EventTimelineSet then undefined will be returned.\n     *\n     * @param timelineSet -  The timelineSet to look for the event in, must be bound to a room\n     * @param eventId -  The ID of the event to look for\n     *\n     * @returns Promise which resolves:\n     *    {@link EventTimeline} including the given event\n     */\n    public async getEventTimeline(timelineSet: EventTimelineSet, eventId: string): Promise<Optional<EventTimeline>> {\n        // don't allow any timeline support unless it's been enabled.\n        if (!this.timelineSupport) {\n            throw new Error(\n                \"timeline support is disabled. Set the 'timelineSupport'\" +\n                    \" parameter to true when creating MatrixClient to enable it.\",\n            );\n        }\n\n        if (!timelineSet?.room) {\n            throw new Error(\"getEventTimeline only supports room timelines\");\n        }\n\n        if (timelineSet.getTimelineForEvent(eventId)) {\n            return timelineSet.getTimelineForEvent(eventId);\n        }\n\n        if (timelineSet.thread && this.supportsThreads()) {\n            return this.getThreadTimeline(timelineSet, eventId);\n        }\n\n        const path = utils.encodeUri(\"/rooms/$roomId/context/$eventId\", {\n            $roomId: timelineSet.room.roomId,\n            $eventId: eventId,\n        });\n\n        let params: Record<string, string | string[]> | undefined = undefined;\n        if (this.clientOpts?.lazyLoadMembers) {\n            params = { filter: JSON.stringify(Filter.LAZY_LOADING_MESSAGES_FILTER) };\n        }\n\n        // TODO: we should implement a backoff (as per scrollback()) to deal more nicely with HTTP errors.\n        const res = await this.http.authedRequest<IContextResponse>(Method.Get, path, params);\n        if (!res.event) {\n            throw new Error(\"'event' not in '/context' result - homeserver too old?\");\n        }\n\n        // by the time the request completes, the event might have ended up in the timeline.\n        if (timelineSet.getTimelineForEvent(eventId)) {\n            return timelineSet.getTimelineForEvent(eventId);\n        }\n\n        const mapper = this.getEventMapper();\n        const event = mapper(res.event);\n        if (event.isRelation(THREAD_RELATION_TYPE.name)) {\n            this.logger.warn(\"Tried loading a regular timeline at the position of a thread event\");\n            return undefined;\n        }\n        const events = [\n            // Order events from most recent to oldest (reverse-chronological).\n            // We start with the last event, since that's the point at which we have known state.\n            // events_after is already backwards; events_before is forwards.\n            ...res.events_after.reverse().map(mapper),\n            event,\n            ...res.events_before.map(mapper),\n        ];\n\n        // Here we handle non-thread timelines only, but still process any thread events to populate thread summaries.\n        let timeline = timelineSet.getTimelineForEvent(events[0].getId());\n        if (timeline) {\n            timeline.getState(EventTimeline.BACKWARDS)!.setUnknownStateEvents(res.state.map(mapper));\n        } else {\n            timeline = timelineSet.addTimeline();\n            timeline.initialiseState(res.state.map(mapper));\n            timeline.getState(EventTimeline.FORWARDS)!.paginationToken = res.end;\n        }\n\n        const [timelineEvents, threadedEvents, unknownRelations] = timelineSet.room.partitionThreadedEvents(events);\n        timelineSet.addEventsToTimeline(timelineEvents, true, false, timeline, res.start);\n        // The target event is not in a thread but process the contextual events, so we can show any threads around it.\n        this.processThreadEvents(timelineSet.room, threadedEvents, true);\n        this.processAggregatedTimelineEvents(timelineSet.room, timelineEvents);\n        unknownRelations.forEach((event) => timelineSet.relations.aggregateChildEvent(event));\n\n        // There is no guarantee that the event ended up in \"timeline\" (we might have switched to a neighbouring\n        // timeline) - so check the room's index again. On the other hand, there's no guarantee the event ended up\n        // anywhere, if it was later redacted, so we just return the timeline we first thought of.\n        return (\n            timelineSet.getTimelineForEvent(eventId) ??\n            timelineSet.room.findThreadForEvent(event)?.liveTimeline ?? // for Threads degraded support\n            timeline\n        );\n    }\n\n    public async getThreadTimeline(timelineSet: EventTimelineSet, eventId: string): Promise<EventTimeline | undefined> {\n        if (!this.supportsThreads()) {\n            throw new Error(\"could not get thread timeline: no client support\");\n        }\n\n        if (!timelineSet.room) {\n            throw new Error(\"could not get thread timeline: not a room timeline\");\n        }\n\n        if (!timelineSet.thread) {\n            throw new Error(\"could not get thread timeline: not a thread timeline\");\n        }\n\n        const path = utils.encodeUri(\"/rooms/$roomId/context/$eventId\", {\n            $roomId: timelineSet.room.roomId,\n            $eventId: eventId,\n        });\n\n        const params: Record<string, string | string[]> = {\n            limit: \"0\",\n        };\n        if (this.clientOpts?.lazyLoadMembers) {\n            params.filter = JSON.stringify(Filter.LAZY_LOADING_MESSAGES_FILTER);\n        }\n\n        // TODO: we should implement a backoff (as per scrollback()) to deal more nicely with HTTP errors.\n        const res = await this.http.authedRequest<IContextResponse>(Method.Get, path, params);\n        const mapper = this.getEventMapper();\n        const event = mapper(res.event);\n\n        if (!timelineSet.canContain(event)) {\n            return undefined;\n        }\n\n        const recurse = this.canSupport.get(Feature.RelationsRecursion) !== ServerSupport.Unsupported;\n        if (Thread.hasServerSideSupport) {\n            if (Thread.hasServerSideFwdPaginationSupport) {\n                if (!timelineSet.thread) {\n                    throw new Error(\"could not get thread timeline: not a thread timeline\");\n                }\n\n                const thread = timelineSet.thread;\n                const resOlder: IRelationsResponse = await this.fetchRelations(\n                    timelineSet.room.roomId,\n                    thread.id,\n                    null,\n                    null,\n                    { dir: Direction.Backward, from: res.start, recurse: recurse || undefined },\n                );\n                const resNewer: IRelationsResponse = await this.fetchRelations(\n                    timelineSet.room.roomId,\n                    thread.id,\n                    null,\n                    null,\n                    { dir: Direction.Forward, from: res.end, recurse: recurse || undefined },\n                );\n                const events = [\n                    // Order events from most recent to oldest (reverse-chronological).\n                    // We start with the last event, since that's the point at which we have known state.\n                    // events_after is already backwards; events_before is forwards.\n                    ...resNewer.chunk.reverse().filter(getRelationsThreadFilter(thread.id)).map(mapper),\n                    event,\n                    ...resOlder.chunk.filter(getRelationsThreadFilter(thread.id)).map(mapper),\n                ];\n\n                for (const event of events) {\n                    await timelineSet.thread?.processEvent(event);\n                }\n\n                // Here we handle non-thread timelines only, but still process any thread events to populate thread summaries.\n                let timeline = timelineSet.getTimelineForEvent(event.getId());\n                if (timeline) {\n                    timeline.getState(EventTimeline.BACKWARDS)!.setUnknownStateEvents(res.state.map(mapper));\n                } else {\n                    timeline = timelineSet.addTimeline();\n                    timeline.initialiseState(res.state.map(mapper));\n                }\n\n                timelineSet.addEventsToTimeline(events, true, false, timeline, resNewer.next_batch);\n                if (!resOlder.next_batch) {\n                    const originalEvent = await this.fetchRoomEvent(timelineSet.room.roomId, thread.id);\n                    timelineSet.addEventsToTimeline([mapper(originalEvent)], true, false, timeline, null);\n                }\n                timeline.setPaginationToken(resOlder.next_batch ?? null, Direction.Backward);\n                timeline.setPaginationToken(resNewer.next_batch ?? null, Direction.Forward);\n                this.processAggregatedTimelineEvents(timelineSet.room, events);\n\n                // There is no guarantee that the event ended up in \"timeline\" (we might have switched to a neighbouring\n                // timeline) - so check the room's index again. On the other hand, there's no guarantee the event ended up\n                // anywhere, if it was later redacted, so we just return the timeline we first thought of.\n                return timelineSet.getTimelineForEvent(eventId) ?? timeline;\n            } else {\n                // Where the event is a thread reply (not a root) and running in MSC-enabled mode the Thread timeline only\n                // functions contiguously, so we have to jump through some hoops to get our target event in it.\n                // XXX: workaround for https://github.com/vector-im/element-meta/issues/150\n\n                const thread = timelineSet.thread;\n\n                const resOlder = await this.fetchRelations(\n                    timelineSet.room.roomId,\n                    thread.id,\n                    THREAD_RELATION_TYPE.name,\n                    null,\n                    { dir: Direction.Backward, from: res.start, recurse: recurse || undefined },\n                );\n                const eventsNewer: IEvent[] = [];\n                let nextBatch: Optional<string> = res.end;\n                while (nextBatch) {\n                    const resNewer: IRelationsResponse = await this.fetchRelations(\n                        timelineSet.room.roomId,\n                        thread.id,\n                        THREAD_RELATION_TYPE.name,\n                        null,\n                        { dir: Direction.Forward, from: nextBatch, recurse: recurse || undefined },\n                    );\n                    nextBatch = resNewer.next_batch ?? null;\n                    eventsNewer.push(...resNewer.chunk);\n                }\n                const events = [\n                    // Order events from most recent to oldest (reverse-chronological).\n                    // We start with the last event, since that's the point at which we have known state.\n                    // events_after is already backwards; events_before is forwards.\n                    ...eventsNewer.reverse().map(mapper),\n                    event,\n                    ...resOlder.chunk.map(mapper),\n                ];\n                for (const event of events) {\n                    await timelineSet.thread?.processEvent(event);\n                }\n\n                // Here we handle non-thread timelines only, but still process any thread events to populate thread\n                // summaries.\n                const timeline = timelineSet.getLiveTimeline();\n                timeline.getState(EventTimeline.BACKWARDS)!.setUnknownStateEvents(res.state.map(mapper));\n\n                timelineSet.addEventsToTimeline(events, true, false, timeline, null);\n                if (!resOlder.next_batch) {\n                    const originalEvent = await this.fetchRoomEvent(timelineSet.room.roomId, thread.id);\n                    timelineSet.addEventsToTimeline([mapper(originalEvent)], true, false, timeline, null);\n                }\n                timeline.setPaginationToken(resOlder.next_batch ?? null, Direction.Backward);\n                timeline.setPaginationToken(null, Direction.Forward);\n                this.processAggregatedTimelineEvents(timelineSet.room, events);\n\n                return timeline;\n            }\n        }\n    }\n\n    /**\n     * Get an EventTimeline for the latest events in the room. This will just\n     * call `/messages` to get the latest message in the room, then use\n     * `client.getEventTimeline(...)` to construct a new timeline from it.\n     *\n     * @param timelineSet -  The timelineSet to find or add the timeline to\n     *\n     * @returns Promise which resolves:\n     *    {@link EventTimeline} timeline with the latest events in the room\n     */\n    public async getLatestTimeline(timelineSet: EventTimelineSet): Promise<Optional<EventTimeline>> {\n        // don't allow any timeline support unless it's been enabled.\n        if (!this.timelineSupport) {\n            throw new Error(\n                \"timeline support is disabled. Set the 'timelineSupport'\" +\n                    \" parameter to true when creating MatrixClient to enable it.\",\n            );\n        }\n\n        if (!timelineSet.room) {\n            throw new Error(\"getLatestTimeline only supports room timelines\");\n        }\n\n        let event: IRoomEvent | undefined;\n        if (timelineSet.threadListType !== null) {\n            const res = await this.createThreadListMessagesRequest(\n                timelineSet.room.roomId,\n                null,\n                1,\n                Direction.Backward,\n                timelineSet.threadListType,\n                timelineSet.getFilter(),\n            );\n            event = res.chunk?.[0];\n        } else if (timelineSet.thread && Thread.hasServerSideSupport) {\n            const recurse = this.canSupport.get(Feature.RelationsRecursion) !== ServerSupport.Unsupported;\n            const res = await this.fetchRelations(\n                timelineSet.room.roomId,\n                timelineSet.thread.id,\n                THREAD_RELATION_TYPE.name,\n                null,\n                { dir: Direction.Backward, limit: 1, recurse: recurse || undefined },\n            );\n            event = res.chunk?.[0];\n        } else {\n            const messagesPath = utils.encodeUri(\"/rooms/$roomId/messages\", {\n                $roomId: timelineSet.room.roomId,\n            });\n\n            const params: Record<string, string | string[]> = {\n                dir: \"b\",\n            };\n            if (this.clientOpts?.lazyLoadMembers) {\n                params.filter = JSON.stringify(Filter.LAZY_LOADING_MESSAGES_FILTER);\n            }\n\n            const res = await this.http.authedRequest<IMessagesResponse>(Method.Get, messagesPath, params);\n            event = res.chunk?.[0];\n        }\n        if (!event) {\n            throw new Error(\"No message returned when trying to construct getLatestTimeline\");\n        }\n\n        return this.getEventTimeline(timelineSet, event.event_id);\n    }\n\n    /**\n     * Makes a request to /messages with the appropriate lazy loading filter set.\n     * XXX: if we do get rid of scrollback (as it's not used at the moment),\n     * we could inline this method again in paginateEventTimeline as that would\n     * then be the only call-site\n     * @param limit - the maximum amount of events the retrieve\n     * @param dir - 'f' or 'b'\n     * @param timelineFilter - the timeline filter to pass\n     */\n    // XXX: Intended private, used in code.\n    public createMessagesRequest(\n        roomId: string,\n        fromToken: string | null,\n        limit = 30,\n        dir: Direction,\n        timelineFilter?: Filter,\n    ): Promise<IMessagesResponse> {\n        const path = utils.encodeUri(\"/rooms/$roomId/messages\", { $roomId: roomId });\n\n        const params: Record<string, string> = {\n            limit: limit.toString(),\n            dir: dir,\n        };\n\n        if (fromToken) {\n            params.from = fromToken;\n        }\n\n        let filter: IRoomEventFilter | null = null;\n        if (this.clientOpts?.lazyLoadMembers) {\n            // create a shallow copy of LAZY_LOADING_MESSAGES_FILTER,\n            // so the timelineFilter doesn't get written into it below\n            filter = Object.assign({}, Filter.LAZY_LOADING_MESSAGES_FILTER);\n        }\n        if (timelineFilter) {\n            // XXX: it's horrific that /messages' filter parameter doesn't match\n            // /sync's one - see https://matrix.org/jira/browse/SPEC-451\n            filter = filter || {};\n            Object.assign(filter, timelineFilter.getRoomTimelineFilterComponent()?.toJSON());\n        }\n        if (filter) {\n            params.filter = JSON.stringify(filter);\n        }\n        return this.http.authedRequest(Method.Get, path, params);\n    }\n\n    /**\n     * Makes a request to /messages with the appropriate lazy loading filter set.\n     * XXX: if we do get rid of scrollback (as it's not used at the moment),\n     * we could inline this method again in paginateEventTimeline as that would\n     * then be the only call-site\n     * @param limit - the maximum amount of events the retrieve\n     * @param dir - 'f' or 'b'\n     * @param timelineFilter - the timeline filter to pass\n     */\n    // XXX: Intended private, used by room.fetchRoomThreads\n    public createThreadListMessagesRequest(\n        roomId: string,\n        fromToken: string | null,\n        limit = 30,\n        dir = Direction.Backward,\n        threadListType: ThreadFilterType | null = ThreadFilterType.All,\n        timelineFilter?: Filter,\n    ): Promise<IMessagesResponse> {\n        const path = utils.encodeUri(\"/rooms/$roomId/threads\", { $roomId: roomId });\n\n        const params: Record<string, string> = {\n            limit: limit.toString(),\n            dir: dir,\n            include: threadFilterTypeToFilter(threadListType),\n        };\n\n        if (fromToken) {\n            params.from = fromToken;\n        }\n\n        let filter: IRoomEventFilter = {};\n        if (this.clientOpts?.lazyLoadMembers) {\n            // create a shallow copy of LAZY_LOADING_MESSAGES_FILTER,\n            // so the timelineFilter doesn't get written into it below\n            filter = {\n                ...Filter.LAZY_LOADING_MESSAGES_FILTER,\n            };\n        }\n        if (timelineFilter) {\n            // XXX: it's horrific that /messages' filter parameter doesn't match\n            // /sync's one - see https://matrix.org/jira/browse/SPEC-451\n            filter = {\n                ...filter,\n                ...timelineFilter.getRoomTimelineFilterComponent()?.toJSON(),\n            };\n        }\n        if (Object.keys(filter).length) {\n            params.filter = JSON.stringify(filter);\n        }\n\n        const opts = {\n            prefix:\n                Thread.hasServerSideListSupport === FeatureSupport.Stable\n                    ? ClientPrefix.V1\n                    : \"/_matrix/client/unstable/org.matrix.msc3856\",\n        };\n\n        return this.http\n            .authedRequest<IThreadedMessagesResponse>(Method.Get, path, params, undefined, opts)\n            .then((res) => ({\n                ...res,\n                chunk: res.chunk?.reverse(),\n                start: res.prev_batch,\n                end: res.next_batch,\n            }));\n    }\n\n    /**\n     * Take an EventTimeline, and back/forward-fill results.\n     *\n     * @param eventTimeline - timeline object to be updated\n     *\n     * @returns Promise which resolves to a boolean: false if there are no\n     *    events and we reached either end of the timeline; else true.\n     */\n    public paginateEventTimeline(eventTimeline: EventTimeline, opts: IPaginateOpts): Promise<boolean> {\n        const isNotifTimeline = eventTimeline.getTimelineSet() === this.notifTimelineSet;\n        const room = this.getRoom(eventTimeline.getRoomId()!);\n        const threadListType = eventTimeline.getTimelineSet().threadListType;\n        const thread = eventTimeline.getTimelineSet().thread;\n\n        // TODO: we should implement a backoff (as per scrollback()) to deal more\n        // nicely with HTTP errors.\n        opts = opts || {};\n        const backwards = opts.backwards || false;\n\n        if (isNotifTimeline) {\n            if (!backwards) {\n                throw new Error(\"paginateNotifTimeline can only paginate backwards\");\n            }\n        }\n\n        const dir = backwards ? EventTimeline.BACKWARDS : EventTimeline.FORWARDS;\n\n        const token = eventTimeline.getPaginationToken(dir);\n        const pendingRequest = eventTimeline.paginationRequests[dir];\n\n        if (pendingRequest) {\n            // already a request in progress - return the existing promise\n            return pendingRequest;\n        }\n\n        let path: string;\n        let params: Record<string, string>;\n        let promise: Promise<boolean>;\n\n        if (isNotifTimeline) {\n            path = \"/notifications\";\n            params = {\n                limit: (opts.limit ?? 30).toString(),\n                only: \"highlight\",\n            };\n\n            if (token && token !== \"end\") {\n                params.from = token;\n            }\n\n            promise = this.http\n                .authedRequest<INotificationsResponse>(Method.Get, path, params)\n                .then(async (res) => {\n                    const token = res.next_token;\n                    const matrixEvents: MatrixEvent[] = [];\n\n                    res.notifications = res.notifications.filter(noUnsafeEventProps);\n\n                    for (let i = 0; i < res.notifications.length; i++) {\n                        const notification = res.notifications[i];\n                        const event = this.getEventMapper()(notification.event);\n\n                        // @TODO(kerrya) reprocessing every notification is ugly\n                        // remove if we get server MSC3994 support\n                        this.getPushDetailsForEvent(event, true);\n\n                        event.event.room_id = notification.room_id; // XXX: gutwrenching\n                        matrixEvents[i] = event;\n                    }\n\n                    // No need to partition events for threads here, everything lives\n                    // in the notification timeline set\n                    const timelineSet = eventTimeline.getTimelineSet();\n                    timelineSet.addEventsToTimeline(matrixEvents, backwards, false, eventTimeline, token);\n                    this.processAggregatedTimelineEvents(timelineSet.room, matrixEvents);\n\n                    // if we've hit the end of the timeline, we need to stop trying to\n                    // paginate. We need to keep the 'forwards' token though, to make sure\n                    // we can recover from gappy syncs.\n                    if (backwards && !res.next_token) {\n                        eventTimeline.setPaginationToken(null, dir);\n                    }\n                    return Boolean(res.next_token);\n                })\n                .finally(() => {\n                    eventTimeline.paginationRequests[dir] = null;\n                });\n            eventTimeline.paginationRequests[dir] = promise;\n        } else if (threadListType !== null) {\n            if (!room) {\n                throw new Error(\"Unknown room \" + eventTimeline.getRoomId());\n            }\n\n            if (!Thread.hasServerSideFwdPaginationSupport && dir === Direction.Forward) {\n                throw new Error(\"Cannot paginate threads forwards without server-side support for MSC 3715\");\n            }\n\n            promise = this.createThreadListMessagesRequest(\n                eventTimeline.getRoomId()!,\n                token,\n                opts.limit,\n                dir,\n                threadListType,\n                eventTimeline.getFilter(),\n            )\n                .then((res) => {\n                    if (res.state) {\n                        const roomState = eventTimeline.getState(dir)!;\n                        const stateEvents = res.state.filter(noUnsafeEventProps).map(this.getEventMapper());\n                        roomState.setUnknownStateEvents(stateEvents);\n                    }\n\n                    const token = res.end;\n                    const matrixEvents = res.chunk.filter(noUnsafeEventProps).map(this.getEventMapper());\n\n                    const timelineSet = eventTimeline.getTimelineSet();\n                    timelineSet.addEventsToTimeline(matrixEvents, backwards, false, eventTimeline, token);\n                    this.processAggregatedTimelineEvents(room, matrixEvents);\n                    this.processThreadRoots(room, matrixEvents, backwards);\n\n                    // if we've hit the end of the timeline, we need to stop trying to\n                    // paginate. We need to keep the 'forwards' token though, to make sure\n                    // we can recover from gappy syncs.\n                    if (backwards && res.end == res.start) {\n                        eventTimeline.setPaginationToken(null, dir);\n                    }\n                    return res.end !== res.start;\n                })\n                .finally(() => {\n                    eventTimeline.paginationRequests[dir] = null;\n                });\n            eventTimeline.paginationRequests[dir] = promise;\n        } else if (thread) {\n            const room = this.getRoom(eventTimeline.getRoomId() ?? undefined);\n            if (!room) {\n                throw new Error(\"Unknown room \" + eventTimeline.getRoomId());\n            }\n\n            const recurse = this.canSupport.get(Feature.RelationsRecursion) !== ServerSupport.Unsupported;\n            promise = this.fetchRelations(eventTimeline.getRoomId() ?? \"\", thread.id, null, null, {\n                dir,\n                limit: opts.limit,\n                from: token ?? undefined,\n                recurse: recurse || undefined,\n            })\n                .then(async (res) => {\n                    const mapper = this.getEventMapper();\n                    const matrixEvents = res.chunk\n                        .filter(noUnsafeEventProps)\n                        .filter(getRelationsThreadFilter(thread.id))\n                        .map(mapper);\n\n                    // Process latest events first\n                    for (const event of matrixEvents.slice().reverse()) {\n                        await thread?.processEvent(event);\n                        const sender = event.getSender()!;\n                        if (!backwards || thread?.getEventReadUpTo(sender) === null) {\n                            room.addLocalEchoReceipt(sender, event, ReceiptType.Read);\n                        }\n                    }\n\n                    const newToken = res.next_batch;\n\n                    const timelineSet = eventTimeline.getTimelineSet();\n                    timelineSet.addEventsToTimeline(matrixEvents, backwards, false, eventTimeline, newToken ?? null);\n                    if (!newToken && backwards) {\n                        const originalEvent =\n                            thread.rootEvent ??\n                            mapper(await this.fetchRoomEvent(eventTimeline.getRoomId() ?? \"\", thread.id));\n                        timelineSet.addEventsToTimeline([originalEvent], true, false, eventTimeline, null);\n                    }\n                    this.processAggregatedTimelineEvents(timelineSet.room, matrixEvents);\n\n                    // if we've hit the end of the timeline, we need to stop trying to\n                    // paginate. We need to keep the 'forwards' token though, to make sure\n                    // we can recover from gappy syncs.\n                    if (backwards && !newToken) {\n                        eventTimeline.setPaginationToken(null, dir);\n                    }\n                    return Boolean(newToken);\n                })\n                .finally(() => {\n                    eventTimeline.paginationRequests[dir] = null;\n                });\n            eventTimeline.paginationRequests[dir] = promise;\n        } else {\n            if (!room) {\n                throw new Error(\"Unknown room \" + eventTimeline.getRoomId());\n            }\n\n            promise = this.createMessagesRequest(\n                eventTimeline.getRoomId()!,\n                token,\n                opts.limit,\n                dir,\n                eventTimeline.getFilter(),\n            )\n                .then((res) => {\n                    if (res.state) {\n                        const roomState = eventTimeline.getState(dir)!;\n                        const stateEvents = res.state.filter(noUnsafeEventProps).map(this.getEventMapper());\n                        roomState.setUnknownStateEvents(stateEvents);\n                    }\n                    const token = res.end;\n                    const matrixEvents = res.chunk.filter(noUnsafeEventProps).map(this.getEventMapper());\n\n                    const timelineSet = eventTimeline.getTimelineSet();\n                    const [timelineEvents, , unknownRelations] = room.partitionThreadedEvents(matrixEvents);\n                    timelineSet.addEventsToTimeline(timelineEvents, backwards, false, eventTimeline, token);\n                    this.processAggregatedTimelineEvents(room, timelineEvents);\n                    this.processThreadRoots(\n                        room,\n                        timelineEvents.filter((it) => it.getServerAggregatedRelation(THREAD_RELATION_TYPE.name)),\n                        false,\n                    );\n                    unknownRelations.forEach((event) => room.relations.aggregateChildEvent(event));\n\n                    const atEnd = res.end === undefined || res.end === res.start;\n\n                    // if we've hit the end of the timeline, we need to stop trying to\n                    // paginate. We need to keep the 'forwards' token though, to make sure\n                    // we can recover from gappy syncs.\n                    if (backwards && atEnd) {\n                        eventTimeline.setPaginationToken(null, dir);\n                    }\n                    return !atEnd;\n                })\n                .finally(() => {\n                    eventTimeline.paginationRequests[dir] = null;\n                });\n            eventTimeline.paginationRequests[dir] = promise;\n        }\n\n        return promise;\n    }\n\n    /**\n     * Reset the notifTimelineSet entirely, paginating in some historical notifs as\n     * a starting point for subsequent pagination.\n     */\n    public resetNotifTimelineSet(): void {\n        if (!this.notifTimelineSet) {\n            return;\n        }\n\n        // FIXME: This thing is a total hack, and results in duplicate events being\n        // added to the timeline both from /sync and /notifications, and lots of\n        // slow and wasteful processing and pagination.  The correct solution is to\n        // extend /messages or /search or something to filter on notifications.\n\n        // use the fictitious token 'end'. in practice we would ideally give it\n        // the oldest backwards pagination token from /sync, but /sync doesn't\n        // know about /notifications, so we have no choice but to start paginating\n        // from the current point in time.  This may well overlap with historical\n        // notifs which are then inserted into the timeline by /sync responses.\n        this.notifTimelineSet.resetLiveTimeline(\"end\");\n\n        // we could try to paginate a single event at this point in order to get\n        // a more valid pagination token, but it just ends up with an out of order\n        // timeline. given what a mess this is and given we're going to have duplicate\n        // events anyway, just leave it with the dummy token for now.\n        /*\n        this.paginateNotifTimeline(this._notifTimelineSet.getLiveTimeline(), {\n            backwards: true,\n            limit: 1\n        });\n        */\n    }\n\n    /**\n     * Peek into a room and receive updates about the room. This only works if the\n     * history visibility for the room is world_readable.\n     * @param roomId - The room to attempt to peek into.\n     * @param limit - The number of timeline events to initially retrieve.\n     * @returns Promise which resolves: Room object\n     * @returns Rejects: with an error response.\n     */\n    public peekInRoom(roomId: string, limit: number = 20): Promise<Room> {\n        this.peekSync?.stopPeeking();\n        this.peekSync = new SyncApi(this, this.clientOpts, this.buildSyncApiOptions());\n        return this.peekSync.peek(roomId, limit);\n    }\n\n    /**\n     * Stop any ongoing room peeking.\n     */\n    public stopPeeking(): void {\n        if (this.peekSync) {\n            this.peekSync.stopPeeking();\n            this.peekSync = null;\n        }\n    }\n\n    /**\n     * Set r/w flags for guest access in a room.\n     * @param roomId - The room to configure guest access in.\n     * @param opts - Options\n     * @returns Promise which resolves\n     * @returns Rejects: with an error response.\n     */\n    public setGuestAccess(roomId: string, opts: IGuestAccessOpts): Promise<void> {\n        const writePromise = this.sendStateEvent(\n            roomId,\n            EventType.RoomGuestAccess,\n            {\n                guest_access: opts.allowJoin ? GuestAccess.CanJoin : GuestAccess.Forbidden,\n            },\n            \"\",\n        );\n\n        let readPromise: Promise<unknown> = Promise.resolve();\n        if (opts.allowRead) {\n            readPromise = this.sendStateEvent(\n                roomId,\n                EventType.RoomHistoryVisibility,\n                {\n                    history_visibility: HistoryVisibility.WorldReadable,\n                },\n                \"\",\n            );\n        }\n\n        return Promise.all([readPromise, writePromise]).then(); // .then() to hide results for contract\n    }\n\n    /**\n     * Requests an email verification token for the purposes of registration.\n     * This API requests a token from the homeserver.\n     * The doesServerRequireIdServerParam() method can be used to determine if\n     * the server requires the id_server parameter to be provided.\n     *\n     * Parameters and return value are as for requestEmailToken\n\n     * @param email - As requestEmailToken\n     * @param clientSecret - As requestEmailToken\n     * @param sendAttempt - As requestEmailToken\n     * @param nextLink - As requestEmailToken\n     * @returns Promise which resolves: As requestEmailToken\n     */\n    public requestRegisterEmailToken(\n        email: string,\n        clientSecret: string,\n        sendAttempt: number,\n        nextLink?: string,\n    ): Promise<IRequestTokenResponse> {\n        return this.requestTokenFromEndpoint(\"/register/email/requestToken\", {\n            email: email,\n            client_secret: clientSecret,\n            send_attempt: sendAttempt,\n            next_link: nextLink,\n        });\n    }\n\n    /**\n     * Requests a text message verification token for the purposes of registration.\n     * This API requests a token from the homeserver.\n     * The doesServerRequireIdServerParam() method can be used to determine if\n     * the server requires the id_server parameter to be provided.\n     *\n     * @param phoneCountry - The ISO 3166-1 alpha-2 code for the country in which\n     *    phoneNumber should be parsed relative to.\n     * @param phoneNumber - The phone number, in national or international format\n     * @param clientSecret - As requestEmailToken\n     * @param sendAttempt - As requestEmailToken\n     * @param nextLink - As requestEmailToken\n     * @returns Promise which resolves: As requestEmailToken\n     */\n    public requestRegisterMsisdnToken(\n        phoneCountry: string,\n        phoneNumber: string,\n        clientSecret: string,\n        sendAttempt: number,\n        nextLink?: string,\n    ): Promise<IRequestMsisdnTokenResponse> {\n        return this.requestTokenFromEndpoint(\"/register/msisdn/requestToken\", {\n            country: phoneCountry,\n            phone_number: phoneNumber,\n            client_secret: clientSecret,\n            send_attempt: sendAttempt,\n            next_link: nextLink,\n        });\n    }\n\n    /**\n     * Requests an email verification token for the purposes of adding a\n     * third party identifier to an account.\n     * This API requests a token from the homeserver.\n     * The doesServerRequireIdServerParam() method can be used to determine if\n     * the server requires the id_server parameter to be provided.\n     * If an account with the given email address already exists and is\n     * associated with an account other than the one the user is authed as,\n     * it will either send an email to the address informing them of this\n     * or return M_THREEPID_IN_USE (which one is up to the homeserver).\n     *\n     * @param email - As requestEmailToken\n     * @param clientSecret - As requestEmailToken\n     * @param sendAttempt - As requestEmailToken\n     * @param nextLink - As requestEmailToken\n     * @returns Promise which resolves: As requestEmailToken\n     */\n    public requestAdd3pidEmailToken(\n        email: string,\n        clientSecret: string,\n        sendAttempt: number,\n        nextLink?: string,\n    ): Promise<IRequestTokenResponse> {\n        return this.requestTokenFromEndpoint(\"/account/3pid/email/requestToken\", {\n            email: email,\n            client_secret: clientSecret,\n            send_attempt: sendAttempt,\n            next_link: nextLink,\n        });\n    }\n\n    /**\n     * Requests a text message verification token for the purposes of adding a\n     * third party identifier to an account.\n     * This API proxies the identity server /validate/email/requestToken API,\n     * adding specific behaviour for the addition of phone numbers to an\n     * account, as requestAdd3pidEmailToken.\n     *\n     * @param phoneCountry - As requestRegisterMsisdnToken\n     * @param phoneNumber - As requestRegisterMsisdnToken\n     * @param clientSecret - As requestEmailToken\n     * @param sendAttempt - As requestEmailToken\n     * @param nextLink - As requestEmailToken\n     * @returns Promise which resolves: As requestEmailToken\n     */\n    public requestAdd3pidMsisdnToken(\n        phoneCountry: string,\n        phoneNumber: string,\n        clientSecret: string,\n        sendAttempt: number,\n        nextLink?: string,\n    ): Promise<IRequestMsisdnTokenResponse> {\n        return this.requestTokenFromEndpoint(\"/account/3pid/msisdn/requestToken\", {\n            country: phoneCountry,\n            phone_number: phoneNumber,\n            client_secret: clientSecret,\n            send_attempt: sendAttempt,\n            next_link: nextLink,\n        });\n    }\n\n    /**\n     * Requests an email verification token for the purposes of resetting\n     * the password on an account.\n     * This API proxies the identity server /validate/email/requestToken API,\n     * adding specific behaviour for the password resetting. Specifically,\n     * if no account with the given email address exists, it may either\n     * return M_THREEPID_NOT_FOUND or send an email\n     * to the address informing them of this (which one is up to the homeserver).\n     *\n     * requestEmailToken calls the equivalent API directly on the identity server,\n     * therefore bypassing the password reset specific logic.\n     *\n     * @param email - As requestEmailToken\n     * @param clientSecret - As requestEmailToken\n     * @param sendAttempt - As requestEmailToken\n     * @param nextLink - As requestEmailToken\n     * @returns Promise which resolves: As requestEmailToken\n     */\n    public requestPasswordEmailToken(\n        email: string,\n        clientSecret: string,\n        sendAttempt: number,\n        nextLink?: string,\n    ): Promise<IRequestTokenResponse> {\n        return this.requestTokenFromEndpoint(\"/account/password/email/requestToken\", {\n            email: email,\n            client_secret: clientSecret,\n            send_attempt: sendAttempt,\n            next_link: nextLink,\n        });\n    }\n\n    /**\n     * Requests a text message verification token for the purposes of resetting\n     * the password on an account.\n     * This API proxies the identity server /validate/email/requestToken API,\n     * adding specific behaviour for the password resetting, as requestPasswordEmailToken.\n     *\n     * @param phoneCountry - As requestRegisterMsisdnToken\n     * @param phoneNumber - As requestRegisterMsisdnToken\n     * @param clientSecret - As requestEmailToken\n     * @param sendAttempt - As requestEmailToken\n     * @param nextLink - As requestEmailToken\n     * @returns Promise which resolves: As requestEmailToken\n     */\n    public requestPasswordMsisdnToken(\n        phoneCountry: string,\n        phoneNumber: string,\n        clientSecret: string,\n        sendAttempt: number,\n        nextLink: string,\n    ): Promise<IRequestMsisdnTokenResponse> {\n        return this.requestTokenFromEndpoint(\"/account/password/msisdn/requestToken\", {\n            country: phoneCountry,\n            phone_number: phoneNumber,\n            client_secret: clientSecret,\n            send_attempt: sendAttempt,\n            next_link: nextLink,\n        });\n    }\n\n    /**\n     * Internal utility function for requesting validation tokens from usage-specific\n     * requestToken endpoints.\n     *\n     * @param endpoint - The endpoint to send the request to\n     * @param params - Parameters for the POST request\n     * @returns Promise which resolves: As requestEmailToken\n     */\n    private async requestTokenFromEndpoint<T extends IRequestTokenResponse>(\n        endpoint: string,\n        params: QueryDict,\n    ): Promise<T> {\n        const postParams = Object.assign({}, params);\n\n        return this.http.request(Method.Post, endpoint, undefined, postParams);\n    }\n\n    /**\n     * Get the room-kind push rule associated with a room.\n     * @param scope - \"global\" or device-specific.\n     * @param roomId - the id of the room.\n     * @returns the rule or undefined.\n     */\n    public getRoomPushRule(scope: \"global\" | \"device\", roomId: string): IPushRule | undefined {\n        // There can be only room-kind push rule per room\n        // and its id is the room id.\n        if (this.pushRules) {\n            return this.pushRules[scope]?.room?.find((rule) => rule.rule_id === roomId);\n        } else {\n            throw new Error(\"SyncApi.sync() must be done before accessing to push rules.\");\n        }\n    }\n\n    /**\n     * Set a room-kind muting push rule in a room.\n     * The operation also updates MatrixClient.pushRules at the end.\n     * @param scope - \"global\" or device-specific.\n     * @param roomId - the id of the room.\n     * @param mute - the mute state.\n     * @returns Promise which resolves: result object\n     * @returns Rejects: with an error response.\n     */\n    public setRoomMutePushRule(scope: \"global\" | \"device\", roomId: string, mute: boolean): Promise<void> | undefined {\n        let promise: Promise<unknown> | undefined;\n        let hasDontNotifyRule = false;\n\n        // Get the existing room-kind push rule if any\n        const roomPushRule = this.getRoomPushRule(scope, roomId);\n        if (roomPushRule?.actions.includes(PushRuleActionName.DontNotify)) {\n            hasDontNotifyRule = true;\n        }\n\n        if (!mute) {\n            // Remove the rule only if it is a muting rule\n            if (hasDontNotifyRule) {\n                promise = this.deletePushRule(scope, PushRuleKind.RoomSpecific, roomPushRule!.rule_id);\n            }\n        } else {\n            if (!roomPushRule) {\n                promise = this.addPushRule(scope, PushRuleKind.RoomSpecific, roomId, {\n                    actions: [PushRuleActionName.DontNotify],\n                });\n            } else if (!hasDontNotifyRule) {\n                // Remove the existing one before setting the mute push rule\n                // This is a workaround to SYN-590 (Push rule update fails)\n                const deferred = utils.defer();\n                this.deletePushRule(scope, PushRuleKind.RoomSpecific, roomPushRule.rule_id)\n                    .then(() => {\n                        this.addPushRule(scope, PushRuleKind.RoomSpecific, roomId, {\n                            actions: [PushRuleActionName.DontNotify],\n                        })\n                            .then(() => {\n                                deferred.resolve();\n                            })\n                            .catch((err) => {\n                                deferred.reject(err);\n                            });\n                    })\n                    .catch((err) => {\n                        deferred.reject(err);\n                    });\n\n                promise = deferred.promise;\n            }\n        }\n\n        if (promise) {\n            return new Promise<void>((resolve, reject) => {\n                // Update this.pushRules when the operation completes\n                promise!\n                    .then(() => {\n                        this.getPushRules()\n                            .then((result) => {\n                                this.pushRules = result;\n                                resolve();\n                            })\n                            .catch((err) => {\n                                reject(err);\n                            });\n                    })\n                    .catch((err: Error) => {\n                        // Update it even if the previous operation fails. This can help the\n                        // app to recover when push settings has been modified from another client\n                        this.getPushRules()\n                            .then((result) => {\n                                this.pushRules = result;\n                                reject(err);\n                            })\n                            .catch((err2) => {\n                                reject(err);\n                            });\n                    });\n            });\n        }\n    }\n\n    public searchMessageText(opts: ISearchOpts): Promise<ISearchResponse> {\n        const roomEvents: ISearchRequestBody[\"search_categories\"][\"room_events\"] = {\n            search_term: opts.query,\n        };\n\n        if (\"keys\" in opts) {\n            roomEvents.keys = opts.keys;\n        }\n\n        return this.search({\n            body: {\n                search_categories: {\n                    room_events: roomEvents,\n                },\n            },\n        });\n    }\n\n    /**\n     * Perform a server-side search for room events.\n     *\n     * The returned promise resolves to an object containing the fields:\n     *\n     *  * count:       estimate of the number of results\n     *  * next_batch:  token for back-pagination; if undefined, there are no more results\n     *  * highlights:  a list of words to highlight from the stemming algorithm\n     *  * results:     a list of results\n     *\n     * Each entry in the results list is a SearchResult.\n     *\n     * @returns Promise which resolves: result object\n     * @returns Rejects: with an error response.\n     */\n    public searchRoomEvents(opts: IEventSearchOpts): Promise<ISearchResults> {\n        // TODO: support search groups\n\n        const body = {\n            search_categories: {\n                room_events: {\n                    search_term: opts.term,\n                    filter: opts.filter,\n                    order_by: SearchOrderBy.Recent,\n                    event_context: {\n                        before_limit: 1,\n                        after_limit: 1,\n                        include_profile: true,\n                    },\n                },\n            },\n        };\n\n        const searchResults: ISearchResults = {\n            _query: body,\n            results: [],\n            highlights: [],\n        };\n\n        return this.search({ body: body }).then((res) => this.processRoomEventsSearch(searchResults, res));\n    }\n\n    /**\n     * Take a result from an earlier searchRoomEvents call, and backfill results.\n     *\n     * @param searchResults -  the results object to be updated\n     * @returns Promise which resolves: updated result object\n     * @returns Rejects: with an error response.\n     */\n    public backPaginateRoomEventsSearch<T extends ISearchResults>(searchResults: T): Promise<T> {\n        // TODO: we should implement a backoff (as per scrollback()) to deal more\n        // nicely with HTTP errors.\n\n        if (!searchResults.next_batch) {\n            return Promise.reject(new Error(\"Cannot backpaginate event search any further\"));\n        }\n\n        if (searchResults.pendingRequest) {\n            // already a request in progress - return the existing promise\n            return searchResults.pendingRequest as Promise<T>;\n        }\n\n        const searchOpts = {\n            body: searchResults._query!,\n            next_batch: searchResults.next_batch,\n        };\n\n        const promise = this.search(searchOpts, searchResults.abortSignal)\n            .then((res) => this.processRoomEventsSearch(searchResults, res))\n            .finally(() => {\n                searchResults.pendingRequest = undefined;\n            });\n        searchResults.pendingRequest = promise;\n\n        return promise;\n    }\n\n    /**\n     * helper for searchRoomEvents and backPaginateRoomEventsSearch. Processes the\n     * response from the API call and updates the searchResults\n     *\n     * @returns searchResults\n     * @internal\n     */\n    // XXX: Intended private, used in code\n    public processRoomEventsSearch<T extends ISearchResults>(searchResults: T, response: ISearchResponse): T {\n        const roomEvents = response.search_categories.room_events;\n\n        searchResults.count = roomEvents.count;\n        searchResults.next_batch = roomEvents.next_batch;\n\n        // combine the highlight list with our existing list;\n        const highlights = new Set<string>(roomEvents.highlights);\n        searchResults.highlights.forEach((hl) => {\n            highlights.add(hl);\n        });\n\n        // turn it back into a list.\n        searchResults.highlights = Array.from(highlights);\n\n        const mapper = this.getEventMapper();\n\n        // append the new results to our existing results\n        const resultsLength = roomEvents.results?.length ?? 0;\n        for (let i = 0; i < resultsLength; i++) {\n            const sr = SearchResult.fromJson(roomEvents.results![i], mapper);\n            const room = this.getRoom(sr.context.getEvent().getRoomId());\n            if (room) {\n                for (const ev of sr.context.getTimeline()) {\n                    ev.setMetadata(room.currentState, false);\n                }\n            }\n            searchResults.results.push(sr);\n        }\n        return searchResults;\n    }\n\n    /**\n     * Populate the store with rooms the user has left.\n     * @returns Promise which resolves: TODO - Resolved when the rooms have\n     * been added to the data store.\n     * @returns Rejects: with an error response.\n     */\n    public syncLeftRooms(): Promise<Room[]> {\n        // Guard against multiple calls whilst ongoing and multiple calls post success\n        if (this.syncedLeftRooms) {\n            return Promise.resolve([]); // don't call syncRooms again if it succeeded.\n        }\n        if (this.syncLeftRoomsPromise) {\n            return this.syncLeftRoomsPromise; // return the ongoing request\n        }\n        const syncApi = new SyncApi(this, this.clientOpts, this.buildSyncApiOptions());\n        this.syncLeftRoomsPromise = syncApi.syncLeftRooms();\n\n        // cleanup locks\n        this.syncLeftRoomsPromise\n            .then(() => {\n                this.logger.debug(\"Marking success of sync left room request\");\n                this.syncedLeftRooms = true; // flip the bit on success\n            })\n            .finally(() => {\n                this.syncLeftRoomsPromise = undefined; // cleanup ongoing request state\n            });\n\n        return this.syncLeftRoomsPromise;\n    }\n\n    /**\n     * Create a new filter.\n     * @param content - The HTTP body for the request\n     * @returns Promise which resolves to a Filter object.\n     * @returns Rejects: with an error response.\n     */\n    public createFilter(content: IFilterDefinition): Promise<Filter> {\n        const path = utils.encodeUri(\"/user/$userId/filter\", {\n            $userId: this.credentials.userId!,\n        });\n        return this.http.authedRequest<IFilterResponse>(Method.Post, path, undefined, content).then((response) => {\n            // persist the filter\n            const filter = Filter.fromJson(this.credentials.userId, response.filter_id, content);\n            this.store.storeFilter(filter);\n            return filter;\n        });\n    }\n\n    /**\n     * Retrieve a filter.\n     * @param userId - The user ID of the filter owner\n     * @param filterId - The filter ID to retrieve\n     * @param allowCached - True to allow cached filters to be returned.\n     * Default: True.\n     * @returns Promise which resolves: a Filter object\n     * @returns Rejects: with an error response.\n     */\n    public getFilter(userId: string, filterId: string, allowCached: boolean): Promise<Filter> {\n        if (allowCached) {\n            const filter = this.store.getFilter(userId, filterId);\n            if (filter) {\n                return Promise.resolve(filter);\n            }\n        }\n\n        const path = utils.encodeUri(\"/user/$userId/filter/$filterId\", {\n            $userId: userId,\n            $filterId: filterId,\n        });\n\n        return this.http.authedRequest<IFilterDefinition>(Method.Get, path).then((response) => {\n            // persist the filter\n            const filter = Filter.fromJson(userId, filterId, response);\n            this.store.storeFilter(filter);\n            return filter;\n        });\n    }\n\n    /**\n     * @returns Filter ID\n     */\n    public async getOrCreateFilter(filterName: string, filter: Filter): Promise<string> {\n        const filterId = this.store.getFilterIdByName(filterName);\n        let existingId: string | undefined;\n\n        if (filterId) {\n            // check that the existing filter matches our expectations\n            try {\n                const existingFilter = await this.getFilter(this.credentials.userId!, filterId, true);\n                if (existingFilter) {\n                    const oldDef = existingFilter.getDefinition();\n                    const newDef = filter.getDefinition();\n\n                    if (utils.deepCompare(oldDef, newDef)) {\n                        // super, just use that.\n                        // debuglog(\"Using existing filter ID %s: %s\", filterId,\n                        //          JSON.stringify(oldDef));\n                        existingId = filterId;\n                    }\n                }\n            } catch (error) {\n                // Synapse currently returns the following when the filter cannot be found:\n                // {\n                //     errcode: \"M_UNKNOWN\",\n                //     name: \"M_UNKNOWN\",\n                //     message: \"No row found\",\n                // }\n                if ((<MatrixError>error).errcode !== \"M_UNKNOWN\" && (<MatrixError>error).errcode !== \"M_NOT_FOUND\") {\n                    throw error;\n                }\n            }\n            // if the filter doesn't exist anymore on the server, remove from store\n            if (!existingId) {\n                this.store.setFilterIdByName(filterName, undefined);\n            }\n        }\n\n        if (existingId) {\n            return existingId;\n        }\n\n        // create a new filter\n        const createdFilter = await this.createFilter(filter.getDefinition());\n\n        this.store.setFilterIdByName(filterName, createdFilter.filterId);\n        return createdFilter.filterId!;\n    }\n\n    /**\n     * Gets a bearer token from the homeserver that the user can\n     * present to a third party in order to prove their ownership\n     * of the Matrix account they are logged into.\n     * @returns Promise which resolves: Token object\n     * @returns Rejects: with an error response.\n     */\n    public getOpenIdToken(): Promise<IOpenIDToken> {\n        const path = utils.encodeUri(\"/user/$userId/openid/request_token\", {\n            $userId: this.credentials.userId!,\n        });\n\n        return this.http.authedRequest(Method.Post, path, undefined, {});\n    }\n\n    private startCallEventHandler = (): void => {\n        if (this.isInitialSyncComplete()) {\n            if (supportsMatrixCall()) {\n                this.callEventHandler!.start();\n                this.groupCallEventHandler!.start();\n            }\n\n            this.off(ClientEvent.Sync, this.startCallEventHandler);\n        }\n    };\n\n    private startMatrixRTC = (): void => {\n        if (this.isInitialSyncComplete()) {\n            this.matrixRTC.start();\n\n            this.off(ClientEvent.Sync, this.startMatrixRTC);\n        }\n    };\n\n    /**\n     * Once the client has been initialised, we want to clear notifications we\n     * know for a fact should be here.\n     * This issue should also be addressed on synapse's side and is tracked as part\n     * of https://github.com/matrix-org/synapse/issues/14837\n     *\n     * We consider a room or a thread as fully read if the current user has sent\n     * the last event in the live timeline of that context and if the read receipt\n     * we have on record matches.\n     */\n    private fixupRoomNotifications = (): void => {\n        if (this.isInitialSyncComplete()) {\n            const unreadRooms = (this.getRooms() ?? []).filter((room) => {\n                return room.getUnreadNotificationCount(NotificationCountType.Total) > 0;\n            });\n\n            for (const room of unreadRooms) {\n                const currentUserId = this.getSafeUserId();\n                room.fixupNotifications(currentUserId);\n            }\n\n            this.off(ClientEvent.Sync, this.fixupRoomNotifications);\n        }\n    };\n\n    /**\n     * @returns Promise which resolves: ITurnServerResponse object\n     * @returns Rejects: with an error response.\n     */\n    public turnServer(): Promise<ITurnServerResponse> {\n        return this.http.authedRequest(Method.Get, \"/voip/turnServer\");\n    }\n\n    /**\n     * Get the TURN servers for this homeserver.\n     * @returns The servers or an empty list.\n     */\n    public getTurnServers(): ITurnServer[] {\n        return this.turnServers || [];\n    }\n\n    /**\n     * Get the unix timestamp (in milliseconds) at which the current\n     * TURN credentials (from getTurnServers) expire\n     * @returns The expiry timestamp in milliseconds\n     */\n    public getTurnServersExpiry(): number {\n        return this.turnServersExpiry;\n    }\n\n    public get pollingTurnServers(): boolean {\n        return this.checkTurnServersIntervalID !== undefined;\n    }\n\n    // XXX: Intended private, used in code.\n    public async checkTurnServers(): Promise<boolean | undefined> {\n        if (!this.canSupportVoip) {\n            return;\n        }\n\n        let credentialsGood = false;\n        const remainingTime = this.turnServersExpiry - Date.now();\n        if (remainingTime > TURN_CHECK_INTERVAL) {\n            this.logger.debug(\"TURN creds are valid for another \" + remainingTime + \" ms: not fetching new ones.\");\n            credentialsGood = true;\n        } else {\n            this.logger.debug(\"Fetching new TURN credentials\");\n            try {\n                const res = await this.turnServer();\n                if (res.uris) {\n                    this.logger.debug(\"Got TURN URIs: \" + res.uris + \" refresh in \" + res.ttl + \" secs\");\n                    // map the response to a format that can be fed to RTCPeerConnection\n                    const servers: ITurnServer = {\n                        urls: res.uris,\n                        username: res.username,\n                        credential: res.password,\n                    };\n                    this.turnServers = [servers];\n                    // The TTL is in seconds but we work in ms\n                    this.turnServersExpiry = Date.now() + res.ttl * 1000;\n                    credentialsGood = true;\n                    this.emit(ClientEvent.TurnServers, this.turnServers);\n                }\n            } catch (err) {\n                this.logger.error(\"Failed to get TURN URIs\", err);\n                if ((<HTTPError>err).httpStatus === 403) {\n                    // We got a 403, so there's no point in looping forever.\n                    this.logger.info(\"TURN access unavailable for this account: stopping credentials checks\");\n                    if (this.checkTurnServersIntervalID !== null) {\n                        globalThis.clearInterval(this.checkTurnServersIntervalID);\n                    }\n                    this.checkTurnServersIntervalID = undefined;\n                    this.emit(ClientEvent.TurnServersError, <HTTPError>err, true); // fatal\n                } else {\n                    // otherwise, if we failed for whatever reason, try again the next time we're called.\n                    this.emit(ClientEvent.TurnServersError, <Error>err, false); // non-fatal\n                }\n            }\n        }\n\n        return credentialsGood;\n    }\n\n    /**\n     * Set whether to allow a fallback ICE server should be used for negotiating a\n     * WebRTC connection if the homeserver doesn't provide any servers. Defaults to\n     * false.\n     *\n     */\n    public setFallbackICEServerAllowed(allow: boolean): void {\n        this.fallbackICEServerAllowed = allow;\n    }\n\n    /**\n     * Get whether to allow a fallback ICE server should be used for negotiating a\n     * WebRTC connection if the homeserver doesn't provide any servers. Defaults to\n     * false.\n     *\n     * @returns\n     */\n    public isFallbackICEServerAllowed(): boolean {\n        return this.fallbackICEServerAllowed;\n    }\n\n    /**\n     * Determines if the current user is an administrator of the Synapse homeserver.\n     * Returns false if untrue or the homeserver does not appear to be a Synapse\n     * homeserver. <strong>This function is implementation specific and may change\n     * as a result.</strong>\n     * @returns true if the user appears to be a Synapse administrator.\n     */\n    public isSynapseAdministrator(): Promise<boolean> {\n        const path = utils.encodeUri(\"/_synapse/admin/v1/users/$userId/admin\", { $userId: this.getUserId()! });\n        return this.http\n            .authedRequest<{ admin: boolean }>(Method.Get, path, undefined, undefined, { prefix: \"\" })\n            .then((r) => r.admin); // pull out the specific boolean we want\n    }\n\n    /**\n     * Performs a whois lookup on a user using Synapse's administrator API.\n     * <strong>This function is implementation specific and may change as a\n     * result.</strong>\n     * @param userId - the User ID to look up.\n     * @returns the whois response - see Synapse docs for information.\n     */\n    public whoisSynapseUser(userId: string): Promise<ISynapseAdminWhoisResponse> {\n        const path = utils.encodeUri(\"/_synapse/admin/v1/whois/$userId\", { $userId: userId });\n        return this.http.authedRequest(Method.Get, path, undefined, undefined, { prefix: \"\" });\n    }\n\n    /**\n     * Deactivates a user using Synapse's administrator API. <strong>This\n     * function is implementation specific and may change as a result.</strong>\n     * @param userId - the User ID to deactivate.\n     * @returns the deactivate response - see Synapse docs for information.\n     */\n    public deactivateSynapseUser(userId: string): Promise<ISynapseAdminDeactivateResponse> {\n        const path = utils.encodeUri(\"/_synapse/admin/v1/deactivate/$userId\", { $userId: userId });\n        return this.http.authedRequest(Method.Post, path, undefined, undefined, { prefix: \"\" });\n    }\n\n    protected async fetchClientWellKnown(): Promise<void> {\n        // `getRawClientConfig` does not throw or reject on network errors, instead\n        // it absorbs errors and returns `{}`.\n        this.clientWellKnownPromise = AutoDiscovery.getRawClientConfig(this.getDomain() ?? undefined);\n        this.clientWellKnown = await this.clientWellKnownPromise;\n        this.emit(ClientEvent.ClientWellKnown, this.clientWellKnown);\n    }\n\n    public getClientWellKnown(): IClientWellKnown | undefined {\n        return this.clientWellKnown;\n    }\n\n    public waitForClientWellKnown(): Promise<IClientWellKnown> {\n        if (!this.clientRunning) {\n            throw new Error(\"Client is not running\");\n        }\n        return this.clientWellKnownPromise!;\n    }\n\n    /**\n     * store client options with boolean/string/numeric values\n     * to know in the next session what flags the sync data was\n     * created with (e.g. lazy loading)\n     * @returns for store operation\n     */\n    public storeClientOptions(): Promise<void> {\n        // XXX: Intended private, used in code\n        const primTypes = [\"boolean\", \"string\", \"number\"];\n        const serializableOpts = Object.entries(this.clientOpts!)\n            .filter(([key, value]) => {\n                return primTypes.includes(typeof value);\n            })\n            .reduce<Record<string, any>>((obj, [key, value]) => {\n                obj[key] = value;\n                return obj;\n            }, {});\n        return this.store.storeClientOptions(serializableOpts);\n    }\n\n    /**\n     * Gets a set of room IDs in common with another user.\n     *\n     * Note: This endpoint is unstable, and can throw an `Error`.\n     *   Check progress on [MSC2666](https://github.com/matrix-org/matrix-spec-proposals/pull/2666) for more details.\n     *\n     * @param userId - The userId to check.\n     * @returns Promise which resolves to an array of rooms\n     * @returns Rejects: with an error response.\n     */\n    // TODO: on spec release, rename this to getMutualRooms\n    // eslint-disable-next-line\n    public async _unstable_getSharedRooms(userId: string): Promise<string[]> {\n        // Initial variant of the MSC\n        const sharedRoomsSupport = await this.doesServerSupportUnstableFeature(UNSTABLE_MSC2666_SHARED_ROOMS);\n\n        // Newer variant that renamed shared rooms to mutual rooms\n        const mutualRoomsSupport = await this.doesServerSupportUnstableFeature(UNSTABLE_MSC2666_MUTUAL_ROOMS);\n\n        // Latest variant that changed from path elements to query elements\n        const queryMutualRoomsSupport = await this.doesServerSupportUnstableFeature(\n            UNSTABLE_MSC2666_QUERY_MUTUAL_ROOMS,\n        );\n\n        if (!sharedRoomsSupport && !mutualRoomsSupport && !queryMutualRoomsSupport) {\n            throw Error(\"Server does not support the Mutual Rooms API\");\n        }\n\n        let path;\n        let query;\n\n        // Cascading unstable support switching.\n        if (queryMutualRoomsSupport) {\n            path = \"/uk.half-shot.msc2666/user/mutual_rooms\";\n            query = { user_id: userId };\n        } else {\n            path = utils.encodeUri(\n                `/uk.half-shot.msc2666/user/${mutualRoomsSupport ? \"mutual_rooms\" : \"shared_rooms\"}/$userId`,\n                { $userId: userId },\n            );\n            query = {};\n        }\n\n        // Accumulated rooms\n        const rooms: string[] = [];\n        let token = null;\n\n        do {\n            const tokenQuery: Record<string, string> = {};\n            if (token != null && queryMutualRoomsSupport) {\n                tokenQuery[\"batch_token\"] = token;\n            }\n\n            const res = await this.http.authedRequest<{\n                joined: string[];\n                next_batch_token?: string;\n            }>(Method.Get, path, { ...query, ...tokenQuery }, undefined, {\n                prefix: ClientPrefix.Unstable,\n            });\n\n            rooms.push(...res.joined);\n\n            if (res.next_batch_token !== undefined) {\n                token = res.next_batch_token;\n            } else {\n                token = null;\n            }\n        } while (token != null);\n\n        return rooms;\n    }\n\n    /**\n     * Get the API versions supported by the server, along with any\n     * unstable APIs it supports\n     * @returns The server /versions response\n     */\n    public async getVersions(): Promise<IServerVersions> {\n        if (this.serverVersionsPromise) {\n            return this.serverVersionsPromise;\n        }\n\n        // We send an authenticated request as of MSC4026\n        this.serverVersionsPromise = this.http\n            .authedRequest<IServerVersions>(Method.Get, \"/_matrix/client/versions\", undefined, undefined, {\n                prefix: \"\",\n            })\n            .catch((e) => {\n                // Need to unset this if it fails, otherwise we'll never retry\n                this.serverVersionsPromise = undefined;\n                // but rethrow the exception to anything that was waiting\n                throw e;\n            });\n\n        const serverVersions = await this.serverVersionsPromise;\n        this.canSupport = await buildFeatureSupportMap(serverVersions);\n\n        return this.serverVersionsPromise;\n    }\n\n    /**\n     * Check if a particular spec version is supported by the server.\n     * @param version - The spec version (such as \"r0.5.0\") to check for.\n     * @returns Whether it is supported\n     */\n    public async isVersionSupported(version: string): Promise<boolean> {\n        const { versions } = await this.getVersions();\n        return versions && versions.includes(version);\n    }\n\n    /**\n     * Query the server to see if it lists support for an unstable feature\n     * in the /versions response\n     * @param feature - the feature name\n     * @returns true if the feature is supported\n     */\n    public async doesServerSupportUnstableFeature(feature: string): Promise<boolean> {\n        const response = await this.getVersions();\n        if (!response) return false;\n        const unstableFeatures = response[\"unstable_features\"];\n        return unstableFeatures && !!unstableFeatures[feature];\n    }\n\n    /**\n     * Query the server to see if it is forcing encryption to be enabled for\n     * a given room preset, based on the /versions response.\n     * @param presetName - The name of the preset to check.\n     * @returns true if the server is forcing encryption\n     * for the preset.\n     */\n    public async doesServerForceEncryptionForPreset(presetName: Preset): Promise<boolean> {\n        const response = await this.getVersions();\n        if (!response) return false;\n        const unstableFeatures = response[\"unstable_features\"];\n\n        // The preset name in the versions response will be without the _chat suffix.\n        const versionsPresetName = presetName.includes(\"_chat\")\n            ? presetName.substring(0, presetName.indexOf(\"_chat\"))\n            : presetName;\n\n        return unstableFeatures && !!unstableFeatures[`io.element.e2ee_forced.${versionsPresetName}`];\n    }\n\n    public async doesServerSupportThread(): Promise<{\n        threads: FeatureSupport;\n        list: FeatureSupport;\n        fwdPagination: FeatureSupport;\n    }> {\n        if (await this.isVersionSupported(\"v1.4\")) {\n            return {\n                threads: FeatureSupport.Stable,\n                list: FeatureSupport.Stable,\n                fwdPagination: FeatureSupport.Stable,\n            };\n        }\n\n        try {\n            const [threadUnstable, threadStable, listUnstable, listStable, fwdPaginationUnstable, fwdPaginationStable] =\n                await Promise.all([\n                    this.doesServerSupportUnstableFeature(\"org.matrix.msc3440\"),\n                    this.doesServerSupportUnstableFeature(\"org.matrix.msc3440.stable\"),\n                    this.doesServerSupportUnstableFeature(\"org.matrix.msc3856\"),\n                    this.doesServerSupportUnstableFeature(\"org.matrix.msc3856.stable\"),\n                    this.doesServerSupportUnstableFeature(\"org.matrix.msc3715\"),\n                    this.doesServerSupportUnstableFeature(\"org.matrix.msc3715.stable\"),\n                ]);\n\n            return {\n                threads: determineFeatureSupport(threadStable, threadUnstable),\n                list: determineFeatureSupport(listStable, listUnstable),\n                fwdPagination: determineFeatureSupport(fwdPaginationStable, fwdPaginationUnstable),\n            };\n        } catch {\n            return {\n                threads: FeatureSupport.None,\n                list: FeatureSupport.None,\n                fwdPagination: FeatureSupport.None,\n            };\n        }\n    }\n\n    /**\n     * Get if lazy loading members is being used.\n     * @returns Whether or not members are lazy loaded by this client\n     */\n    public hasLazyLoadMembersEnabled(): boolean {\n        return !!this.clientOpts?.lazyLoadMembers;\n    }\n\n    /**\n     * Set a function which is called when /sync returns a 'limited' response.\n     * It is called with a room ID and returns a boolean. It should return 'true' if the SDK\n     * can SAFELY remove events from this room. It may not be safe to remove events if there\n     * are other references to the timelines for this room, e.g because the client is\n     * actively viewing events in this room.\n     * Default: returns false.\n     * @param cb - The callback which will be invoked.\n     */\n    public setCanResetTimelineCallback(cb: ResetTimelineCallback): void {\n        this.canResetTimelineCallback = cb;\n    }\n\n    /**\n     * Get the callback set via `setCanResetTimelineCallback`.\n     * @returns The callback or null\n     */\n    public getCanResetTimelineCallback(): ResetTimelineCallback | undefined {\n        return this.canResetTimelineCallback;\n    }\n\n    /**\n     * Returns relations for a given event. Handles encryption transparently,\n     * with the caveat that the amount of events returned might be 0, even though you get a nextBatch.\n     * When the returned promise resolves, all messages should have finished trying to decrypt.\n     * @param roomId - the room of the event\n     * @param eventId - the id of the event\n     * @param relationType - the rel_type of the relations requested\n     * @param eventType - the event type of the relations requested\n     * @param opts - options with optional values for the request.\n     * @returns an object with `events` as `MatrixEvent[]` and optionally `nextBatch` if more relations are available.\n     */\n    public async relations(\n        roomId: string,\n        eventId: string,\n        relationType: RelationType | string | null,\n        eventType?: EventType | string | null,\n        opts: IRelationsRequestOpts = { dir: Direction.Backward },\n    ): Promise<{\n        originalEvent?: MatrixEvent | null;\n        events: MatrixEvent[];\n        nextBatch?: string | null;\n        prevBatch?: string | null;\n    }> {\n        const fetchedEventType = eventType ? this.getEncryptedIfNeededEventType(roomId, eventType) : null;\n        const [eventResult, result] = await Promise.all([\n            this.fetchRoomEvent(roomId, eventId),\n            this.fetchRelations(roomId, eventId, relationType, fetchedEventType, opts),\n        ]);\n        const mapper = this.getEventMapper();\n\n        const originalEvent = eventResult ? mapper(eventResult) : undefined;\n        let events = result.chunk.map(mapper);\n\n        if (fetchedEventType === EventType.RoomMessageEncrypted) {\n            const allEvents = originalEvent ? events.concat(originalEvent) : events;\n            await Promise.all(allEvents.map((e) => this.decryptEventIfNeeded(e)));\n            if (eventType !== null) {\n                events = events.filter((e) => e.getType() === eventType);\n            }\n        }\n\n        if (originalEvent && relationType === RelationType.Replace) {\n            events = events.filter((e) => e.getSender() === originalEvent.getSender());\n        }\n        return {\n            originalEvent: originalEvent ?? null,\n            events,\n            nextBatch: result.next_batch ?? null,\n            prevBatch: result.prev_batch ?? null,\n        };\n    }\n\n    /**\n     * Generates a random string suitable for use as a client secret. <strong>This\n     * method is experimental and may change.</strong>\n     * @returns A new client secret\n     */\n    public generateClientSecret(): string {\n        return secureRandomString(32);\n    }\n\n    /**\n     * Attempts to decrypt an event\n     * @param event - The event to decrypt\n     * @returns A decryption promise\n     */\n    public decryptEventIfNeeded(event: MatrixEvent, options?: IDecryptOptions): Promise<void> {\n        if (event.shouldAttemptDecryption() && this.getCrypto()) {\n            event.attemptDecryption(this.cryptoBackend!, options);\n        }\n\n        if (event.isBeingDecrypted()) {\n            return event.getDecryptionPromise()!;\n        } else {\n            return Promise.resolve();\n        }\n    }\n\n    private termsUrlForService(serviceType: SERVICE_TYPES, baseUrl: string): URL {\n        switch (serviceType) {\n            case SERVICE_TYPES.IS:\n                return this.http.getUrl(\"/terms\", undefined, IdentityPrefix.V2, baseUrl);\n            case SERVICE_TYPES.IM:\n                return this.http.getUrl(\"/terms\", undefined, \"/_matrix/integrations/v1\", baseUrl);\n            default:\n                throw new Error(\"Unsupported service type\");\n        }\n    }\n\n    /**\n     * Get the Homeserver URL of this client\n     * @returns Homeserver URL of this client\n     */\n    public getHomeserverUrl(): string {\n        return this.baseUrl;\n    }\n\n    /**\n     * Get the identity server URL of this client\n     * @param stripProto - whether or not to strip the protocol from the URL\n     * @returns Identity server URL of this client\n     */\n    public getIdentityServerUrl(stripProto = false): string | undefined {\n        if (stripProto && (this.idBaseUrl?.startsWith(\"http://\") || this.idBaseUrl?.startsWith(\"https://\"))) {\n            return this.idBaseUrl.split(\"://\")[1];\n        }\n        return this.idBaseUrl;\n    }\n\n    /**\n     * Set the identity server URL of this client\n     * @param url - New identity server URL\n     */\n    public setIdentityServerUrl(url?: string): void {\n        this.idBaseUrl = utils.ensureNoTrailingSlash(url);\n        this.http.setIdBaseUrl(this.idBaseUrl);\n    }\n\n    /**\n     * Get the access token associated with this account.\n     * @returns The access_token or null\n     */\n    public getAccessToken(): string | null {\n        return this.http.opts.accessToken || null;\n    }\n\n    /**\n     * Get the refresh token associated with this account.\n     * @returns The refresh_token or null\n     */\n    public getRefreshToken(): string | null {\n        return this.http.opts.refreshToken ?? null;\n    }\n\n    /**\n     * Set the access token associated with this account.\n     * @param token - The new access token.\n     */\n    public setAccessToken(token: string): void {\n        this.http.opts.accessToken = token;\n        // The /versions response can vary for different users so clear the cache\n        this.serverVersionsPromise = undefined;\n    }\n\n    /**\n     * @returns true if there is a valid access_token for this client.\n     */\n    public isLoggedIn(): boolean {\n        return this.http.opts.accessToken !== undefined;\n    }\n\n    /**\n     * Make up a new transaction id\n     *\n     * @returns a new, unique, transaction id\n     */\n    public makeTxnId(): string {\n        return \"m\" + new Date().getTime() + \".\" + this.txnCtr++;\n    }\n\n    /**\n     * Check whether a username is available prior to registration. An error response\n     * indicates an invalid/unavailable username.\n     * @param username - The username to check the availability of.\n     * @returns Promise which resolves: to boolean of whether the username is available.\n     */\n    public isUsernameAvailable(username: string): Promise<boolean> {\n        return this.http\n            .authedRequest<{ available: true }>(Method.Get, \"/register/available\", { username })\n            .then((response) => {\n                return response.available;\n            })\n            .catch((response) => {\n                if (response.errcode === \"M_USER_IN_USE\") {\n                    return false;\n                }\n                return Promise.reject(response);\n            });\n    }\n\n    /**\n     * @param bindThreepids - Set key 'email' to true to bind any email\n     *     threepid uses during registration in the identity server. Set 'msisdn' to\n     *     true to bind msisdn.\n     * @returns Promise which resolves to a RegisterResponse object\n     * @returns Rejects: with an error response.\n     */\n    public register(\n        username: string,\n        password: string,\n        sessionId: string | null,\n        auth: { session?: string; type: string },\n        bindThreepids?: { email?: boolean; msisdn?: boolean },\n        guestAccessToken?: string,\n        inhibitLogin?: boolean,\n    ): Promise<RegisterResponse> {\n        if (sessionId) {\n            auth.session = sessionId;\n        }\n\n        const params: RegisterRequest = {\n            auth: auth,\n            refresh_token: true, // always ask for a refresh token - does nothing if unsupported\n        };\n        if (username !== undefined && username !== null) {\n            params.username = username;\n        }\n        if (password !== undefined && password !== null) {\n            params.password = password;\n        }\n        if (guestAccessToken !== undefined && guestAccessToken !== null) {\n            params.guest_access_token = guestAccessToken;\n        }\n        if (inhibitLogin !== undefined && inhibitLogin !== null) {\n            params.inhibit_login = inhibitLogin;\n        }\n\n        return this.registerRequest(params);\n    }\n\n    /**\n     * Register a guest account.\n     * This method returns the auth info needed to create a new authenticated client,\n     * Remember to call `setGuest(true)` on the (guest-)authenticated client, e.g:\n     * ```javascript\n     * const tmpClient = await sdk.createClient(MATRIX_INSTANCE);\n     * const { user_id, device_id, access_token } = tmpClient.registerGuest();\n     * const client = createClient({\n     *   baseUrl: MATRIX_INSTANCE,\n     *   accessToken: access_token,\n     *   userId: user_id,\n     *   deviceId: device_id,\n     * })\n     * client.setGuest(true);\n     * ```\n     *\n     * @param body - JSON HTTP body to provide.\n     * @returns Promise which resolves: JSON object that contains:\n     *                   `{ user_id, device_id, access_token, home_server }`\n     * @returns Rejects: with an error response.\n     */\n    public registerGuest({ body }: { body?: RegisterRequest } = {}): Promise<RegisterResponse> {\n        return this.registerRequest(body || {}, \"guest\");\n    }\n\n    /**\n     * @param data - parameters for registration request\n     * @param kind - type of user to register. may be \"guest\"\n     * @returns Promise which resolves: to the /register response\n     * @returns Rejects: with an error response.\n     */\n    public registerRequest(data: RegisterRequest, kind?: string): Promise<RegisterResponse> {\n        const params: { kind?: string } = {};\n        if (kind) {\n            params.kind = kind;\n        }\n\n        return this.http.request(Method.Post, \"/register\", params, data);\n    }\n\n    /**\n     * Refreshes an access token using a provided refresh token. The refresh token\n     * must be valid for the current access token known to the client instance.\n     *\n     * Note that this function will not cause a logout if the token is deemed\n     * unknown by the server - the caller is responsible for managing logout\n     * actions on error.\n     * @param refreshToken - The refresh token.\n     * @returns Promise which resolves to the new token.\n     * @returns Rejects with an error response.\n     */\n    public refreshToken(refreshToken: string): Promise<IRefreshTokenResponse> {\n        const performRefreshRequestWithPrefix = (prefix: ClientPrefix): Promise<IRefreshTokenResponse> =>\n            this.http.authedRequest(\n                Method.Post,\n                \"/refresh\",\n                undefined,\n                { refresh_token: refreshToken },\n                {\n                    prefix,\n                    inhibitLogoutEmit: true, // we don't want to cause logout loops\n                },\n            );\n\n        // First try with the (specced) /v3/ prefix.\n        // However, before Synapse 1.72.0, Synapse incorrectly required a /v1/ prefix, so we fall\n        // back to that if the request fails, for backwards compatibility.\n        return performRefreshRequestWithPrefix(ClientPrefix.V3).catch((e) => {\n            if (e.errcode === \"M_UNRECOGNIZED\") {\n                return performRefreshRequestWithPrefix(ClientPrefix.V1);\n            }\n            throw e;\n        });\n    }\n\n    /**\n     * @returns Promise which resolves to the available login flows\n     * @returns Rejects: with an error response.\n     */\n    public loginFlows(): Promise<ILoginFlowsResponse> {\n        return this.http.request(Method.Get, \"/login\");\n    }\n\n    /**\n     * @returns Promise which resolves to a LoginResponse object\n     * @returns Rejects: with an error response.\n     *\n     * @deprecated This method has unintuitive behaviour: it updates the `MatrixClient` instance with *some* of the\n     *    returned credentials. Instead, call {@link loginRequest} and create a new `MatrixClient` instance using the\n     *    results. See https://github.com/matrix-org/matrix-js-sdk/issues/4502.\n     */\n    public login(loginType: LoginRequest[\"type\"], data: Omit<LoginRequest, \"type\">): Promise<LoginResponse> {\n        return this.loginRequest({\n            ...data,\n            type: loginType,\n        }).then((response) => {\n            if (response.access_token && response.user_id) {\n                this.http.opts.accessToken = response.access_token;\n                this.credentials = {\n                    userId: response.user_id,\n                };\n            }\n            return response;\n        });\n    }\n\n    /**\n     * @returns Promise which resolves to a LoginResponse object\n     * @returns Rejects: with an error response.\n     *\n     * @deprecated This method has unintuitive behaviour: it updates the `MatrixClient` instance with *some* of the\n     *   returned credentials. Instead, call {@link loginRequest} with `data.type: \"m.login.password\"`, and create a new\n     *   `MatrixClient` instance using the results. See https://github.com/matrix-org/matrix-js-sdk/issues/4502.\n     */\n    public loginWithPassword(user: string, password: string): Promise<LoginResponse> {\n        return this.login(\"m.login.password\", {\n            user: user,\n            password: password,\n        });\n    }\n\n    /**\n     * @param redirectUrl - The URL to redirect to after the HS\n     * authenticates with CAS.\n     * @returns The HS URL to hit to begin the CAS login process.\n     */\n    public getCasLoginUrl(redirectUrl: string): string {\n        return this.getSsoLoginUrl(redirectUrl, \"cas\");\n    }\n\n    /**\n     * @param redirectUrl - The URL to redirect to after the HS\n     *     authenticates with the SSO.\n     * @param loginType - The type of SSO login we are doing (sso or cas).\n     *     Defaults to 'sso'.\n     * @param idpId - The ID of the Identity Provider being targeted, optional.\n     * @param action - the SSO flow to indicate to the IdP, optional.\n     * @returns The HS URL to hit to begin the SSO login process.\n     */\n    public getSsoLoginUrl(redirectUrl: string, loginType = \"sso\", idpId?: string, action?: SSOAction): string {\n        let url = \"/login/\" + loginType + \"/redirect\";\n        if (idpId) {\n            url += \"/\" + idpId;\n        }\n\n        const params = {\n            redirectUrl,\n            [SSO_ACTION_PARAM.unstable!]: action,\n        };\n\n        return this.http.getUrl(url, params).href;\n    }\n\n    /**\n     * @param token - Login token previously received from homeserver\n     * @returns Promise which resolves to a LoginResponse object\n     * @returns Rejects: with an error response.\n     *\n     * @deprecated This method has unintuitive behaviour: it updates the `MatrixClient` instance with *some* of the\n     *   returned credentials. Instead, call {@link loginRequest} with `data.type: \"m.login.token\"`, and create a new\n     *   `MatrixClient` instance using the results. See https://github.com/matrix-org/matrix-js-sdk/issues/4502.\n     */\n    public loginWithToken(token: string): Promise<LoginResponse> {\n        return this.login(\"m.login.token\", {\n            token: token,\n        });\n    }\n\n    /**\n     * Sends a `POST /login` request to the server.\n     *\n     * If successful, this will create a new device and access token for the user.\n     *\n     * @see {@link MatrixClient.loginFlows} which makes a `GET /login` request.\n     * @see https://spec.matrix.org/v1.13/client-server-api/#post_matrixclientv3login\n     *\n     * @param data - Credentials and other details for the login request.\n     */\n    public async loginRequest(data: LoginRequest): Promise<LoginResponse> {\n        return await this.http.authedRequest<LoginResponse>(Method.Post, \"/login\", undefined, data);\n    }\n\n    /**\n     * Logs out the current session.\n     * Obviously, further calls that require authorisation should fail after this\n     * method is called. The state of the MatrixClient object is not affected:\n     * it is up to the caller to either reset or destroy the MatrixClient after\n     * this method succeeds.\n     * @param stopClient - whether to stop the client before calling /logout to prevent invalid token errors.\n     * @returns Promise which resolves: On success, the empty object `{}`\n     */\n    public async logout(stopClient = false): Promise<EmptyObject> {\n        if (stopClient) {\n            this.stopClient();\n            this.http.abort();\n        }\n\n        return this.http.authedRequest(Method.Post, \"/logout\");\n    }\n\n    /**\n     * Deactivates the logged-in account.\n     * Obviously, further calls that require authorisation should fail after this\n     * method is called. The state of the MatrixClient object is not affected:\n     * it is up to the caller to either reset or destroy the MatrixClient after\n     * this method succeeds.\n     * @param auth - Optional. Auth data to supply for User-Interactive auth.\n     * @param erase - Optional. If set, send as `erase` attribute in the\n     * JSON request body, indicating whether the account should be erased. Defaults\n     * to false.\n     * @returns Promise which resolves: On success, the empty object\n     */\n    public deactivateAccount(\n        auth?: AuthDict,\n        erase?: boolean,\n    ): Promise<{ id_server_unbind_result: IdServerUnbindResult }> {\n        const body: Body = {};\n        if (auth) {\n            body.auth = auth;\n        }\n        if (erase !== undefined) {\n            body.erase = erase;\n        }\n\n        return this.http.authedRequest(Method.Post, \"/account/deactivate\", undefined, body);\n    }\n\n    /**\n     * Make a request for an `m.login.token` to be issued as per\n     * https://spec.matrix.org/v1.7/client-server-api/#post_matrixclientv1loginget_token\n     *\n     * The server may require User-Interactive auth.\n     *\n     * @param auth - Optional. Auth data to supply for User-Interactive auth.\n     * @returns Promise which resolves: On success, the token response\n     * or UIA auth data.\n     */\n    public async requestLoginToken(auth?: AuthDict): Promise<LoginTokenPostResponse> {\n        const body: UIARequest<unknown> = { auth };\n        return this.http.authedRequest<LoginTokenPostResponse>(\n            Method.Post,\n            \"/login/get_token\",\n            undefined, // no query params\n            body,\n            { prefix: ClientPrefix.V1 },\n        );\n    }\n\n    /**\n     * Get the fallback URL to use for unknown interactive-auth stages.\n     *\n     * @param loginType -     the type of stage being attempted\n     * @param authSessionId - the auth session ID provided by the homeserver\n     *\n     * @returns HS URL to hit to for the fallback interface\n     */\n    public getFallbackAuthUrl(loginType: string, authSessionId: string): string {\n        const path = utils.encodeUri(\"/auth/$loginType/fallback/web\", {\n            $loginType: loginType,\n        });\n\n        return this.http.getUrl(path, {\n            session: authSessionId,\n        }).href;\n    }\n\n    /**\n     * Create a new room.\n     * @param options - a list of options to pass to the /createRoom API.\n     * @returns Promise which resolves: `{room_id: {string}}`\n     * @returns Rejects: with an error response.\n     */\n    public async createRoom(options: ICreateRoomOpts): Promise<{ room_id: string }> {\n        // eslint-disable-line camelcase\n        // some valid options include: room_alias_name, visibility, invite\n\n        // inject the id_access_token if inviting 3rd party addresses\n        const invitesNeedingToken = (options.invite_3pid || []).filter((i) => !i.id_access_token);\n        if (invitesNeedingToken.length > 0 && this.identityServer?.getAccessToken) {\n            const identityAccessToken = await this.identityServer.getAccessToken();\n            if (identityAccessToken) {\n                for (const invite of invitesNeedingToken) {\n                    invite.id_access_token = identityAccessToken;\n                }\n            }\n        }\n\n        return this.http.authedRequest(Method.Post, \"/createRoom\", undefined, options);\n    }\n\n    /**\n     * Fetches relations for a given event\n     * @param roomId - the room of the event\n     * @param eventId - the id of the event\n     * @param relationType - the rel_type of the relations requested\n     * @param eventType - the event type of the relations requested\n     * @param opts - options with optional values for the request.\n     * @returns the response, with chunk, prev_batch and, next_batch.\n     */\n    public fetchRelations(\n        roomId: string,\n        eventId: string,\n        relationType: RelationType | string | null,\n        eventType?: EventType | string | null,\n        opts: IRelationsRequestOpts = { dir: Direction.Backward },\n    ): Promise<IRelationsResponse> {\n        let params = opts as QueryDict;\n        if (Thread.hasServerSideFwdPaginationSupport === FeatureSupport.Experimental) {\n            params = replaceParam(\"dir\", \"org.matrix.msc3715.dir\", params);\n        }\n        if (this.canSupport.get(Feature.RelationsRecursion) === ServerSupport.Unstable) {\n            params = replaceParam(\"recurse\", \"org.matrix.msc3981.recurse\", params);\n        }\n        const queryString = utils.encodeParams(params);\n\n        let templatedUrl = \"/rooms/$roomId/relations/$eventId\";\n        if (relationType !== null) {\n            templatedUrl += \"/$relationType\";\n            if (eventType !== null) {\n                templatedUrl += \"/$eventType\";\n            }\n        } else if (eventType !== null) {\n            this.logger.warn(`eventType: ${eventType} ignored when fetching\n            relations as relationType is null`);\n            eventType = null;\n        }\n\n        const path = utils.encodeUri(templatedUrl + \"?\" + queryString, {\n            $roomId: roomId,\n            $eventId: eventId,\n            $relationType: relationType!,\n            $eventType: eventType!,\n        });\n        return this.http.authedRequest(Method.Get, path, undefined, undefined, {\n            prefix: ClientPrefix.V1,\n        });\n    }\n\n    /**\n     * @returns Promise which resolves: TODO\n     * @returns Rejects: with an error response.\n     */\n    public roomState(roomId: string): Promise<IStateEventWithRoomId[]> {\n        const path = utils.encodeUri(\"/rooms/$roomId/state\", { $roomId: roomId });\n        return this.http.authedRequest(Method.Get, path);\n    }\n\n    /**\n     * Get an event in a room by its event id.\n     *\n     * @returns Promise which resolves to an object containing the event.\n     * @returns Rejects: with an error response.\n     */\n    public fetchRoomEvent(roomId: string, eventId: string): Promise<Partial<IEvent>> {\n        const path = utils.encodeUri(\"/rooms/$roomId/event/$eventId\", {\n            $roomId: roomId,\n            $eventId: eventId,\n        });\n        return this.http.authedRequest(Method.Get, path);\n    }\n\n    /**\n     * @param includeMembership - the membership type to include in the response\n     * @param excludeMembership - the membership type to exclude from the response\n     * @param atEventId - the id of the event for which moment in the timeline the members should be returned for\n     * @returns Promise which resolves: dictionary of userid to profile information\n     * @returns Rejects: with an error response.\n     */\n    public members(\n        roomId: string,\n        includeMembership?: string,\n        excludeMembership?: string,\n        atEventId?: string,\n    ): Promise<{ [userId: string]: IStateEventWithRoomId[] }> {\n        const queryParams: Record<string, string> = {};\n        if (includeMembership) {\n            queryParams.membership = includeMembership;\n        }\n        if (excludeMembership) {\n            queryParams.not_membership = excludeMembership;\n        }\n        if (atEventId) {\n            queryParams.at = atEventId;\n        }\n\n        const queryString = utils.encodeParams(queryParams);\n\n        const path = utils.encodeUri(\"/rooms/$roomId/members?\" + queryString, { $roomId: roomId });\n        return this.http.authedRequest(Method.Get, path);\n    }\n\n    /**\n     * Upgrades a room to a new protocol version\n     * @param newVersion - The target version to upgrade to\n     * @returns Promise which resolves: Object with key 'replacement_room'\n     * @returns Rejects: with an error response.\n     */\n    public upgradeRoom(roomId: string, newVersion: string): Promise<{ replacement_room: string }> {\n        // eslint-disable-line camelcase\n        const path = utils.encodeUri(\"/rooms/$roomId/upgrade\", { $roomId: roomId });\n        return this.http.authedRequest(Method.Post, path, undefined, { new_version: newVersion });\n    }\n\n    /**\n     * Retrieve a state event.\n     * @returns Promise which resolves: TODO\n     * @returns Rejects: with an error response.\n     */\n    public getStateEvent(roomId: string, eventType: string, stateKey: string): Promise<Record<string, any>> {\n        const pathParams = {\n            $roomId: roomId,\n            $eventType: eventType,\n            $stateKey: stateKey,\n        };\n        let path = utils.encodeUri(\"/rooms/$roomId/state/$eventType\", pathParams);\n        if (stateKey !== undefined) {\n            path = utils.encodeUri(path + \"/$stateKey\", pathParams);\n        }\n        return this.http.authedRequest(Method.Get, path);\n    }\n\n    /**\n     * Send a state event into a room\n     * @param roomId - ID of the room to send the event into\n     * @param eventType - type of the state event to send\n     * @param content - content of the event to send\n     * @param stateKey - the stateKey to send into the room\n     * @param opts - Options for the request function.\n     * @returns Promise which resolves: TODO\n     * @returns Rejects: with an error response.\n     */\n    public sendStateEvent<K extends keyof StateEvents>(\n        roomId: string,\n        eventType: K,\n        content: StateEvents[K],\n        stateKey = \"\",\n        opts: IRequestOpts = {},\n    ): Promise<ISendEventResponse> {\n        const pathParams = {\n            $roomId: roomId,\n            $eventType: eventType,\n            $stateKey: stateKey,\n        };\n        let path = utils.encodeUri(\"/rooms/$roomId/state/$eventType\", pathParams);\n        if (stateKey !== undefined) {\n            path = utils.encodeUri(path + \"/$stateKey\", pathParams);\n        }\n        return this.http.authedRequest(Method.Put, path, undefined, content as Body, opts);\n    }\n\n    /**\n     * @returns Promise which resolves: TODO\n     * @returns Rejects: with an error response.\n     */\n    public roomInitialSync(roomId: string, limit: number): Promise<IRoomInitialSyncResponse> {\n        const path = utils.encodeUri(\"/rooms/$roomId/initialSync\", { $roomId: roomId });\n\n        return this.http.authedRequest(Method.Get, path, { limit: limit?.toString() ?? \"30\" });\n    }\n\n    /**\n     * Set a marker to indicate the point in a room before which the user has read every\n     * event. This can be retrieved from room account data (the event type is `m.fully_read`)\n     * and displayed as a horizontal line in the timeline that is visually distinct to the\n     * position of the user's own read receipt.\n     * @param roomId - ID of the room that has been read\n     * @param rmEventId - ID of the event that has been read\n     * @param rrEventId - ID of the event tracked by the read receipt. This is here\n     * for convenience because the RR and the RM are commonly updated at the same time as\n     * each other. Optional.\n     * @param rpEventId - rpEvent the m.read.private read receipt event for when we\n     * don't want other users to see the read receipts. This is experimental. Optional.\n     * @returns Promise which resolves: the empty object, `{}`.\n     */\n    public async setRoomReadMarkersHttpRequest(\n        roomId: string,\n        rmEventId: string,\n        rrEventId?: string,\n        rpEventId?: string,\n    ): Promise<EmptyObject> {\n        const path = utils.encodeUri(\"/rooms/$roomId/read_markers\", {\n            $roomId: roomId,\n        });\n\n        const content: IContent = {\n            [ReceiptType.FullyRead]: rmEventId,\n            [ReceiptType.Read]: rrEventId,\n        };\n\n        if (\n            (await this.doesServerSupportUnstableFeature(\"org.matrix.msc2285.stable\")) ||\n            (await this.isVersionSupported(\"v1.4\"))\n        ) {\n            content[ReceiptType.ReadPrivate] = rpEventId;\n        }\n\n        return this.http.authedRequest(Method.Post, path, undefined, content);\n    }\n\n    /**\n     * @returns Promise which resolves: A list of the user's current rooms\n     * @returns Rejects: with an error response.\n     */\n    public getJoinedRooms(): Promise<IJoinedRoomsResponse> {\n        const path = utils.encodeUri(\"/joined_rooms\", {});\n        return this.http.authedRequest(Method.Get, path);\n    }\n\n    /**\n     * Retrieve membership info. for a room.\n     * @param roomId - ID of the room to get membership for\n     * @returns Promise which resolves: A list of currently joined users\n     *                                 and their profile data.\n     * @returns Rejects: with an error response.\n     */\n    public getJoinedRoomMembers(roomId: string): Promise<IJoinedMembersResponse> {\n        const path = utils.encodeUri(\"/rooms/$roomId/joined_members\", {\n            $roomId: roomId,\n        });\n        return this.http.authedRequest(Method.Get, path);\n    }\n\n    /**\n     * @param params - Options for this request\n     * @returns Promise which resolves: IPublicRoomsResponse\n     * @returns Rejects: with an error response.\n     */\n    public publicRooms({\n        server,\n        limit,\n        since,\n        ...options\n    }: IRoomDirectoryOptions = {}): Promise<IPublicRoomsResponse> {\n        if (Object.keys(options).length === 0) {\n            const queryParams: QueryDict = { server, limit, since };\n            return this.http.authedRequest(Method.Get, \"/publicRooms\", queryParams);\n        } else {\n            const queryParams: QueryDict = { server };\n            const body = {\n                limit,\n                since,\n                ...options,\n            };\n            return this.http.authedRequest(Method.Post, \"/publicRooms\", queryParams, body);\n        }\n    }\n\n    /**\n     * Create an alias to room ID mapping.\n     * @param alias - The room alias to create.\n     * @param roomId - The room ID to link the alias to.\n     * @returns Promise which resolves: an empty object `{}`\n     * @returns Rejects: with an error response.\n     */\n    public createAlias(alias: string, roomId: string): Promise<EmptyObject> {\n        const path = utils.encodeUri(\"/directory/room/$alias\", {\n            $alias: alias,\n        });\n        const data = {\n            room_id: roomId,\n        };\n        return this.http.authedRequest(Method.Put, path, undefined, data);\n    }\n\n    /**\n     * Delete an alias to room ID mapping. This alias must be on your local server,\n     * and you must have sufficient access to do this operation.\n     * @param alias - The room alias to delete.\n     * @returns Promise which resolves: an empty object `{}`.\n     * @returns Rejects: with an error response.\n     */\n    public deleteAlias(alias: string): Promise<EmptyObject> {\n        const path = utils.encodeUri(\"/directory/room/$alias\", {\n            $alias: alias,\n        });\n        return this.http.authedRequest(Method.Delete, path);\n    }\n\n    /**\n     * Gets the local aliases for the room. Note: this includes all local aliases, unlike the\n     * curated list from the m.room.canonical_alias state event.\n     * @param roomId - The room ID to get local aliases for.\n     * @returns Promise which resolves: an object with an `aliases` property, containing an array of local aliases\n     * @returns Rejects: with an error response.\n     */\n    public getLocalAliases(roomId: string): Promise<{ aliases: string[] }> {\n        const path = utils.encodeUri(\"/rooms/$roomId/aliases\", { $roomId: roomId });\n        const prefix = ClientPrefix.V3;\n        return this.http.authedRequest(Method.Get, path, undefined, undefined, { prefix });\n    }\n\n    /**\n     * Get room info for the given alias.\n     * @param alias - The room alias to resolve.\n     * @returns Promise which resolves: Object with room_id and servers.\n     * @returns Rejects: with an error response.\n     */\n    public getRoomIdForAlias(alias: string): Promise<{ room_id: string; servers: string[] }> {\n        // eslint-disable-line camelcase\n        const path = utils.encodeUri(\"/directory/room/$alias\", {\n            $alias: alias,\n        });\n        return this.http.authedRequest(Method.Get, path);\n    }\n\n    /**\n     * Get the visibility of a room in the current HS's room directory\n     * @returns Promise which resolves: TODO\n     * @returns Rejects: with an error response.\n     */\n    public getRoomDirectoryVisibility(roomId: string): Promise<{ visibility: Visibility }> {\n        const path = utils.encodeUri(\"/directory/list/room/$roomId\", {\n            $roomId: roomId,\n        });\n        return this.http.authedRequest(Method.Get, path);\n    }\n\n    /**\n     * Set the visibility of a room in the current HS's room directory\n     * @param visibility - \"public\" to make the room visible\n     *                 in the public directory, or \"private\" to make\n     *                 it invisible.\n     * @returns Promise which resolves: to an empty object `{}`\n     * @returns Rejects: with an error response.\n     */\n    public setRoomDirectoryVisibility(roomId: string, visibility: Visibility): Promise<EmptyObject> {\n        const path = utils.encodeUri(\"/directory/list/room/$roomId\", {\n            $roomId: roomId,\n        });\n        return this.http.authedRequest(Method.Put, path, undefined, { visibility });\n    }\n\n    /**\n     * Query the user directory with a term matching user IDs, display names and domains.\n     * @param options\n     * @param options.term - the term with which to search.\n     * @param options.limit - the maximum number of results to return. The server will apply a limit if unspecified.\n     * @returns Promise which resolves: an array of results.\n     */\n    public searchUserDirectory({ term, limit }: { term: string; limit?: number }): Promise<IUserDirectoryResponse> {\n        const body: Body = {\n            search_term: term,\n        };\n\n        if (limit !== undefined) {\n            body.limit = limit;\n        }\n\n        return this.http.authedRequest(Method.Post, \"/user_directory/search\", undefined, body);\n    }\n\n    /**\n     * Upload a file to the media repository on the homeserver.\n     *\n     * @param file - The object to upload. On a browser, something that\n     *   can be sent to XMLHttpRequest.send (typically a File).  Under node.js,\n     *   a a Buffer, String or ReadStream.\n     *\n     * @param opts -  options object\n     *\n     * @returns Promise which resolves to response object, as\n     *    determined by this.opts.onlyData, opts.rawResponse, and\n     *    opts.onlyContentUri.  Rejects with an error (usually a MatrixError).\n     */\n    public uploadContent(file: FileType, opts?: UploadOpts): Promise<UploadResponse> {\n        return this.http.uploadContent(file, opts);\n    }\n\n    /**\n     * Cancel a file upload in progress\n     * @param upload - The object returned from uploadContent\n     * @returns true if canceled, otherwise false\n     */\n    public cancelUpload(upload: Promise<UploadResponse>): boolean {\n        return this.http.cancelUpload(upload);\n    }\n\n    /**\n     * Get a list of all file uploads in progress\n     * @returns Array of objects representing current uploads.\n     * Currently in progress is element 0. Keys:\n     *  - promise: The promise associated with the upload\n     *  - loaded: Number of bytes uploaded\n     *  - total: Total number of bytes to upload\n     */\n    public getCurrentUploads(): Upload[] {\n        return this.http.getCurrentUploads();\n    }\n\n    /**\n     * @param info - The kind of info to retrieve (e.g. 'displayname',\n     * 'avatar_url').\n     * @returns Promise which resolves: TODO\n     * @returns Rejects: with an error response.\n     */\n    public getProfileInfo(\n        userId: string,\n        info?: string,\n        // eslint-disable-next-line camelcase\n    ): Promise<{ avatar_url?: string; displayname?: string }> {\n        const path = info\n            ? utils.encodeUri(\"/profile/$userId/$info\", { $userId: userId, $info: info })\n            : utils.encodeUri(\"/profile/$userId\", { $userId: userId });\n        return this.http.authedRequest(Method.Get, path);\n    }\n\n    /**\n     * Determine if the server supports extended profiles, as described by MSC4133.\n     *\n     * @returns `true` if supported, otherwise `false`\n     */\n    public async doesServerSupportExtendedProfiles(): Promise<boolean> {\n        return this.doesServerSupportUnstableFeature(UNSTABLE_MSC4133_EXTENDED_PROFILES);\n    }\n\n    /**\n     * Get the prefix used for extended profile requests.\n     *\n     * @returns The prefix for use with `authedRequest`\n     */\n    private async getExtendedProfileRequestPrefix(): Promise<string> {\n        if (await this.doesServerSupportUnstableFeature(\"uk.tcpip.msc4133.stable\")) {\n            return ClientPrefix.V3;\n        }\n        return \"/_matrix/client/unstable/uk.tcpip.msc4133\";\n    }\n\n    /**\n     * Fetch a user's *extended* profile, which may include additional keys.\n     *\n     * @see https://github.com/tcpipuk/matrix-spec-proposals/blob/main/proposals/4133-extended-profiles.md\n     * @param userId The user ID to fetch the profile of.\n     * @returns A set of keys to property values.\n     *\n     * @throws An error if the server does not support MSC4133.\n     * @throws A M_NOT_FOUND error if the profile could not be found.\n     */\n    public async getExtendedProfile(userId: string): Promise<Record<string, unknown>> {\n        if (!(await this.doesServerSupportExtendedProfiles())) {\n            throw new Error(\"Server does not support extended profiles\");\n        }\n        return this.http.authedRequest(\n            Method.Get,\n            utils.encodeUri(\"/profile/$userId\", { $userId: userId }),\n            undefined,\n            undefined,\n            {\n                prefix: await this.getExtendedProfileRequestPrefix(),\n            },\n        );\n    }\n\n    /**\n     * Fetch a specific key from the user's *extended* profile.\n     *\n     * @see https://github.com/tcpipuk/matrix-spec-proposals/blob/main/proposals/4133-extended-profiles.md\n     * @param userId The user ID to fetch the profile of.\n     * @param key The key of the property to fetch.\n     * @returns The property value.\n     *\n     * @throws An error if the server does not support MSC4133.\n     * @throws A M_NOT_FOUND error if the key was not set OR the profile could not be found.\n     */\n    public async getExtendedProfileProperty(userId: string, key: string): Promise<unknown> {\n        if (!(await this.doesServerSupportExtendedProfiles())) {\n            throw new Error(\"Server does not support extended profiles\");\n        }\n        const profile = (await this.http.authedRequest(\n            Method.Get,\n            utils.encodeUri(\"/profile/$userId/$key\", { $userId: userId, $key: key }),\n            undefined,\n            undefined,\n            {\n                prefix: await this.getExtendedProfileRequestPrefix(),\n            },\n        )) as Record<string, unknown>;\n        return profile[key];\n    }\n\n    /**\n     * Set a property on your *extended* profile.\n     *\n     * @see https://github.com/tcpipuk/matrix-spec-proposals/blob/main/proposals/4133-extended-profiles.md\n     * @param key The key of the property to set.\n     * @param value The value to set on the property.\n     *\n     * @throws An error if the server does not support MSC4133 OR the server disallows editing the user profile.\n     */\n    public async setExtendedProfileProperty(key: string, value: unknown): Promise<void> {\n        if (!(await this.doesServerSupportExtendedProfiles())) {\n            throw new Error(\"Server does not support extended profiles\");\n        }\n        const userId = this.getUserId();\n\n        await this.http.authedRequest(\n            Method.Put,\n            utils.encodeUri(\"/profile/$userId/$key\", { $userId: userId, $key: key }),\n            undefined,\n            { [key]: value },\n            {\n                prefix: await this.getExtendedProfileRequestPrefix(),\n            },\n        );\n    }\n\n    /**\n     * Delete a property on your *extended* profile.\n     *\n     * @see https://github.com/tcpipuk/matrix-spec-proposals/blob/main/proposals/4133-extended-profiles.md\n     * @param key The key of the property to delete.\n     *\n     * @throws An error if the server does not support MSC4133 OR the server disallows editing the user profile.\n     */\n    public async deleteExtendedProfileProperty(key: string): Promise<void> {\n        if (!(await this.doesServerSupportExtendedProfiles())) {\n            throw new Error(\"Server does not support extended profiles\");\n        }\n        const userId = this.getUserId();\n\n        await this.http.authedRequest(\n            Method.Delete,\n            utils.encodeUri(\"/profile/$userId/$key\", { $userId: userId, $key: key }),\n            undefined,\n            undefined,\n            {\n                prefix: await this.getExtendedProfileRequestPrefix(),\n            },\n        );\n    }\n\n    /**\n     * Update multiple properties on your *extended* profile. This will\n     * merge with any existing keys.\n     *\n     * @see https://github.com/tcpipuk/matrix-spec-proposals/blob/main/proposals/4133-extended-profiles.md\n     * @param profile The profile object to merge with the existing profile.\n     * @returns The newly merged profile.\n     *\n     * @throws An error if the server does not support MSC4133 OR the server disallows editing the user profile.\n     */\n    public async patchExtendedProfile(profile: Record<string, unknown>): Promise<Record<string, unknown>> {\n        if (!(await this.doesServerSupportExtendedProfiles())) {\n            throw new Error(\"Server does not support extended profiles\");\n        }\n        const userId = this.getUserId();\n\n        return this.http.authedRequest(\n            Method.Patch,\n            utils.encodeUri(\"/profile/$userId\", { $userId: userId }),\n            {},\n            profile,\n            {\n                prefix: await this.getExtendedProfileRequestPrefix(),\n            },\n        );\n    }\n\n    /**\n     * Set multiple properties on your *extended* profile. This will completely\n     * replace the existing profile, removing any unspecified keys.\n     *\n     * @see https://github.com/tcpipuk/matrix-spec-proposals/blob/main/proposals/4133-extended-profiles.md\n     * @param profile The profile object to set.\n     *\n     * @throws An error if the server does not support MSC4133 OR the server disallows editing the user profile.\n     */\n    public async setExtendedProfile(profile: Record<string, unknown>): Promise<void> {\n        if (!(await this.doesServerSupportExtendedProfiles())) {\n            throw new Error(\"Server does not support extended profiles\");\n        }\n        const userId = this.getUserId();\n\n        await this.http.authedRequest(\n            Method.Put,\n            utils.encodeUri(\"/profile/$userId\", { $userId: userId }),\n            {},\n            profile,\n            {\n                prefix: await this.getExtendedProfileRequestPrefix(),\n            },\n        );\n    }\n\n    /**\n     * @returns Promise which resolves to a list of the user's threepids.\n     * @returns Rejects: with an error response.\n     */\n    public getThreePids(): Promise<{ threepids: IThreepid[] }> {\n        return this.http.authedRequest(Method.Get, \"/account/3pid\");\n    }\n\n    /**\n     * Add a 3PID to your homeserver account. This API does not use an identity\n     * server, as the homeserver is expected to handle 3PID ownership validation.\n     *\n     * @param data - A object with 3PID validation data from having called\n     * `account/3pid/<medium>/requestToken` on the homeserver.\n     * @returns Promise which resolves: to an empty object `{}`\n     * @returns Rejects: with an error response.\n     */\n    public async addThreePidOnly(data: IAddThreePidOnlyBody): Promise<EmptyObject> {\n        const path = \"/account/3pid/add\";\n        return this.http.authedRequest(Method.Post, path, undefined, data);\n    }\n\n    /**\n     * Bind a 3PID for discovery onto an identity server via the homeserver. The\n     * identity server handles 3PID ownership validation and the homeserver records\n     * the new binding to track where all 3PIDs for the account are bound.\n     *\n     * @param data - A object with 3PID validation data from having called\n     * `validate/<medium>/requestToken` on the identity server. It should also\n     * contain `id_server` and `id_access_token` fields as well.\n     * @returns Promise which resolves: to an empty object `{}`\n     * @returns Rejects: with an error response.\n     */\n    public async bindThreePid(data: IBindThreePidBody): Promise<EmptyObject> {\n        const path = \"/account/3pid/bind\";\n        return this.http.authedRequest(Method.Post, path, undefined, data);\n    }\n\n    /**\n     * Unbind a 3PID for discovery on an identity server via the homeserver. The\n     * homeserver removes its record of the binding to keep an updated record of\n     * where all 3PIDs for the account are bound.\n     *\n     * @param medium - The threepid medium (eg. 'email')\n     * @param address - The threepid address (eg. 'bob\\@example.com')\n     *        this must be as returned by getThreePids.\n     * @returns Promise which resolves: on success\n     * @returns Rejects: with an error response.\n     */\n    public async unbindThreePid(\n        medium: string,\n        address: string,\n        // eslint-disable-next-line camelcase\n    ): Promise<{ id_server_unbind_result: IdServerUnbindResult }> {\n        const path = \"/account/3pid/unbind\";\n        const data = {\n            medium,\n            address,\n            id_server: this.getIdentityServerUrl(true),\n        };\n        return this.http.authedRequest(Method.Post, path, undefined, data);\n    }\n\n    /**\n     * @param medium - The threepid medium (eg. 'email')\n     * @param address - The threepid address (eg. 'bob\\@example.com')\n     *        this must be as returned by getThreePids.\n     * @returns Promise which resolves: The server response on success\n     *     (generally the empty JSON object)\n     * @returns Rejects: with an error response.\n     */\n    public deleteThreePid(\n        medium: string,\n        address: string,\n        // eslint-disable-next-line camelcase\n    ): Promise<{ id_server_unbind_result: IdServerUnbindResult }> {\n        const path = \"/account/3pid/delete\";\n        return this.http.authedRequest(Method.Post, path, undefined, { medium, address });\n    }\n\n    /**\n     * Make a request to change your password.\n     * @param newPassword - The new desired password.\n     * @param logoutDevices - Should all sessions be logged out after the password change. Defaults to true.\n     * @returns Promise which resolves: to an empty object `{}`\n     * @returns Rejects: with an error response.\n     */\n    public setPassword(authDict: AuthDict, newPassword: string, logoutDevices?: boolean): Promise<EmptyObject> {\n        const path = \"/account/password\";\n        const data = {\n            auth: authDict,\n            new_password: newPassword,\n            logout_devices: logoutDevices,\n        };\n\n        return this.http.authedRequest<EmptyObject>(Method.Post, path, undefined, data);\n    }\n\n    /**\n     * Gets all devices recorded for the logged-in user\n     * @returns Promise which resolves: result object\n     * @returns Rejects: with an error response.\n     */\n    public getDevices(): Promise<{ devices: IMyDevice[] }> {\n        return this.http.authedRequest(Method.Get, \"/devices\");\n    }\n\n    /**\n     * Gets specific device details for the logged-in user\n     * @param deviceId -  device to query\n     * @returns Promise which resolves: result object\n     * @returns Rejects: with an error response.\n     */\n    public getDevice(deviceId: string): Promise<IMyDevice> {\n        const path = utils.encodeUri(\"/devices/$device_id\", {\n            $device_id: deviceId,\n        });\n        return this.http.authedRequest(Method.Get, path);\n    }\n\n    /**\n     * Update the given device\n     *\n     * @param deviceId -  device to update\n     * @param body -       body of request\n     * @returns Promise which resolves: to an empty object `{}`\n     * @returns Rejects: with an error response.\n     */\n    // eslint-disable-next-line camelcase\n    public setDeviceDetails(deviceId: string, body: { display_name: string }): Promise<EmptyObject> {\n        const path = utils.encodeUri(\"/devices/$device_id\", {\n            $device_id: deviceId,\n        });\n\n        return this.http.authedRequest(Method.Put, path, undefined, body);\n    }\n\n    /**\n     * Delete the given device\n     *\n     * @param deviceId -  device to delete\n     * @param auth - Optional. Auth data to supply for User-Interactive auth.\n     * @returns Promise which resolves: result object\n     * @returns Rejects: with an error response.\n     */\n    public deleteDevice(deviceId: string, auth?: AuthDict): Promise<EmptyObject> {\n        const path = utils.encodeUri(\"/devices/$device_id\", {\n            $device_id: deviceId,\n        });\n\n        const body: Body = {};\n\n        if (auth) {\n            body.auth = auth;\n        }\n\n        return this.http.authedRequest(Method.Delete, path, undefined, body);\n    }\n\n    /**\n     * Delete multiple device\n     *\n     * @param devices - IDs of the devices to delete\n     * @param auth - Optional. Auth data to supply for User-Interactive auth.\n     * @returns Promise which resolves: result object\n     * @returns Rejects: with an error response.\n     */\n    public deleteMultipleDevices(devices: string[], auth?: AuthDict): Promise<EmptyObject> {\n        const body: Body = { devices };\n\n        if (auth) {\n            body.auth = auth;\n        }\n\n        const path = \"/delete_devices\";\n        return this.http.authedRequest(Method.Post, path, undefined, body);\n    }\n\n    /**\n     * Gets all pushers registered for the logged-in user\n     *\n     * @returns Promise which resolves: Array of objects representing pushers\n     * @returns Rejects: with an error response.\n     */\n    public async getPushers(): Promise<{ pushers: IPusher[] }> {\n        const response = await this.http.authedRequest<{ pushers: IPusher[] }>(Method.Get, \"/pushers\");\n\n        // Migration path for clients that connect to a homeserver that does not support\n        // MSC3881 yet, see https://github.com/matrix-org/matrix-spec-proposals/blob/kerry/remote-push-toggle/proposals/3881-remote-push-notification-toggling.md#migration\n        if (!(await this.doesServerSupportUnstableFeature(\"org.matrix.msc3881\"))) {\n            response.pushers = response.pushers.map((pusher) => {\n                if (!pusher.hasOwnProperty(PUSHER_ENABLED.name)) {\n                    pusher[PUSHER_ENABLED.name] = true;\n                }\n                return pusher;\n            });\n        }\n\n        return response;\n    }\n\n    /**\n     * Adds a new pusher or updates an existing pusher\n     *\n     * @param pusher - Object representing a pusher\n     * @returns Promise which resolves: Empty json object on success\n     * @returns Rejects: with an error response.\n     */\n    public setPusher(pusher: IPusherRequest): Promise<EmptyObject> {\n        const path = \"/pushers/set\";\n        return this.http.authedRequest(Method.Post, path, undefined, pusher);\n    }\n\n    /**\n     * Removes an existing pusher\n     * @param pushKey - pushkey of pusher to remove\n     * @param appId - app_id of pusher to remove\n     * @returns Promise which resolves: Empty json object on success\n     * @returns Rejects: with an error response.\n     */\n    public removePusher(pushKey: string, appId: string): Promise<EmptyObject> {\n        const path = \"/pushers/set\";\n        const body = {\n            pushkey: pushKey,\n            app_id: appId,\n            kind: null, // marks pusher for removal\n        };\n        return this.http.authedRequest(Method.Post, path, undefined, body);\n    }\n\n    /**\n     * Persists local notification settings\n     * @returns Promise which resolves: an empty object\n     * @returns Rejects: with an error response.\n     */\n    public setLocalNotificationSettings(\n        deviceId: string,\n        notificationSettings: LocalNotificationSettings,\n    ): Promise<EmptyObject> {\n        const key = `${LOCAL_NOTIFICATION_SETTINGS_PREFIX.name}.${deviceId}` as const;\n        return this.setAccountData(key, notificationSettings);\n    }\n\n    /**\n     * Get the push rules for the account from the server.\n     * @returns Promise which resolves to the push rules.\n     * @returns Rejects: with an error response.\n     */\n    public getPushRules(): Promise<IPushRules> {\n        return this.http.authedRequest<IPushRules>(Method.Get, \"/pushrules/\").then((rules: IPushRules) => {\n            this.setPushRules(rules);\n            return this.pushRules!;\n        });\n    }\n\n    /**\n     * Update the push rules for the account. This should be called whenever\n     * updated push rules are available.\n     */\n    public setPushRules(rules: IPushRules): void {\n        // Fix-up defaults, if applicable.\n        this.pushRules = PushProcessor.rewriteDefaultRules(rules, this.getUserId()!);\n        // Pre-calculate any necessary caches.\n        this.pushProcessor.updateCachedPushRuleKeys(this.pushRules);\n    }\n\n    /**\n     * @returns Promise which resolves: an empty object `{}`\n     * @returns Rejects: with an error response.\n     */\n    public addPushRule(\n        scope: string,\n        kind: PushRuleKind,\n        ruleId: Exclude<string, RuleId>,\n        body: Pick<IPushRule, \"actions\" | \"conditions\" | \"pattern\">,\n    ): Promise<EmptyObject> {\n        // NB. Scope not uri encoded because devices need the '/'\n        const path = utils.encodeUri(\"/pushrules/\" + scope + \"/$kind/$ruleId\", {\n            $kind: kind,\n            $ruleId: ruleId,\n        });\n        return this.http.authedRequest(Method.Put, path, undefined, body);\n    }\n\n    /**\n     * @returns Promise which resolves: an empty object `{}`\n     * @returns Rejects: with an error response.\n     */\n    public deletePushRule(scope: string, kind: PushRuleKind, ruleId: Exclude<string, RuleId>): Promise<EmptyObject> {\n        // NB. Scope not uri encoded because devices need the '/'\n        const path = utils.encodeUri(\"/pushrules/\" + scope + \"/$kind/$ruleId\", {\n            $kind: kind,\n            $ruleId: ruleId,\n        });\n        return this.http.authedRequest(Method.Delete, path);\n    }\n\n    /**\n     * Enable or disable a push notification rule.\n     * @returns Promise which resolves: to an empty object `{}`\n     * @returns Rejects: with an error response.\n     */\n    public setPushRuleEnabled(\n        scope: string,\n        kind: PushRuleKind,\n        ruleId: RuleId | string,\n        enabled: boolean,\n    ): Promise<EmptyObject> {\n        const path = utils.encodeUri(\"/pushrules/\" + scope + \"/$kind/$ruleId/enabled\", {\n            $kind: kind,\n            $ruleId: ruleId,\n        });\n        return this.http.authedRequest(Method.Put, path, undefined, { enabled: enabled });\n    }\n\n    /**\n     * Set the actions for a push notification rule.\n     * @returns Promise which resolves: to an empty object `{}`\n     * @returns Rejects: with an error response.\n     */\n    public setPushRuleActions(\n        scope: string,\n        kind: PushRuleKind,\n        ruleId: RuleId | string,\n        actions: PushRuleAction[],\n    ): Promise<EmptyObject> {\n        const path = utils.encodeUri(\"/pushrules/\" + scope + \"/$kind/$ruleId/actions\", {\n            $kind: kind,\n            $ruleId: ruleId,\n        });\n        return this.http.authedRequest(Method.Put, path, undefined, { actions: actions });\n    }\n\n    /**\n     * Perform a server-side search.\n     * @param params\n     * @param params.next_batch - the batch token to pass in the query string\n     * @param params.body - the JSON object to pass to the request body.\n     * @param abortSignal - optional signal used to cancel the http request.\n     * @returns Promise which resolves to the search response object.\n     * @returns Rejects: with an error response.\n     */\n    public search(\n        { body, next_batch: nextBatch }: { body: ISearchRequestBody; next_batch?: string },\n        abortSignal?: AbortSignal,\n    ): Promise<ISearchResponse> {\n        const queryParams: QueryDict = {};\n        if (nextBatch) {\n            queryParams.next_batch = nextBatch;\n        }\n        return this.http.authedRequest(Method.Post, \"/search\", queryParams, body, { abortSignal });\n    }\n\n    /**\n     * Upload keys\n     *\n     * @param content -  body of upload request\n     *\n     * @param opts - this method no longer takes any opts,\n     *  used to take opts.device_id but this was not removed from the spec as a redundant parameter\n     *\n     * @returns Promise which resolves: result object. Rejects: with\n     *     an error response ({@link MatrixError}).\n     */\n    public uploadKeysRequest(content: IUploadKeysRequest, opts?: void): Promise<IKeysUploadResponse> {\n        return this.http.authedRequest(Method.Post, \"/keys/upload\", undefined, content);\n    }\n\n    public uploadKeySignatures(content: KeySignatures): Promise<IUploadKeySignaturesResponse> {\n        return this.http.authedRequest(Method.Post, \"/keys/signatures/upload\", undefined, content);\n    }\n\n    /**\n     * Download device keys\n     *\n     * @param userIds -  list of users to get keys for\n     *\n     * @param token - sync token to pass in the query request, to help\n     *   the HS give the most recent results\n     *\n     * @returns Promise which resolves: result object. Rejects: with\n     *     an error response ({@link MatrixError}).\n     */\n    public downloadKeysForUsers(userIds: string[], { token }: { token?: string } = {}): Promise<IDownloadKeyResult> {\n        const content: IQueryKeysRequest = {\n            device_keys: {},\n        };\n        if (token !== undefined) {\n            content.token = token;\n        }\n        userIds.forEach((u) => {\n            content.device_keys[u] = [];\n        });\n\n        return this.http.authedRequest(Method.Post, \"/keys/query\", undefined, content);\n    }\n\n    /**\n     * Claim one-time keys\n     *\n     * @param devices -  a list of [userId, deviceId] pairs\n     *\n     * @param keyAlgorithm -  desired key type\n     *\n     * @param timeout - the time (in milliseconds) to wait for keys from remote\n     *     servers\n     *\n     * @returns Promise which resolves: result object. Rejects: with\n     *     an error response ({@link MatrixError}).\n     */\n    public claimOneTimeKeys(\n        devices: [string, string][],\n        keyAlgorithm = \"signed_curve25519\",\n        timeout?: number,\n    ): Promise<IClaimOTKsResult> {\n        const queries: Record<string, Record<string, string>> = {};\n\n        if (keyAlgorithm === undefined) {\n            keyAlgorithm = \"signed_curve25519\";\n        }\n\n        for (const [userId, deviceId] of devices) {\n            const query = queries[userId] || {};\n            safeSet(queries, userId, query);\n            safeSet(query, deviceId, keyAlgorithm);\n        }\n        const content: IClaimKeysRequest = { one_time_keys: queries };\n        if (timeout) {\n            content.timeout = timeout;\n        }\n        const path = \"/keys/claim\";\n        return this.http.authedRequest(Method.Post, path, undefined, content);\n    }\n\n    /**\n     * Ask the server for a list of users who have changed their device lists\n     * between a pair of sync tokens\n     *\n     *\n     * @returns Promise which resolves: result object. Rejects: with\n     *     an error response ({@link MatrixError}).\n     */\n    public getKeyChanges(oldToken: string, newToken: string): Promise<{ changed: string[]; left: string[] }> {\n        const qps = {\n            from: oldToken,\n            to: newToken,\n        };\n\n        return this.http.authedRequest(Method.Get, \"/keys/changes\", qps);\n    }\n\n    public uploadDeviceSigningKeys(auth?: AuthDict, keys?: CrossSigningKeys): Promise<EmptyObject> {\n        // API returns empty object\n        const data = Object.assign({}, keys);\n        if (auth) Object.assign(data, { auth });\n        return this.http.authedRequest(Method.Post, \"/keys/device_signing/upload\", undefined, data, {\n            prefix: ClientPrefix.Unstable,\n        });\n    }\n\n    /**\n     * Register with an identity server using the OpenID token from the user's\n     * Homeserver, which can be retrieved via\n     * {@link MatrixClient#getOpenIdToken}.\n     *\n     * Note that the `/account/register` endpoint (as well as IS authentication in\n     * general) was added as part of the v2 API version.\n     *\n     * @returns Promise which resolves: with object containing an Identity\n     * Server access token.\n     * @returns Rejects: with an error response.\n     */\n    public registerWithIdentityServer(hsOpenIdToken: IOpenIDToken): Promise<{\n        access_token: string;\n        token: string;\n    }> {\n        if (!this.idBaseUrl) {\n            throw new Error(\"No identity server base URL set\");\n        }\n\n        const uri = this.http.getUrl(\"/account/register\", undefined, IdentityPrefix.V2, this.idBaseUrl);\n        return this.http.requestOtherUrl(Method.Post, uri, hsOpenIdToken);\n    }\n\n    /**\n     * Requests an email verification token directly from an identity server.\n     *\n     * This API is used as part of binding an email for discovery on an identity\n     * server. The validation data that results should be passed to the\n     * `bindThreePid` method to complete the binding process.\n     *\n     * @param email - The email address to request a token for\n     * @param clientSecret - A secret binary string generated by the client.\n     *                 It is recommended this be around 16 ASCII characters.\n     * @param sendAttempt - If an identity server sees a duplicate request\n     *                 with the same sendAttempt, it will not send another email.\n     *                 To request another email to be sent, use a larger value for\n     *                 the sendAttempt param as was used in the previous request.\n     * @param nextLink - Optional If specified, the client will be redirected\n     *                 to this link after validation.\n     * @param identityAccessToken - The `access_token` field of the identity\n     * server `/account/register` response (see {@link registerWithIdentityServer}).\n     *\n     * @returns Promise which resolves: TODO\n     * @returns Rejects: with an error response.\n     * @throws Error if no identity server is set\n     */\n    public requestEmailToken(\n        email: string,\n        clientSecret: string,\n        sendAttempt: number,\n        nextLink?: string,\n        identityAccessToken?: string,\n    ): Promise<IRequestTokenResponse> {\n        const params: Record<string, string> = {\n            client_secret: clientSecret,\n            email: email,\n            send_attempt: sendAttempt?.toString(),\n        };\n        if (nextLink) {\n            params.next_link = nextLink;\n        }\n\n        return this.http.idServerRequest<IRequestTokenResponse>(\n            Method.Post,\n            \"/validate/email/requestToken\",\n            params,\n            IdentityPrefix.V2,\n            identityAccessToken,\n        );\n    }\n\n    /**\n     * Requests a MSISDN verification token directly from an identity server.\n     *\n     * This API is used as part of binding a MSISDN for discovery on an identity\n     * server. The validation data that results should be passed to the\n     * `bindThreePid` method to complete the binding process.\n     *\n     * @param phoneCountry - The ISO 3166-1 alpha-2 code for the country in\n     *                 which phoneNumber should be parsed relative to.\n     * @param phoneNumber - The phone number, in national or international\n     *                 format\n     * @param clientSecret - A secret binary string generated by the client.\n     *                 It is recommended this be around 16 ASCII characters.\n     * @param sendAttempt - If an identity server sees a duplicate request\n     *                 with the same sendAttempt, it will not send another SMS.\n     *                 To request another SMS to be sent, use a larger value for\n     *                 the sendAttempt param as was used in the previous request.\n     * @param nextLink - Optional If specified, the client will be redirected\n     *                 to this link after validation.\n     * @param identityAccessToken - The `access_token` field of the Identity\n     * Server `/account/register` response (see {@link registerWithIdentityServer}).\n     *\n     * @returns Promise which resolves to an object with a sid string\n     * @returns Rejects: with an error response.\n     * @throws Error if no identity server is set\n     */\n    public requestMsisdnToken(\n        phoneCountry: string,\n        phoneNumber: string,\n        clientSecret: string,\n        sendAttempt: number,\n        nextLink?: string,\n        identityAccessToken?: string,\n    ): Promise<IRequestMsisdnTokenResponse> {\n        const params: Record<string, string> = {\n            client_secret: clientSecret,\n            country: phoneCountry,\n            phone_number: phoneNumber,\n            send_attempt: sendAttempt?.toString(),\n        };\n        if (nextLink) {\n            params.next_link = nextLink;\n        }\n\n        return this.http.idServerRequest<IRequestMsisdnTokenResponse>(\n            Method.Post,\n            \"/validate/msisdn/requestToken\",\n            params,\n            IdentityPrefix.V2,\n            identityAccessToken,\n        );\n    }\n\n    /**\n     * Submits a MSISDN token to the identity server\n     *\n     * This is used when submitting the code sent by SMS to a phone number.\n     * The identity server has an equivalent API for email but the js-sdk does\n     * not expose this, since email is normally validated by the user clicking\n     * a link rather than entering a code.\n     *\n     * @param sid - The sid given in the response to requestToken\n     * @param clientSecret - A secret binary string generated by the client.\n     *                 This must be the same value submitted in the requestToken call.\n     * @param msisdnToken - The MSISDN token, as entered by the user.\n     * @param identityAccessToken - The `access_token` field of the Identity\n     * Server `/account/register` response (see {@link registerWithIdentityServer}).\n     * Some legacy identity servers had no authentication here.\n     *\n     * @returns Promise which resolves: Object, containing success boolean.\n     * @returns Rejects: with an error response.\n     * @throws Error if No identity server is set\n     */\n    public submitMsisdnToken(\n        sid: string,\n        clientSecret: string,\n        msisdnToken: string,\n        identityAccessToken: string | null,\n    ): Promise<{ success: boolean }> {\n        const params = {\n            sid: sid,\n            client_secret: clientSecret,\n            token: msisdnToken,\n        };\n\n        return this.http.idServerRequest(\n            Method.Post,\n            \"/validate/msisdn/submitToken\",\n            params,\n            IdentityPrefix.V2,\n            identityAccessToken ?? undefined,\n        );\n    }\n\n    /**\n     * Submits a MSISDN token to an arbitrary URL.\n     *\n     * This is used when submitting the code sent by SMS to a phone number in the\n     * newer 3PID flow where the homeserver validates 3PID ownership (as part of\n     * `requestAdd3pidMsisdnToken`). The homeserver response may include a\n     * `submit_url` to specify where the token should be sent, and this helper can\n     * be used to pass the token to this URL.\n     *\n     * @param url - The URL to submit the token to\n     * @param sid - The sid given in the response to requestToken\n     * @param clientSecret - A secret binary string generated by the client.\n     *                 This must be the same value submitted in the requestToken call.\n     * @param msisdnToken - The MSISDN token, as entered by the user.\n     *\n     * @returns Promise which resolves: Object, containing success boolean.\n     * @returns Rejects: with an error response.\n     */\n    public submitMsisdnTokenOtherUrl(\n        url: string,\n        sid: string,\n        clientSecret: string,\n        msisdnToken: string,\n    ): Promise<{ success: boolean }> {\n        const params = {\n            sid: sid,\n            client_secret: clientSecret,\n            token: msisdnToken,\n        };\n        return this.http.requestOtherUrl(Method.Post, url, params);\n    }\n\n    /**\n     * Gets the V2 hashing information from the identity server. Primarily useful for\n     * lookups.\n     * @param identityAccessToken - The access token for the identity server.\n     * @returns The hashing information for the identity server.\n     */\n    public getIdentityHashDetails(identityAccessToken: string): Promise<{\n        /**\n         * The algorithms the server supports. Must contain at least sha256.\n         */\n        algorithms: string[];\n        /**\n         * The pepper the client MUST use in hashing identifiers,\n         * and MUST supply to the /lookup endpoint when performing lookups.\n         */\n        lookup_pepper: string;\n    }> {\n        return this.http.idServerRequest(\n            Method.Get,\n            \"/hash_details\",\n            undefined,\n            IdentityPrefix.V2,\n            identityAccessToken,\n        );\n    }\n\n    /**\n     * Performs a hashed lookup of addresses against the identity server. This is\n     * only supported on identity servers which have at least the version 2 API.\n     * @param addressPairs - An array of 2 element arrays.\n     * The first element of each pair is the address, the second is the 3PID medium.\n     * Eg: `[\"email@example.org\", \"email\"]`\n     * @param identityAccessToken - The access token for the identity server.\n     * @returns A collection of address mappings to\n     * found MXIDs. Results where no user could be found will not be listed.\n     */\n    public async identityHashedLookup(\n        addressPairs: [string, string][],\n        identityAccessToken: string,\n    ): Promise<{ address: string; mxid: string }[]> {\n        const params: Record<string, string | string[]> = {\n            // addresses: [\"email@example.org\", \"10005550000\"],\n            // algorithm: \"sha256\",\n            // pepper: \"abc123\"\n        };\n\n        // Get hash information first before trying to do a lookup\n        const hashes = await this.getIdentityHashDetails(identityAccessToken);\n        if (!hashes || !hashes[\"lookup_pepper\"] || !hashes[\"algorithms\"]) {\n            throw new Error(\"Unsupported identity server: bad response\");\n        }\n\n        params[\"pepper\"] = hashes[\"lookup_pepper\"];\n\n        const localMapping: Record<string, string> = {\n            // hashed identifier => plain text address\n            // For use in this function's return format\n        };\n\n        // When picking an algorithm, we pick the hashed over no hashes\n        if (hashes[\"algorithms\"].includes(\"sha256\")) {\n            params[\"addresses\"] = await Promise.all(\n                addressPairs.map(async (p) => {\n                    const addr = p[0].toLowerCase(); // lowercase to get consistent hashes\n                    const med = p[1].toLowerCase();\n                    const hashBuffer = await sha256(`${addr} ${med} ${params[\"pepper\"]}`);\n                    const hashed = encodeUnpaddedBase64Url(hashBuffer);\n\n                    // Map the hash to a known (case-sensitive) address. We use the case\n                    // sensitive version because the caller might be expecting that.\n                    localMapping[hashed] = p[0];\n                    return hashed;\n                }),\n            );\n            params[\"algorithm\"] = \"sha256\";\n        } else if (hashes[\"algorithms\"].includes(\"none\")) {\n            params[\"addresses\"] = addressPairs.map((p) => {\n                const addr = p[0].toLowerCase(); // lowercase to get consistent hashes\n                const med = p[1].toLowerCase();\n                const unhashed = `${addr} ${med}`;\n                // Map the unhashed values to a known (case-sensitive) address. We use\n                // the case-sensitive version because the caller might be expecting that.\n                localMapping[unhashed] = p[0];\n                return unhashed;\n            });\n            params[\"algorithm\"] = \"none\";\n        } else {\n            throw new Error(\"Unsupported identity server: unknown hash algorithm\");\n        }\n\n        const response = await this.http.idServerRequest<{\n            mappings: { [address: string]: string };\n        }>(Method.Post, \"/lookup\", params, IdentityPrefix.V2, identityAccessToken);\n\n        if (!response?.[\"mappings\"]) return []; // no results\n\n        const foundAddresses: { address: string; mxid: string }[] = [];\n        for (const hashed of Object.keys(response[\"mappings\"])) {\n            const mxid = response[\"mappings\"][hashed];\n            const plainAddress = localMapping[hashed];\n            if (!plainAddress) {\n                throw new Error(\"Identity server returned more results than expected\");\n            }\n\n            foundAddresses.push({ address: plainAddress, mxid });\n        }\n        return foundAddresses;\n    }\n\n    /**\n     * Looks up the public Matrix ID mapping for a given 3rd party\n     * identifier from the identity server\n     *\n     * @param medium - The medium of the threepid, eg. 'email'\n     * @param address - The textual address of the threepid\n     * @param identityAccessToken - The `access_token` field of the Identity\n     * Server `/account/register` response (see {@link registerWithIdentityServer}).\n     *\n     * @returns Promise which resolves: A threepid mapping\n     *                                 object or the empty object if no mapping\n     *                                 exists\n     * @returns Rejects: with an error response.\n     */\n    public async lookupThreePid(\n        medium: string,\n        address: string,\n        identityAccessToken: string,\n    ): Promise<\n        | {\n              address: string;\n              medium: string;\n              mxid: string;\n          }\n        | EmptyObject\n    > {\n        // Note: we're using the V2 API by calling this function, but our\n        // function contract requires a V1 response. We therefore have to\n        // convert it manually.\n        const response = await this.identityHashedLookup([[address, medium]], identityAccessToken);\n        const result = response.find((p) => p.address === address);\n        if (!result) {\n            return {};\n        }\n\n        const mapping = {\n            address,\n            medium,\n            mxid: result.mxid,\n\n            // We can't reasonably fill these parameters:\n            // not_before\n            // not_after\n            // ts\n            // signatures\n        };\n\n        return mapping;\n    }\n\n    /**\n     * Looks up the public Matrix ID mappings for multiple 3PIDs.\n     *\n     * @param query - Array of arrays containing\n     * [medium, address]\n     * @param identityAccessToken - The `access_token` field of the Identity\n     * Server `/account/register` response (see {@link registerWithIdentityServer}).\n     *\n     * @returns Promise which resolves: Lookup results from IS.\n     * @returns Rejects: with an error response.\n     */\n    public async bulkLookupThreePids(\n        query: [string, string][],\n        identityAccessToken: string,\n    ): Promise<{\n        threepids: [medium: string, address: string, mxid: string][];\n    }> {\n        // Note: we're using the V2 API by calling this function, but our\n        // function contract requires a V1 response. We therefore have to\n        // convert it manually.\n        const response = await this.identityHashedLookup(\n            // We have to reverse the query order to get [address, medium] pairs\n            query.map((p) => [p[1], p[0]]),\n            identityAccessToken,\n        );\n\n        const v1results: [medium: string, address: string, mxid: string][] = [];\n        for (const mapping of response) {\n            const originalQuery = query.find((p) => p[1] === mapping.address);\n            if (!originalQuery) {\n                throw new Error(\"Identity sever returned unexpected results\");\n            }\n\n            v1results.push([\n                originalQuery[0], // medium\n                mapping.address,\n                mapping.mxid,\n            ]);\n        }\n\n        return { threepids: v1results };\n    }\n\n    /**\n     * Get account info from the identity server. This is useful as a neutral check\n     * to verify that other APIs are likely to approve access by testing that the\n     * token is valid, terms have been agreed, etc.\n     *\n     * @param identityAccessToken - The `access_token` field of the Identity\n     * Server `/account/register` response (see {@link registerWithIdentityServer}).\n     *\n     * @returns Promise which resolves: an object with account info.\n     * @returns Rejects: with an error response.\n     */\n    public getIdentityAccount(identityAccessToken: string): Promise<{ user_id: string }> {\n        return this.http.idServerRequest(Method.Get, \"/account\", undefined, IdentityPrefix.V2, identityAccessToken);\n    }\n\n    /**\n     * Send an event to a specific list of devices.\n     * This is a low-level API that simply wraps the HTTP API\n     * call to send to-device messages. We recommend using\n     * queueToDevice() which is a higher level API.\n     *\n     * @param eventType -  type of event to send\n     *    content to send. Map from user_id to device_id to content object.\n     * @param txnId -     transaction id. One will be made up if not\n     *    supplied.\n     * @returns Promise which resolves: to an empty object `{}`\n     */\n    public sendToDevice(eventType: string, contentMap: SendToDeviceContentMap, txnId?: string): Promise<EmptyObject> {\n        const path = utils.encodeUri(\"/sendToDevice/$eventType/$txnId\", {\n            $eventType: eventType,\n            $txnId: txnId ? txnId : this.makeTxnId(),\n        });\n\n        const body = {\n            messages: utils.recursiveMapToObject(contentMap),\n        };\n\n        const targets = new Map<string, string[]>();\n\n        for (const [userId, deviceMessages] of contentMap) {\n            targets.set(userId, Array.from(deviceMessages.keys()));\n        }\n\n        this.logger.debug(`PUT ${path}`, targets);\n\n        return this.http.authedRequest(Method.Put, path, undefined, body);\n    }\n\n    /**\n     * Sends events directly to specific devices using Matrix's to-device\n     * messaging system. The batch will be split up into appropriately sized\n     * batches for sending and stored in the store so they can be retried\n     * later if they fail to send. Retries will happen automatically.\n     * @param batch - The to-device messages to send\n     */\n    public queueToDevice(batch: ToDeviceBatch): Promise<void> {\n        return this.toDeviceMessageQueue.queueBatch(batch);\n    }\n\n    /**\n     * Get the third party protocols that can be reached using\n     * this HS\n     * @returns Promise which resolves to the result object\n     */\n    public getThirdpartyProtocols(): Promise<{ [protocol: string]: IProtocol }> {\n        return this.http\n            .authedRequest<Record<string, IProtocol>>(Method.Get, \"/thirdparty/protocols\")\n            .then((response) => {\n                // sanity check\n                if (!response || typeof response !== \"object\") {\n                    throw new Error(`/thirdparty/protocols did not return an object: ${response}`);\n                }\n                return response;\n            });\n    }\n\n    /**\n     * Get information on how a specific place on a third party protocol\n     * may be reached.\n     * @param protocol - The protocol given in getThirdpartyProtocols()\n     * @param params - Protocol-specific parameters, as given in the\n     *                        response to getThirdpartyProtocols()\n     * @returns Promise which resolves to the result object\n     */\n    public getThirdpartyLocation(\n        protocol: string,\n        params: { searchFields?: string[] },\n    ): Promise<IThirdPartyLocation[]> {\n        const path = utils.encodeUri(\"/thirdparty/location/$protocol\", {\n            $protocol: protocol,\n        });\n\n        return this.http.authedRequest(Method.Get, path, params);\n    }\n\n    /**\n     * Get information on how a specific user on a third party protocol\n     * may be reached.\n     * @param protocol - The protocol given in getThirdpartyProtocols()\n     * @param params - Protocol-specific parameters, as given in the\n     *                        response to getThirdpartyProtocols()\n     * @returns Promise which resolves to the result object\n     */\n    public getThirdpartyUser(protocol: string, params?: QueryDict): Promise<IThirdPartyUser[]> {\n        const path = utils.encodeUri(\"/thirdparty/user/$protocol\", {\n            $protocol: protocol,\n        });\n\n        return this.http.authedRequest(Method.Get, path, params);\n    }\n\n    public getTerms(serviceType: SERVICE_TYPES, baseUrl: string): Promise<Terms> {\n        const url = this.termsUrlForService(serviceType, baseUrl);\n        return this.http.requestOtherUrl(Method.Get, url);\n    }\n\n    public agreeToTerms(\n        serviceType: SERVICE_TYPES,\n        baseUrl: string,\n        accessToken: string,\n        termsUrls: string[],\n    ): Promise<EmptyObject> {\n        const url = this.termsUrlForService(serviceType, baseUrl);\n        const headers = {\n            Authorization: \"Bearer \" + accessToken,\n        };\n        return this.http.requestOtherUrl(\n            Method.Post,\n            url,\n            {\n                user_accepts: termsUrls,\n            },\n            { headers },\n        );\n    }\n\n    /**\n     * Reports an event as inappropriate to the server, which may then notify the appropriate people.\n     * @param roomId - The room in which the event being reported is located.\n     * @param eventId - The event to report.\n     * @param score - The score to rate this content as where -100 is most offensive and 0 is inoffensive.\n     * @param reason - The reason the content is being reported. May be blank.\n     * @returns Promise which resolves to an empty object if successful\n     */\n    public reportEvent(roomId: string, eventId: string, score: number, reason: string): Promise<EmptyObject> {\n        const path = utils.encodeUri(\"/rooms/$roomId/report/$eventId\", {\n            $roomId: roomId,\n            $eventId: eventId,\n        });\n\n        return this.http.authedRequest(Method.Post, path, undefined, { score, reason });\n    }\n\n    /**\n     * Reports a room as inappropriate to the server, which may then notify the appropriate people.\n     *\n     * This API was introduced in Matrix v1.13.\n     *\n     * @param roomId - The room being reported.\n     * @param reason - The reason the room is being reported. May be blank.\n     * @returns Promise which resolves to an empty object if successful\n     */\n    public reportRoom(roomId: string, reason: string): Promise<EmptyObject> {\n        const path = utils.encodeUri(\"/rooms/$roomId/report\", {\n            $roomId: roomId,\n        });\n\n        return this.http.authedRequest(Method.Post, path, undefined, { reason });\n    }\n\n    /**\n     * Fetches or paginates a room hierarchy asmatrix-js-sdk/spec/unit/matrix-client.spec.ts defined by MSC2946.\n     * Falls back gracefully to sourcing its data from `getSpaceSummary` if this API is not yet supported by the server.\n     * @param roomId - The ID of the space-room to use as the root of the summary.\n     * @param limit - The maximum number of rooms to return per page.\n     * @param maxDepth - The maximum depth in the tree from the root room to return.\n     * @param suggestedOnly - Whether to only return rooms with suggested=true.\n     * @param fromToken - The opaque token to paginate a previous request.\n     * @returns the response, with next_batch & rooms fields.\n     */\n    public getRoomHierarchy(\n        roomId: string,\n        limit?: number,\n        maxDepth?: number,\n        suggestedOnly = false,\n        fromToken?: string,\n    ): Promise<IRoomHierarchy> {\n        const path = utils.encodeUri(\"/rooms/$roomId/hierarchy\", {\n            $roomId: roomId,\n        });\n\n        const queryParams: QueryDict = {\n            suggested_only: String(suggestedOnly),\n            max_depth: maxDepth?.toString(),\n            from: fromToken,\n            limit: limit?.toString(),\n        };\n\n        return this.http\n            .authedRequest<IRoomHierarchy>(Method.Get, path, queryParams, undefined, {\n                prefix: ClientPrefix.V1,\n            })\n            .catch((e) => {\n                if (e.errcode === \"M_UNRECOGNIZED\") {\n                    // fall back to the prefixed hierarchy API.\n                    return this.http.authedRequest<IRoomHierarchy>(Method.Get, path, queryParams, undefined, {\n                        prefix: \"/_matrix/client/unstable/org.matrix.msc2946\",\n                    });\n                }\n\n                throw e;\n            });\n    }\n\n    /**\n     * Creates a new file tree space with the given name. The client will pick\n     * defaults for how it expects to be able to support the remaining API offered\n     * by the returned class.\n     *\n     * Note that this is UNSTABLE and may have breaking changes without notice.\n     * @param name - The name of the tree space.\n     * @returns Promise which resolves to the created space.\n     */\n    public async unstableCreateFileTree(name: string): Promise<MSC3089TreeSpace> {\n        const { room_id: roomId } = await this.createRoom({\n            name: name,\n            preset: Preset.PrivateChat,\n            power_level_content_override: {\n                ...DEFAULT_TREE_POWER_LEVELS_TEMPLATE,\n                users: {\n                    [this.getUserId()!]: 100,\n                },\n            },\n            creation_content: {\n                [RoomCreateTypeField]: RoomType.Space,\n            },\n            initial_state: [\n                {\n                    type: UNSTABLE_MSC3088_PURPOSE.name,\n                    state_key: UNSTABLE_MSC3089_TREE_SUBTYPE.name,\n                    content: {\n                        [UNSTABLE_MSC3088_ENABLED.name]: true,\n                    },\n                },\n                {\n                    type: EventType.RoomEncryption,\n                    state_key: \"\",\n                    content: {\n                        algorithm: \"m.megolm.v1.aes-sha2\",\n                    },\n                },\n            ],\n        });\n        return new MSC3089TreeSpace(this, roomId);\n    }\n\n    /**\n     * Gets a reference to a tree space, if the room ID given is a tree space. If the room\n     * does not appear to be a tree space then null is returned.\n     *\n     * Note that this is UNSTABLE and may have breaking changes without notice.\n     * @param roomId - The room ID to get a tree space reference for.\n     * @returns The tree space, or null if not a tree space.\n     */\n    public unstableGetFileTreeSpace(roomId: string): MSC3089TreeSpace | null {\n        const room = this.getRoom(roomId);\n        if (room?.getMyMembership() !== KnownMembership.Join) return null;\n\n        const createEvent = room.currentState.getStateEvents(EventType.RoomCreate, \"\");\n        const purposeEvent = room.currentState.getStateEvents(\n            UNSTABLE_MSC3088_PURPOSE.name,\n            UNSTABLE_MSC3089_TREE_SUBTYPE.name,\n        );\n\n        if (!createEvent) throw new Error(\"Expected single room create event\");\n\n        if (!purposeEvent?.getContent()?.[UNSTABLE_MSC3088_ENABLED.name]) return null;\n        if (createEvent.getContent()?.[RoomCreateTypeField] !== RoomType.Space) return null;\n\n        return new MSC3089TreeSpace(this, roomId);\n    }\n\n    /**\n     * Perform a single MSC3575 sliding sync request.\n     * @param req - The request to make.\n     * @param proxyBaseUrl - The base URL for the sliding sync proxy.\n     * @param abortSignal - Optional signal to abort request mid-flight.\n     * @returns The sliding sync response, or a standard error.\n     * @throws on non 2xx status codes with an object with a field \"httpStatus\":number.\n     */\n    public slidingSync(\n        req: MSC3575SlidingSyncRequest,\n        proxyBaseUrl?: string,\n        abortSignal?: AbortSignal,\n    ): Promise<MSC3575SlidingSyncResponse> {\n        const qps: QueryDict = {};\n        if (req.pos) {\n            qps.pos = req.pos;\n            delete req.pos;\n        }\n        if (req.timeout) {\n            qps.timeout = req.timeout;\n            delete req.timeout;\n        }\n        const clientTimeout = req.clientTimeout;\n        delete req.clientTimeout;\n        return this.http.authedRequest<MSC3575SlidingSyncResponse>(Method.Post, \"/sync\", qps, req, {\n            prefix: \"/_matrix/client/unstable/org.matrix.msc3575\",\n            baseUrl: proxyBaseUrl,\n            localTimeoutMs: clientTimeout,\n            abortSignal,\n        });\n    }\n\n    /**\n     * A helper to determine thread support\n     * @returns a boolean to determine if threads are enabled\n     */\n    public supportsThreads(): boolean {\n        return this.clientOpts?.threadSupport || false;\n    }\n\n    /**\n     * A helper to determine intentional mentions support\n     * @returns a boolean to determine if intentional mentions are enabled on the server\n     * @experimental\n     */\n    public supportsIntentionalMentions(): boolean {\n        return this.canSupport.get(Feature.IntentionalMentions) !== ServerSupport.Unsupported;\n    }\n\n    /**\n     * Fetches the summary of a room as defined by an initial version of MSC3266 and implemented in Synapse\n     * Proposed at https://github.com/matrix-org/matrix-doc/pull/3266\n     * @param roomIdOrAlias - The ID or alias of the room to get the summary of.\n     * @param via - The list of servers which know about the room if only an ID was provided.\n     */\n    public async getRoomSummary(roomIdOrAlias: string, via?: string[]): Promise<RoomSummary> {\n        const paramOpts = {\n            prefix: \"/_matrix/client/unstable/im.nheko.summary\",\n        };\n        try {\n            const path = utils.encodeUri(\"/summary/$roomid\", { $roomid: roomIdOrAlias });\n            return await this.http.authedRequest(Method.Get, path, { via }, undefined, paramOpts);\n        } catch (e) {\n            if (e instanceof MatrixError && e.errcode === \"M_UNRECOGNIZED\") {\n                const path = utils.encodeUri(\"/rooms/$roomid/summary\", { $roomid: roomIdOrAlias });\n                return await this.http.authedRequest(Method.Get, path, { via }, undefined, paramOpts);\n            } else {\n                throw e;\n            }\n        }\n    }\n\n    /**\n     * Processes a list of threaded events and adds them to their respective timelines\n     * @param room - the room the adds the threaded events\n     * @param threadedEvents - an array of the threaded events\n     * @param toStartOfTimeline - the direction in which we want to add the events\n     */\n    public processThreadEvents(room: Room, threadedEvents: MatrixEvent[], toStartOfTimeline: boolean): void {\n        room.processThreadedEvents(threadedEvents, toStartOfTimeline);\n    }\n\n    /**\n     * Processes a list of thread roots and creates a thread model\n     * @param room - the room to create the threads in\n     * @param threadedEvents - an array of thread roots\n     * @param toStartOfTimeline - the direction\n     */\n    public processThreadRoots(room: Room, threadedEvents: MatrixEvent[], toStartOfTimeline: boolean): void {\n        if (!this.supportsThreads()) return;\n        room.processThreadRoots(threadedEvents, toStartOfTimeline);\n    }\n\n    public processBeaconEvents(room?: Room, events?: MatrixEvent[]): void {\n        this.processAggregatedTimelineEvents(room, events);\n    }\n\n    /**\n     * Calls aggregation functions for event types that are aggregated\n     * Polls and location beacons\n     * @param room - room the events belong to\n     * @param events - timeline events to be processed\n     * @returns\n     */\n    public processAggregatedTimelineEvents(room?: Room, events?: MatrixEvent[]): void {\n        if (!events?.length) return;\n        if (!room) return;\n\n        room.currentState.processBeaconEvents(events, this);\n        room.processPollEvents(events);\n    }\n\n    /**\n     * Fetches information about the user for the configured access token.\n     */\n    public async whoami(): Promise<IWhoamiResponse> {\n        return this.http.authedRequest(Method.Get, \"/account/whoami\");\n    }\n\n    /**\n     * Find the event_id closest to the given timestamp in the given direction.\n     * @returns Resolves: A promise of an object containing the event_id and\n     *    origin_server_ts of the closest event to the timestamp in the given direction\n     * @returns Rejects: when the request fails (module:http-api.MatrixError)\n     */\n    public async timestampToEvent(\n        roomId: string,\n        timestamp: number,\n        dir: Direction,\n    ): Promise<TimestampToEventResponse> {\n        const path = utils.encodeUri(\"/rooms/$roomId/timestamp_to_event\", {\n            $roomId: roomId,\n        });\n        const queryParams = {\n            ts: timestamp.toString(),\n            dir: dir,\n        };\n\n        try {\n            return await this.http.authedRequest(Method.Get, path, queryParams, undefined, {\n                prefix: ClientPrefix.V1,\n            });\n        } catch (err) {\n            // Fallback to the prefixed unstable endpoint. Since the stable endpoint is\n            // new, we should also try the unstable endpoint before giving up. We can\n            // remove this fallback request in a year (remove after 2023-11-28).\n            if (\n                (<MatrixError>err).errcode === \"M_UNRECOGNIZED\" &&\n                // XXX: The 400 status code check should be removed in the future\n                // when Synapse is compliant with MSC3743.\n                ((<MatrixError>err).httpStatus === 400 ||\n                    // This the correct standard status code for an unsupported\n                    // endpoint according to MSC3743. Not Found and Method Not Allowed\n                    // both indicate that this endpoint+verb combination is\n                    // not supported.\n                    (<MatrixError>err).httpStatus === 404 ||\n                    (<MatrixError>err).httpStatus === 405)\n            ) {\n                return await this.http.authedRequest(Method.Get, path, queryParams, undefined, {\n                    prefix: \"/_matrix/client/unstable/org.matrix.msc3030\",\n                });\n            }\n\n            throw err;\n        }\n    }\n\n    /**\n     * Get the OIDC issuer responsible for authentication on this server, if any\n     * @returns Resolves: A promise of an object containing the OIDC issuer if configured\n     * @returns Rejects: when the request fails (module:http-api.MatrixError)\n     * @experimental - part of MSC2965\n     * @deprecated in favour of getAuthMetadata\n     */\n    public async getAuthIssuer(): Promise<{\n        issuer: string;\n    }> {\n        return this.http.request(Method.Get, \"/auth_issuer\", undefined, undefined, {\n            prefix: ClientPrefix.Unstable + \"/org.matrix.msc2965\",\n        });\n    }\n\n    /**\n     * Discover and validate delegated auth configuration\n     * - delegated auth issuer openid-configuration is reachable\n     * - delegated auth issuer openid-configuration is configured correctly for us\n     * Fetches /auth_metadata falling back to legacy implementation using /auth_issuer followed by\n     * https://oidc-issuer.example.com/.well-known/openid-configuration and other files linked therein.\n     * When successful, validated metadata is returned\n     * @returns validated authentication metadata and optionally signing keys\n     * @throws when delegated auth config is invalid or unreachable\n     * @experimental - part of MSC2965\n     */\n    public async getAuthMetadata(): Promise<OidcClientConfig> {\n        let authMetadata: unknown | undefined;\n        try {\n            authMetadata = await this.http.request<unknown>(Method.Get, \"/auth_metadata\", undefined, undefined, {\n                prefix: ClientPrefix.Unstable + \"/org.matrix.msc2965\",\n            });\n        } catch (e) {\n            if (e instanceof MatrixError && e.errcode === \"M_UNRECOGNIZED\") {\n                const { issuer } = await this.getAuthIssuer();\n                return discoverAndValidateOIDCIssuerWellKnown(issuer);\n            }\n            throw e;\n        }\n\n        return validateAuthMetadataAndKeys(authMetadata);\n    }\n}\n\nfunction getUnstableDelayQueryOpts(delayOpts: SendDelayedEventRequestOpts): QueryDict {\n    return Object.fromEntries(\n        Object.entries(delayOpts).map(([k, v]) => [`${UNSTABLE_MSC4140_DELAYED_EVENTS}.${k}`, v]),\n    );\n}\n\n/**\n * recalculates an accurate notifications count on event decryption.\n * Servers do not have enough knowledge about encrypted events to calculate an\n * accurate notification_count\n */\nexport function fixNotificationCountOnDecryption(cli: MatrixClient, event: MatrixEvent): void {\n    const ourUserId = cli.getUserId();\n    const eventId = event.getId();\n\n    const room = cli.getRoom(event.getRoomId());\n    if (!room || !ourUserId || !eventId) return;\n\n    // Due to threads, we can get relation events (eg. edits & reactions) that never get\n    // added to a timeline and so cannot be found in their own room (their edit / reaction\n    // still applies to the event it needs to, so it doesn't matter too much). However, if\n    // we try to process notification about this event, we'll get very confused because we\n    // won't be able to find the event in the room, so will assume it must be unread, even\n    // if it's actually read. We therefore skip anything that isn't in the room. This isn't\n    // *great*, so if we can fix the homeless events (eg. with MSC4023) then we should probably\n    // remove this workaround.\n    if (!room.findEventById(eventId)) {\n        logger.info(`Decrypted event ${event.getId()} is not in room ${room.roomId}: ignoring`);\n        return;\n    }\n\n    const isThreadEvent = !!event.threadRootId && !event.isThreadRoot;\n\n    let hasReadEvent;\n    if (isThreadEvent) {\n        const thread = room.getThread(event.threadRootId);\n        hasReadEvent = thread\n            ? thread.hasUserReadEvent(ourUserId, eventId)\n            : // If the thread object does not exist in the room yet, we don't\n              // want to calculate notification for this event yet. We have not\n              // restored the read receipts yet and can't accurately calculate\n              // notifications at this stage.\n              //\n              // This issue can likely go away when MSC3874 is implemented\n              true;\n    } else {\n        hasReadEvent = room.hasUserReadEvent(ourUserId, eventId);\n    }\n\n    if (hasReadEvent) {\n        // If the event has been read, ignore it.\n        return;\n    }\n\n    const actions = cli.getPushActionsForEvent(event, true);\n\n    // Ensure the unread counts are kept up to date if the event is encrypted\n    // We also want to make sure that the notification count goes up if we already\n    // have encrypted events to avoid other code from resetting 'highlight' to zero.\n    const newHighlight = !!actions?.tweaks?.highlight;\n\n    if (newHighlight) {\n        // TODO: Handle mentions received while the client is offline\n        // See also https://github.com/vector-im/element-web/issues/9069\n        const newCount = room.getUnreadCountForEventContext(NotificationCountType.Highlight, event) + 1;\n        if (isThreadEvent) {\n            room.setThreadUnreadNotificationCount(event.threadRootId, NotificationCountType.Highlight, newCount);\n        } else {\n            room.setUnreadNotificationCount(NotificationCountType.Highlight, newCount);\n        }\n    }\n\n    // `notify` is used in practice for incrementing the total count\n    const newNotify = !!actions?.notify;\n\n    // The room total count is NEVER incremented by the server for encrypted rooms. We basically ignore\n    // the server here as it's always going to tell us to increment for encrypted events.\n    if (newNotify) {\n        // Total count is used to typically increment a room notification counter, but not loudly highlight it.\n        const newCount = room.getUnreadCountForEventContext(NotificationCountType.Total, event) + 1;\n        if (isThreadEvent) {\n            room.setThreadUnreadNotificationCount(event.threadRootId, NotificationCountType.Total, newCount);\n        } else {\n            room.setUnreadNotificationCount(NotificationCountType.Total, newCount);\n        }\n    }\n}\n\n/**\n * Given an event, figure out the thread ID we should use for it in a receipt.\n *\n * This will either be \"main\", or event.threadRootId. For the thread root, or\n * e.g. reactions to the thread root, this will be main. For events inside the\n * thread, or e.g. reactions to them, this will be event.threadRootId.\n *\n * (Exported for test.)\n */\nexport function threadIdForReceipt(event: MatrixEvent): string {\n    return inMainTimelineForReceipt(event) ? MAIN_ROOM_TIMELINE : event.threadRootId!;\n}\n\n/**\n * a) True for non-threaded messages, thread roots and non-thread relations to thread roots.\n * b) False for messages with thread relations to the thread root.\n * c) False for messages with any kind of relation to a message from case b.\n *\n * Note: true for redactions of messages that are in threads. Redacted messages\n * are not really in threads (because their relations are gone), so if they look\n * like they are in threads, that is a sign of a bug elsewhere. (At time of\n * writing, this bug definitely exists - messages are not moved to another\n * thread when they are redacted.)\n *\n * @returns true if this event is considered to be in the main timeline as far\n *               as receipts are concerned.\n */\nexport function inMainTimelineForReceipt(event: MatrixEvent): boolean {\n    if (!event.threadRootId) {\n        // Not in a thread: then it is in the main timeline\n        return true;\n    }\n\n    if (event.isThreadRoot) {\n        // Thread roots are in the main timeline. Note: the spec is ambiguous (or\n        // wrong) on this - see\n        // https://github.com/matrix-org/matrix-spec-proposals/pull/4037\n        return true;\n    }\n\n    if (!event.isRelation()) {\n        // If it's not related to anything, it can't be related via a chain of\n        // relations to a thread root.\n        //\n        // Note: this is a bug, because how does it have a threadRootId if it is\n        // neither a thread root, nor related to one?\n        logger.warn(`Event is not a relation or a thread root, but still has a threadRootId! id=${event.getId()}`);\n        return true;\n    }\n\n    if (event.isRelation(THREAD_RELATION_TYPE.name)) {\n        // It's a message in a thread - definitely not in the main timeline.\n        return false;\n    }\n\n    const isRelatedToRoot = event.relationEventId === event.threadRootId;\n\n    // If it's related to the thread root (and we already know it's not a thread\n    // relation) then it's in the main timeline. If it's related to something\n    // else, then it's in the thread (because it has a thread ID).\n    return isRelatedToRoot;\n}\n","/*\nCopyright 2021 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { type MatrixClient } from \"./client.ts\";\nimport { type IEvent, MatrixEvent, MatrixEventEvent } from \"./models/event.ts\";\nimport { RelationType } from \"./@types/event.ts\";\n\nexport type EventMapper = (obj: Partial<IEvent>) => MatrixEvent;\n\nexport interface MapperOpts {\n    // don't re-emit events emitted on an event mapped by this mapper on the client\n    preventReEmit?: boolean;\n    // decrypt event proactively\n    decrypt?: boolean;\n\n    /** @deprecated no longer used */\n    toDevice?: boolean;\n}\n\nexport function eventMapperFor(client: MatrixClient, options: MapperOpts): EventMapper {\n    let preventReEmit = Boolean(options.preventReEmit);\n    const decrypt = options.decrypt !== false;\n\n    function mapper(plainOldJsObject: Partial<IEvent>): MatrixEvent {\n        const room = client.getRoom(plainOldJsObject.room_id);\n\n        let event: MatrixEvent | undefined;\n        // If the event is already known to the room, let's re-use the model rather than duplicating.\n        // We avoid doing this to state events as they may be forward or backwards looking which tweaks behaviour.\n        if (room && plainOldJsObject.state_key === undefined) {\n            event = room.findEventById(plainOldJsObject.event_id!);\n        }\n\n        if (!event || event.status) {\n            event = new MatrixEvent(plainOldJsObject);\n        } else {\n            // merge the latest unsigned data from the server\n            event.setUnsigned({ ...event.getUnsigned(), ...plainOldJsObject.unsigned });\n            // prevent doubling up re-emitters\n            preventReEmit = true;\n        }\n\n        // if there is a complete edit bundled alongside the event, perform the replacement.\n        // (prior to MSC3925, events were automatically replaced on the server-side. MSC3925 proposes that that doesn't\n        // happen automatically but the server does provide us with the whole content of the edit event.)\n        const bundledEdit = event.getServerAggregatedRelation<Partial<IEvent>>(RelationType.Replace);\n        if (bundledEdit?.content) {\n            const replacement = mapper(bundledEdit);\n            // XXX: it's worth noting that the spec says we should only respect encrypted edits if, once decrypted, the\n            //   replacement has a `m.new_content` property. The problem is that we haven't yet decrypted the replacement\n            //   (it should be happening in the background), so we can't enforce this. Possibly we should for decryption\n            //   to complete, but that sounds a bit racy. For now, we just assume it's ok.\n            event.makeReplaced(replacement);\n        }\n\n        const thread = room?.findThreadForEvent(event);\n        if (thread) {\n            event.setThread(thread);\n        }\n\n        if (event.isEncrypted()) {\n            if (!preventReEmit) {\n                client.reEmitter.reEmit(event, [MatrixEventEvent.Decrypted]);\n            }\n            if (decrypt) {\n                client.decryptEventIfNeeded(event);\n            }\n        }\n\n        if (!preventReEmit) {\n            client.reEmitter.reEmit(event, [MatrixEventEvent.Replaced, MatrixEventEvent.VisibilityChange]);\n            room?.reEmitter.reEmit(event, [MatrixEventEvent.BeforeRedaction]);\n        }\n        return event;\n    }\n\n    return mapper;\n}\n","/*\nCopyright 2022 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport type { IDeviceLists, IToDeviceEvent } from \"../sync-accumulator.ts\";\nimport { type IClearEvent, type MatrixEvent } from \"../models/event.ts\";\nimport { type Room } from \"../models/room.ts\";\nimport { type CryptoApi, type DecryptionFailureCode, type ImportRoomKeysOpts } from \"../crypto-api/index.ts\";\nimport { type KeyBackupInfo, type KeyBackupSession } from \"../crypto-api/keybackup.ts\";\nimport { type IMegolmSessionData } from \"../@types/crypto.ts\";\n\n/**\n * Common interface for the crypto implementations\n *\n * @internal\n */\nexport interface CryptoBackend extends SyncCryptoCallbacks, CryptoApi {\n    /**\n     * Whether sendMessage in a room with unknown and unverified devices\n     * should throw an error and not send the message. This has 'Global' for\n     * symmetry with setGlobalBlacklistUnverifiedDevices but there is currently\n     * no room-level equivalent for this setting.\n     *\n     * @remarks This has no effect in Rust Crypto; it exists only for the sake of\n     * the accessors in MatrixClient.\n     */\n    globalErrorOnUnknownDevices: boolean;\n\n    /**\n     * Shut down any background processes related to crypto\n     */\n    stop(): void;\n\n    /**\n     * Encrypt an event according to the configuration of the room.\n     *\n     * @param event -  event to be sent\n     *\n     * @param room - destination room.\n     *\n     * @returns Promise which resolves when the event has been\n     *     encrypted, or null if nothing was needed\n     */\n    encryptEvent(event: MatrixEvent, room: Room): Promise<void>;\n\n    /**\n     * Decrypt a received event\n     *\n     * @returns a promise which resolves once we have finished decrypting.\n     * Rejects with an error if there is a problem decrypting the event.\n     */\n    decryptEvent(event: MatrixEvent): Promise<EventDecryptionResult>;\n\n    /**\n     * Get a backup decryptor capable of decrypting megolm session data encrypted with the given backup information.\n     * @param backupInfo - The backup information\n     * @param privKey - The private decryption key.\n     */\n    getBackupDecryptor(backupInfo: KeyBackupInfo, privKey: Uint8Array): Promise<BackupDecryptor>;\n\n    /**\n     * Import a list of room keys restored from backup\n     *\n     * @param keys - a list of session export objects\n     * @param backupVersion - the version of the backup these keys came from.\n     * @param opts - options object\n     * @returns a promise which resolves once the keys have been imported\n     */\n    importBackedUpRoomKeys(keys: IMegolmSessionData[], backupVersion: string, opts?: ImportRoomKeysOpts): Promise<void>;\n}\n\n/** The methods which crypto implementations should expose to the Sync api\n *\n * @internal\n */\nexport interface SyncCryptoCallbacks {\n    /**\n     * Called by the /sync loop whenever there are incoming to-device messages.\n     *\n     * The implementation may preprocess the received messages (eg, decrypt them) and return an\n     * updated list of messages for dispatch to the rest of the system.\n     *\n     * Note that, unlike {@link ClientEvent.ToDeviceEvent} events, this is called on the raw to-device\n     * messages, rather than the results of any decryption attempts.\n     *\n     * @param events - the received to-device messages\n     * @returns A list of preprocessed to-device messages.\n     */\n    preprocessToDeviceMessages(events: IToDeviceEvent[]): Promise<IToDeviceEvent[]>;\n\n    /**\n     * Called by the /sync loop when one time key counts and unused fallback key details are received.\n     *\n     * @param oneTimeKeysCounts - the received one time key counts\n     * @param unusedFallbackKeys - the received unused fallback keys\n     */\n    processKeyCounts(oneTimeKeysCounts?: Record<string, number>, unusedFallbackKeys?: string[]): Promise<void>;\n\n    /**\n     * Handle the notification from /sync that device lists have\n     * been changed.\n     *\n     * @param deviceLists - device_lists field from /sync\n     */\n    processDeviceLists(deviceLists: IDeviceLists): Promise<void>;\n\n    /**\n     * Called by the /sync loop whenever an m.room.encryption event is received.\n     *\n     * This is called before RoomStateEvents are emitted for any of the events in the /sync\n     * response (even if the other events technically happened first). This works around a problem\n     * if the client uses a RoomStateEvent (typically a membership event) as a trigger to send a message\n     * in a new room (or one where encryption has been newly enabled): that would otherwise leave the\n     * crypto layer confused because it expects crypto to be set up, but it has not yet been.\n     *\n     * @param room - in which the event was received\n     * @param event - encryption event to be processed\n     */\n    onCryptoEvent(room: Room, event: MatrixEvent): Promise<void>;\n\n    /**\n     * Called by the /sync loop after each /sync response is processed.\n     *\n     * Used to complete batch processing, or to initiate background processes\n     *\n     * @param syncState - information about the completed sync.\n     */\n    onSyncCompleted(syncState: OnSyncCompletedData): void;\n}\n\n/**\n * @internal\n */\nexport interface OnSyncCompletedData {\n    /**\n     * The 'next_batch' result from /sync, which will become the 'since' token for the next call to /sync.\n     */\n    nextSyncToken?: string;\n\n    /**\n     * True if we are working our way through a backlog of events after connecting.\n     */\n    catchingUp?: boolean;\n}\n\n/**\n * The result of a (successful) call to {@link CryptoBackend.decryptEvent}\n */\nexport interface EventDecryptionResult {\n    /**\n     * The plaintext payload for the event (typically containing <tt>type</tt> and <tt>content</tt> fields).\n     */\n    clearEvent: IClearEvent;\n    /**\n     * List of curve25519 keys involved in telling us about the senderCurve25519Key and claimedEd25519Key.\n     * See {@link MatrixEvent#getForwardingCurve25519KeyChain}.\n     */\n    forwardingCurve25519KeyChain?: string[];\n    /**\n     * Key owned by the sender of this event.  See {@link MatrixEvent#getSenderKey}.\n     */\n    senderCurve25519Key?: string;\n    /**\n     * ed25519 key claimed by the sender of this event. See {@link MatrixEvent#getClaimedEd25519Key}.\n     */\n    claimedEd25519Key?: string;\n    /**\n     * Whether the keys for this event have been received via an unauthenticated source (eg via key forwards, or\n     * restored from backup)\n     */\n    untrusted?: boolean;\n}\n\n/**\n * Responsible for decrypting megolm session data retrieved from a remote backup.\n * The result of {@link CryptoBackend#getBackupDecryptor}.\n */\nexport interface BackupDecryptor {\n    /**\n     * Whether keys retrieved from this backup can be trusted.\n     *\n     * Depending on the backup algorithm, keys retrieved from the backup can be trusted or not.\n     * If false, keys retrieved from the backup  must be considered unsafe (authenticity cannot be guaranteed).\n     * It could be by design (deniability) or for some technical reason (eg asymmetric encryption).\n     */\n    readonly sourceTrusted: boolean;\n\n    /**\n     *\n     * Decrypt megolm session data retrieved from backup.\n     *\n     * @param ciphertexts - a Record of sessionId to session data.\n     *\n     * @returns An array of decrypted `IMegolmSessionData`\n     */\n    decryptSessions(ciphertexts: Record<string, KeyBackupSession>): Promise<IMegolmSessionData[]>;\n\n    /**\n     * Free any resources held by this decryptor.\n     *\n     * Should be called once the decryptor is no longer needed.\n     */\n    free(): void;\n}\n\n/**\n * Exception thrown when decryption fails\n *\n * @param code - Reason code for the failure.\n *\n * @param msg - user-visible message describing the problem\n *\n * @param details - key/value pairs reported in the logs but not shown\n *   to the user.\n */\nexport class DecryptionError extends Error {\n    public readonly detailedString: string;\n\n    public constructor(\n        public readonly code: DecryptionFailureCode,\n        msg: string,\n        details?: Record<string, string | Error>,\n    ) {\n        super(msg);\n        this.name = \"DecryptionError\";\n        this.detailedString = detailedStringForDecryptionError(this, details);\n    }\n}\n\nfunction detailedStringForDecryptionError(err: DecryptionError, details?: Record<string, string | Error>): string {\n    let result = err.name + \"[msg: \" + err.message;\n\n    if (details) {\n        result +=\n            \", \" +\n            Object.keys(details)\n                .map((k) => k + \": \" + details[k])\n                .join(\", \");\n    }\n\n    result += \"]\";\n\n    return result;\n}\n","/*\nCopyright 2018 - 2022 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { type MBeaconEventContent, type MBeaconInfoContent, type MBeaconInfoEventContent } from \"./@types/beacon.ts\";\nimport { MsgType } from \"./@types/event.ts\";\nimport { M_TEXT, REFERENCE_RELATION } from \"./@types/extensible_events.ts\";\nimport { isProvided } from \"./extensible_events_v1/utilities.ts\";\nimport {\n    M_ASSET,\n    LocationAssetType,\n    M_LOCATION,\n    M_TIMESTAMP,\n    type LocationEventWireContent,\n    type MLocationEventContent,\n    type MLocationContent,\n    type MAssetContent,\n    type LegacyLocationEventContent,\n} from \"./@types/location.ts\";\nimport { type MRoomTopicEventContent, type MTopicContent, M_TOPIC } from \"./@types/topic.ts\";\nimport { type RoomMessageEventContent } from \"./@types/events.ts\";\n\n/**\n * Generates the content for a HTML Message event\n * @param body - the plaintext body of the message\n * @param htmlBody - the HTML representation of the message\n * @returns\n */\nexport function makeHtmlMessage(body: string, htmlBody: string): RoomMessageEventContent {\n    return {\n        msgtype: MsgType.Text,\n        format: \"org.matrix.custom.html\",\n        body: body,\n        formatted_body: htmlBody,\n    };\n}\n\n/**\n * Generates the content for a HTML Notice event\n * @param body - the plaintext body of the notice\n * @param htmlBody - the HTML representation of the notice\n * @returns\n */\nexport function makeHtmlNotice(body: string, htmlBody: string): RoomMessageEventContent {\n    return {\n        msgtype: MsgType.Notice,\n        format: \"org.matrix.custom.html\",\n        body: body,\n        formatted_body: htmlBody,\n    };\n}\n\n/**\n * Generates the content for a HTML Emote event\n * @param body - the plaintext body of the emote\n * @param htmlBody - the HTML representation of the emote\n * @returns\n */\nexport function makeHtmlEmote(body: string, htmlBody: string): RoomMessageEventContent {\n    return {\n        msgtype: MsgType.Emote,\n        format: \"org.matrix.custom.html\",\n        body: body,\n        formatted_body: htmlBody,\n    };\n}\n\n/**\n * Generates the content for a Plaintext Message event\n * @param body - the plaintext body of the emote\n * @returns\n */\nexport function makeTextMessage(body: string): RoomMessageEventContent {\n    return {\n        msgtype: MsgType.Text,\n        body: body,\n    };\n}\n\n/**\n * Generates the content for a Plaintext Notice event\n * @param body - the plaintext body of the notice\n * @returns\n */\nexport function makeNotice(body: string): RoomMessageEventContent {\n    return {\n        msgtype: MsgType.Notice,\n        body: body,\n    };\n}\n\n/**\n * Generates the content for a Plaintext Emote event\n * @param body - the plaintext body of the emote\n * @returns\n */\nexport function makeEmoteMessage(body: string): RoomMessageEventContent {\n    return {\n        msgtype: MsgType.Emote,\n        body: body,\n    };\n}\n\n/** Location content helpers */\n\nexport const getTextForLocationEvent = (\n    uri: string | undefined,\n    assetType: LocationAssetType,\n    timestamp?: number,\n    description?: string | null,\n): string => {\n    const date = `at ${new Date(timestamp!).toISOString()}`;\n    const assetName = assetType === LocationAssetType.Self ? \"User\" : undefined;\n    const quotedDescription = description ? `\"${description}\"` : undefined;\n\n    return [assetName, \"Location\", quotedDescription, uri, date].filter(Boolean).join(\" \");\n};\n\n/**\n * Generates the content for a Location event\n * @param uri - a geo:// uri for the location\n * @param timestamp - the timestamp when the location was correct (milliseconds since the UNIX epoch)\n * @param description - the (optional) label for this location on the map\n * @param assetType - the (optional) asset type of this location e.g. \"m.self\"\n * @param text - optional. A text for the location\n */\nexport const makeLocationContent = (\n    // this is first but optional\n    // to avoid a breaking change\n    text?: string,\n    uri?: string,\n    timestamp?: number,\n    description?: string | null,\n    assetType?: LocationAssetType,\n): LegacyLocationEventContent & MLocationEventContent => {\n    const defaultedText =\n        text ?? getTextForLocationEvent(uri, assetType || LocationAssetType.Self, timestamp, description);\n    const timestampEvent = timestamp ? { [M_TIMESTAMP.name]: timestamp } : {};\n    return {\n        msgtype: MsgType.Location,\n        body: defaultedText,\n        geo_uri: uri,\n        [M_LOCATION.name]: {\n            description,\n            uri,\n        },\n        [M_ASSET.name]: {\n            type: assetType || LocationAssetType.Self,\n        },\n        [M_TEXT.name]: defaultedText,\n        ...timestampEvent,\n    } as LegacyLocationEventContent & MLocationEventContent;\n};\n\n/**\n * Parse location event content and transform to\n * a backwards compatible modern m.location event format\n */\nexport const parseLocationEvent = (wireEventContent: LocationEventWireContent): MLocationEventContent => {\n    const location = M_LOCATION.findIn<MLocationContent>(wireEventContent);\n    const asset = M_ASSET.findIn<MAssetContent>(wireEventContent);\n    const timestamp = M_TIMESTAMP.findIn<number>(wireEventContent);\n    const text = M_TEXT.findIn<string>(wireEventContent);\n\n    const geoUri = location?.uri ?? wireEventContent?.geo_uri;\n    const description = location?.description;\n    const assetType = asset?.type ?? LocationAssetType.Self;\n    const fallbackText = text ?? wireEventContent.body;\n\n    return makeLocationContent(fallbackText, geoUri, timestamp ?? undefined, description, assetType);\n};\n\n/**\n * Topic event helpers\n */\nexport type MakeTopicContent = (topic: string | null | undefined, htmlTopic?: string) => MRoomTopicEventContent;\n\nexport const makeTopicContent: MakeTopicContent = (topic, htmlTopic) => {\n    const renderings = [];\n    if (isProvided(topic)) {\n        renderings.push({ body: topic, mimetype: \"text/plain\" });\n    }\n    if (isProvided(htmlTopic)) {\n        renderings.push({ body: htmlTopic, mimetype: \"text/html\" });\n    }\n    return { topic, [M_TOPIC.name]: renderings };\n};\n\nexport type TopicState = {\n    text?: string;\n    html?: string;\n};\n\nexport const parseTopicContent = (content: MRoomTopicEventContent): TopicState => {\n    const mtopic = M_TOPIC.findIn<MTopicContent>(content);\n    if (!Array.isArray(mtopic)) {\n        return { text: content.topic ?? undefined };\n    }\n    const text =\n        mtopic?.find((r) => !isProvided(r.mimetype) || r.mimetype === \"text/plain\")?.body ?? content.topic ?? undefined;\n    const html = mtopic?.find((r) => r.mimetype === \"text/html\")?.body;\n    return { text, html };\n};\n\n/**\n * Beacon event helpers\n */\nexport type MakeBeaconInfoContent = (\n    timeout: number,\n    isLive?: boolean,\n    description?: string,\n    assetType?: LocationAssetType,\n    timestamp?: number,\n) => MBeaconInfoEventContent;\n\nexport const makeBeaconInfoContent: MakeBeaconInfoContent = (timeout, isLive, description, assetType, timestamp) => ({\n    description,\n    timeout,\n    live: isLive,\n    [M_TIMESTAMP.name]: timestamp || Date.now(),\n    [M_ASSET.name]: {\n        type: assetType ?? LocationAssetType.Self,\n    },\n});\n\nexport type BeaconInfoState = MBeaconInfoContent & {\n    assetType?: LocationAssetType;\n    timestamp?: number;\n};\n/**\n * Flatten beacon info event content\n */\nexport const parseBeaconInfoContent = (content: MBeaconInfoEventContent): BeaconInfoState => {\n    const { description, timeout, live } = content;\n    const timestamp = M_TIMESTAMP.findIn<number>(content) ?? undefined;\n    const asset = M_ASSET.findIn<MAssetContent>(content);\n\n    return {\n        description,\n        timeout,\n        live,\n        assetType: asset?.type,\n        timestamp,\n    };\n};\n\nexport type MakeBeaconContent = (\n    uri: string,\n    timestamp: number,\n    beaconInfoEventId: string,\n    description?: string,\n) => MBeaconEventContent;\n\nexport const makeBeaconContent: MakeBeaconContent = (uri, timestamp, beaconInfoEventId, description) => ({\n    [M_LOCATION.name]: {\n        description,\n        uri,\n    },\n    [M_TIMESTAMP.name]: timestamp,\n    \"m.relates_to\": {\n        rel_type: REFERENCE_RELATION.name,\n        event_id: beaconInfoEventId,\n    },\n});\n\nexport type BeaconLocationState = Omit<MLocationContent, \"uri\"> & {\n    uri?: string; // override from MLocationContent to allow optionals\n    timestamp?: number;\n};\n\nexport const parseBeaconContent = (content: MBeaconEventContent): BeaconLocationState => {\n    const location = M_LOCATION.findIn<MLocationContent>(content);\n    const timestamp = M_TIMESTAMP.findIn<number>(content) ?? undefined;\n\n    return {\n        description: location?.description,\n        uri: location?.uri,\n        timestamp,\n    };\n};\n","/*\nCopyright 2015 - 2024 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\n// Validation based on https://spec.matrix.org/v1.12/appendices/#server-name\n// We do not use the validation described in https://spec.matrix.org/v1.12/client-server-api/#security-considerations-5\n// as it'd wrongly make all MXCs invalid due to not allowing `[].:` in server names.\nconst serverNameRegex =\n    /^(?:(?:\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3})|(?:\\[[\\dA-Fa-f:.]{2,45}])|(?:[A-Za-z\\d\\-.]{1,255}))(?::\\d{1,5})?$/;\nfunction validateServerName(serverName: string): boolean {\n    const matches = serverNameRegex.exec(serverName);\n    return matches?.[0] === serverName;\n}\n\n// Validation based on https://spec.matrix.org/v1.12/client-server-api/#security-considerations-5\nconst mediaIdRegex = /^[\\w-]+$/;\nfunction validateMediaId(mediaId: string): boolean {\n    const matches = mediaIdRegex.exec(mediaId);\n    return matches?.[0] === mediaId;\n}\n\n/**\n * Get the HTTP URL for an MXC URI.\n * @param baseUrl - The base homeserver url which has a content repo.\n * @param mxc - The mxc:// URI.\n * @param width - The desired width of the thumbnail.\n * @param height - The desired height of the thumbnail.\n * @param resizeMethod - The thumbnail resize method to use, either\n * \"crop\" or \"scale\".\n * @param allowDirectLinks - If true, return any non-mxc URLs\n * directly. Fetching such URLs will leak information about the user to\n * anyone they share a room with. If false, will return the emptry string\n * for such URLs.\n * @param allowRedirects - If true, the caller supports the URL being 307 or\n * 308 redirected to another resource upon request. If false, redirects\n * are not expected. Implied `true` when `useAuthentication` is `true`.\n * @param useAuthentication - If true, the caller supports authenticated\n * media and wants an authentication-required URL. Note that server support\n * for authenticated media will *not* be checked - it is the caller's responsibility\n * to do so before calling this function. Note also that `useAuthentication`\n * implies `allowRedirects`. Defaults to false (unauthenticated endpoints).\n * @returns The complete URL to the content, may be an empty string if the provided mxc is not valid.\n */\nexport function getHttpUriForMxc(\n    baseUrl: string,\n    mxc?: string,\n    width?: number,\n    height?: number,\n    resizeMethod?: string,\n    allowDirectLinks = false,\n    allowRedirects?: boolean,\n    useAuthentication?: boolean,\n): string {\n    if (typeof mxc !== \"string\" || !mxc) {\n        return \"\";\n    }\n    if (!mxc.startsWith(\"mxc://\")) {\n        if (allowDirectLinks) {\n            return mxc;\n        } else {\n            return \"\";\n        }\n    }\n\n    const [serverName, mediaId, ...rest] = mxc.slice(6).split(\"/\");\n    if (rest.length > 0 || !validateServerName(serverName) || !validateMediaId(mediaId)) {\n        return \"\";\n    }\n\n    if (useAuthentication) {\n        allowRedirects = true; // per docs (MSC3916 always expects redirects)\n\n        // Dev note: MSC3916 removes `allow_redirect` entirely, but\n        // for explicitness we set it here. This makes it slightly more obvious to\n        // callers, hopefully.\n    }\n\n    let prefix: string;\n    const isThumbnailRequest = !!width || !!height || !!resizeMethod;\n    const verb = isThumbnailRequest ? \"thumbnail\" : \"download\";\n    if (useAuthentication) {\n        prefix = `/_matrix/client/v1/media/${verb}`;\n    } else {\n        prefix = `/_matrix/media/v3/${verb}`;\n    }\n\n    const url = new URL(`${prefix}/${serverName}/${mediaId}`, baseUrl);\n\n    if (width) {\n        url.searchParams.set(\"width\", Math.round(width).toString());\n    }\n    if (height) {\n        url.searchParams.set(\"height\", Math.round(height).toString());\n    }\n    if (resizeMethod) {\n        url.searchParams.set(\"method\", resizeMethod);\n    }\n\n    if (typeof allowRedirects === \"boolean\") {\n        // We add this after, so we don't convert everything to a thumbnail request.\n        url.searchParams.set(\"allow_redirect\", JSON.stringify(allowRedirects));\n    }\n\n    return url.href;\n}\n","// base-x encoding / decoding\n// Copyright (c) 2018 base-x contributors\n// Copyright (c) 2014-2018 The Bitcoin Core developers (base58.cpp)\n// Distributed under the MIT software license, see the accompanying\n// file LICENSE or http://www.opensource.org/licenses/mit-license.php.\nfunction base (ALPHABET) {\n  if (ALPHABET.length >= 255) { throw new TypeError('Alphabet too long') }\n  const BASE_MAP = new Uint8Array(256)\n  for (let j = 0; j < BASE_MAP.length; j++) {\n    BASE_MAP[j] = 255\n  }\n  for (let i = 0; i < ALPHABET.length; i++) {\n    const x = ALPHABET.charAt(i)\n    const xc = x.charCodeAt(0)\n    if (BASE_MAP[xc] !== 255) { throw new TypeError(x + ' is ambiguous') }\n    BASE_MAP[xc] = i\n  }\n  const BASE = ALPHABET.length\n  const LEADER = ALPHABET.charAt(0)\n  const FACTOR = Math.log(BASE) / Math.log(256) // log(BASE) / log(256), rounded up\n  const iFACTOR = Math.log(256) / Math.log(BASE) // log(256) / log(BASE), rounded up\n  function encode (source) {\n    // eslint-disable-next-line no-empty\n    if (source instanceof Uint8Array) { } else if (ArrayBuffer.isView(source)) {\n      source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength)\n    } else if (Array.isArray(source)) {\n      source = Uint8Array.from(source)\n    }\n    if (!(source instanceof Uint8Array)) { throw new TypeError('Expected Uint8Array') }\n    if (source.length === 0) { return '' }\n    // Skip & count leading zeroes.\n    let zeroes = 0\n    let length = 0\n    let pbegin = 0\n    const pend = source.length\n    while (pbegin !== pend && source[pbegin] === 0) {\n      pbegin++\n      zeroes++\n    }\n    // Allocate enough space in big-endian base58 representation.\n    const size = ((pend - pbegin) * iFACTOR + 1) >>> 0\n    const b58 = new Uint8Array(size)\n    // Process the bytes.\n    while (pbegin !== pend) {\n      let carry = source[pbegin]\n      // Apply \"b58 = b58 * 256 + ch\".\n      let i = 0\n      for (let it1 = size - 1; (carry !== 0 || i < length) && (it1 !== -1); it1--, i++) {\n        carry += (256 * b58[it1]) >>> 0\n        b58[it1] = (carry % BASE) >>> 0\n        carry = (carry / BASE) >>> 0\n      }\n      if (carry !== 0) { throw new Error('Non-zero carry') }\n      length = i\n      pbegin++\n    }\n    // Skip leading zeroes in base58 result.\n    let it2 = size - length\n    while (it2 !== size && b58[it2] === 0) {\n      it2++\n    }\n    // Translate the result into a string.\n    let str = LEADER.repeat(zeroes)\n    for (; it2 < size; ++it2) { str += ALPHABET.charAt(b58[it2]) }\n    return str\n  }\n  function decodeUnsafe (source) {\n    if (typeof source !== 'string') { throw new TypeError('Expected String') }\n    if (source.length === 0) { return new Uint8Array() }\n    let psz = 0\n    // Skip and count leading '1's.\n    let zeroes = 0\n    let length = 0\n    while (source[psz] === LEADER) {\n      zeroes++\n      psz++\n    }\n    // Allocate enough space in big-endian base256 representation.\n    const size = (((source.length - psz) * FACTOR) + 1) >>> 0 // log(58) / log(256), rounded up.\n    const b256 = new Uint8Array(size)\n    // Process the characters.\n    while (source[psz]) {\n      // Decode character\n      let carry = BASE_MAP[source.charCodeAt(psz)]\n      // Invalid character\n      if (carry === 255) { return }\n      let i = 0\n      for (let it3 = size - 1; (carry !== 0 || i < length) && (it3 !== -1); it3--, i++) {\n        carry += (BASE * b256[it3]) >>> 0\n        b256[it3] = (carry % 256) >>> 0\n        carry = (carry / 256) >>> 0\n      }\n      if (carry !== 0) { throw new Error('Non-zero carry') }\n      length = i\n      psz++\n    }\n    // Skip leading zeroes in b256.\n    let it4 = size - length\n    while (it4 !== size && b256[it4] === 0) {\n      it4++\n    }\n    const vch = new Uint8Array(zeroes + (size - it4))\n    let j = zeroes\n    while (it4 !== size) {\n      vch[j++] = b256[it4++]\n    }\n    return vch\n  }\n  function decode (string) {\n    const buffer = decodeUnsafe(string)\n    if (buffer) { return buffer }\n    throw new Error('Non-base' + BASE + ' character')\n  }\n  return {\n    encode,\n    decodeUnsafe,\n    decode\n  }\n}\nexport default base\n","import basex from 'base-x';\nvar ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';\nexport default basex(ALPHABET);\n","/*\n * Copyright 2024 The Matrix.org Foundation C.I.C.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport bs58 from \"bs58\";\n\n// picked arbitrarily but to try & avoid clashing with any bitcoin ones\n// (which are also base58 encoded, but bitcoin's involve a lot more hashing)\nconst OLM_RECOVERY_KEY_PREFIX = [0x8b, 0x01];\nconst KEY_SIZE = 32;\n\n/**\n * Encode a recovery key using the Matrix {@link https://spec.matrix.org/v1.11/appendices/#cryptographic-key-representation | Cryptographic key representation}\n * @param key\n */\nexport function encodeRecoveryKey(key: ArrayLike<number>): string | undefined {\n    const buf = new Uint8Array(OLM_RECOVERY_KEY_PREFIX.length + key.length + 1);\n    buf.set(OLM_RECOVERY_KEY_PREFIX, 0);\n    buf.set(key, OLM_RECOVERY_KEY_PREFIX.length);\n\n    let parity = 0;\n    for (let i = 0; i < buf.length - 1; ++i) {\n        parity ^= buf[i];\n    }\n    buf[buf.length - 1] = parity;\n    const base58key = bs58.encode(buf);\n\n    return base58key.match(/.{1,4}/g)?.join(\" \");\n}\n\n/**\n * Decode a recovery key encoded with the Matrix {@link https://spec.matrix.org/v1.11/appendices/#cryptographic-key-representation | Cryptographic key representation} encoding.\n * @param recoveryKey\n */\nexport function decodeRecoveryKey(recoveryKey: string): Uint8Array {\n    const result = bs58.decode(recoveryKey.replace(/ /g, \"\"));\n\n    let parity = 0;\n    for (const b of result) {\n        parity ^= b;\n    }\n    if (parity !== 0) {\n        throw new Error(\"Incorrect parity\");\n    }\n\n    for (let i = 0; i < OLM_RECOVERY_KEY_PREFIX.length; ++i) {\n        if (result[i] !== OLM_RECOVERY_KEY_PREFIX[i]) {\n            throw new Error(\"Incorrect prefix\");\n        }\n    }\n\n    if (result.length !== OLM_RECOVERY_KEY_PREFIX.length + KEY_SIZE + 1) {\n        throw new Error(\"Incorrect length\");\n    }\n\n    return Uint8Array.from(result.slice(OLM_RECOVERY_KEY_PREFIX.length, OLM_RECOVERY_KEY_PREFIX.length + KEY_SIZE));\n}\n","/*\n * Copyright 2024 The Matrix.org Foundation C.I.C.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nconst DEFAULT_BIT_SIZE = 256;\n\n/**\n * Derive a recovery key from a passphrase and salt using PBKDF2.\n * @see https://spec.matrix.org/v1.11/client-server-api/#deriving-keys-from-passphrases\n *\n * @param passphrase - The passphrase to derive the key from\n * @param salt - The salt to use in the derivation\n * @param iterations - The number of iterations to use in the derivation\n * @param numBits - The number of bits to derive\n */\nexport async function deriveRecoveryKeyFromPassphrase(\n    passphrase: string,\n    salt: string,\n    iterations: number,\n    numBits = DEFAULT_BIT_SIZE,\n): Promise<Uint8Array> {\n    if (!globalThis.crypto.subtle || !TextEncoder) {\n        throw new Error(\"Password-based backup is not available on this platform\");\n    }\n\n    const key = await globalThis.crypto.subtle.importKey(\n        \"raw\",\n        new TextEncoder().encode(passphrase),\n        { name: \"PBKDF2\" },\n        false,\n        [\"deriveBits\"],\n    );\n\n    const keybits = await globalThis.crypto.subtle.deriveBits(\n        {\n            name: \"PBKDF2\",\n            salt: new TextEncoder().encode(salt),\n            iterations: iterations,\n            hash: \"SHA-512\",\n        },\n        key,\n        numBits,\n    );\n\n    return new Uint8Array(keybits);\n}\n","/*\n * Copyright 2024 The Matrix.org Foundation C.I.C.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * Cryptography-related events emitted by the {@link matrix.MatrixClient}.\n */\nexport enum CryptoEvent {\n    /**\n     * Fires when the trust status of a user changes.\n     * The payload is a pair (userId, userTrustLevel). The trust level is one of the values from UserVerificationStatus.\n     */\n    UserTrustStatusChanged = \"userTrustStatusChanged\",\n\n    /**\n     * Fires when the key backup status changes.\n     * The payload is a boolean indicating whether the key backup is enabled.\n     */\n    KeyBackupStatus = \"crypto.keyBackupStatus\",\n\n    /**\n     * Fires when we failed to back up the keys\n     * The payload is the error code of the error that occurred.\n     */\n    KeyBackupFailed = \"crypto.keyBackupFailed\",\n\n    /**\n     * Fires when the number of sessions that can be backed up changes.\n     * The payload is the remaining number of sessions that can be backed up.\n     */\n    KeyBackupSessionsRemaining = \"crypto.keyBackupSessionsRemaining\",\n\n    /**\n     * Fires when a new valid backup decryption key is in cache.\n     * This will happen when a secret is received from another session, from secret storage,\n     * or when a new backup is created from this session.\n     *\n     * The payload is the version of the backup for which we have the key for.\n     *\n     * This event is only fired by the rust crypto backend.\n     */\n    KeyBackupDecryptionKeyCached = \"crypto.keyBackupDecryptionKeyCached\",\n\n    /**\n     * Fires when a key verification request is received.\n     * The payload is a VerificationRequest object representing the request.\n     */\n    VerificationRequestReceived = \"crypto.verificationRequestReceived\",\n\n    /** @deprecated Use {@link DevicesUpdated} instead when using rust crypto */\n    WillUpdateDevices = \"crypto.willUpdateDevices\",\n\n    /**\n     * Fires whenever the stored devices for a user have been updated\n     * The payload is a pair (userIds, initialFetch).\n     */\n    DevicesUpdated = \"crypto.devicesUpdated\",\n\n    /**\n     * Fires when the user's cross-signing keys have changed or cross-signing\n     * has been enabled/disabled. The client can use getStoredCrossSigningForUser\n     * with the user ID of the logged in user to check if cross-signing is\n     * enabled on the account. If enabled, it can test whether the current key\n     * is trusted using with checkUserTrust with the user ID of the logged\n     * in user. The checkOwnCrossSigningTrust function may be used to reconcile\n     * the trust in the account key.\n     *\n     * The cross-signing API is currently UNSTABLE and may change without notice.\n     * @experimental\n     */\n    KeysChanged = \"crossSigning.keysChanged\",\n\n    /**\n     * Fires when data is being migrated from legacy crypto to rust crypto.\n     *\n     * The payload is a pair `(progress, total)`, where `progress` is the number of steps completed so far, and\n     * `total` is the total number of steps. When migration is complete, a final instance of the event is emitted, with\n     * `progress === total === -1`.\n     */\n    LegacyCryptoStoreMigrationProgress = \"crypto.legacyCryptoStoreMigrationProgress\",\n\n    /**\n     * Fires when a new dehydrated device is created locally.\n     *\n     * After the client calls {@link CryptoApi.startDehydration}, this event\n     * will be fired every time a new dehydrated device is created.  It may fire\n     * before `startDehydration` returns.\n     */\n    DehydratedDeviceCreated = \"dehydration.DehydratedDeviceCreated\",\n\n    /**\n     * Fires when a new dehydrated device is successfully uploaded to the server.\n     *\n     * This should fire shortly after {@link DehydratedDeviceCreated} fires. If\n     * upload is unsuccessful, this will be reported either by an error thrown\n     * by {@link CryptoApi.startDehydration} (for errors that happen before\n     * `startDehydration` returns), or by firing {@link DehydratedDeviceRotationError}\n     * (for errors that happen during regular rotation of the dehydrated device)\n     */\n    DehydratedDeviceUploaded = \"dehydration.DehydratedDeviceUploaded\",\n\n    /**\n     * Fires when rehydration has started.\n     *\n     * After the client calls {@link CryptoApi.startDehydration}, this event will\n     * fire if a dehydrated device is found and we attempt to rehydrate it.\n     */\n    RehydrationStarted = \"dehydration.RehydrationStarted\",\n\n    /**\n     * Fires during rehydration, to inform the application of rehydration progress.\n     *\n     * The payload is a pair `[roomKeyCount: number, toDeviceCount: number]`,\n     * where `roomKeyCount` is the number of room keys that have been received\n     * so far, and `toDeviceCount` is the number of to-device messages received\n     * so far (including the messages containing room keys).\n     */\n    RehydrationProgress = \"dehydration.RehydrationProgress\",\n\n    /** Fires when rehydration has completed successfully. */\n    RehydrationCompleted = \"dehydration.RehydrationCompleted\",\n\n    /** Fires when there was an error in rehydration.\n     *\n     * The payload is an error message as a string.\n     */\n    RehydrationError = \"dehydration.RehydrationError\",\n\n    /**\n     * Fires when a dehydrated device key has been cached in the local database.\n     */\n    DehydrationKeyCached = \"dehydration.DehydrationKeyCached\",\n\n    /**\n     * Fires when an error occurs during periodic rotation of the dehydrated device.\n     *\n     * The payload is an error message as a string.\n     */\n    DehydratedDeviceRotationError = \"dehydration.DehydratedDeviceRotationError\",\n}\n","/*\nCopyright 2023 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport type { SecretsBundle } from \"@matrix-org/matrix-sdk-crypto-wasm\";\nimport type { IMegolmSessionData } from \"../@types/crypto.ts\";\nimport type { ToDeviceBatch, ToDevicePayload } from \"../models/ToDeviceMessage.ts\";\nimport { type Room } from \"../models/room.ts\";\nimport { type DeviceMap } from \"../models/device.ts\";\nimport { type UIAuthCallback } from \"../interactive-auth.ts\";\nimport { type PassphraseInfo, type SecretStorageKeyDescription } from \"../secret-storage.ts\";\nimport { type VerificationRequest } from \"./verification.ts\";\nimport {\n    type BackupTrustInfo,\n    type KeyBackupCheck,\n    type KeyBackupInfo,\n    type KeyBackupRestoreOpts,\n    type KeyBackupRestoreResult,\n} from \"./keybackup.ts\";\nimport { type ISignatures } from \"../@types/signed.ts\";\nimport { type MatrixEvent } from \"../models/event.ts\";\n\n/**\n * `matrix-js-sdk/lib/crypto-api`: End-to-end encryption support.\n *\n * The most important type is {@link CryptoApi}, an instance of which can be retrieved via\n * {@link MatrixClient.getCrypto}.\n *\n * @packageDocumentation\n */\n\n/**\n * The options to start device dehydration.\n */\nexport interface StartDehydrationOpts {\n    /**\n     * Force creation of a new dehydration key, even if there is already an\n     * existing dehydration key. If `false`, and `onlyIfKeyCached` is `false`, a\n     * new key will be created if there is no existing dehydration key, whether\n     * already cached in our local storage or stored in Secret Storage.\n     *\n     * Checking for the presence of the key in Secret Storage may result in the\n     * `getSecretStorageKey` callback being called.\n     *\n     * Defaults to `false`.\n     */\n    createNewKey?: boolean;\n    /**\n     * Only start dehydration if we have a dehydration key cached in our local\n     * storage. If `true`, Secret Storage will not be checked. Defaults to\n     * `false`.\n     */\n    onlyIfKeyCached?: boolean;\n    /**\n     * Try to rehydrate a device before creating a new dehydrated device.\n     * Setting this to `false` may be useful for situations where the client is\n     * known to pre-date the dehydrated device, and so rehydration is\n     * unnecessary. Defaults to `true`.\n     */\n    rehydrate?: boolean;\n}\n\n/**\n * Public interface to the cryptography parts of the js-sdk\n *\n * @remarks Currently, this is a work-in-progress. In time, more methods will be added here.\n */\nexport interface CryptoApi {\n    /**\n     * Global override for whether the client should ever send encrypted\n     * messages to unverified devices. This provides the default for rooms which\n     * do not specify a value.\n     *\n     * If true, all unverified devices will be blacklisted by default\n     */\n    globalBlacklistUnverifiedDevices: boolean;\n\n    /**\n     * The {@link DeviceIsolationMode} mode to use.\n     */\n    setDeviceIsolationMode(isolationMode: DeviceIsolationMode): void;\n\n    /**\n     * Return the current version of the crypto module.\n     * For example: `Rust SDK ${versions.matrix_sdk_crypto} (${versions.git_sha}), Vodozemac ${versions.vodozemac}`.\n     * @returns the formatted version\n     */\n    getVersion(): string;\n\n    /**\n     * Get the public part of the device keys for the current device.\n     *\n     * @returns The public device keys.\n     */\n    getOwnDeviceKeys(): Promise<OwnDeviceKeys>;\n\n    /**\n     * Check if we believe the given room to be encrypted.\n     *\n     * This method returns true if the room has been configured with encryption. The setting is persistent, so that\n     * even if the encryption event is removed from the room state, it still returns true. This helps to guard against\n     * a downgrade attack wherein a server admin attempts to remove encryption.\n     *\n     * @returns `true` if the room with the supplied ID is encrypted. `false` if the room is not encrypted, or is unknown to\n     * us.\n     */\n    isEncryptionEnabledInRoom(roomId: string): Promise<boolean>;\n\n    /**\n     * Perform any background tasks that can be done before a message is ready to\n     * send, in order to speed up sending of the message.\n     *\n     * @param room - the room the event is in\n     */\n    prepareToEncrypt(room: Room): void;\n\n    /**\n     * Discard any existing megolm session for the given room.\n     *\n     * This will ensure that a new session is created on the next call to {@link prepareToEncrypt},\n     * or the next time a message is sent.\n     *\n     * This should not normally be necessary: it should only be used as a debugging tool if there has been a\n     * problem with encryption.\n     *\n     * @param roomId - the room to discard sessions for\n     */\n    forceDiscardSession(roomId: string): Promise<void>;\n\n    /**\n     * Get a list containing all of the room keys\n     *\n     * This should be encrypted before returning it to the user.\n     *\n     * @returns a promise which resolves to a list of\n     *    session export objects\n     */\n    exportRoomKeys(): Promise<IMegolmSessionData[]>;\n\n    /**\n     * Get a JSON list containing all of the room keys\n     *\n     * This should be encrypted before returning it to the user.\n     *\n     * @returns a promise which resolves to a JSON string\n     *    encoding a list of session export objects,\n     *    each of which is an IMegolmSessionData\n     */\n    exportRoomKeysAsJson(): Promise<string>;\n\n    /**\n     * Import a list of room keys previously exported by exportRoomKeys\n     *\n     * @param keys - a list of session export objects\n     * @param opts - options object\n     * @returns a promise which resolves once the keys have been imported\n     */\n    importRoomKeys(keys: IMegolmSessionData[], opts?: ImportRoomKeysOpts): Promise<void>;\n\n    /**\n     * Import a JSON string encoding a list of room keys previously\n     * exported by exportRoomKeysAsJson\n     *\n     * @param keys - a JSON string encoding a list of session export\n     *    objects, each of which is an IMegolmSessionData\n     * @param opts - options object\n     * @returns a promise which resolves once the keys have been imported\n     */\n    importRoomKeysAsJson(keys: string, opts?: ImportRoomKeysOpts): Promise<void>;\n\n    /**\n     * Check if the given user has published cross-signing keys.\n     *\n     * - If the user is tracked, a `/keys/query` request is made to update locally the cross signing keys.\n     * - If the user is not tracked locally and downloadUncached is set to true,\n     *   a `/keys/query` request is made to the server to retrieve the cross signing keys.\n     * - Otherwise, return false\n     *\n     * @param userId - the user ID to check. Defaults to the local user.\n     * @param downloadUncached - If true, download the device list for users whose device list we are not\n     *    currently tracking. Defaults to false, in which case `false` will be returned for such users.\n     *\n     * @returns true if the cross signing keys are available.\n     */\n    userHasCrossSigningKeys(userId?: string, downloadUncached?: boolean): Promise<boolean>;\n\n    /**\n     * Get the device information for the given list of users.\n     *\n     * For any users whose device lists are cached (due to sharing an encrypted room with the user), the\n     * cached device data is returned.\n     *\n     * If there are uncached users, and the `downloadUncached` parameter is set to `true`,\n     * a `/keys/query` request is made to the server to retrieve these devices.\n     *\n     * @param userIds - The users to fetch.\n     * @param downloadUncached - If true, download the device list for users whose device list we are not\n     *    currently tracking. Defaults to false, in which case such users will not appear at all in the result map.\n     *\n     * @returns A map `{@link DeviceMap}`.\n     */\n    getUserDeviceInfo(userIds: string[], downloadUncached?: boolean): Promise<DeviceMap>;\n\n    /**\n     * Set whether to trust other user's signatures of their devices.\n     *\n     * If false, devices will only be considered 'verified' if we have\n     * verified that device individually (effectively disabling cross-signing).\n     *\n     * `true` by default.\n     *\n     * @param val - the new value\n     */\n    setTrustCrossSignedDevices(val: boolean): void;\n\n    /**\n     * Return whether we trust other user's signatures of their devices.\n     *\n     * @see {@link CryptoApi.setTrustCrossSignedDevices}\n     *\n     * @returns `true` if we trust cross-signed devices, otherwise `false`.\n     */\n    getTrustCrossSignedDevices(): boolean;\n\n    /**\n     * Get the verification status of a given user.\n     *\n     * @param userId - The ID of the user to check.\n     *\n     */\n    getUserVerificationStatus(userId: string): Promise<UserVerificationStatus>;\n\n    /**\n     * \"Pin\" the current identity of the given user, accepting it as genuine.\n     *\n     * This is useful if the user has changed identity since we first saw them (leading to\n     * {@link UserVerificationStatus.needsUserApproval}), and we are now accepting their new identity.\n     *\n     * Throws an error if called on our own user ID, or on a user ID that we don't have an identity for.\n     */\n    pinCurrentUserIdentity(userId: string): Promise<void>;\n\n    /**\n     * Remove the requirement for this identity to be verified, and pin it.\n     *\n     * This is useful if the user was previously verified but is not anymore\n     * ({@link UserVerificationStatus.wasCrossSigningVerified}) and it is not possible to verify him again now.\n     *\n     */\n    withdrawVerificationRequirement(userId: string): Promise<void>;\n\n    /**\n     * Get the verification status of a given device.\n     *\n     * @param userId - The ID of the user whose device is to be checked.\n     * @param deviceId - The ID of the device to check\n     *\n     * @returns `null` if the device is unknown, or has not published any encryption keys (implying it does not support\n     *     encryption); otherwise the verification status of the device.\n     */\n    getDeviceVerificationStatus(userId: string, deviceId: string): Promise<DeviceVerificationStatus | null>;\n\n    /**\n     * Mark the given device as locally verified.\n     *\n     * Marking a device as locally verified has much the same effect as completing the verification dance, or receiving\n     * a cross-signing signature for it.\n     *\n     * @param userId - owner of the device\n     * @param deviceId - unique identifier for the device.\n     * @param verified - whether to mark the device as verified. Defaults to 'true'.\n     *\n     * @throws an error if the device is unknown, or has not published any encryption keys.\n     */\n    setDeviceVerified(userId: string, deviceId: string, verified?: boolean): Promise<void>;\n\n    /**\n     * Cross-sign one of our own devices.\n     *\n     * This will create a signature for the device using our self-signing key, and publish that signature.\n     * Cross-signing a device indicates, to our other devices and to other users, that we have verified that it really\n     * belongs to us.\n     *\n     * Requires that cross-signing has been set up on this device (normally by calling {@link bootstrapCrossSigning}).\n     *\n     * *Note*: Do not call this unless you have verified, somehow, that the device is genuine!\n     *\n     * @param deviceId - ID of the device to be signed.\n     */\n    crossSignDevice(deviceId: string): Promise<void>;\n\n    /**\n     * Checks whether cross signing:\n     * - is enabled on this account and trusted by this device\n     * - has private keys either cached locally or stored in secret storage\n     *\n     * If this function returns false, {@link bootstrapCrossSigning()} can be used\n     * to fix things such that it returns true. That is to say, after\n     * `bootstrapCrossSigning()` completes successfully, this function should\n     * return true.\n     *\n     * @returns True if cross-signing is ready to be used on this device\n     *\n     * @throws May throw {@link matrix.ClientStoppedError} if the `MatrixClient` is stopped before or during the call.\n     */\n    isCrossSigningReady(): Promise<boolean>;\n\n    /**\n     * Get the ID of one of the user's cross-signing keys, if both private and matching\n     * public parts of that key are available (ie. cached in the local crypto store).\n     *\n     * The public part may not be available if a `/keys/query` request has not yet been\n     * performed, or if the device that created the keys failed to publish them.\n     *\n     * If either part of the keypair is not available, this will return `null`.\n     *\n     * @param type - The type of key to get the ID of.  One of `CrossSigningKey.Master`, `CrossSigningKey.SelfSigning`,\n     *     or `CrossSigningKey.UserSigning`.  Defaults to `CrossSigningKey.Master`.\n     *\n     * @returns If cross-signing has been initialised on this device, the ID of the given key. Otherwise, null\n     */\n    getCrossSigningKeyId(type?: CrossSigningKey): Promise<string | null>;\n\n    /**\n     * Bootstrap cross-signing by creating keys if needed.\n     *\n     * If everything is already set up, then no changes are made, so this is safe to run to ensure\n     * cross-signing is ready for use.\n     *\n     * This function:\n     * - creates new cross-signing keys if they are not found locally cached nor in\n     *   secret storage (if it has been set up)\n     * - publishes the public keys to the server if they are not already published\n     * - stores the private keys in secret storage if secret storage is set up.\n     *\n     * @param opts - options object\n     */\n    bootstrapCrossSigning(opts: BootstrapCrossSigningOpts): Promise<void>;\n\n    /**\n     * Checks whether secret storage:\n     * - is enabled on this account\n     * - is storing cross-signing private keys\n     * - is storing session backup key (if enabled)\n     *\n     * If this function returns false, {@link bootstrapSecretStorage()} can be used\n     * to fix things such that it returns true. That is to say, after\n     * `bootstrapSecretStorage()` completes successfully, this function should\n     * return true.\n     *\n     * @returns True if secret storage is ready to be used on this device\n     */\n    isSecretStorageReady(): Promise<boolean>;\n\n    /**\n     * Bootstrap [secret storage](https://spec.matrix.org/v1.12/client-server-api/#storage).\n     *\n     * - If secret storage is not already set up, or {@link CreateSecretStorageOpts.setupNewSecretStorage} is set:\n     *   * Calls {@link CreateSecretStorageOpts.createSecretStorageKey} to generate a new key.\n     *   * Stores the metadata of the new key in account data and sets it as the default secret storage key.\n     *   * Calls {@link CryptoCallbacks.cacheSecretStorageKey} if provided.\n     * - Stores the private cross signing keys in the secret storage if they are known, and they are not\n     *   already stored in secret storage.\n     * - If {@link CreateSecretStorageOpts.setupNewKeyBackup} is set, calls {@link CryptoApi.resetKeyBackup}; otherwise,\n     *   stores the key backup decryption key in secret storage if it is known, and it is not\n     *   already stored in secret storage.\n     *\n     * Note that there may be multiple accesses to secret storage during the course of this call, each of which will\n     * result in a call to {@link CryptoCallbacks.getSecretStorageKey}.\n     *\n     * @param opts - Options object.\n     */\n    bootstrapSecretStorage(opts: CreateSecretStorageOpts): Promise<void>;\n\n    /**\n     * Get the status of our cross-signing keys.\n     *\n     * @returns The current status of cross-signing keys: whether we have public and private keys cached locally, and\n     * whether the private keys are in secret storage.\n     *\n     * @throws May throw {@link matrix.ClientStoppedError} if the `MatrixClient` is stopped before or during the call.\n     */\n    getCrossSigningStatus(): Promise<CrossSigningStatus>;\n\n    /**\n     * Create a recovery key (ie, a key suitable for use with server-side secret storage).\n     *\n     * The key can either be based on a user-supplied passphrase, or just created randomly.\n     *\n     * @param password - Optional passphrase string to use to derive the key,\n     *      which can later be entered by the user as an alternative to entering the\n     *      recovery key itself. If omitted, a key is generated randomly.\n     *\n     * @returns Object including recovery key and server upload parameters.\n     *      The private key should be disposed of after displaying to the use.\n     */\n    createRecoveryKeyFromPassphrase(password?: string): Promise<GeneratedSecretStorageKey>;\n\n    /**\n     * Get information about the encryption of the given event.\n     *\n     * @param event - the event to get information for\n     *\n     * @returns `null` if the event is not encrypted, or has not (yet) been successfully decrypted. Otherwise, an\n     *      object with information about the encryption of the event.\n     */\n    getEncryptionInfoForEvent(event: MatrixEvent): Promise<EventEncryptionInfo | null>;\n\n    /**\n     * Encrypts a given payload object via Olm to-device messages to a given\n     * set of devices.\n     *\n     * @param eventType - the type of the event to send.\n     * @param devices - an array of devices to encrypt the payload for.\n     * @param payload - the payload to encrypt.\n     *\n     * @returns the batch of encrypted payloads which can then be sent via {@link matrix.MatrixClient#queueToDevice}.\n     */\n    encryptToDeviceMessages(\n        eventType: string,\n        devices: { userId: string; deviceId: string }[],\n        payload: ToDevicePayload,\n    ): Promise<ToDeviceBatch>;\n\n    /**\n     * Reset the encryption of the user by going through the following steps:\n     * - Remove the dehydrated device and stop the periodic creation of dehydrated devices.\n     * - Disable backing up room keys and delete any existing backups.\n     * - Remove the default secret storage key from the account data (ie: the recovery key).\n     * - Reset the cross-signing keys.\n     * - Create a new key backup.\n     *\n     * Note that the dehydrated device will be removed, but will not be replaced\n     * and it will not schedule creating new dehydrated devices.  To do this,\n     * {@link startDehydration} should be called after a new secret storage key\n     * is created.\n     *\n     * @param authUploadDeviceSigningKeys - Callback to authenticate the upload of device signing keys.\n     *      Used when resetting the cross signing keys.\n     *      See {@link BootstrapCrossSigningOpts#authUploadDeviceSigningKeys}.\n     */\n    resetEncryption(authUploadDeviceSigningKeys: UIAuthCallback<void>): Promise<void>;\n\n    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////\n    //\n    // Device/User verification\n    //\n    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////\n\n    /**\n     * Returns to-device verification requests that are already in progress for the given user id.\n     *\n     * @param userId - the ID of the user to query\n     *\n     * @returns the VerificationRequests that are in progress\n     */\n    getVerificationRequestsToDeviceInProgress(userId: string): VerificationRequest[];\n\n    /**\n     * Finds a DM verification request that is already in progress for the given room id\n     *\n     * @param roomId - the room to use for verification\n     *\n     * @returns the VerificationRequest that is in progress, if any\n     * @deprecated prefer `userId` parameter variant.\n     */\n    findVerificationRequestDMInProgress(roomId: string): VerificationRequest | undefined;\n\n    /**\n     * Finds a DM verification request that is already in progress for the given room and user.\n     *\n     * @param roomId - the room to use for verification.\n     * @param userId - search for a verification request for the given user.\n     *\n     * @returns the VerificationRequest that is in progress, if any.\n     */\n    findVerificationRequestDMInProgress(roomId: string, userId?: string): VerificationRequest | undefined;\n\n    /**\n     * Request a key verification from another user, using a DM.\n     *\n     * @param userId - the user to request verification with.\n     * @param roomId - the room to use for verification.\n     *\n     * @returns resolves to a VerificationRequest when the request has been sent to the other party.\n     */\n    requestVerificationDM(userId: string, roomId: string): Promise<VerificationRequest>;\n\n    /**\n     * Send a verification request to our other devices.\n     *\n     * This is normally used when the current device is new, and we want to ask another of our devices to cross-sign.\n     *\n     * If an all-devices verification is already in flight, returns it. Otherwise, initiates a new one.\n     *\n     * To control the methods offered, set {@link matrix.ICreateClientOpts.verificationMethods} when creating the\n     * `MatrixClient`.\n     *\n     * @returns a VerificationRequest when the request has been sent to the other party.\n     */\n    requestOwnUserVerification(): Promise<VerificationRequest>;\n\n    /**\n     * Request an interactive verification with the given device.\n     *\n     * This is normally used on one of our own devices, when the current device is already cross-signed, and we want to\n     * validate another device.\n     *\n     * If a verification for this user/device is already in flight, returns it. Otherwise, initiates a new one.\n     *\n     * To control the methods offered, set {@link  matrix.ICreateClientOpts.verificationMethods} when creating the\n     * `MatrixClient`.\n     *\n     * @param userId - ID of the owner of the device to verify\n     * @param deviceId - ID of the device to verify\n     *\n     * @returns a VerificationRequest when the request has been sent to the other party.\n     */\n    requestDeviceVerification(userId: string, deviceId: string): Promise<VerificationRequest>;\n\n    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////\n    //\n    // Secure key backup\n    //\n    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////\n\n    /**\n     * Fetch the backup decryption key we have saved in our store.\n     *\n     * This can be used for gossiping the key to other devices.\n     *\n     * @returns the key, if any, or null\n     */\n    getSessionBackupPrivateKey(): Promise<Uint8Array | null>;\n\n    /**\n     * Store the backup decryption key.\n     *\n     * This should be called if the client has received the key from another device via secret sharing (gossiping).\n     * It is the responsability of the caller to check that the decryption key is valid for the current backup version.\n     *\n     * @param key - the backup decryption key\n     *\n     * @deprecated prefer the variant with a `version` parameter.\n     */\n    storeSessionBackupPrivateKey(key: Uint8Array): Promise<void>;\n\n    /**\n     * Store the backup decryption key.\n     *\n     * This should be called if the client has received the key from another device via secret sharing (gossiping).\n     * It is the responsability of the caller to check that the decryption key is valid for the given backup version.\n     *\n     * @param key - the backup decryption key\n     * @param version - the backup version corresponding to this decryption key\n     */\n    storeSessionBackupPrivateKey(key: Uint8Array, version: string): Promise<void>;\n\n    /**\n     * Attempt to fetch the backup decryption key from secret storage.\n     *\n     * If the key is found in secret storage, checks it against the latest backup on the server;\n     * if they match, stores the key in the crypto store by calling {@link storeSessionBackupPrivateKey},\n     * which enables automatic restore of individual keys when an Unable-to-decrypt error is encountered.\n     *\n     * If we are unable to fetch the key from secret storage, there is no backup on the server, or the key\n     * does not match, throws an exception.\n     */\n    loadSessionBackupPrivateKeyFromSecretStorage(): Promise<void>;\n\n    /**\n     * Get the current status of key backup.\n     *\n     * @returns If automatic key backups are enabled, the `version` of the active backup. Otherwise, `null`.\n     */\n    getActiveSessionBackupVersion(): Promise<string | null>;\n\n    /**\n     * Determine if a key backup can be trusted.\n     *\n     * @param info - key backup info dict from {@link CryptoApi.getKeyBackupInfo}.\n     */\n    isKeyBackupTrusted(info: KeyBackupInfo): Promise<BackupTrustInfo>;\n\n    /**\n     * Return the details of the latest backup on the server, when we last checked.\n     *\n     * This normally returns a cached value, but if we haven't yet made a request to the server, it will fire one off.\n     * It will always return the details of the active backup if key backup is enabled.\n     *\n     * Return null if there is no backup.\n     *\n     * @returns the key backup information\n     */\n    getKeyBackupInfo(): Promise<KeyBackupInfo | null>;\n\n    /**\n     * Force a re-check of the key backup and enable/disable it as appropriate.\n     *\n     * Fetches the current backup information from the server. If there is a backup, and it is trusted, starts\n     * backing up to it; otherwise, disables backups.\n     *\n     * @returns `null` if there is no backup on the server. Otherwise, data on the backup as returned by the server,\n     *   and trust information (as returned by {@link isKeyBackupTrusted}).\n     */\n    checkKeyBackupAndEnable(): Promise<KeyBackupCheck | null>;\n\n    /**\n     * Creates a new key backup version.\n     *\n     * If there are existing backups they will be replaced.\n     *\n     * If secret storage is set up, the new decryption key will be saved (the {@link CryptoCallbacks.getSecretStorageKey}\n     * callback will be called to obtain the secret storage key).\n     *\n     * The backup engine will be started using the new backup version (i.e., {@link checkKeyBackupAndEnable} is called).\n     */\n    resetKeyBackup(): Promise<void>;\n\n    /**\n     * Disables server-side key storage and deletes server-side backups.\n     *  * Deletes the current key backup version, if any (but not any previous versions).\n     *  * Disables 4S, deleting the info for the default key, the default key pointer itself and any\n     *    known 4S data (cross-signing keys and the megolm key backup key).\n     *  * Deletes any dehydrated devices.\n     *  * Sets the \"m.org.matrix.custom.backup_disabled\" account data flag to indicate that the user has disabled backups.\n     */\n    disableKeyStorage(): Promise<void>;\n\n    /**\n     * Deletes the given key backup.\n     *\n     * @param version - The backup version to delete.\n     */\n    deleteKeyBackupVersion(version: string): Promise<void>;\n\n    /**\n     * Download and restore the full key backup from the homeserver.\n     *\n     * Before calling this method, a decryption key, and the backup version to restore,\n     * must have been saved in the crypto store. This happens in one of the following ways:\n     *\n     * - When a new backup version is created with {@link CryptoApi.resetKeyBackup}, a new key is created and cached.\n     * - The key can be loaded from secret storage with {@link CryptoApi.loadSessionBackupPrivateKeyFromSecretStorage}.\n     * - The key can be received from another device via secret sharing, typically as part of the interactive verification flow.\n     * - The key and backup version can also be set explicitly via {@link CryptoApi.storeSessionBackupPrivateKey},\n     *   though this is not expected to be a common operation.\n     *\n     * Warning: the full key backup may be quite large, so this operation may take several hours to complete.\n     * Use of {@link KeyBackupRestoreOpts.progressCallback} is recommended.\n     *\n     * @param opts\n     */\n    restoreKeyBackup(opts?: KeyBackupRestoreOpts): Promise<KeyBackupRestoreResult>;\n\n    /**\n     * Restores a key backup using a passphrase.\n     * The decoded key (derived from the passphrase) is stored locally by calling {@link CryptoApi#storeSessionBackupPrivateKey}.\n     *\n     * @param passphrase - The passphrase to use to restore the key backup.\n     * @param opts\n     *\n     * @deprecated Deriving a backup key from a passphrase is not part of the matrix spec. Instead, a random key is generated and stored/shared via 4S.\n     */\n    restoreKeyBackupWithPassphrase(passphrase: string, opts?: KeyBackupRestoreOpts): Promise<KeyBackupRestoreResult>;\n\n    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////\n    //\n    // Dehydrated devices\n    //\n    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////\n\n    /**\n     * Returns whether MSC3814 dehydrated devices are supported by the crypto\n     * backend and by the server.\n     *\n     * This should be called before calling `startDehydration`, and if this\n     * returns `false`, `startDehydration` should not be called.\n     */\n    isDehydrationSupported(): Promise<boolean>;\n\n    /**\n     * Start using device dehydration.\n     *\n     * - Rehydrates a dehydrated device, if one is available and `opts.rehydrate`\n     *   is `true`.\n     * - Creates a new dehydration key, if necessary, and stores it in Secret\n     *   Storage.\n     *   - If `opts.createNewKey` is set to true, always creates a new key.\n     *   - If a dehydration key is not available, creates a new one.\n     * - Creates a new dehydrated device, and schedules periodically creating\n     *   new dehydrated devices.\n     *\n     * This function must not be called unless `isDehydrationSupported` returns\n     * `true`, and must not be called until after cross-signing and secret\n     * storage have been set up.\n     *\n     * @param opts - options for device dehydration. For backwards compatibility\n     *     with old code, a boolean can be given here, which will be treated as\n     *     the `createNewKey` option. However, this is deprecated.\n     */\n    startDehydration(opts?: StartDehydrationOpts | boolean): Promise<void>;\n\n    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////\n    //\n    // Import/export of secret keys\n    //\n    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////\n\n    /**\n     * Export secrets bundle for transmitting to another device as part of OIDC QR login\n     */\n    exportSecretsBundle?(): Promise<Awaited<ReturnType<SecretsBundle[\"to_json\"]>>>;\n\n    /**\n     * Import secrets bundle transmitted from another device.\n     * @param secrets - The secrets bundle received from the other device\n     */\n    importSecretsBundle?(secrets: Awaited<ReturnType<SecretsBundle[\"to_json\"]>>): Promise<void>;\n}\n\n/** A reason code for a failure to decrypt an event. */\nexport enum DecryptionFailureCode {\n    /** Message was encrypted with a Megolm session whose keys have not been shared with us. */\n    MEGOLM_UNKNOWN_INBOUND_SESSION_ID = \"MEGOLM_UNKNOWN_INBOUND_SESSION_ID\",\n\n    /** A special case of {@link MEGOLM_UNKNOWN_INBOUND_SESSION_ID}: the sender has told us it is withholding the key. */\n    MEGOLM_KEY_WITHHELD = \"MEGOLM_KEY_WITHHELD\",\n\n    /** A special case of {@link MEGOLM_KEY_WITHHELD}: the sender has told us it is withholding the key, because the current device is unverified. */\n    MEGOLM_KEY_WITHHELD_FOR_UNVERIFIED_DEVICE = \"MEGOLM_KEY_WITHHELD_FOR_UNVERIFIED_DEVICE\",\n\n    /** Message was encrypted with a Megolm session which has been shared with us, but in a later ratchet state. */\n    OLM_UNKNOWN_MESSAGE_INDEX = \"OLM_UNKNOWN_MESSAGE_INDEX\",\n\n    /**\n     * Message was sent before the current device was created; there is no key backup on the server, so this\n     * decryption failure is expected.\n     */\n    HISTORICAL_MESSAGE_NO_KEY_BACKUP = \"HISTORICAL_MESSAGE_NO_KEY_BACKUP\",\n\n    /**\n     * Message was sent before the current device was created; there was a key backup on the server, but we don't\n     * seem to have access to the backup. (Probably we don't have the right key.)\n     */\n    HISTORICAL_MESSAGE_BACKUP_UNCONFIGURED = \"HISTORICAL_MESSAGE_BACKUP_UNCONFIGURED\",\n\n    /**\n     * Message was sent before the current device was created; there was a (usable) key backup on the server, but we\n     * still can't decrypt. (Either the session isn't in the backup, or we just haven't gotten around to checking yet.)\n     */\n    HISTORICAL_MESSAGE_WORKING_BACKUP = \"HISTORICAL_MESSAGE_WORKING_BACKUP\",\n\n    /**\n     * Message was sent when the user was not a member of the room.\n     */\n    HISTORICAL_MESSAGE_USER_NOT_JOINED = \"HISTORICAL_MESSAGE_USER_NOT_JOINED\",\n\n    /**\n     * The sender's identity is not verified, but was previously verified.\n     */\n    SENDER_IDENTITY_PREVIOUSLY_VERIFIED = \"SENDER_IDENTITY_PREVIOUSLY_VERIFIED\",\n\n    /**\n     * The sender device is not cross-signed.  This will only be used if the\n     * device isolation mode is set to `OnlySignedDevicesIsolationMode`.\n     */\n    UNSIGNED_SENDER_DEVICE = \"UNSIGNED_SENDER_DEVICE\",\n\n    /**\n     * We weren't able to link the message back to any known device.  This will\n     * only be used if the device isolation mode is set to `OnlySignedDevicesIsolationMode`.\n     */\n    UNKNOWN_SENDER_DEVICE = \"UNKNOWN_SENDER_DEVICE\",\n\n    /** Unknown or unclassified error. */\n    UNKNOWN_ERROR = \"UNKNOWN_ERROR\",\n\n    /** @deprecated only used in legacy crypto */\n    MEGOLM_BAD_ROOM = \"MEGOLM_BAD_ROOM\",\n\n    /** @deprecated only used in legacy crypto */\n    MEGOLM_MISSING_FIELDS = \"MEGOLM_MISSING_FIELDS\",\n\n    /** @deprecated only used in legacy crypto */\n    OLM_DECRYPT_GROUP_MESSAGE_ERROR = \"OLM_DECRYPT_GROUP_MESSAGE_ERROR\",\n\n    /** @deprecated only used in legacy crypto */\n    OLM_BAD_ENCRYPTED_MESSAGE = \"OLM_BAD_ENCRYPTED_MESSAGE\",\n\n    /** @deprecated only used in legacy crypto */\n    OLM_BAD_RECIPIENT = \"OLM_BAD_RECIPIENT\",\n\n    /** @deprecated only used in legacy crypto */\n    OLM_BAD_RECIPIENT_KEY = \"OLM_BAD_RECIPIENT_KEY\",\n\n    /** @deprecated only used in legacy crypto */\n    OLM_BAD_ROOM = \"OLM_BAD_ROOM\",\n\n    /** @deprecated only used in legacy crypto */\n    OLM_BAD_SENDER_CHECK_FAILED = \"OLM_BAD_SENDER_CHECK_FAILED\",\n\n    /** @deprecated only used in legacy crypto */\n    OLM_BAD_SENDER = \"OLM_BAD_SENDER\",\n\n    /** @deprecated only used in legacy crypto */\n    OLM_FORWARDED_MESSAGE = \"OLM_FORWARDED_MESSAGE\",\n\n    /** @deprecated only used in legacy crypto */\n    OLM_MISSING_CIPHERTEXT = \"OLM_MISSING_CIPHERTEXT\",\n\n    /** @deprecated only used in legacy crypto */\n    OLM_NOT_INCLUDED_IN_RECIPIENTS = \"OLM_NOT_INCLUDED_IN_RECIPIENTS\",\n\n    /** @deprecated only used in legacy crypto */\n    UNKNOWN_ENCRYPTION_ALGORITHM = \"UNKNOWN_ENCRYPTION_ALGORITHM\",\n}\n\n/** Base {@link DeviceIsolationMode} kind. */\nexport enum DeviceIsolationModeKind {\n    AllDevicesIsolationMode,\n    OnlySignedDevicesIsolationMode,\n}\n\n/**\n * A type of {@link DeviceIsolationMode}.\n *\n * Message encryption keys are shared with all devices in the room, except in case of\n * verified user problems (see {@link errorOnVerifiedUserProblems}).\n *\n * Events from all senders are always decrypted (and should be decorated with message shields in case\n * of authenticity warnings, see {@link EventEncryptionInfo}).\n */\nexport class AllDevicesIsolationMode {\n    public readonly kind = DeviceIsolationModeKind.AllDevicesIsolationMode;\n\n    /**\n     *\n     * @param errorOnVerifiedUserProblems - Behavior when sharing keys to remote devices.\n     *\n     * If set to `true`, sharing keys will fail (i.e. message sending will fail) with an error if:\n     *   - The user was previously verified but is not anymore, or:\n     *   - A verified user has some unverified devices (not cross-signed).\n     *\n     * If `false`, the keys will be distributed as usual. In this case, the client UX should display\n     * warnings to inform the user about problematic devices/users, and stop them hitting this case.\n     */\n    public constructor(public readonly errorOnVerifiedUserProblems: boolean) {}\n}\n\n/**\n * A type of {@link DeviceIsolationMode}.\n *\n * Message encryption keys are only shared with devices that have been cross-signed by their owner.\n * Encryption will throw an error if a verified user replaces their identity.\n *\n * Events are decrypted only if they come from a cross-signed device. Other events will result in a decryption\n * failure. (To access the failure reason, see {@link MatrixEvent.decryptionFailureReason}.)\n */\nexport class OnlySignedDevicesIsolationMode {\n    public readonly kind = DeviceIsolationModeKind.OnlySignedDevicesIsolationMode;\n}\n\n/**\n * DeviceIsolationMode represents the mode of device isolation used when encrypting or decrypting messages.\n * It can be one of two types: {@link AllDevicesIsolationMode} or {@link OnlySignedDevicesIsolationMode}.\n *\n * Only supported by rust Crypto.\n */\nexport type DeviceIsolationMode = AllDevicesIsolationMode | OnlySignedDevicesIsolationMode;\n\n/**\n * Options object for `CryptoApi.bootstrapCrossSigning`.\n */\nexport interface BootstrapCrossSigningOpts {\n    /** Optional. Reset the cross-signing keys even if keys already exist. */\n    setupNewCrossSigning?: boolean;\n\n    /**\n     * An application callback to collect the authentication data for uploading the keys. If not given, the keys\n     * will not be uploaded to the server (which seems like a bad thing?).\n     */\n    authUploadDeviceSigningKeys?: UIAuthCallback<void>;\n}\n\n/**\n * Represents the ways in which we trust a user\n */\nexport class UserVerificationStatus {\n    /**\n     * Indicates if the identity has changed in a way that needs user approval.\n     *\n     * This happens if the identity has changed since we first saw it, *unless* the new identity has also been verified\n     * by our user (eg via an interactive verification).\n     *\n     * To rectify this, either:\n     *\n     *  * Conduct a verification of the new identity via {@link CryptoApi.requestVerificationDM}.\n     *  * Pin the new identity, via {@link CryptoApi.pinCurrentUserIdentity}.\n     *\n     * @returns true if the identity has changed in a way that needs user approval.\n     */\n    public readonly needsUserApproval: boolean;\n\n    public constructor(\n        private readonly crossSigningVerified: boolean,\n        private readonly crossSigningVerifiedBefore: boolean,\n        private readonly tofu: boolean,\n        needsUserApproval: boolean = false,\n    ) {\n        this.needsUserApproval = needsUserApproval;\n    }\n\n    /**\n     * @returns true if this user is verified via any means\n     */\n    public isVerified(): boolean {\n        return this.isCrossSigningVerified();\n    }\n\n    /**\n     * @returns true if this user is verified via cross signing\n     */\n    public isCrossSigningVerified(): boolean {\n        return this.crossSigningVerified;\n    }\n\n    /**\n     * @returns true if we ever verified this user before (at least for\n     * the history of verifications observed by this device).\n     */\n    public wasCrossSigningVerified(): boolean {\n        return this.crossSigningVerifiedBefore;\n    }\n\n    /**\n     * @returns true if this user's key is trusted on first use\n     *\n     * @deprecated No longer supported, with the Rust crypto stack.\n     */\n    public isTofu(): boolean {\n        return this.tofu;\n    }\n}\n\nexport class DeviceVerificationStatus {\n    /**\n     * True if this device has been signed by its owner (and that signature verified).\n     *\n     * This doesn't necessarily mean that we have verified the device, since we may not have verified the\n     * owner's cross-signing key.\n     */\n    public readonly signedByOwner: boolean;\n\n    /**\n     * True if this device has been verified via cross signing.\n     *\n     * This does *not* take into account `trustCrossSignedDevices`.\n     */\n    public readonly crossSigningVerified: boolean;\n\n    /**\n     * TODO: tofu magic wtf does this do?\n     */\n    public readonly tofu: boolean;\n\n    /**\n     * True if the device has been marked as locally verified.\n     */\n    public readonly localVerified: boolean;\n\n    /**\n     * True if the client has been configured to trust cross-signed devices via {@link CryptoApi#setTrustCrossSignedDevices}.\n     */\n    private readonly trustCrossSignedDevices: boolean;\n\n    public constructor(\n        opts: Partial<DeviceVerificationStatus> & {\n            /**\n             * True if cross-signed devices should be considered verified for {@link DeviceVerificationStatus#isVerified}.\n             */\n            trustCrossSignedDevices?: boolean;\n        },\n    ) {\n        this.signedByOwner = opts.signedByOwner ?? false;\n        this.crossSigningVerified = opts.crossSigningVerified ?? false;\n        this.tofu = opts.tofu ?? false;\n        this.localVerified = opts.localVerified ?? false;\n        this.trustCrossSignedDevices = opts.trustCrossSignedDevices ?? false;\n    }\n\n    /**\n     * Check if we should consider this device \"verified\".\n     *\n     * A device is \"verified\" if either:\n     *  * it has been manually marked as such via {@link CryptoApi.setDeviceVerified}.\n     *  * it has been cross-signed with a verified signing key, **and** the client has been configured to trust\n     *    cross-signed devices via {@link CryptoApi.setTrustCrossSignedDevices}.\n     *\n     * @returns true if this device is verified via any means.\n     */\n    public isVerified(): boolean {\n        return this.localVerified || (this.trustCrossSignedDevices && this.crossSigningVerified);\n    }\n}\n\n/**\n * Enum representing the different stages of importing room keys.\n *\n * This is the type of the `stage` property of {@link ImportRoomKeyProgressData}.\n */\nexport enum ImportRoomKeyStage {\n    /**\n     * The stage where room keys are being fetched.\n     *\n     * @see {@link ImportRoomKeyFetchProgress}.\n     */\n    Fetch = \"fetch\",\n    /**\n     * The stage where room keys are being loaded.\n     *\n     * @see {@link ImportRoomKeyLoadProgress}.\n     */\n    LoadKeys = \"load_keys\",\n}\n\n/**\n * Type representing the progress during the 'fetch' stage of the room key import process.\n *\n * @see {@link ImportRoomKeyProgressData}.\n */\nexport type ImportRoomKeyFetchProgress = {\n    /**\n     * The current stage of the import process.\n     */\n    stage: ImportRoomKeyStage.Fetch;\n};\n\n/**\n * Type representing the progress during the 'load_keys' stage of the room key import process.\n *\n * @see {@link ImportRoomKeyProgressData}.\n */\nexport type ImportRoomKeyLoadProgress = {\n    /**\n     * The current stage of the import process.\n     */\n    stage: ImportRoomKeyStage.LoadKeys;\n\n    /**\n     * The number of successfully loaded room keys so far.\n     */\n    successes: number;\n\n    /**\n     * The number of room keys that failed to load so far.\n     */\n    failures: number;\n\n    /**\n     * The total number of room keys being loaded.\n     */\n    total: number;\n};\n\n/**\n * Room key import progress report.\n * Used when calling {@link CryptoApi#importRoomKeys},\n * {@link CryptoApi#importRoomKeysAsJson} or {@link CryptoApi#restoreKeyBackup} as the parameter of\n * the progressCallback. Used to display feedback.\n */\nexport type ImportRoomKeyProgressData = ImportRoomKeyFetchProgress | ImportRoomKeyLoadProgress;\n\n/**\n * Options object for {@link CryptoApi#importRoomKeys} and\n * {@link CryptoApi#importRoomKeysAsJson}.\n */\nexport interface ImportRoomKeysOpts {\n    /** Reports ongoing progress of the import process. Can be used for feedback. */\n    progressCallback?: (stage: ImportRoomKeyProgressData) => void;\n    /** @deprecated the rust SDK will always such imported keys as untrusted */\n    untrusted?: boolean;\n    /** @deprecated not useful externally */\n    source?: string;\n}\n\n/**\n * The result of a call to {@link CryptoApi.getCrossSigningStatus}.\n */\nexport interface CrossSigningStatus {\n    /**\n     * True if the public master, self signing and user signing keys are available on this device.\n     */\n    publicKeysOnDevice: boolean;\n    /**\n     * True if the private keys are stored in the secret storage.\n     */\n    privateKeysInSecretStorage: boolean;\n    /**\n     * True if the private keys are stored locally.\n     */\n    privateKeysCachedLocally: {\n        masterKey: boolean;\n        selfSigningKey: boolean;\n        userSigningKey: boolean;\n    };\n}\n\n/**\n * Crypto callbacks provided by the application\n */\nexport interface CryptoCallbacks {\n    /**\n     * Called to retrieve a secret storage encryption key.\n     *\n     * [Server-side secret storage](https://spec.matrix.org/v1.12/client-server-api/#key-storage)\n     * is, as the name implies, a mechanism for storing secrets which should be shared between\n     * clients on the server. For example, it is typically used for storing the\n     * [key backup decryption key](https://spec.matrix.org/v1.12/client-server-api/#decryption-key)\n     * and the private [cross-signing keys](https://spec.matrix.org/v1.12/client-server-api/#cross-signing).\n     *\n     * The secret storage mechanism encrypts the secrets before uploading them to the server using a\n     * secret storage key. The schema supports multiple keys, but in practice only one tends to be used\n     * at once; this is the \"default secret storage key\" and may be known as the \"recovery key\" (or, sometimes,\n     * the \"security key\").\n     *\n     * Secret storage can be set up by calling {@link CryptoApi.bootstrapSecretStorage}. Having done so, when\n     * the crypto stack needs to access secret storage (for example, when setting up a new device, or to\n     * store newly-generated secrets), it will use this callback (`getSecretStorageKey`).\n     *\n     * Note that the secret storage key may be needed several times in quick succession: it is recommended\n     * that applications use a temporary cache to avoid prompting the user multiple times for the key. See\n     * also {@link cacheSecretStorageKey} which is called when a new key is created.\n     *\n     * The helper method {@link deriveRecoveryKeyFromPassphrase} may be useful if the secret storage key\n     * was derived from a passphrase.\n     *\n     * @param opts - An options object.\n     *\n     * @param name - the name of the *secret* (NB: not the encryption key) being stored or retrieved.\n     *    When the item is stored in account data, it will have this `type`.\n     *\n     * @returns a pair [`keyId`, `privateKey`], where `keyId` is one of the keys from the `keys` parameter,\n     *    and `privateKey` is the raw private encryption key, as appropriate for the encryption algorithm.\n     *    (For `m.secret_storage.v1.aes-hmac-sha2`, it is the input to an HKDF as defined in the\n     *    [specification](https://spec.matrix.org/v1.6/client-server-api/#msecret_storagev1aes-hmac-sha2).)\n     *\n     *    Alternatively, if none of the keys are known, may return `null` — in which case the original\n     *     operation that requires access to a secret in secret storage may fail with an exception.\n     */\n    getSecretStorageKey?: (\n        opts: {\n            /**\n             * Details of the secret storage keys required: a map from the key ID\n             * (excluding the `m.secret_storage.key.` prefix) to details of the key.\n             *\n             * When storing a secret, `keys` will contain exactly one entry.\n             *\n             * For secret retrieval, `keys` may contain several entries, and the application can return\n             * any one of the requested keys. Unless your application specifically wants to offer the\n             * user the ability to have more than one secret storage key active at a time, it is recommended\n             * to call {@link matrix.SecretStorage.ServerSideSecretStorage.getDefaultKeyId | ServerSideSecretStorage.getDefaultKeyId}\n             * to figure out which is the current default key, and to return `null` if the default key is not listed in `keys`.\n             */\n            keys: Record<string, SecretStorageKeyDescription>;\n        },\n        name: string,\n    ) => Promise<[string, Uint8Array] | null>;\n\n    /** @deprecated: unused with the Rust crypto stack. */\n    getCrossSigningKey?: (keyType: string, pubKey: string) => Promise<Uint8Array | null>;\n    /** @deprecated: unused with the Rust crypto stack. */\n    saveCrossSigningKeys?: (keys: Record<string, Uint8Array>) => void;\n    /** @deprecated: unused with the Rust crypto stack. */\n    shouldUpgradeDeviceVerifications?: (users: Record<string, any>) => Promise<string[]>;\n\n    /**\n     * Called by {@link CryptoApi.bootstrapSecretStorage} when a new default secret storage key is created.\n     *\n     * Applications can use this to (temporarily) cache the secret storage key, for later return by\n     * {@link getSecretStorageKey}.\n     *\n     * @param keyId - secret storage key id\n     * @param keyInfo - secret storage key info\n     * @param key - private key to store\n     */\n    cacheSecretStorageKey?: (keyId: string, keyInfo: SecretStorageKeyDescription, key: Uint8Array) => void;\n\n    /** @deprecated: unused with the Rust crypto stack. */\n    onSecretRequested?: (\n        userId: string,\n        deviceId: string,\n        requestId: string,\n        secretName: string,\n        deviceTrust: DeviceVerificationStatus,\n    ) => Promise<string | undefined>;\n\n    /** @deprecated: unused with the Rust crypto stack. */\n    getDehydrationKey?: (\n        keyInfo: SecretStorageKeyDescription,\n        checkFunc: (key: Uint8Array) => void,\n    ) => Promise<Uint8Array>;\n\n    /** @deprecated: unused with the Rust crypto stack. */\n    getBackupKey?: () => Promise<Uint8Array>;\n}\n\n/**\n * Parameter of {@link CryptoApi#bootstrapSecretStorage}\n */\nexport interface CreateSecretStorageOpts {\n    /**\n     * Function called to await a secret storage key creation flow.\n     * @returns Promise resolving to an object with public key metadata, encoded private\n     *     recovery key which should be disposed of after displaying to the user,\n     *     and raw private key to avoid round tripping if needed.\n     */\n    createSecretStorageKey?: () => Promise<GeneratedSecretStorageKey>;\n\n    /**\n     * The current key backup object. If passed,\n     * the passphrase and recovery key from this backup will be used.\n     * @deprecated Not used by the Rust crypto stack.\n     */\n    keyBackupInfo?: KeyBackupInfo;\n\n    /**\n     * If true, a new key backup version will be\n     * created and the private key stored in the new SSSS store. Ignored if keyBackupInfo\n     * is supplied.\n     */\n    setupNewKeyBackup?: boolean;\n\n    /**\n     * Reset even if keys already exist.\n     */\n    setupNewSecretStorage?: boolean;\n\n    /**\n     * Function called to get the user's current key backup passphrase.\n     *\n     * Should return a promise that resolves with a Uint8Array\n     * containing the key, or rejects if the key cannot be obtained.\n     *\n     * Only used when the client has existing key backup, but no secret storage.\n     *\n     * @deprecated Not used by the Rust crypto stack.\n     */\n    getKeyBackupPassphrase?: () => Promise<Uint8Array>;\n}\n\n/** Types of cross-signing key */\nexport enum CrossSigningKey {\n    Master = \"master\",\n    SelfSigning = \"self_signing\",\n    UserSigning = \"user_signing\",\n}\n\n/**\n * Information on one of the cross-signing keys.\n * @see https://spec.matrix.org/v1.7/client-server-api/#post_matrixclientv3keysdevice_signingupload\n */\nexport interface CrossSigningKeyInfo {\n    keys: { [algorithm: string]: string };\n    signatures?: ISignatures;\n    usage: string[];\n    user_id: string;\n}\n\n/**\n * Recovery key created by {@link CryptoApi#createRecoveryKeyFromPassphrase} or {@link CreateSecretStorageOpts#createSecretStorageKey}.\n */\nexport interface GeneratedSecretStorageKey {\n    keyInfo?: {\n        /** If the key was derived from a passphrase, information (algorithm, salt, etc) on that derivation. */\n        passphrase?: PassphraseInfo;\n        /** Optional human-readable name for the key, to be stored in account_data. */\n        name?: string;\n    };\n    /** The raw generated private key. */\n    privateKey: Uint8Array;\n    /** The generated key, encoded for display to the user per https://spec.matrix.org/v1.7/client-server-api/#key-representation. */\n    encodedPrivateKey?: string;\n}\n\n/**\n *  Result type of {@link CryptoApi#getEncryptionInfoForEvent}.\n */\nexport interface EventEncryptionInfo {\n    /** \"Shield\" to be shown next to this event representing its verification status */\n    shieldColour: EventShieldColour;\n\n    /**\n     * `null` if `shieldColour` is `EventShieldColour.NONE`; otherwise a reason code for the shield in `shieldColour`.\n     */\n    shieldReason: EventShieldReason | null;\n}\n\n/**\n * Types of shield to be shown for {@link EventEncryptionInfo#shieldColour}.\n */\nexport enum EventShieldColour {\n    NONE,\n    GREY,\n    RED,\n}\n\n/**\n * Reason codes for {@link EventEncryptionInfo#shieldReason}.\n */\nexport enum EventShieldReason {\n    /** An unknown reason from the crypto library (if you see this, it is a bug in matrix-js-sdk). */\n    UNKNOWN,\n\n    /** \"Encrypted by an unverified user.\" */\n    UNVERIFIED_IDENTITY,\n\n    /** \"Encrypted by a device not verified by its owner.\" */\n    UNSIGNED_DEVICE,\n\n    /** \"Encrypted by an unknown or deleted device.\" */\n    UNKNOWN_DEVICE,\n\n    /**\n     * \"The authenticity of this encrypted message can't be guaranteed on this device.\"\n     *\n     * ie: the key has been forwarded, or retrieved from an insecure backup.\n     */\n    AUTHENTICITY_NOT_GUARANTEED,\n\n    /**\n     * The (deprecated) sender_key field in the event does not match the Ed25519 key of the device that sent us the\n     * decryption keys.\n     */\n    MISMATCHED_SENDER_KEY,\n\n    /**\n     * The event was sent unencrypted in an encrypted room.\n     */\n    SENT_IN_CLEAR,\n\n    /**\n     * The sender was previously verified but changed their identity.\n     */\n    VERIFICATION_VIOLATION,\n}\n\n/** The result of a call to {@link CryptoApi.getOwnDeviceKeys} */\nexport interface OwnDeviceKeys {\n    /** Public part of the Ed25519 fingerprint key for the current device, base64 encoded. */\n    ed25519: string;\n    /** Public part of the Curve25519 identity key for the current device, base64 encoded. */\n    curve25519: string;\n}\n\nexport * from \"./verification.ts\";\nexport type * from \"./keybackup.ts\";\nexport * from \"./recovery-key.ts\";\nexport * from \"./key-passphrase.ts\";\nexport * from \"./CryptoEvent.ts\";\nexport type * from \"./CryptoEventHandlerMap.ts\";\n","/*\nCopyright 2023 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { type MatrixEvent } from \"../models/event.ts\";\nimport { type TypedEventEmitter } from \"../models/typed-event-emitter.ts\";\n\n/**\n * An incoming, or outgoing, request to verify a user or a device via cross-signing.\n */\nexport interface VerificationRequest\n    extends TypedEventEmitter<VerificationRequestEvent, VerificationRequestEventHandlerMap> {\n    /**\n     * Unique ID for this verification request.\n     *\n     * An ID isn't assigned until the first message is sent, so this may be `undefined` in the early phases.\n     */\n    get transactionId(): string | undefined;\n\n    /**\n     * For an in-room verification, the ID of the room.\n     *\n     * For to-device verifictions, `undefined`.\n     */\n    get roomId(): string | undefined;\n\n    /**\n     * True if this request was initiated by the local client.\n     *\n     * For in-room verifications, the initiator is who sent the `m.key.verification.request` event.\n     * For to-device verifications, the initiator is who sent the `m.key.verification.start` event.\n     */\n    get initiatedByMe(): boolean;\n\n    /** The user id of the other party in this request */\n    get otherUserId(): string;\n\n    /** For verifications via to-device messages: the ID of the other device. Otherwise, undefined. */\n    get otherDeviceId(): string | undefined;\n\n    /** True if the other party in this request is one of this user's own devices. */\n    get isSelfVerification(): boolean;\n\n    /** current phase of the request. */\n    get phase(): VerificationPhase;\n\n    /** True if the request has sent its initial event and needs more events to complete\n     * (ie it is in phase `Requested`, `Ready` or `Started`).\n     */\n    get pending(): boolean;\n\n    /**\n     * True if we have started the process of sending an `m.key.verification.ready` (but have not necessarily received\n     * the remote echo which causes a transition to {@link VerificationPhase.Ready}.\n     */\n    get accepting(): boolean;\n\n    /**\n     * True if we have started the process of sending an `m.key.verification.cancel` (but have not necessarily received\n     * the remote echo which causes a transition to {@link VerificationPhase.Cancelled}).\n     */\n    get declining(): boolean;\n\n    /**\n     * The remaining number of ms before the request will be automatically cancelled.\n     *\n     * `null` indicates that there is no timeout\n     */\n    get timeout(): number | null;\n\n    /** once the phase is Started (and !initiatedByMe) or Ready: common methods supported by both sides */\n    get methods(): string[];\n\n    /** the method picked in the .start event */\n    get chosenMethod(): string | null;\n\n    /**\n     * Checks whether the other party supports a given verification method.\n     * This is useful when setting up the QR code UI, as it is somewhat asymmetrical:\n     * if the other party supports SCAN_QR, we should show a QR code in the UI, and vice versa.\n     * For methods that need to be supported by both ends, use the `methods` property.\n     *\n     * @param method - the method to check\n     * @returns true if the other party said they supported the method\n     */\n    otherPartySupportsMethod(method: string): boolean;\n\n    /**\n     * Accepts the request, sending a .ready event to the other party\n     *\n     * @returns Promise which resolves when the event has been sent.\n     */\n    accept(): Promise<void>;\n\n    /**\n     * Cancels the request, sending a cancellation to the other party\n     *\n     * @param params - Details for the cancellation, including `reason` (defaults to \"User declined\"), and `code`\n     *    (defaults to `m.user`). **Deprecated**: this parameter is ignored by the Rust cryptography implementation.\n     *\n     * @returns Promise which resolves when the event has been sent.\n     */\n    cancel(params?: { reason?: string; code?: string }): Promise<void>;\n\n    /**\n     * Create a {@link Verifier} to do this verification via a particular method.\n     *\n     * If a verifier has already been created for this request, returns that verifier.\n     *\n     * This does *not* send the `m.key.verification.start` event - to do so, call {@link Verifier.verify} on the\n     * returned verifier.\n     *\n     * If no previous events have been sent, pass in `targetDevice` to set who to direct this request to.\n     *\n     * @param method - the name of the verification method to use.\n     * @param targetDevice - details of where to send the request to.\n     *\n     * @returns The verifier which will do the actual verification.\n     *\n     * @deprecated Use {@link VerificationRequest#startVerification} instead.\n     */\n    beginKeyVerification(method: string, targetDevice?: { userId?: string; deviceId?: string }): Verifier;\n\n    /**\n     * Send an `m.key.verification.start` event to start verification via a particular method.\n     *\n     * This is normally used when starting a verification via emojis (ie, `method` is set to `m.sas.v1`).\n     *\n     * @param method - the name of the verification method to use.\n     *\n     * @returns The verifier which will do the actual verification.\n     */\n    startVerification(method: string): Promise<Verifier>;\n\n    /**\n     * Start a QR code verification by providing a scanned QR code for this verification flow.\n     *\n     * Validates the QR code, and if it is ok, sends an `m.key.verification.start` event with `method` set to\n     * `m.reciprocate.v1`, to tell the other side the scan was successful.\n     *\n     * See also {@link VerificationRequest#startVerification} which can be used to start other verification methods.\n     *\n     * @param qrCodeData - the decoded QR code.\n     * @returns A verifier; call `.verify()` on it to wait for the other side to complete the verification flow.\n     */\n    scanQRCode(qrCodeData: Uint8ClampedArray): Promise<Verifier>;\n\n    /**\n     * The verifier which is doing the actual verification, once the method has been established.\n     * Only defined when the `phase` is Started.\n     */\n    get verifier(): Verifier | undefined;\n\n    /**\n     * Get the data for a QR code allowing the other device to verify this one, if it supports it.\n     *\n     * Only set after a .ready if the other party can scan a QR code, otherwise undefined.\n     *\n     * @deprecated Not supported in Rust Crypto. Use {@link VerificationRequest#generateQRCode} instead.\n     */\n    getQRCodeBytes(): Uint8ClampedArray | undefined;\n\n    /**\n     * Generate the data for a QR code allowing the other device to verify this one, if it supports it.\n     *\n     * Only returns data once `phase` is {@link VerificationPhase.Ready} and the other party can scan a QR code;\n     * otherwise returns `undefined`.\n     */\n    generateQRCode(): Promise<Uint8ClampedArray | undefined>;\n\n    /**\n     * If this request has been cancelled, the cancellation code (e.g `m.user`) which is responsible for cancelling\n     * this verification.\n     */\n    get cancellationCode(): string | null;\n\n    /**\n     * The id of the user that cancelled the request.\n     *\n     * Only defined when phase is Cancelled\n     */\n    get cancellingUserId(): string | undefined;\n}\n\n/** Events emitted by {@link VerificationRequest}. */\nexport enum VerificationRequestEvent {\n    /**\n     * Fires whenever the state of the request object has changed.\n     *\n     * There is no payload to the event.\n     */\n    Change = \"change\",\n}\n\n/**\n * Listener type map for {@link VerificationRequestEvent}s.\n *\n * @internal\n */\nexport type VerificationRequestEventHandlerMap = {\n    [VerificationRequestEvent.Change]: () => void;\n};\n\n/** The current phase of a verification request. */\nexport enum VerificationPhase {\n    /** Initial state: no event yet exchanged */\n    Unsent = 1,\n\n    /** An `m.key.verification.request` event has been sent or received */\n    Requested,\n\n    /** An `m.key.verification.ready` event has been sent or received, indicating the verification request is accepted. */\n    Ready,\n\n    /**\n     * The verification is in flight.\n     *\n     * This means that an `m.key.verification.start` event has been sent or received, choosing a verification method;\n     * however the verification has not yet completed or been cancelled.\n     */\n    Started,\n\n    /**\n     * An `m.key.verification.cancel` event has been sent or received at any time before the `done` event, cancelling\n     * the verification request\n     */\n    Cancelled,\n\n    /**\n     * The verification request is complete.\n     *\n     * Normally this means that `m.key.verification.done` events have been sent and received.\n     */\n    Done,\n}\n\n/**\n * A `Verifier` is responsible for performing the verification using a particular method, such as via QR code or SAS\n * (emojis).\n *\n * A verifier object can be created by calling `VerificationRequest.beginVerification`; one is also created\n * automatically when a `m.key.verification.start` event is received for an existing VerificationRequest.\n *\n * Once a verifier object is created, the verification can be started by calling the {@link Verifier#verify} method.\n */\nexport interface Verifier extends TypedEventEmitter<VerifierEvent, VerifierEventHandlerMap> {\n    /**\n     * Returns true if the verification has been cancelled, either by us or the other side.\n     */\n    get hasBeenCancelled(): boolean;\n\n    /**\n     * The ID of the other user in the verification process.\n     */\n    get userId(): string;\n\n    /**\n     * Start the key verification, if it has not already been started.\n     *\n     * This means sending a `m.key.verification.start` if we are the first responder, or a `m.key.verification.accept`\n     * if the other side has already sent a start event.\n     *\n     * @returns Promise which resolves when the verification has completed, or rejects if the verification is cancelled\n     *    or times out.\n     */\n    verify(): Promise<void>;\n\n    /**\n     * Cancel a verification.\n     *\n     * We will send an `m.key.verification.cancel` if the verification is still in flight. The verification promise\n     * will reject, and a {@link crypto-api.VerifierEvent.Cancel | VerifierEvent.Cancel} will be emitted.\n     *\n     * @param e - the reason for the cancellation.\n     */\n    cancel(e: Error): void;\n\n    /**\n     * Get the details for an SAS verification, if one is in progress\n     *\n     * Returns `null`, unless this verifier is for a SAS-based verification and we are waiting for the user to confirm\n     * the SAS matches.\n     */\n    getShowSasCallbacks(): ShowSasCallbacks | null;\n\n    /**\n     * Get the details for reciprocating QR code verification, if one is in progress\n     *\n     * Returns `null`, unless this verifier is for reciprocating a QR-code-based verification (ie, the other user has\n     * already scanned our QR code), and we are waiting for the user to confirm.\n     */\n    getReciprocateQrCodeCallbacks(): ShowQrCodeCallbacks | null;\n}\n\n/** Events emitted by {@link Verifier} */\nexport enum VerifierEvent {\n    /**\n     * The verification has been cancelled, by us or the other side.\n     *\n     * The payload is either an {@link Error}, or an (incoming or outgoing) {@link MatrixEvent}, depending on\n     * unspecified reasons.\n     */\n    Cancel = \"cancel\",\n\n    /**\n     * SAS data has been exchanged and should be displayed to the user.\n     *\n     * The payload is the {@link ShowSasCallbacks} object.\n     */\n    ShowSas = \"show_sas\",\n\n    /**\n     * The user should confirm if the other side has scanned our QR code.\n     *\n     * The payload is the {@link ShowQrCodeCallbacks} object.\n     */\n    ShowReciprocateQr = \"show_reciprocate_qr\",\n}\n\n/** Listener type map for {@link VerifierEvent}s. */\nexport type VerifierEventHandlerMap = {\n    [VerifierEvent.Cancel]: (e: Error | MatrixEvent) => void;\n    [VerifierEvent.ShowSas]: (sas: ShowSasCallbacks) => void;\n    [VerifierEvent.ShowReciprocateQr]: (qr: ShowQrCodeCallbacks) => void;\n};\n\n/**\n * Callbacks for user actions to confirm that the other side has scanned our QR code.\n *\n * This is exposed as the payload of a `VerifierEvent.ShowReciprocateQr` event, or can be retrieved directly from the\n * verifier as `reciprocateQREvent`.\n */\nexport interface ShowQrCodeCallbacks {\n    /** The user confirms that the verification data matches */\n    confirm(): void;\n\n    /** Cancel the verification flow */\n    cancel(): void;\n}\n\n/**\n * Callbacks for user actions while a SAS is displayed.\n *\n * This is exposed as the payload of a `VerifierEvent.ShowSas` event, or directly from the verifier as `sasEvent`.\n */\nexport interface ShowSasCallbacks {\n    /** The generated SAS to be shown to the user */\n    sas: GeneratedSas;\n\n    /** Function to call if the user confirms that the SAS matches.\n     *\n     * @returns A Promise that completes once the m.key.verification.mac is queued.\n     */\n    confirm(): Promise<void>;\n\n    /**\n     * Function to call if the user finds the SAS does not match.\n     *\n     * Sends an `m.key.verification.cancel` event with a `m.mismatched_sas` error code.\n     */\n    mismatch(): void;\n\n    /** Cancel the verification flow */\n    cancel(): void;\n}\n\n/** A generated SAS to be shown to the user, in alternative formats */\nexport interface GeneratedSas {\n    /**\n     * The SAS as three numbers between 0 and 8191.\n     *\n     * Only populated if the `decimal` SAS method was negotiated.\n     */\n    decimal?: [number, number, number];\n\n    /**\n     * The SAS as seven emojis.\n     *\n     * Only populated if the `emoji` SAS method was negotiated.\n     */\n    emoji?: EmojiMapping[];\n}\n\n/**\n * An emoji for the generated SAS. A tuple `[emoji, name]` where `emoji` is the emoji itself and `name` is the\n * English name.\n */\nexport type EmojiMapping = [emoji: string, name: string];\n\n/**\n * True if the request is in a state where it can be accepted (ie, that we're in phases {@link VerificationPhase.Unsent}\n * or {@link VerificationPhase.Requested}, and that we're not in the process of sending a `ready` or `cancel`).\n */\nexport function canAcceptVerificationRequest(req: VerificationRequest): boolean {\n    return req.phase < VerificationPhase.Ready && !req.accepting && !req.declining;\n}\n","/*\nCopyright 2021 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { type Logger } from \"../../logger.ts\";\nimport { type CrossSigningKeyInfo } from \"../../crypto-api/index.ts\";\nimport { type AESEncryptedSecretStoragePayload } from \"../../@types/AESEncryptedSecretStoragePayload.ts\";\nimport { type ISignatures } from \"../../@types/signed.ts\";\n\n/**\n * Internal module. Definitions for storage for the crypto module\n */\n\nexport interface SecretStorePrivateKeys {\n    \"m.megolm_backup.v1\": AESEncryptedSecretStoragePayload;\n}\n\n/**\n * Abstraction of things that can store data required for end-to-end encryption\n */\nexport interface CryptoStore {\n    /**\n     * Returns true if this CryptoStore has ever been initialised (ie, it might contain data).\n     *\n     * Unlike the rest of the methods in this interface, can be called before {@link CryptoStore#startup}.\n     *\n     * @internal\n     */\n    containsData(): Promise<boolean>;\n\n    /**\n     * Initialise this crypto store.\n     *\n     * Typically, this involves provisioning storage, and migrating any existing data to the current version of the\n     * storage schema where appropriate.\n     *\n     * Must be called before any of the rest of the methods in this interface.\n     */\n    startup(): Promise<CryptoStore>;\n\n    deleteAllData(): Promise<void>;\n\n    /**\n     * Get data on how much of the libolm to Rust Crypto migration has been done.\n     *\n     * @internal\n     */\n    getMigrationState(): Promise<MigrationState>;\n\n    /**\n     * Set data on how much of the libolm to Rust Crypto migration has been done.\n     *\n     * @internal\n     */\n    setMigrationState(migrationState: MigrationState): Promise<void>;\n\n    // Olm Account\n    getAccount(txn: unknown, func: (accountPickle: string | null) => void): void;\n    storeAccount(txn: unknown, accountPickle: string): void;\n    getCrossSigningKeys(txn: unknown, func: (keys: Record<string, CrossSigningKeyInfo> | null) => void): void;\n    getSecretStorePrivateKey<K extends keyof SecretStorePrivateKeys>(\n        txn: unknown,\n        func: (key: SecretStorePrivateKeys[K] | null) => void,\n        type: K,\n    ): void;\n    storeSecretStorePrivateKey<K extends keyof SecretStorePrivateKeys>(\n        txn: unknown,\n        type: K,\n        key: SecretStorePrivateKeys[K],\n    ): void;\n\n    // Olm Sessions\n    countEndToEndSessions(txn: unknown, func: (count: number) => void): void;\n    getEndToEndSession(\n        deviceKey: string,\n        sessionId: string,\n        txn: unknown,\n        func: (session: ISessionInfo | null) => void,\n    ): void;\n    getEndToEndSessions(\n        deviceKey: string,\n        txn: unknown,\n        func: (sessions: { [sessionId: string]: ISessionInfo }) => void,\n    ): void;\n\n    storeEndToEndSession(deviceKey: string, sessionId: string, sessionInfo: ISessionInfo, txn: unknown): void;\n\n    /**\n     * Get a batch of end-to-end sessions from the database.\n     *\n     * @returns A batch of Olm Sessions, or `null` if no sessions are left.\n     * @internal\n     */\n    getEndToEndSessionsBatch(): Promise<ISessionInfo[] | null>;\n\n    /**\n     * Delete a batch of end-to-end sessions from the database.\n     *\n     * Any sessions in the list which are not found are silently ignored.\n     *\n     * @internal\n     */\n    deleteEndToEndSessionsBatch(sessions: { deviceKey?: string; sessionId?: string }[]): Promise<void>;\n\n    // Inbound Group Sessions\n    getEndToEndInboundGroupSession(\n        senderCurve25519Key: string,\n        sessionId: string,\n        txn: unknown,\n        func: (groupSession: InboundGroupSessionData | null, groupSessionWithheld: IWithheld | null) => void,\n    ): void;\n    storeEndToEndInboundGroupSession(\n        senderCurve25519Key: string,\n        sessionId: string,\n        sessionData: InboundGroupSessionData,\n        txn: unknown,\n    ): void;\n\n    /**\n     * Count the number of Megolm sessions in the database.\n     *\n     * @internal\n     */\n    countEndToEndInboundGroupSessions(): Promise<number>;\n\n    /**\n     * Get a batch of Megolm sessions from the database.\n     *\n     * @returns A batch of Megolm Sessions, or `null` if no sessions are left.\n     * @internal\n     */\n    getEndToEndInboundGroupSessionsBatch(): Promise<SessionExtended[] | null>;\n\n    /**\n     * Delete a batch of Megolm sessions from the database.\n     *\n     * Any sessions in the list which are not found are silently ignored.\n     *\n     * @internal\n     */\n    deleteEndToEndInboundGroupSessionsBatch(sessions: { senderKey: string; sessionId: string }[]): Promise<void>;\n\n    // Device Data\n    getEndToEndRooms(txn: unknown, func: (rooms: Record<string, IRoomEncryption>) => void): void;\n    markSessionsNeedingBackup(sessions: ISession[], txn?: unknown): Promise<void>;\n\n    // Session key backups\n    doTxn<T>(mode: Mode, stores: Iterable<string>, func: (txn: unknown) => T, log?: Logger): Promise<T>;\n}\n\nexport type Mode = \"readonly\" | \"readwrite\";\n\n/** Data on a Megolm session */\nexport interface ISession {\n    senderKey: string;\n    sessionId: string;\n    sessionData?: InboundGroupSessionData;\n}\n\n/** Extended data on a Megolm session */\nexport interface SessionExtended extends ISession {\n    needsBackup: boolean;\n}\n\n/** Data on an Olm session */\nexport interface ISessionInfo {\n    deviceKey?: string;\n    sessionId?: string;\n    session?: string;\n    lastReceivedMessageTs?: number;\n}\n\nexport interface IDeviceData {\n    devices: {\n        [userId: string]: {\n            [deviceId: string]: IDevice;\n        };\n    };\n    trackingStatus: {\n        [userId: string]: TrackingStatus;\n    };\n    crossSigningInfo?: Record<string, ICrossSigningInfo>;\n    syncToken?: string;\n}\n\nexport interface IWithheld {\n    // eslint-disable-next-line camelcase\n    room_id: string;\n    code: string;\n    reason: string;\n}\n\n/**\n * Represents an outgoing room key request\n */\nexport interface OutgoingRoomKeyRequest {\n    /**\n     * Unique id for this request. Used for both an id within the request for later pairing with a cancellation,\n     * and for the transaction id when sending the to_device messages to our local server.\n     */\n    requestId: string;\n    requestTxnId?: string;\n    /**\n     * Transaction id for the cancellation, if any\n     */\n    cancellationTxnId?: string;\n    /**\n     * List of recipients for the request\n     */\n    recipients: IRoomKeyRequestRecipient[];\n    /**\n     * Parameters for the request\n     */\n    requestBody: IRoomKeyRequestBody;\n    /**\n     * current state of this request\n     */\n    state: RoomKeyRequestState;\n}\n\n/**\n * Keys for the `account` object store to store the migration state.\n * Values are defined in `MigrationState`.\n * @internal\n */\nexport const ACCOUNT_OBJECT_KEY_MIGRATION_STATE = \"migrationState\";\n\n/**\n * A record of which steps have been completed in the libolm to Rust Crypto migration.\n *\n * Used by {@link CryptoStore#getMigrationState} and {@link CryptoStore#setMigrationState}.\n *\n * @internal\n */\nexport enum MigrationState {\n    /** No migration steps have yet been completed. */\n    NOT_STARTED,\n\n    /** We have migrated the account data, cross-signing keys, etc. */\n    INITIAL_DATA_MIGRATED,\n\n    /** INITIAL_DATA_MIGRATED, and in addition, we have migrated all the Olm sessions. */\n    OLM_SESSIONS_MIGRATED,\n\n    /** OLM_SESSIONS_MIGRATED, and in addition, we have migrated all the Megolm sessions. */\n    MEGOLM_SESSIONS_MIGRATED,\n\n    /** MEGOLM_SESSIONS_MIGRATED, and in addition, we have migrated all the room settings. */\n    ROOM_SETTINGS_MIGRATED,\n\n    /** ROOM_SETTINGS_MIGRATED, and in addition, we have done the first own keys query in order to\n     * load the public part of the keys that have been migrated */\n    INITIAL_OWN_KEY_QUERY_DONE,\n}\n\n/**\n * The size of batches to be returned by {@link CryptoStore#getEndToEndSessionsBatch} and\n * {@link CryptoStore#getEndToEndInboundGroupSessionsBatch}.\n */\nexport const SESSION_BATCH_SIZE = 50;\n\nexport interface InboundGroupSessionData {\n    room_id: string; // eslint-disable-line camelcase\n    /** pickled Olm.InboundGroupSession */\n    session: string;\n    keysClaimed?: Record<string, string>;\n    /** Devices involved in forwarding this session to us (normally empty). */\n    forwardingCurve25519KeyChain: string[];\n    /** whether this session is untrusted. */\n    untrusted?: boolean;\n    /** whether this session exists during the room being set to shared history. */\n    sharedHistory?: boolean;\n}\n\nexport interface ICrossSigningInfo {\n    keys: Record<string, CrossSigningKeyInfo>;\n    firstUse: boolean;\n    crossSigningVerifiedBefore: boolean;\n}\n\n/* eslint-disable camelcase */\nexport interface IRoomEncryption {\n    algorithm: string;\n    rotation_period_ms?: number;\n    rotation_period_msgs?: number;\n}\n/* eslint-enable camelcase */\n\nexport enum TrackingStatus {\n    NotTracked,\n    PendingDownload,\n    DownloadInProgress,\n    UpToDate,\n}\n\n/**\n *  possible states for a room key request\n *\n * The state machine looks like:\n * ```\n *\n *     |         (cancellation sent)\n *     | .-------------------------------------------------.\n *     | |                                                 |\n *     V V       (cancellation requested)                  |\n *   UNSENT  -----------------------------+                |\n *     |                                  |                |\n *     |                                  |                |\n *     | (send successful)                |  CANCELLATION_PENDING_AND_WILL_RESEND\n *     V                                  |                Λ\n *    SENT                                |                |\n *     |--------------------------------  |  --------------'\n *     |                                  |  (cancellation requested with intent\n *     |                                  |   to resend the original request)\n *     |                                  |\n *     | (cancellation requested)         |\n *     V                                  |\n * CANCELLATION_PENDING                   |\n *     |                                  |\n *     | (cancellation sent)              |\n *     V                                  |\n * (deleted)  <---------------------------+\n * ```\n */\nexport enum RoomKeyRequestState {\n    /** request not yet sent */\n    Unsent,\n    /** request sent, awaiting reply */\n    Sent,\n    /** reply received, cancellation not yet sent */\n    CancellationPending,\n    /**\n     * Cancellation not yet sent and will transition to UNSENT instead of\n     * being deleted once the cancellation has been sent.\n     */\n    CancellationPendingAndWillResend,\n}\n\n/* eslint-disable camelcase */\ninterface IRoomKey {\n    room_id: string;\n    algorithm: string;\n}\n\n/**\n * The parameters of a room key request. The details of the request may\n * vary with the crypto algorithm, but the management and storage layers for\n * outgoing requests expect it to have 'room_id' and 'session_id' properties.\n */\nexport interface IRoomKeyRequestBody extends IRoomKey {\n    session_id: string;\n    sender_key: string;\n}\n\n/* eslint-enable camelcase */\n\nexport interface IRoomKeyRequestRecipient {\n    userId: string;\n    deviceId: string;\n}\n\ninterface IDevice {\n    keys: Record<string, string>;\n    algorithms: string[];\n    verified: DeviceVerification;\n    known: boolean;\n    unsigned?: Record<string, any>;\n    signatures?: ISignatures;\n}\n\n/** State of the verification of the device. */\nexport enum DeviceVerification {\n    Blocked = -1,\n    Unverified = 0,\n    Verified = 1,\n}\n","/*\nCopyright 2017 - 2021 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { type Logger, logger } from \"../../logger.ts\";\nimport {\n    type CryptoStore,\n    type IDeviceData,\n    type ISession,\n    type SessionExtended,\n    type ISessionInfo,\n    type IWithheld,\n    MigrationState,\n    type Mode,\n    type SecretStorePrivateKeys,\n    SESSION_BATCH_SIZE,\n    ACCOUNT_OBJECT_KEY_MIGRATION_STATE,\n    type InboundGroupSessionData,\n    type IRoomEncryption,\n} from \"./base.ts\";\nimport { IndexedDBCryptoStore } from \"./indexeddb-crypto-store.ts\";\nimport { type CrossSigningKeyInfo } from \"../../crypto-api/index.ts\";\n\nconst PROFILE_TRANSACTIONS = false;\n\n/**\n * Implementation of a CryptoStore which is backed by an existing\n * IndexedDB connection. Generally you want IndexedDBCryptoStore\n * which connects to the database and defers to one of these.\n *\n * @internal\n */\nexport class Backend implements CryptoStore {\n    private nextTxnId = 0;\n\n    /**\n     */\n    public constructor(private db: IDBDatabase) {\n        // make sure we close the db on `onversionchange` - otherwise\n        // attempts to delete the database will block (and subsequent\n        // attempts to re-create it will also block).\n        db.onversionchange = (): void => {\n            logger.log(`versionchange for indexeddb ${this.db.name}: closing`);\n            db.close();\n        };\n    }\n\n    public async containsData(): Promise<boolean> {\n        throw Error(\"Not implemented for Backend\");\n    }\n\n    public async startup(): Promise<CryptoStore> {\n        // No work to do, as the startup is done by the caller (e.g IndexedDBCryptoStore)\n        // by passing us a ready IDBDatabase instance\n        return this;\n    }\n\n    public async deleteAllData(): Promise<void> {\n        throw Error(\"This is not implemented, call IDBFactory::deleteDatabase(dbName) instead.\");\n    }\n\n    /**\n     * Get data on how much of the libolm to Rust Crypto migration has been done.\n     *\n     * Implementation of {@link CryptoStore.getMigrationState}.\n     */\n    public async getMigrationState(): Promise<MigrationState> {\n        let migrationState = MigrationState.NOT_STARTED;\n        await this.doTxn(\"readonly\", [IndexedDBCryptoStore.STORE_ACCOUNT], (txn) => {\n            const objectStore = txn.objectStore(IndexedDBCryptoStore.STORE_ACCOUNT);\n            const getReq = objectStore.get(ACCOUNT_OBJECT_KEY_MIGRATION_STATE);\n            getReq.onsuccess = (): void => {\n                migrationState = getReq.result ?? MigrationState.NOT_STARTED;\n            };\n        });\n        return migrationState;\n    }\n\n    /**\n     * Set data on how much of the libolm to Rust Crypto migration has been done.\n     *\n     * Implementation of {@link CryptoStore.setMigrationState}.\n     */\n    public async setMigrationState(migrationState: MigrationState): Promise<void> {\n        await this.doTxn(\"readwrite\", [IndexedDBCryptoStore.STORE_ACCOUNT], (txn) => {\n            const objectStore = txn.objectStore(IndexedDBCryptoStore.STORE_ACCOUNT);\n            objectStore.put(migrationState, ACCOUNT_OBJECT_KEY_MIGRATION_STATE);\n        });\n    }\n\n    // Olm Account\n\n    public getAccount(txn: IDBTransaction, func: (accountPickle: string | null) => void): void {\n        const objectStore = txn.objectStore(\"account\");\n        const getReq = objectStore.get(\"-\");\n        getReq.onsuccess = function (): void {\n            try {\n                func(getReq.result || null);\n            } catch (e) {\n                abortWithException(txn, <Error>e);\n            }\n        };\n    }\n\n    public storeAccount(txn: IDBTransaction, accountPickle: string): void {\n        const objectStore = txn.objectStore(\"account\");\n        objectStore.put(accountPickle, \"-\");\n    }\n\n    public getCrossSigningKeys(\n        txn: IDBTransaction,\n        func: (keys: Record<string, CrossSigningKeyInfo> | null) => void,\n    ): void {\n        const objectStore = txn.objectStore(\"account\");\n        const getReq = objectStore.get(\"crossSigningKeys\");\n        getReq.onsuccess = function (): void {\n            try {\n                func(getReq.result || null);\n            } catch (e) {\n                abortWithException(txn, <Error>e);\n            }\n        };\n    }\n\n    public getSecretStorePrivateKey<K extends keyof SecretStorePrivateKeys>(\n        txn: IDBTransaction,\n        func: (key: SecretStorePrivateKeys[K] | null) => void,\n        type: K,\n    ): void {\n        const objectStore = txn.objectStore(\"account\");\n        const getReq = objectStore.get(`ssss_cache:${type}`);\n        getReq.onsuccess = function (): void {\n            try {\n                func(getReq.result || null);\n            } catch (e) {\n                abortWithException(txn, <Error>e);\n            }\n        };\n    }\n\n    public storeSecretStorePrivateKey<K extends keyof SecretStorePrivateKeys>(\n        txn: IDBTransaction,\n        type: K,\n        key: SecretStorePrivateKeys[K],\n    ): void {\n        const objectStore = txn.objectStore(\"account\");\n        objectStore.put(key, `ssss_cache:${type}`);\n    }\n\n    // Olm Sessions\n\n    public countEndToEndSessions(txn: IDBTransaction, func: (count: number) => void): void {\n        const objectStore = txn.objectStore(\"sessions\");\n        const countReq = objectStore.count();\n        countReq.onsuccess = function (): void {\n            try {\n                func(countReq.result);\n            } catch (e) {\n                abortWithException(txn, <Error>e);\n            }\n        };\n    }\n\n    public getEndToEndSessions(\n        deviceKey: string,\n        txn: IDBTransaction,\n        func: (sessions: { [sessionId: string]: ISessionInfo }) => void,\n    ): void {\n        const objectStore = txn.objectStore(\"sessions\");\n        const idx = objectStore.index(\"deviceKey\");\n        const getReq = idx.openCursor(deviceKey);\n        const results: Parameters<Parameters<Backend[\"getEndToEndSessions\"]>[2]>[0] = {};\n        getReq.onsuccess = function (): void {\n            const cursor = getReq.result;\n            if (cursor) {\n                results[cursor.value.sessionId] = {\n                    session: cursor.value.session,\n                    lastReceivedMessageTs: cursor.value.lastReceivedMessageTs,\n                };\n                cursor.continue();\n            } else {\n                try {\n                    func(results);\n                } catch (e) {\n                    abortWithException(txn, <Error>e);\n                }\n            }\n        };\n    }\n\n    public getEndToEndSession(\n        deviceKey: string,\n        sessionId: string,\n        txn: IDBTransaction,\n        func: (session: ISessionInfo | null) => void,\n    ): void {\n        const objectStore = txn.objectStore(\"sessions\");\n        const getReq = objectStore.get([deviceKey, sessionId]);\n        getReq.onsuccess = function (): void {\n            try {\n                if (getReq.result) {\n                    func({\n                        session: getReq.result.session,\n                        lastReceivedMessageTs: getReq.result.lastReceivedMessageTs,\n                    });\n                } else {\n                    func(null);\n                }\n            } catch (e) {\n                abortWithException(txn, <Error>e);\n            }\n        };\n    }\n\n    public storeEndToEndSession(\n        deviceKey: string,\n        sessionId: string,\n        sessionInfo: ISessionInfo,\n        txn: IDBTransaction,\n    ): void {\n        const objectStore = txn.objectStore(\"sessions\");\n        objectStore.put({\n            deviceKey,\n            sessionId,\n            session: sessionInfo.session,\n            lastReceivedMessageTs: sessionInfo.lastReceivedMessageTs,\n        });\n    }\n\n    /**\n     * Fetch a batch of Olm sessions from the database.\n     *\n     * Implementation of {@link CryptoStore.getEndToEndSessionsBatch}.\n     */\n    public async getEndToEndSessionsBatch(): Promise<null | ISessionInfo[]> {\n        const result: ISessionInfo[] = [];\n        await this.doTxn(\"readonly\", [IndexedDBCryptoStore.STORE_SESSIONS], (txn) => {\n            const objectStore = txn.objectStore(IndexedDBCryptoStore.STORE_SESSIONS);\n            const getReq = objectStore.openCursor();\n            getReq.onsuccess = function (): void {\n                try {\n                    const cursor = getReq.result;\n                    if (cursor) {\n                        result.push(cursor.value);\n                        if (result.length < SESSION_BATCH_SIZE) {\n                            cursor.continue();\n                        }\n                    }\n                } catch (e) {\n                    abortWithException(txn, <Error>e);\n                }\n            };\n        });\n\n        if (result.length === 0) {\n            // No sessions left.\n            return null;\n        }\n\n        return result;\n    }\n\n    /**\n     * Delete a batch of Olm sessions from the database.\n     *\n     * Implementation of {@link CryptoStore.deleteEndToEndSessionsBatch}.\n     *\n     * @internal\n     */\n    public async deleteEndToEndSessionsBatch(sessions: { deviceKey: string; sessionId: string }[]): Promise<void> {\n        await this.doTxn(\"readwrite\", [IndexedDBCryptoStore.STORE_SESSIONS], async (txn) => {\n            try {\n                const objectStore = txn.objectStore(IndexedDBCryptoStore.STORE_SESSIONS);\n                for (const { deviceKey, sessionId } of sessions) {\n                    const req = objectStore.delete([deviceKey, sessionId]);\n                    await new Promise((resolve) => {\n                        req.onsuccess = resolve;\n                    });\n                }\n            } catch (e) {\n                abortWithException(txn, <Error>e);\n            }\n        });\n    }\n\n    // Inbound group sessions\n\n    public getEndToEndInboundGroupSession(\n        senderCurve25519Key: string,\n        sessionId: string,\n        txn: IDBTransaction,\n        func: (groupSession: InboundGroupSessionData | null, groupSessionWithheld: IWithheld | null) => void,\n    ): void {\n        let session: InboundGroupSessionData | null | boolean = false;\n        let withheld: IWithheld | null | boolean = false;\n        const objectStore = txn.objectStore(\"inbound_group_sessions\");\n        const getReq = objectStore.get([senderCurve25519Key, sessionId]);\n        getReq.onsuccess = function (): void {\n            try {\n                if (getReq.result) {\n                    session = getReq.result.session;\n                } else {\n                    session = null;\n                }\n                if (withheld !== false) {\n                    func(session as InboundGroupSessionData, withheld as IWithheld);\n                }\n            } catch (e) {\n                abortWithException(txn, <Error>e);\n            }\n        };\n\n        const withheldObjectStore = txn.objectStore(\"inbound_group_sessions_withheld\");\n        const withheldGetReq = withheldObjectStore.get([senderCurve25519Key, sessionId]);\n        withheldGetReq.onsuccess = function (): void {\n            try {\n                if (withheldGetReq.result) {\n                    withheld = withheldGetReq.result.session;\n                } else {\n                    withheld = null;\n                }\n                if (session !== false) {\n                    func(session as InboundGroupSessionData, withheld as IWithheld);\n                }\n            } catch (e) {\n                abortWithException(txn, <Error>e);\n            }\n        };\n    }\n\n    public storeEndToEndInboundGroupSession(\n        senderCurve25519Key: string,\n        sessionId: string,\n        sessionData: InboundGroupSessionData,\n        txn: IDBTransaction,\n    ): void {\n        const objectStore = txn.objectStore(\"inbound_group_sessions\");\n        objectStore.put({\n            senderCurve25519Key,\n            sessionId,\n            session: sessionData,\n        });\n    }\n\n    /**\n     * Count the number of Megolm sessions in the database.\n     *\n     * Implementation of {@link CryptoStore.countEndToEndInboundGroupSessions}.\n     *\n     * @internal\n     */\n    public async countEndToEndInboundGroupSessions(): Promise<number> {\n        let result = 0;\n        await this.doTxn(\"readonly\", [IndexedDBCryptoStore.STORE_INBOUND_GROUP_SESSIONS], (txn) => {\n            const sessionStore = txn.objectStore(IndexedDBCryptoStore.STORE_INBOUND_GROUP_SESSIONS);\n            const countReq = sessionStore.count();\n            countReq.onsuccess = (): void => {\n                result = countReq.result;\n            };\n        });\n        return result;\n    }\n\n    /**\n     * Fetch a batch of Megolm sessions from the database.\n     *\n     * Implementation of {@link CryptoStore.getEndToEndInboundGroupSessionsBatch}.\n     */\n    public async getEndToEndInboundGroupSessionsBatch(): Promise<null | SessionExtended[]> {\n        const result: SessionExtended[] = [];\n        await this.doTxn(\n            \"readonly\",\n            [IndexedDBCryptoStore.STORE_INBOUND_GROUP_SESSIONS, IndexedDBCryptoStore.STORE_BACKUP],\n            (txn) => {\n                const sessionStore = txn.objectStore(IndexedDBCryptoStore.STORE_INBOUND_GROUP_SESSIONS);\n                const backupStore = txn.objectStore(IndexedDBCryptoStore.STORE_BACKUP);\n\n                const getReq = sessionStore.openCursor();\n                getReq.onsuccess = function (): void {\n                    try {\n                        const cursor = getReq.result;\n                        if (cursor) {\n                            const backupGetReq = backupStore.get(cursor.key);\n                            backupGetReq.onsuccess = (): void => {\n                                result.push({\n                                    senderKey: cursor.value.senderCurve25519Key,\n                                    sessionId: cursor.value.sessionId,\n                                    sessionData: cursor.value.session,\n                                    needsBackup: backupGetReq.result !== undefined,\n                                });\n                                if (result.length < SESSION_BATCH_SIZE) {\n                                    cursor.continue();\n                                }\n                            };\n                        }\n                    } catch (e) {\n                        abortWithException(txn, <Error>e);\n                    }\n                };\n            },\n        );\n\n        if (result.length === 0) {\n            // No sessions left.\n            return null;\n        }\n\n        return result;\n    }\n\n    /**\n     * Delete a batch of Megolm sessions from the database.\n     *\n     * Implementation of {@link CryptoStore.deleteEndToEndInboundGroupSessionsBatch}.\n     *\n     * @internal\n     */\n    public async deleteEndToEndInboundGroupSessionsBatch(\n        sessions: { senderKey: string; sessionId: string }[],\n    ): Promise<void> {\n        await this.doTxn(\"readwrite\", [IndexedDBCryptoStore.STORE_INBOUND_GROUP_SESSIONS], async (txn) => {\n            try {\n                const objectStore = txn.objectStore(IndexedDBCryptoStore.STORE_INBOUND_GROUP_SESSIONS);\n                for (const { senderKey, sessionId } of sessions) {\n                    const req = objectStore.delete([senderKey, sessionId]);\n                    await new Promise((resolve) => {\n                        req.onsuccess = resolve;\n                    });\n                }\n            } catch (e) {\n                abortWithException(txn, <Error>e);\n            }\n        });\n    }\n\n    public getEndToEndDeviceData(txn: IDBTransaction, func: (deviceData: IDeviceData | null) => void): void {\n        const objectStore = txn.objectStore(\"device_data\");\n        const getReq = objectStore.get(\"-\");\n        getReq.onsuccess = function (): void {\n            try {\n                func(getReq.result || null);\n            } catch (e) {\n                abortWithException(txn, <Error>e);\n            }\n        };\n    }\n\n    public getEndToEndRooms(txn: IDBTransaction, func: (rooms: Record<string, IRoomEncryption>) => void): void {\n        const rooms: Parameters<Parameters<Backend[\"getEndToEndRooms\"]>[1]>[0] = {};\n        const objectStore = txn.objectStore(\"rooms\");\n        const getReq = objectStore.openCursor();\n        getReq.onsuccess = function (): void {\n            const cursor = getReq.result;\n            if (cursor) {\n                rooms[cursor.key as string] = cursor.value;\n                cursor.continue();\n            } else {\n                try {\n                    func(rooms);\n                } catch (e) {\n                    abortWithException(txn, <Error>e);\n                }\n            }\n        };\n    }\n\n    public async markSessionsNeedingBackup(sessions: ISession[], txn?: IDBTransaction): Promise<void> {\n        if (!txn) {\n            txn = this.db.transaction(\"sessions_needing_backup\", \"readwrite\");\n        }\n        const objectStore = txn.objectStore(\"sessions_needing_backup\");\n        await Promise.all(\n            sessions.map((session) => {\n                return new Promise((resolve, reject) => {\n                    const req = objectStore.put({\n                        senderCurve25519Key: session.senderKey,\n                        sessionId: session.sessionId,\n                    });\n                    req.onsuccess = resolve;\n                    req.onerror = reject;\n                });\n            }),\n        );\n    }\n\n    public doTxn<T>(\n        mode: Mode,\n        stores: string | string[],\n        func: (txn: IDBTransaction) => T,\n        log: Logger = logger,\n    ): Promise<T> {\n        let startTime: number;\n        let description: string;\n        if (PROFILE_TRANSACTIONS) {\n            const txnId = this.nextTxnId++;\n            startTime = Date.now();\n            description = `${mode} crypto store transaction ${txnId} in ${stores}`;\n            log.debug(`Starting ${description}`);\n        }\n        const txn = this.db.transaction(stores, mode);\n        const promise = promiseifyTxn(txn);\n        const result = func(txn);\n        if (PROFILE_TRANSACTIONS) {\n            promise.then(\n                () => {\n                    const elapsedTime = Date.now() - startTime;\n                    log.debug(`Finished ${description}, took ${elapsedTime} ms`);\n                },\n                () => {\n                    const elapsedTime = Date.now() - startTime;\n                    log.error(`Failed ${description}, took ${elapsedTime} ms`);\n                },\n            );\n        }\n        return promise.then(() => {\n            return result;\n        });\n    }\n}\n\ntype DbMigration = (db: IDBDatabase) => void;\nconst DB_MIGRATIONS: DbMigration[] = [\n    (db): void => {\n        createDatabase(db);\n    },\n    (db): void => {\n        db.createObjectStore(\"account\");\n    },\n    (db): void => {\n        const sessionsStore = db.createObjectStore(\"sessions\", {\n            keyPath: [\"deviceKey\", \"sessionId\"],\n        });\n        sessionsStore.createIndex(\"deviceKey\", \"deviceKey\");\n    },\n    (db): void => {\n        db.createObjectStore(\"inbound_group_sessions\", {\n            keyPath: [\"senderCurve25519Key\", \"sessionId\"],\n        });\n    },\n    (db): void => {\n        db.createObjectStore(\"device_data\");\n    },\n    (db): void => {\n        db.createObjectStore(\"rooms\");\n    },\n    (db): void => {\n        db.createObjectStore(\"sessions_needing_backup\", {\n            keyPath: [\"senderCurve25519Key\", \"sessionId\"],\n        });\n    },\n    (db): void => {\n        db.createObjectStore(\"inbound_group_sessions_withheld\", {\n            keyPath: [\"senderCurve25519Key\", \"sessionId\"],\n        });\n    },\n    (db): void => {\n        const problemsStore = db.createObjectStore(\"session_problems\", {\n            keyPath: [\"deviceKey\", \"time\"],\n        });\n        problemsStore.createIndex(\"deviceKey\", \"deviceKey\");\n\n        db.createObjectStore(\"notified_error_devices\", {\n            keyPath: [\"userId\", \"deviceId\"],\n        });\n    },\n    (db): void => {\n        db.createObjectStore(\"shared_history_inbound_group_sessions\", {\n            keyPath: [\"roomId\"],\n        });\n    },\n    (db): void => {\n        db.createObjectStore(\"parked_shared_history\", {\n            keyPath: [\"roomId\"],\n        });\n    },\n    // Expand as needed.\n];\nexport const VERSION = DB_MIGRATIONS.length;\n\nexport function upgradeDatabase(db: IDBDatabase, oldVersion: number): void {\n    logger.log(`Upgrading IndexedDBCryptoStore from version ${oldVersion}` + ` to ${VERSION}`);\n    DB_MIGRATIONS.forEach((migration, index) => {\n        if (oldVersion <= index) migration(db);\n    });\n}\n\nfunction createDatabase(db: IDBDatabase): void {\n    const outgoingRoomKeyRequestsStore = db.createObjectStore(\"outgoingRoomKeyRequests\", { keyPath: \"requestId\" });\n\n    // we assume that the RoomKeyRequestBody will have room_id and session_id\n    // properties, to make the index efficient.\n    outgoingRoomKeyRequestsStore.createIndex(\"session\", [\"requestBody.room_id\", \"requestBody.session_id\"]);\n\n    outgoingRoomKeyRequestsStore.createIndex(\"state\", \"state\");\n}\n\ninterface IWrappedIDBTransaction extends IDBTransaction {\n    _mx_abortexception: Error; // eslint-disable-line camelcase\n}\n\n/*\n * Aborts a transaction with a given exception\n * The transaction promise will be rejected with this exception.\n */\nfunction abortWithException(txn: IDBTransaction, e: Error): void {\n    // We cheekily stick our exception onto the transaction object here\n    // We could alternatively make the thing we pass back to the app\n    // an object containing the transaction and exception.\n    (txn as IWrappedIDBTransaction)._mx_abortexception = e;\n    try {\n        txn.abort();\n    } catch {\n        // sometimes we won't be able to abort the transaction\n        // (ie. if it's aborted or completed)\n    }\n}\n\nfunction promiseifyTxn<T>(txn: IDBTransaction): Promise<T | null> {\n    return new Promise((resolve, reject) => {\n        txn.oncomplete = (): void => {\n            if ((txn as IWrappedIDBTransaction)._mx_abortexception !== undefined) {\n                reject((txn as IWrappedIDBTransaction)._mx_abortexception);\n            }\n            resolve(null);\n        };\n        txn.onerror = (event): void => {\n            if ((txn as IWrappedIDBTransaction)._mx_abortexception !== undefined) {\n                reject((txn as IWrappedIDBTransaction)._mx_abortexception);\n            } else {\n                logger.log(\"Error performing indexeddb txn\", event);\n                reject(txn.error);\n            }\n        };\n        txn.onabort = (event): void => {\n            if ((txn as IWrappedIDBTransaction)._mx_abortexception !== undefined) {\n                reject((txn as IWrappedIDBTransaction)._mx_abortexception);\n            } else {\n                logger.log(\"Error performing indexeddb txn\", event);\n                reject(txn.error);\n            }\n        };\n    });\n}\n","/*\nCopyright 2017 - 2021 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { logger, type Logger } from \"../../logger.ts\";\nimport { LocalStorageCryptoStore } from \"./localStorage-crypto-store.ts\";\nimport { MemoryCryptoStore } from \"./memory-crypto-store.ts\";\nimport * as IndexedDBCryptoStoreBackend from \"./indexeddb-crypto-store-backend.ts\";\nimport { InvalidCryptoStoreError, InvalidCryptoStoreState } from \"../../errors.ts\";\nimport * as IndexedDBHelpers from \"../../indexeddb-helpers.ts\";\nimport {\n    type CryptoStore,\n    type ISession,\n    type SessionExtended,\n    type ISessionInfo,\n    type IWithheld,\n    MigrationState,\n    type Mode,\n    type SecretStorePrivateKeys,\n    ACCOUNT_OBJECT_KEY_MIGRATION_STATE,\n    type InboundGroupSessionData,\n    type IRoomEncryption,\n} from \"./base.ts\";\nimport { type CrossSigningKeyInfo } from \"../../crypto-api/index.ts\";\n\n/*\n * Internal module. indexeddb storage for e2e.\n */\n\n/**\n * An implementation of CryptoStore, which is normally backed by an indexeddb,\n * but with fallback to MemoryCryptoStore.\n */\nexport class IndexedDBCryptoStore implements CryptoStore {\n    public static STORE_ACCOUNT = \"account\";\n    public static STORE_SESSIONS = \"sessions\";\n    public static STORE_INBOUND_GROUP_SESSIONS = \"inbound_group_sessions\";\n    public static STORE_INBOUND_GROUP_SESSIONS_WITHHELD = \"inbound_group_sessions_withheld\";\n    public static STORE_SHARED_HISTORY_INBOUND_GROUP_SESSIONS = \"shared_history_inbound_group_sessions\";\n    public static STORE_PARKED_SHARED_HISTORY = \"parked_shared_history\";\n    public static STORE_DEVICE_DATA = \"device_data\";\n    public static STORE_ROOMS = \"rooms\";\n    public static STORE_BACKUP = \"sessions_needing_backup\";\n\n    public static exists(indexedDB: IDBFactory, dbName: string): Promise<boolean> {\n        return IndexedDBHelpers.exists(indexedDB, dbName);\n    }\n\n    /**\n     * Utility to check if a legacy crypto store exists and has not been migrated.\n     * Returns true if the store exists and has not been migrated, false otherwise.\n     */\n    public static existsAndIsNotMigrated(indexedDb: IDBFactory, dbName: string): Promise<boolean> {\n        return new Promise<boolean>((resolve, reject) => {\n            let exists = true;\n            const openDBRequest = indexedDb.open(dbName);\n            openDBRequest.onupgradeneeded = (): void => {\n                // Since we did not provide an explicit version when opening, this event\n                // should only fire if the DB did not exist before at any version.\n                exists = false;\n            };\n            openDBRequest.onblocked = (): void => reject(openDBRequest.error);\n            openDBRequest.onsuccess = (): void => {\n                const db = openDBRequest.result;\n                if (!exists) {\n                    db.close();\n                    // The DB did not exist before, but has been created as part of this\n                    // existence check. Delete it now to restore previous state. Delete can\n                    // actually take a while to complete in some browsers, so don't wait for\n                    // it. This won't block future open calls that a store might issue next to\n                    // properly set up the DB.\n                    indexedDb.deleteDatabase(dbName);\n                    resolve(false);\n                } else {\n                    const tx = db.transaction([IndexedDBCryptoStore.STORE_ACCOUNT], \"readonly\");\n                    const objectStore = tx.objectStore(IndexedDBCryptoStore.STORE_ACCOUNT);\n                    const getReq = objectStore.get(ACCOUNT_OBJECT_KEY_MIGRATION_STATE);\n\n                    getReq.onsuccess = (): void => {\n                        const migrationState = getReq.result ?? MigrationState.NOT_STARTED;\n                        resolve(migrationState === MigrationState.NOT_STARTED);\n                    };\n\n                    getReq.onerror = (): void => {\n                        reject(getReq.error);\n                    };\n\n                    db.close();\n                }\n            };\n            openDBRequest.onerror = (): void => reject(openDBRequest.error);\n        });\n    }\n\n    private backendPromise?: Promise<CryptoStore>;\n    private backend?: CryptoStore;\n\n    /**\n     * Create a new IndexedDBCryptoStore\n     *\n     * @param indexedDB -  global indexedDB instance\n     * @param dbName -   name of db to connect to\n     */\n    public constructor(\n        private readonly indexedDB: IDBFactory,\n        private readonly dbName: string,\n    ) {}\n\n    /**\n     * Returns true if this CryptoStore has ever been initialised (ie, it might contain data).\n     *\n     * Implementation of {@link CryptoStore.containsData}.\n     *\n     * @internal\n     */\n    public async containsData(): Promise<boolean> {\n        return IndexedDBCryptoStore.exists(this.indexedDB, this.dbName);\n    }\n\n    /**\n     * Ensure the database exists and is up-to-date, or fall back to\n     * a local storage or in-memory store.\n     *\n     * This must be called before the store can be used.\n     *\n     * @returns resolves to either an IndexedDBCryptoStoreBackend.Backend,\n     * or a MemoryCryptoStore\n     */\n    public startup(): Promise<CryptoStore> {\n        if (this.backendPromise) {\n            return this.backendPromise;\n        }\n\n        this.backendPromise = new Promise<CryptoStore>((resolve, reject) => {\n            if (!this.indexedDB) {\n                reject(new Error(\"no indexeddb support available\"));\n                return;\n            }\n\n            logger.log(`connecting to indexeddb ${this.dbName}`);\n\n            const req = this.indexedDB.open(this.dbName, IndexedDBCryptoStoreBackend.VERSION);\n\n            req.onupgradeneeded = (ev): void => {\n                const db = req.result;\n                const oldVersion = ev.oldVersion;\n                IndexedDBCryptoStoreBackend.upgradeDatabase(db, oldVersion);\n            };\n\n            req.onblocked = (): void => {\n                logger.log(`can't yet open IndexedDBCryptoStore because it is open elsewhere`);\n            };\n\n            req.onerror = (ev): void => {\n                logger.log(\"Error connecting to indexeddb\", ev);\n                reject(req.error);\n            };\n\n            req.onsuccess = (): void => {\n                const db = req.result;\n\n                logger.log(`connected to indexeddb ${this.dbName}`);\n                resolve(new IndexedDBCryptoStoreBackend.Backend(db));\n            };\n        })\n            .then((backend) => {\n                // Edge has IndexedDB but doesn't support compund keys which we use fairly extensively.\n                // Try a dummy query which will fail if the browser doesn't support compund keys, so\n                // we can fall back to a different backend.\n                return backend\n                    .doTxn(\n                        \"readonly\",\n                        [\n                            IndexedDBCryptoStore.STORE_INBOUND_GROUP_SESSIONS,\n                            IndexedDBCryptoStore.STORE_INBOUND_GROUP_SESSIONS_WITHHELD,\n                        ],\n                        (txn) => {\n                            backend.getEndToEndInboundGroupSession(\"\", \"\", txn, () => {});\n                        },\n                    )\n                    .then(() => backend);\n            })\n            .catch((e) => {\n                if (e.name === \"VersionError\") {\n                    logger.warn(\"Crypto DB is too new for us to use!\", e);\n                    // don't fall back to a different store: the user has crypto data\n                    // in this db so we should use it or nothing at all.\n                    throw new InvalidCryptoStoreError(InvalidCryptoStoreState.TooNew);\n                }\n                logger.warn(\n                    `unable to connect to indexeddb ${this.dbName}` + `: falling back to localStorage store: ${e}`,\n                );\n\n                try {\n                    return new LocalStorageCryptoStore(globalThis.localStorage);\n                } catch (e) {\n                    logger.warn(`unable to open localStorage: falling back to in-memory store: ${e}`);\n                    return new MemoryCryptoStore();\n                }\n            })\n            .then((backend) => {\n                this.backend = backend;\n                return backend;\n            });\n\n        return this.backendPromise;\n    }\n\n    /**\n     * Delete all data from this store.\n     *\n     * @returns resolves when the store has been cleared.\n     */\n    public deleteAllData(): Promise<void> {\n        return new Promise<void>((resolve, reject) => {\n            if (!this.indexedDB) {\n                reject(new Error(\"no indexeddb support available\"));\n                return;\n            }\n\n            logger.log(`Removing indexeddb instance: ${this.dbName}`);\n            const req = this.indexedDB.deleteDatabase(this.dbName);\n\n            req.onblocked = (): void => {\n                logger.log(`can't yet delete IndexedDBCryptoStore because it is open elsewhere`);\n            };\n\n            req.onerror = (ev): void => {\n                logger.log(\"Error deleting data from indexeddb\", ev);\n                reject(req.error);\n            };\n\n            req.onsuccess = (): void => {\n                logger.log(`Removed indexeddb instance: ${this.dbName}`);\n                resolve();\n            };\n        }).catch((e) => {\n            // in firefox, with indexedDB disabled, this fails with a\n            // DOMError. We treat this as non-fatal, so that people can\n            // still use the app.\n            logger.warn(`unable to delete IndexedDBCryptoStore: ${e}`);\n        });\n    }\n\n    /**\n     * Get data on how much of the libolm to Rust Crypto migration has been done.\n     *\n     * Implementation of {@link CryptoStore.getMigrationState}.\n     *\n     * @internal\n     */\n    public getMigrationState(): Promise<MigrationState> {\n        return this.backend!.getMigrationState();\n    }\n\n    /**\n     * Set data on how much of the libolm to Rust Crypto migration has been done.\n     *\n     * Implementation of {@link CryptoStore.setMigrationState}.\n     *\n     * @internal\n     */\n    public setMigrationState(migrationState: MigrationState): Promise<void> {\n        return this.backend!.setMigrationState(migrationState);\n    }\n\n    // Olm Account\n\n    /*\n     * Get the account pickle from the store.\n     * This requires an active transaction. See doTxn().\n     *\n     * @param txn - An active transaction. See doTxn().\n     * @param func - Called with the account pickle\n     */\n    public getAccount(txn: IDBTransaction, func: (accountPickle: string | null) => void): void {\n        this.backend!.getAccount(txn, func);\n    }\n\n    /**\n     * Write the account pickle to the store.\n     * This requires an active transaction. See doTxn().\n     *\n     * @param txn - An active transaction. See doTxn().\n     * @param accountPickle - The new account pickle to store.\n     */\n    public storeAccount(txn: IDBTransaction, accountPickle: string): void {\n        this.backend!.storeAccount(txn, accountPickle);\n    }\n\n    /**\n     * Get the public part of the cross-signing keys (eg. self-signing key,\n     * user signing key).\n     *\n     * @param txn - An active transaction. See doTxn().\n     * @param func - Called with the account keys object:\n     *        `{ key_type: base64 encoded seed }` where key type = user_signing_key_seed or self_signing_key_seed\n     */\n    public getCrossSigningKeys(\n        txn: IDBTransaction,\n        func: (keys: Record<string, CrossSigningKeyInfo> | null) => void,\n    ): void {\n        this.backend!.getCrossSigningKeys(txn, func);\n    }\n\n    /**\n     * @param txn - An active transaction. See doTxn().\n     * @param func - Called with the private key\n     * @param type - A key type\n     */\n    public getSecretStorePrivateKey<K extends keyof SecretStorePrivateKeys>(\n        txn: IDBTransaction,\n        func: (key: SecretStorePrivateKeys[K] | null) => void,\n        type: K,\n    ): void {\n        this.backend!.getSecretStorePrivateKey(txn, func, type);\n    }\n\n    /**\n     * Write the cross-signing private keys back to the store\n     *\n     * @param txn - An active transaction. See doTxn().\n     * @param type - The type of cross-signing private key to store\n     * @param key - keys object as getCrossSigningKeys()\n     */\n    public storeSecretStorePrivateKey<K extends keyof SecretStorePrivateKeys>(\n        txn: IDBTransaction,\n        type: K,\n        key: SecretStorePrivateKeys[K],\n    ): void {\n        this.backend!.storeSecretStorePrivateKey(txn, type, key);\n    }\n\n    // Olm sessions\n\n    /**\n     * Returns the number of end-to-end sessions in the store\n     * @param txn - An active transaction. See doTxn().\n     * @param func - Called with the count of sessions\n     */\n    public countEndToEndSessions(txn: IDBTransaction, func: (count: number) => void): void {\n        this.backend!.countEndToEndSessions(txn, func);\n    }\n\n    /**\n     * Retrieve a specific end-to-end session between the logged-in user\n     * and another device.\n     * @param deviceKey - The public key of the other device.\n     * @param sessionId - The ID of the session to retrieve\n     * @param txn - An active transaction. See doTxn().\n     * @param func - Called with A map from sessionId\n     *     to session information object with 'session' key being the\n     *     Base64 end-to-end session and lastReceivedMessageTs being the\n     *     timestamp in milliseconds at which the session last received\n     *     a message.\n     */\n    public getEndToEndSession(\n        deviceKey: string,\n        sessionId: string,\n        txn: IDBTransaction,\n        func: (session: ISessionInfo | null) => void,\n    ): void {\n        this.backend!.getEndToEndSession(deviceKey, sessionId, txn, func);\n    }\n\n    /**\n     * Retrieve the end-to-end sessions between the logged-in user and another\n     * device.\n     * @param deviceKey - The public key of the other device.\n     * @param txn - An active transaction. See doTxn().\n     * @param func - Called with A map from sessionId\n     *     to session information object with 'session' key being the\n     *     Base64 end-to-end session and lastReceivedMessageTs being the\n     *     timestamp in milliseconds at which the session last received\n     *     a message.\n     */\n    public getEndToEndSessions(\n        deviceKey: string,\n        txn: IDBTransaction,\n        func: (sessions: { [sessionId: string]: ISessionInfo }) => void,\n    ): void {\n        this.backend!.getEndToEndSessions(deviceKey, txn, func);\n    }\n\n    /**\n     * Store a session between the logged-in user and another device\n     * @param deviceKey - The public key of the other device.\n     * @param sessionId - The ID for this end-to-end session.\n     * @param sessionInfo - Session information object\n     * @param txn - An active transaction. See doTxn().\n     */\n    public storeEndToEndSession(\n        deviceKey: string,\n        sessionId: string,\n        sessionInfo: ISessionInfo,\n        txn: IDBTransaction,\n    ): void {\n        this.backend!.storeEndToEndSession(deviceKey, sessionId, sessionInfo, txn);\n    }\n\n    /**\n     * Count the number of Megolm sessions in the database.\n     *\n     * Implementation of {@link CryptoStore.countEndToEndInboundGroupSessions}.\n     *\n     * @internal\n     */\n    public countEndToEndInboundGroupSessions(): Promise<number> {\n        return this.backend!.countEndToEndInboundGroupSessions();\n    }\n\n    /**\n     * Fetch a batch of Olm sessions from the database.\n     *\n     * Implementation of {@link CryptoStore.getEndToEndSessionsBatch}.\n     *\n     * @internal\n     */\n    public getEndToEndSessionsBatch(): Promise<null | ISessionInfo[]> {\n        return this.backend!.getEndToEndSessionsBatch();\n    }\n\n    /**\n     * Delete a batch of Olm sessions from the database.\n     *\n     * Implementation of {@link CryptoStore.deleteEndToEndSessionsBatch}.\n     *\n     * @internal\n     */\n    public deleteEndToEndSessionsBatch(sessions: { deviceKey: string; sessionId: string }[]): Promise<void> {\n        return this.backend!.deleteEndToEndSessionsBatch(sessions);\n    }\n\n    // Inbound group sessions\n\n    /**\n     * Retrieve the end-to-end inbound group session for a given\n     * server key and session ID\n     * @param senderCurve25519Key - The sender's curve 25519 key\n     * @param sessionId - The ID of the session\n     * @param txn - An active transaction. See doTxn().\n     * @param func - Called with A map from sessionId\n     *     to Base64 end-to-end session.\n     */\n    public getEndToEndInboundGroupSession(\n        senderCurve25519Key: string,\n        sessionId: string,\n        txn: IDBTransaction,\n        func: (groupSession: InboundGroupSessionData | null, groupSessionWithheld: IWithheld | null) => void,\n    ): void {\n        this.backend!.getEndToEndInboundGroupSession(senderCurve25519Key, sessionId, txn, func);\n    }\n\n    /**\n     * Writes an end-to-end inbound group session to the store.\n     * If there already exists an inbound group session with the same\n     * senderCurve25519Key and sessionID, it will be overwritten.\n     * @param senderCurve25519Key - The sender's curve 25519 key\n     * @param sessionId - The ID of the session\n     * @param sessionData - The session data structure\n     * @param txn - An active transaction. See doTxn().\n     */\n    public storeEndToEndInboundGroupSession(\n        senderCurve25519Key: string,\n        sessionId: string,\n        sessionData: InboundGroupSessionData,\n        txn: IDBTransaction,\n    ): void {\n        this.backend!.storeEndToEndInboundGroupSession(senderCurve25519Key, sessionId, sessionData, txn);\n    }\n\n    /**\n     * Fetch a batch of Megolm sessions from the database.\n     *\n     * Implementation of {@link CryptoStore.getEndToEndInboundGroupSessionsBatch}.\n     *\n     * @internal\n     */\n    public getEndToEndInboundGroupSessionsBatch(): Promise<SessionExtended[] | null> {\n        return this.backend!.getEndToEndInboundGroupSessionsBatch();\n    }\n\n    /**\n     * Delete a batch of Megolm sessions from the database.\n     *\n     * Implementation of {@link CryptoStore.deleteEndToEndInboundGroupSessionsBatch}.\n     *\n     * @internal\n     */\n    public deleteEndToEndInboundGroupSessionsBatch(\n        sessions: { senderKey: string; sessionId: string }[],\n    ): Promise<void> {\n        return this.backend!.deleteEndToEndInboundGroupSessionsBatch(sessions);\n    }\n\n    /**\n     * Get an object of `roomId->roomInfo` for all e2e rooms in the store\n     * @param txn - An active transaction. See doTxn().\n     * @param func - Function called with the end-to-end encrypted rooms\n     */\n    public getEndToEndRooms(txn: IDBTransaction, func: (rooms: Record<string, IRoomEncryption>) => void): void {\n        this.backend!.getEndToEndRooms(txn, func);\n    }\n\n    /**\n     * Mark sessions as needing to be backed up.\n     * @param sessions - The sessions that need to be backed up.\n     * @param txn - An active transaction. See doTxn(). (optional)\n     * @returns resolves when the sessions are marked\n     */\n    public markSessionsNeedingBackup(sessions: ISession[], txn?: IDBTransaction): Promise<void> {\n        return this.backend!.markSessionsNeedingBackup(sessions, txn);\n    }\n\n    /**\n     * Perform a transaction on the crypto store. Any store methods\n     * that require a transaction (txn) object to be passed in may\n     * only be called within a callback of either this function or\n     * one of the store functions operating on the same transaction.\n     *\n     * @param mode - 'readwrite' if you need to call setter\n     *     functions with this transaction. Otherwise, 'readonly'.\n     * @param stores - List IndexedDBCryptoStore.STORE_*\n     *     options representing all types of object that will be\n     *     accessed or written to with this transaction.\n     * @param func - Function called with the\n     *     transaction object: an opaque object that should be passed\n     *     to store functions.\n     * @param log - A possibly customised log\n     * @returns Promise that resolves with the result of the `func`\n     *     when the transaction is complete. If the backend is\n     *     async (ie. the indexeddb backend) any of the callback\n     *     functions throwing an exception will cause this promise to\n     *     reject with that exception. On synchronous backends, the\n     *     exception will propagate to the caller of the getFoo method.\n     */\n    public doTxn<T>(mode: Mode, stores: Iterable<string>, func: (txn: IDBTransaction) => T, log?: Logger): Promise<T> {\n        return this.backend!.doTxn<T>(mode, stores, func as (txn: unknown) => T, log);\n    }\n}\n","/*\nCopyright 2017 - 2021 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { logger } from \"../../logger.ts\";\nimport { MemoryCryptoStore } from \"./memory-crypto-store.ts\";\nimport {\n    type CryptoStore,\n    type ISession,\n    type SessionExtended,\n    type ISessionInfo,\n    type IWithheld,\n    MigrationState,\n    type Mode,\n    type SecretStorePrivateKeys,\n    SESSION_BATCH_SIZE,\n    type InboundGroupSessionData,\n    type IRoomEncryption,\n} from \"./base.ts\";\nimport { type CrossSigningKeyInfo } from \"../../crypto-api/index.ts\";\n\n/**\n * Internal module. Partial localStorage backed storage for e2e.\n * This is not a full crypto store, just the in-memory store with\n * some things backed by localStorage. It exists because indexedDB\n * is broken in Firefox private mode or set to, \"will not remember\n * history\".\n */\n\nconst E2E_PREFIX = \"crypto.\";\nconst KEY_END_TO_END_MIGRATION_STATE = E2E_PREFIX + \"migration\";\nconst KEY_END_TO_END_ACCOUNT = E2E_PREFIX + \"account\";\nconst KEY_CROSS_SIGNING_KEYS = E2E_PREFIX + \"cross_signing_keys\";\nconst KEY_INBOUND_SESSION_PREFIX = E2E_PREFIX + \"inboundgroupsessions/\";\nconst KEY_INBOUND_SESSION_WITHHELD_PREFIX = E2E_PREFIX + \"inboundgroupsessions.withheld/\";\nconst KEY_ROOMS_PREFIX = E2E_PREFIX + \"rooms/\";\nconst KEY_SESSIONS_NEEDING_BACKUP = E2E_PREFIX + \"sessionsneedingbackup\";\n\nfunction keyEndToEndSessions(deviceKey: string): string {\n    return E2E_PREFIX + \"sessions/\" + deviceKey;\n}\n\nfunction keyEndToEndInboundGroupSession(senderKey: string, sessionId: string): string {\n    return KEY_INBOUND_SESSION_PREFIX + senderKey + \"/\" + sessionId;\n}\n\nfunction keyEndToEndInboundGroupSessionWithheld(senderKey: string, sessionId: string): string {\n    return KEY_INBOUND_SESSION_WITHHELD_PREFIX + senderKey + \"/\" + sessionId;\n}\n\nfunction keyEndToEndRoomsPrefix(roomId: string): string {\n    return KEY_ROOMS_PREFIX + roomId;\n}\n\nexport class LocalStorageCryptoStore extends MemoryCryptoStore implements CryptoStore {\n    public static exists(store: Storage): boolean {\n        const length = store.length;\n        for (let i = 0; i < length; i++) {\n            if (store.key(i)?.startsWith(E2E_PREFIX)) {\n                return true;\n            }\n        }\n        return false;\n    }\n\n    public constructor(private readonly store: Storage) {\n        super();\n    }\n\n    /**\n     * Returns true if this CryptoStore has ever been initialised (ie, it might contain data).\n     *\n     * Implementation of {@link CryptoStore.containsData}.\n     *\n     * @internal\n     */\n    public async containsData(): Promise<boolean> {\n        return LocalStorageCryptoStore.exists(this.store);\n    }\n\n    /**\n     * Get data on how much of the libolm to Rust Crypto migration has been done.\n     *\n     * Implementation of {@link CryptoStore.getMigrationState}.\n     *\n     * @internal\n     */\n    public async getMigrationState(): Promise<MigrationState> {\n        return getJsonItem(this.store, KEY_END_TO_END_MIGRATION_STATE) ?? MigrationState.NOT_STARTED;\n    }\n\n    /**\n     * Set data on how much of the libolm to Rust Crypto migration has been done.\n     *\n     * Implementation of {@link CryptoStore.setMigrationState}.\n     *\n     * @internal\n     */\n    public async setMigrationState(migrationState: MigrationState): Promise<void> {\n        setJsonItem(this.store, KEY_END_TO_END_MIGRATION_STATE, migrationState);\n    }\n\n    // Olm Sessions\n\n    public countEndToEndSessions(txn: unknown, func: (count: number) => void): void {\n        let count = 0;\n        for (let i = 0; i < this.store.length; ++i) {\n            const key = this.store.key(i);\n            if (key?.startsWith(keyEndToEndSessions(\"\"))) {\n                const sessions = getJsonItem(this.store, key);\n                count += Object.keys(sessions ?? {}).length;\n            }\n        }\n        func(count);\n    }\n\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    private _getEndToEndSessions(deviceKey: string): Record<string, ISessionInfo> {\n        const sessions = getJsonItem(this.store, keyEndToEndSessions(deviceKey));\n        const fixedSessions: Record<string, ISessionInfo> = {};\n\n        // fix up any old sessions to be objects rather than just the base64 pickle\n        for (const [sid, val] of Object.entries(sessions || {})) {\n            if (typeof val === \"string\") {\n                fixedSessions[sid] = {\n                    session: val,\n                };\n            } else {\n                fixedSessions[sid] = val;\n            }\n        }\n\n        return fixedSessions;\n    }\n\n    public getEndToEndSession(\n        deviceKey: string,\n        sessionId: string,\n        txn: unknown,\n        func: (session: ISessionInfo) => void,\n    ): void {\n        const sessions = this._getEndToEndSessions(deviceKey);\n        func(sessions[sessionId] ?? {});\n    }\n\n    public getEndToEndSessions(\n        deviceKey: string,\n        txn: unknown,\n        func: (sessions: { [sessionId: string]: ISessionInfo }) => void,\n    ): void {\n        func(this._getEndToEndSessions(deviceKey) ?? {});\n    }\n\n    public storeEndToEndSession(deviceKey: string, sessionId: string, sessionInfo: ISessionInfo, txn: unknown): void {\n        const sessions = this._getEndToEndSessions(deviceKey) || {};\n        sessions[sessionId] = sessionInfo;\n        setJsonItem(this.store, keyEndToEndSessions(deviceKey), sessions);\n    }\n\n    /**\n     * Fetch a batch of Olm sessions from the database.\n     *\n     * Implementation of {@link CryptoStore.getEndToEndSessionsBatch}.\n     *\n     * @internal\n     */\n    public async getEndToEndSessionsBatch(): Promise<null | ISessionInfo[]> {\n        const result: ISessionInfo[] = [];\n        for (let i = 0; i < this.store.length; ++i) {\n            if (this.store.key(i)?.startsWith(keyEndToEndSessions(\"\"))) {\n                const deviceKey = this.store.key(i)!.split(\"/\")[1];\n                for (const session of Object.values(this._getEndToEndSessions(deviceKey))) {\n                    result.push(session);\n                    if (result.length >= SESSION_BATCH_SIZE) {\n                        return result;\n                    }\n                }\n            }\n        }\n\n        if (result.length === 0) {\n            // No sessions left.\n            return null;\n        }\n\n        // There are fewer sessions than the batch size; return the final batch of sessions.\n        return result;\n    }\n\n    /**\n     * Delete a batch of Olm sessions from the database.\n     *\n     * Implementation of {@link CryptoStore.deleteEndToEndSessionsBatch}.\n     *\n     * @internal\n     */\n    public async deleteEndToEndSessionsBatch(sessions: { deviceKey: string; sessionId: string }[]): Promise<void> {\n        for (const { deviceKey, sessionId } of sessions) {\n            const deviceSessions = this._getEndToEndSessions(deviceKey) || {};\n            delete deviceSessions[sessionId];\n            if (Object.keys(deviceSessions).length === 0) {\n                // No more sessions for this device.\n                this.store.removeItem(keyEndToEndSessions(deviceKey));\n            } else {\n                setJsonItem(this.store, keyEndToEndSessions(deviceKey), deviceSessions);\n            }\n        }\n    }\n\n    // Inbound Group Sessions\n\n    public getEndToEndInboundGroupSession(\n        senderCurve25519Key: string,\n        sessionId: string,\n        txn: unknown,\n        func: (groupSession: InboundGroupSessionData | null, groupSessionWithheld: IWithheld | null) => void,\n    ): void {\n        func(\n            getJsonItem(this.store, keyEndToEndInboundGroupSession(senderCurve25519Key, sessionId)),\n            getJsonItem(this.store, keyEndToEndInboundGroupSessionWithheld(senderCurve25519Key, sessionId)),\n        );\n    }\n\n    public storeEndToEndInboundGroupSession(\n        senderCurve25519Key: string,\n        sessionId: string,\n        sessionData: InboundGroupSessionData,\n        txn: unknown,\n    ): void {\n        setJsonItem(this.store, keyEndToEndInboundGroupSession(senderCurve25519Key, sessionId), sessionData);\n    }\n\n    /**\n     * Count the number of Megolm sessions in the database.\n     *\n     * Implementation of {@link CryptoStore.countEndToEndInboundGroupSessions}.\n     *\n     * @internal\n     */\n    public async countEndToEndInboundGroupSessions(): Promise<number> {\n        let count = 0;\n        for (let i = 0; i < this.store.length; ++i) {\n            const key = this.store.key(i);\n            if (key?.startsWith(KEY_INBOUND_SESSION_PREFIX)) {\n                count += 1;\n            }\n        }\n        return count;\n    }\n\n    /**\n     * Fetch a batch of Megolm sessions from the database.\n     *\n     * Implementation of {@link CryptoStore.getEndToEndInboundGroupSessionsBatch}.\n     *\n     * @internal\n     */\n    public async getEndToEndInboundGroupSessionsBatch(): Promise<SessionExtended[] | null> {\n        const sessionsNeedingBackup = getJsonItem<string[]>(this.store, KEY_SESSIONS_NEEDING_BACKUP) || {};\n        const result: SessionExtended[] = [];\n        for (let i = 0; i < this.store.length; ++i) {\n            const key = this.store.key(i);\n            if (key?.startsWith(KEY_INBOUND_SESSION_PREFIX)) {\n                const key2 = key.slice(KEY_INBOUND_SESSION_PREFIX.length);\n\n                // we can't use split, as the components we are trying to split out\n                // might themselves contain '/' characters. We rely on the\n                // senderKey being a (32-byte) curve25519 key, base64-encoded\n                // (hence 43 characters long).\n\n                result.push({\n                    senderKey: key2.slice(0, 43),\n                    sessionId: key2.slice(44),\n                    sessionData: getJsonItem(this.store, key)!,\n                    needsBackup: key2 in sessionsNeedingBackup,\n                });\n\n                if (result.length >= SESSION_BATCH_SIZE) {\n                    return result;\n                }\n            }\n        }\n\n        if (result.length === 0) {\n            // No sessions left.\n            return null;\n        }\n\n        // There are fewer sessions than the batch size; return the final batch of sessions.\n        return result;\n    }\n\n    /**\n     * Delete a batch of Megolm sessions from the database.\n     *\n     * Implementation of {@link CryptoStore.deleteEndToEndInboundGroupSessionsBatch}.\n     *\n     * @internal\n     */\n    public async deleteEndToEndInboundGroupSessionsBatch(\n        sessions: { senderKey: string; sessionId: string }[],\n    ): Promise<void> {\n        for (const { senderKey, sessionId } of sessions) {\n            const k = keyEndToEndInboundGroupSession(senderKey, sessionId);\n            this.store.removeItem(k);\n        }\n    }\n\n    public getEndToEndRooms(txn: unknown, func: (rooms: Record<string, IRoomEncryption>) => void): void {\n        const result: Record<string, IRoomEncryption> = {};\n        const prefix = keyEndToEndRoomsPrefix(\"\");\n\n        for (let i = 0; i < this.store.length; ++i) {\n            const key = this.store.key(i);\n            if (key?.startsWith(prefix)) {\n                const roomId = key.slice(prefix.length);\n                result[roomId] = getJsonItem(this.store, key)!;\n            }\n        }\n        func(result);\n    }\n\n    public markSessionsNeedingBackup(sessions: ISession[]): Promise<void> {\n        const sessionsNeedingBackup =\n            getJsonItem<{\n                [senderKeySessionId: string]: boolean;\n            }>(this.store, KEY_SESSIONS_NEEDING_BACKUP) || {};\n        for (const session of sessions) {\n            sessionsNeedingBackup[session.senderKey + \"/\" + session.sessionId] = true;\n        }\n        setJsonItem(this.store, KEY_SESSIONS_NEEDING_BACKUP, sessionsNeedingBackup);\n        return Promise.resolve();\n    }\n\n    /**\n     * Delete all data from this store.\n     *\n     * @returns Promise which resolves when the store has been cleared.\n     */\n    public deleteAllData(): Promise<void> {\n        this.store.removeItem(KEY_END_TO_END_ACCOUNT);\n        return Promise.resolve();\n    }\n\n    // Olm account\n\n    public getAccount(txn: unknown, func: (accountPickle: string | null) => void): void {\n        const accountPickle = getJsonItem<string>(this.store, KEY_END_TO_END_ACCOUNT);\n        func(accountPickle);\n    }\n\n    public storeAccount(txn: unknown, accountPickle: string): void {\n        setJsonItem(this.store, KEY_END_TO_END_ACCOUNT, accountPickle);\n    }\n\n    public getCrossSigningKeys(txn: unknown, func: (keys: Record<string, CrossSigningKeyInfo> | null) => void): void {\n        const keys = getJsonItem<Record<string, CrossSigningKeyInfo>>(this.store, KEY_CROSS_SIGNING_KEYS);\n        func(keys);\n    }\n\n    public getSecretStorePrivateKey<K extends keyof SecretStorePrivateKeys>(\n        txn: unknown,\n        func: (key: SecretStorePrivateKeys[K] | null) => void,\n        type: K,\n    ): void {\n        const key = getJsonItem<SecretStorePrivateKeys[K]>(this.store, E2E_PREFIX + `ssss_cache.${type}`);\n        func(key);\n    }\n\n    public storeSecretStorePrivateKey<K extends keyof SecretStorePrivateKeys>(\n        txn: unknown,\n        type: K,\n        key: SecretStorePrivateKeys[K],\n    ): void {\n        setJsonItem(this.store, E2E_PREFIX + `ssss_cache.${type}`, key);\n    }\n\n    public doTxn<T>(mode: Mode, stores: Iterable<string>, func: (txn: unknown) => T): Promise<T> {\n        return Promise.resolve(func(null));\n    }\n}\n\nfunction getJsonItem<T>(store: Storage, key: string): T | null {\n    try {\n        // if the key is absent, store.getItem() returns null, and\n        // JSON.parse(null) === null, so this returns null.\n        return JSON.parse(store.getItem(key)!);\n    } catch (e) {\n        logger.log(\"Error: Failed to get key %s: %s\", key, (<Error>e).message);\n        logger.log((<Error>e).stack);\n    }\n    return null;\n}\n\nfunction setJsonItem<T>(store: Storage, key: string, val: T): void {\n    store.setItem(key, JSON.stringify(val));\n}\n","/*\nCopyright 2017 - 2021 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { safeSet } from \"../../utils.ts\";\nimport {\n    type CryptoStore,\n    type ISession,\n    type SessionExtended,\n    type ISessionInfo,\n    type IWithheld,\n    MigrationState,\n    type Mode,\n    type SecretStorePrivateKeys,\n    SESSION_BATCH_SIZE,\n    type InboundGroupSessionData,\n    type IRoomEncryption,\n} from \"./base.ts\";\nimport { type CrossSigningKeyInfo } from \"../../crypto-api/index.ts\";\n\nfunction encodeSessionKey(senderCurve25519Key: string, sessionId: string): string {\n    return encodeURIComponent(senderCurve25519Key) + \"/\" + encodeURIComponent(sessionId);\n}\n\nfunction decodeSessionKey(key: string): { senderKey: string; sessionId: string } {\n    const keyParts = key.split(\"/\");\n    const senderKey = decodeURIComponent(keyParts[0]);\n    const sessionId = decodeURIComponent(keyParts[1]);\n    return { senderKey, sessionId };\n}\n\n/**\n * Internal module. in-memory storage for e2e.\n */\n\nexport class MemoryCryptoStore implements CryptoStore {\n    private migrationState: MigrationState = MigrationState.NOT_STARTED;\n    private account: string | null = null;\n    private crossSigningKeys: Record<string, CrossSigningKeyInfo> | null = null;\n    private privateKeys: Partial<SecretStorePrivateKeys> = {};\n\n    private sessions: { [deviceKey: string]: { [sessionId: string]: ISessionInfo } } = {};\n    private inboundGroupSessions: { [sessionKey: string]: InboundGroupSessionData } = {};\n    private inboundGroupSessionsWithheld: Record<string, IWithheld> = {};\n    // Opaque device data object\n    private rooms: { [roomId: string]: IRoomEncryption } = {};\n    private sessionsNeedingBackup: { [sessionKey: string]: boolean } = {};\n\n    /**\n     * Returns true if this CryptoStore has ever been initialised (ie, it might contain data).\n     *\n     * Implementation of {@link CryptoStore.containsData}.\n     *\n     * @internal\n     */\n    public async containsData(): Promise<boolean> {\n        // If it contains anything, it should contain an account.\n        return this.account !== null;\n    }\n\n    /**\n     * Ensure the database exists and is up-to-date.\n     *\n     * This must be called before the store can be used.\n     *\n     * @returns resolves to the store.\n     */\n    public async startup(): Promise<CryptoStore> {\n        // No startup work to do for the memory store.\n        return this;\n    }\n\n    /**\n     * Delete all data from this store.\n     *\n     * @returns Promise which resolves when the store has been cleared.\n     */\n    public deleteAllData(): Promise<void> {\n        return Promise.resolve();\n    }\n\n    /**\n     * Get data on how much of the libolm to Rust Crypto migration has been done.\n     *\n     * Implementation of {@link CryptoStore.getMigrationState}.\n     *\n     * @internal\n     */\n    public async getMigrationState(): Promise<MigrationState> {\n        return this.migrationState;\n    }\n\n    /**\n     * Set data on how much of the libolm to Rust Crypto migration has been done.\n     *\n     * Implementation of {@link CryptoStore.setMigrationState}.\n     *\n     * @internal\n     */\n    public async setMigrationState(migrationState: MigrationState): Promise<void> {\n        this.migrationState = migrationState;\n    }\n\n    // Olm Account\n\n    public getAccount(txn: unknown, func: (accountPickle: string | null) => void): void {\n        func(this.account);\n    }\n\n    public storeAccount(txn: unknown, accountPickle: string): void {\n        this.account = accountPickle;\n    }\n\n    public getCrossSigningKeys(txn: unknown, func: (keys: Record<string, CrossSigningKeyInfo> | null) => void): void {\n        func(this.crossSigningKeys);\n    }\n\n    public getSecretStorePrivateKey<K extends keyof SecretStorePrivateKeys>(\n        txn: unknown,\n        func: (key: SecretStorePrivateKeys[K] | null) => void,\n        type: K,\n    ): void {\n        const result = this.privateKeys[type] as SecretStorePrivateKeys[K] | undefined;\n        func(result || null);\n    }\n\n    public storeSecretStorePrivateKey<K extends keyof SecretStorePrivateKeys>(\n        txn: unknown,\n        type: K,\n        key: SecretStorePrivateKeys[K],\n    ): void {\n        this.privateKeys[type] = key;\n    }\n\n    // Olm Sessions\n\n    public countEndToEndSessions(txn: unknown, func: (count: number) => void): void {\n        let count = 0;\n        for (const deviceSessions of Object.values(this.sessions)) {\n            count += Object.keys(deviceSessions).length;\n        }\n        func(count);\n    }\n\n    public getEndToEndSession(\n        deviceKey: string,\n        sessionId: string,\n        txn: unknown,\n        func: (session: ISessionInfo) => void,\n    ): void {\n        const deviceSessions = this.sessions[deviceKey] || {};\n        func(deviceSessions[sessionId] || null);\n    }\n\n    public getEndToEndSessions(\n        deviceKey: string,\n        txn: unknown,\n        func: (sessions: { [sessionId: string]: ISessionInfo }) => void,\n    ): void {\n        func(this.sessions[deviceKey] || {});\n    }\n\n    public storeEndToEndSession(deviceKey: string, sessionId: string, sessionInfo: ISessionInfo, txn: unknown): void {\n        let deviceSessions = this.sessions[deviceKey];\n        if (deviceSessions === undefined) {\n            deviceSessions = {};\n            this.sessions[deviceKey] = deviceSessions;\n        }\n        safeSet(deviceSessions, sessionId, sessionInfo);\n    }\n\n    /**\n     * Fetch a batch of Olm sessions from the database.\n     *\n     * Implementation of {@link CryptoStore.getEndToEndSessionsBatch}.\n     *\n     * @internal\n     */\n    public async getEndToEndSessionsBatch(): Promise<null | ISessionInfo[]> {\n        const result: ISessionInfo[] = [];\n        for (const deviceSessions of Object.values(this.sessions)) {\n            for (const session of Object.values(deviceSessions)) {\n                result.push(session);\n                if (result.length >= SESSION_BATCH_SIZE) {\n                    return result;\n                }\n            }\n        }\n\n        if (result.length === 0) {\n            // No sessions left.\n            return null;\n        }\n\n        // There are fewer sessions than the batch size; return the final batch of sessions.\n        return result;\n    }\n\n    /**\n     * Delete a batch of Olm sessions from the database.\n     *\n     * Implementation of {@link CryptoStore.deleteEndToEndSessionsBatch}.\n     *\n     * @internal\n     */\n    public async deleteEndToEndSessionsBatch(sessions: { deviceKey: string; sessionId: string }[]): Promise<void> {\n        for (const { deviceKey, sessionId } of sessions) {\n            const deviceSessions = this.sessions[deviceKey] || {};\n            delete deviceSessions[sessionId];\n            if (Object.keys(deviceSessions).length === 0) {\n                // No more sessions for this device.\n                delete this.sessions[deviceKey];\n            }\n        }\n    }\n\n    // Inbound Group Sessions\n\n    public getEndToEndInboundGroupSession(\n        senderCurve25519Key: string,\n        sessionId: string,\n        txn: unknown,\n        func: (groupSession: InboundGroupSessionData | null, groupSessionWithheld: IWithheld | null) => void,\n    ): void {\n        const k = encodeSessionKey(senderCurve25519Key, sessionId);\n        func(this.inboundGroupSessions[k] || null, this.inboundGroupSessionsWithheld[k] || null);\n    }\n\n    public storeEndToEndInboundGroupSession(\n        senderCurve25519Key: string,\n        sessionId: string,\n        sessionData: InboundGroupSessionData,\n        txn: unknown,\n    ): void {\n        const k = encodeSessionKey(senderCurve25519Key, sessionId);\n        this.inboundGroupSessions[k] = sessionData;\n    }\n\n    /**\n     * Count the number of Megolm sessions in the database.\n     *\n     * Implementation of {@link CryptoStore.countEndToEndInboundGroupSessions}.\n     *\n     * @internal\n     */\n    public async countEndToEndInboundGroupSessions(): Promise<number> {\n        return Object.keys(this.inboundGroupSessions).length;\n    }\n\n    /**\n     * Fetch a batch of Megolm sessions from the database.\n     *\n     * Implementation of {@link CryptoStore.getEndToEndInboundGroupSessionsBatch}.\n     *\n     * @internal\n     */\n    public async getEndToEndInboundGroupSessionsBatch(): Promise<null | SessionExtended[]> {\n        const result: SessionExtended[] = [];\n        for (const [key, session] of Object.entries(this.inboundGroupSessions)) {\n            result.push({\n                ...decodeSessionKey(key),\n                sessionData: session,\n                needsBackup: key in this.sessionsNeedingBackup,\n            });\n            if (result.length >= SESSION_BATCH_SIZE) {\n                return result;\n            }\n        }\n\n        if (result.length === 0) {\n            // No sessions left.\n            return null;\n        }\n\n        // There are fewer sessions than the batch size; return the final batch of sessions.\n        return result;\n    }\n\n    /**\n     * Delete a batch of Megolm sessions from the database.\n     *\n     * Implementation of {@link CryptoStore.deleteEndToEndInboundGroupSessionsBatch}.\n     *\n     * @internal\n     */\n    public async deleteEndToEndInboundGroupSessionsBatch(\n        sessions: { senderKey: string; sessionId: string }[],\n    ): Promise<void> {\n        for (const { senderKey, sessionId } of sessions) {\n            const k = encodeSessionKey(senderKey, sessionId);\n            delete this.inboundGroupSessions[k];\n        }\n    }\n\n    // E2E rooms\n\n    public getEndToEndRooms(txn: unknown, func: (rooms: Record<string, IRoomEncryption>) => void): void {\n        func(this.rooms);\n    }\n\n    public markSessionsNeedingBackup(sessions: ISession[]): Promise<void> {\n        for (const session of sessions) {\n            const sessionKey = encodeSessionKey(session.senderKey, session.sessionId);\n            this.sessionsNeedingBackup[sessionKey] = true;\n        }\n        return Promise.resolve();\n    }\n\n    // Session key backups\n\n    public doTxn<T>(mode: Mode, stores: Iterable<string>, func: (txn?: unknown) => T): Promise<T> {\n        return Promise.resolve(func(null));\n    }\n}\n","/*\nCopyright 2024 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\n/**\n * Computes a SHA-256 hash of a string (after utf-8 encoding) and returns it as an ArrayBuffer.\n *\n * @param plaintext The string to hash\n * @returns An Uint8Array containing the SHA-256 hash of the input string\n * @throws If the subtle crypto API is not available, for example if the code is running\n *         in a web page with an insecure context (eg. served over plain HTTP).\n */\nexport async function sha256(plaintext: string): Promise<Uint8Array> {\n    if (!globalThis.crypto.subtle) {\n        throw new Error(\"Crypto.subtle is not available: insecure context?\");\n    }\n    const utf8 = new TextEncoder().encode(plaintext);\n\n    const digest = await globalThis.crypto.subtle.digest(\"SHA-256\", utf8);\n\n    return new Uint8Array(digest);\n}\n","/*\nCopyright 2022 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nexport enum InvalidCryptoStoreState {\n    TooNew = \"TOO_NEW\",\n}\n\nexport class InvalidCryptoStoreError extends Error {\n    public static TOO_NEW = InvalidCryptoStoreState.TooNew;\n\n    public constructor(public readonly reason: InvalidCryptoStoreState) {\n        const message =\n            `Crypto store is invalid because ${reason}, ` +\n            `please stop the client, delete all data and start the client again`;\n        super(message);\n        this.name = \"InvalidCryptoStoreError\";\n    }\n}\n\nexport class KeySignatureUploadError extends Error {\n    public constructor(\n        message: string,\n        public readonly value: any,\n    ) {\n        super(message);\n    }\n}\n\n/**\n * It is invalid to call most methods once {@link MatrixClient#stopClient} has been called.\n *\n * This error will be thrown if you attempt to do so.\n *\n * {@link MatrixClient#stopClient} itself is an exception to this: it may safely be called multiple times on the same\n * instance.\n */\nexport class ClientStoppedError extends Error {\n    public constructor() {\n        super(\"MatrixClient has been stopped\");\n    }\n}\n\n/**\n * This error is thrown when the Homeserver does not support the delayed events enpdpoints.\n */\nexport class UnsupportedDelayedEventsEndpointError extends Error {\n    public constructor(\n        message: string,\n        public clientEndpoint: \"sendDelayedEvent\" | \"updateDelayedEvent\" | \"sendDelayedStateEvent\" | \"getDelayedEvents\",\n    ) {\n        super(message);\n        this.name = \"UnsupportedDelayedEventsEndpointError\";\n    }\n}\n","/*\nCopyright 2021 - 2023 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { type ExtensibleEventType, type IPartialEvent } from \"../@types/extensible_events.ts\";\n\n/**\n * Represents an Extensible Event in Matrix.\n */\nexport abstract class ExtensibleEvent<TContent extends object = object> {\n    protected constructor(public readonly wireFormat: IPartialEvent<TContent>) {}\n\n    /**\n     * Shortcut to wireFormat.content\n     */\n    public get wireContent(): TContent {\n        return this.wireFormat.content;\n    }\n\n    /**\n     * Serializes the event into a format which can be used to send the\n     * event to the room.\n     * @returns The serialized event.\n     */\n    public abstract serialize(): IPartialEvent<object>;\n\n    /**\n     * Determines if this event is equivalent to the provided event type.\n     * This is recommended over `instanceof` checks due to issues in the JS\n     * runtime (and layering of dependencies in some projects).\n     *\n     * Implementations should pass this check off to their super classes\n     * if their own checks fail. Some primary implementations do not extend\n     * fallback classes given they support the primary type first. Thus,\n     * those classes may return false if asked about their fallback\n     * representation.\n     *\n     * Note that this only checks primary event types: legacy events, like\n     * m.room.message, should/will fail this check.\n     * @param primaryEventType - The (potentially namespaced) event\n     * type.\n     * @returns True if this event *could* be represented as the\n     * given type.\n     */\n    public abstract isEquivalentTo(primaryEventType: ExtensibleEventType): boolean;\n}\n","/*\nCopyright 2022 - 2023 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\n/**\n * Thrown when an event is unforgivably unparsable.\n */\nexport class InvalidEventError extends Error {\n    public constructor(message: string) {\n        super(message);\n    }\n}\n","/*\nCopyright 2022 - 2023 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { type Optional } from \"matrix-events-sdk\";\n\nimport { ExtensibleEvent } from \"./ExtensibleEvent.ts\";\nimport {\n    type ExtensibleEventType,\n    type IMessageRendering,\n    type IPartialEvent,\n    isEventTypeSame,\n    M_HTML,\n    M_MESSAGE,\n    type ExtensibleAnyMessageEventContent,\n    M_TEXT,\n} from \"../@types/extensible_events.ts\";\nimport { isOptionalAString, isProvided } from \"./utilities.ts\";\nimport { InvalidEventError } from \"./InvalidEventError.ts\";\n\n/**\n * Represents a message event. Message events are the simplest form of event with\n * just text (optionally of different mimetypes, like HTML).\n *\n * Message events can additionally be an Emote or Notice, though typically those\n * are represented as EmoteEvent and NoticeEvent respectively.\n */\nexport class MessageEvent extends ExtensibleEvent<ExtensibleAnyMessageEventContent> {\n    /**\n     * The default text for the event.\n     */\n    public readonly text: string;\n\n    /**\n     * The default HTML for the event, if provided.\n     */\n    public readonly html: Optional<string>;\n\n    /**\n     * All the different renderings of the message. Note that this is the same\n     * format as an m.message body but may contain elements not found directly\n     * in the event content: this is because this is interpreted based off the\n     * other information available in the event.\n     */\n    public readonly renderings: IMessageRendering[];\n\n    /**\n     * Creates a new MessageEvent from a pure format. Note that the event is\n     * *not* parsed here: it will be treated as a literal m.message primary\n     * typed event.\n     * @param wireFormat - The event.\n     */\n    public constructor(wireFormat: IPartialEvent<ExtensibleAnyMessageEventContent>) {\n        super(wireFormat);\n\n        const mmessage = M_MESSAGE.findIn(this.wireContent);\n        const mtext = M_TEXT.findIn<string>(this.wireContent);\n        const mhtml = M_HTML.findIn<string>(this.wireContent);\n        if (isProvided(mmessage)) {\n            if (!Array.isArray(mmessage)) {\n                throw new InvalidEventError(\"m.message contents must be an array\");\n            }\n            const text = mmessage.find((r) => !isProvided(r.mimetype) || r.mimetype === \"text/plain\");\n            const html = mmessage.find((r) => r.mimetype === \"text/html\");\n\n            if (!text) throw new InvalidEventError(\"m.message is missing a plain text representation\");\n\n            this.text = text.body;\n            this.html = html?.body;\n            this.renderings = mmessage;\n        } else if (isOptionalAString(mtext)) {\n            this.text = mtext;\n            this.html = mhtml;\n            this.renderings = [{ body: mtext, mimetype: \"text/plain\" }];\n            if (this.html) {\n                this.renderings.push({ body: this.html, mimetype: \"text/html\" });\n            }\n        } else {\n            throw new InvalidEventError(\"Missing textual representation for event\");\n        }\n    }\n\n    public isEquivalentTo(primaryEventType: ExtensibleEventType): boolean {\n        return isEventTypeSame(primaryEventType, M_MESSAGE);\n    }\n\n    protected serializeMMessageOnly(): ExtensibleAnyMessageEventContent {\n        let messageRendering: ExtensibleAnyMessageEventContent = {\n            [M_MESSAGE.name]: this.renderings,\n        };\n\n        // Use the shorthand if it's just a simple text event\n        if (this.renderings.length === 1) {\n            const mime = this.renderings[0].mimetype;\n            if (mime === undefined || mime === \"text/plain\") {\n                messageRendering = {\n                    [M_TEXT.name]: this.renderings[0].body,\n                };\n            }\n        }\n\n        return messageRendering;\n    }\n\n    public serialize(): IPartialEvent<object> {\n        return {\n            type: \"m.room.message\",\n            content: {\n                ...this.serializeMMessageOnly(),\n                body: this.text,\n                msgtype: \"m.text\",\n                format: this.html ? \"org.matrix.custom.html\" : undefined,\n                formatted_body: this.html ?? undefined,\n            },\n        };\n    }\n\n    /**\n     * Creates a new MessageEvent from text and HTML.\n     * @param text - The text.\n     * @param html - Optional HTML.\n     * @returns The representative message event.\n     */\n    public static from(text: string, html?: string): MessageEvent {\n        return new MessageEvent({\n            type: M_MESSAGE.name,\n            content: {\n                [M_TEXT.name]: text,\n                [M_HTML.name]: html,\n            },\n        });\n    }\n}\n","/*\nCopyright 2022 - 2023 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport {\n    type ExtensibleEventType,\n    type IPartialEvent,\n    isEventTypeSame,\n    M_TEXT,\n    REFERENCE_RELATION,\n} from \"../@types/extensible_events.ts\";\nimport { M_POLL_END, type PollEndEventContent } from \"../@types/polls.ts\";\nimport { ExtensibleEvent } from \"./ExtensibleEvent.ts\";\nimport { InvalidEventError } from \"./InvalidEventError.ts\";\nimport { MessageEvent } from \"./MessageEvent.ts\";\n\n/**\n * Represents a poll end/closure event.\n */\nexport class PollEndEvent extends ExtensibleEvent<PollEndEventContent> {\n    /**\n     * The poll start event ID referenced by the response.\n     */\n    public readonly pollEventId: string;\n\n    /**\n     * The closing message for the event.\n     */\n    public readonly closingMessage: MessageEvent;\n\n    /**\n     * Creates a new PollEndEvent from a pure format. Note that the event is *not*\n     * parsed here: it will be treated as a literal m.poll.response primary typed event.\n     * @param wireFormat - The event.\n     */\n    public constructor(wireFormat: IPartialEvent<PollEndEventContent>) {\n        super(wireFormat);\n\n        const rel = this.wireContent[\"m.relates_to\"];\n        if (!REFERENCE_RELATION.matches(rel?.rel_type) || typeof rel?.event_id !== \"string\") {\n            throw new InvalidEventError(\"Relationship must be a reference to an event\");\n        }\n\n        this.pollEventId = rel.event_id;\n        this.closingMessage = new MessageEvent(this.wireFormat);\n    }\n\n    public isEquivalentTo(primaryEventType: ExtensibleEventType): boolean {\n        return isEventTypeSame(primaryEventType, M_POLL_END);\n    }\n\n    public serialize(): IPartialEvent<object> {\n        return {\n            type: M_POLL_END.name,\n            content: {\n                \"m.relates_to\": {\n                    rel_type: REFERENCE_RELATION.name,\n                    event_id: this.pollEventId,\n                },\n                [M_POLL_END.name]: {},\n                ...this.closingMessage.serialize().content,\n            },\n        };\n    }\n\n    /**\n     * Creates a new PollEndEvent from a poll event ID.\n     * @param pollEventId - The poll start event ID.\n     * @param message - A closing message, typically revealing the top answer.\n     * @returns The representative poll closure event.\n     */\n    public static from(pollEventId: string, message: string): PollEndEvent {\n        return new PollEndEvent({\n            type: M_POLL_END.name,\n            content: {\n                \"m.relates_to\": {\n                    rel_type: REFERENCE_RELATION.name,\n                    event_id: pollEventId,\n                },\n                [M_POLL_END.name]: {},\n                [M_TEXT.name]: message,\n            },\n        });\n    }\n}\n","/*\nCopyright 2022 - 2023 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { ExtensibleEvent } from \"./ExtensibleEvent.ts\";\nimport { M_POLL_RESPONSE, type PollResponseEventContent, type PollResponseSubtype } from \"../@types/polls.ts\";\nimport {\n    type ExtensibleEventType,\n    type IPartialEvent,\n    isEventTypeSame,\n    REFERENCE_RELATION,\n} from \"../@types/extensible_events.ts\";\nimport { InvalidEventError } from \"./InvalidEventError.ts\";\nimport { type PollStartEvent } from \"./PollStartEvent.ts\";\n\n/**\n * Represents a poll response event.\n */\nexport class PollResponseEvent extends ExtensibleEvent<PollResponseEventContent> {\n    private internalAnswerIds: string[] = [];\n    private internalSpoiled = false;\n\n    /**\n     * The provided answers for the poll. Note that this may be falsy/unpredictable if\n     * the `spoiled` property is true.\n     */\n    public get answerIds(): string[] {\n        return this.internalAnswerIds;\n    }\n\n    /**\n     * The poll start event ID referenced by the response.\n     */\n    public readonly pollEventId: string;\n\n    /**\n     * Whether the vote is spoiled.\n     */\n    public get spoiled(): boolean {\n        return this.internalSpoiled;\n    }\n\n    /**\n     * Creates a new PollResponseEvent from a pure format. Note that the event is *not*\n     * parsed here: it will be treated as a literal m.poll.response primary typed event.\n     *\n     * To validate the response against a poll, call `validateAgainst` after creation.\n     * @param wireFormat - The event.\n     */\n    public constructor(wireFormat: IPartialEvent<PollResponseEventContent>) {\n        super(wireFormat);\n\n        const rel = this.wireContent[\"m.relates_to\"];\n        if (!REFERENCE_RELATION.matches(rel?.rel_type) || typeof rel?.event_id !== \"string\") {\n            throw new InvalidEventError(\"Relationship must be a reference to an event\");\n        }\n\n        this.pollEventId = rel.event_id;\n        this.validateAgainst(null);\n    }\n\n    /**\n     * Validates the poll response using the poll start event as a frame of reference. This\n     * is used to determine if the vote is spoiled, whether the answers are valid, etc.\n     * @param poll - The poll start event.\n     */\n    public validateAgainst(poll: PollStartEvent | null): void {\n        const response = M_POLL_RESPONSE.findIn<PollResponseSubtype>(this.wireContent);\n        if (!Array.isArray(response?.answers)) {\n            this.internalSpoiled = true;\n            this.internalAnswerIds = [];\n            return;\n        }\n\n        let answers = response?.answers ?? [];\n        if (answers.some((a) => typeof a !== \"string\") || answers.length === 0) {\n            this.internalSpoiled = true;\n            this.internalAnswerIds = [];\n            return;\n        }\n\n        if (poll) {\n            if (answers.some((a) => !poll.answers.some((pa) => pa.id === a))) {\n                this.internalSpoiled = true;\n                this.internalAnswerIds = [];\n                return;\n            }\n\n            answers = answers.slice(0, poll.maxSelections);\n        }\n\n        this.internalAnswerIds = answers;\n        this.internalSpoiled = false;\n    }\n\n    public isEquivalentTo(primaryEventType: ExtensibleEventType): boolean {\n        return isEventTypeSame(primaryEventType, M_POLL_RESPONSE);\n    }\n\n    public serialize(): IPartialEvent<object> {\n        return {\n            type: M_POLL_RESPONSE.name,\n            content: {\n                \"m.relates_to\": {\n                    rel_type: REFERENCE_RELATION.name,\n                    event_id: this.pollEventId,\n                },\n                [M_POLL_RESPONSE.name]: {\n                    answers: this.spoiled ? undefined : this.answerIds,\n                },\n            },\n        };\n    }\n\n    /**\n     * Creates a new PollResponseEvent from a set of answers. To spoil the vote, pass an empty\n     * answers array.\n     * @param answers - The user's answers. Should be valid from a poll's answer IDs.\n     * @param pollEventId - The poll start event ID.\n     * @returns The representative poll response event.\n     */\n    public static from(answers: string[], pollEventId: string): PollResponseEvent {\n        return new PollResponseEvent({\n            type: M_POLL_RESPONSE.name,\n            content: {\n                \"m.relates_to\": {\n                    rel_type: REFERENCE_RELATION.name,\n                    event_id: pollEventId,\n                },\n                [M_POLL_RESPONSE.name]: {\n                    answers: answers,\n                },\n            },\n        });\n    }\n}\n","/*\nCopyright 2022 - 2023 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { NamespacedValue } from \"matrix-events-sdk\";\n\nimport { MessageEvent } from \"./MessageEvent.ts\";\nimport { type ExtensibleEventType, type IPartialEvent, isEventTypeSame, M_TEXT } from \"../@types/extensible_events.ts\";\nimport {\n    type KnownPollKind,\n    M_POLL_KIND_DISCLOSED,\n    M_POLL_KIND_UNDISCLOSED,\n    M_POLL_START,\n    type PollStartEventContent,\n    type PollStartSubtype,\n    type PollAnswer,\n} from \"../@types/polls.ts\";\nimport { InvalidEventError } from \"./InvalidEventError.ts\";\nimport { ExtensibleEvent } from \"./ExtensibleEvent.ts\";\n\n/**\n * Represents a poll answer. Note that this is represented as a subtype and is\n * not registered as a parsable event - it is implied for usage exclusively\n * within the PollStartEvent parsing.\n */\nexport class PollAnswerSubevent extends MessageEvent {\n    /**\n     * The answer ID.\n     */\n    public readonly id: string;\n\n    public constructor(wireFormat: IPartialEvent<PollAnswer>) {\n        super(wireFormat);\n\n        const id = wireFormat.content.id;\n        if (!id || typeof id !== \"string\") {\n            throw new InvalidEventError(\"Answer ID must be a non-empty string\");\n        }\n        this.id = id;\n    }\n\n    public serialize(): IPartialEvent<object> {\n        return {\n            type: \"org.matrix.sdk.poll.answer\",\n            content: {\n                id: this.id,\n                ...this.serializeMMessageOnly(),\n            },\n        };\n    }\n\n    /**\n     * Creates a new PollAnswerSubevent from ID and text.\n     * @param id - The answer ID (unique within the poll).\n     * @param text - The text.\n     * @returns The representative answer.\n     */\n    public static from(id: string, text: string): PollAnswerSubevent {\n        return new PollAnswerSubevent({\n            type: \"org.matrix.sdk.poll.answer\",\n            content: {\n                id: id,\n                [M_TEXT.name]: text,\n            },\n        });\n    }\n}\n\n/**\n * Represents a poll start event.\n */\nexport class PollStartEvent extends ExtensibleEvent<PollStartEventContent> {\n    /**\n     * The question being asked, as a MessageEvent node.\n     */\n    public readonly question: MessageEvent;\n\n    /**\n     * The interpreted kind of poll. Note that this will infer a value that is known to the\n     * SDK rather than verbatim - this means unknown types will be represented as undisclosed\n     * polls.\n     *\n     * To get the raw kind, use rawKind.\n     */\n    public readonly kind: KnownPollKind;\n\n    /**\n     * The true kind as provided by the event sender. Might not be valid.\n     */\n    public readonly rawKind: string;\n\n    /**\n     * The maximum number of selections a user is allowed to make.\n     */\n    public readonly maxSelections: number;\n\n    /**\n     * The possible answers for the poll.\n     */\n    public readonly answers: PollAnswerSubevent[];\n\n    /**\n     * Creates a new PollStartEvent from a pure format. Note that the event is *not*\n     * parsed here: it will be treated as a literal m.poll.start primary typed event.\n     * @param wireFormat - The event.\n     */\n    public constructor(wireFormat: IPartialEvent<PollStartEventContent>) {\n        super(wireFormat);\n\n        const poll = M_POLL_START.findIn<PollStartSubtype>(this.wireContent);\n\n        if (!poll?.question) {\n            throw new InvalidEventError(\"A question is required\");\n        }\n\n        this.question = new MessageEvent({ type: \"org.matrix.sdk.poll.question\", content: poll.question });\n\n        this.rawKind = poll.kind;\n        if (M_POLL_KIND_DISCLOSED.matches(this.rawKind)) {\n            this.kind = M_POLL_KIND_DISCLOSED;\n        } else {\n            this.kind = M_POLL_KIND_UNDISCLOSED; // default & assumed value\n        }\n\n        this.maxSelections =\n            Number.isFinite(poll.max_selections) && poll.max_selections! > 0 ? poll.max_selections! : 1;\n\n        if (!Array.isArray(poll.answers)) {\n            throw new InvalidEventError(\"Poll answers must be an array\");\n        }\n        const answers = poll.answers.slice(0, 20).map(\n            (a) =>\n                new PollAnswerSubevent({\n                    type: \"org.matrix.sdk.poll.answer\",\n                    content: a,\n                }),\n        );\n        if (answers.length <= 0) {\n            throw new InvalidEventError(\"No answers available\");\n        }\n        this.answers = answers;\n    }\n\n    public isEquivalentTo(primaryEventType: ExtensibleEventType): boolean {\n        return isEventTypeSame(primaryEventType, M_POLL_START);\n    }\n\n    public serialize(): IPartialEvent<object> {\n        return {\n            type: M_POLL_START.name,\n            content: {\n                [M_POLL_START.name]: {\n                    question: this.question.serialize().content,\n                    kind: this.rawKind,\n                    max_selections: this.maxSelections,\n                    answers: this.answers.map((a) => a.serialize().content),\n                },\n                [M_TEXT.name]: `${this.question.text}\\n${this.answers.map((a, i) => `${i + 1}. ${a.text}`).join(\"\\n\")}`,\n            },\n        };\n    }\n\n    /**\n     * Creates a new PollStartEvent from question, answers, and metadata.\n     * @param question - The question to ask.\n     * @param answers - The answers. Should be unique within each other.\n     * @param kind - The kind of poll.\n     * @param maxSelections - The maximum number of selections. Must be 1 or higher.\n     * @returns The representative poll start event.\n     */\n    public static from(\n        question: string,\n        answers: string[],\n        kind: KnownPollKind | string,\n        maxSelections = 1,\n    ): PollStartEvent {\n        return new PollStartEvent({\n            type: M_POLL_START.name,\n            content: {\n                [M_TEXT.name]: question, // unused by parsing\n                [M_POLL_START.name]: {\n                    question: { [M_TEXT.name]: question },\n                    kind: kind instanceof NamespacedValue ? kind.name : kind,\n                    max_selections: maxSelections,\n                    answers: answers.map((a) => ({ id: makeId(), [M_TEXT.name]: a })),\n                },\n            },\n        });\n    }\n}\n\nconst LETTERS = \"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789\";\nfunction makeId(): string {\n    return [...Array(16)].map(() => LETTERS.charAt(Math.floor(Math.random() * LETTERS.length))).join(\"\");\n}\n","/*\nCopyright 2021 - 2023 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { type Optional } from \"matrix-events-sdk\";\n\n/**\n * Determines if the given optional was provided a value.\n * @param s - The optional to test.\n * @returns True if the value is defined.\n */\nexport function isProvided<T>(s: Optional<T>): s is T {\n    return s !== null && s !== undefined;\n}\n\n/**\n * Determines if the given optional string is a defined string.\n * @param s - The input string.\n * @returns True if the input is a defined string.\n */\nexport function isOptionalAString(s: Optional<string>): s is string {\n    return isProvided(s) && typeof s === \"string\";\n}\n","/*\nCopyright 2022 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { type IServerVersions } from \"./client.ts\";\n\nexport enum ServerSupport {\n    Stable,\n    Unstable,\n    Unsupported,\n}\n\nexport enum Feature {\n    Thread = \"Thread\",\n    ThreadUnreadNotifications = \"ThreadUnreadNotifications\",\n    /**\n     * @deprecated this is now exposed as a capability not a feature\n     */\n    LoginTokenRequest = \"LoginTokenRequest\",\n    RelationBasedRedactions = \"RelationBasedRedactions\",\n    AccountDataDeletion = \"AccountDataDeletion\",\n    RelationsRecursion = \"RelationsRecursion\",\n    IntentionalMentions = \"IntentionalMentions\",\n}\n\ntype FeatureSupportCondition = {\n    unstablePrefixes?: string[];\n    matrixVersion?: string;\n};\n\nconst featureSupportResolver: Record<string, FeatureSupportCondition> = {\n    [Feature.Thread]: {\n        unstablePrefixes: [\"org.matrix.msc3440\"],\n        matrixVersion: \"v1.3\",\n    },\n    [Feature.ThreadUnreadNotifications]: {\n        unstablePrefixes: [\"org.matrix.msc3771\", \"org.matrix.msc3773\"],\n        matrixVersion: \"v1.4\",\n    },\n    [Feature.LoginTokenRequest]: {\n        unstablePrefixes: [\"org.matrix.msc3882\"],\n    },\n    [Feature.RelationBasedRedactions]: {\n        unstablePrefixes: [\"org.matrix.msc3912\"],\n    },\n    [Feature.AccountDataDeletion]: {\n        unstablePrefixes: [\"org.matrix.msc3391\"],\n    },\n    [Feature.RelationsRecursion]: {\n        unstablePrefixes: [\"org.matrix.msc3981\"],\n        matrixVersion: \"v1.10\",\n    },\n    [Feature.IntentionalMentions]: {\n        unstablePrefixes: [\"org.matrix.msc3952_intentional_mentions\"],\n        matrixVersion: \"v1.7\",\n    },\n};\n\nexport async function buildFeatureSupportMap(versions: IServerVersions): Promise<Map<Feature, ServerSupport>> {\n    const supportMap = new Map<Feature, ServerSupport>();\n    for (const [feature, supportCondition] of Object.entries(featureSupportResolver)) {\n        const supportMatrixVersion = versions.versions?.includes(supportCondition.matrixVersion || \"\") ?? false;\n        const supportUnstablePrefixes =\n            supportCondition.unstablePrefixes?.every((unstablePrefix) => {\n                return versions.unstable_features?.[unstablePrefix] === true;\n            }) ?? false;\n        if (supportMatrixVersion) {\n            supportMap.set(feature as Feature, ServerSupport.Stable);\n        } else if (supportUnstablePrefixes) {\n            supportMap.set(feature as Feature, ServerSupport.Unstable);\n        } else {\n            supportMap.set(feature as Feature, ServerSupport.Unsupported);\n        }\n    }\n    return supportMap;\n}\n","/*\nCopyright 2016 - 2021 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { type RelationType } from \"./@types/event.ts\";\nimport { type MatrixEvent } from \"./models/event.ts\";\nimport { FILTER_RELATED_BY_REL_TYPES, FILTER_RELATED_BY_SENDERS, THREAD_RELATION_TYPE } from \"./models/thread.ts\";\n\n/**\n * Checks if a value matches a given field value, which may be a * terminated\n * wildcard pattern.\n * @param actualValue -  The value to be compared\n * @param filterValue -  The filter pattern to be compared\n * @returns true if the actualValue matches the filterValue\n */\nfunction matchesWildcard(actualValue: string, filterValue: string): boolean {\n    if (filterValue.endsWith(\"*\")) {\n        const typePrefix = filterValue.slice(0, -1);\n        return actualValue.slice(0, typePrefix.length) === typePrefix;\n    } else {\n        return actualValue === filterValue;\n    }\n}\n\n/* eslint-disable camelcase */\nexport interface IFilterComponent {\n    \"types\"?: string[];\n    \"not_types\"?: string[];\n    \"rooms\"?: string[];\n    \"not_rooms\"?: string[];\n    \"senders\"?: string[];\n    \"not_senders\"?: string[];\n    \"contains_url\"?: boolean;\n    \"limit\"?: number;\n    \"related_by_senders\"?: Array<RelationType | string>;\n    \"related_by_rel_types\"?: string[];\n\n    // Unstable values\n    \"io.element.relation_senders\"?: Array<RelationType | string>;\n    \"io.element.relation_types\"?: string[];\n}\n/* eslint-enable camelcase */\n\n/**\n * FilterComponent is a section of a Filter definition which defines the\n * types, rooms, senders filters etc to be applied to a particular type of resource.\n * This is all ported over from synapse's Filter object.\n *\n * N.B. that synapse refers to these as 'Filters', and what js-sdk refers to as\n * 'Filters' are referred to as 'FilterCollections'.\n */\nexport class FilterComponent {\n    public constructor(\n        private filterJson: IFilterComponent,\n        public readonly userId?: string | undefined | null,\n    ) {}\n\n    /**\n     * Checks with the filter component matches the given event\n     * @param event - event to be checked against the filter\n     * @returns true if the event matches the filter\n     */\n    public check(event: MatrixEvent): boolean {\n        const bundledRelationships = event.getUnsigned()?.[\"m.relations\"] || {};\n        const relations: Array<string | RelationType> = Object.keys(bundledRelationships);\n        // Relation senders allows in theory a look-up of any senders\n        // however clients can only know about the current user participation status\n        // as sending a whole list of participants could be proven problematic in terms\n        // of performance\n        // This should be improved when bundled relationships solve that problem\n        const relationSenders: string[] = [];\n        if (this.userId && bundledRelationships?.[THREAD_RELATION_TYPE.name]?.current_user_participated) {\n            relationSenders.push(this.userId);\n        }\n\n        return this.checkFields(\n            event.getRoomId(),\n            event.getSender(),\n            event.getType(),\n            event.getContent() ? event.getContent().url !== undefined : false,\n            relations,\n            relationSenders,\n        );\n    }\n\n    /**\n     * Converts the filter component into the form expected over the wire\n     */\n    public toJSON(): object {\n        return {\n            types: this.filterJson.types || null,\n            not_types: this.filterJson.not_types || [],\n            rooms: this.filterJson.rooms || null,\n            not_rooms: this.filterJson.not_rooms || [],\n            senders: this.filterJson.senders || null,\n            not_senders: this.filterJson.not_senders || [],\n            contains_url: this.filterJson.contains_url || null,\n            [FILTER_RELATED_BY_SENDERS.name]: this.filterJson[FILTER_RELATED_BY_SENDERS.name] || [],\n            [FILTER_RELATED_BY_REL_TYPES.name]: this.filterJson[FILTER_RELATED_BY_REL_TYPES.name] || [],\n        };\n    }\n\n    /**\n     * Checks whether the filter component matches the given event fields.\n     * @param roomId -        the roomId for the event being checked\n     * @param sender -        the sender of the event being checked\n     * @param eventType -     the type of the event being checked\n     * @param containsUrl -  whether the event contains a content.url field\n     * @param relationTypes -  whether has aggregated relation of the given type\n     * @param relationSenders - whether one of the relation is sent by the user listed\n     * @returns true if the event fields match the filter\n     */\n    private checkFields(\n        roomId: string | undefined,\n        sender: string | undefined,\n        eventType: string,\n        containsUrl: boolean,\n        relationTypes: Array<RelationType | string>,\n        relationSenders: string[],\n    ): boolean {\n        const literalKeys = {\n            rooms: function (v: string): boolean {\n                return roomId === v;\n            },\n            senders: function (v: string): boolean {\n                return sender === v;\n            },\n            types: function (v: string): boolean {\n                return matchesWildcard(eventType, v);\n            },\n        } as const;\n\n        for (const name in literalKeys) {\n            const matchFunc = literalKeys[<keyof typeof literalKeys>name];\n            const notName = \"not_\" + name;\n            const disallowedValues = this.filterJson[<`not_${keyof typeof literalKeys}`>notName];\n            if (disallowedValues?.some(matchFunc)) {\n                return false;\n            }\n\n            const allowedValues = this.filterJson[name as keyof typeof literalKeys];\n            if (allowedValues && !allowedValues.some(matchFunc)) {\n                return false;\n            }\n        }\n\n        const containsUrlFilter = this.filterJson.contains_url;\n        if (containsUrlFilter !== undefined && containsUrlFilter !== containsUrl) {\n            return false;\n        }\n\n        const relationTypesFilter = this.filterJson[FILTER_RELATED_BY_REL_TYPES.name];\n        if (relationTypesFilter !== undefined) {\n            if (!this.arrayMatchesFilter(relationTypesFilter, relationTypes)) {\n                return false;\n            }\n        }\n\n        const relationSendersFilter = this.filterJson[FILTER_RELATED_BY_SENDERS.name];\n        if (relationSendersFilter !== undefined) {\n            if (!this.arrayMatchesFilter(relationSendersFilter, relationSenders)) {\n                return false;\n            }\n        }\n\n        return true;\n    }\n\n    private arrayMatchesFilter(filter: any[], values: any[]): boolean {\n        return (\n            values.length > 0 &&\n            filter.every((value) => {\n                return values.includes(value);\n            })\n        );\n    }\n\n    /**\n     * Filters a list of events down to those which match this filter component\n     * @param events -  Events to be checked against the filter component\n     * @returns events which matched the filter component\n     */\n    public filter(events: MatrixEvent[]): MatrixEvent[] {\n        return events.filter(this.check, this);\n    }\n\n    /**\n     * Returns the limit field for a given filter component, providing a default of\n     * 10 if none is otherwise specified. Cargo-culted from Synapse.\n     * @returns the limit for this filter component.\n     */\n    public limit(): number {\n        return this.filterJson.limit !== undefined ? this.filterJson.limit : 10;\n    }\n}\n","/*\nCopyright 2015 - 2021 Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { type EventType, type RelationType } from \"./@types/event.ts\";\nimport { UNREAD_THREAD_NOTIFICATIONS } from \"./@types/sync.ts\";\nimport { FilterComponent, type IFilterComponent } from \"./filter-component.ts\";\nimport { type MatrixEvent } from \"./models/event.ts\";\n\n/**\n */\nfunction setProp(obj: Record<string, any>, keyNesting: string, val: any): void {\n    const nestedKeys = keyNesting.split(\".\") as [keyof typeof obj];\n    let currentObj = obj;\n    for (let i = 0; i < nestedKeys.length - 1; i++) {\n        if (!currentObj[nestedKeys[i]]) {\n            currentObj[nestedKeys[i]] = {};\n        }\n        currentObj = currentObj[nestedKeys[i]];\n    }\n    currentObj[nestedKeys[nestedKeys.length - 1]] = val;\n}\n\n/* eslint-disable camelcase */\nexport interface IFilterDefinition {\n    event_fields?: string[];\n    event_format?: \"client\" | \"federation\";\n    presence?: IFilterComponent;\n    account_data?: IFilterComponent;\n    room?: IRoomFilter;\n}\n\nexport interface IRoomEventFilter extends IFilterComponent {\n    \"lazy_load_members\"?: boolean;\n    \"include_redundant_members\"?: boolean;\n    \"types\"?: Array<EventType | string>;\n    \"related_by_senders\"?: Array<RelationType | string>;\n    \"related_by_rel_types\"?: string[];\n    \"unread_thread_notifications\"?: boolean;\n    \"org.matrix.msc3773.unread_thread_notifications\"?: boolean;\n\n    // Unstable values\n    \"io.element.relation_senders\"?: Array<RelationType | string>;\n    \"io.element.relation_types\"?: string[];\n}\n\ninterface IStateFilter extends IRoomEventFilter {}\n\ninterface IRoomFilter {\n    not_rooms?: string[];\n    rooms?: string[];\n    ephemeral?: IRoomEventFilter;\n    include_leave?: boolean;\n    state?: IStateFilter;\n    timeline?: IRoomEventFilter;\n    account_data?: IRoomEventFilter;\n}\n/* eslint-enable camelcase */\n\nexport class Filter {\n    public static LAZY_LOADING_MESSAGES_FILTER = {\n        lazy_load_members: true,\n    };\n\n    /**\n     * Create a filter from existing data.\n     */\n    public static fromJson(userId: string | undefined | null, filterId: string, jsonObj: IFilterDefinition): Filter {\n        const filter = new Filter(userId, filterId);\n        filter.setDefinition(jsonObj);\n        return filter;\n    }\n\n    private definition: IFilterDefinition = {};\n    private roomFilter?: FilterComponent;\n    private roomTimelineFilter?: FilterComponent;\n\n    /**\n     * Construct a new Filter.\n     * @param userId - The user ID for this filter.\n     * @param filterId - The filter ID if known.\n     */\n    public constructor(\n        public readonly userId: string | undefined | null,\n        public filterId?: string,\n    ) {}\n\n    /**\n     * Get the ID of this filter on your homeserver (if known)\n     * @returns The filter ID\n     */\n    public getFilterId(): string | undefined {\n        return this.filterId;\n    }\n\n    /**\n     * Get the JSON body of the filter.\n     * @returns The filter definition\n     */\n    public getDefinition(): IFilterDefinition {\n        return this.definition;\n    }\n\n    /**\n     * Set the JSON body of the filter\n     * @param definition - The filter definition\n     */\n    public setDefinition(definition: IFilterDefinition): void {\n        this.definition = definition;\n\n        // This is all ported from synapse's FilterCollection()\n\n        // definitions look something like:\n        // {\n        //   \"room\": {\n        //     \"rooms\": [\"!abcde:example.com\"],\n        //     \"not_rooms\": [\"!123456:example.com\"],\n        //     \"state\": {\n        //       \"types\": [\"m.room.*\"],\n        //       \"not_rooms\": [\"!726s6s6q:example.com\"],\n        //       \"lazy_load_members\": true,\n        //     },\n        //     \"timeline\": {\n        //       \"limit\": 10,\n        //       \"types\": [\"m.room.message\"],\n        //       \"not_rooms\": [\"!726s6s6q:example.com\"],\n        //       \"not_senders\": [\"@spam:example.com\"]\n        //       \"contains_url\": true\n        //     },\n        //     \"ephemeral\": {\n        //       \"types\": [\"m.receipt\", \"m.typing\"],\n        //       \"not_rooms\": [\"!726s6s6q:example.com\"],\n        //       \"not_senders\": [\"@spam:example.com\"]\n        //     }\n        //   },\n        //   \"presence\": {\n        //     \"types\": [\"m.presence\"],\n        //     \"not_senders\": [\"@alice:example.com\"]\n        //   },\n        //   \"event_format\": \"client\",\n        //   \"event_fields\": [\"type\", \"content\", \"sender\"]\n        // }\n\n        const roomFilterJson = definition.room;\n\n        // consider the top level rooms/not_rooms filter\n        const roomFilterFields: IRoomFilter = {};\n        if (roomFilterJson) {\n            if (roomFilterJson.rooms) {\n                roomFilterFields.rooms = roomFilterJson.rooms;\n            }\n            if (roomFilterJson.rooms) {\n                roomFilterFields.not_rooms = roomFilterJson.not_rooms;\n            }\n        }\n\n        this.roomFilter = new FilterComponent(roomFilterFields, this.userId);\n        this.roomTimelineFilter = new FilterComponent(roomFilterJson?.timeline || {}, this.userId);\n\n        // don't bother porting this from synapse yet:\n        // this._room_state_filter =\n        //     new FilterComponent(roomFilterJson.state || {});\n        // this._room_ephemeral_filter =\n        //     new FilterComponent(roomFilterJson.ephemeral || {});\n        // this._room_account_data_filter =\n        //     new FilterComponent(roomFilterJson.account_data || {});\n        // this._presence_filter =\n        //     new FilterComponent(definition.presence || {});\n        // this._account_data_filter =\n        //     new FilterComponent(definition.account_data || {});\n    }\n\n    /**\n     * Get the room.timeline filter component of the filter\n     * @returns room timeline filter component\n     */\n    public getRoomTimelineFilterComponent(): FilterComponent | undefined {\n        return this.roomTimelineFilter;\n    }\n\n    /**\n     * Filter the list of events based on whether they are allowed in a timeline\n     * based on this filter\n     * @param events -  the list of events being filtered\n     * @returns the list of events which match the filter\n     */\n    public filterRoomTimeline(events: MatrixEvent[]): MatrixEvent[] {\n        if (this.roomFilter) {\n            events = this.roomFilter.filter(events);\n        }\n        if (this.roomTimelineFilter) {\n            events = this.roomTimelineFilter.filter(events);\n        }\n        return events;\n    }\n\n    /**\n     * Set the max number of events to return for each room's timeline.\n     * @param limit - The max number of events to return for each room.\n     */\n    public setTimelineLimit(limit: number): void {\n        setProp(this.definition, \"room.timeline.limit\", limit);\n    }\n\n    /**\n     * Enable threads unread notification\n     */\n    public setUnreadThreadNotifications(enabled: boolean): void {\n        this.definition = {\n            ...this.definition,\n            room: {\n                ...this.definition?.room,\n                timeline: {\n                    ...this.definition?.room?.timeline,\n                    [UNREAD_THREAD_NOTIFICATIONS.name]: enabled,\n                },\n            },\n        };\n    }\n\n    public setLazyLoadMembers(enabled: boolean): void {\n        setProp(this.definition, \"room.state.lazy_load_members\", enabled);\n    }\n\n    /**\n     * Control whether left rooms should be included in responses.\n     * @param includeLeave - True to make rooms the user has left appear\n     * in responses.\n     */\n    public setIncludeLeaveRooms(includeLeave: boolean): void {\n        setProp(this.definition, \"room.include_leave\", includeLeave);\n    }\n}\n","/*\nCopyright 2022 - 2024 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { type IMatrixApiError as IWidgetMatrixError } from \"matrix-widget-api\";\n\nimport { type IUsageLimit } from \"../@types/partials.ts\";\nimport { type MatrixEvent } from \"../models/event.ts\";\n\ninterface IErrorJson extends Partial<IUsageLimit> {\n    [key: string]: any; // extensible\n    errcode?: string;\n    error?: string;\n}\n\n/**\n * Construct a generic HTTP error. This is a JavaScript Error with additional information\n * specific to HTTP responses.\n * @param msg - The error message to include.\n * @param httpStatus - The HTTP response status code.\n * @param httpHeaders - The HTTP response headers.\n */\nexport class HTTPError extends Error {\n    public constructor(\n        msg: string,\n        public readonly httpStatus?: number,\n        public readonly httpHeaders?: Headers,\n    ) {\n        super(msg);\n    }\n\n    /**\n     * Check if this error was due to rate-limiting on the server side (and should therefore be retried after a delay).\n     *\n     * If this returns `true`, {@link getRetryAfterMs} can be called to retrieve the server-side\n     * recommendation for the retry period.\n     *\n     * @returns Whether this error is due to rate-limiting.\n     */\n    public isRateLimitError(): boolean {\n        return this.httpStatus === 429;\n    }\n\n    /**\n     * @returns The recommended delay in milliseconds to wait before retrying\n     * the request that triggered this error, or null if no delay is recommended.\n     * @throws Error if the recommended delay is an invalid value.\n     * @see {@link safeGetRetryAfterMs} for a version of this check that doesn't throw.\n     */\n    public getRetryAfterMs(): number | null {\n        const retryAfter = this.httpHeaders?.get(\"Retry-After\");\n        if (retryAfter != null) {\n            if (/^\\d+$/.test(retryAfter)) {\n                const ms = Number.parseInt(retryAfter) * 1000;\n                if (!Number.isFinite(ms)) {\n                    throw new Error(\"Retry-After header integer value is too large\");\n                }\n                return ms;\n            }\n            const date = new Date(retryAfter);\n            if (date.toUTCString() !== retryAfter) {\n                throw new Error(\"Retry-After header value is not a valid HTTP-date or non-negative decimal integer\");\n            }\n            return date.getTime() - Date.now();\n        }\n        return null;\n    }\n}\n\nexport class MatrixError extends HTTPError {\n    // The Matrix 'errcode' value, e.g. \"M_FORBIDDEN\".\n    public readonly errcode?: string;\n    // The raw Matrix error JSON used to construct this object.\n    public data: IErrorJson;\n\n    /**\n     * Construct a Matrix error. This is a JavaScript Error with additional\n     * information specific to the standard Matrix error response.\n     * @param errorJson - The Matrix error JSON returned from the homeserver.\n     * @param httpStatus - The numeric HTTP status code given\n     * @param httpHeaders - The HTTP response headers given\n     */\n    public constructor(\n        errorJson: IErrorJson = {},\n        httpStatus?: number,\n        public url?: string,\n        public event?: MatrixEvent,\n        httpHeaders?: Headers,\n    ) {\n        let message = errorJson.error || \"Unknown message\";\n        if (httpStatus) {\n            message = `[${httpStatus}] ${message}`;\n        }\n        if (url) {\n            message = `${message} (${url})`;\n        }\n        super(`MatrixError: ${message}`, httpStatus, httpHeaders);\n        this.errcode = errorJson.errcode;\n        this.name = errorJson.errcode || \"Unknown error code\";\n        this.data = errorJson;\n    }\n\n    public isRateLimitError(): boolean {\n        return (\n            this.errcode === \"M_LIMIT_EXCEEDED\" ||\n            ((this.errcode === \"M_UNKNOWN\" || this.errcode === undefined) && super.isRateLimitError())\n        );\n    }\n\n    public getRetryAfterMs(): number | null {\n        const headerValue = super.getRetryAfterMs();\n        if (headerValue !== null) {\n            return headerValue;\n        }\n        // Note: retry_after_ms is deprecated as of spec version v1.10\n        if (this.errcode === \"M_LIMIT_EXCEEDED\" && \"retry_after_ms\" in this.data) {\n            if (!Number.isInteger(this.data.retry_after_ms)) {\n                throw new Error(\"retry_after_ms is not an integer\");\n            }\n            return this.data.retry_after_ms;\n        }\n        return null;\n    }\n\n    /**\n     * @returns this error expressed as a JSON payload\n     * for use by Widget API error responses.\n     */\n    public asWidgetApiErrorData(): IWidgetMatrixError {\n        const headers: Record<string, string> = {};\n        if (this.httpHeaders) {\n            for (const [name, value] of this.httpHeaders) {\n                headers[name] = value;\n            }\n        }\n        return {\n            http_status: this.httpStatus ?? 400,\n            http_headers: headers,\n            url: this.url ?? \"\",\n            response: {\n                errcode: this.errcode ?? \"M_UNKNOWN\",\n                error: this.data.error ?? \"Unknown message\",\n                ...this.data,\n            },\n        };\n    }\n\n    /**\n     * @returns a new {@link MatrixError} from a JSON payload\n     * received from Widget API error responses.\n     */\n    public static fromWidgetApiErrorData(data: IWidgetMatrixError): MatrixError {\n        return new MatrixError(data.response, data.http_status, data.url, undefined, new Headers(data.http_headers));\n    }\n}\n\n/**\n * @returns The recommended delay in milliseconds to wait before retrying the request.\n * @param error - The error to check for a retry delay.\n * @param defaultMs - The delay to use if the error was not due to rate-limiting or if no valid delay is recommended.\n */\nexport function safeGetRetryAfterMs(error: unknown, defaultMs: number): number {\n    if (!(error instanceof HTTPError) || !error.isRateLimitError()) {\n        return defaultMs;\n    }\n    try {\n        return error.getRetryAfterMs() ?? defaultMs;\n    } catch {\n        return defaultMs;\n    }\n}\n\n/**\n * Construct a ConnectionError. This is a JavaScript Error indicating\n * that a request failed because of some error with the connection, either\n * CORS was not correctly configured on the server, the server didn't response,\n * the request timed out, or the internet connection on the client side went down.\n */\nexport class ConnectionError extends Error {\n    public constructor(message: string, cause?: Error) {\n        super(message + (cause ? `: ${cause.message}` : \"\"));\n    }\n\n    public get name(): string {\n        return \"ConnectionError\";\n    }\n}\n\n/**\n * Construct a TokenRefreshError. This indicates that a request failed due to the token being expired,\n * and attempting to refresh said token also failed but in a way which was not indicative of token invalidation.\n * Assumed to be a temporary failure.\n */\nexport class TokenRefreshError extends Error {\n    public constructor(cause?: Error) {\n        super(cause?.message ?? \"\");\n    }\n\n    public get name(): string {\n        return \"TokenRefreshError\";\n    }\n}\n","/*\nCopyright 2022 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nexport enum Method {\n    Get = \"GET\",\n    Put = \"PUT\",\n    Post = \"POST\",\n    Delete = \"DELETE\",\n    Options = \"OPTIONS\",\n    Head = \"HEAD\",\n    Patch = \"PATCH\",\n}\n","/*\nCopyright 2022 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { type MatrixError } from \"./errors.ts\";\nimport { type Logger } from \"../logger.ts\";\n\nexport type Body = Record<string, any> | BodyInit;\n\n/**\n * @experimental\n * Unencrypted access and (optional) refresh token\n */\nexport type AccessTokens = {\n    accessToken: string;\n    refreshToken?: string;\n};\n/**\n * @experimental\n * Function that performs token refresh using the given refreshToken.\n * Returns a promise that resolves to the refreshed access and (optional) refresh tokens.\n *\n * Can be passed to HttpApi instance as {@link IHttpOpts.tokenRefreshFunction} during client creation {@link ICreateClientOpts}\n */\nexport type TokenRefreshFunction = (refreshToken: string) => Promise<AccessTokens>;\nexport interface IHttpOpts {\n    fetchFn?: typeof globalThis.fetch;\n\n    baseUrl: string;\n    idBaseUrl?: string;\n    prefix: string;\n    extraParams?: Record<string, string>;\n\n    accessToken?: string;\n    /**\n     * Used in conjunction with tokenRefreshFunction to attempt token refresh\n     */\n    refreshToken?: string;\n    /**\n     * Function to attempt token refresh when a possibly expired token is encountered\n     * Optional, only called when a refreshToken is present\n     */\n    tokenRefreshFunction?: TokenRefreshFunction;\n    useAuthorizationHeader?: boolean; // defaults to true\n\n    onlyData?: boolean;\n    localTimeoutMs?: number;\n\n    /** Optional logger instance. If provided, requests and responses will be logged. */\n    logger?: Logger;\n}\n\nexport interface IRequestOpts extends Pick<RequestInit, \"priority\"> {\n    /**\n     * The alternative base url to use.\n     * If not specified, uses this.opts.baseUrl\n     */\n    baseUrl?: string;\n    /**\n     * The full prefix to use e.g.\n     * \"/_matrix/client/v2_alpha\". If not specified, uses this.opts.prefix.\n     */\n    prefix?: string;\n    /**\n     * map of additional request headers\n     */\n    headers?: Record<string, string>;\n    abortSignal?: AbortSignal;\n    /**\n     * The maximum amount of time to wait before\n     * timing out the request. If not specified, there is no timeout.\n     */\n    localTimeoutMs?: number;\n    keepAlive?: boolean; // defaults to false\n    json?: boolean; // defaults to true\n\n    // Set to true to prevent the request function from emitting a Session.logged_out event.\n    // This is intended for use on endpoints where M_UNKNOWN_TOKEN is a valid/notable error response,\n    // such as with token refreshes.\n    inhibitLogoutEmit?: boolean;\n}\n\nexport interface IContentUri {\n    base: string;\n    path: string;\n    params: {\n        // eslint-disable-next-line camelcase\n        access_token: string;\n    };\n}\n\nexport enum HttpApiEvent {\n    SessionLoggedOut = \"Session.logged_out\",\n    NoConsent = \"no_consent\",\n}\n\nexport type HttpApiEventHandlerMap = {\n    /**\n     * Fires whenever the login session the JS SDK is using is no\n     * longer valid and the user must log in again.\n     * NB. This only fires when action is required from the user, not\n     * when then login session can be renewed by using a refresh token.\n     * @example\n     * ```\n     * matrixClient.on(\"Session.logged_out\", function(errorObj){\n     *   // show the login screen\n     * });\n     * ```\n     */\n    [HttpApiEvent.SessionLoggedOut]: (err: MatrixError) => void;\n    /**\n     * Fires when the JS SDK receives a M_CONSENT_NOT_GIVEN error in response\n     * to a HTTP request.\n     * @example\n     * ```\n     * matrixClient.on(\"no_consent\", function(message, contentUri) {\n     *     console.info(message + ' Go to ' + contentUri);\n     * });\n     * ```\n     */\n    [HttpApiEvent.NoConsent]: (message: string, consentUri: string) => void;\n};\n\nexport interface UploadProgress {\n    loaded: number;\n    total: number;\n}\n\nexport interface UploadOpts {\n    /**\n     * Name to give the file on the server. Defaults to <tt>file.name</tt>.\n     */\n    name?: string;\n    /**\n     * Content-type for the upload. Defaults to\n     *   <tt>file.type</tt>, or <tt>applicaton/octet-stream</tt>.\n     */\n    type?: string;\n    /**\n     * if false will not send the filename,\n     *   e.g for encrypted file uploads where filename leaks are undesirable.\n     *   Defaults to true.\n     */\n    includeFilename?: boolean;\n    /**\n     * Optional. Called when a chunk of\n     *    data has been uploaded, with an object containing the fields `loaded`\n     *    (number of bytes transferred) and `total` (total size, if known).\n     */\n    progressHandler?(progress: UploadProgress): void;\n    abortController?: AbortController;\n}\n\nexport interface Upload {\n    loaded: number;\n    total: number;\n    promise: Promise<UploadResponse>;\n    abortController: AbortController;\n}\n\nexport interface UploadResponse {\n    // eslint-disable-next-line camelcase\n    content_uri: string;\n}\n\nexport type FileType = XMLHttpRequestBodyInit;\n","/*\nCopyright 2022 - 2024 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { parse as parseContentType, type ParsedMediaType } from \"content-type\";\n\nimport { logger } from \"../logger.ts\";\nimport { sleep } from \"../utils.ts\";\nimport { ConnectionError, HTTPError, MatrixError, safeGetRetryAfterMs } from \"./errors.ts\";\n\n// Ponyfill for https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal/timeout\nexport function timeoutSignal(ms: number): AbortSignal {\n    const controller = new AbortController();\n    setTimeout(() => {\n        controller.abort();\n    }, ms);\n\n    return controller.signal;\n}\n\nexport function anySignal(signals: AbortSignal[]): {\n    signal: AbortSignal;\n    cleanup(): void;\n} {\n    const controller = new AbortController();\n\n    function cleanup(): void {\n        for (const signal of signals) {\n            signal.removeEventListener(\"abort\", onAbort);\n        }\n    }\n\n    function onAbort(): void {\n        controller.abort();\n        cleanup();\n    }\n\n    for (const signal of signals) {\n        if (signal.aborted) {\n            onAbort();\n            break;\n        }\n        signal.addEventListener(\"abort\", onAbort);\n    }\n\n    return {\n        signal: controller.signal,\n        cleanup,\n    };\n}\n\n/**\n * Attempt to turn an HTTP error response into a Javascript Error.\n *\n * If it is a JSON response, we will parse it into a MatrixError. Otherwise\n * we return a generic Error.\n *\n * @param response - response object\n * @param body - raw body of the response\n * @returns\n */\nexport function parseErrorResponse(response: XMLHttpRequest | Response, body?: string): Error {\n    const httpHeaders = isXhr(response)\n        ? new Headers(\n              response\n                  .getAllResponseHeaders()\n                  .trim()\n                  .split(/[\\r\\n]+/)\n                  .map((header): [string, string] => {\n                      const colonIdx = header.indexOf(\":\");\n                      return [header.substring(0, colonIdx), header.substring(colonIdx + 1)];\n                  }),\n          )\n        : response.headers;\n\n    let contentType: ParsedMediaType | null;\n    try {\n        contentType = getResponseContentType(httpHeaders);\n    } catch (e) {\n        return <Error>e;\n    }\n    if (contentType?.type === \"application/json\" && body) {\n        return new MatrixError(\n            JSON.parse(body),\n            response.status,\n            isXhr(response) ? response.responseURL : response.url,\n            undefined,\n            httpHeaders,\n        );\n    }\n    if (contentType?.type === \"text/plain\") {\n        return new HTTPError(`Server returned ${response.status} error: ${body}`, response.status, httpHeaders);\n    }\n    return new HTTPError(`Server returned ${response.status} error`, response.status, httpHeaders);\n}\n\nfunction isXhr(response: XMLHttpRequest | Response): response is XMLHttpRequest {\n    return \"getResponseHeader\" in response;\n}\n\n/**\n * extract the Content-Type header from response headers, and\n * parse it to a `{type, parameters}` object.\n *\n * returns null if no content-type header could be found.\n *\n * @param response - response object\n * @returns parsed content-type header, or null if not found\n */\nfunction getResponseContentType(headers: Headers): ParsedMediaType | null {\n    const contentType = headers.get(\"Content-Type\");\n    if (contentType === null) return null;\n\n    try {\n        return parseContentType(contentType);\n    } catch (e) {\n        throw new Error(`Error parsing Content-Type '${contentType}': ${e}`);\n    }\n}\n\n/**\n * Retries a network operation run in a callback.\n * @param maxAttempts - maximum attempts to try\n * @param callback - callback that returns a promise of the network operation. If rejected with ConnectionError, it will be retried by calling the callback again.\n * @returns the result of the network operation\n * @throws {@link ConnectionError} If after maxAttempts the callback still throws ConnectionError\n */\nexport async function retryNetworkOperation<T>(maxAttempts: number, callback: () => Promise<T>): Promise<T> {\n    let attempts = 0;\n    let lastConnectionError: ConnectionError | null = null;\n    while (attempts < maxAttempts) {\n        try {\n            if (attempts > 0) {\n                const timeout = 1000 * Math.pow(2, attempts);\n                logger.log(`network operation failed ${attempts} times, retrying in ${timeout}ms...`);\n                await sleep(timeout);\n            }\n            return await callback();\n        } catch (err) {\n            if (err instanceof ConnectionError) {\n                attempts += 1;\n                lastConnectionError = err;\n            } else {\n                throw err;\n            }\n        }\n    }\n    throw lastConnectionError;\n}\n\n/**\n * Calculate the backoff time for a request retry attempt.\n * This produces wait times of 2, 4, 8, and 16 seconds (30s total) after which we give up. If the\n * failure was due to a rate limited request, the time specified in the error is returned.\n *\n * Returns -1 if the error is not retryable, or if we reach the maximum number of attempts.\n *\n * @param err - The error thrown by the http call\n * @param attempts - The number of attempts made so far, including the one that just failed.\n * @param retryConnectionError - Whether to retry on {@link ConnectionError} (CORS, connection is down, etc.)\n */\nexport function calculateRetryBackoff(err: any, attempts: number, retryConnectionError: boolean): number {\n    if (attempts > 4) {\n        return -1; // give up\n    }\n\n    if (err instanceof ConnectionError && !retryConnectionError) {\n        return -1;\n    }\n\n    if (err.httpStatus && Math.floor(err.httpStatus / 100) === 4 && err.httpStatus !== 429) {\n        // client error; no amount of retrying will save you now (except for rate limiting which is handled below)\n        return -1;\n    }\n\n    if (err.name === \"AbortError\") {\n        // this is a client timeout, that is already very high 60s/80s\n        // we don't want to retry, as it could do it for very long\n        return -1;\n    }\n\n    // If we are trying to send an event (or similar) that is too large in any way, then retrying won't help\n    if (err.name === \"M_TOO_LARGE\") {\n        return -1;\n    }\n\n    return safeGetRetryAfterMs(err, 1000 * Math.pow(2, attempts));\n}\n","/*\nCopyright 2022 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\n/**\n * This is an internal module. See {@link MatrixHttpApi} for the public class.\n */\n\nimport { ErrorResponse as OidcAuthError } from \"oidc-client-ts\";\n\nimport { checkObjectHasKeys, encodeParams } from \"../utils.ts\";\nimport { type TypedEventEmitter } from \"../models/typed-event-emitter.ts\";\nimport { Method } from \"./method.ts\";\nimport { ConnectionError, MatrixError, TokenRefreshError } from \"./errors.ts\";\nimport {\n    HttpApiEvent,\n    type HttpApiEventHandlerMap,\n    type IHttpOpts,\n    type IRequestOpts,\n    type Body,\n} from \"./interface.ts\";\nimport { anySignal, parseErrorResponse, timeoutSignal } from \"./utils.ts\";\nimport { type QueryDict } from \"../utils.ts\";\nimport { singleAsyncExecution } from \"../utils/decorators.ts\";\n\ninterface TypedResponse<T> extends Response {\n    json(): Promise<T>;\n}\n\nexport type ResponseType<T, O extends IHttpOpts> = O extends { json: false }\n    ? string\n    : O extends { onlyData: true } | undefined\n      ? T\n      : TypedResponse<T>;\n\nconst enum TokenRefreshOutcome {\n    Success = \"success\",\n    Failure = \"failure\",\n    Logout = \"logout\",\n}\n\nexport class FetchHttpApi<O extends IHttpOpts> {\n    private abortController = new AbortController();\n\n    public constructor(\n        private eventEmitter: TypedEventEmitter<HttpApiEvent, HttpApiEventHandlerMap>,\n        public readonly opts: O,\n    ) {\n        checkObjectHasKeys(opts, [\"baseUrl\", \"prefix\"]);\n        opts.onlyData = !!opts.onlyData;\n        opts.useAuthorizationHeader = opts.useAuthorizationHeader ?? true;\n    }\n\n    public abort(): void {\n        this.abortController.abort();\n        this.abortController = new AbortController();\n    }\n\n    public fetch(resource: URL | string, options?: RequestInit): ReturnType<typeof globalThis.fetch> {\n        if (this.opts.fetchFn) {\n            return this.opts.fetchFn(resource, options);\n        }\n        return globalThis.fetch(resource, options);\n    }\n\n    /**\n     * Sets the base URL for the identity server\n     * @param url - The new base url\n     */\n    public setIdBaseUrl(url?: string): void {\n        this.opts.idBaseUrl = url;\n    }\n\n    public idServerRequest<T extends object = Record<string, unknown>>(\n        method: Method,\n        path: string,\n        params: Record<string, string | string[]> | undefined,\n        prefix: string,\n        accessToken?: string,\n    ): Promise<ResponseType<T, O>> {\n        if (!this.opts.idBaseUrl) {\n            throw new Error(\"No identity server base URL set\");\n        }\n\n        let queryParams: QueryDict | undefined = undefined;\n        let body: Record<string, string | string[]> | undefined = undefined;\n        if (method === Method.Get) {\n            queryParams = params;\n        } else {\n            body = params;\n        }\n\n        const fullUri = this.getUrl(path, queryParams, prefix, this.opts.idBaseUrl);\n\n        const opts: IRequestOpts = {\n            json: true,\n            headers: {},\n        };\n        if (accessToken) {\n            opts.headers!.Authorization = `Bearer ${accessToken}`;\n        }\n\n        return this.requestOtherUrl(method, fullUri, body, opts);\n    }\n\n    /**\n     * Promise used to block authenticated requests during a token refresh to avoid repeated expected errors.\n     * @private\n     */\n    private tokenRefreshPromise?: Promise<unknown>;\n\n    /**\n     * Perform an authorised request to the homeserver.\n     * @param method - The HTTP method e.g. \"GET\".\n     * @param path - The HTTP path <b>after</b> the supplied prefix e.g.\n     * \"/createRoom\".\n     *\n     * @param queryParams - A dict of query params (these will NOT be\n     * urlencoded). If unspecified, there will be no query params.\n     *\n     * @param body - The HTTP JSON body.\n     *\n     * @param paramOpts - additional options.\n     * When `paramOpts.doNotAttemptTokenRefresh` is true, token refresh will not be attempted\n     * when an expired token is encountered. Used to only attempt token refresh once.\n     *\n     * @returns Promise which resolves to\n     * ```\n     * {\n     *     data: {Object},\n     *     headers: {Object},\n     *     code: {Number},\n     * }\n     * ```\n     * If `onlyData` is set, this will resolve to the `data` object only.\n     * @returns Rejects with an error if a problem occurred.\n     * This includes network problems and Matrix-specific error JSON.\n     */\n    public async authedRequest<T>(\n        method: Method,\n        path: string,\n        queryParams?: QueryDict,\n        body?: Body,\n        paramOpts: IRequestOpts & { doNotAttemptTokenRefresh?: boolean } = {},\n    ): Promise<ResponseType<T, O>> {\n        if (!queryParams) queryParams = {};\n\n        // avoid mutating paramOpts so they can be used on retry\n        const opts = { ...paramOpts };\n\n        if (this.opts.accessToken) {\n            if (this.opts.useAuthorizationHeader) {\n                if (!opts.headers) {\n                    opts.headers = {};\n                }\n                if (!opts.headers.Authorization) {\n                    opts.headers.Authorization = \"Bearer \" + this.opts.accessToken;\n                }\n                if (queryParams.access_token) {\n                    delete queryParams.access_token;\n                }\n            } else if (!queryParams.access_token) {\n                queryParams.access_token = this.opts.accessToken;\n            }\n        }\n\n        try {\n            // Await any ongoing token refresh\n            await this.tokenRefreshPromise;\n            const response = await this.request<T>(method, path, queryParams, body, opts);\n            return response;\n        } catch (error) {\n            if (!(error instanceof MatrixError)) {\n                throw error;\n            }\n\n            if (error.errcode === \"M_UNKNOWN_TOKEN\" && !opts.doNotAttemptTokenRefresh) {\n                const tokenRefreshPromise = this.tryRefreshToken();\n                this.tokenRefreshPromise = Promise.allSettled([tokenRefreshPromise]);\n                const outcome = await tokenRefreshPromise;\n\n                if (outcome === TokenRefreshOutcome.Success) {\n                    // if we got a new token retry the request\n                    return this.authedRequest(method, path, queryParams, body, {\n                        ...paramOpts,\n                        doNotAttemptTokenRefresh: true,\n                    });\n                }\n                if (outcome === TokenRefreshOutcome.Failure) {\n                    throw new TokenRefreshError(error);\n                }\n                // Fall through to SessionLoggedOut handler below\n            }\n\n            // otherwise continue with error handling\n            if (error.errcode == \"M_UNKNOWN_TOKEN\" && !opts?.inhibitLogoutEmit) {\n                this.eventEmitter.emit(HttpApiEvent.SessionLoggedOut, error);\n            } else if (error.errcode == \"M_CONSENT_NOT_GIVEN\") {\n                this.eventEmitter.emit(HttpApiEvent.NoConsent, error.message, error.data.consent_uri);\n            }\n\n            throw error;\n        }\n    }\n\n    /**\n     * Attempt to refresh access tokens.\n     * On success, sets new access and refresh tokens in opts.\n     * @returns Promise that resolves to a boolean - true when token was refreshed successfully\n     */\n    @singleAsyncExecution\n    private async tryRefreshToken(): Promise<TokenRefreshOutcome> {\n        if (!this.opts.refreshToken || !this.opts.tokenRefreshFunction) {\n            return TokenRefreshOutcome.Logout;\n        }\n\n        try {\n            const { accessToken, refreshToken } = await this.opts.tokenRefreshFunction(this.opts.refreshToken);\n            this.opts.accessToken = accessToken;\n            this.opts.refreshToken = refreshToken;\n            // successfully got new tokens\n            return TokenRefreshOutcome.Success;\n        } catch (error) {\n            this.opts.logger?.warn(\"Failed to refresh token\", error);\n            if (error instanceof OidcAuthError || error instanceof MatrixError) {\n                return TokenRefreshOutcome.Logout;\n            }\n            return TokenRefreshOutcome.Failure;\n        }\n    }\n\n    /**\n     * Perform a request to the homeserver without any credentials.\n     * @param method - The HTTP method e.g. \"GET\".\n     * @param path - The HTTP path <b>after</b> the supplied prefix e.g.\n     * \"/createRoom\".\n     *\n     * @param queryParams - A dict of query params (these will NOT be\n     * urlencoded). If unspecified, there will be no query params.\n     *\n     * @param body - The HTTP JSON body.\n     *\n     * @param opts - additional options\n     *\n     * @returns Promise which resolves to\n     * ```\n     * {\n     *  data: {Object},\n     *  headers: {Object},\n     *  code: {Number},\n     * }\n     * ```\n     * If `onlyData</code> is set, this will resolve to the <code>data`\n     * object only.\n     * @returns Rejects with an error if a problem\n     * occurred. This includes network problems and Matrix-specific error JSON.\n     */\n    public request<T>(\n        method: Method,\n        path: string,\n        queryParams?: QueryDict,\n        body?: Body,\n        opts?: IRequestOpts,\n    ): Promise<ResponseType<T, O>> {\n        const fullUri = this.getUrl(path, queryParams, opts?.prefix, opts?.baseUrl);\n        return this.requestOtherUrl<T>(method, fullUri, body, opts);\n    }\n\n    /**\n     * Perform a request to an arbitrary URL.\n     * @param method - The HTTP method e.g. \"GET\".\n     * @param url - The HTTP URL object.\n     *\n     * @param body - The HTTP JSON body.\n     *\n     * @param opts - additional options\n     *\n     * @returns Promise which resolves to data unless `onlyData` is specified as false,\n     * where the resolved value will be a fetch Response object.\n     * @returns Rejects with an error if a problem\n     * occurred. This includes network problems and Matrix-specific error JSON.\n     */\n    public async requestOtherUrl<T>(\n        method: Method,\n        url: URL | string,\n        body?: Body,\n        opts: Pick<IRequestOpts, \"headers\" | \"json\" | \"localTimeoutMs\" | \"keepAlive\" | \"abortSignal\" | \"priority\"> = {},\n    ): Promise<ResponseType<T, O>> {\n        const urlForLogs = this.sanitizeUrlForLogs(url);\n        this.opts.logger?.debug(`FetchHttpApi: --> ${method} ${urlForLogs}`);\n\n        const headers = Object.assign({}, opts.headers || {});\n        const json = opts.json ?? true;\n        // We can't use getPrototypeOf here as objects made in other contexts e.g. over postMessage won't have same ref\n        const jsonBody = json && body?.constructor?.name === Object.name;\n\n        if (json) {\n            if (jsonBody && !headers[\"Content-Type\"]) {\n                headers[\"Content-Type\"] = \"application/json\";\n            }\n\n            if (!headers[\"Accept\"]) {\n                headers[\"Accept\"] = \"application/json\";\n            }\n        }\n\n        const timeout = opts.localTimeoutMs ?? this.opts.localTimeoutMs;\n        const keepAlive = opts.keepAlive ?? false;\n        const signals = [this.abortController.signal];\n        if (timeout !== undefined) {\n            signals.push(timeoutSignal(timeout));\n        }\n        if (opts.abortSignal) {\n            signals.push(opts.abortSignal);\n        }\n\n        let data: BodyInit;\n        if (jsonBody) {\n            data = JSON.stringify(body);\n        } else {\n            data = body as BodyInit;\n        }\n\n        const { signal, cleanup } = anySignal(signals);\n\n        let res: Response;\n        const start = Date.now();\n        try {\n            res = await this.fetch(url, {\n                signal,\n                method,\n                body: data,\n                headers,\n                mode: \"cors\",\n                redirect: \"follow\",\n                referrer: \"\",\n                referrerPolicy: \"no-referrer\",\n                cache: \"no-cache\",\n                credentials: \"omit\", // we send credentials via headers\n                keepalive: keepAlive,\n                priority: opts.priority,\n            });\n\n            this.opts.logger?.debug(\n                `FetchHttpApi: <-- ${method} ${urlForLogs} [${Date.now() - start}ms ${res.status}]`,\n            );\n        } catch (e) {\n            this.opts.logger?.debug(`FetchHttpApi: <-- ${method} ${urlForLogs} [${Date.now() - start}ms ${e}]`);\n            if ((<Error>e).name === \"AbortError\") {\n                throw e;\n            }\n            throw new ConnectionError(\"fetch failed\", <Error>e);\n        } finally {\n            cleanup();\n        }\n\n        if (!res.ok) {\n            throw parseErrorResponse(res, await res.text());\n        }\n\n        if (this.opts.onlyData) {\n            return (json ? res.json() : res.text()) as ResponseType<T, O>;\n        }\n        return res as ResponseType<T, O>;\n    }\n\n    private sanitizeUrlForLogs(url: URL | string): string {\n        try {\n            let asUrl: URL;\n            if (typeof url === \"string\") {\n                asUrl = new URL(url);\n            } else {\n                asUrl = url;\n            }\n            // Remove the values of any URL params that could contain potential secrets\n            const sanitizedQs = new URLSearchParams();\n            for (const key of asUrl.searchParams.keys()) {\n                sanitizedQs.append(key, \"xxx\");\n            }\n            const sanitizedQsString = sanitizedQs.toString();\n            const sanitizedQsUrlPiece = sanitizedQsString ? `?${sanitizedQsString}` : \"\";\n\n            return asUrl.origin + asUrl.pathname + sanitizedQsUrlPiece;\n        } catch {\n            // defensive coding for malformed url\n            return \"??\";\n        }\n    }\n    /**\n     * Form and return a homeserver request URL based on the given path params and prefix.\n     * @param path - The HTTP path <b>after</b> the supplied prefix e.g. \"/createRoom\".\n     * @param queryParams - A dict of query params (these will NOT be urlencoded).\n     * @param prefix - The full prefix to use e.g. \"/_matrix/client/v2_alpha\", defaulting to this.opts.prefix.\n     * @param baseUrl - The baseUrl to use e.g. \"https://matrix.org\", defaulting to this.opts.baseUrl.\n     * @returns URL\n     */\n    public getUrl(path: string, queryParams?: QueryDict, prefix?: string, baseUrl?: string): URL {\n        const baseUrlWithFallback = baseUrl ?? this.opts.baseUrl;\n        const baseUrlWithoutTrailingSlash = baseUrlWithFallback.endsWith(\"/\")\n            ? baseUrlWithFallback.slice(0, -1)\n            : baseUrlWithFallback;\n        const url = new URL(baseUrlWithoutTrailingSlash + (prefix ?? this.opts.prefix) + path);\n        if (queryParams) {\n            encodeParams(queryParams, url.searchParams);\n        }\n        return url;\n    }\n}\n","/*\nCopyright 2025 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\n/**\n * Method decorator to ensure that only one instance of the method is running at a time,\n * and any concurrent calls will return the same promise as the original call.\n * After execution is complete a new call will be able to run the method again.\n */\nexport function singleAsyncExecution<This, Args extends unknown[], Return>(\n    target: (this: This, ...args: Args) => Promise<Return>,\n): (this: This, ...args: Args) => Promise<Return> {\n    let promise: Promise<Return> | undefined;\n\n    async function replacementMethod(this: This, ...args: Args): Promise<Return> {\n        if (promise) return promise;\n        try {\n            promise = target.call(this, ...args);\n            await promise;\n            return promise;\n        } finally {\n            promise = undefined;\n        }\n    }\n\n    return replacementMethod;\n}\n","/*\nCopyright 2022 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nexport enum ClientPrefix {\n    /**\n     * A constant representing the URI path for Client-Server API endpoints versioned at v1.\n     */\n    V1 = \"/_matrix/client/v1\",\n    /**\n     * A constant representing the URI path for Client-Server API endpoints versioned at v3.\n     */\n    V3 = \"/_matrix/client/v3\",\n    /**\n     * A constant representing the URI path for as-yet unspecified Client-Server HTTP APIs.\n     */\n    Unstable = \"/_matrix/client/unstable\",\n}\n\nexport enum IdentityPrefix {\n    /**\n     * URI path for the v2 identity API\n     */\n    V2 = \"/_matrix/identity/v2\",\n}\n\nexport enum MediaPrefix {\n    /**\n     * A constant representing the URI path for Client-Server API Media endpoints versioned at v1.\n     */\n    V1 = \"/_matrix/media/v1\",\n    /**\n     * A constant representing the URI path for Client-Server API Media endpoints versioned at v3.\n     */\n    V3 = \"/_matrix/media/v3\",\n}\n","/*\nCopyright 2016 OpenMarket Ltd\nCopyright 2019 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\n/* A re-implementation of the javascript callback functions (setTimeout,\n * clearTimeout; setInterval and clearInterval are not yet implemented) which\n * try to improve handling of large clock jumps (as seen when\n * suspending/resuming the system).\n *\n * In particular, if a timeout would have fired while the system was suspended,\n * it will instead fire as soon as possible after resume.\n */\n\nimport { logger } from \"./logger.ts\";\n\n// we schedule a callback at least this often, to check if we've missed out on\n// some wall-clock time due to being suspended.\nconst TIMER_CHECK_PERIOD_MS = 1000;\n\n// counter, for making up ids to return from setTimeout\nlet count = 0;\n\n// the key for our callback with the real globalThis.setTimeout\nlet realCallbackKey: NodeJS.Timeout | number;\n\ntype Callback = {\n    runAt: number;\n    func: (...params: any[]) => void;\n    params: any[];\n    key: number;\n};\n\n// a sorted list of the callbacks to be run.\n// each is an object with keys [runAt, func, params, key].\nconst callbackList: Callback[] = [];\n\n// var debuglog = logger.log.bind(logger);\n/* istanbul ignore next */\nconst debuglog = function (...params: any[]): void {};\n\n/**\n * reimplementation of window.setTimeout, which will call the callback if\n * the wallclock time goes past the deadline.\n *\n * @param func -   callback to be called after a delay\n * @param delayMs -  number of milliseconds to delay by\n *\n * @returns an identifier for this callback, which may be passed into\n *                   clearTimeout later.\n */\nexport function setTimeout(func: (...params: any[]) => void, delayMs: number, ...params: any[]): number {\n    delayMs = delayMs || 0;\n    if (delayMs < 0) {\n        delayMs = 0;\n    }\n\n    const runAt = Date.now() + delayMs;\n    const key = count++;\n    debuglog(\"setTimeout: scheduling cb\", key, \"at\", runAt, \"(delay\", delayMs, \")\");\n    const data = {\n        runAt: runAt,\n        func: func,\n        params: params,\n        key: key,\n    };\n\n    // figure out where it goes in the list\n    const idx = binarySearch(callbackList, function (el) {\n        return el.runAt - runAt;\n    });\n\n    callbackList.splice(idx, 0, data);\n    scheduleRealCallback();\n\n    return key;\n}\n\n/**\n * reimplementation of window.clearTimeout, which mirrors setTimeout\n *\n * @param key -   result from an earlier setTimeout call\n */\nexport function clearTimeout(key: number): void {\n    if (callbackList.length === 0) {\n        return;\n    }\n\n    // remove the element from the list\n    let i: number;\n    for (i = 0; i < callbackList.length; i++) {\n        const cb = callbackList[i];\n        if (cb.key == key) {\n            callbackList.splice(i, 1);\n            break;\n        }\n    }\n\n    // iff it was the first one in the list, reschedule our callback.\n    if (i === 0) {\n        scheduleRealCallback();\n    }\n}\n\n// use the real globalThis.setTimeout to schedule a callback to runCallbacks.\nfunction scheduleRealCallback(): void {\n    if (realCallbackKey) {\n        globalThis.clearTimeout(realCallbackKey as NodeJS.Timeout);\n    }\n\n    const first = callbackList[0];\n\n    if (!first) {\n        debuglog(\"scheduleRealCallback: no more callbacks, not rescheduling\");\n        return;\n    }\n\n    const timestamp = Date.now();\n    const delayMs = Math.min(first.runAt - timestamp, TIMER_CHECK_PERIOD_MS);\n\n    debuglog(\"scheduleRealCallback: now:\", timestamp, \"delay:\", delayMs);\n    realCallbackKey = globalThis.setTimeout(runCallbacks, delayMs);\n}\n\nfunction runCallbacks(): void {\n    const timestamp = Date.now();\n    debuglog(\"runCallbacks: now:\", timestamp);\n\n    // get the list of things to call\n    const callbacksToRun: Callback[] = [];\n    // eslint-disable-next-line\n    while (true) {\n        const first = callbackList[0];\n        if (!first || first.runAt > timestamp) {\n            break;\n        }\n        const cb = callbackList.shift()!;\n        debuglog(\"runCallbacks: popping\", cb.key);\n        callbacksToRun.push(cb);\n    }\n\n    // reschedule the real callback before running our functions, to\n    // keep the codepaths the same whether or not our functions\n    // register their own setTimeouts.\n    scheduleRealCallback();\n\n    for (const cb of callbacksToRun) {\n        try {\n            cb.func.apply(globalThis, cb.params);\n        } catch (e) {\n            logger.error(\"Uncaught exception in callback function\", e);\n        }\n    }\n}\n\n/* search in a sorted array.\n *\n * returns the index of the last element for which func returns\n * greater than zero, or array.length if no such element exists.\n */\nfunction binarySearch<T>(array: T[], func: (v: T) => number): number {\n    // min is inclusive, max exclusive.\n    let min = 0;\n    let max = array.length;\n\n    while (min < max) {\n        const mid = (min + max) >> 1;\n        const res = func(array[mid]);\n        if (res > 0) {\n            // the element at 'mid' is too big; set it as the new max.\n            max = mid;\n        } else {\n            // the element at 'mid' is too small. 'min' is inclusive, so +1.\n            min = mid + 1;\n        }\n    }\n    // presumably, min==max now.\n    return min;\n}\n","/*\nCopyright 2022 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { FetchHttpApi } from \"./fetch.ts\";\nimport {\n    type FileType,\n    type IContentUri,\n    type IHttpOpts,\n    type Upload,\n    type UploadOpts,\n    type UploadResponse,\n} from \"./interface.ts\";\nimport { MediaPrefix } from \"./prefix.ts\";\nimport { defer, type QueryDict, removeElement } from \"../utils.ts\";\nimport * as callbacks from \"../realtime-callbacks.ts\";\nimport { Method } from \"./method.ts\";\nimport { ConnectionError } from \"./errors.ts\";\nimport { parseErrorResponse } from \"./utils.ts\";\n\nexport * from \"./interface.ts\";\nexport * from \"./prefix.ts\";\nexport * from \"./errors.ts\";\nexport * from \"./method.ts\";\nexport * from \"./utils.ts\";\n\nexport class MatrixHttpApi<O extends IHttpOpts> extends FetchHttpApi<O> {\n    private uploads: Upload[] = [];\n\n    /**\n     * Upload content to the homeserver\n     *\n     * @param file - The object to upload. On a browser, something that\n     *   can be sent to XMLHttpRequest.send (typically a File).  Under node.js,\n     *   a Buffer, String or ReadStream.\n     *\n     * @param opts - options object\n     *\n     * @returns Promise which resolves to response object, as\n     *    determined by this.opts.onlyData, opts.rawResponse, and\n     *    opts.onlyContentUri.  Rejects with an error (usually a MatrixError).\n     */\n    public uploadContent(file: FileType, opts: UploadOpts = {}): Promise<UploadResponse> {\n        const includeFilename = opts.includeFilename ?? true;\n        const abortController = opts.abortController ?? new AbortController();\n\n        // If the file doesn't have a mime type, use a default since the HS errors if we don't supply one.\n        const contentType = (opts.type ?? (file as File).type) || \"application/octet-stream\";\n        const fileName = opts.name ?? (file as File).name;\n\n        const upload = {\n            loaded: 0,\n            total: 0,\n            abortController,\n        } as Upload;\n        const deferred = defer<UploadResponse>();\n\n        if (globalThis.XMLHttpRequest) {\n            const xhr = new globalThis.XMLHttpRequest();\n\n            const timeoutFn = function (): void {\n                xhr.abort();\n                deferred.reject(new Error(\"Timeout\"));\n            };\n\n            // set an initial timeout of 30s; we'll advance it each time we get a progress notification\n            let timeoutTimer = callbacks.setTimeout(timeoutFn, 30000);\n\n            xhr.onreadystatechange = function (): void {\n                switch (xhr.readyState) {\n                    case globalThis.XMLHttpRequest.DONE:\n                        callbacks.clearTimeout(timeoutTimer);\n                        try {\n                            if (xhr.status === 0) {\n                                throw new DOMException(xhr.statusText, \"AbortError\"); // mimic fetch API\n                            }\n                            if (!xhr.responseText) {\n                                throw new Error(\"No response body.\");\n                            }\n\n                            if (xhr.status >= 400) {\n                                deferred.reject(parseErrorResponse(xhr, xhr.responseText));\n                            } else {\n                                deferred.resolve(JSON.parse(xhr.responseText));\n                            }\n                        } catch (err) {\n                            if ((<Error>err).name === \"AbortError\") {\n                                deferred.reject(err);\n                                return;\n                            }\n                            deferred.reject(new ConnectionError(\"request failed\", <Error>err));\n                        }\n                        break;\n                }\n            };\n\n            xhr.upload.onprogress = (ev: ProgressEvent): void => {\n                callbacks.clearTimeout(timeoutTimer);\n                upload.loaded = ev.loaded;\n                upload.total = ev.total;\n                timeoutTimer = callbacks.setTimeout(timeoutFn, 30000);\n                opts.progressHandler?.({\n                    loaded: ev.loaded,\n                    total: ev.total,\n                });\n            };\n\n            const url = this.getUrl(\"/upload\", undefined, MediaPrefix.V3);\n\n            if (includeFilename && fileName) {\n                url.searchParams.set(\"filename\", encodeURIComponent(fileName));\n            }\n\n            if (!this.opts.useAuthorizationHeader && this.opts.accessToken) {\n                url.searchParams.set(\"access_token\", encodeURIComponent(this.opts.accessToken));\n            }\n\n            xhr.open(Method.Post, url.href);\n            if (this.opts.useAuthorizationHeader && this.opts.accessToken) {\n                xhr.setRequestHeader(\"Authorization\", \"Bearer \" + this.opts.accessToken);\n            }\n            xhr.setRequestHeader(\"Content-Type\", contentType);\n            xhr.send(file);\n\n            abortController.signal.addEventListener(\"abort\", () => {\n                xhr.abort();\n            });\n        } else {\n            const queryParams: QueryDict = {};\n            if (includeFilename && fileName) {\n                queryParams.filename = fileName;\n            }\n\n            const headers: Record<string, string> = { \"Content-Type\": contentType };\n\n            this.authedRequest<UploadResponse>(Method.Post, \"/upload\", queryParams, file, {\n                prefix: MediaPrefix.V3,\n                headers,\n                abortSignal: abortController.signal,\n            })\n                .then((response) => {\n                    return this.opts.onlyData ? <UploadResponse>response : response.json();\n                })\n                .then(deferred.resolve, deferred.reject);\n        }\n\n        // remove the upload from the list on completion\n        upload.promise = deferred.promise.finally(() => {\n            removeElement(this.uploads, (elem) => elem === upload);\n        });\n        abortController.signal.addEventListener(\"abort\", () => {\n            removeElement(this.uploads, (elem) => elem === upload);\n            deferred.reject(new DOMException(\"Aborted\", \"AbortError\"));\n        });\n        this.uploads.push(upload);\n        return upload.promise;\n    }\n\n    public cancelUpload(promise: Promise<UploadResponse>): boolean {\n        const upload = this.uploads.find((u) => u.promise === promise);\n        if (upload) {\n            upload.abortController.abort();\n            return true;\n        }\n        return false;\n    }\n\n    public getCurrentUploads(): Upload[] {\n        return this.uploads;\n    }\n\n    /**\n     * Get the content repository url with query parameters.\n     * @returns An object with a 'base', 'path' and 'params' for base URL,\n     *          path and query parameters respectively.\n     */\n    public getContentUri(): IContentUri {\n        return {\n            base: this.opts.baseUrl,\n            path: MediaPrefix.V3 + \"/upload\",\n            params: {\n                access_token: this.opts.accessToken!,\n            },\n        };\n    }\n}\n","/*\nCopyright 2016 OpenMarket Ltd\nCopyright 2017 Vector Creations Ltd\nCopyright 2019 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { logger } from \"./logger.ts\";\nimport { type MatrixClient } from \"./client.ts\";\nimport { defer, type IDeferred } from \"./utils.ts\";\nimport { MatrixError } from \"./http-api/index.ts\";\nimport { type UserIdentifier } from \"./@types/auth.ts\";\n\nconst EMAIL_STAGE_TYPE = \"m.login.email.identity\";\nconst MSISDN_STAGE_TYPE = \"m.login.msisdn\";\n\nexport interface UIAFlow {\n    stages: Array<AuthType | string>;\n}\n\nexport interface IInputs {\n    // An email address. If supplied, a flow using email verification will be chosen.\n    emailAddress?: string;\n    // An ISO two letter country code. Gives the country that opts.phoneNumber should be resolved relative to.\n    phoneCountry?: string;\n    // A phone number. If supplied, a flow using phone number validation will be chosen.\n    phoneNumber?: string;\n    registrationToken?: string;\n}\n\nexport interface IStageStatus {\n    emailSid?: string;\n    errcode?: string;\n    error?: string;\n}\n\n/**\n * Data returned in the body of a 401 response from a UIA endpoint.\n *\n * @see https://spec.matrix.org/v1.6/client-server-api/#user-interactive-api-in-the-rest-api\n */\nexport interface IAuthData {\n    /**\n     * This is a session identifier that the client must pass back to the home server,\n     * if one is provided, in subsequent attempts to authenticate in the same API call.\n     */\n    session?: string;\n    /**\n     * A list of the stages the client has completed successfully\n     */\n    completed?: string[];\n    /**\n     * A list of the login flows supported by the server for this API.\n     */\n    flows?: UIAFlow[];\n    /**\n     * Contains any information that the client will need to know in order to use a given type of authentication.\n     * For each login type presented, that type may be present as a key in this dictionary.\n     * For example, the public part of an OAuth client ID could be given here.\n     */\n    params?: Record<string, Record<string, any>>;\n}\n\nexport enum AuthType {\n    Password = \"m.login.password\",\n    Recaptcha = \"m.login.recaptcha\",\n    Terms = \"m.login.terms\",\n    Email = \"m.login.email.identity\",\n    Msisdn = \"m.login.msisdn\",\n    Sso = \"m.login.sso\",\n    SsoUnstable = \"org.matrix.login.sso\",\n    Dummy = \"m.login.dummy\",\n    RegistrationToken = \"m.login.registration_token\",\n    // For backwards compatability with servers that have not yet updated to\n    // use the stable \"m.login.registration_token\" type.\n    // The authentication flow is the same in both cases.\n    UnstableRegistrationToken = \"org.matrix.msc3231.login.registration_token\",\n}\n\n/**\n * https://spec.matrix.org/v1.7/client-server-api/#password-based\n */\ntype PasswordDict = {\n    type: AuthType.Password;\n    identifier: UserIdentifier;\n    password: string;\n    session: string;\n};\n\n/**\n * https://spec.matrix.org/v1.7/client-server-api/#google-recaptcha\n */\ntype RecaptchaDict = {\n    type: AuthType.Recaptcha;\n    response: string;\n    session: string;\n};\n\ninterface ThreepidCreds {\n    sid: string;\n    client_secret: string;\n    id_server: string;\n    id_access_token: string;\n}\n\n/**\n * https://spec.matrix.org/v1.7/client-server-api/#email-based-identity--homeserver\n */\ntype EmailIdentityDict = {\n    type: AuthType.Email;\n    threepid_creds: ThreepidCreds;\n    session: string;\n};\n\n/**\n * The parameters which are submitted as the `auth` dict in a UIA request\n *\n * @see https://spec.matrix.org/v1.6/client-server-api/#authentication-types\n */\nexport type AuthDict =\n    | PasswordDict\n    | RecaptchaDict\n    | EmailIdentityDict\n    | { type: Exclude<string, AuthType>; [key: string]: any }\n    // eslint-disable-next-line @typescript-eslint/no-empty-object-type\n    | {};\n\nexport class NoAuthFlowFoundError extends Error {\n    public name = \"NoAuthFlowFoundError\";\n\n    public constructor(\n        m: string,\n        // eslint-disable-next-line @typescript-eslint/naming-convention, camelcase\n        public readonly required_stages: string[],\n        public readonly flows: UIAFlow[],\n    ) {\n        super(m);\n    }\n}\n\n/**\n * The type of an application callback to perform the user-interactive bit of UIA.\n *\n * It is called with a single parameter, `makeRequest`, which is a function which takes the UIA parameters and\n * makes the HTTP request. The `authData` parameter in `makeRequest` can be set to null to omit the `auth` field\n * from the UIA request.\n *\n * The generic parameter `T` is the type of the response of the endpoint, once it is eventually successful.\n */\nexport type UIAuthCallback<T> = (makeRequest: (authData: AuthDict | null) => Promise<T>) => Promise<T>;\n\ninterface IOpts<T> {\n    /**\n     * A matrix client to use for the auth process\n     */\n    matrixClient: MatrixClient;\n    /**\n     * Error response from the last request. If null, a request will be made with no auth before starting.\n     */\n    authData?: IAuthData;\n    /**\n     * Inputs provided by the user and used by different stages of the auto process.\n     * The inputs provided will affect what flow is chosen.\n     */\n    inputs?: IInputs;\n    /**\n     * If resuming an existing interactive auth session, the sessionId of that session.\n     */\n    sessionId?: string;\n    /**\n     * If resuming an existing interactive auth session, the client secret for that session\n     */\n    clientSecret?: string;\n    /**\n     * If returning from having completed m.login.email.identity auth, the sid for the email verification session.\n     */\n    emailSid?: string;\n\n    /**\n     * If specified, will prefer flows which entirely consist of listed stages.\n     * These should normally be of type AuthTypes but can be string when supporting custom auth stages.\n     *\n     * This can be used to avoid needing the fallback mechanism.\n     */\n    supportedStages?: Array<AuthType | string>;\n\n    /**\n     * Called with the new auth dict to submit the request.\n     * Also passes a second deprecated arg which is a flag set to true if this request is a background request.\n     * The busyChanged callback should be used instead of the background flag.\n     * Should return a promise which resolves to the successful response or rejects with a MatrixError.\n     */\n    doRequest(auth: AuthDict | null, background: boolean): Promise<T>;\n    /**\n     * Called when the status of the UI auth changes,\n     * ie. when the state of an auth stage changes of when the auth flow moves to a new stage.\n     * The arguments are: the login type (eg m.login.password); and an object which is either an error or an\n     * informational object specific to the login type.\n     * If the 'errcode' key is defined, the object is an error, and has keys:\n     *     errcode: string, the textual error code, eg. M_UNKNOWN\n     *     error: string, human readable string describing the error\n     *\n     * The login type specific objects are as follows:\n     *     m.login.email.identity:\n     *         * emailSid: string, the sid of the active email auth session\n     */\n    stateUpdated(nextStage: AuthType | string, status: IStageStatus): void;\n\n    /**\n     * A function that takes the email address (string), clientSecret (string), attempt number (int) and\n     * sessionId (string) and calls the relevant requestToken function and returns the promise returned by that\n     * function.\n     * If the resulting promise rejects, the rejection will propagate through to the attemptAuth promise.\n     */\n    requestEmailToken(email: string, secret: string, attempt: number, session: string): Promise<{ sid: string }>;\n    /**\n     * Called whenever the interactive auth logic becomes busy submitting information provided by the user or finishes.\n     * After this has been called with true the UI should indicate that a request is in progress\n     * until it is called again with false.\n     */\n    busyChanged?(busy: boolean): void;\n    startAuthStage?(nextStage: string): Promise<void>; // LEGACY\n}\n\n/**\n * Abstracts the logic used to drive the interactive auth process.\n *\n * <p>Components implementing an interactive auth flow should instantiate one of\n * these, passing in the necessary callbacks to the constructor. They should\n * then call attemptAuth, which will return a promise which will resolve or\n * reject when the interactive-auth process completes.\n *\n * <p>Meanwhile, calls will be made to the startAuthStage and doRequest\n * callbacks, and information gathered from the user can be submitted with\n * submitAuthDict.\n *\n * @param opts - options object\n * @typeParam T - the return type of the request when it is successful\n */\nexport class InteractiveAuth<T> {\n    private readonly matrixClient: MatrixClient;\n    private readonly inputs: IInputs;\n    private readonly clientSecret: string;\n    private readonly requestCallback: IOpts<T>[\"doRequest\"];\n    private readonly busyChangedCallback?: IOpts<T>[\"busyChanged\"];\n    private readonly stateUpdatedCallback: IOpts<T>[\"stateUpdated\"];\n    private readonly requestEmailTokenCallback: IOpts<T>[\"requestEmailToken\"];\n    private readonly supportedStages?: Set<string>;\n\n    // The current latest data or error received from the server during the user interactive auth flow.\n    private data: IAuthData & MatrixError[\"data\"];\n    private emailSid?: string;\n    private requestingEmailToken = false;\n    private attemptAuthDeferred: IDeferred<T> | null = null;\n    private chosenFlow: UIAFlow | null = null;\n    private currentStage: string | null = null;\n\n    private emailAttempt = 1;\n\n    // if we are currently trying to submit an auth dict (which includes polling)\n    // the promise the will resolve/reject when it completes\n    private submitPromise: Promise<void> | null = null;\n\n    public constructor(opts: IOpts<T>) {\n        this.matrixClient = opts.matrixClient;\n        this.data = opts.authData || { flows: [] };\n        this.requestCallback = opts.doRequest;\n        this.busyChangedCallback = opts.busyChanged;\n        // startAuthStage included for backwards compat\n        this.stateUpdatedCallback = opts.stateUpdated || opts.startAuthStage;\n        this.requestEmailTokenCallback = opts.requestEmailToken;\n        this.inputs = opts.inputs || {};\n\n        if (opts.sessionId) this.data.session = opts.sessionId;\n        this.clientSecret = opts.clientSecret || this.matrixClient.generateClientSecret();\n        this.emailSid = opts.emailSid;\n        if (opts.supportedStages !== undefined) this.supportedStages = new Set(opts.supportedStages);\n    }\n\n    /**\n     * begin the authentication process.\n     *\n     * @returns which resolves to the response on success,\n     * or rejects with the error on failure. Rejects with NoAuthFlowFoundError if\n     *     no suitable authentication flow can be found\n     */\n    public async attemptAuth(): Promise<T> {\n        // This promise will be quite long-lived and will resolve when the\n        // request is authenticated and completes successfully.\n        this.attemptAuthDeferred = defer();\n        // pluck the promise out now, as doRequest may clear before we return\n        const promise = this.attemptAuthDeferred.promise;\n\n        // if we have no flows, try a request to acquire the flows\n        if (!(this.data as IAuthData)?.flows?.length) {\n            this.busyChangedCallback?.(true);\n            // use the existing sessionId, if one is present.\n            const auth = (this.data as IAuthData).session ? { session: (this.data as IAuthData).session } : null;\n            this.doRequest(auth).finally(() => {\n                this.busyChangedCallback?.(false);\n            });\n        } else {\n            this.startNextAuthStage();\n        }\n\n        return promise;\n    }\n\n    /**\n     * Poll to check if the auth session or current stage has been\n     * completed out-of-band. If so, the attemptAuth promise will\n     * be resolved.\n     */\n    public async poll(): Promise<void> {\n        if (!(this.data as IAuthData).session) return;\n        // likewise don't poll if there is no auth session in progress\n        if (!this.attemptAuthDeferred) return;\n        // if we currently have a request in flight, there's no point making\n        // another just to check what the status is\n        if (this.submitPromise) return;\n\n        let authDict: AuthDict = {};\n        if (this.currentStage == EMAIL_STAGE_TYPE) {\n            // The email can be validated out-of-band, but we need to provide the\n            // creds so the HS can go & check it.\n            if (this.emailSid) {\n                const creds: Record<string, string> = {\n                    sid: this.emailSid,\n                    client_secret: this.clientSecret,\n                };\n                const isUrl = this.matrixClient.getIdentityServerUrl();\n                if (isUrl) {\n                    creds.id_server = new URL(isUrl).host;\n                }\n                authDict = {\n                    type: EMAIL_STAGE_TYPE,\n                    threepid_creds: creds,\n                };\n            }\n        }\n\n        this.submitAuthDict(authDict, true);\n    }\n\n    /**\n     * get the auth session ID\n     *\n     * @returns session id\n     */\n    public getSessionId(): string | undefined {\n        return (this.data as IAuthData)?.session;\n    }\n\n    /**\n     * get the client secret used for validation sessions\n     * with the identity server.\n     *\n     * @returns client secret\n     */\n    public getClientSecret(): string {\n        return this.clientSecret;\n    }\n\n    /**\n     * get the server params for a given stage\n     *\n     * @param loginType - login type for the stage\n     * @returns any parameters from the server for this stage\n     */\n    public getStageParams(loginType: string): Record<string, any> | undefined {\n        return (this.data as IAuthData)?.params?.[loginType];\n    }\n\n    public getChosenFlow(): UIAFlow | null {\n        return this.chosenFlow;\n    }\n\n    /**\n     * submit a new auth dict and fire off the request. This will either\n     * make attemptAuth resolve/reject, or cause the startAuthStage callback\n     * to be called for a new stage.\n     *\n     * @param authData - new auth dict to send to the server. Should\n     *    include a `type` property denoting the login type, as well as any\n     *    other params for that stage.\n     * @param background - If true, this request failing will not result\n     *    in the attemptAuth promise being rejected. This can be set to true\n     *    for requests that just poll to see if auth has been completed elsewhere.\n     */\n    public async submitAuthDict(authData: AuthDict, background = false): Promise<void> {\n        if (!this.attemptAuthDeferred) {\n            throw new Error(\"submitAuthDict() called before attemptAuth()\");\n        }\n\n        if (!background) {\n            this.busyChangedCallback?.(true);\n        }\n\n        // if we're currently trying a request, wait for it to finish\n        // as otherwise we can get multiple 200 responses which can mean\n        // things like multiple logins for register requests.\n        // (but discard any exceptions as we only care when its done,\n        // not whether it worked or not)\n        while (this.submitPromise) {\n            try {\n                await this.submitPromise;\n            } catch {}\n        }\n\n        // use the sessionid from the last request, if one is present.\n        let auth: AuthDict;\n        if ((this.data as IAuthData)?.session) {\n            auth = Object.assign(\n                {\n                    session: (this.data as IAuthData).session,\n                },\n                authData,\n            );\n        } else {\n            auth = authData;\n        }\n\n        try {\n            // NB. the 'background' flag is deprecated by the busyChanged\n            // callback and is here for backwards compat\n            this.submitPromise = this.doRequest(auth, background);\n            await this.submitPromise;\n        } finally {\n            this.submitPromise = null;\n            if (!background) {\n                this.busyChangedCallback?.(false);\n            }\n        }\n    }\n\n    /**\n     * Gets the sid for the email validation session\n     * Specific to m.login.email.identity\n     *\n     * @returns The sid of the email auth session\n     */\n    public getEmailSid(): string | undefined {\n        return this.emailSid;\n    }\n\n    /**\n     * Sets the sid for the email validation session\n     * This must be set in order to successfully poll for completion\n     * of the email validation.\n     * Specific to m.login.email.identity\n     *\n     * @param sid - The sid for the email validation session\n     */\n    public setEmailSid(sid: string): void {\n        this.emailSid = sid;\n    }\n\n    /**\n     * Requests a new email token and sets the email sid for the validation session\n     */\n    public requestEmailToken = async (): Promise<void> => {\n        if (!this.requestingEmailToken) {\n            logger.trace(\"Requesting email token. Attempt: \" + this.emailAttempt);\n            // If we've picked a flow with email auth, we send the email\n            // now because we want the request to fail as soon as possible\n            // if the email address is not valid (ie. already taken or not\n            // registered, depending on what the operation is).\n            this.requestingEmailToken = true;\n            try {\n                const requestTokenResult = await this.requestEmailTokenCallback(\n                    this.inputs.emailAddress!,\n                    this.clientSecret,\n                    this.emailAttempt++,\n                    (this.data as IAuthData).session!,\n                );\n                this.emailSid = requestTokenResult.sid;\n                logger.trace(\"Email token request succeeded\");\n            } finally {\n                this.requestingEmailToken = false;\n            }\n        } else {\n            logger.warn(\"Could not request email token: Already requesting\");\n        }\n    };\n\n    /**\n     * Fire off a request, and either resolve the promise, or call\n     * startAuthStage.\n     *\n     * @internal\n     * @param auth - new auth dict, including session id\n     * @param background - If true, this request is a background poll, so it\n     *    failing will not result in the attemptAuth promise being rejected.\n     *    This can be set to true for requests that just poll to see if auth has\n     *    been completed elsewhere.\n     */\n    private async doRequest(auth: AuthDict | null, background = false): Promise<void> {\n        try {\n            const result = await this.requestCallback(auth, background);\n            this.attemptAuthDeferred!.resolve(result);\n            this.attemptAuthDeferred = null;\n        } catch (error) {\n            const matrixError = error instanceof MatrixError ? error : null;\n\n            // sometimes UI auth errors don't come with flows\n            const errorFlows = matrixError?.data?.flows ?? null;\n            const haveFlows = (this.data as IAuthData)?.flows || Boolean(errorFlows);\n            if (!matrixError || matrixError.httpStatus !== 401 || !matrixError.data || !haveFlows) {\n                // doesn't look like an interactive-auth failure.\n                if (!background) {\n                    this.attemptAuthDeferred?.reject(error);\n                } else {\n                    // We ignore all failures here (even non-UI auth related ones)\n                    // since we don't want to suddenly fail if the internet connection\n                    // had a blip whilst we were polling\n                    logger.log(\"Background poll request failed doing UI auth: ignoring\", error);\n                }\n            }\n            if (matrixError && !matrixError.data) {\n                matrixError.data = {};\n            }\n            // if the error didn't come with flows, completed flows or session ID,\n            // copy over the ones we have. Synapse sometimes sends responses without\n            // any UI auth data (eg. when polling for email validation, if the email\n            // has not yet been validated). This appears to be a Synapse bug, which\n            // we workaround here.\n            if (matrixError && !matrixError.data.flows && !matrixError.data.completed && !matrixError.data.session) {\n                matrixError.data.flows = (this.data as IAuthData).flows;\n                matrixError.data.completed = (this.data as IAuthData).completed;\n                matrixError.data.session = (this.data as IAuthData).session;\n            }\n            if (matrixError) {\n                this.data = matrixError.data;\n            }\n            try {\n                this.startNextAuthStage();\n            } catch (e) {\n                this.attemptAuthDeferred!.reject(e);\n                this.attemptAuthDeferred = null;\n                return;\n            }\n\n            if (!this.emailSid && this.chosenFlow?.stages.includes(AuthType.Email)) {\n                try {\n                    await this.requestEmailToken();\n                    // NB. promise is not resolved here - at some point, doRequest\n                    // will be called again and if the user has jumped through all\n                    // the hoops correctly, auth will be complete and the request\n                    // will succeed.\n                    // Also, we should expose the fact that this request has compledted\n                    // so clients can know that the email has actually been sent.\n                } catch (e) {\n                    // we failed to request an email token, so fail the request.\n                    // This could be due to the email already beeing registered\n                    // (or not being registered, depending on what we're trying\n                    // to do) or it could be a network failure. Either way, pass\n                    // the failure up as the user can't complete auth if we can't\n                    // send the email, for whatever reason.\n                    this.attemptAuthDeferred!.reject(e);\n                    this.attemptAuthDeferred = null;\n                }\n            }\n        }\n    }\n\n    /**\n     * Pick the next stage and call the callback\n     *\n     * @internal\n     * @throws {@link NoAuthFlowFoundError} If no suitable authentication flow can be found\n     */\n    private startNextAuthStage(): void {\n        const nextStage = this.chooseStage();\n        if (!nextStage) {\n            throw new Error(\"No incomplete flows from the server\");\n        }\n        this.currentStage = nextStage;\n\n        if (nextStage === AuthType.Dummy) {\n            this.submitAuthDict({\n                type: \"m.login.dummy\",\n            });\n            return;\n        }\n\n        if (this.data?.errcode || this.data?.error) {\n            this.stateUpdatedCallback(nextStage, {\n                errcode: this.data?.errcode || \"\",\n                error: this.data?.error || \"\",\n            });\n            return;\n        }\n\n        this.stateUpdatedCallback(nextStage, nextStage === EMAIL_STAGE_TYPE ? { emailSid: this.emailSid } : {});\n    }\n\n    /**\n     * Pick the next auth stage\n     *\n     * @internal\n     * @returns login type\n     * @throws {@link NoAuthFlowFoundError} If no suitable authentication flow can be found\n     */\n    private chooseStage(): AuthType | string | undefined {\n        if (this.chosenFlow === null) {\n            this.chosenFlow = this.chooseFlow();\n        }\n        logger.log(\"Active flow => %s\", JSON.stringify(this.chosenFlow));\n        const nextStage = this.firstUncompletedStage(this.chosenFlow);\n        logger.log(\"Next stage: %s\", nextStage);\n        return nextStage;\n    }\n\n    // Returns a low number for flows we consider best. Counts increase for longer flows and even more so\n    // for flows which contain stages not listed in `supportedStages`.\n    private scoreFlow(flow: UIAFlow): number {\n        let score = flow.stages.length;\n        if (this.supportedStages !== undefined) {\n            // Add 10 points to the score for each unsupported stage in the flow.\n            score += flow.stages.filter((stage) => !this.supportedStages!.has(stage)).length * 10;\n        }\n        return score;\n    }\n\n    /**\n     * Pick one of the flows from the returned list\n     * If a flow using all of the inputs is found, it will\n     * be returned, otherwise, null will be returned.\n     *\n     * Only flows using all given inputs are chosen because it\n     * is likely to be surprising if the user provides a\n     * credential and it is not used. For example, for registration,\n     * this could result in the email not being used which would leave\n     * the account with no means to reset a password.\n     *\n     * @internal\n     * @returns flow\n     * @throws {@link NoAuthFlowFoundError} If no suitable authentication flow can be found\n     */\n    private chooseFlow(): UIAFlow {\n        const flows = (this.data as IAuthData)?.flows || [];\n\n        // we've been given an email or we've already done an email part\n        const haveEmail = Boolean(this.inputs.emailAddress) || Boolean(this.emailSid);\n        const haveMsisdn = Boolean(this.inputs.phoneCountry) && Boolean(this.inputs.phoneNumber);\n\n        // Flows are not represented in a significant order, so we can choose any we support best\n        // Sort flows based on how many unsupported stages they contain ascending\n        flows.sort((a, b) => this.scoreFlow(a) - this.scoreFlow(b));\n\n        for (const flow of flows) {\n            let flowHasEmail = false;\n            let flowHasMsisdn = false;\n            for (const stage of flow.stages) {\n                if (stage === EMAIL_STAGE_TYPE) {\n                    flowHasEmail = true;\n                } else if (stage == MSISDN_STAGE_TYPE) {\n                    flowHasMsisdn = true;\n                }\n            }\n\n            if (flowHasEmail == haveEmail && flowHasMsisdn == haveMsisdn) {\n                return flow;\n            }\n        }\n\n        const requiredStages: string[] = [];\n        if (haveEmail) requiredStages.push(EMAIL_STAGE_TYPE);\n        if (haveMsisdn) requiredStages.push(MSISDN_STAGE_TYPE);\n        // Throw an error with a fairly generic description, but with more\n        // information such that the app can give a better one if so desired.\n        throw new NoAuthFlowFoundError(\"No appropriate authentication flow found\", requiredStages, flows);\n    }\n\n    /**\n     * Get the first uncompleted stage in the given flow\n     *\n     * @internal\n     * @returns login type\n     */\n    private firstUncompletedStage(flow: UIAFlow): AuthType | string | undefined {\n        const completed = (this.data as IAuthData)?.completed || [];\n        return flow.stages.find((stageType) => !completed.includes(stageType));\n    }\n}\n","/*\nCopyright 2015 - 2021 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\n/**\n * This is an internal module. See {@link MemoryStore} for the public class.\n */\n\nimport { type EventType } from \"../@types/event.ts\";\nimport { type Room } from \"../models/room.ts\";\nimport { type User } from \"../models/user.ts\";\nimport { type IEvent, type MatrixEvent } from \"../models/event.ts\";\nimport { type RoomState, RoomStateEvent } from \"../models/room-state.ts\";\nimport { type RoomMember } from \"../models/room-member.ts\";\nimport { type Filter } from \"../filter.ts\";\nimport { type ISavedSync, type IStore, type UserCreator } from \"./index.ts\";\nimport { type RoomSummary } from \"../models/room-summary.ts\";\nimport { type ISyncResponse } from \"../sync-accumulator.ts\";\nimport { type IStateEventWithRoomId } from \"../@types/search.ts\";\nimport { type IndexedToDeviceBatch, type ToDeviceBatchWithTxnId } from \"../models/ToDeviceMessage.ts\";\nimport { type IStoredClientOpts } from \"../client.ts\";\nimport { MapWithDefault } from \"../utils.ts\";\nimport { KnownMembership } from \"../@types/membership.ts\";\n\nfunction isValidFilterId(filterId?: string | number | null): boolean {\n    const isValidStr =\n        typeof filterId === \"string\" &&\n        !!filterId &&\n        filterId !== \"undefined\" && // exclude these as we've serialized undefined in localStorage before\n        filterId !== \"null\";\n\n    return isValidStr || typeof filterId === \"number\";\n}\n\nexport interface IOpts {\n    /** The local storage instance to persist some forms of data such as tokens. Rooms will NOT be stored. */\n    localStorage?: Storage;\n}\n\nexport class MemoryStore implements IStore {\n    private rooms: Record<string, Room> = {}; // roomId: Room\n    private users: Record<string, User> = {}; // userId: User\n    private syncToken: string | null = null;\n    // userId: {\n    //    filterId: Filter\n    // }\n    private filters: MapWithDefault<string, Map<string, Filter>> = new MapWithDefault(() => new Map());\n    public accountData: Map<string, MatrixEvent> = new Map(); // type: content\n    protected readonly localStorage?: Storage;\n    private oobMembers: Map<string, IStateEventWithRoomId[]> = new Map(); // roomId: [member events]\n    private pendingEvents: { [roomId: string]: Partial<IEvent>[] } = {};\n    private clientOptions?: IStoredClientOpts;\n    private pendingToDeviceBatches: IndexedToDeviceBatch[] = [];\n    private nextToDeviceBatchId = 0;\n    protected createUser?: UserCreator;\n\n    /**\n     * Construct a new in-memory data store for the Matrix Client.\n     * @param opts - Config options\n     */\n    public constructor(opts: IOpts = {}) {\n        this.localStorage = opts.localStorage;\n    }\n\n    /**\n     * Retrieve the token to stream from.\n     * @returns The token or null.\n     */\n    public getSyncToken(): string | null {\n        return this.syncToken;\n    }\n\n    /** @returns whether or not the database was newly created in this session. */\n    public isNewlyCreated(): Promise<boolean> {\n        return Promise.resolve(true);\n    }\n\n    /**\n     * Set the token to stream from.\n     * @param token - The token to stream from.\n     */\n    public setSyncToken(token: string): void {\n        this.syncToken = token;\n    }\n\n    /**\n     * Store the given room.\n     * @param room - The room to be stored. All properties must be stored.\n     */\n    public storeRoom(room: Room): void {\n        this.rooms[room.roomId] = room;\n        // add listeners for room member changes so we can keep the room member\n        // map up-to-date.\n        room.currentState.on(RoomStateEvent.Members, this.onRoomMember);\n        // add existing members\n        room.currentState.getMembers().forEach((m) => {\n            this.onRoomMember(null, room.currentState, m);\n        });\n    }\n\n    public setUserCreator(creator: UserCreator): void {\n        this.createUser = creator;\n    }\n\n    /**\n     * Called when a room member in a room being tracked by this store has been\n     * updated.\n     */\n    private onRoomMember = (event: MatrixEvent | null, state: RoomState, member: RoomMember): void => {\n        if (member.membership === KnownMembership.Invite) {\n            // We do NOT add invited members because people love to typo user IDs\n            // which would then show up in these lists (!)\n            return;\n        }\n\n        const user = this.users[member.userId] || this.createUser?.(member.userId);\n        if (member.name) {\n            user.setDisplayName(member.name);\n            if (member.events.member) {\n                user.setRawDisplayName(member.events.member.getDirectionalContent().displayname);\n            }\n        }\n        if (member.events.member && member.events.member.getContent().avatar_url) {\n            user.setAvatarUrl(member.events.member.getContent().avatar_url);\n        }\n        this.users[user.userId] = user;\n    };\n\n    /**\n     * Retrieve a room by its' room ID.\n     * @param roomId - The room ID.\n     * @returns The room or null.\n     */\n    public getRoom(roomId: string): Room | null {\n        return this.rooms[roomId] || null;\n    }\n\n    /**\n     * Retrieve all known rooms.\n     * @returns A list of rooms, which may be empty.\n     */\n    public getRooms(): Room[] {\n        return Object.values(this.rooms);\n    }\n\n    /**\n     * Permanently delete a room.\n     */\n    public removeRoom(roomId: string): void {\n        if (this.rooms[roomId]) {\n            this.rooms[roomId].currentState.removeListener(RoomStateEvent.Members, this.onRoomMember);\n        }\n        delete this.rooms[roomId];\n    }\n\n    /**\n     * Retrieve a summary of all the rooms.\n     * @returns A summary of each room.\n     */\n    public getRoomSummaries(): RoomSummary[] {\n        return Object.values(this.rooms).map(function (room) {\n            return room.summary!;\n        });\n    }\n\n    /**\n     * Store a User.\n     * @param user - The user to store.\n     */\n    public storeUser(user: User): void {\n        this.users[user.userId] = user;\n    }\n\n    /**\n     * Retrieve a User by its' user ID.\n     * @param userId - The user ID.\n     * @returns The user or null.\n     */\n    public getUser(userId: string): User | null {\n        return this.users[userId] || null;\n    }\n\n    /**\n     * Retrieve all known users.\n     * @returns A list of users, which may be empty.\n     */\n    public getUsers(): User[] {\n        return Object.values(this.users);\n    }\n\n    /**\n     * Retrieve scrollback for this room.\n     * @param room - The matrix room\n     * @param limit - The max number of old events to retrieve.\n     * @returns An array of objects which will be at most 'limit'\n     * length and at least 0. The objects are the raw event JSON.\n     */\n    public scrollback(room: Room, limit: number): MatrixEvent[] {\n        return [];\n    }\n\n    /**\n     * Store events for a room. The events have already been added to the timeline\n     * @param room - The room to store events for.\n     * @param events - The events to store.\n     * @param token - The token associated with these events.\n     * @param toStart - True if these are paginated results.\n     */\n    public storeEvents(room: Room, events: MatrixEvent[], token: string | null, toStart: boolean): void {\n        // no-op because they've already been added to the room instance.\n    }\n\n    /**\n     * Store a filter.\n     */\n    public storeFilter(filter: Filter): void {\n        if (!filter?.userId || !filter?.filterId) return;\n        this.filters.getOrCreate(filter.userId).set(filter.filterId, filter);\n    }\n\n    /**\n     * Retrieve a filter.\n     * @returns A filter or null.\n     */\n    public getFilter(userId: string, filterId: string): Filter | null {\n        return this.filters.get(userId)?.get(filterId) || null;\n    }\n\n    /**\n     * Retrieve a filter ID with the given name.\n     * @param filterName - The filter name.\n     * @returns The filter ID or null.\n     */\n    public getFilterIdByName(filterName: string): string | null {\n        if (!this.localStorage) {\n            return null;\n        }\n        const key = \"mxjssdk_memory_filter_\" + filterName;\n        // XXX Storage.getItem doesn't throw ...\n        // or are we using something different\n        // than window.localStorage in some cases\n        // that does throw?\n        // that would be very naughty\n        try {\n            const value = this.localStorage.getItem(key);\n            if (isValidFilterId(value)) {\n                return value;\n            }\n        } catch {}\n        return null;\n    }\n\n    /**\n     * Set a filter name to ID mapping.\n     */\n    public setFilterIdByName(filterName: string, filterId?: string): void {\n        if (!this.localStorage) {\n            return;\n        }\n        const key = \"mxjssdk_memory_filter_\" + filterName;\n        try {\n            if (isValidFilterId(filterId)) {\n                this.localStorage.setItem(key, filterId!);\n            } else {\n                this.localStorage.removeItem(key);\n            }\n        } catch {}\n    }\n\n    /**\n     * Store user-scoped account data events.\n     * N.B. that account data only allows a single event per type, so multiple\n     * events with the same type will replace each other.\n     * @param events - The events to store.\n     */\n    public storeAccountDataEvents(events: MatrixEvent[]): void {\n        events.forEach((event) => {\n            // MSC3391: an event with content of {} should be interpreted as deleted\n            const isDeleted = !Object.keys(event.getContent()).length;\n            if (isDeleted) {\n                this.accountData.delete(event.getType());\n            } else {\n                this.accountData.set(event.getType(), event);\n            }\n        });\n    }\n\n    /**\n     * Get account data event by event type\n     * @param eventType - The event type being queried\n     * @returns the user account_data event of given type, if any\n     */\n    public getAccountData(eventType: EventType | string): MatrixEvent | undefined {\n        return this.accountData.get(eventType);\n    }\n\n    /**\n     * setSyncData does nothing as there is no backing data store.\n     *\n     * @param syncData - The sync data\n     * @returns An immediately resolved promise.\n     */\n    public setSyncData(syncData: ISyncResponse): Promise<void> {\n        return Promise.resolve();\n    }\n\n    /**\n     * We never want to save becase we have nothing to save to.\n     *\n     * @returns If the store wants to save\n     */\n    public wantsSave(): boolean {\n        return false;\n    }\n\n    /**\n     * Save does nothing as there is no backing data store.\n     * @param force - True to force a save (but the memory\n     *     store still can't save anything)\n     */\n    public save(force: boolean): Promise<void> {\n        return Promise.resolve();\n    }\n\n    /**\n     * Startup does nothing as this store doesn't require starting up.\n     * @returns An immediately resolved promise.\n     */\n    public startup(): Promise<void> {\n        return Promise.resolve();\n    }\n\n    /**\n     * @returns Promise which resolves with a sync response to restore the\n     * client state to where it was at the last save, or null if there\n     * is no saved sync data.\n     */\n    public getSavedSync(): Promise<ISavedSync | null> {\n        return Promise.resolve(null);\n    }\n\n    /**\n     * @returns If there is a saved sync, the nextBatch token\n     * for this sync, otherwise null.\n     */\n    public getSavedSyncToken(): Promise<string | null> {\n        return Promise.resolve(null);\n    }\n\n    /**\n     * Delete all data from this store.\n     * @returns An immediately resolved promise.\n     */\n    public deleteAllData(): Promise<void> {\n        this.rooms = {\n            // roomId: Room\n        };\n        this.users = {\n            // userId: User\n        };\n        this.syncToken = null;\n        this.filters = new MapWithDefault(() => new Map());\n        this.accountData = new Map(); // type : content\n        return Promise.resolve();\n    }\n\n    /**\n     * Returns the out-of-band membership events for this room that\n     * were previously loaded.\n     * @returns the events, potentially an empty array if OOB loading didn't yield any new members\n     * @returns in case the members for this room haven't been stored yet\n     */\n    public getOutOfBandMembers(roomId: string): Promise<IStateEventWithRoomId[] | null> {\n        return Promise.resolve(this.oobMembers.get(roomId) || null);\n    }\n\n    /**\n     * Stores the out-of-band membership events for this room. Note that\n     * it still makes sense to store an empty array as the OOB status for the room is\n     * marked as fetched, and getOutOfBandMembers will return an empty array instead of null\n     * @param membershipEvents - the membership events to store\n     * @returns when all members have been stored\n     */\n    public setOutOfBandMembers(roomId: string, membershipEvents: IStateEventWithRoomId[]): Promise<void> {\n        this.oobMembers.set(roomId, membershipEvents);\n        return Promise.resolve();\n    }\n\n    public clearOutOfBandMembers(roomId: string): Promise<void> {\n        this.oobMembers.delete(roomId);\n        return Promise.resolve();\n    }\n\n    public getClientOptions(): Promise<IStoredClientOpts | undefined> {\n        return Promise.resolve(this.clientOptions);\n    }\n\n    public storeClientOptions(options: IStoredClientOpts): Promise<void> {\n        this.clientOptions = Object.assign({}, options);\n        return Promise.resolve();\n    }\n\n    public async getPendingEvents(roomId: string): Promise<Partial<IEvent>[]> {\n        return this.pendingEvents[roomId] ?? [];\n    }\n\n    public async setPendingEvents(roomId: string, events: Partial<IEvent>[]): Promise<void> {\n        this.pendingEvents[roomId] = events;\n    }\n\n    public saveToDeviceBatches(batches: ToDeviceBatchWithTxnId[]): Promise<void> {\n        for (const batch of batches) {\n            this.pendingToDeviceBatches.push({\n                id: this.nextToDeviceBatchId++,\n                eventType: batch.eventType,\n                txnId: batch.txnId,\n                batch: batch.batch,\n            });\n        }\n        return Promise.resolve();\n    }\n\n    public async getOldestToDeviceBatch(): Promise<IndexedToDeviceBatch | null> {\n        if (this.pendingToDeviceBatches.length === 0) return null;\n        return this.pendingToDeviceBatches[0];\n    }\n\n    public removeToDeviceBatch(id: number): Promise<void> {\n        this.pendingToDeviceBatches = this.pendingToDeviceBatches.filter((batch) => batch.id !== id);\n        return Promise.resolve();\n    }\n\n    public async destroy(): Promise<void> {\n        // Nothing to do\n    }\n}\n","/*\nCopyright 2022 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport {\n    type WidgetApi,\n    WidgetApiToWidgetAction,\n    WidgetApiResponseError,\n    MatrixCapabilities,\n    type IWidgetApiRequest,\n    type IWidgetApiAcknowledgeResponseData,\n    type ISendEventToWidgetActionRequest,\n    type ISendToDeviceToWidgetActionRequest,\n    type ISendEventFromWidgetResponseData,\n    type IWidgetApiRequestData,\n    type WidgetApiAction,\n    type IWidgetApiResponse,\n    type IWidgetApiResponseData,\n} from \"matrix-widget-api\";\n\nimport { MatrixEvent, type IEvent, type IContent, EventStatus } from \"./models/event.ts\";\nimport {\n    type ISendEventResponse,\n    type SendDelayedEventRequestOpts,\n    type SendDelayedEventResponse,\n    type UpdateDelayedEventAction,\n} from \"./@types/requests.ts\";\nimport { EventType, type StateEvents } from \"./@types/event.ts\";\nimport { logger } from \"./logger.ts\";\nimport {\n    MatrixClient,\n    ClientEvent,\n    type IMatrixClientCreateOpts,\n    type IStartClientOpts,\n    type SendToDeviceContentMap,\n    type IOpenIDToken,\n    UNSTABLE_MSC4140_DELAYED_EVENTS,\n} from \"./client.ts\";\nimport { SyncApi, SyncState } from \"./sync.ts\";\nimport { SlidingSyncSdk } from \"./sliding-sync-sdk.ts\";\nimport { ConnectionError, MatrixError } from \"./http-api/errors.ts\";\nimport { User } from \"./models/user.ts\";\nimport { type Room } from \"./models/room.ts\";\nimport { type ToDeviceBatch, type ToDevicePayload } from \"./models/ToDeviceMessage.ts\";\nimport { MapWithDefault, recursiveMapToObject } from \"./utils.ts\";\nimport { type EmptyObject, TypedEventEmitter, UnsupportedDelayedEventsEndpointError } from \"./matrix.ts\";\n\ninterface IStateEventRequest {\n    eventType: string;\n    stateKey?: string;\n}\n\nexport interface OlmDevice {\n    /**\n     * The user ID of the device owner.\n     */\n    userId: string;\n    /**\n     * The device ID of the device.\n     */\n    deviceId: string;\n}\n\nexport interface ICapabilities {\n    /**\n     * Event types that this client expects to send.\n     */\n    sendEvent?: string[];\n    /**\n     * Event types that this client expects to receive.\n     */\n    receiveEvent?: string[];\n\n    /**\n     * Message types that this client expects to send, or true for all message\n     * types.\n     */\n    sendMessage?: string[] | true;\n    /**\n     * Message types that this client expects to receive, or true for all\n     * message types.\n     */\n    receiveMessage?: string[] | true;\n\n    /**\n     * Types of state events that this client expects to send.\n     */\n    sendState?: IStateEventRequest[];\n    /**\n     * Types of state events that this client expects to receive.\n     */\n    receiveState?: IStateEventRequest[];\n\n    /**\n     * To-device event types that this client expects to send.\n     */\n    sendToDevice?: string[];\n    /**\n     * To-device event types that this client expects to receive.\n     */\n    receiveToDevice?: string[];\n\n    /**\n     * Whether this client needs access to TURN servers.\n     * @defaultValue false\n     */\n    turnServers?: boolean;\n\n    /**\n     * Whether this client needs to be able to send delayed events.\n     * @experimental Part of MSC4140 & MSC4157\n     * @defaultValue false\n     */\n    sendDelayedEvents?: boolean;\n\n    /**\n     * Whether this client needs to be able to update delayed events.\n     * @experimental Part of MSC4140 & MSC4157\n     * @defaultValue false\n     */\n    updateDelayedEvents?: boolean;\n}\n\nexport enum RoomWidgetClientEvent {\n    PendingEventsChanged = \"PendingEvent.pendingEventsChanged\",\n}\nexport type EventHandlerMap = { [RoomWidgetClientEvent.PendingEventsChanged]: () => void };\n\n/**\n * A MatrixClient that routes its requests through the widget API instead of the\n * real CS API.\n * @experimental This class is considered unstable!\n */\nexport class RoomWidgetClient extends MatrixClient {\n    private room?: Room;\n    private readonly widgetApiReady: Promise<void>;\n    private lifecycle?: AbortController;\n    private syncState: SyncState | null = null;\n\n    private pendingSendingEventsTxId: { type: string; id: string | undefined; txId: string }[] = [];\n    private eventEmitter = new TypedEventEmitter<keyof EventHandlerMap, EventHandlerMap>();\n\n    /**\n     *\n     * @param widgetApi - The widget api to use for communication.\n     * @param capabilities - The capabilities the widget client will request.\n     * @param roomId - The room id the widget is associated with.\n     * @param opts - The configuration options for this client.\n     * @param sendContentLoaded - Whether to send a content loaded widget action immediately after initial setup.\n     *   Set to `false` if the widget uses `waitForIFrameLoad=true` (in this case the client does not expect a content loaded action at all),\n     *   or if the the widget wants to send the `ContentLoaded` action at a later point in time after the initial setup.\n     */\n    public constructor(\n        private readonly widgetApi: WidgetApi,\n        private readonly capabilities: ICapabilities,\n        private readonly roomId: string,\n        opts: IMatrixClientCreateOpts,\n        sendContentLoaded: boolean,\n    ) {\n        super(opts);\n\n        const transportSend = this.widgetApi.transport.send.bind(this.widgetApi.transport);\n        this.widgetApi.transport.send = async <\n            T extends IWidgetApiRequestData,\n            R extends IWidgetApiResponseData = IWidgetApiAcknowledgeResponseData,\n        >(\n            action: WidgetApiAction,\n            data: T,\n        ): Promise<R> => {\n            try {\n                return await transportSend(action, data);\n            } catch (error) {\n                processAndThrow(error);\n            }\n        };\n\n        const transportSendComplete = this.widgetApi.transport.sendComplete.bind(this.widgetApi.transport);\n        this.widgetApi.transport.sendComplete = async <T extends IWidgetApiRequestData, R extends IWidgetApiResponse>(\n            action: WidgetApiAction,\n            data: T,\n        ): Promise<R> => {\n            try {\n                return await transportSendComplete(action, data);\n            } catch (error) {\n                processAndThrow(error);\n            }\n        };\n\n        this.widgetApiReady = new Promise<void>((resolve) => this.widgetApi.once(\"ready\", resolve));\n\n        // Request capabilities for the functionality this client needs to support\n        if (\n            capabilities.sendEvent?.length ||\n            capabilities.receiveEvent?.length ||\n            capabilities.sendMessage === true ||\n            (Array.isArray(capabilities.sendMessage) && capabilities.sendMessage.length) ||\n            capabilities.receiveMessage === true ||\n            (Array.isArray(capabilities.receiveMessage) && capabilities.receiveMessage.length) ||\n            capabilities.sendState?.length ||\n            capabilities.receiveState?.length\n        ) {\n            widgetApi.requestCapabilityForRoomTimeline(roomId);\n        }\n        capabilities.sendEvent?.forEach((eventType) => widgetApi.requestCapabilityToSendEvent(eventType));\n        capabilities.receiveEvent?.forEach((eventType) => widgetApi.requestCapabilityToReceiveEvent(eventType));\n        if (capabilities.sendMessage === true) {\n            widgetApi.requestCapabilityToSendMessage();\n        } else if (Array.isArray(capabilities.sendMessage)) {\n            capabilities.sendMessage.forEach((msgType) => widgetApi.requestCapabilityToSendMessage(msgType));\n        }\n        if (capabilities.receiveMessage === true) {\n            widgetApi.requestCapabilityToReceiveMessage();\n        } else if (Array.isArray(capabilities.receiveMessage)) {\n            capabilities.receiveMessage.forEach((msgType) => widgetApi.requestCapabilityToReceiveMessage(msgType));\n        }\n        capabilities.sendState?.forEach(({ eventType, stateKey }) =>\n            widgetApi.requestCapabilityToSendState(eventType, stateKey),\n        );\n        capabilities.receiveState?.forEach(({ eventType, stateKey }) =>\n            widgetApi.requestCapabilityToReceiveState(eventType, stateKey),\n        );\n        capabilities.sendToDevice?.forEach((eventType) => widgetApi.requestCapabilityToSendToDevice(eventType));\n        capabilities.receiveToDevice?.forEach((eventType) => widgetApi.requestCapabilityToReceiveToDevice(eventType));\n        if (\n            capabilities.sendDelayedEvents &&\n            (capabilities.sendEvent?.length ||\n                capabilities.sendMessage === true ||\n                (Array.isArray(capabilities.sendMessage) && capabilities.sendMessage.length) ||\n                capabilities.sendState?.length)\n        ) {\n            widgetApi.requestCapability(MatrixCapabilities.MSC4157SendDelayedEvent);\n        }\n        if (capabilities.updateDelayedEvents) {\n            widgetApi.requestCapability(MatrixCapabilities.MSC4157UpdateDelayedEvent);\n        }\n        if (capabilities.turnServers) {\n            widgetApi.requestCapability(MatrixCapabilities.MSC3846TurnServers);\n        }\n\n        widgetApi.on(`action:${WidgetApiToWidgetAction.SendEvent}`, this.onEvent);\n        widgetApi.on(`action:${WidgetApiToWidgetAction.SendToDevice}`, this.onToDevice);\n\n        // Open communication with the host\n        widgetApi.start();\n        // Send a content loaded event now we've started the widget API\n        // Note that element-web currently does not use waitForIFrameLoad=false and so\n        // does *not* (yes, that is the right way around) wait for this event. Let's\n        // start sending this, then once this has rolled out, we can change element-web to\n        // use waitForIFrameLoad=false and have a widget API that's less racy.\n        if (sendContentLoaded) widgetApi.sendContentLoaded();\n    }\n\n    public async startClient(opts: IStartClientOpts = {}): Promise<void> {\n        this.lifecycle = new AbortController();\n\n        // Create our own user object artificially (instead of waiting for sync)\n        // so it's always available, even if the user is not in any rooms etc.\n        const userId = this.getUserId();\n        if (userId) {\n            this.store.storeUser(new User(userId));\n        }\n\n        // Even though we have no access token and cannot sync, the sync class\n        // still has some valuable helper methods that we make use of, so we\n        // instantiate it anyways\n        if (opts.slidingSync) {\n            this.syncApi = new SlidingSyncSdk(opts.slidingSync, this, opts, this.buildSyncApiOptions());\n        } else {\n            this.syncApi = new SyncApi(this, opts, this.buildSyncApiOptions());\n        }\n\n        this.room = this.syncApi.createRoom(this.roomId);\n        this.store.storeRoom(this.room);\n\n        await this.widgetApiReady;\n\n        // Backfill the requested events\n        // We only get the most recent event for every type + state key combo,\n        // so it doesn't really matter what order we inject them in\n        await Promise.all(\n            this.capabilities.receiveState?.map(async ({ eventType, stateKey }) => {\n                const rawEvents = await this.widgetApi.readStateEvents(eventType, undefined, stateKey, [this.roomId]);\n                const events = rawEvents.map((rawEvent) => new MatrixEvent(rawEvent as Partial<IEvent>));\n\n                if (this.syncApi instanceof SyncApi) {\n                    // Passing undefined for `stateAfterEventList` allows will make `injectRoomEvents` run in legacy mode\n                    // -> state events in `timelineEventList` will update the state.\n                    await this.syncApi.injectRoomEvents(this.room!, undefined, events);\n                } else {\n                    await this.syncApi!.injectRoomEvents(this.room!, events); // Sliding Sync\n                }\n                events.forEach((event) => {\n                    this.emit(ClientEvent.Event, event);\n                    logger.info(`Backfilled event ${event.getId()} ${event.getType()} ${event.getStateKey()}`);\n                });\n            }) ?? [],\n        );\n\n        if (opts.clientWellKnownPollPeriod !== undefined) {\n            this.clientWellKnownIntervalID = setInterval(() => {\n                this.fetchClientWellKnown();\n            }, 1000 * opts.clientWellKnownPollPeriod);\n            this.fetchClientWellKnown();\n        }\n\n        this.setSyncState(SyncState.Syncing);\n        logger.info(\"Finished backfilling events\");\n\n        this.matrixRTC.start();\n\n        // Watch for TURN servers, if requested\n        if (this.capabilities.turnServers) this.watchTurnServers();\n    }\n\n    public stopClient(): void {\n        this.widgetApi.off(`action:${WidgetApiToWidgetAction.SendEvent}`, this.onEvent);\n        this.widgetApi.off(`action:${WidgetApiToWidgetAction.SendToDevice}`, this.onToDevice);\n\n        super.stopClient();\n        this.lifecycle!.abort(); // Signal to other async tasks that the client has stopped\n    }\n\n    public async joinRoom(roomIdOrAlias: string): Promise<Room> {\n        if (roomIdOrAlias === this.roomId) return this.room!;\n        throw new Error(`Unknown room: ${roomIdOrAlias}`);\n    }\n\n    protected async encryptAndSendEvent(room: Room, event: MatrixEvent): Promise<ISendEventResponse>;\n    protected async encryptAndSendEvent(\n        room: Room,\n        event: MatrixEvent,\n        delayOpts: SendDelayedEventRequestOpts,\n    ): Promise<SendDelayedEventResponse>;\n    protected async encryptAndSendEvent(\n        room: Room,\n        event: MatrixEvent,\n        delayOpts?: SendDelayedEventRequestOpts,\n    ): Promise<ISendEventResponse | SendDelayedEventResponse> {\n        // We need to extend the content with the redacts parameter\n        // The js sdk uses event.redacts but the widget api uses event.content.redacts\n        // This will be converted back to event.redacts in the widget driver.\n        const content = event.event.redacts\n            ? { ...event.getContent(), redacts: event.event.redacts }\n            : event.getContent();\n\n        // Delayed event special case.\n        if (delayOpts) {\n            // TODO: updatePendingEvent for delayed events?\n            const response = await this.widgetApi\n                .sendRoomEvent(\n                    event.getType(),\n                    content,\n                    room.roomId,\n                    \"delay\" in delayOpts ? delayOpts.delay : undefined,\n                    \"parent_delay_id\" in delayOpts ? delayOpts.parent_delay_id : undefined,\n                )\n                .catch(timeoutToConnectionError);\n            return this.validateSendDelayedEventResponse(response);\n        }\n\n        const txId = event.getTxnId();\n        // Add the txnId to the pending list (still with unknown evID)\n        if (txId) this.pendingSendingEventsTxId.push({ type: event.getType(), id: undefined, txId });\n\n        let response: ISendEventFromWidgetResponseData;\n        try {\n            response = await this.widgetApi\n                .sendRoomEvent(event.getType(), content, room.roomId)\n                .catch(timeoutToConnectionError);\n        } catch (e) {\n            this.updatePendingEventStatus(room, event, EventStatus.NOT_SENT);\n            throw e;\n        }\n        // This also checks for an event id on the response\n        room.updatePendingEvent(event, EventStatus.SENT, response.event_id);\n\n        // Update the pending events list with the eventId\n        this.pendingSendingEventsTxId.forEach((p) => {\n            if (p.txId === txId) p.id = response.event_id;\n        });\n        this.eventEmitter.emit(RoomWidgetClientEvent.PendingEventsChanged);\n\n        return { event_id: response.event_id! };\n    }\n\n    public async sendStateEvent(\n        roomId: string,\n        eventType: string,\n        content: any,\n        stateKey = \"\",\n    ): Promise<ISendEventResponse> {\n        const response = await this.widgetApi\n            .sendStateEvent(eventType, stateKey, content, roomId)\n            .catch(timeoutToConnectionError);\n        if (response.event_id === undefined) {\n            throw new Error(\"'event_id' absent from response to an event request\");\n        }\n        return { event_id: response.event_id };\n    }\n\n    /**\n     * @experimental This currently relies on an unstable MSC (MSC4140).\n     */\n    // eslint-disable-next-line\n    public async _unstable_sendDelayedStateEvent<K extends keyof StateEvents>(\n        roomId: string,\n        delayOpts: SendDelayedEventRequestOpts,\n        eventType: K,\n        content: StateEvents[K],\n        stateKey = \"\",\n    ): Promise<SendDelayedEventResponse> {\n        if (!(await this.doesServerSupportUnstableFeature(UNSTABLE_MSC4140_DELAYED_EVENTS))) {\n            throw new UnsupportedDelayedEventsEndpointError(\n                \"Server does not support the delayed events API\",\n                \"sendDelayedStateEvent\",\n            );\n        }\n\n        const response = await this.widgetApi\n            .sendStateEvent(\n                eventType,\n                stateKey,\n                content,\n                roomId,\n                \"delay\" in delayOpts ? delayOpts.delay : undefined,\n                \"parent_delay_id\" in delayOpts ? delayOpts.parent_delay_id : undefined,\n            )\n            .catch(timeoutToConnectionError);\n        return this.validateSendDelayedEventResponse(response);\n    }\n\n    private validateSendDelayedEventResponse(response: ISendEventFromWidgetResponseData): SendDelayedEventResponse {\n        if (response.delay_id === undefined) {\n            throw new Error(\"'delay_id' absent from response to a delayed event request\");\n        }\n        return { delay_id: response.delay_id };\n    }\n\n    /**\n     * @experimental This currently relies on an unstable MSC (MSC4140).\n     */\n    // eslint-disable-next-line\n    public async _unstable_updateDelayedEvent(delayId: string, action: UpdateDelayedEventAction): Promise<EmptyObject> {\n        if (!(await this.doesServerSupportUnstableFeature(UNSTABLE_MSC4140_DELAYED_EVENTS))) {\n            throw new UnsupportedDelayedEventsEndpointError(\n                \"Server does not support the delayed events API\",\n                \"updateDelayedEvent\",\n            );\n        }\n\n        await this.widgetApi.updateDelayedEvent(delayId, action).catch(timeoutToConnectionError);\n        return {};\n    }\n\n    public async sendToDevice(eventType: string, contentMap: SendToDeviceContentMap): Promise<EmptyObject> {\n        await this.widgetApi\n            .sendToDevice(eventType, false, recursiveMapToObject(contentMap))\n            .catch(timeoutToConnectionError);\n        return {};\n    }\n\n    public async getOpenIdToken(): Promise<IOpenIDToken> {\n        const token = await this.widgetApi.requestOpenIDConnectToken().catch(timeoutToConnectionError);\n        // the IOpenIDCredentials from the widget-api and IOpenIDToken form the matrix-js-sdk are compatible.\n        // we still recreate the token to make this transparent and catch'able by the linter in case the types change in the future.\n        return <IOpenIDToken>{\n            access_token: token.access_token,\n            expires_in: token.expires_in,\n            matrix_server_name: token.matrix_server_name,\n            token_type: token.token_type,\n        };\n    }\n\n    public async queueToDevice({ eventType, batch }: ToDeviceBatch): Promise<void> {\n        // map: user Id → device Id → payload\n        const contentMap: MapWithDefault<string, Map<string, ToDevicePayload>> = new MapWithDefault(() => new Map());\n        for (const { userId, deviceId, payload } of batch) {\n            contentMap.getOrCreate(userId).set(deviceId, payload);\n        }\n\n        await this.widgetApi\n            .sendToDevice(eventType, false, recursiveMapToObject(contentMap))\n            .catch(timeoutToConnectionError);\n    }\n\n    public async encryptAndSendToDevices(userDeviceInfoArr: OlmDevice[], payload: object): Promise<void> {\n        // map: user Id → device Id → payload\n        const contentMap: MapWithDefault<string, Map<string, object>> = new MapWithDefault(() => new Map());\n        for (const { userId, deviceId } of userDeviceInfoArr) {\n            contentMap.getOrCreate(userId).set(deviceId, payload);\n        }\n\n        await this.widgetApi\n            .sendToDevice((payload as { type: string }).type, true, recursiveMapToObject(contentMap))\n            .catch(timeoutToConnectionError);\n    }\n\n    /**\n     * Send an event to a specific list of devices via the widget API. Optionally encrypts the event.\n     *\n     * If you are using a full MatrixClient you would be calling {@link MatrixClient.getCrypto().encryptToDeviceMessages()} followed\n     * by {@link MatrixClient.queueToDevice}.\n     *\n     * However, this is combined into a single step when running as an embedded widget client. So, we expose this method for those\n     * that need it.\n     *\n     * @param eventType - Type of the event to send.\n     * @param encrypted - Whether the event should be encrypted.\n     * @param contentMap - The content to send. Map from user_id to device_id to content object.\n     */\n    public async sendToDeviceViaWidgetApi(\n        eventType: string,\n        encrypted: boolean,\n        contentMap: SendToDeviceContentMap,\n    ): Promise<void> {\n        await this.widgetApi\n            .sendToDevice(eventType, encrypted, recursiveMapToObject(contentMap))\n            .catch(timeoutToConnectionError);\n    }\n\n    // Overridden since we get TURN servers automatically over the widget API,\n    // and this method would otherwise complain about missing an access token\n    public async checkTurnServers(): Promise<boolean> {\n        return this.turnServers.length > 0;\n    }\n\n    // Overridden since we 'sync' manually without the sync API\n    public getSyncState(): SyncState | null {\n        return this.syncState;\n    }\n\n    private setSyncState(state: SyncState): void {\n        const oldState = this.syncState;\n        this.syncState = state;\n        this.emit(ClientEvent.Sync, state, oldState);\n    }\n\n    private async ack(ev: CustomEvent<IWidgetApiRequest>): Promise<void> {\n        await this.widgetApi.transport.reply<IWidgetApiAcknowledgeResponseData>(ev.detail, {});\n    }\n\n    private updateTxId = async (event: MatrixEvent): Promise<void> => {\n        // We update the txId for remote echos that originate from this client.\n        // This happens with the help of `pendingSendingEventsTxId` where we store all events that are currently sending\n        // with their widget txId and once ready the final evId.\n        if (\n            // This could theoretically be an event send by this device\n            // In that case we need to update the txId of the event because the embedded client/widget\n            // knows this event with a different transaction Id than what was used by the host client.\n            event.getSender() === this.getUserId() &&\n            // We optimize by not blocking events from types that we have not send\n            // with this client.\n            this.pendingSendingEventsTxId.some((p) => event.getType() === p.type)\n        ) {\n            // Compare by event Id if we have a matching pending event where we know the txId.\n            let matchingTxId = this.pendingSendingEventsTxId.find((p) => p.id === event.getId())?.txId;\n            // Block any further processing of this event until we have received the sending response.\n            // -> until we know the event id.\n            // -> until we have not pending events anymore.\n            while (!matchingTxId && this.pendingSendingEventsTxId.length > 0) {\n                // Recheck whenever the PendingEventsChanged\n                await new Promise<void>((resolve) =>\n                    this.eventEmitter.once(RoomWidgetClientEvent.PendingEventsChanged, () => resolve()),\n                );\n                matchingTxId = this.pendingSendingEventsTxId.find((p) => p.id === event.getId())?.txId;\n            }\n\n            // We found the correct txId: we update the event and delete the entry of the pending events.\n            if (matchingTxId) {\n                event.setTxnId(matchingTxId);\n                event.setUnsigned({ ...event.getUnsigned(), transaction_id: matchingTxId });\n            }\n            this.pendingSendingEventsTxId = this.pendingSendingEventsTxId.filter((p) => p.id !== event.getId());\n\n            // Emit once there are no pending events anymore to release all other events that got\n            // awaited in the `while (!matchingTxId && this.pendingSendingEventsTxId.length > 0)` loop\n            // but are not send by this client.\n            if (this.pendingSendingEventsTxId.length === 0) {\n                this.eventEmitter.emit(RoomWidgetClientEvent.PendingEventsChanged);\n            }\n        }\n    };\n\n    private onEvent = async (ev: CustomEvent<ISendEventToWidgetActionRequest>): Promise<void> => {\n        ev.preventDefault();\n\n        // Verify the room ID matches, since it's possible for the client to\n        // send us events from other rooms if this widget is always on screen\n        if (ev.detail.data.room_id === this.roomId) {\n            const event = new MatrixEvent(ev.detail.data as Partial<IEvent>);\n\n            // Only inject once we have update the txId\n            await this.updateTxId(event);\n\n            // The widget API does not tell us whether a state event came from `state_after` or not so we assume legacy behaviour for now.\n            if (this.syncApi instanceof SyncApi) {\n                // The code will want to be something like:\n                // ```\n                // if (!params.addToTimeline && !params.addToState) {\n                // // Passing undefined for `stateAfterEventList` makes `injectRoomEvents` run in \"legacy mode\"\n                // // -> state events part of the `timelineEventList` parameter will update the state.\n                //     this.injectRoomEvents(this.room!, [], undefined, [event]);\n                // } else {\n                //     this.injectRoomEvents(this.room!, undefined, params.addToState ? [event] : [], params.addToTimeline ? [event] : []);\n                // }\n                // ```\n\n                // Passing undefined for `stateAfterEventList` allows will make `injectRoomEvents` run in legacy mode\n                // -> state events in `timelineEventList` will update the state.\n                await this.syncApi.injectRoomEvents(this.room!, [], undefined, [event]);\n            } else {\n                // The code will want to be something like:\n                // ```\n                // if (!params.addToTimeline && !params.addToState) {\n                //     this.injectRoomEvents(this.room!, [], [event]);\n                // } else {\n                //     this.injectRoomEvents(this.room!, params.addToState ? [event] : [], params.addToTimeline ? [event] : []);\n                // }\n                // ```\n                await this.syncApi!.injectRoomEvents(this.room!, [], [event]); // Sliding Sync\n            }\n            this.emit(ClientEvent.Event, event);\n            this.setSyncState(SyncState.Syncing);\n            logger.info(`Received event ${event.getId()} ${event.getType()} ${event.getStateKey()}`);\n        } else {\n            const { event_id: eventId, room_id: roomId } = ev.detail.data;\n            logger.info(`Received event ${eventId} for a different room ${roomId}; discarding`);\n        }\n\n        await this.ack(ev);\n    };\n\n    private onToDevice = async (ev: CustomEvent<ISendToDeviceToWidgetActionRequest>): Promise<void> => {\n        ev.preventDefault();\n\n        const event = new MatrixEvent({\n            type: ev.detail.data.type,\n            sender: ev.detail.data.sender,\n            content: ev.detail.data.content as IContent,\n        });\n        // Mark the event as encrypted if it was, using fake contents and keys since those are unknown to us\n        if (ev.detail.data.encrypted) event.makeEncrypted(EventType.RoomMessageEncrypted, {}, \"\", \"\");\n\n        this.emit(ClientEvent.ToDeviceEvent, event);\n        this.setSyncState(SyncState.Syncing);\n        await this.ack(ev);\n    };\n\n    private async watchTurnServers(): Promise<void> {\n        const servers = this.widgetApi.getTurnServers();\n        const onClientStopped = (): void => {\n            servers.return(undefined);\n        };\n        this.lifecycle!.signal.addEventListener(\"abort\", onClientStopped);\n\n        try {\n            for await (const server of servers) {\n                this.turnServers = [\n                    {\n                        urls: server.uris,\n                        username: server.username,\n                        credential: server.password,\n                    },\n                ];\n                this.emit(ClientEvent.TurnServers, this.turnServers);\n                logger.log(`Received TURN server: ${server.uris}`);\n            }\n        } catch (e) {\n            logger.warn(\"Error watching TURN servers\", e);\n        } finally {\n            this.lifecycle!.signal.removeEventListener(\"abort\", onClientStopped);\n        }\n    }\n}\n\nfunction processAndThrow(error: unknown): never {\n    if (error instanceof WidgetApiResponseError && error.data.matrix_api_error) {\n        throw MatrixError.fromWidgetApiErrorData(error.data.matrix_api_error);\n    } else {\n        throw error;\n    }\n}\n\n/**\n * This converts an \"Request timed out\" error from the PostmessageTransport into a ConnectionError.\n * It either throws the original error or a new ConnectionError.\n **/\nfunction timeoutToConnectionError(error: unknown): never {\n    // TODO: this should not check on error.message but instead it should be a specific type\n    // error instanceof WidgetTimeoutError\n    if (error instanceof Error && error.message === \"Request timed out\") {\n        throw new ConnectionError(\"widget api timeout\");\n    }\n    throw error;\n}\n","/*\nCopyright 2016 - 2021 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { type Optional } from \"matrix-events-sdk\";\n\nimport { type Direction, EventTimeline } from \"./models/event-timeline.ts\";\nimport { logger } from \"./logger.ts\";\nimport { type MatrixClient } from \"./client.ts\";\nimport { type EventTimelineSet } from \"./models/event-timeline-set.ts\";\nimport { type MatrixEvent } from \"./models/event.ts\";\nimport { type Room, RoomEvent } from \"./models/room.ts\";\n\n/**\n * @internal\n */\nconst DEBUG = false;\n\n/**\n * @internal\n */\n/* istanbul ignore next */\nconst debuglog = DEBUG ? logger.log.bind(logger) : function (): void {};\n\n/**\n * the number of times we ask the server for more events before giving up\n * this is currently higher than it needs to be to workaround lack of a filter\n * for excluding thread responses from main timeline pagination which can cause\n * giving up incorrectly - https://github.com/matrix-org/matrix-spec-proposals/pull/3874\n *\n * @internal\n */\nconst DEFAULT_PAGINATE_LOOP_LIMIT = 10;\n\ninterface IOpts {\n    /**\n     * Maximum number of events to keep in the window. If more events are retrieved via pagination requests,\n     * excess events will be dropped from the other end of the window.\n     */\n    windowLimit?: number;\n}\n\nexport class TimelineWindow {\n    private readonly windowLimit: number;\n    // these will be TimelineIndex objects; they delineate the 'start' and\n    // 'end' of the window.\n    //\n    // start.index is inclusive; end.index is exclusive.\n    private start?: TimelineIndex;\n    private end?: TimelineIndex;\n    private eventCount = 0;\n\n    /**\n     * Construct a TimelineWindow.\n     *\n     * <p>This abstracts the separate timelines in a Matrix {@link Room} into a single iterable thing.\n     * It keeps track of the start and endpoints of the window, which can be advanced with the help\n     * of pagination requests.\n     *\n     * <p>Before the window is useful, it must be initialised by calling {@link TimelineWindow#load}.\n     *\n     * <p>Note that the window will not automatically extend itself when new events\n     * are received from /sync; you should arrange to call {@link TimelineWindow#paginate}\n     * on {@link RoomEvent.Timeline} events.\n     *\n     * <p>Note that constructing an instance of this class for a room adds a\n     * listener for RoomEvent.Timeline events which is never removed. In theory\n     * this should not cause a leak since the EventEmitter uses weak mappings.\n     *\n     * @param client -   MatrixClient to be used for context/pagination\n     *   requests.\n     *\n     * @param timelineSet -  The timelineSet to track\n     *\n     * @param opts - Configuration options for this window\n     */\n    public constructor(\n        private readonly client: MatrixClient,\n        private readonly timelineSet: EventTimelineSet,\n        opts: IOpts = {},\n    ) {\n        this.windowLimit = opts.windowLimit || 1000;\n        timelineSet.room?.on(RoomEvent.Timeline, this.onTimelineEvent.bind(this));\n    }\n\n    /**\n     * Initialise the window to point at a given event, or the live timeline\n     *\n     * @param initialEventId -   If given, the window will contain the\n     *    given event\n     * @param initialWindowSize -   Size of the initial window\n     */\n    public load(initialEventId?: string, initialWindowSize = 20): Promise<void> {\n        // given an EventTimeline, find the event we were looking for, and initialise our\n        // fields so that the event in question is in the middle of the window.\n        const initFields = (timeline: Optional<EventTimeline>): void => {\n            if (!timeline) {\n                throw new Error(\"No timeline given to initFields\");\n            }\n\n            let eventIndex: number;\n\n            const events = timeline.getEvents();\n\n            if (!initialEventId) {\n                // we were looking for the live timeline: initialise to the end\n                eventIndex = events.length;\n            } else {\n                eventIndex = events.findIndex((e) => e.getId() === initialEventId);\n\n                if (eventIndex < 0) {\n                    throw new Error(\"getEventTimeline result didn't include requested event\");\n                }\n            }\n\n            const endIndex = Math.min(events.length, eventIndex + Math.ceil(initialWindowSize / 2));\n            const startIndex = Math.max(0, endIndex - initialWindowSize);\n            this.start = new TimelineIndex(timeline, startIndex - timeline.getBaseIndex());\n            this.end = new TimelineIndex(timeline, endIndex - timeline.getBaseIndex());\n            this.eventCount = endIndex - startIndex;\n        };\n\n        // We avoid delaying the resolution of the promise by a reactor tick if we already have the data we need,\n        // which is important to keep room-switching feeling snappy.\n        if (this.timelineSet.getTimelineForEvent(initialEventId)) {\n            initFields(this.timelineSet.getTimelineForEvent(initialEventId));\n            return Promise.resolve();\n        } else if (initialEventId) {\n            return this.client.getEventTimeline(this.timelineSet, initialEventId).then(initFields);\n        } else {\n            initFields(this.timelineSet.getLiveTimeline());\n            return Promise.resolve();\n        }\n    }\n\n    /**\n     * Get the TimelineIndex of the window in the given direction.\n     *\n     * @param direction -   EventTimeline.BACKWARDS to get the TimelineIndex\n     * at the start of the window; EventTimeline.FORWARDS to get the TimelineIndex at\n     * the end.\n     *\n     * @returns The requested timeline index if one exists, null\n     * otherwise.\n     */\n    public getTimelineIndex(direction: Direction): TimelineIndex | null {\n        if (direction == EventTimeline.BACKWARDS) {\n            return this.start ?? null;\n        } else if (direction == EventTimeline.FORWARDS) {\n            return this.end ?? null;\n        } else {\n            throw new Error(\"Invalid direction '\" + direction + \"'\");\n        }\n    }\n\n    /**\n     * Try to extend the window using events that are already in the underlying\n     * TimelineIndex.\n     *\n     * @param direction -   EventTimeline.BACKWARDS to try extending it\n     *   backwards; EventTimeline.FORWARDS to try extending it forwards.\n     * @param size -   number of events to try to extend by.\n     *\n     * @returns true if the window was extended, false otherwise.\n     */\n    public extend(direction: Direction, size: number): boolean {\n        const tl = this.getTimelineIndex(direction);\n\n        if (!tl) {\n            debuglog(\"TimelineWindow: no timeline yet\");\n            return false;\n        }\n\n        const count = direction == EventTimeline.BACKWARDS ? tl.retreat(size) : tl.advance(size);\n\n        if (count) {\n            this.eventCount += count;\n            debuglog(\"TimelineWindow: increased cap by \" + count + \" (now \" + this.eventCount + \")\");\n            // remove some events from the other end, if necessary\n            const excess = this.eventCount - this.windowLimit;\n            if (excess > 0) {\n                this.unpaginate(excess, direction != EventTimeline.BACKWARDS);\n            }\n            return true;\n        }\n\n        return false;\n    }\n\n    private onTimelineEvent(_event?: MatrixEvent, _room?: Room, _atStart?: boolean, removed?: boolean): void {\n        if (removed) {\n            this.onEventRemoved();\n        }\n    }\n\n    /**\n     * If an event was removed, meaning this window is longer than the timeline,\n     * shorten the window.\n     */\n    private onEventRemoved(): void {\n        const events = this.getEvents();\n        if (events.length > 0 && events[events.length - 1] === undefined && this.end) {\n            this.end.index--;\n        }\n    }\n\n    /**\n     * Check if this window can be extended\n     *\n     * <p>This returns true if we either have more events, or if we have a\n     * pagination token which means we can paginate in that direction. It does not\n     * necessarily mean that there are more events available in that direction at\n     * this time.\n     *\n     * @param direction -   EventTimeline.BACKWARDS to check if we can\n     *   paginate backwards; EventTimeline.FORWARDS to check if we can go forwards\n     *\n     * @returns true if we can paginate in the given direction\n     */\n    public canPaginate(direction: Direction): boolean {\n        const tl = this.getTimelineIndex(direction);\n\n        if (!tl) {\n            debuglog(\"TimelineWindow: no timeline yet\");\n            return false;\n        }\n\n        if (direction == EventTimeline.BACKWARDS) {\n            if (tl.index > tl.minIndex()) {\n                return true;\n            }\n        } else {\n            if (tl.index < tl.maxIndex()) {\n                return true;\n            }\n        }\n\n        const hasNeighbouringTimeline = tl.timeline.getNeighbouringTimeline(direction);\n        const paginationToken = tl.timeline.getPaginationToken(direction);\n        return Boolean(hasNeighbouringTimeline) || Boolean(paginationToken);\n    }\n\n    /**\n     * Attempt to extend the window\n     *\n     * @param direction -   EventTimeline.BACKWARDS to extend the window\n     *    backwards (towards older events); EventTimeline.FORWARDS to go forwards.\n     *\n     * @param size -   number of events to try to extend by. If fewer than this\n     *    number are immediately available, then we return immediately rather than\n     *    making an API call.\n     *\n     * @param makeRequest - whether we should make API calls to\n     *    fetch further events if we don't have any at all. (This has no effect if\n     *    the room already knows about additional events in the relevant direction,\n     *    even if there are fewer than 'size' of them, as we will just return those\n     *    we already know about.)\n     *\n     * @param requestLimit - limit for the number of API requests we\n     *    should make.\n     *\n     * @returns Promise which resolves to a boolean which is true if more events\n     *    were successfully retrieved.\n     */\n    public async paginate(\n        direction: Direction,\n        size: number,\n        makeRequest = true,\n        requestLimit = DEFAULT_PAGINATE_LOOP_LIMIT,\n    ): Promise<boolean> {\n        // Either wind back the message cap (if there are enough events in the\n        // timeline to do so), or fire off a pagination request.\n        const tl = this.getTimelineIndex(direction);\n\n        if (!tl) {\n            debuglog(\"TimelineWindow: no timeline yet\");\n            return false;\n        }\n\n        if (tl.pendingPaginate) {\n            return tl.pendingPaginate;\n        }\n\n        // try moving the cap\n        if (this.extend(direction, size)) {\n            return true;\n        }\n\n        if (!makeRequest || requestLimit === 0) {\n            // todo: should we return something different to indicate that there\n            // might be more events out there, but we haven't found them yet?\n            return false;\n        }\n\n        // try making a pagination request\n        const token = tl.timeline.getPaginationToken(direction);\n        if (!token) {\n            debuglog(\"TimelineWindow: no token\");\n            return false;\n        }\n\n        debuglog(\"TimelineWindow: starting request\");\n\n        const prom = this.client\n            .paginateEventTimeline(tl.timeline, {\n                backwards: direction == EventTimeline.BACKWARDS,\n                limit: size,\n            })\n            .finally(function () {\n                tl.pendingPaginate = undefined;\n            })\n            .then((r) => {\n                debuglog(\"TimelineWindow: request completed with result \" + r);\n                if (!r) {\n                    return this.paginate(direction, size, false, 0);\n                }\n\n                // recurse to advance the index into the results.\n                //\n                // If we don't get any new events, we want to make sure we keep asking\n                // the server for events for as long as we have a valid pagination\n                // token. In particular, we want to know if we've actually hit the\n                // start of the timeline, or if we just happened to know about all of\n                // the events thanks to https://matrix.org/jira/browse/SYN-645.\n                //\n                // On the other hand, we necessarily want to wait forever for the\n                // server to make its mind up about whether there are other events,\n                // because it gives a bad user experience\n                // (https://github.com/vector-im/vector-web/issues/1204).\n                return this.paginate(direction, size, true, requestLimit - 1);\n            });\n        tl.pendingPaginate = prom;\n        return prom;\n    }\n\n    /**\n     * Remove `delta` events from the start or end of the timeline.\n     *\n     * @param delta - number of events to remove from the timeline\n     * @param startOfTimeline - if events should be removed from the start\n     *     of the timeline.\n     */\n    public unpaginate(delta: number, startOfTimeline: boolean): void {\n        const tl = startOfTimeline ? this.start : this.end;\n        if (!tl) {\n            throw new Error(\n                `Attempting to unpaginate startOfTimeline=${startOfTimeline} but don't have this direction`,\n            );\n        }\n\n        // sanity-check the delta\n        if (delta > this.eventCount || delta < 0) {\n            throw new Error(\n                `Attemting to unpaginate ${delta} events, but only have ${this.eventCount} in the timeline`,\n            );\n        }\n\n        while (delta > 0) {\n            const count = startOfTimeline ? tl.advance(delta) : tl.retreat(delta);\n            if (count <= 0) {\n                // sadness. This shouldn't be possible.\n                throw new Error(\"Unable to unpaginate any further, but still have \" + this.eventCount + \" events\");\n            }\n\n            delta -= count;\n            this.eventCount -= count;\n            debuglog(\"TimelineWindow.unpaginate: dropped \" + count + \" (now \" + this.eventCount + \")\");\n        }\n    }\n\n    /**\n     * Get a list of the events currently in the window\n     *\n     * @returns the events in the window\n     */\n    public getEvents(): MatrixEvent[] {\n        if (!this.start) {\n            // not yet loaded\n            return [];\n        }\n\n        const result: MatrixEvent[] = [];\n\n        // iterate through each timeline between this.start and this.end\n        // (inclusive).\n        let timeline: EventTimeline | null = this.start.timeline;\n        // eslint-disable-next-line no-constant-condition\n        while (timeline) {\n            const events = timeline.getEvents();\n\n            // For the first timeline in the chain, we want to start at\n            // this.start.index. For the last timeline in the chain, we want to\n            // stop before this.end.index. Otherwise, we want to copy all of the\n            // events in the timeline.\n            //\n            // (Note that both this.start.index and this.end.index are relative\n            // to their respective timelines' BaseIndex).\n            //\n            let startIndex = 0;\n            let endIndex = events.length;\n            if (timeline === this.start.timeline) {\n                startIndex = this.start.index + timeline.getBaseIndex();\n            }\n            if (timeline === this.end?.timeline) {\n                endIndex = this.end.index + timeline.getBaseIndex();\n            }\n\n            for (let i = startIndex; i < endIndex; i++) {\n                result.push(events[i]);\n            }\n\n            // if we're not done, iterate to the next timeline.\n            if (timeline === this.end?.timeline) {\n                break;\n            } else {\n                timeline = timeline.getNeighbouringTimeline(EventTimeline.FORWARDS);\n            }\n        }\n\n        return result;\n    }\n}\n\n/**\n * A thing which contains a timeline reference, and an index into it.\n * @internal\n */\nexport class TimelineIndex {\n    public pendingPaginate?: Promise<boolean>;\n\n    // index: the indexes are relative to BaseIndex, so could well be negative.\n    public constructor(\n        public timeline: EventTimeline,\n        public index: number,\n    ) {}\n\n    /**\n     * @returns the minimum possible value for the index in the current\n     *    timeline\n     */\n    public minIndex(): number {\n        return this.timeline.getBaseIndex() * -1;\n    }\n\n    /**\n     * @returns the maximum possible value for the index in the current\n     *    timeline (exclusive - ie, it actually returns one more than the index\n     *    of the last element).\n     */\n    public maxIndex(): number {\n        return this.timeline.getEvents().length - this.timeline.getBaseIndex();\n    }\n\n    /**\n     * Try move the index forward, or into the neighbouring timeline\n     *\n     * @param delta -  number of events to advance by\n     * @returns number of events successfully advanced by\n     */\n    public advance(delta: number): number {\n        if (!delta) {\n            return 0;\n        }\n\n        // first try moving the index in the current timeline. See if there is room\n        // to do so.\n        let cappedDelta;\n        if (delta < 0) {\n            // we want to wind the index backwards.\n            //\n            // (this.minIndex() - this.index) is a negative number whose magnitude\n            // is the amount of room we have to wind back the index in the current\n            // timeline. We cap delta to this quantity.\n            cappedDelta = Math.max(delta, this.minIndex() - this.index);\n            if (cappedDelta < 0) {\n                this.index += cappedDelta;\n                return cappedDelta;\n            }\n        } else {\n            // we want to wind the index forwards.\n            //\n            // (this.maxIndex() - this.index) is a (positive) number whose magnitude\n            // is the amount of room we have to wind forward the index in the current\n            // timeline. We cap delta to this quantity.\n            cappedDelta = Math.min(delta, this.maxIndex() - this.index);\n            if (cappedDelta > 0) {\n                this.index += cappedDelta;\n                return cappedDelta;\n            }\n        }\n\n        // the index is already at the start/end of the current timeline.\n        //\n        // next see if there is a neighbouring timeline to switch to.\n        const neighbour = this.timeline.getNeighbouringTimeline(\n            delta < 0 ? EventTimeline.BACKWARDS : EventTimeline.FORWARDS,\n        );\n        if (neighbour) {\n            this.timeline = neighbour;\n            if (delta < 0) {\n                this.index = this.maxIndex();\n            } else {\n                this.index = this.minIndex();\n            }\n\n            debuglog(\"paginate: switched to new neighbour\");\n\n            // recurse, using the next timeline\n            return this.advance(delta);\n        }\n\n        return 0;\n    }\n\n    /**\n     * Try move the index backwards, or into the neighbouring timeline\n     *\n     * @param delta -  number of events to retreat by\n     * @returns number of events successfully retreated by\n     */\n    public retreat(delta: number): number {\n        return this.advance(delta * -1) * -1;\n    }\n}\n","/*\nCopyright 2017 - 2021 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { logger } from \"../logger.ts\";\nimport { defer, type IDeferred } from \"../utils.ts\";\nimport { type ISavedSync } from \"./index.ts\";\nimport { type IStoredClientOpts } from \"../client.ts\";\nimport { type IStateEventWithRoomId, type ISyncResponse } from \"../matrix.ts\";\nimport { type IIndexedDBBackend, type UserTuple } from \"./indexeddb-backend.ts\";\nimport { type IndexedToDeviceBatch, type ToDeviceBatchWithTxnId } from \"../models/ToDeviceMessage.ts\";\n\nexport class RemoteIndexedDBStoreBackend implements IIndexedDBBackend {\n    private worker?: Worker;\n    private nextSeq = 0;\n    // The currently in-flight requests to the actual backend\n    private inFlight: Record<number, IDeferred<any>> = {}; // seq: promise\n    // Once we start connecting, we keep the promise and re-use it\n    // if we try to connect again\n    private startPromise?: Promise<void>;\n    // Callback for when the IndexedDB gets closed unexpectedly\n    private onClose?(): void;\n\n    /**\n     * An IndexedDB store backend where the actual backend sits in a web\n     * worker.\n     *\n     * Construct a new Indexed Database store backend. This requires a call to\n     * `connect()` before this store can be used.\n     * @param workerFactory - Factory which produces a Worker\n     * @param dbName - Optional database name. The same name must be used\n     * to open the same database.\n     */\n    public constructor(\n        private readonly workerFactory: () => Worker,\n        private readonly dbName?: string,\n    ) {}\n\n    /**\n     * Attempt to connect to the database. This can fail if the user does not\n     * grant permission.\n     * @returns Promise which resolves if successfully connected.\n     */\n    public connect(onClose?: () => void): Promise<void> {\n        this.onClose = onClose;\n        return this.ensureStarted().then(() => this.doCmd(\"connect\"));\n    }\n\n    /**\n     * Clear the entire database. This should be used when logging out of a client\n     * to prevent mixing data between accounts.\n     * @returns Resolved when the database is cleared.\n     */\n    public clearDatabase(): Promise<void> {\n        return this.ensureStarted().then(() => this.doCmd(\"clearDatabase\"));\n    }\n\n    /** @returns whether or not the database was newly created in this session. */\n    public isNewlyCreated(): Promise<boolean> {\n        return this.doCmd(\"isNewlyCreated\");\n    }\n\n    /**\n     * @returns Promise which resolves with a sync response to restore the\n     * client state to where it was at the last save, or null if there\n     * is no saved sync data.\n     */\n    public getSavedSync(): Promise<ISavedSync> {\n        return this.doCmd(\"getSavedSync\");\n    }\n\n    public getNextBatchToken(): Promise<string> {\n        return this.doCmd(\"getNextBatchToken\");\n    }\n\n    public setSyncData(syncData: ISyncResponse): Promise<void> {\n        return this.doCmd(\"setSyncData\", [syncData]);\n    }\n\n    public syncToDatabase(userTuples: UserTuple[]): Promise<void> {\n        return this.doCmd(\"syncToDatabase\", [userTuples]);\n    }\n\n    /**\n     * Returns the out-of-band membership events for this room that\n     * were previously loaded.\n     * @returns the events, potentially an empty array if OOB loading didn't yield any new members\n     * @returns in case the members for this room haven't been stored yet\n     */\n    public getOutOfBandMembers(roomId: string): Promise<IStateEventWithRoomId[] | null> {\n        return this.doCmd(\"getOutOfBandMembers\", [roomId]);\n    }\n\n    /**\n     * Stores the out-of-band membership events for this room. Note that\n     * it still makes sense to store an empty array as the OOB status for the room is\n     * marked as fetched, and getOutOfBandMembers will return an empty array instead of null\n     * @param membershipEvents - the membership events to store\n     * @returns when all members have been stored\n     */\n    public setOutOfBandMembers(roomId: string, membershipEvents: IStateEventWithRoomId[]): Promise<void> {\n        return this.doCmd(\"setOutOfBandMembers\", [roomId, membershipEvents]);\n    }\n\n    public clearOutOfBandMembers(roomId: string): Promise<void> {\n        return this.doCmd(\"clearOutOfBandMembers\", [roomId]);\n    }\n\n    public getClientOptions(): Promise<IStoredClientOpts | undefined> {\n        return this.doCmd(\"getClientOptions\");\n    }\n\n    public storeClientOptions(options: IStoredClientOpts): Promise<void> {\n        return this.doCmd(\"storeClientOptions\", [options]);\n    }\n\n    /**\n     * Load all user presence events from the database. This is not cached.\n     * @returns A list of presence events in their raw form.\n     */\n    public getUserPresenceEvents(): Promise<UserTuple[]> {\n        return this.doCmd(\"getUserPresenceEvents\");\n    }\n\n    public async saveToDeviceBatches(batches: ToDeviceBatchWithTxnId[]): Promise<void> {\n        return this.doCmd(\"saveToDeviceBatches\", [batches]);\n    }\n\n    public async getOldestToDeviceBatch(): Promise<IndexedToDeviceBatch | null> {\n        return this.doCmd(\"getOldestToDeviceBatch\");\n    }\n\n    public async removeToDeviceBatch(id: number): Promise<void> {\n        return this.doCmd(\"removeToDeviceBatch\", [id]);\n    }\n\n    private ensureStarted(): Promise<void> {\n        if (!this.startPromise) {\n            this.worker = this.workerFactory();\n            this.worker.onmessage = this.onWorkerMessage;\n\n            // tell the worker the db name.\n            this.startPromise = this.doCmd(\"setupWorker\", [this.dbName]).then(() => {\n                logger.log(\"IndexedDB worker is ready\");\n            });\n        }\n        return this.startPromise;\n    }\n\n    private doCmd<T>(command: string, args?: any): Promise<T> {\n        // wrap in a q so if the postMessage throws,\n        // the promise automatically gets rejected\n        return Promise.resolve().then(() => {\n            const seq = this.nextSeq++;\n            const def = defer<T>();\n\n            this.inFlight[seq] = def;\n\n            this.worker?.postMessage({ command, seq, args });\n\n            return def.promise;\n        });\n    }\n\n    private onWorkerMessage = (ev: MessageEvent): void => {\n        const msg = ev.data;\n\n        if (msg.command == \"closed\") {\n            this.onClose?.();\n        } else if (msg.command == \"cmd_success\" || msg.command == \"cmd_fail\") {\n            if (msg.seq === undefined) {\n                logger.error(\"Got reply from worker with no seq\");\n                return;\n            }\n\n            const def = this.inFlight[msg.seq];\n            if (def === undefined) {\n                logger.error(\"Got reply for unknown seq \" + msg.seq);\n                return;\n            }\n            delete this.inFlight[msg.seq];\n\n            if (msg.command == \"cmd_success\") {\n                def.resolve(msg.result);\n            } else {\n                const error = new Error(msg.error.message);\n                error.name = msg.error.name;\n                def.reject(error);\n            }\n        } else {\n            logger.warn(\"Unrecognised message from worker: \", msg);\n        }\n    };\n\n    /*\n     * Destroy the web worker\n     */\n    public async destroy(): Promise<void> {\n        this.worker?.terminate();\n    }\n}\n","/*\nCopyright 2017 - 2021 Vector Creations Ltd\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\n/* eslint-disable @babel/no-invalid-this */\n\nimport { MemoryStore, type IOpts as IBaseOpts } from \"./memory.ts\";\nimport { LocalIndexedDBStoreBackend } from \"./indexeddb-local-backend.ts\";\nimport { RemoteIndexedDBStoreBackend } from \"./indexeddb-remote-backend.ts\";\nimport { type IEvent, MatrixEvent } from \"../models/event.ts\";\nimport { logger } from \"../logger.ts\";\nimport { type ISavedSync } from \"./index.ts\";\nimport { type IIndexedDBBackend } from \"./indexeddb-backend.ts\";\nimport { type ISyncResponse } from \"../sync-accumulator.ts\";\nimport { type EventEmitterEvents, TypedEventEmitter } from \"../models/typed-event-emitter.ts\";\nimport { type IStateEventWithRoomId } from \"../@types/search.ts\";\nimport { type IndexedToDeviceBatch, type ToDeviceBatchWithTxnId } from \"../models/ToDeviceMessage.ts\";\nimport { type IStoredClientOpts } from \"../client.ts\";\n\n/**\n * This is an internal module. See {@link IndexedDBStore} for the public class.\n */\n\n// If this value is too small we'll be writing very often which will cause\n// noticeable stop-the-world pauses. If this value is too big we'll be writing\n// so infrequently that the /sync size gets bigger on reload. Writing more\n// often does not affect the length of the pause since the entire /sync\n// response is persisted each time.\nconst WRITE_DELAY_MS = 1000 * 60 * 5; // once every 5 minutes\n\ninterface IOpts extends IBaseOpts {\n    /** The Indexed DB interface e.g. `window.indexedDB` */\n    indexedDB?: IDBFactory;\n    /** Optional database name. The same name must be used to open the same database. */\n    dbName?: string;\n    /** Optional factory to spin up a Worker to execute the IDB transactions within. */\n    workerFactory?: () => Worker;\n}\n\ntype EventHandlerMap = {\n    // Fired when an IDB command fails on a degradable path, and the store falls back to MemoryStore\n    // This signals the potential for data volatility.\n    degraded: (e: Error) => void;\n    // Fired when the IndexedDB gets closed unexpectedly, for example, if the underlying storage is removed or\n    // if the user clears the database in the browser's history preferences.\n    closed: () => void;\n};\n\nexport class IndexedDBStore extends MemoryStore {\n    public static exists(indexedDB: IDBFactory, dbName: string): Promise<boolean> {\n        return LocalIndexedDBStoreBackend.exists(indexedDB, dbName);\n    }\n\n    /**\n     * The backend instance.\n     * Call through to this API if you need to perform specific indexeddb actions like deleting the database.\n     */\n    public readonly backend: IIndexedDBBackend;\n\n    private startedUp = false;\n    private syncTs = 0;\n    // Records the last-modified-time of each user at the last point we saved\n    // the database, such that we can derive the set if users that have been\n    // modified since we last saved.\n    private userModifiedMap: Record<string, number> = {}; // user_id : timestamp\n    private emitter = new TypedEventEmitter<keyof EventHandlerMap, EventHandlerMap>();\n\n    /**\n     * Construct a new Indexed Database store, which extends MemoryStore.\n     *\n     * This store functions like a MemoryStore except it periodically persists\n     * the contents of the store to an IndexedDB backend.\n     *\n     * All data is still kept in-memory but can be loaded from disk by calling\n     * `startup()`. This can make startup times quicker as a complete\n     * sync from the server is not required. This does not reduce memory usage as all\n     * the data is eagerly fetched when `startup()` is called.\n     * ```\n     * let opts = { indexedDB: window.indexedDB, localStorage: window.localStorage };\n     * let store = new IndexedDBStore(opts);\n     * let client = sdk.createClient({\n     *     store: store,\n     * });\n     * await store.startup(); // load from indexed db, must be called after createClient\n     * client.startClient();\n     * client.on(\"sync\", function(state, prevState, data) {\n     *     if (state === \"PREPARED\") {\n     *         console.log(\"Started up, now with go faster stripes!\");\n     *     }\n     * });\n     * ```\n     *\n     * @param opts - Options object.\n     */\n    public constructor(opts: IOpts) {\n        super(opts);\n\n        if (!opts.indexedDB) {\n            throw new Error(\"Missing required option: indexedDB\");\n        }\n\n        if (opts.workerFactory) {\n            this.backend = new RemoteIndexedDBStoreBackend(opts.workerFactory, opts.dbName);\n        } else {\n            this.backend = new LocalIndexedDBStoreBackend(opts.indexedDB, opts.dbName);\n        }\n    }\n\n    /** Re-exports `TypedEventEmitter.on` */\n    public on(event: EventEmitterEvents | \"degraded\" | \"closed\", handler: (...args: any[]) => void): void {\n        this.emitter.on(event, handler);\n    }\n\n    /**\n     * @returns Resolved when loaded from indexed db.\n     */\n    public startup(): Promise<void> {\n        if (this.startedUp) {\n            logger.log(`IndexedDBStore.startup: already started`);\n            return Promise.resolve();\n        }\n\n        logger.log(`IndexedDBStore.startup: connecting to backend`);\n        return this.backend\n            .connect(this.onClose)\n            .then(() => {\n                logger.log(`IndexedDBStore.startup: loading presence events`);\n                return this.backend.getUserPresenceEvents();\n            })\n            .then((userPresenceEvents) => {\n                logger.log(`IndexedDBStore.startup: processing presence events`);\n                userPresenceEvents.forEach(([userId, rawEvent]) => {\n                    if (!this.createUser) {\n                        throw new Error(\n                            \"`IndexedDBStore.startup` must be called after assigning it to the client, not before!\",\n                        );\n                    }\n                    const u = this.createUser(userId);\n                    if (rawEvent) {\n                        u.setPresenceEvent(new MatrixEvent(rawEvent));\n                    }\n                    this.userModifiedMap[u.userId] = u.getLastModifiedTime();\n                    this.storeUser(u);\n                });\n                this.startedUp = true;\n            });\n    }\n\n    /*\n     * Close the database and destroy any associated workers\n     */\n    public destroy(): Promise<void> {\n        return this.backend.destroy();\n    }\n\n    private onClose = (): void => {\n        this.emitter.emit(\"closed\");\n    };\n\n    /**\n     * @returns Promise which resolves with a sync response to restore the\n     * client state to where it was at the last save, or null if there\n     * is no saved sync data.\n     */\n    public getSavedSync = this.degradable((): Promise<ISavedSync | null> => {\n        return this.backend.getSavedSync();\n    }, \"getSavedSync\");\n\n    /** @returns whether or not the database was newly created in this session. */\n    public isNewlyCreated = this.degradable((): Promise<boolean> => {\n        return this.backend.isNewlyCreated();\n    }, \"isNewlyCreated\");\n\n    /**\n     * @returns If there is a saved sync, the nextBatch token\n     * for this sync, otherwise null.\n     */\n    public getSavedSyncToken = this.degradable((): Promise<string | null> => {\n        return this.backend.getNextBatchToken();\n    }, \"getSavedSyncToken\");\n\n    /**\n     * Delete all data from this store.\n     * @returns Promise which resolves if the data was deleted from the database.\n     */\n    public deleteAllData = this.degradable((): Promise<void> => {\n        super.deleteAllData();\n        return this.backend.clearDatabase().then(\n            () => {\n                logger.log(\"Deleted indexeddb data.\");\n            },\n            (err) => {\n                logger.error(`Failed to delete indexeddb data: ${err}`);\n                throw err;\n            },\n        );\n    }, null);\n\n    /**\n     * Whether this store would like to save its data\n     * Note that obviously whether the store wants to save or\n     * not could change between calling this function and calling\n     * save().\n     *\n     * @returns True if calling save() will actually save\n     *     (at the time this function is called).\n     */\n    public wantsSave(): boolean {\n        const now = Date.now();\n        return now - this.syncTs > WRITE_DELAY_MS;\n    }\n\n    /**\n     * Possibly write data to the database.\n     *\n     * @param force - True to force a save to happen\n     * @returns Promise resolves after the write completes\n     *     (or immediately if no write is performed)\n     */\n    public save(force = false): Promise<void> {\n        if (force || this.wantsSave()) {\n            return this.reallySave();\n        }\n        return Promise.resolve();\n    }\n\n    private reallySave = this.degradable((): Promise<void> => {\n        this.syncTs = Date.now(); // set now to guard against multi-writes\n\n        // work out changed users (this doesn't handle deletions but you\n        // can't 'delete' users as they are just presence events).\n        const userTuples: [userId: string, presenceEvent: Partial<IEvent>][] = [];\n        for (const u of this.getUsers()) {\n            if (this.userModifiedMap[u.userId] === u.getLastModifiedTime()) continue;\n            if (!u.events.presence) continue;\n\n            userTuples.push([u.userId, u.events.presence.event]);\n\n            // note that we've saved this version of the user\n            this.userModifiedMap[u.userId] = u.getLastModifiedTime();\n        }\n\n        return this.backend.syncToDatabase(userTuples);\n    }, null);\n\n    public setSyncData = this.degradable((syncData: ISyncResponse): Promise<void> => {\n        return this.backend.setSyncData(syncData);\n    }, \"setSyncData\");\n\n    /**\n     * Returns the out-of-band membership events for this room that\n     * were previously loaded.\n     * @returns the events, potentially an empty array if OOB loading didn't yield any new members\n     * @returns in case the members for this room haven't been stored yet\n     */\n    public getOutOfBandMembers = this.degradable((roomId: string): Promise<IStateEventWithRoomId[] | null> => {\n        return this.backend.getOutOfBandMembers(roomId);\n    }, \"getOutOfBandMembers\");\n\n    /**\n     * Stores the out-of-band membership events for this room. Note that\n     * it still makes sense to store an empty array as the OOB status for the room is\n     * marked as fetched, and getOutOfBandMembers will return an empty array instead of null\n     * @param membershipEvents - the membership events to store\n     * @returns when all members have been stored\n     */\n    public setOutOfBandMembers = this.degradable(\n        (roomId: string, membershipEvents: IStateEventWithRoomId[]): Promise<void> => {\n            super.setOutOfBandMembers(roomId, membershipEvents);\n            return this.backend.setOutOfBandMembers(roomId, membershipEvents);\n        },\n        \"setOutOfBandMembers\",\n    );\n\n    public clearOutOfBandMembers = this.degradable((roomId: string) => {\n        super.clearOutOfBandMembers(roomId);\n        return this.backend.clearOutOfBandMembers(roomId);\n    }, \"clearOutOfBandMembers\");\n\n    public getClientOptions = this.degradable((): Promise<IStoredClientOpts | undefined> => {\n        return this.backend.getClientOptions();\n    }, \"getClientOptions\");\n\n    public storeClientOptions = this.degradable((options: IStoredClientOpts): Promise<void> => {\n        super.storeClientOptions(options);\n        return this.backend.storeClientOptions(options);\n    }, \"storeClientOptions\");\n\n    /**\n     * All member functions of `IndexedDBStore` that access the backend use this wrapper to\n     * watch for failures after initial store startup, including `QuotaExceededError` as\n     * free disk space changes, etc.\n     *\n     * When IndexedDB fails via any of these paths, we degrade this back to a `MemoryStore`\n     * in place so that the current operation and all future ones are in-memory only.\n     *\n     * @param func - The degradable work to do.\n     * @param fallback - The method name for fallback.\n     * @returns A wrapped member function.\n     */\n    private degradable<A extends Array<any>, F extends keyof MemoryStore | null, R = void>(\n        func: DegradableFn<A, R>,\n        fallback: F,\n    ): DegradableFn<A, F extends string ? R : void> {\n        const fallbackFn = fallback ? (super[fallback] as (...args: A) => Promise<R>) : null;\n\n        return (async (...args) => {\n            try {\n                return await func.call(this, ...args);\n            } catch (e) {\n                logger.error(\"IndexedDBStore failure, degrading to MemoryStore\", e);\n                this.emitter.emit(\"degraded\", e as Error);\n                try {\n                    // We try to delete IndexedDB after degrading since this store is only a\n                    // cache (the app will still function correctly without the data).\n                    // It's possible that deleting repair IndexedDB for the next app load,\n                    // potentially by making a little more space available.\n                    logger.log(\"IndexedDBStore trying to delete degraded data\");\n                    await this.backend.clearDatabase();\n                    logger.log(\"IndexedDBStore delete after degrading succeeded\");\n                } catch (e) {\n                    logger.warn(\"IndexedDBStore delete after degrading failed\", e);\n                }\n                // Degrade the store from being an instance of `IndexedDBStore` to instead be\n                // an instance of `MemoryStore` so that future API calls use the memory path\n                // directly and skip IndexedDB entirely. This should be safe as\n                // `IndexedDBStore` already extends from `MemoryStore`, so we are making the\n                // store become its parent type in a way. The mutator methods of\n                // `IndexedDBStore` also maintain the state that `MemoryStore` uses (many are\n                // not overridden at all).\n                if (fallbackFn) {\n                    return fallbackFn.call(this, ...args);\n                }\n            }\n        }) as DegradableFn<A, F extends string ? R : void>;\n    }\n\n    // XXX: ideally these would be stored in indexeddb as part of the room but,\n    // we don't store rooms as such and instead accumulate entire sync responses atm.\n    public async getPendingEvents(roomId: string): Promise<Partial<IEvent>[]> {\n        if (!this.localStorage) return super.getPendingEvents(roomId);\n\n        const serialized = this.localStorage.getItem(pendingEventsKey(roomId));\n        if (serialized) {\n            try {\n                return JSON.parse(serialized);\n            } catch (e) {\n                logger.error(\"Could not parse persisted pending events\", e);\n            }\n        }\n        return [];\n    }\n\n    public async setPendingEvents(roomId: string, events: Partial<IEvent>[]): Promise<void> {\n        if (!this.localStorage) return super.setPendingEvents(roomId, events);\n\n        if (events.length > 0) {\n            this.localStorage.setItem(pendingEventsKey(roomId), JSON.stringify(events));\n        } else {\n            this.localStorage.removeItem(pendingEventsKey(roomId));\n        }\n    }\n\n    public saveToDeviceBatches(batches: ToDeviceBatchWithTxnId[]): Promise<void> {\n        return this.backend.saveToDeviceBatches(batches);\n    }\n\n    public getOldestToDeviceBatch(): Promise<IndexedToDeviceBatch | null> {\n        return this.backend.getOldestToDeviceBatch();\n    }\n\n    public removeToDeviceBatch(id: number): Promise<void> {\n        return this.backend.removeToDeviceBatch(id);\n    }\n}\n\n/**\n * @param roomId - ID of the current room\n * @returns Storage key to retrieve pending events\n */\nfunction pendingEventsKey(roomId: string): string {\n    return `mx_pending_events_${roomId}`;\n}\n\ntype DegradableFn<A extends Array<any>, T> = (...args: A) => Promise<T>;\n","/*\nCopyright 2021 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nexport enum ThreepidMedium {\n    Email = \"email\",\n    Phone = \"msisdn\",\n}\n\n// TODO: Are these types universal, or specific to just /account/3pid?\nexport interface IThreepid {\n    medium: ThreepidMedium;\n    address: string;\n    validated_at: number; // eslint-disable-line camelcase\n    added_at: number; // eslint-disable-line camelcase\n    bound?: boolean;\n}\n","/*\nCopyright 2022 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { UnstableValue } from \"../NamespacedValue.ts\";\nimport { type IClientWellKnown } from \"../client.ts\";\n\n// disable lint because these are wire responses\n/* eslint-disable camelcase */\n\n/**\n * Represents a response to the CSAPI `/refresh` endpoint.\n */\nexport interface IRefreshTokenResponse {\n    access_token: string;\n    expires_in_ms: number;\n    refresh_token: string;\n}\n\n/* eslint-enable camelcase */\n\n/**\n * Response to GET login flows as per https://spec.matrix.org/v1.3/client-server-api/#get_matrixclientv3login\n */\nexport interface ILoginFlowsResponse {\n    flows: LoginFlow[];\n}\n\nexport type LoginFlow = ISSOFlow | IPasswordFlow | ILoginFlow;\n\nexport interface ILoginFlow {\n    type: string;\n}\n\nexport interface IPasswordFlow extends ILoginFlow {\n    type: \"m.login.password\";\n}\n\nexport const DELEGATED_OIDC_COMPATIBILITY = new UnstableValue(\n    \"delegated_oidc_compatibility\",\n    \"org.matrix.msc3824.delegated_oidc_compatibility\",\n);\n\n/**\n * Representation of SSO flow as per https://spec.matrix.org/v1.3/client-server-api/#client-login-via-sso\n */\nexport interface ISSOFlow extends ILoginFlow {\n    type: \"m.login.sso\" | \"m.login.cas\";\n    // eslint-disable-next-line camelcase\n    identity_providers?: IIdentityProvider[];\n    [DELEGATED_OIDC_COMPATIBILITY.name]?: boolean;\n    [DELEGATED_OIDC_COMPATIBILITY.altName]?: boolean;\n}\n\nexport enum IdentityProviderBrand {\n    Gitlab = \"gitlab\",\n    Github = \"github\",\n    Apple = \"apple\",\n    Google = \"google\",\n    Facebook = \"facebook\",\n    Twitter = \"twitter\",\n}\n\nexport interface IIdentityProvider {\n    id: string;\n    name: string;\n    icon?: string;\n    brand?: IdentityProviderBrand | string;\n}\n\nexport enum SSOAction {\n    /** The user intends to login to an existing account */\n    LOGIN = \"login\",\n\n    /** The user intends to register for a new account */\n    REGISTER = \"register\",\n}\n\n/**\n * A client can identify a user using their Matrix ID.\n * This can either be the fully qualified Matrix user ID, or just the localpart of the user ID.\n * @see https://spec.matrix.org/v1.7/client-server-api/#matrix-user-id\n */\ntype UserLoginIdentifier = {\n    type: \"m.id.user\";\n    user: string;\n};\n\n/**\n * A client can identify a user using a 3PID associated with the user’s account on the homeserver,\n * where the 3PID was previously associated using the /account/3pid API.\n * See the 3PID Types Appendix for a list of Third-party ID media.\n * @see https://spec.matrix.org/v1.7/client-server-api/#third-party-id\n */\ntype ThirdPartyLoginIdentifier = {\n    type: \"m.id.thirdparty\";\n    medium: string;\n    address: string;\n};\n\n/**\n * A client can identify a user using a phone number associated with the user’s account,\n * where the phone number was previously associated using the /account/3pid API.\n * The phone number can be passed in as entered by the user; the homeserver will be responsible for canonicalising it.\n * If the client wishes to canonicalise the phone number,\n * then it can use the m.id.thirdparty identifier type with a medium of msisdn instead.\n *\n * The country is the two-letter uppercase ISO-3166-1 alpha-2 country code that the number in phone should be parsed as if it were dialled from.\n *\n * @see https://spec.matrix.org/v1.7/client-server-api/#phone-number\n */\ntype PhoneLoginIdentifier = {\n    type: \"m.id.phone\";\n    country: string;\n    phone: string;\n};\n\ntype SpecUserIdentifier = UserLoginIdentifier | ThirdPartyLoginIdentifier | PhoneLoginIdentifier;\n\n/**\n * User Identifiers usable for login & user-interactive authentication.\n *\n * Extensibly allows more than Matrix specified identifiers.\n */\nexport type UserIdentifier =\n    | SpecUserIdentifier\n    | { type: Exclude<string, SpecUserIdentifier[\"type\"]>; [key: string]: any };\n\n/**\n * Request body for POST /login request\n * @see https://spec.matrix.org/v1.7/client-server-api/#post_matrixclientv3login\n */\nexport interface LoginRequest {\n    /**\n     * The login type being used.\n     */\n    type: \"m.login.password\" | \"m.login.token\" | string;\n    /**\n     * ID of the client device.\n     * If this does not correspond to a known client device, a new device will be created.\n     * The given device ID must not be the same as a cross-signing key ID.\n     * The server will auto-generate a device_id if this is not specified.\n     */\n    device_id?: string;\n    /**\n     * Identification information for a user\n     */\n    identifier?: UserIdentifier;\n    /**\n     * A display name to assign to the newly-created device.\n     * Ignored if device_id corresponds to a known device.\n     */\n    initial_device_display_name?: string;\n    /**\n     * When logging in using a third-party identifier, the medium of the identifier.\n     * Must be `email`.\n     * @deprecated in favour of `identifier`.\n     */\n    medium?: \"email\";\n    /**\n     * Required when type is `m.login.password`. The user’s password.\n     */\n    password?: string;\n    /**\n     * If true, the client supports refresh tokens.\n     */\n    refresh_token?: boolean;\n    /**\n     * Required when type is `m.login.token`. Part of Token-based login.\n     */\n    token?: string;\n    /**\n     * The fully qualified user ID or just local part of the user ID, to log in.\n     * @deprecated in favour of identifier.\n     */\n    user?: string;\n    // Extensible\n    [key: string]: any;\n}\n\n// Export for backwards compatibility\nexport type ILoginParams = LoginRequest;\n\n/**\n * Response body for POST /login request\n * @see https://spec.matrix.org/v1.7/client-server-api/#post_matrixclientv3login\n */\nexport interface LoginResponse {\n    /**\n     * An access token for the account.\n     * This access token can then be used to authorize other requests.\n     */\n    access_token: string;\n    /**\n     * ID of the logged-in device.\n     * Will be the same as the corresponding parameter in the request, if one was specified.\n     */\n    device_id: string;\n    /**\n     * The fully-qualified Matrix ID for the account.\n     */\n    user_id: string;\n    /**\n     * The lifetime of the access token, in milliseconds.\n     * Once the access token has expired a new access token can be obtained by using the provided refresh token.\n     * If no refresh token is provided, the client will need to re-log in to obtain a new access token.\n     * If not given, the client can assume that the access token will not expire.\n     */\n    expires_in_ms?: number;\n    /**\n     * A refresh token for the account.\n     * This token can be used to obtain a new access token when it expires by calling the /refresh endpoint.\n     */\n    refresh_token?: string;\n    /**\n     * Optional client configuration provided by the server.\n     * If present, clients SHOULD use the provided object to reconfigure themselves, optionally validating the URLs within.\n     * This object takes the same form as the one returned from .well-known autodiscovery.\n     */\n    well_known?: IClientWellKnown;\n    /**\n     * The server_name of the homeserver on which the account has been registered.\n     * @deprecated Clients should extract the server_name from user_id (by splitting at the first colon) if they require it.\n     */\n    home_server?: string;\n}\n\n/**\n * The result of a successful `m.login.token` issuance request as per https://spec.matrix.org/v1.7/client-server-api/#post_matrixclientv1loginget_token\n */\nexport interface LoginTokenPostResponse {\n    /**\n     * The token to use with `m.login.token` to authenticate.\n     */\n    login_token: string;\n    /**\n     * Expiration in milliseconds.\n     */\n    expires_in_ms: number;\n}\n","/**\n * The timezone the user is currently in. The value of this property should\n * match a timezone provided in https://www.iana.org/time-zones.\n *\n * @see https://github.com/matrix-org/matrix-spec-proposals/blob/clokep/profile-tz/proposals/4175-profile-field-time-zone.md\n * @experimental\n */\nexport const ProfileKeyMSC4175Timezone = \"us.cloke.msc4175.tz\";\n","/*\nCopyright 2021 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { TypedEventEmitter } from \"../models/typed-event-emitter.ts\";\n\nexport enum LocalStorageErrors {\n    Global = \"Global\",\n    SetItemError = \"setItem\",\n    GetItemError = \"getItem\",\n    RemoveItemError = \"removeItem\",\n    ClearError = \"clear\",\n    QuotaExceededError = \"QuotaExceededError\",\n}\n\ntype EventHandlerMap = {\n    [LocalStorageErrors.Global]: (error: Error) => void;\n    [LocalStorageErrors.SetItemError]: (error: Error) => void;\n    [LocalStorageErrors.GetItemError]: (error: Error) => void;\n    [LocalStorageErrors.RemoveItemError]: (error: Error) => void;\n    [LocalStorageErrors.ClearError]: (error: Error) => void;\n    [LocalStorageErrors.QuotaExceededError]: (error: Error) => void;\n};\n\n/**\n * Used in element-web as a temporary hack to handle all the localStorage errors on the highest level possible\n * As of 15.11.2021 (DD/MM/YYYY) we're not properly handling local storage exceptions anywhere.\n * This store, as an event emitter, is used to re-emit local storage exceptions so that we can handle them\n * and show some kind of a \"It's dead Jim\" modal to the users, telling them that hey,\n * maybe you should check out your disk, as it's probably dying and your session may die with it.\n * See: https://github.com/vector-im/element-web/issues/18423\n */\nclass LocalStorageErrorsEventsEmitter extends TypedEventEmitter<LocalStorageErrors, EventHandlerMap> {}\nexport const localStorageErrorsEventsEmitter = new LocalStorageErrorsEventsEmitter();\n","/*\nCopyright 2015-2022 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { type WidgetApi } from \"matrix-widget-api\";\n\nimport { MemoryCryptoStore } from \"./crypto/store/memory-crypto-store.ts\";\nimport { MemoryStore } from \"./store/memory.ts\";\nimport { MatrixScheduler } from \"./scheduler.ts\";\nimport { MatrixClient, type ICreateClientOpts } from \"./client.ts\";\nimport { RoomWidgetClient, type ICapabilities } from \"./embedded.ts\";\nimport { type CryptoStore } from \"./crypto/store/base.ts\";\n\nexport * from \"./client.ts\";\nexport * from \"./serverCapabilities.ts\";\nexport * from \"./embedded.ts\";\nexport * from \"./http-api/index.ts\";\nexport * from \"./autodiscovery.ts\";\nexport * from \"./sync-accumulator.ts\";\nexport * from \"./errors.ts\";\nexport * from \"./base64.ts\";\nexport * from \"./models/beacon.ts\";\nexport * from \"./models/event.ts\";\nexport * from \"./models/room.ts\";\nexport * from \"./models/event-timeline.ts\";\nexport * from \"./models/event-timeline-set.ts\";\nexport * from \"./models/poll.ts\";\nexport * from \"./models/room-member.ts\";\nexport * from \"./models/room-state.ts\";\nexport * from \"./models/thread.ts\";\nexport * from \"./models/typed-event-emitter.ts\";\nexport * from \"./models/user.ts\";\nexport * from \"./models/device.ts\";\nexport * from \"./models/search-result.ts\";\nexport * from \"./oidc/index.ts\";\nexport * from \"./scheduler.ts\";\nexport * from \"./filter.ts\";\nexport * from \"./timeline-window.ts\";\nexport * from \"./interactive-auth.ts\";\nexport * from \"./version-support.ts\";\nexport * from \"./service-types.ts\";\nexport * from \"./store/memory.ts\";\nexport * from \"./store/indexeddb.ts\";\nexport * from \"./crypto/store/memory-crypto-store.ts\";\nexport * from \"./crypto/store/localStorage-crypto-store.ts\";\nexport * from \"./crypto/store/indexeddb-crypto-store.ts\";\nexport type { OutgoingRoomKeyRequest } from \"./crypto/store/base.ts\";\nexport * from \"./content-repo.ts\";\nexport type * from \"./@types/common.ts\";\nexport type * from \"./@types/uia.ts\";\nexport * from \"./@types/event.ts\";\nexport * from \"./@types/PushRules.ts\";\nexport * from \"./@types/partials.ts\";\nexport * from \"./@types/requests.ts\";\nexport * from \"./@types/search.ts\";\nexport * from \"./@types/beacon.ts\";\nexport * from \"./@types/topic.ts\";\nexport * from \"./@types/location.ts\";\nexport * from \"./@types/threepids.ts\";\nexport * from \"./@types/auth.ts\";\nexport * from \"./@types/polls.ts\";\nexport type * from \"./@types/local_notifications.ts\";\nexport type * from \"./@types/registration.ts\";\nexport * from \"./@types/read_receipts.ts\";\nexport type * from \"./@types/crypto.ts\";\nexport * from \"./@types/extensible_events.ts\";\nexport type * from \"./@types/IIdentityServerProvider.ts\";\nexport * from \"./@types/membership.ts\";\nexport * from \"./models/room-summary.ts\";\nexport * from \"./models/event-status.ts\";\nexport * from \"./models/profile-keys.ts\";\nexport * from \"./models/related-relations.ts\";\nexport type { RoomSummary } from \"./client.ts\";\nexport * as ContentHelpers from \"./content-helpers.ts\";\nexport * as SecretStorage from \"./secret-storage.ts\";\nexport { createNewMatrixCall, CallEvent } from \"./webrtc/call.ts\";\nexport type { MatrixCall } from \"./webrtc/call.ts\";\nexport {\n    GroupCall,\n    GroupCallEvent,\n    GroupCallIntent,\n    GroupCallState,\n    GroupCallType,\n    GroupCallStatsReportEvent,\n} from \"./webrtc/groupCall.ts\";\n\nexport { SyncState, SetPresence } from \"./sync.ts\";\nexport type { ISyncStateData as SyncStateData } from \"./sync.ts\";\nexport { SlidingSyncEvent } from \"./sliding-sync.ts\";\nexport { MediaHandlerEvent } from \"./webrtc/mediaHandler.ts\";\nexport { CallFeedEvent } from \"./webrtc/callFeed.ts\";\nexport { StatsReport } from \"./webrtc/stats/statsReport.ts\";\nexport { Relations, RelationsEvent } from \"./models/relations.ts\";\nexport { TypedEventEmitter } from \"./models/typed-event-emitter.ts\";\nexport { LocalStorageErrors, localStorageErrorsEventsEmitter } from \"./store/local-storage-events-emitter.ts\";\nexport { IdentityProviderBrand, SSOAction } from \"./@types/auth.ts\";\nexport type { ISSOFlow as SSOFlow, LoginFlow } from \"./@types/auth.ts\";\nexport type { IHierarchyRelation as HierarchyRelation, IHierarchyRoom as HierarchyRoom } from \"./@types/spaces.ts\";\nexport { LocationAssetType } from \"./@types/location.ts\";\n\nlet cryptoStoreFactory = (): CryptoStore => new MemoryCryptoStore();\n\n/**\n * Configure a different factory to be used for creating crypto stores\n *\n * @param fac - a function which will return a new `CryptoStore`\n */\nexport function setCryptoStoreFactory(fac: () => CryptoStore): void {\n    cryptoStoreFactory = fac;\n}\n\nfunction amendClientOpts(opts: ICreateClientOpts): ICreateClientOpts {\n    opts.store =\n        opts.store ??\n        new MemoryStore({\n            localStorage: globalThis.localStorage,\n        });\n    opts.scheduler = opts.scheduler ?? new MatrixScheduler();\n    opts.cryptoStore = opts.cryptoStore ?? cryptoStoreFactory();\n\n    return opts;\n}\n\n/**\n * Construct a Matrix Client. Similar to {@link MatrixClient}\n * except that the 'request', 'store' and 'scheduler' dependencies are satisfied.\n * @param opts - The configuration options for this client. These configuration\n * options will be passed directly to {@link MatrixClient}.\n *\n * @returns A new matrix client.\n * @see {@link MatrixClient} for the full list of options for\n * `opts`.\n */\nexport function createClient(opts: ICreateClientOpts): MatrixClient {\n    return new MatrixClient(amendClientOpts(opts));\n}\n\n/**\n * Construct a Matrix Client that works in a widget.\n * This client has a subset of features compared to a full client.\n * It uses the widget-api to communicate with matrix. (widget \\<-\\> client \\<-\\> homeserver)\n * @returns A new matrix client with a subset of features.\n * @param opts - The configuration options for this client. These configuration\n * options will be passed directly to {@link MatrixClient}.\n * @param widgetApi - The widget api to use for communication.\n * @param capabilities - The capabilities the widget client will request.\n * @param roomId - The room id the widget is associated with.\n * @param sendContentLoaded - Whether to send a content loaded widget action immediately after initial setup.\n *   Set to `false` if the widget uses `waitForIFrameLoad=true` (in this case the client does not expect a content loaded action at all),\n *   or if the the widget wants to send the `ContentLoaded` action at a later point in time after the initial setup.\n */\nexport function createRoomWidgetClient(\n    widgetApi: WidgetApi,\n    capabilities: ICapabilities,\n    roomId: string,\n    opts: ICreateClientOpts,\n    sendContentLoaded = true,\n): MatrixClient {\n    return new RoomWidgetClient(widgetApi, capabilities, roomId, amendClientOpts(opts), sendContentLoaded);\n}\n","/*\nCopyright 2023 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { type MatrixEvent } from \"../matrix.ts\";\nimport { deepCompare } from \"../utils.ts\";\nimport { type Focus } from \"./focus.ts\";\nimport { isLivekitFocusActive } from \"./LivekitFocus.ts\";\n\n/**\n * The default duration in milliseconds that a membership is considered valid for.\n * Ordinarily the client responsible for the session will update the membership before it expires.\n * We use this duration as the fallback case where stale sessions are present for some reason.\n */\nexport const DEFAULT_EXPIRE_DURATION = 1000 * 60 * 60 * 4;\n\ntype CallScope = \"m.room\" | \"m.user\";\n\n/**\n * MSC4143 (MatrixRTC) session membership data.\n * Represents an entry in the memberships section of an m.call.member event as it is on the wire.\n **/\nexport type SessionMembershipData = {\n    /**\n     * The RTC application defines the type of the RTC session.\n     */\n    application: string;\n\n    /**\n     * The id of this session.\n     * A session can never span over multiple rooms so this id is to distinguish between\n     * multiple session in one room. A room wide session that is not associated with a user,\n     * and therefore immune to creation race conflicts, uses the `call_id: \"\"`.\n     */\n    call_id: string;\n\n    /**\n     * The Matrix device ID of this session. A single user can have multiple sessions on different devices.\n     */\n    device_id: string;\n\n    /**\n     * The focus selection system this user/membership is using.\n     */\n    focus_active: Focus;\n\n    /**\n     * A list of possible foci this uses knows about. One of them might be used based on the focus_active\n     * selection system.\n     */\n    foci_preferred: Focus[];\n\n    /**\n     * Optional field that contains the creation of the session. If it is undefined the creation\n     * is the `origin_server_ts` of the event itself. For updates to the event this property tracks\n     * the `origin_server_ts` of the initial join event.\n     *  - If it is undefined it can be interpreted as a \"Join\".\n     *  - If it is defined it can be interpreted as an \"Update\"\n     */\n    created_ts?: number;\n\n    // Application specific data\n\n    /**\n     * If the `application` = `\"m.call\"` this defines if it is a room or user owned call.\n     * There can always be one room scroped call but multiple user owned calls (breakout sessions)\n     */\n    scope?: CallScope;\n\n    /**\n     * Optionally we allow to define a delta to the `created_ts` that defines when the event is expired/invalid.\n     * This should be set to multiple hours. The only reason it exist is to deal with failed delayed events.\n     * (for example caused by a homeserver crashes)\n     **/\n    expires?: number;\n};\n\nconst checkSessionsMembershipData = (data: any, errors: string[]): data is SessionMembershipData => {\n    const prefix = \"Malformed session membership event: \";\n    if (typeof data.device_id !== \"string\") errors.push(prefix + \"device_id must be string\");\n    if (typeof data.call_id !== \"string\") errors.push(prefix + \"call_id must be string\");\n    if (typeof data.application !== \"string\") errors.push(prefix + \"application must be a string\");\n    if (typeof data.focus_active?.type !== \"string\") errors.push(prefix + \"focus_active.type must be a string\");\n    if (!Array.isArray(data.foci_preferred)) errors.push(prefix + \"foci_preferred must be an array\");\n    // optional parameters\n    if (data.created_ts && typeof data.created_ts !== \"number\") errors.push(prefix + \"created_ts must be number\");\n\n    // application specific data (we first need to check if they exist)\n    if (data.scope && typeof data.scope !== \"string\") errors.push(prefix + \"scope must be string\");\n    return errors.length === 0;\n};\n\nexport class CallMembership {\n    public static equal(a: CallMembership, b: CallMembership): boolean {\n        return deepCompare(a.membershipData, b.membershipData);\n    }\n    private membershipData: SessionMembershipData;\n\n    public constructor(\n        private parentEvent: MatrixEvent,\n        data: any,\n    ) {\n        const sessionErrors: string[] = [];\n        if (!checkSessionsMembershipData(data, sessionErrors)) {\n            throw Error(\n                `unknown CallMembership data. Does not match MSC4143 call.member (${sessionErrors.join(\" & \")}) events this could be a legacy membership event: (${data})`,\n            );\n        } else {\n            this.membershipData = data;\n        }\n    }\n\n    public get sender(): string | undefined {\n        return this.parentEvent.getSender();\n    }\n\n    public get eventId(): string | undefined {\n        return this.parentEvent.getId();\n    }\n\n    public get callId(): string {\n        return this.membershipData.call_id;\n    }\n\n    public get deviceId(): string {\n        return this.membershipData.device_id;\n    }\n\n    public get application(): string | undefined {\n        return this.membershipData.application;\n    }\n\n    public get scope(): CallScope | undefined {\n        return this.membershipData.scope;\n    }\n\n    public get membershipID(): string {\n        // the createdTs behaves equivalent to the membershipID.\n        // we only need the field for the legacy member envents where we needed to update them\n        // synapse ignores sending state events if they have the same content.\n        return this.createdTs().toString();\n    }\n\n    public createdTs(): number {\n        return this.membershipData.created_ts ?? this.parentEvent.getTs();\n    }\n\n    /**\n     * Gets the absolute expiry timestamp of the membership.\n     * @returns The absolute expiry time of the membership as a unix timestamp in milliseconds or undefined if not applicable\n     */\n    public getAbsoluteExpiry(): number {\n        // TODO: calculate this from the MatrixRTCSession join configuration directly\n        return this.createdTs() + (this.membershipData.expires ?? DEFAULT_EXPIRE_DURATION);\n    }\n\n    /**\n     * @returns The number of milliseconds until the membership expires or undefined if applicable\n     */\n    public getMsUntilExpiry(): number {\n        // Assume that local clock is sufficiently in sync with other clocks in the distributed system.\n        // We used to try and adjust for the local clock being skewed, but there are cases where this is not accurate.\n        // The current implementation allows for the local clock to be -infinity to +MatrixRTCSession.MEMBERSHIP_EXPIRY_TIME/2\n        return this.getAbsoluteExpiry() - Date.now();\n    }\n\n    /**\n     * @returns true if the membership has expired, otherwise false\n     */\n    public isExpired(): boolean {\n        return this.getMsUntilExpiry() <= 0;\n    }\n\n    public getPreferredFoci(): Focus[] {\n        return this.membershipData.foci_preferred;\n    }\n\n    public getFocusSelection(): string | undefined {\n        const focusActive = this.membershipData.focus_active;\n        if (isLivekitFocusActive(focusActive)) {\n            return focusActive.focus_selection;\n        }\n    }\n}\n","/*\nCopyright 2023 New Vector Ltd\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { type Focus } from \"./focus.ts\";\n\nexport interface LivekitFocusConfig extends Focus {\n    type: \"livekit\";\n    livekit_service_url: string;\n}\n\nexport const isLivekitFocusConfig = (object: any): object is LivekitFocusConfig =>\n    object.type === \"livekit\" && \"livekit_service_url\" in object;\n\nexport interface LivekitFocus extends LivekitFocusConfig {\n    livekit_alias: string;\n}\n\nexport const isLivekitFocus = (object: any): object is LivekitFocus =>\n    isLivekitFocusConfig(object) && \"livekit_alias\" in object;\n\nexport interface LivekitFocusActive extends Focus {\n    type: \"livekit\";\n    focus_selection: \"oldest_membership\";\n}\nexport const isLivekitFocusActive = (object: any): object is LivekitFocusActive =>\n    object.type === \"livekit\" && \"focus_selection\" in object;\n","import { logger as rootLogger } from \"../logger.ts\";\nimport { type EmptyObject } from \"../matrix.ts\";\nimport { sleep } from \"../utils.ts\";\nimport { MembershipActionType } from \"./NewMembershipManager.ts\";\n\nconst logger = rootLogger.getChild(\"MatrixRTCSession\");\n\n/** @internal */\nexport interface Action {\n    /**\n     * When this action should be executed\n     */\n    ts: number;\n    /**\n     * The state of the different loops\n     * can also be thought of as the type of the action\n     */\n    type: MembershipActionType;\n}\n\n/** @internal */\nexport type ActionUpdate =\n    | {\n          /** Replace all existing scheduled actions with this new array */\n          replace: Action[];\n      }\n    | {\n          /** Add these actions to the existing scheduled actions */\n          insert: Action[];\n      }\n    | EmptyObject;\n\n/**\n * This scheduler tracks the state of the current membership participation\n * and runs one central timer that wakes up a handler callback with the correct action + state\n * whenever necessary.\n *\n * It can also be awakened whenever a new action is added which is\n * earlier then the current \"next awake\".\n * @internal\n */\nexport class ActionScheduler {\n    /**\n     * This is tracking the state of the scheduler loop.\n     * Only used to prevent starting the loop twice.\n     */\n    public running = false;\n\n    public constructor(\n        /** This is the callback called for each scheduled action (`this.addAction()`) */\n        private membershipLoopHandler: (type: MembershipActionType) => Promise<ActionUpdate>,\n    ) {}\n\n    // function for the wakeup mechanism (in case we add an action externally and need to leave the current sleep)\n    private wakeup: (update: ActionUpdate) => void = (update: ActionUpdate): void => {\n        logger.error(\"Cannot call wakeup before calling `startWithJoin()`\");\n    };\n    private _actions: Action[] = [];\n    public get actions(): Action[] {\n        return this._actions;\n    }\n\n    /**\n     * This starts the main loop of the membership manager that handles event sending, delayed event sending and delayed event restarting.\n     * @param initialActions The initial actions the manager will start with. It should be enough to pass: DelayedLeaveActionType.Initial\n     * @returns Promise that resolves once all actions have run and no more are scheduled.\n     * @throws This throws an error if one of the actions throws.\n     * In most other error cases the manager will try to handle any server errors by itself.\n     */\n    public async startWithJoin(): Promise<void> {\n        if (this.running) {\n            logger.error(\"Cannot call startWithJoin() on NewMembershipActionScheduler while already running\");\n            return;\n        }\n        this.running = true;\n        this._actions = [{ ts: Date.now(), type: MembershipActionType.SendFirstDelayedEvent }];\n        try {\n            while (this._actions.length > 0) {\n                // Sort so next (smallest ts) action is at the beginning\n                this._actions.sort((a, b) => a.ts - b.ts);\n                const nextAction = this._actions[0];\n                let wakeupUpdate: ActionUpdate | undefined = undefined;\n\n                // while we await for the next action, wakeup has to resolve the wakeupPromise\n                const wakeupPromise = new Promise<void>((resolve) => {\n                    this.wakeup = (update: ActionUpdate): void => {\n                        wakeupUpdate = update;\n                        resolve();\n                    };\n                });\n                if (nextAction.ts > Date.now()) await Promise.race([wakeupPromise, sleep(nextAction.ts - Date.now())]);\n\n                let handlerResult: ActionUpdate = {};\n                if (!wakeupUpdate) {\n                    logger.debug(\n                        `Current MembershipManager processing: ${nextAction.type}\\nQueue:`,\n                        this._actions,\n                        `\\nDate.now: \"${Date.now()}`,\n                    );\n                    try {\n                        // `this.wakeup` can also be called and sets the `wakupUpdate` object while we are in the handler.\n                        handlerResult = await this.membershipLoopHandler(nextAction.type as MembershipActionType);\n                    } catch (e) {\n                        throw Error(`The MembershipManager shut down because of the end condition: ${e}`);\n                    }\n                }\n                // remove the processed action only after we are done processing\n                this._actions.splice(0, 1);\n                // The wakeupUpdate always wins since that is a direct external update.\n                const actionUpdate = wakeupUpdate ?? handlerResult;\n\n                if (\"replace\" in actionUpdate) {\n                    this._actions = actionUpdate.replace;\n                } else if (\"insert\" in actionUpdate) {\n                    this._actions.push(...actionUpdate.insert);\n                }\n            }\n        } finally {\n            // Set the rtc session running state since we cannot recover from here and the consumer user of the\n            // MatrixRTCSession class needs to manually rejoin.\n            this.running = false;\n        }\n\n        logger.debug(\"Leave MembershipManager ActionScheduler loop (no more actions)\");\n    }\n\n    public initiateJoin(): void {\n        this.wakeup?.({ replace: [{ ts: Date.now(), type: MembershipActionType.SendFirstDelayedEvent }] });\n    }\n    public initiateLeave(): void {\n        this.wakeup?.({ replace: [{ ts: Date.now(), type: MembershipActionType.SendScheduledDelayedLeaveEvent }] });\n    }\n}\n","/*\nCopyright 2025 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { EventType } from \"../@types/event.ts\";\nimport { UpdateDelayedEventAction } from \"../@types/requests.ts\";\nimport { type MatrixClient } from \"../client.ts\";\nimport { UnsupportedDelayedEventsEndpointError } from \"../errors.ts\";\nimport { ConnectionError, HTTPError, MatrixError } from \"../http-api/errors.ts\";\nimport { logger as rootLogger } from \"../logger.ts\";\nimport { type Room } from \"../models/room.ts\";\nimport { defer, type IDeferred } from \"../utils.ts\";\nimport { type CallMembership, DEFAULT_EXPIRE_DURATION, type SessionMembershipData } from \"./CallMembership.ts\";\nimport { type Focus } from \"./focus.ts\";\nimport { isLivekitFocusActive } from \"./LivekitFocus.ts\";\nimport { type MembershipConfig } from \"./MatrixRTCSession.ts\";\nimport { ActionScheduler, type ActionUpdate } from \"./NewMembershipManagerActionScheduler.ts\";\n\nconst logger = rootLogger.getChild(\"MatrixRTCSession\");\n\n/**\n * This interface defines what a MembershipManager uses and exposes.\n * This interface is what we use to write tests and allows changing the actual implementation\n * without breaking tests because of some internal method renaming.\n *\n * @internal\n */\nexport interface IMembershipManager {\n    /**\n     * If we are trying to join, or have successfully joined the session.\n     * It does not reflect if the room state is already configured to represent us being joined.\n     * It only means that the Manager should be trying to connect or to disconnect running.\n     * The Manager is still running right after isJoined becomes false to send the disconnect events.\n     * (A more accurate name would be `isActivated`)\n     * @returns true if we intend to be participating in the MatrixRTC session\n     */\n    isJoined(): boolean;\n    /**\n     * Start sending all necessary events to make this user participate in the RTC session.\n     * @param fociPreferred the list of preferred foci to use in the joined RTC membership event.\n     * @param fociActive the active focus to use in the joined RTC membership event.\n     * @throws can throw if it exceeds a configured maximum retry.\n     */\n    join(fociPreferred: Focus[], fociActive?: Focus, onError?: (error: unknown) => void): void;\n    /**\n     * Send all necessary events to make this user leave the RTC session.\n     * @param timeout the maximum duration in ms until the promise is forced to resolve.\n     * @returns It resolves with true in case the leave was sent successfully.\n     * It resolves with false in case we hit the timeout before sending successfully.\n     */\n    leave(timeout?: number): Promise<boolean>;\n    /**\n     * Call this if the MatrixRTC session members have changed.\n     */\n    onRTCSessionMemberUpdate(memberships: CallMembership[]): Promise<void>;\n    /**\n     * The used active focus in the currently joined session.\n     * @returns the used active focus in the currently joined session or undefined if not joined.\n     */\n    getActiveFocus(): Focus | undefined;\n}\n\n/* MembershipActionTypes:\n                           ▼\n                 ┌─────────────────────┐\n                 │SendFirstDelayedEvent│\n                 └─────────────────────┘\n                           │\n                           ▼\n                    ┌─────────────┐\n       ┌────────────│SendJoinEvent│────────────┐\n       │            └─────────────┘            │\n       │  ┌─────┐                  ┌──────┐    │    ┌──────┐\n       ▼  ▼     │                  │      ▼    ▼    ▼      │\n┌────────────┐  │                  │ ┌───────────────────┐ │\n│UpdateExpiry│  │                  │ │RestartDelayedEvent│ │\n└────────────┘  │                  │ └───────────────────┘ │\n          │     │                  │      │    │           │\n          └─────┘                  └──────┘    │           │\n                                               │           │\n                 ┌────────────────────┐        │           │\n                 │SendMainDelayedEvent│◄───────┘           │\n                 └───────────────────┬┘                    │\n                                     │                     │\n                                     └─────────────────────┘\n                     STOP ALL ABOVE\n                           ▼\n            ┌───────────────────────────────┐\n            │ SendScheduledDelayedLeaveEvent│\n            └───────────────────────────────┘\n                           │\n                           ▼\n                    ┌──────────────┐\n                    │SendLeaveEvent│\n                    └──────────────┘\n\n*/\n/**\n * The different types of actions the MembershipManager can take.\n * @internal\n */\nexport enum MembershipActionType {\n    SendFirstDelayedEvent = \"SendFirstDelayedEvent\",\n    //  -> MembershipActionType.SendJoinEvent if successful\n    //  -> DelayedLeaveActionType.SendFirstDelayedEvent on error, retry sending the first delayed event.\n    SendJoinEvent = \"SendJoinEvent\",\n    //  -> MembershipActionType.SendJoinEvent if we run into a rate limit and need to retry\n    //  -> MembershipActionType.Update if we successfully send the join event then schedule the expire event update\n    //  -> DelayedLeaveActionType.RestartDelayedEvent to recheck the delayed event\n    RestartDelayedEvent = \"RestartDelayedEvent\",\n    //  -> DelayedLeaveActionType.SendMainDelayedEvent on missing delay id but there is a rtc state event\n    //  -> DelayedLeaveActionType.SendFirstDelayedEvent on missing delay id and there is no state event\n    //  -> DelayedLeaveActionType.RestartDelayedEvent on success we schedule the next restart\n    UpdateExpiry = \"UpdateExpiry\",\n    //  -> MembershipActionType.Update if the timeout has passed so the next update is required.\n    SendMainDelayedEvent = \"SendMainDelayedEvent\",\n    //  -> DelayedLeaveActionType.RestartDelayedEvent on success start updating the delayed event\n    //  -> DelayedLeaveActionType.SendMainDelayedEvent on error try again\n    SendScheduledDelayedLeaveEvent = \"SendScheduledDelayedLeaveEvent\",\n    //  -> MembershipActionType.SendLeaveEvent on failiour (not found) we need to send the leave manually and cannot use the scheduled delayed event\n    //  -> DelayedLeaveActionType.SendScheduledDelayedLeaveEvent on error we try again.\n    SendLeaveEvent = \"SendLeaveEvent\",\n    // -> MembershipActionType.SendLeaveEvent\n}\n\n/**\n * @internal\n */\nexport interface ActionSchedulerState {\n    /** The delayId we got when successfully sending the delayed leave event.\n     * Gets set to undefined if the server claims it cannot find the delayed event anymore. */\n    delayId?: string;\n    /** Stores how often we have update the `expires` field.\n     * `expireUpdateIterations` * `membershipEventExpiryTimeout` resolves to the value the expires field should contain next */\n    expireUpdateIterations: number;\n    /** The time at which we send the first state event. The time the call started from the DAG point of view.\n     * This is used to compute the local sleep timestamps when to next update the member event with a new expires value. */\n    startTime: number;\n    /** The manager is in the state where its actually connected to the session. */\n    hasMemberStateEvent: boolean;\n    // There can be multiple retries at once so we need to store counters per action\n    // e.g. the send update membership and the restart delayed could be rate limited at the same time.\n    /** Retry counter for rate limits */\n    rateLimitRetries: Map<MembershipActionType, number>;\n    /** Retry counter for other errors */\n    networkErrorRetries: Map<MembershipActionType, number>;\n}\n\nenum Status {\n    Disconnected = \"Disconnected\",\n    Connecting = \"Connecting\",\n    ConnectingFailed = \"ConnectingFailed\",\n    Connected = \"Connected\",\n    Reconnecting = \"Reconnecting\",\n    Disconnecting = \"Disconnecting\",\n    Stuck = \"Stuck\",\n    Unknown = \"Unknown\",\n}\n\n/**\n * This class is responsible for sending all events relating to the own membership of a matrixRTC call.\n * It has the following tasks:\n *  - Send the users leave delayed event before sending the membership\n *  - Send the users membership if the state machine is started\n *  - Check if the delayed event was canceled due to sending the membership\n *  - update the delayed event (`restart`)\n *  - Update the state event every ~5h = `DEFAULT_EXPIRE_DURATION` (so it does not get treated as expired)\n *  - When the state machine is stopped:\n *   - Disconnect the member\n *   - Stop the timer for the delay refresh\n *   - Stop the timer for updating the state event\n */\nexport class MembershipManager implements IMembershipManager {\n    private activated = false;\n    public isJoined(): boolean {\n        return this.activated;\n    }\n\n    /**\n     * Puts the MembershipManager in a state where it tries to be joined.\n     * It will send delayed events and membership events\n     * @param fociPreferred\n     * @param focusActive\n     * @param onError This will be called once the membership manager encounters an unrecoverable error.\n     * This should bubble up the the frontend to communicate that the call does not work in the current environment.\n     */\n    public join(fociPreferred: Focus[], focusActive?: Focus, onError?: (error: unknown) => void): void {\n        if (this.scheduler.running) {\n            logger.error(\"MembershipManager is already running. Ignoring join request.\");\n            return;\n        }\n        this.fociPreferred = fociPreferred;\n        this.focusActive = focusActive;\n        this.leavePromiseDefer = undefined;\n        this.activated = true;\n\n        this.state = MembershipManager.defaultState;\n\n        this.scheduler\n            .startWithJoin()\n            .then(() => {\n                if (!this.scheduler.running) {\n                    this.leavePromiseDefer?.resolve(true);\n                    this.leavePromiseDefer = undefined;\n                }\n            })\n            .catch((e) => {\n                logger.error(\"MembershipManager stopped because: \", e);\n                onError?.(e);\n            })\n            // Should already be set to false when calling `leave` in non error cases.\n            .finally(() => (this.activated = false));\n    }\n\n    /**\n     * Leave from the call (Send an rtc session event with content: `{}`)\n     * @param timeout the maximum duration this promise will take to resolve\n     * @returns true if it managed to leave and false if the timeout condition happened.\n     */\n    public leave(timeout?: number): Promise<boolean> {\n        if (!this.scheduler.running) {\n            logger.warn(\"Called MembershipManager.leave() even though the MembershipManager is not running\");\n            return Promise.resolve(true);\n        }\n\n        // We use the promise to track if we already scheduled a leave event\n        // So we do not check scheduler.actions/scheduler.insertions\n        if (!this.leavePromiseDefer) {\n            // reset scheduled actions so we will not do any new actions.\n            this.leavePromiseDefer = defer<boolean>();\n            this.activated = false;\n            this.scheduler.initiateLeave();\n            if (timeout) setTimeout(() => this.leavePromiseDefer?.resolve(false), timeout);\n        }\n        return this.leavePromiseDefer.promise;\n    }\n    private leavePromiseDefer?: IDeferred<boolean>;\n\n    public async onRTCSessionMemberUpdate(memberships: CallMembership[]): Promise<void> {\n        const isMyMembership = (m: CallMembership): boolean =>\n            m.sender === this.client.getUserId() && m.deviceId === this.client.getDeviceId();\n\n        if (this.isJoined() && !memberships.some(isMyMembership)) {\n            // If one of these actions are scheduled or are getting inserted in the next iteration, we should already\n            // take care of our missing membership.\n            const sendingMembershipActions = [\n                MembershipActionType.SendFirstDelayedEvent,\n                MembershipActionType.SendJoinEvent,\n            ];\n            logger.warn(\"Missing own membership: force re-join\");\n            if (this.scheduler.actions.find((a) => sendingMembershipActions.includes(a.type as MembershipActionType))) {\n                logger.error(\n                    \"NewMembershipManger tried adding another `SendFirstDelayedEvent` actions even though we already have one in the Queue\\nActionQueueOnMemberUpdate:\",\n                    this.scheduler.actions,\n                );\n            } else {\n                // Only react to our own membership missing if we have not already scheduled sending a new membership DirectMembershipManagerAction.Join\n                this.state.hasMemberStateEvent = false;\n                this.scheduler.initiateJoin();\n            }\n        }\n        return Promise.resolve();\n    }\n\n    public getActiveFocus(): Focus | undefined {\n        if (this.focusActive) {\n            // A livekit active focus\n            if (isLivekitFocusActive(this.focusActive)) {\n                if (this.focusActive.focus_selection === \"oldest_membership\") {\n                    const oldestMembership = this.getOldestMembership();\n                    return oldestMembership?.getPreferredFoci()[0];\n                }\n            } else {\n                logger.warn(\"Unknown own ActiveFocus type. This makes it impossible to connect to an SFU.\");\n            }\n        } else {\n            // We do not understand the membership format (could be legacy). We default to oldestMembership\n            // Once there are other methods this is a hard error!\n            const oldestMembership = this.getOldestMembership();\n            return oldestMembership?.getPreferredFoci()[0];\n        }\n    }\n\n    /**\n     * @throws if the client does not return user or device id.\n     * @param joinConfig\n     * @param room\n     * @param client\n     * @param getOldestMembership\n     */\n    public constructor(\n        private joinConfig: MembershipConfig | undefined,\n        private room: Pick<Room, \"getLiveTimeline\" | \"roomId\" | \"getVersion\">,\n        private client: Pick<\n            MatrixClient,\n            | \"getUserId\"\n            | \"getDeviceId\"\n            | \"sendStateEvent\"\n            | \"_unstable_sendDelayedStateEvent\"\n            | \"_unstable_updateDelayedEvent\"\n        >,\n        private getOldestMembership: () => CallMembership | undefined,\n    ) {\n        const [userId, deviceId] = [this.client.getUserId(), this.client.getDeviceId()];\n        if (userId === null) throw Error(\"Missing userId in client\");\n        if (deviceId === null) throw Error(\"Missing deviceId in client\");\n        this.deviceId = deviceId;\n        this.stateKey = this.makeMembershipStateKey(userId, deviceId);\n        this.state = MembershipManager.defaultState;\n    }\n\n    // MembershipManager mutable state.\n    private state: ActionSchedulerState;\n    private static get defaultState(): ActionSchedulerState {\n        return {\n            hasMemberStateEvent: false,\n            delayId: undefined,\n\n            startTime: 0,\n            rateLimitRetries: new Map(),\n            networkErrorRetries: new Map(),\n            expireUpdateIterations: 1,\n        };\n    }\n    // Membership Event static parameters:\n    private deviceId: string;\n    private stateKey: string;\n    private fociPreferred?: Focus[];\n    private focusActive?: Focus;\n\n    // Config:\n    private membershipServerSideExpiryTimeoutOverride?: number;\n\n    private get callMemberEventRetryDelayMinimum(): number {\n        return this.joinConfig?.callMemberEventRetryDelayMinimum ?? 3_000;\n    }\n    private get membershipEventExpiryTimeout(): number {\n        return this.joinConfig?.membershipExpiryTimeout ?? DEFAULT_EXPIRE_DURATION;\n    }\n    private get membershipEventExpiryTimeoutHeadroom(): number {\n        return this.joinConfig?.membershipExpiryTimeoutHeadroom ?? 5_000;\n    }\n    private computeNextExpiryActionTs(iteration: number): number {\n        return (\n            this.state.startTime +\n            this.membershipEventExpiryTimeout * iteration -\n            this.membershipEventExpiryTimeoutHeadroom\n        );\n    }\n    private get membershipServerSideExpiryTimeout(): number {\n        return (\n            this.membershipServerSideExpiryTimeoutOverride ??\n            this.joinConfig?.membershipServerSideExpiryTimeout ??\n            8_000\n        );\n    }\n    private get membershipKeepAlivePeriod(): number {\n        return this.joinConfig?.membershipKeepAlivePeriod ?? 5_000;\n    }\n    private get maximumRateLimitRetryCount(): number {\n        return this.joinConfig?.maximumRateLimitRetryCount ?? 10;\n    }\n    private get maximumNetworkErrorRetryCount(): number {\n        return this.joinConfig?.maximumNetworkErrorRetryCount ?? 10;\n    }\n\n    // Scheduler:\n    private oldStatus?: Status;\n    private scheduler = new ActionScheduler((type): Promise<ActionUpdate> => {\n        if (this.oldStatus) {\n            //  we put this at the beginning of the actions scheduler loop handle callback since it is a loop this\n            // is equivalent to running it at the end of the loop. (just after applying the status/action list changes)\n            logger.debug(`MembershipManager applied action changes. Status: ${this.oldStatus} -> ${this.status}`);\n        }\n        this.oldStatus = this.status;\n        logger.debug(`MembershipManager before processing action. status=${this.oldStatus}`);\n        return this.membershipLoopHandler(type);\n    });\n\n    // LOOP HANDLER:\n    private async membershipLoopHandler(type: MembershipActionType): Promise<ActionUpdate> {\n        this.oldStatus = this.status;\n        switch (type) {\n            case MembershipActionType.SendFirstDelayedEvent: {\n                // Before we start we check if we come from a state where we have a delay id.\n                if (!this.state.delayId) {\n                    return this.sendFirstDelayedLeaveEvent(); // Normal case without any previous delayed id.\n                } else {\n                    // This can happen if someone else (or another client) removes our own membership event.\n                    // It will trigger `onRTCSessionMemberUpdate` queue `MembershipActionType.SendFirstDelayedEvent`.\n                    // We might still have our delayed event from the previous participation and dependent on the server this might not\n                    // get automatically removed if the state changes. Hence It would remove our membership unexpectedly shortly after the rejoin.\n                    //\n                    // In this block we will try to cancel this delayed event before setting up a new one.\n\n                    return this.cancelKnownDelayIdBeforeSendFirstDelayedEvent(this.state.delayId);\n                }\n            }\n            case MembershipActionType.RestartDelayedEvent: {\n                if (!this.state.delayId) {\n                    // Delay id got reset. This action was used to check if the hs canceled the delayed event when the join state got sent.\n                    return createInsertActionUpdate(\n                        this.state.hasMemberStateEvent\n                            ? MembershipActionType.SendMainDelayedEvent\n                            : MembershipActionType.SendFirstDelayedEvent,\n                    );\n                }\n                return this.restartDelayedEvent(this.state.delayId);\n            }\n            case MembershipActionType.SendMainDelayedEvent: {\n                return this.sendMainDelayedEvent();\n            }\n            case MembershipActionType.SendScheduledDelayedLeaveEvent: {\n                // We are already good\n                if (!this.state.hasMemberStateEvent) {\n                    return { replace: [] };\n                }\n                if (this.state.delayId) {\n                    return this.sendScheduledDelayedLeaveEventOrFallbackToSendLeaveEvent(this.state.delayId);\n                } else {\n                    return createInsertActionUpdate(MembershipActionType.SendLeaveEvent);\n                }\n            }\n            case MembershipActionType.SendJoinEvent: {\n                return this.sendJoinEvent();\n            }\n            case MembershipActionType.UpdateExpiry: {\n                return this.updateExpiryOnJoinedEvent();\n            }\n            case MembershipActionType.SendLeaveEvent: {\n                // We are good already\n                if (!this.state.hasMemberStateEvent) {\n                    return { replace: [] };\n                }\n                // This is only a fallback in case we do not have working delayed events support.\n                // first we should try to just send the scheduled leave event\n                return this.sendFallbackLeaveEvent();\n            }\n        }\n    }\n\n    // HANDLERS (used in the membershipLoopHandler)\n    private async sendFirstDelayedLeaveEvent(): Promise<ActionUpdate> {\n        return await this.client\n            ._unstable_sendDelayedStateEvent(\n                this.room.roomId,\n                {\n                    delay: this.membershipServerSideExpiryTimeout,\n                },\n                EventType.GroupCallMemberPrefix,\n                {}, // leave event\n                this.stateKey,\n            )\n            .then((response) => {\n                // On success we reset retries and set delayId.\n                this.state.rateLimitRetries.set(MembershipActionType.SendFirstDelayedEvent, 0);\n                this.state.networkErrorRetries.set(MembershipActionType.SendFirstDelayedEvent, 0);\n                this.state.delayId = response.delay_id;\n                return createInsertActionUpdate(MembershipActionType.SendJoinEvent);\n            })\n            .catch((e) => {\n                const repeatActionType = MembershipActionType.SendFirstDelayedEvent;\n                if (this.manageMaxDelayExceededSituation(e)) {\n                    return createInsertActionUpdate(repeatActionType);\n                }\n                const update = this.actionUpdateFromErrors(e, repeatActionType, \"sendDelayedStateEvent\");\n                if (update) return update;\n\n                // log and fall through\n                if (this.isUnsupportedDelayedEndpoint(e)) {\n                    logger.info(\"Not using delayed event because the endpoint is not supported\");\n                } else {\n                    logger.info(\"Not using delayed event because: \" + e);\n                }\n                // On any other error we fall back to not using delayed events and send the join state event immediately\n                return createInsertActionUpdate(MembershipActionType.SendJoinEvent);\n            });\n    }\n\n    private async cancelKnownDelayIdBeforeSendFirstDelayedEvent(delayId: string): Promise<ActionUpdate> {\n        // Remove all running updates and restarts\n        return await this.client\n            ._unstable_updateDelayedEvent(delayId, UpdateDelayedEventAction.Cancel)\n            .then(() => {\n                this.state.delayId = undefined;\n                this.resetRateLimitCounter(MembershipActionType.SendFirstDelayedEvent);\n                return createReplaceActionUpdate(MembershipActionType.SendFirstDelayedEvent);\n            })\n            .catch((e) => {\n                const repeatActionType = MembershipActionType.SendFirstDelayedEvent;\n                const update = this.actionUpdateFromErrors(e, repeatActionType, \"updateDelayedEvent\");\n                if (update) return update;\n\n                if (this.isNotFoundError(e)) {\n                    // If we get a M_NOT_FOUND we know that the delayed event got already removed.\n                    // This means we are good and can set it to undefined and run this again.\n                    this.state.delayId = undefined;\n                    return createReplaceActionUpdate(repeatActionType);\n                }\n                if (this.isUnsupportedDelayedEndpoint(e)) {\n                    return createReplaceActionUpdate(MembershipActionType.SendJoinEvent);\n                }\n                // We do not just ignore and log this error since we would also need to reset the delayId.\n\n                // This becomes an unrecoverable error case since something is significantly off if we don't hit any of the above cases\n                // when state.delayId !== undefined\n                // We do not just ignore and log this error since we would also need to reset the delayId.\n                // It is cleaner if we, the frontend, rejoins instead of resetting the delayId here and behaving like in the success case.\n                throw Error(\n                    \"We failed to cancel a delayed event where we already had a delay id with an error we cannot automatically handle\",\n                );\n            });\n    }\n\n    private async restartDelayedEvent(delayId: string): Promise<ActionUpdate> {\n        return await this.client\n            ._unstable_updateDelayedEvent(delayId, UpdateDelayedEventAction.Restart)\n            .then(() => {\n                this.resetRateLimitCounter(MembershipActionType.RestartDelayedEvent);\n                return createInsertActionUpdate(\n                    MembershipActionType.RestartDelayedEvent,\n                    this.membershipKeepAlivePeriod,\n                );\n            })\n            .catch((e) => {\n                const repeatActionType = MembershipActionType.RestartDelayedEvent;\n                if (this.isNotFoundError(e)) {\n                    this.state.delayId = undefined;\n                    return createInsertActionUpdate(MembershipActionType.SendMainDelayedEvent);\n                }\n                // If the HS does not support delayed events we wont reschedule.\n                if (this.isUnsupportedDelayedEndpoint(e)) return {};\n\n                // TODO this also needs a test: get rate limit while checking id delayed event is scheduled\n                const update = this.actionUpdateFromErrors(e, repeatActionType, \"updateDelayedEvent\");\n                if (update) return update;\n\n                // In other error cases we have no idea what is happening\n                throw Error(\"Could not restart delayed event, even though delayed events are supported. \" + e);\n            });\n    }\n\n    private async sendMainDelayedEvent(): Promise<ActionUpdate> {\n        return await this.client\n            ._unstable_sendDelayedStateEvent(\n                this.room.roomId,\n                {\n                    delay: this.membershipServerSideExpiryTimeout,\n                },\n                EventType.GroupCallMemberPrefix,\n                {}, // leave event\n                this.stateKey,\n            )\n            .then((response) => {\n                this.state.delayId = response.delay_id;\n                this.resetRateLimitCounter(MembershipActionType.SendMainDelayedEvent);\n                return createInsertActionUpdate(\n                    MembershipActionType.RestartDelayedEvent,\n                    this.membershipKeepAlivePeriod,\n                );\n            })\n            .catch((e) => {\n                const repeatActionType = MembershipActionType.SendMainDelayedEvent;\n                // Don't do any other delayed event work if its not supported.\n                if (this.isUnsupportedDelayedEndpoint(e)) return {};\n\n                if (this.manageMaxDelayExceededSituation(e)) {\n                    return createInsertActionUpdate(repeatActionType);\n                }\n                const update = this.actionUpdateFromErrors(e, repeatActionType, \"updateDelayedEvent\");\n                if (update) return update;\n\n                throw Error(\"Could not send delayed event, even though delayed events are supported. \" + e);\n            });\n    }\n\n    private async sendScheduledDelayedLeaveEventOrFallbackToSendLeaveEvent(delayId: string): Promise<ActionUpdate> {\n        return await this.client\n            ._unstable_updateDelayedEvent(delayId, UpdateDelayedEventAction.Send)\n            .then(() => {\n                this.state.hasMemberStateEvent = false;\n                this.resetRateLimitCounter(MembershipActionType.SendScheduledDelayedLeaveEvent);\n\n                return { replace: [] };\n            })\n            .catch((e) => {\n                const repeatActionType = MembershipActionType.SendLeaveEvent;\n                if (this.isUnsupportedDelayedEndpoint(e)) return {};\n                if (this.isNotFoundError(e)) {\n                    this.state.delayId = undefined;\n                    return createInsertActionUpdate(repeatActionType);\n                }\n                const update = this.actionUpdateFromErrors(e, repeatActionType, \"updateDelayedEvent\");\n                if (update) return update;\n\n                // On any other error we fall back to SendLeaveEvent (this includes hard errors from rate limiting)\n                logger.warn(\n                    \"Encountered unexpected error during SendScheduledDelayedLeaveEvent. Falling back to SendLeaveEvent\",\n                    e,\n                );\n                return createInsertActionUpdate(repeatActionType);\n            });\n    }\n\n    private async sendJoinEvent(): Promise<ActionUpdate> {\n        return await this.client\n            .sendStateEvent(\n                this.room.roomId,\n                EventType.GroupCallMemberPrefix,\n                this.makeMyMembership(this.membershipEventExpiryTimeout),\n                this.stateKey,\n            )\n            .then(() => {\n                this.state.startTime = Date.now();\n                // The next update should already use twice the membershipEventExpiryTimeout\n                this.state.expireUpdateIterations = 1;\n                this.state.hasMemberStateEvent = true;\n                this.resetRateLimitCounter(MembershipActionType.SendJoinEvent);\n                return {\n                    insert: [\n                        { ts: Date.now(), type: MembershipActionType.RestartDelayedEvent },\n                        {\n                            ts: this.computeNextExpiryActionTs(this.state.expireUpdateIterations),\n                            type: MembershipActionType.UpdateExpiry,\n                        },\n                    ],\n                };\n            })\n            .catch((e) => {\n                const update = this.actionUpdateFromErrors(e, MembershipActionType.SendJoinEvent, \"sendStateEvent\");\n                if (update) return update;\n                throw e;\n            });\n    }\n\n    private async updateExpiryOnJoinedEvent(): Promise<ActionUpdate> {\n        const nextExpireUpdateIteration = this.state.expireUpdateIterations + 1;\n        return await this.client\n            .sendStateEvent(\n                this.room.roomId,\n                EventType.GroupCallMemberPrefix,\n                this.makeMyMembership(this.membershipEventExpiryTimeout * nextExpireUpdateIteration),\n                this.stateKey,\n            )\n            .then(() => {\n                // Success, we reset retries and schedule update.\n                this.resetRateLimitCounter(MembershipActionType.UpdateExpiry);\n                this.state.expireUpdateIterations = nextExpireUpdateIteration;\n                return {\n                    insert: [\n                        {\n                            ts: this.computeNextExpiryActionTs(nextExpireUpdateIteration),\n                            type: MembershipActionType.UpdateExpiry,\n                        },\n                    ],\n                };\n            })\n            .catch((e) => {\n                const update = this.actionUpdateFromErrors(e, MembershipActionType.UpdateExpiry, \"sendStateEvent\");\n                if (update) return update;\n\n                throw e;\n            });\n    }\n    private async sendFallbackLeaveEvent(): Promise<ActionUpdate> {\n        return await this.client\n            .sendStateEvent(this.room.roomId, EventType.GroupCallMemberPrefix, {}, this.stateKey)\n            .then(() => {\n                this.resetRateLimitCounter(MembershipActionType.SendLeaveEvent);\n                this.state.hasMemberStateEvent = false;\n                return { replace: [] };\n            })\n            .catch((e) => {\n                const update = this.actionUpdateFromErrors(e, MembershipActionType.SendLeaveEvent, \"sendStateEvent\");\n                if (update) return update;\n                throw e;\n            });\n    }\n\n    // HELPERS\n    private makeMembershipStateKey(localUserId: string, localDeviceId: string): string {\n        const stateKey = `${localUserId}_${localDeviceId}`;\n        if (/^org\\.matrix\\.msc(3757|3779)\\b/.exec(this.room.getVersion())) {\n            return stateKey;\n        } else {\n            return `_${stateKey}`;\n        }\n    }\n\n    /**\n     * Constructs our own membership\n     */\n    private makeMyMembership(expires: number): SessionMembershipData {\n        return {\n            call_id: \"\",\n            scope: \"m.room\",\n            application: \"m.call\",\n            device_id: this.deviceId,\n            expires,\n            focus_active: { type: \"livekit\", focus_selection: \"oldest_membership\" },\n            foci_preferred: this.fociPreferred ?? [],\n        };\n    }\n\n    // Error checks and handlers\n\n    /**\n     * Check if its a NOT_FOUND error\n     * @param error the error causing this handler check/execution\n     * @returns true if its a not found error\n     */\n    private isNotFoundError(error: unknown): boolean {\n        return error instanceof MatrixError && error.errcode === \"M_NOT_FOUND\";\n    }\n\n    /**\n     * Check if this is a DelayExceeded timeout and update the TimeoutOverride for the next try\n     * @param error the error causing this handler check/execution\n     * @returns true if its a delay exceeded error and we updated the local TimeoutOverride\n     */\n    private manageMaxDelayExceededSituation(error: unknown): boolean {\n        if (\n            error instanceof MatrixError &&\n            error.errcode === \"M_UNKNOWN\" &&\n            error.data[\"org.matrix.msc4140.errcode\"] === \"M_MAX_DELAY_EXCEEDED\"\n        ) {\n            const maxDelayAllowed = error.data[\"org.matrix.msc4140.max_delay\"];\n            if (typeof maxDelayAllowed === \"number\" && this.membershipServerSideExpiryTimeout > maxDelayAllowed) {\n                this.membershipServerSideExpiryTimeoutOverride = maxDelayAllowed;\n            }\n            logger.warn(\"Retry sending delayed disconnection event due to server timeout limitations:\", error);\n            return true;\n        }\n        return false;\n    }\n\n    private actionUpdateFromErrors(\n        error: unknown,\n        type: MembershipActionType,\n        method: string,\n    ): ActionUpdate | undefined {\n        const updateLimit = this.actionUpdateFromRateLimitError(error, method, type);\n        if (updateLimit) return updateLimit;\n        const updateNetwork = this.actionUpdateFromNetworkErrorRetry(error, type);\n        if (updateNetwork) return updateNetwork;\n    }\n    /**\n     * Check if we have a rate limit error and schedule the same action again if we dont exceed the rate limit retry count yet.\n     * @param error the error causing this handler check/execution\n     * @param method the method used for the throw message\n     * @param type which MembershipActionType we reschedule because of a rate limit.\n     * @throws If it is a rate limit error and the retry count got exceeded\n     * @returns Returns true if we handled the error by rescheduling the correct next action.\n     * Returns false if it is not a network error.\n     */\n    private actionUpdateFromRateLimitError(\n        error: unknown,\n        method: string,\n        type: MembershipActionType,\n    ): ActionUpdate | undefined {\n        // \"Is rate limit\"-boundary\n        if (!((error instanceof HTTPError || error instanceof MatrixError) && error.isRateLimitError())) {\n            return undefined;\n        }\n\n        // retry boundary\n        const rateLimitRetries = this.state.rateLimitRetries.get(type) ?? 0;\n        if (rateLimitRetries < this.maximumRateLimitRetryCount) {\n            let resendDelay: number;\n            const defaultMs = 5000;\n            try {\n                resendDelay = error.getRetryAfterMs() ?? defaultMs;\n                logger.info(`Rate limited by server, retrying in ${resendDelay}ms`);\n            } catch (e) {\n                logger.warn(\n                    `Error while retrieving a rate-limit retry delay, retrying after default delay of ${defaultMs}`,\n                    e,\n                );\n                resendDelay = defaultMs;\n            }\n            this.state.rateLimitRetries.set(type, rateLimitRetries + 1);\n            return createInsertActionUpdate(type, resendDelay);\n        }\n\n        throw Error(\"Exceeded maximum retries for \" + type + \" attempts (client.\" + method + \"): \" + (error as Error));\n    }\n\n    /**\n     * FIXME Don't Check the error and retry the same MembershipAction again in the configured time and for the configured retry count.\n     * @param error the error causing this handler check/execution\n     * @param type the action type that we need to repeat because of the error\n     * @throws If it is a network error and the retry count got exceeded\n     * @returns\n     * Returns true if we handled the error by rescheduling the correct next action.\n     * Returns false if it is not a network error.\n     */\n    private actionUpdateFromNetworkErrorRetry(error: unknown, type: MembershipActionType): ActionUpdate | undefined {\n        // \"Is a network error\"-boundary\n        const retries = this.state.networkErrorRetries.get(type) ?? 0;\n        const retryDurationString = this.callMemberEventRetryDelayMinimum / 1000 + \"s\";\n        const retryCounterString = \"(\" + retries + \"/\" + this.maximumNetworkErrorRetryCount + \")\";\n        if (error instanceof Error && error.name === \"AbortError\") {\n            logger.warn(\n                \"Network local timeout error while sending event, retrying in \" +\n                    retryDurationString +\n                    \" \" +\n                    retryCounterString,\n                error,\n            );\n        } else if (error instanceof Error && error.message.includes(\"updating delayed event\")) {\n            // TODO: We do not want error message matching here but instead the error should be a typed HTTPError\n            // and be handled below automatically (the same as in the SPA case).\n            //\n            // The error originates because of https://github.com/matrix-org/matrix-widget-api/blob/5d81d4a26ff69e4bd3ddc79a884c9527999fb2f4/src/ClientWidgetApi.ts#L698-L701\n            // uses `e` instance of HttpError (and not MatrixError)\n            // The element web widget driver (only checks for MatrixError) is then failing to process (`processError`) it as a typed error: https://github.com/element-hq/element-web/blob/471712cbf06a067e5499bd5d2d7a75f693d9a12d/src/stores/widgets/StopGapWidgetDriver.ts#L711-L715\n            // So it will not call: `error.asWidgetApiErrorData()` which is also missing for `HttpError`\n            //\n            // A proper fix would be to either find a place to convert the `HttpError` into a `MatrixError` and the `processError`\n            // method to handle it as expected or to adjust `processError` to also process `HttpError`'s.\n            logger.warn(\n                \"delayed event update timeout error, retrying in \" + retryDurationString + \" \" + retryCounterString,\n                error,\n            );\n        } else if (error instanceof ConnectionError) {\n            logger.warn(\n                \"Network connection error while sending event, retrying in \" +\n                    retryDurationString +\n                    \" \" +\n                    retryCounterString,\n                error,\n            );\n        } else if (\n            (error instanceof HTTPError || error instanceof MatrixError) &&\n            typeof error.httpStatus === \"number\" &&\n            error.httpStatus >= 500 &&\n            error.httpStatus < 600\n        ) {\n            logger.warn(\n                \"Server error while sending event, retrying in \" + retryDurationString + \" \" + retryCounterString,\n                error,\n            );\n        } else {\n            return undefined;\n        }\n\n        // retry boundary\n        if (retries < this.maximumNetworkErrorRetryCount) {\n            this.state.networkErrorRetries.set(type, retries + 1);\n            return createInsertActionUpdate(type, this.callMemberEventRetryDelayMinimum);\n        }\n\n        // Failure\n        throw Error(\n            \"Reached maximum (\" + this.maximumNetworkErrorRetryCount + \") retries cause by: \" + (error as Error),\n        );\n    }\n\n    /**\n     * Check if its an UnsupportedDelayedEventsEndpointError and which implies that we cannot do any delayed event logic\n     * @param error The error to check\n     * @returns true it its an UnsupportedDelayedEventsEndpointError\n     */\n    private isUnsupportedDelayedEndpoint(error: unknown): boolean {\n        return error instanceof UnsupportedDelayedEventsEndpointError;\n    }\n\n    private resetRateLimitCounter(type: MembershipActionType): void {\n        this.state.rateLimitRetries.set(type, 0);\n        this.state.networkErrorRetries.set(type, 0);\n    }\n\n    public get status(): Status {\n        const actions = this.scheduler.actions;\n        if (actions.length === 1) {\n            const { type } = actions[0];\n            switch (type) {\n                case MembershipActionType.SendFirstDelayedEvent:\n                case MembershipActionType.SendJoinEvent:\n                case MembershipActionType.SendMainDelayedEvent:\n                    return Status.Connecting;\n                case MembershipActionType.UpdateExpiry: // where no delayed events\n                    return Status.Connected;\n                case MembershipActionType.SendScheduledDelayedLeaveEvent:\n                case MembershipActionType.SendLeaveEvent:\n                    return Status.Disconnecting;\n                default:\n                // pass through as not expected\n            }\n        } else if (actions.length === 2) {\n            const types = actions.map((a) => a.type);\n            // normal state for connected with delayed events\n            if (\n                (types.includes(MembershipActionType.RestartDelayedEvent) ||\n                    types.includes(MembershipActionType.SendMainDelayedEvent)) &&\n                types.includes(MembershipActionType.UpdateExpiry)\n            ) {\n                return Status.Connected;\n            }\n        } else if (actions.length === 3) {\n            const types = actions.map((a) => a.type);\n            // It is a correct connected state if we already schedule the next Restart but have not yet cleaned up\n            // the current restart.\n            if (\n                types.filter((t) => t === MembershipActionType.RestartDelayedEvent).length === 2 &&\n                types.includes(MembershipActionType.UpdateExpiry)\n            ) {\n                return Status.Connected;\n            }\n        }\n\n        if (!this.scheduler.running) {\n            return Status.Disconnected;\n        }\n\n        logger.error(\"MembershipManager has an unknown state. Actions: \", actions);\n        return Status.Unknown;\n    }\n}\n\nfunction createInsertActionUpdate(type: MembershipActionType, offset?: number): ActionUpdate {\n    return {\n        insert: [{ ts: Date.now() + (offset ?? 0), type }],\n    };\n}\n\nfunction createReplaceActionUpdate(type: MembershipActionType, offset?: number): ActionUpdate {\n    return {\n        replace: [{ ts: Date.now() + (offset ?? 0), type }],\n    };\n}\n","import { type MatrixClient } from \"../client.ts\";\nimport { logger as rootLogger } from \"../logger.ts\";\nimport { type MatrixEvent } from \"../models/event.ts\";\nimport { type Room } from \"../models/room.ts\";\nimport { type EncryptionConfig } from \"./MatrixRTCSession.ts\";\nimport { secureRandomBase64Url } from \"../randomstring.ts\";\nimport { type EncryptionKeysEventContent } from \"./types.ts\";\nimport { decodeBase64, encodeUnpaddedBase64 } from \"../base64.ts\";\nimport { type MatrixError, safeGetRetryAfterMs } from \"../http-api/errors.ts\";\nimport { type CallMembership } from \"./CallMembership.ts\";\nimport { EventType } from \"../@types/event.ts\";\nconst logger = rootLogger.getChild(\"MatrixRTCSession\");\n\n/**\n * A type collecting call encryption statistics for a session.\n */\nexport type Statistics = {\n    counters: {\n        /**\n         * The number of times we have sent a room event containing encryption keys.\n         */\n        roomEventEncryptionKeysSent: number;\n        /**\n         * The number of times we have received a room event containing encryption keys.\n         */\n        roomEventEncryptionKeysReceived: number;\n    };\n    totals: {\n        /**\n         * The total age (in milliseconds) of all room events containing encryption keys that we have received.\n         * We track the total age so that we can later calculate the average age of all keys received.\n         */\n        roomEventEncryptionKeysReceivedTotalAge: number;\n    };\n};\n\n/**\n * This interface is for testing and for making it possible to interchange the encryption manager.\n * @internal\n */\nexport interface IEncryptionManager {\n    join(joinConfig: EncryptionConfig | undefined): void;\n    leave(): void;\n    onMembershipsUpdate(oldMemberships: CallMembership[]): void;\n    /**\n     * Process `m.call.encryption_keys` events to track the encryption keys for call participants.\n     * This should be called each time the relevant event is received from a room timeline.\n     * If the event is malformed then it will be logged and ignored.\n     *\n     * @param event the event to process\n     */\n    onCallEncryptionEventReceived(event: MatrixEvent): void;\n    getEncryptionKeys(): Map<string, Array<{ key: Uint8Array; timestamp: number }>>;\n    statistics: Statistics;\n}\n\n/**\n * This class implements the IEncryptionManager interface,\n * and takes care of managing the encryption keys of all rtc members:\n *  - generate new keys for the local user and send them to other participants\n *  - track all keys of all other members and update livekit.\n *\n * @internal\n */\nexport class EncryptionManager implements IEncryptionManager {\n    private manageMediaKeys = false;\n    private keysEventUpdateTimeout?: ReturnType<typeof setTimeout>;\n    private makeNewKeyTimeout?: ReturnType<typeof setTimeout>;\n    private setNewKeyTimeouts = new Set<ReturnType<typeof setTimeout>>();\n\n    private get updateEncryptionKeyThrottle(): number {\n        return this.joinConfig?.updateEncryptionKeyThrottle ?? 3_000;\n    }\n    private get makeKeyDelay(): number {\n        return this.joinConfig?.makeKeyDelay ?? 3_000;\n    }\n    private get useKeyDelay(): number {\n        return this.joinConfig?.useKeyDelay ?? 5_000;\n    }\n\n    private encryptionKeys = new Map<string, Array<{ key: Uint8Array; timestamp: number }>>();\n    private lastEncryptionKeyUpdateRequest?: number;\n\n    // We use this to store the last membership fingerprints we saw, so we can proactively re-send encryption keys\n    // if it looks like a membership has been updated.\n    private lastMembershipFingerprints: Set<string> | undefined;\n\n    private currentEncryptionKeyIndex = -1;\n\n    public statistics: Statistics = {\n        counters: {\n            roomEventEncryptionKeysSent: 0,\n            roomEventEncryptionKeysReceived: 0,\n        },\n        totals: {\n            roomEventEncryptionKeysReceivedTotalAge: 0,\n        },\n    };\n    private joinConfig: EncryptionConfig | undefined;\n\n    public constructor(\n        private client: Pick<MatrixClient, \"sendEvent\" | \"getDeviceId\" | \"getUserId\" | \"cancelPendingEvent\">,\n        private room: Pick<Room, \"roomId\">,\n        private getMemberships: () => CallMembership[],\n        private onEncryptionKeysChanged: (\n            keyBin: Uint8Array<ArrayBufferLike>,\n            encryptionKeyIndex: number,\n            participantId: string,\n        ) => void,\n    ) {}\n\n    public getEncryptionKeys(): Map<string, Array<{ key: Uint8Array; timestamp: number }>> {\n        return this.encryptionKeys;\n    }\n    private joined = false;\n    public join(joinConfig: EncryptionConfig): void {\n        this.joinConfig = joinConfig;\n        this.joined = true;\n        this.manageMediaKeys = this.joinConfig?.manageMediaKeys ?? this.manageMediaKeys;\n        if (this.joinConfig?.manageMediaKeys) {\n            this.makeNewSenderKey();\n            this.requestSendCurrentKey();\n        }\n    }\n\n    public leave(): void {\n        const userId = this.client.getUserId();\n        const deviceId = this.client.getDeviceId();\n\n        if (!userId) throw new Error(\"No userId\");\n        if (!deviceId) throw new Error(\"No deviceId\");\n        // clear our encryption keys as we're done with them now (we'll\n        // make new keys if we rejoin). We leave keys for other participants\n        // as they may still be using the same ones.\n        this.encryptionKeys.set(getParticipantId(userId, deviceId), []);\n\n        if (this.makeNewKeyTimeout !== undefined) {\n            clearTimeout(this.makeNewKeyTimeout);\n            this.makeNewKeyTimeout = undefined;\n        }\n        for (const t of this.setNewKeyTimeouts) {\n            clearTimeout(t);\n        }\n        this.setNewKeyTimeouts.clear();\n\n        this.manageMediaKeys = false;\n        this.joined = false;\n    }\n    // TODO deduplicate this method. It also is in MatrixRTCSession.\n    private isMyMembership = (m: CallMembership): boolean =>\n        m.sender === this.client.getUserId() && m.deviceId === this.client.getDeviceId();\n\n    public onMembershipsUpdate(oldMemberships: CallMembership[]): void {\n        if (this.manageMediaKeys && this.joined) {\n            const oldMembershipIds = new Set(\n                oldMemberships.filter((m) => !this.isMyMembership(m)).map(getParticipantIdFromMembership),\n            );\n            const newMembershipIds = new Set(\n                this.getMemberships()\n                    .filter((m) => !this.isMyMembership(m))\n                    .map(getParticipantIdFromMembership),\n            );\n\n            // We can use https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/symmetricDifference\n            // for this once available\n            const anyLeft = Array.from(oldMembershipIds).some((x) => !newMembershipIds.has(x));\n            const anyJoined = Array.from(newMembershipIds).some((x) => !oldMembershipIds.has(x));\n\n            const oldFingerprints = this.lastMembershipFingerprints;\n            // always store the fingerprints of these latest memberships\n            this.storeLastMembershipFingerprints();\n\n            if (anyLeft) {\n                if (this.makeNewKeyTimeout) {\n                    // existing rotation in progress, so let it complete\n                } else {\n                    logger.debug(`Member(s) have left: queueing sender key rotation`);\n                    this.makeNewKeyTimeout = setTimeout(this.onRotateKeyTimeout, this.makeKeyDelay);\n                }\n            } else if (anyJoined) {\n                logger.debug(`New member(s) have joined: re-sending keys`);\n                this.requestSendCurrentKey();\n            } else if (oldFingerprints) {\n                // does it look like any of the members have updated their memberships?\n                const newFingerprints = this.lastMembershipFingerprints!;\n\n                // We can use https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/symmetricDifference\n                // for this once available\n                const candidateUpdates =\n                    Array.from(oldFingerprints).some((x) => !newFingerprints.has(x)) ||\n                    Array.from(newFingerprints).some((x) => !oldFingerprints.has(x));\n                if (candidateUpdates) {\n                    logger.debug(`Member(s) have updated/reconnected: re-sending keys to everyone`);\n                    this.requestSendCurrentKey();\n                }\n            }\n        }\n    }\n\n    /**\n     * Generate a new sender key and add it at the next available index\n     * @param delayBeforeUse - If true, wait for a short period before setting the key for the\n     *                         media encryptor to use. If false, set the key immediately.\n     * @returns The index of the new key\n     */\n    private makeNewSenderKey(delayBeforeUse = false): number {\n        const userId = this.client.getUserId();\n        const deviceId = this.client.getDeviceId();\n\n        if (!userId) throw new Error(\"No userId\");\n        if (!deviceId) throw new Error(\"No deviceId\");\n\n        const encryptionKey = secureRandomBase64Url(16);\n        const encryptionKeyIndex = this.getNewEncryptionKeyIndex();\n        logger.info(\"Generated new key at index \" + encryptionKeyIndex);\n        this.setEncryptionKey(userId, deviceId, encryptionKeyIndex, encryptionKey, Date.now(), delayBeforeUse);\n        return encryptionKeyIndex;\n    }\n\n    /**\n     * Requests that we resend our current keys to the room. May send a keys event immediately\n     * or queue for alter if one has already been sent recently.\n     */\n    private requestSendCurrentKey(): void {\n        if (!this.manageMediaKeys) return;\n\n        if (\n            this.lastEncryptionKeyUpdateRequest &&\n            this.lastEncryptionKeyUpdateRequest + this.updateEncryptionKeyThrottle > Date.now()\n        ) {\n            logger.info(\"Last encryption key event sent too recently: postponing\");\n            if (this.keysEventUpdateTimeout === undefined) {\n                this.keysEventUpdateTimeout = setTimeout(\n                    () => void this.sendEncryptionKeysEvent(),\n                    this.updateEncryptionKeyThrottle,\n                );\n            }\n            return;\n        }\n\n        void this.sendEncryptionKeysEvent();\n    }\n\n    /**\n     * Get the known encryption keys for a given participant device.\n     *\n     * @param userId the user ID of the participant\n     * @param deviceId the device ID of the participant\n     * @returns The encryption keys for the given participant, or undefined if they are not known.\n     */\n    private getKeysForParticipant(userId: string, deviceId: string): Array<Uint8Array> | undefined {\n        return this.encryptionKeys.get(getParticipantId(userId, deviceId))?.map((entry) => entry.key);\n    }\n\n    /**\n     * Re-sends the encryption keys room event\n     */\n    private sendEncryptionKeysEvent = async (indexToSend?: number): Promise<void> => {\n        if (this.keysEventUpdateTimeout !== undefined) {\n            clearTimeout(this.keysEventUpdateTimeout);\n            this.keysEventUpdateTimeout = undefined;\n        }\n        this.lastEncryptionKeyUpdateRequest = Date.now();\n\n        if (!this.joined) return;\n\n        logger.info(`Sending encryption keys event. indexToSend=${indexToSend}`);\n\n        const userId = this.client.getUserId();\n        const deviceId = this.client.getDeviceId();\n\n        if (!userId) throw new Error(\"No userId\");\n        if (!deviceId) throw new Error(\"No deviceId\");\n\n        const myKeys = this.getKeysForParticipant(userId, deviceId);\n\n        if (!myKeys) {\n            logger.warn(\"Tried to send encryption keys event but no keys found!\");\n            return;\n        }\n\n        if (typeof indexToSend !== \"number\" && this.currentEncryptionKeyIndex === -1) {\n            logger.warn(\"Tried to send encryption keys event but no current key index found!\");\n            return;\n        }\n\n        const keyIndexToSend = indexToSend ?? this.currentEncryptionKeyIndex;\n        const keyToSend = myKeys[keyIndexToSend];\n\n        try {\n            const content: EncryptionKeysEventContent = {\n                keys: [\n                    {\n                        index: keyIndexToSend,\n                        key: encodeUnpaddedBase64(keyToSend),\n                    },\n                ],\n                device_id: deviceId,\n                call_id: \"\",\n                sent_ts: Date.now(),\n            };\n\n            this.statistics.counters.roomEventEncryptionKeysSent += 1;\n\n            await this.client.sendEvent(this.room.roomId, EventType.CallEncryptionKeysPrefix, content);\n\n            logger.debug(\n                `Embedded-E2EE-LOG updateEncryptionKeyEvent participantId=${userId}:${deviceId} numKeys=${myKeys.length} currentKeyIndex=${this.currentEncryptionKeyIndex} keyIndexToSend=${keyIndexToSend}`,\n                this.encryptionKeys,\n            );\n        } catch (error) {\n            const matrixError = error as MatrixError;\n            if (matrixError.event) {\n                // cancel the pending event: we'll just generate a new one with our latest\n                // keys when we resend\n                this.client.cancelPendingEvent(matrixError.event);\n            }\n            if (this.keysEventUpdateTimeout === undefined) {\n                const resendDelay = safeGetRetryAfterMs(matrixError, 5000);\n                logger.warn(`Failed to send m.call.encryption_key, retrying in ${resendDelay}`, error);\n                this.keysEventUpdateTimeout = setTimeout(() => void this.sendEncryptionKeysEvent(), resendDelay);\n            } else {\n                logger.info(\"Not scheduling key resend as another re-send is already pending\");\n            }\n        }\n    };\n\n    public onCallEncryptionEventReceived = (event: MatrixEvent): void => {\n        const userId = event.getSender();\n        const content = event.getContent<EncryptionKeysEventContent>();\n\n        const deviceId = content[\"device_id\"];\n        const callId = content[\"call_id\"];\n\n        if (!userId) {\n            logger.warn(`Received m.call.encryption_keys with no userId: callId=${callId}`);\n            return;\n        }\n\n        // We currently only handle callId = \"\" (which is the default for room scoped calls)\n        if (callId !== \"\") {\n            logger.warn(\n                `Received m.call.encryption_keys with unsupported callId: userId=${userId}, deviceId=${deviceId}, callId=${callId}`,\n            );\n            return;\n        }\n\n        if (!Array.isArray(content.keys)) {\n            logger.warn(`Received m.call.encryption_keys where keys wasn't an array: callId=${callId}`);\n            return;\n        }\n\n        if (userId === this.client.getUserId() && deviceId === this.client.getDeviceId()) {\n            // We store our own sender key in the same set along with keys from others, so it's\n            // important we don't allow our own keys to be set by one of these events (apart from\n            // the fact that we don't need it anyway because we already know our own keys).\n            logger.info(\"Ignoring our own keys event\");\n            return;\n        }\n\n        this.statistics.counters.roomEventEncryptionKeysReceived += 1;\n        const age = Date.now() - (typeof content.sent_ts === \"number\" ? content.sent_ts : event.getTs());\n        this.statistics.totals.roomEventEncryptionKeysReceivedTotalAge += age;\n\n        for (const key of content.keys) {\n            if (!key) {\n                logger.info(\"Ignoring false-y key in keys event\");\n                continue;\n            }\n\n            const encryptionKey = key.key;\n            const encryptionKeyIndex = key.index;\n\n            if (\n                !encryptionKey ||\n                encryptionKeyIndex === undefined ||\n                encryptionKeyIndex === null ||\n                callId === undefined ||\n                callId === null ||\n                typeof deviceId !== \"string\" ||\n                typeof callId !== \"string\" ||\n                typeof encryptionKey !== \"string\" ||\n                typeof encryptionKeyIndex !== \"number\"\n            ) {\n                logger.warn(\n                    `Malformed call encryption_key: userId=${userId}, deviceId=${deviceId}, encryptionKeyIndex=${encryptionKeyIndex} callId=${callId}`,\n                );\n            } else {\n                logger.debug(\n                    `Embedded-E2EE-LOG onCallEncryption userId=${userId}:${deviceId} encryptionKeyIndex=${encryptionKeyIndex} age=${age}ms`,\n                    this.encryptionKeys,\n                );\n                this.setEncryptionKey(userId, deviceId, encryptionKeyIndex, encryptionKey, event.getTs());\n            }\n        }\n    };\n    private storeLastMembershipFingerprints(): void {\n        this.lastMembershipFingerprints = new Set(\n            this.getMemberships()\n                .filter((m) => !this.isMyMembership(m))\n                .map((m) => `${getParticipantIdFromMembership(m)}:${m.createdTs()}`),\n        );\n    }\n\n    private getNewEncryptionKeyIndex(): number {\n        if (this.currentEncryptionKeyIndex === -1) {\n            return 0;\n        }\n\n        // maximum key index is 255\n        return (this.currentEncryptionKeyIndex + 1) % 256;\n    }\n\n    /**\n     * Sets an encryption key at a specified index for a participant.\n     * The encryption keys for the local participant are also stored here under the\n     * user and device ID of the local participant.\n     * If the key is older than the existing key at the index, it will be ignored.\n     * @param userId - The user ID of the participant\n     * @param deviceId - Device ID of the participant\n     * @param encryptionKeyIndex - The index of the key to set\n     * @param encryptionKeyString - The string representation of the key to set in base64\n     * @param timestamp - The timestamp of the key. We assume that these are monotonic for each participant device.\n     * @param delayBeforeUse - If true, delay before emitting a key changed event. Useful when setting\n     *                         encryption keys for the local participant to allow time for the key to\n     *                         be distributed.\n     */\n    private setEncryptionKey(\n        userId: string,\n        deviceId: string,\n        encryptionKeyIndex: number,\n        encryptionKeyString: string,\n        timestamp: number,\n        delayBeforeUse = false,\n    ): void {\n        const keyBin = decodeBase64(encryptionKeyString);\n\n        const participantId = getParticipantId(userId, deviceId);\n        if (!this.encryptionKeys.has(participantId)) {\n            this.encryptionKeys.set(participantId, []);\n        }\n        const participantKeys = this.encryptionKeys.get(participantId)!;\n\n        const existingKeyAtIndex = participantKeys[encryptionKeyIndex];\n\n        if (existingKeyAtIndex) {\n            if (existingKeyAtIndex.timestamp > timestamp) {\n                logger.info(\n                    `Ignoring new key at index ${encryptionKeyIndex} for ${participantId} as it is older than existing known key`,\n                );\n                return;\n            }\n\n            if (keysEqual(existingKeyAtIndex.key, keyBin)) {\n                existingKeyAtIndex.timestamp = timestamp;\n                return;\n            }\n        }\n\n        participantKeys[encryptionKeyIndex] = {\n            key: keyBin,\n            timestamp,\n        };\n\n        if (delayBeforeUse) {\n            const useKeyTimeout = setTimeout(() => {\n                this.setNewKeyTimeouts.delete(useKeyTimeout);\n                logger.info(`Delayed-emitting key changed event for ${participantId} idx ${encryptionKeyIndex}`);\n                if (userId === this.client.getUserId() && deviceId === this.client.getDeviceId()) {\n                    this.currentEncryptionKeyIndex = encryptionKeyIndex;\n                }\n                this.onEncryptionKeysChanged(keyBin, encryptionKeyIndex, participantId);\n            }, this.useKeyDelay);\n            this.setNewKeyTimeouts.add(useKeyTimeout);\n        } else {\n            if (userId === this.client.getUserId() && deviceId === this.client.getDeviceId()) {\n                this.currentEncryptionKeyIndex = encryptionKeyIndex;\n            }\n            this.onEncryptionKeysChanged(keyBin, encryptionKeyIndex, participantId);\n        }\n    }\n\n    private onRotateKeyTimeout = (): void => {\n        if (!this.manageMediaKeys) return;\n\n        this.makeNewKeyTimeout = undefined;\n        logger.info(\"Making new sender key for key rotation\");\n        const newKeyIndex = this.makeNewSenderKey(true);\n        // send immediately: if we're about to start sending with a new key, it's\n        // important we get it out to others as soon as we can.\n        void this.sendEncryptionKeysEvent(newKeyIndex);\n    };\n}\n\nconst getParticipantId = (userId: string, deviceId: string): string => `${userId}:${deviceId}`;\nfunction keysEqual(a: Uint8Array | undefined, b: Uint8Array | undefined): boolean {\n    if (a === b) return true;\n    return !!a && !!b && a.length === b.length && a.every((x, i) => x === b[i]);\n}\nconst getParticipantIdFromMembership = (m: CallMembership): string => getParticipantId(m.sender!, m.deviceId);\n","/*\nCopyright 2025 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { EventType } from \"../@types/event.ts\";\nimport { UpdateDelayedEventAction } from \"../@types/requests.ts\";\nimport type { MatrixClient } from \"../client.ts\";\nimport { HTTPError, MatrixError } from \"../http-api/errors.ts\";\nimport { logger } from \"../logger.ts\";\nimport { EventTimeline } from \"../models/event-timeline.ts\";\nimport { type Room } from \"../models/room.ts\";\nimport { sleep } from \"../utils.ts\";\nimport { type CallMembership, DEFAULT_EXPIRE_DURATION, type SessionMembershipData } from \"./CallMembership.ts\";\nimport { type Focus } from \"./focus.ts\";\nimport { isLivekitFocusActive } from \"./LivekitFocus.ts\";\nimport { type MembershipConfig } from \"./MatrixRTCSession.ts\";\nimport { type EmptyObject } from \"../@types/common.ts\";\nimport { type IMembershipManager } from \"./NewMembershipManager.ts\";\n\n/**\n * This internal class is used by the MatrixRTCSession to manage the local user's own membership of the session.\n *\n * Its responsibitiy is to manage the locals user membership:\n *  - send that sate event\n *  - send the delayed leave event\n *  - update the delayed leave event while connected\n *  - update the state event when it times out (for calls longer than membershipExpiryTimeout ~ 4h)\n *\n * It is possible to test this class on its own. The api surface (to use for tests) is\n * defined in `MembershipManagerInterface`.\n *\n * It is recommended to only use this interface for testing to allow replacing this class.\n *\n * @internal\n * @deprecated Use {@link MembershipManager} instead\n */\nexport class LegacyMembershipManager implements IMembershipManager {\n    private relativeExpiry: number | undefined;\n\n    private memberEventTimeout?: ReturnType<typeof setTimeout>;\n\n    /**\n     *   This is a Foci array that contains the Focus objects this user is aware of and proposes to use.\n     */\n    private ownFociPreferred?: Focus[];\n    /**\n     *   This is a Focus with the specified fields for an ActiveFocus (e.g. LivekitFocusActive for type=\"livekit\")\n     */\n    private ownFocusActive?: Focus;\n\n    private updateCallMembershipRunning = false;\n    private needCallMembershipUpdate = false;\n    /**\n     * If the server disallows the configured {@link membershipServerSideExpiryTimeout},\n     * this stores a delay that the server does allow.\n     */\n    private membershipServerSideExpiryTimeoutOverride?: number;\n    private disconnectDelayId: string | undefined;\n\n    private get callMemberEventRetryDelayMinimum(): number {\n        return this.joinConfig?.callMemberEventRetryDelayMinimum ?? 3_000;\n    }\n    private get membershipExpiryTimeout(): number {\n        return this.joinConfig?.membershipExpiryTimeout ?? DEFAULT_EXPIRE_DURATION;\n    }\n    private get membershipServerSideExpiryTimeout(): number {\n        return (\n            this.membershipServerSideExpiryTimeoutOverride ??\n            this.joinConfig?.membershipServerSideExpiryTimeout ??\n            8_000\n        );\n    }\n    private get membershipKeepAlivePeriod(): number {\n        return this.joinConfig?.membershipKeepAlivePeriod ?? 5_000;\n    }\n    private get callMemberEventRetryJitter(): number {\n        return this.joinConfig?.callMemberEventRetryJitter ?? 2_000;\n    }\n\n    public constructor(\n        private joinConfig: MembershipConfig | undefined,\n        private room: Pick<Room, \"getLiveTimeline\" | \"roomId\" | \"getVersion\">,\n        private client: Pick<\n            MatrixClient,\n            | \"getUserId\"\n            | \"getDeviceId\"\n            | \"sendStateEvent\"\n            | \"_unstable_sendDelayedStateEvent\"\n            | \"_unstable_updateDelayedEvent\"\n        >,\n        private getOldestMembership: () => CallMembership | undefined,\n    ) {}\n\n    public isJoined(): boolean {\n        return this.relativeExpiry !== undefined;\n    }\n\n    public join(fociPreferred: Focus[], fociActive?: Focus): void {\n        this.ownFocusActive = fociActive;\n        this.ownFociPreferred = fociPreferred;\n        this.relativeExpiry = this.membershipExpiryTimeout;\n        // We don't wait for this, mostly because it may fail and schedule a retry, so this\n        // function returning doesn't really mean anything at all.\n        void this.triggerCallMembershipEventUpdate();\n    }\n\n    public async leave(timeout: number | undefined = undefined): Promise<boolean> {\n        this.relativeExpiry = undefined;\n        this.ownFocusActive = undefined;\n\n        if (this.memberEventTimeout) {\n            clearTimeout(this.memberEventTimeout);\n            this.memberEventTimeout = undefined;\n        }\n        if (timeout) {\n            // The sleep promise returns the string 'timeout' and the membership update void\n            // A success implies that the membership update was quicker then the timeout.\n            const raceResult = await Promise.race([this.triggerCallMembershipEventUpdate(), sleep(timeout, \"timeout\")]);\n            return raceResult !== \"timeout\";\n        } else {\n            await this.triggerCallMembershipEventUpdate();\n            return true;\n        }\n    }\n\n    public async onRTCSessionMemberUpdate(memberships: CallMembership[]): Promise<void> {\n        const isMyMembership = (m: CallMembership): boolean =>\n            m.sender === this.client.getUserId() && m.deviceId === this.client.getDeviceId();\n\n        if (this.isJoined() && !memberships.some(isMyMembership)) {\n            logger.warn(\"Missing own membership: force re-join\");\n            // TODO: Should this be awaited? And is there anything to tell the focus?\n            return this.triggerCallMembershipEventUpdate();\n        }\n    }\n\n    public getActiveFocus(): Focus | undefined {\n        if (this.ownFocusActive) {\n            // A livekit active focus\n            if (isLivekitFocusActive(this.ownFocusActive)) {\n                if (this.ownFocusActive.focus_selection === \"oldest_membership\") {\n                    const oldestMembership = this.getOldestMembership();\n                    return oldestMembership?.getPreferredFoci()[0];\n                }\n            } else {\n                logger.warn(\"Unknown own ActiveFocus type. This makes it impossible to connect to an SFU.\");\n            }\n        } else {\n            // We do not understand the membership format (could be legacy). We default to oldestMembership\n            // Once there are other methods this is a hard error!\n            const oldestMembership = this.getOldestMembership();\n            return oldestMembership?.getPreferredFoci()[0];\n        }\n    }\n\n    private triggerCallMembershipEventUpdate = async (): Promise<void> => {\n        // TODO: Should this await on a shared promise?\n        if (this.updateCallMembershipRunning) {\n            this.needCallMembershipUpdate = true;\n            return;\n        }\n\n        this.updateCallMembershipRunning = true;\n        try {\n            // if anything triggers an update while the update is running, do another update afterwards\n            do {\n                this.needCallMembershipUpdate = false;\n                await this.updateCallMembershipEvent();\n            } while (this.needCallMembershipUpdate);\n        } finally {\n            this.updateCallMembershipRunning = false;\n        }\n    };\n    private makeNewMembership(deviceId: string): SessionMembershipData | EmptyObject {\n        // If we're joined, add our own\n        if (this.isJoined()) {\n            return this.makeMyMembership(deviceId);\n        }\n        return {};\n    }\n\n    /**\n     * Constructs our own membership\n     */\n    private makeMyMembership(deviceId: string): SessionMembershipData {\n        return {\n            call_id: \"\",\n            scope: \"m.room\",\n            application: \"m.call\",\n            device_id: deviceId,\n            expires: this.relativeExpiry,\n            focus_active: { type: \"livekit\", focus_selection: \"oldest_membership\" },\n            foci_preferred: this.ownFociPreferred ?? [],\n        };\n    }\n\n    private async updateCallMembershipEvent(): Promise<void> {\n        if (this.memberEventTimeout) {\n            clearTimeout(this.memberEventTimeout);\n            this.memberEventTimeout = undefined;\n        }\n\n        const roomState = this.room.getLiveTimeline().getState(EventTimeline.FORWARDS);\n        if (!roomState) throw new Error(\"Couldn't get room state for room \" + this.room.roomId);\n\n        const localUserId = this.client.getUserId();\n        const localDeviceId = this.client.getDeviceId();\n        if (!localUserId || !localDeviceId) throw new Error(\"User ID or device ID was null!\");\n\n        let newContent: EmptyObject | SessionMembershipData = {};\n        // TODO: add back expiary logic to non-legacy events\n        // previously we checked here if the event is timed out and scheduled a check if not.\n        // maybe there is a better way.\n        newContent = this.makeNewMembership(localDeviceId);\n\n        try {\n            if (this.isJoined()) {\n                const stateKey = this.makeMembershipStateKey(localUserId, localDeviceId);\n                const prepareDelayedDisconnection = async (): Promise<void> => {\n                    try {\n                        const res = await resendIfRateLimited(() =>\n                            this.client._unstable_sendDelayedStateEvent(\n                                this.room.roomId,\n                                {\n                                    delay: this.membershipServerSideExpiryTimeout,\n                                },\n                                EventType.GroupCallMemberPrefix,\n                                {}, // leave event\n                                stateKey,\n                            ),\n                        );\n                        this.disconnectDelayId = res.delay_id;\n                    } catch (e) {\n                        if (\n                            e instanceof MatrixError &&\n                            e.errcode === \"M_UNKNOWN\" &&\n                            e.data[\"org.matrix.msc4140.errcode\"] === \"M_MAX_DELAY_EXCEEDED\"\n                        ) {\n                            const maxDelayAllowed = e.data[\"org.matrix.msc4140.max_delay\"];\n                            if (\n                                typeof maxDelayAllowed === \"number\" &&\n                                this.membershipServerSideExpiryTimeout > maxDelayAllowed\n                            ) {\n                                this.membershipServerSideExpiryTimeoutOverride = maxDelayAllowed;\n                                return prepareDelayedDisconnection();\n                            }\n                        }\n                        logger.error(\"Failed to prepare delayed disconnection event:\", e);\n                    }\n                };\n\n                await prepareDelayedDisconnection();\n                // Send join event _after_ preparing the delayed disconnection event\n                await resendIfRateLimited(() =>\n                    this.client.sendStateEvent(this.room.roomId, EventType.GroupCallMemberPrefix, newContent, stateKey),\n                );\n                // If sending state cancels your own delayed state, prepare another delayed state\n                // TODO: Remove this once MSC4140 is stable & doesn't cancel own delayed state\n                if (this.disconnectDelayId !== undefined) {\n                    try {\n                        const knownDisconnectDelayId = this.disconnectDelayId;\n                        await resendIfRateLimited(() =>\n                            this.client._unstable_updateDelayedEvent(\n                                knownDisconnectDelayId,\n                                UpdateDelayedEventAction.Restart,\n                            ),\n                        );\n                    } catch (e) {\n                        if (e instanceof MatrixError && e.errcode === \"M_NOT_FOUND\") {\n                            // If we get a M_NOT_FOUND we prepare a new delayed event.\n                            // In other error cases we do not want to prepare anything since we do not have the guarantee, that the\n                            // future is not still running.\n                            logger.warn(\"Failed to update delayed disconnection event, prepare it again:\", e);\n                            this.disconnectDelayId = undefined;\n                            await prepareDelayedDisconnection();\n                        }\n                    }\n                }\n                if (this.disconnectDelayId !== undefined) {\n                    this.scheduleDelayDisconnection();\n                }\n                // TODO throw or log an error if this.disconnectDelayId === undefined\n            } else {\n                // Not joined\n                let sentDelayedDisconnect = false;\n                if (this.disconnectDelayId !== undefined) {\n                    try {\n                        const knownDisconnectDelayId = this.disconnectDelayId;\n                        await resendIfRateLimited(() =>\n                            this.client._unstable_updateDelayedEvent(\n                                knownDisconnectDelayId,\n                                UpdateDelayedEventAction.Send,\n                            ),\n                        );\n                        sentDelayedDisconnect = true;\n                    } catch (e) {\n                        logger.error(\"Failed to send our delayed disconnection event:\", e);\n                    }\n                    this.disconnectDelayId = undefined;\n                }\n                if (!sentDelayedDisconnect) {\n                    await resendIfRateLimited(() =>\n                        this.client.sendStateEvent(\n                            this.room.roomId,\n                            EventType.GroupCallMemberPrefix,\n                            {},\n                            this.makeMembershipStateKey(localUserId, localDeviceId),\n                        ),\n                    );\n                }\n            }\n            logger.info(\"Sent updated call member event.\");\n        } catch (e) {\n            const resendDelay = this.callMemberEventRetryDelayMinimum + Math.random() * this.callMemberEventRetryJitter;\n            logger.warn(`Failed to send call member event (retrying in ${resendDelay}): ${e}`);\n            await sleep(resendDelay);\n            await this.triggerCallMembershipEventUpdate();\n        }\n    }\n\n    private scheduleDelayDisconnection(): void {\n        this.memberEventTimeout = setTimeout(() => void this.delayDisconnection(), this.membershipKeepAlivePeriod);\n    }\n\n    private readonly delayDisconnection = async (): Promise<void> => {\n        try {\n            const knownDisconnectDelayId = this.disconnectDelayId!;\n            await resendIfRateLimited(() =>\n                this.client._unstable_updateDelayedEvent(knownDisconnectDelayId, UpdateDelayedEventAction.Restart),\n            );\n            this.scheduleDelayDisconnection();\n        } catch (e) {\n            logger.error(\"Failed to delay our disconnection event:\", e);\n        }\n    };\n\n    private makeMembershipStateKey(localUserId: string, localDeviceId: string): string {\n        const stateKey = `${localUserId}_${localDeviceId}`;\n        if (/^org\\.matrix\\.msc(3757|3779)\\b/.exec(this.room.getVersion())) {\n            return stateKey;\n        } else {\n            return `_${stateKey}`;\n        }\n    }\n}\n\nasync function resendIfRateLimited<T>(func: () => Promise<T>, numRetriesAllowed: number = 1): Promise<T> {\n    // eslint-disable-next-line no-constant-condition\n    while (true) {\n        try {\n            return await func();\n        } catch (e) {\n            if (numRetriesAllowed > 0 && e instanceof HTTPError && e.isRateLimitError()) {\n                numRetriesAllowed--;\n                let resendDelay: number;\n                const defaultMs = 5000;\n                try {\n                    resendDelay = e.getRetryAfterMs() ?? defaultMs;\n                    logger.info(`Rate limited by server, retrying in ${resendDelay}ms`);\n                } catch (e) {\n                    logger.warn(\n                        `Error while retrieving a rate-limit retry delay, retrying after default delay of ${defaultMs}`,\n                        e,\n                    );\n                    resendDelay = defaultMs;\n                }\n                await sleep(resendDelay);\n            } else {\n                throw e;\n            }\n        }\n    }\n}\n","/*\nCopyright 2023 - 2024 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { logger as rootLogger } from \"../logger.ts\";\nimport { TypedEventEmitter } from \"../models/typed-event-emitter.ts\";\nimport { EventTimeline } from \"../models/event-timeline.ts\";\nimport { type Room } from \"../models/room.ts\";\nimport { type MatrixClient } from \"../client.ts\";\nimport { EventType } from \"../@types/event.ts\";\nimport { CallMembership } from \"./CallMembership.ts\";\nimport { RoomStateEvent } from \"../models/room-state.ts\";\nimport { type Focus } from \"./focus.ts\";\nimport { KnownMembership } from \"../@types/membership.ts\";\nimport { type MatrixEvent } from \"../models/event.ts\";\nimport { MembershipManager, type IMembershipManager } from \"./NewMembershipManager.ts\";\nimport { EncryptionManager, type IEncryptionManager, type Statistics } from \"./EncryptionManager.ts\";\nimport { LegacyMembershipManager } from \"./LegacyMembershipManager.ts\";\nimport { logDurationSync } from \"../utils.ts\";\n\nconst logger = rootLogger.getChild(\"MatrixRTCSession\");\n\nexport enum MatrixRTCSessionEvent {\n    // A member joined, left, or updated a property of their membership.\n    MembershipsChanged = \"memberships_changed\",\n    // We joined or left the session: our own local idea of whether we are joined,\n    // separate from MembershipsChanged, ie. independent of whether our member event\n    // has successfully gone through.\n    JoinStateChanged = \"join_state_changed\",\n    // The key used to encrypt media has changed\n    EncryptionKeyChanged = \"encryption_key_changed\",\n    /** The membership manager had to shut down caused by an unrecoverable error */\n    MembershipManagerError = \"membership_manager_error\",\n}\n\nexport type MatrixRTCSessionEventHandlerMap = {\n    [MatrixRTCSessionEvent.MembershipsChanged]: (\n        oldMemberships: CallMembership[],\n        newMemberships: CallMembership[],\n    ) => void;\n    [MatrixRTCSessionEvent.JoinStateChanged]: (isJoined: boolean) => void;\n    [MatrixRTCSessionEvent.EncryptionKeyChanged]: (\n        key: Uint8Array,\n        encryptionKeyIndex: number,\n        participantId: string,\n    ) => void;\n    [MatrixRTCSessionEvent.MembershipManagerError]: (error: unknown) => void;\n};\n\nexport interface MembershipConfig {\n    /**\n     * Use the new Manager.\n     *\n     * Default: `false`.\n     */\n    useNewMembershipManager?: boolean;\n\n    /**\n     * The timeout (in milliseconds) after we joined the call, that our membership should expire\n     * unless we have explicitly updated it.\n     *\n     * This is what goes into the m.rtc.member event expiry field and is typically set to a number of hours.\n     */\n    membershipExpiryTimeout?: number;\n\n    /**\n     * The time in (in milliseconds) which the manager will prematurely send the updated state event before the membership `expires` time to make sure it\n     * sends the updated state event early enough.\n     *\n     * A headroom of 1000ms and a `membershipExpiryTimeout` of 10000ms would result in the first membership event update after 9s and\n     * a membership event that would be considered expired after 10s.\n     *\n     * This value does not have an effect on the value of `SessionMembershipData.expires`.\n     */\n    membershipExpiryTimeoutHeadroom?: number;\n\n    /**\n     * The period (in milliseconds) with which we check that our membership event still exists on the\n     * server. If it is not found we create it again.\n     */\n    memberEventCheckPeriod?: number;\n\n    /**\n     * The minimum delay (in milliseconds) after which we will retry sending the membership event if it\n     * failed to send.\n     */\n    callMemberEventRetryDelayMinimum?: number;\n\n    /**\n     * The timeout (in milliseconds) with which the deleayed leave event on the server is configured.\n     * After this time the server will set the event to the disconnected stat if it has not received a keep-alive from the client.\n     */\n    membershipServerSideExpiryTimeout?: number;\n\n    /**\n     * The interval (in milliseconds) in which the client will send membership keep-alives to the server.\n     */\n    membershipKeepAlivePeriod?: number;\n\n    /**\n     * @deprecated It should be possible to make it stable without this.\n     */\n    callMemberEventRetryJitter?: number;\n\n    /**\n     * The maximum number of retries that the manager will do for delayed event sending/updating and state event sending when a server rate limit has been hit.\n     */\n    maximumRateLimitRetryCount?: number;\n\n    /**\n     * The maximum number of retries that the manager will do for delayed event sending/updating and state event sending when a network error occurs.\n     */\n    maximumNetworkErrorRetryCount?: number;\n}\n\nexport interface EncryptionConfig {\n    /**\n     *  If true, generate and share a media key for this participant,\n     *  and emit MatrixRTCSessionEvent.EncryptionKeyChanged when\n     *  media keys for other participants become available.\n     */\n    manageMediaKeys?: boolean;\n    /**\n     * The minimum time (in milliseconds) between each attempt to send encryption key(s).\n     * e.g. if this is set to 1000, then we will send at most one key event every second.\n     */\n    updateEncryptionKeyThrottle?: number;\n    /**\n     * The delay (in milliseconds) after a member leaves before we create and publish a new key, because people\n     * tend to leave calls at the same time.\n     */\n    makeKeyDelay?: number;\n    /**\n     * The delay (in milliseconds) between creating and sending a new key and starting to encrypt with it. This\n     * gives other a chance to receive the new key to minimise the chance they don't get media they can't decrypt.\n     * The total time between a member leaving and the call switching to new keys is therefore:\n     * makeKeyDelay + useKeyDelay\n     */\n    useKeyDelay?: number;\n}\nexport type JoinSessionConfig = MembershipConfig & EncryptionConfig;\n\n/**\n * A MatrixRTCSession manages the membership & properties of a MatrixRTC session.\n * This class doesn't deal with media at all, just membership & properties of a session.\n */\nexport class MatrixRTCSession extends TypedEventEmitter<MatrixRTCSessionEvent, MatrixRTCSessionEventHandlerMap> {\n    private membershipManager?: IMembershipManager;\n    private encryptionManager: IEncryptionManager;\n    // The session Id of the call, this is the call_id of the call Member event.\n    private _callId: string | undefined;\n\n    /**\n     * This timeout is responsible to track any expiration. We need to know when we have to start\n     * to ignore other call members. There is no callback for this. This timeout will always be configured to\n     * emit when the next membership expires.\n     */\n    private expiryTimeout?: ReturnType<typeof setTimeout>;\n\n    /**\n     * The statistics for this session.\n     */\n    public get statistics(): Statistics {\n        return this.encryptionManager.statistics;\n    }\n\n    /**\n     * The callId (sessionId) of the call.\n     *\n     * It can be undefined since the callId is only known once the first membership joins.\n     * The callId is the property that, per definition, groups memberships into one call.\n     */\n    public get callId(): string | undefined {\n        return this._callId;\n    }\n\n    /**\n     * Returns all the call memberships for a room, oldest first\n     */\n    public static callMembershipsForRoom(\n        room: Pick<Room, \"getLiveTimeline\" | \"roomId\" | \"hasMembershipState\">,\n    ): CallMembership[] {\n        const roomState = room.getLiveTimeline().getState(EventTimeline.FORWARDS);\n        if (!roomState) {\n            logger.warn(\"Couldn't get state for room \" + room.roomId);\n            throw new Error(\"Could't get state for room \" + room.roomId);\n        }\n        const callMemberEvents = roomState.getStateEvents(EventType.GroupCallMemberPrefix);\n\n        const callMemberships: CallMembership[] = [];\n        for (const memberEvent of callMemberEvents) {\n            const content = memberEvent.getContent();\n            const eventKeysCount = Object.keys(content).length;\n            // Dont even bother about empty events (saves us from costly type/\"key in\" checks in bigger rooms)\n            if (eventKeysCount === 0) continue;\n\n            const membershipContents: any[] = [];\n\n            // We first decide if its a MSC4143 event (per device state key)\n            if (eventKeysCount > 1 && \"focus_active\" in content) {\n                // We have a MSC4143 event membership event\n                membershipContents.push(content);\n            } else if (eventKeysCount === 1 && \"memberships\" in content) {\n                logger.warn(`Legacy event found. Those are ignored, they do not contribute to the MatrixRTC session`);\n            }\n\n            if (membershipContents.length === 0) continue;\n\n            for (const membershipData of membershipContents) {\n                try {\n                    const membership = new CallMembership(memberEvent, membershipData);\n\n                    if (membership.callId !== \"\" || membership.scope !== \"m.room\") {\n                        // for now, just ignore anything that isn't a room scope call\n                        logger.info(`Ignoring user-scoped call`);\n                        continue;\n                    }\n\n                    if (membership.isExpired()) {\n                        logger.info(`Ignoring expired device membership ${membership.sender}/${membership.deviceId}`);\n                        continue;\n                    }\n                    if (!room.hasMembershipState(membership.sender ?? \"\", KnownMembership.Join)) {\n                        logger.info(`Ignoring membership of user ${membership.sender} who is not in the room.`);\n                        continue;\n                    }\n                    callMemberships.push(membership);\n                } catch (e) {\n                    logger.warn(\"Couldn't construct call membership: \", e);\n                }\n            }\n        }\n\n        callMemberships.sort((a, b) => a.createdTs() - b.createdTs());\n        if (callMemberships.length > 1) {\n            logger.debug(\n                `Call memberships in room ${room.roomId}, in order: `,\n                callMemberships.map((m) => [m.createdTs(), m.sender]),\n            );\n        }\n\n        return callMemberships;\n    }\n\n    /**\n     * Return the MatrixRTC session for the room, whether there are currently active members or not\n     */\n    public static roomSessionForRoom(client: MatrixClient, room: Room): MatrixRTCSession {\n        const callMemberships = MatrixRTCSession.callMembershipsForRoom(room);\n\n        return new MatrixRTCSession(client, room, callMemberships);\n    }\n\n    /**\n     * WARN: this can in theory only be a subset of the room with the properties required by\n     * this class.\n     * Outside of tests this most likely will be a full room, however.\n     * @deprecated Relying on a full Room object being available here is an anti-pattern. You should be tracking\n     * the room object in your own code and passing it in when needed.\n     */\n    public get room(): Room {\n        return this.roomSubset as Room;\n    }\n\n    /**\n     * This constructs a room session. When using MatrixRTC inside the js-sdk this is expected\n     * to be used with the MatrixRTCSessionManager exclusively.\n     *\n     * In cases where you don't use the js-sdk but build on top of another Matrix stack this class can be used standalone\n     * to manage a joined MatrixRTC session.\n     *\n     * @param client A subset of the {@link MatrixClient} that lets the session interact with the Matrix room.\n     * @param roomSubset The room this session is attached to. A subset of a js-sdk Room that the session needs.\n     * @param memberships The list of memberships this session currently has.\n     */\n    public constructor(\n        private readonly client: Pick<\n            MatrixClient,\n            | \"getUserId\"\n            | \"getDeviceId\"\n            | \"sendStateEvent\"\n            | \"_unstable_sendDelayedStateEvent\"\n            | \"_unstable_updateDelayedEvent\"\n            | \"sendEvent\"\n            | \"cancelPendingEvent\"\n        >,\n        private roomSubset: Pick<Room, \"getLiveTimeline\" | \"roomId\" | \"getVersion\" | \"hasMembershipState\">,\n        public memberships: CallMembership[],\n    ) {\n        super();\n        this._callId = memberships[0]?.callId;\n        const roomState = this.roomSubset.getLiveTimeline().getState(EventTimeline.FORWARDS);\n        // TODO: double check if this is actually needed. Should be covered by refreshRoom in MatrixRTCSessionManager\n        roomState?.on(RoomStateEvent.Members, this.onRoomMemberUpdate);\n        this.setExpiryTimer();\n        this.encryptionManager = new EncryptionManager(\n            this.client,\n            this.roomSubset,\n            () => this.memberships,\n            (keyBin: Uint8Array<ArrayBufferLike>, encryptionKeyIndex: number, participantId: string) => {\n                this.emit(MatrixRTCSessionEvent.EncryptionKeyChanged, keyBin, encryptionKeyIndex, participantId);\n            },\n        );\n    }\n\n    /*\n     * Returns true if we intend to be participating in the MatrixRTC session.\n     * This is determined by checking if the relativeExpiry has been set.\n     */\n    public isJoined(): boolean {\n        return this.membershipManager?.isJoined() ?? false;\n    }\n\n    /**\n     * Performs cleanup & removes timers for client shutdown\n     */\n    public async stop(): Promise<void> {\n        await this.membershipManager?.leave(1000);\n        if (this.expiryTimeout) {\n            clearTimeout(this.expiryTimeout);\n            this.expiryTimeout = undefined;\n        }\n        const roomState = this.roomSubset.getLiveTimeline().getState(EventTimeline.FORWARDS);\n        roomState?.off(RoomStateEvent.Members, this.onRoomMemberUpdate);\n    }\n\n    /**\n     * Announces this user and device as joined to the MatrixRTC session,\n     * and continues to update the membership event to keep it valid until\n     * leaveRoomSession() is called\n     * This will not subscribe to updates: remember to call subscribe() separately if\n     * desired.\n     * This method will return immediately and the session will be joined in the background.\n     *\n     * @param fociActive - The object representing the active focus. (This depends on the focus type.)\n     * @param fociPreferred - The list of preferred foci this member proposes to use/knows/has access to.\n     *                        For the livekit case this is a list of foci generated from the homeserver well-known, the current rtc session,\n     *                        or optionally other room members homeserver well known.\n     * @param joinConfig - Additional configuration for the joined session.\n     */\n    public joinRoomSession(fociPreferred: Focus[], fociActive?: Focus, joinConfig?: JoinSessionConfig): void {\n        if (this.isJoined()) {\n            logger.info(`Already joined to session in room ${this.roomSubset.roomId}: ignoring join call`);\n            return;\n        } else {\n            // Create MembershipManager\n            if (joinConfig?.useNewMembershipManager ?? false) {\n                this.membershipManager = new MembershipManager(joinConfig, this.roomSubset, this.client, () =>\n                    this.getOldestMembership(),\n                );\n            } else {\n                this.membershipManager = new LegacyMembershipManager(joinConfig, this.roomSubset, this.client, () =>\n                    this.getOldestMembership(),\n                );\n            }\n        }\n\n        // Join!\n        this.membershipManager!.join(fociPreferred, fociActive, (e) => {\n            logger.error(\"MembershipManager encountered an unrecoverable error: \", e);\n            this.emit(MatrixRTCSessionEvent.MembershipManagerError, e);\n            this.emit(MatrixRTCSessionEvent.JoinStateChanged, this.isJoined());\n        });\n        this.encryptionManager!.join(joinConfig);\n\n        this.emit(MatrixRTCSessionEvent.JoinStateChanged, true);\n    }\n\n    /**\n     * Announces this user and device as having left the MatrixRTC session\n     * and stops scheduled updates.\n     * This will not unsubscribe from updates: remember to call unsubscribe() separately if\n     * desired.\n     * The membership update required to leave the session will retry if it fails.\n     * Without network connection the promise will never resolve.\n     * A timeout can be provided so that there is a guarantee for the promise to resolve.\n     * @returns Whether the membership update was attempted and did not time out.\n     */\n    public async leaveRoomSession(timeout: number | undefined = undefined): Promise<boolean> {\n        if (!this.isJoined()) {\n            logger.info(`Not joined to session in room ${this.roomSubset.roomId}: ignoring leave call`);\n            return false;\n        }\n\n        logger.info(`Leaving call session in room ${this.roomSubset.roomId}`);\n\n        this.encryptionManager.leave();\n\n        const leavePromise = this.membershipManager!.leave(timeout);\n        this.emit(MatrixRTCSessionEvent.JoinStateChanged, false);\n\n        return await leavePromise;\n    }\n\n    /**\n     * Get the active focus from the current CallMemberState event\n     * @returns The focus that is currently in use to connect to this session. This is undefined\n     * if the client is not connected to this session.\n     */\n    public getActiveFocus(): Focus | undefined {\n        return this.membershipManager?.getActiveFocus();\n    }\n\n    public getOldestMembership(): CallMembership | undefined {\n        return this.memberships[0];\n    }\n\n    /**\n     * This method is used when the user is not yet connected to the Session but wants to know what focus\n     * the users in the session are using to make a decision how it wants/should connect.\n     *\n     * See also `getActiveFocus`\n     * @returns The focus which should be used when joining this session.\n     */\n    public getFocusInUse(): Focus | undefined {\n        const oldestMembership = this.getOldestMembership();\n        if (oldestMembership?.getFocusSelection() === \"oldest_membership\") {\n            return oldestMembership.getPreferredFoci()[0];\n        }\n    }\n\n    /**\n     * Re-emit an EncryptionKeyChanged event for each tracked encryption key. This can be used to export\n     * the keys.\n     */\n    public reemitEncryptionKeys(): void {\n        this.encryptionManager.getEncryptionKeys().forEach((keys, participantId) => {\n            keys.forEach((key, index) => {\n                this.emit(MatrixRTCSessionEvent.EncryptionKeyChanged, key.key, index, participantId);\n            });\n        });\n    }\n\n    /**\n     * A map of keys used to encrypt and decrypt (we are using a symmetric\n     * cipher) given participant's media. This also includes our own key\n     *\n     * @deprecated This will be made private in a future release.\n     */\n    public getEncryptionKeys(): IterableIterator<[string, Array<Uint8Array>]> {\n        const keys =\n            this.encryptionManager.getEncryptionKeys() ??\n            new Map<string, Array<{ key: Uint8Array; timestamp: number }>>();\n        // the returned array doesn't contain the timestamps\n        return Array.from(keys.entries())\n            .map(([participantId, keys]): [string, Uint8Array[]] => [participantId, keys.map((k) => k.key)])\n            .values();\n    }\n\n    /**\n     * Sets a timer for the soonest membership expiry\n     */\n    private setExpiryTimer(): void {\n        if (this.expiryTimeout) {\n            clearTimeout(this.expiryTimeout);\n            this.expiryTimeout = undefined;\n        }\n\n        let soonestExpiry;\n        for (const membership of this.memberships) {\n            const thisExpiry = membership.getMsUntilExpiry();\n            // If getMsUntilExpiry is undefined we have a MSC4143 (MatrixRTC) compliant event - it never expires\n            // but will be reliably resent on disconnect.\n            if (thisExpiry !== undefined && (soonestExpiry === undefined || thisExpiry < soonestExpiry)) {\n                soonestExpiry = thisExpiry;\n            }\n        }\n\n        if (soonestExpiry != undefined) {\n            this.expiryTimeout = setTimeout(this.onRTCSessionMemberUpdate, soonestExpiry);\n        }\n    }\n\n    /**\n     * Process `m.call.encryption_keys` events to track the encryption keys for call participants.\n     * This should be called each time the relevant event is received from a room timeline.\n     * If the event is malformed then it will be logged and ignored.\n     *\n     * @param event the event to process\n     */\n    public onCallEncryption = (event: MatrixEvent): void => {\n        this.encryptionManager.onCallEncryptionEventReceived(event);\n    };\n\n    /**\n     * @deprecated use onRoomMemberUpdate or onRTCSessionMemberUpdate instead. this should be called when any membership in the call is updated\n     * the old name might have implied to only need to call this when your own membership changes.\n     */\n    public onMembershipUpdate = (): void => {\n        this.recalculateSessionMembers();\n    };\n\n    /**\n     * Call this when the Matrix room members have changed.\n     */\n    public onRoomMemberUpdate = (): void => {\n        this.recalculateSessionMembers();\n    };\n\n    /**\n     * Call this when something changed that may impacts the current MatrixRTC members in this session.\n     */\n    public onRTCSessionMemberUpdate = (): void => {\n        this.recalculateSessionMembers();\n    };\n\n    /**\n     * Call this when anything that could impact rtc memberships has changed: Room Members or RTC members.\n     *\n     * Examines the latest call memberships and handles any encryption key sending or rotation that is needed.\n     *\n     * This function should be called when the room members or call memberships might have changed.\n     */\n    private recalculateSessionMembers = (): void => {\n        const oldMemberships = this.memberships;\n        this.memberships = MatrixRTCSession.callMembershipsForRoom(this.room);\n\n        this._callId = this._callId ?? this.memberships[0]?.callId;\n\n        const changed =\n            oldMemberships.length != this.memberships.length ||\n            oldMemberships.some((m, i) => !CallMembership.equal(m, this.memberships[i]));\n\n        if (changed) {\n            logger.info(`Memberships for call in room ${this.roomSubset.roomId} have changed: emitting`);\n            logDurationSync(logger, \"emit MatrixRTCSessionEvent.MembershipsChanged\", () => {\n                this.emit(MatrixRTCSessionEvent.MembershipsChanged, oldMemberships, this.memberships);\n            });\n\n            void this.membershipManager?.onRTCSessionMemberUpdate(this.memberships);\n        }\n        // This also needs to be done if `changed` = false\n        // A member might have updated their fingerprint (created_ts)\n        void this.encryptionManager.onMembershipsUpdate(oldMemberships);\n\n        this.setExpiryTimer();\n    };\n}\n","/*\nCopyright 2023 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { logger as rootLogger } from \"../logger.ts\";\nimport { type MatrixClient, ClientEvent } from \"../client.ts\";\nimport { TypedEventEmitter } from \"../models/typed-event-emitter.ts\";\nimport { type Room, RoomEvent } from \"../models/room.ts\";\nimport { type RoomState, RoomStateEvent } from \"../models/room-state.ts\";\nimport { type MatrixEvent } from \"../models/event.ts\";\nimport { MatrixRTCSession } from \"./MatrixRTCSession.ts\";\nimport { EventType } from \"../@types/event.ts\";\n\nconst logger = rootLogger.getChild(\"MatrixRTCSessionManager\");\n\nexport enum MatrixRTCSessionManagerEvents {\n    // A member has joined the MatrixRTC session, creating an active session in a room where there wasn't previously\n    SessionStarted = \"session_started\",\n    // All participants have left a given MatrixRTC session.\n    SessionEnded = \"session_ended\",\n}\n\ntype EventHandlerMap = {\n    [MatrixRTCSessionManagerEvents.SessionStarted]: (roomId: string, session: MatrixRTCSession) => void;\n    [MatrixRTCSessionManagerEvents.SessionEnded]: (roomId: string, session: MatrixRTCSession) => void;\n};\n\n/**\n * Holds all active MatrixRTC session objects and creates new ones as events arrive.\n * This interface is UNSTABLE and may change without warning.\n */\nexport class MatrixRTCSessionManager extends TypedEventEmitter<MatrixRTCSessionManagerEvents, EventHandlerMap> {\n    // All the room-scoped sessions we know about. This will include any where the app\n    // has queried for the MatrixRTC sessions in a room, whether it's ever had any members\n    // or not). We keep a (lazily created) session object for every room to ensure that there\n    // is only ever one single room session object for any given room for the lifetime of the\n    // client: that way there can never be any code holding onto a stale object that is no\n    // longer the correct session object for the room.\n    private roomSessions = new Map<string, MatrixRTCSession>();\n\n    public constructor(private client: MatrixClient) {\n        super();\n    }\n\n    public start(): void {\n        // We shouldn't need to null-check here, but matrix-client.spec.ts mocks getRooms\n        // returning nothing, and breaks tests if you change it to return an empty array :'(\n        for (const room of this.client.getRooms() ?? []) {\n            const session = MatrixRTCSession.roomSessionForRoom(this.client, room);\n            if (session.memberships.length > 0) {\n                this.roomSessions.set(room.roomId, session);\n            }\n        }\n\n        this.client.on(ClientEvent.Room, this.onRoom);\n        this.client.on(RoomEvent.Timeline, this.onTimeline);\n        this.client.on(RoomStateEvent.Events, this.onRoomState);\n    }\n\n    public stop(): void {\n        for (const sess of this.roomSessions.values()) {\n            void sess.stop();\n        }\n        this.roomSessions.clear();\n\n        this.client.off(ClientEvent.Room, this.onRoom);\n        this.client.off(RoomEvent.Timeline, this.onTimeline);\n        this.client.off(RoomStateEvent.Events, this.onRoomState);\n    }\n\n    /**\n     * Gets the main MatrixRTC session for a room, or undefined if there is\n     * no current session\n     */\n    public getActiveRoomSession(room: Room): MatrixRTCSession | undefined {\n        return this.roomSessions.get(room.roomId)!;\n    }\n\n    /**\n     * Gets the main MatrixRTC session for a room, returning an empty session\n     * if no members are currently participating\n     */\n    public getRoomSession(room: Room): MatrixRTCSession {\n        if (!this.roomSessions.has(room.roomId)) {\n            this.roomSessions.set(room.roomId, MatrixRTCSession.roomSessionForRoom(this.client, room));\n        }\n\n        return this.roomSessions.get(room.roomId)!;\n    }\n\n    private async consumeCallEncryptionEvent(event: MatrixEvent, isRetry = false): Promise<void> {\n        await this.client.decryptEventIfNeeded(event);\n        if (event.isDecryptionFailure()) {\n            if (!isRetry) {\n                logger.warn(\n                    `Decryption failed for event ${event.getId()}: ${event.decryptionFailureReason} will retry once only`,\n                );\n                // retry after 1 second. After this we give up.\n                setTimeout(() => void this.consumeCallEncryptionEvent(event, true), 1000);\n            } else {\n                logger.warn(`Decryption failed for event ${event.getId()}: ${event.decryptionFailureReason}`);\n            }\n            return;\n        } else if (isRetry) {\n            logger.info(`Decryption succeeded for event ${event.getId()} after retry`);\n        }\n\n        if (event.getType() !== EventType.CallEncryptionKeysPrefix) return Promise.resolve();\n\n        const room = this.client.getRoom(event.getRoomId());\n        if (!room) {\n            logger.error(`Got room state event for unknown room ${event.getRoomId()}!`);\n            return Promise.resolve();\n        }\n\n        this.getRoomSession(room).onCallEncryption(event);\n    }\n    private onTimeline = (event: MatrixEvent): void => {\n        void this.consumeCallEncryptionEvent(event);\n    };\n\n    private onRoom = (room: Room): void => {\n        this.refreshRoom(room);\n    };\n\n    private onRoomState = (event: MatrixEvent, _state: RoomState): void => {\n        const room = this.client.getRoom(event.getRoomId());\n        if (!room) {\n            logger.error(`Got room state event for unknown room ${event.getRoomId()}!`);\n            return;\n        }\n\n        if (event.getType() == EventType.GroupCallMemberPrefix) {\n            this.refreshRoom(room);\n        }\n    };\n\n    private refreshRoom(room: Room): void {\n        const isNewSession = !this.roomSessions.has(room.roomId);\n        const sess = this.getRoomSession(room);\n\n        const wasActiveAndKnown = sess.memberships.length > 0 && !isNewSession;\n\n        sess.onRTCSessionMemberUpdate();\n\n        const nowActive = sess.memberships.length > 0;\n\n        if (wasActiveAndKnown && !nowActive) {\n            this.emit(MatrixRTCSessionManagerEvents.SessionEnded, room.roomId, this.roomSessions.get(room.roomId)!);\n        } else if (!wasActiveAndKnown && nowActive) {\n            this.emit(MatrixRTCSessionManagerEvents.SessionStarted, room.roomId, this.roomSessions.get(room.roomId)!);\n        }\n    }\n}\n","/*\nCopyright 2022 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { type MBeaconEventContent } from \"../@types/beacon.ts\";\nimport {\n    type BeaconInfoState,\n    type BeaconLocationState,\n    parseBeaconContent,\n    parseBeaconInfoContent,\n} from \"../content-helpers.ts\";\nimport { type MatrixEvent } from \"./event.ts\";\nimport { sortEventsByLatestContentTimestamp } from \"../utils.ts\";\nimport { TypedEventEmitter } from \"./typed-event-emitter.ts\";\n\nexport enum BeaconEvent {\n    New = \"Beacon.new\",\n    Update = \"Beacon.update\",\n    LivenessChange = \"Beacon.LivenessChange\",\n    Destroy = \"Beacon.Destroy\",\n    LocationUpdate = \"Beacon.LocationUpdate\",\n}\n\nexport type BeaconEventHandlerMap = {\n    [BeaconEvent.Update]: (event: MatrixEvent, beacon: Beacon) => void;\n    [BeaconEvent.LivenessChange]: (isLive: boolean, beacon: Beacon) => void;\n    [BeaconEvent.Destroy]: (beaconIdentifier: string) => void;\n    [BeaconEvent.LocationUpdate]: (locationState: BeaconLocationState) => void;\n    [BeaconEvent.Destroy]: (beaconIdentifier: string) => void;\n};\n\nexport const isTimestampInDuration = (startTimestamp: number, durationMs: number, timestamp: number): boolean =>\n    timestamp >= startTimestamp && startTimestamp + durationMs >= timestamp;\n\n// beacon info events are uniquely identified by\n// `<roomId>_<state_key>`\nexport type BeaconIdentifier = string;\nexport const getBeaconInfoIdentifier = (event: MatrixEvent): BeaconIdentifier =>\n    `${event.getRoomId()}_${event.getStateKey()}`;\n\n// https://github.com/matrix-org/matrix-spec-proposals/pull/3672\nexport class Beacon extends TypedEventEmitter<Exclude<BeaconEvent, BeaconEvent.New>, BeaconEventHandlerMap> {\n    public readonly roomId: string;\n    // beaconInfo is assigned by setBeaconInfo in the constructor\n    // ! to make tsc believe it is definitely assigned\n    private _beaconInfo!: BeaconInfoState;\n    private _isLive?: boolean;\n    private livenessWatchTimeout?: ReturnType<typeof setTimeout>;\n    private _latestLocationEvent?: MatrixEvent;\n\n    public constructor(private rootEvent: MatrixEvent) {\n        super();\n        this.roomId = this.rootEvent.getRoomId()!;\n        this.setBeaconInfo(this.rootEvent);\n    }\n\n    public get isLive(): boolean {\n        return !!this._isLive;\n    }\n\n    public get identifier(): BeaconIdentifier {\n        return getBeaconInfoIdentifier(this.rootEvent);\n    }\n\n    public get beaconInfoId(): string {\n        return this.rootEvent.getId()!;\n    }\n\n    public get beaconInfoOwner(): string {\n        return this.rootEvent.getStateKey()!;\n    }\n\n    public get beaconInfoEventType(): string {\n        return this.rootEvent.getType();\n    }\n\n    public get beaconInfo(): BeaconInfoState {\n        return this._beaconInfo;\n    }\n\n    public get latestLocationState(): BeaconLocationState | undefined {\n        return this._latestLocationEvent && parseBeaconContent(this._latestLocationEvent.getContent());\n    }\n\n    public get latestLocationEvent(): MatrixEvent | undefined {\n        return this._latestLocationEvent;\n    }\n\n    public update(beaconInfoEvent: MatrixEvent): void {\n        if (getBeaconInfoIdentifier(beaconInfoEvent) !== this.identifier) {\n            throw new Error(\"Invalid updating event\");\n        }\n        // don't update beacon with an older event\n        if (beaconInfoEvent.getTs() < this.rootEvent.getTs()) {\n            return;\n        }\n        this.rootEvent = beaconInfoEvent;\n        this.setBeaconInfo(this.rootEvent);\n\n        this.emit(BeaconEvent.Update, beaconInfoEvent, this);\n        this.clearLatestLocation();\n    }\n\n    public destroy(): void {\n        if (this.livenessWatchTimeout) {\n            clearTimeout(this.livenessWatchTimeout);\n        }\n\n        this._isLive = false;\n        this.emit(BeaconEvent.Destroy, this.identifier);\n    }\n\n    /**\n     * Monitor liveness of a beacon\n     * Emits BeaconEvent.LivenessChange when beacon expires\n     */\n    public monitorLiveness(): void {\n        if (this.livenessWatchTimeout) {\n            clearTimeout(this.livenessWatchTimeout);\n        }\n\n        this.checkLiveness();\n        if (!this.beaconInfo) return;\n        if (this.isLive) {\n            const expiryInMs = this.beaconInfo.timestamp! + this.beaconInfo.timeout - Date.now();\n            if (expiryInMs > 1) {\n                this.livenessWatchTimeout = setTimeout(() => {\n                    this.monitorLiveness();\n                }, expiryInMs);\n            }\n        } else if (this.beaconInfo.timestamp! > Date.now()) {\n            // beacon start timestamp is in the future\n            // check liveness again then\n            this.livenessWatchTimeout = setTimeout(() => {\n                this.monitorLiveness();\n            }, this.beaconInfo.timestamp! - Date.now());\n        }\n    }\n\n    /**\n     * Process Beacon locations\n     * Emits BeaconEvent.LocationUpdate\n     */\n    public addLocations(beaconLocationEvents: MatrixEvent[]): void {\n        // discard locations for beacons that are not live\n        if (!this.isLive) {\n            return;\n        }\n\n        const validLocationEvents = beaconLocationEvents.filter((event) => {\n            const content = event.getContent<MBeaconEventContent>();\n            const parsed = parseBeaconContent(content);\n            if (!parsed.uri || !parsed.timestamp) return false; // we won't be able to process these\n            const { timestamp } = parsed;\n            return (\n                this._beaconInfo.timestamp &&\n                // only include positions that were taken inside the beacon's live period\n                isTimestampInDuration(this._beaconInfo.timestamp, this._beaconInfo.timeout, timestamp) &&\n                // ignore positions older than our current latest location\n                (!this.latestLocationState || timestamp > this.latestLocationState.timestamp!)\n            );\n        });\n        const latestLocationEvent = validLocationEvents.sort(sortEventsByLatestContentTimestamp)?.[0];\n\n        if (latestLocationEvent) {\n            this._latestLocationEvent = latestLocationEvent;\n            this.emit(BeaconEvent.LocationUpdate, this.latestLocationState!);\n        }\n    }\n\n    private clearLatestLocation = (): void => {\n        this._latestLocationEvent = undefined;\n        this.emit(BeaconEvent.LocationUpdate, this.latestLocationState!);\n    };\n\n    private setBeaconInfo(event: MatrixEvent): void {\n        this._beaconInfo = parseBeaconInfoContent(event.getContent());\n        this.checkLiveness();\n    }\n\n    private checkLiveness(): void {\n        const prevLiveness = this.isLive;\n\n        // element web sets a beacon's start timestamp to the senders local current time\n        // when Alice's system clock deviates slightly from Bob's a beacon Alice intended to be live\n        // may have a start timestamp in the future from Bob's POV\n        // handle this by adding 6min of leniency to the start timestamp when it is in the future\n        if (!this.beaconInfo) return;\n        const startTimestamp =\n            this.beaconInfo.timestamp! > Date.now()\n                ? this.beaconInfo.timestamp! - 360000 /* 6min */\n                : this.beaconInfo.timestamp;\n        this._isLive =\n            !!this._beaconInfo.live &&\n            !!startTimestamp &&\n            isTimestampInDuration(startTimestamp, this._beaconInfo.timeout, Date.now());\n\n        if (prevLiveness !== this.isLive) {\n            this.emit(BeaconEvent.LivenessChange, this.isLive, this);\n        }\n    }\n}\n","/*\nCopyright 2023 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\n/** State of the verification of the device. */\nexport enum DeviceVerification {\n    Blocked = -1,\n    Unverified = 0,\n    Verified = 1,\n}\n\n/** A map from user ID to device ID to Device */\nexport type DeviceMap = Map<string, Map<string, Device>>;\n\ntype DeviceParameters = Pick<Device, \"deviceId\" | \"userId\" | \"algorithms\" | \"keys\"> & Partial<Device>;\n\n/**\n *  Information on a user's device, as returned by {@link crypto-api!CryptoApi.getUserDeviceInfo}.\n */\nexport class Device {\n    /** id of the device */\n    public readonly deviceId: string;\n\n    /** id of the user that owns the device */\n    public readonly userId: string;\n\n    /** list of algorithms supported by this device */\n    public readonly algorithms: string[];\n\n    /** a map from `<key type>:<id> -> <base64-encoded key>` */\n    public readonly keys: Map<string, string>;\n\n    /** whether the device has been verified/blocked by the user */\n    public readonly verified: DeviceVerification;\n\n    /** a map `<userId, map<algorithm:device_id, signature>>` */\n    public readonly signatures: Map<string, Map<string, string>>;\n\n    /** display name of the device */\n    public readonly displayName?: string;\n\n    /** whether the device is a dehydrated device */\n    public readonly dehydrated: boolean = false;\n\n    public constructor(opts: DeviceParameters) {\n        this.deviceId = opts.deviceId;\n        this.userId = opts.userId;\n        this.algorithms = opts.algorithms;\n        this.keys = opts.keys;\n        this.verified = opts.verified || DeviceVerification.Unverified;\n        this.signatures = opts.signatures || new Map();\n        this.displayName = opts.displayName;\n        this.dehydrated = !!opts.dehydrated;\n    }\n\n    /**\n     * Get the fingerprint for this device (ie, the Ed25519 key)\n     *\n     * @returns base64-encoded fingerprint of this device\n     */\n    public getFingerprint(): string | undefined {\n        return this.keys.get(`ed25519:${this.deviceId}`);\n    }\n\n    /**\n     * Get the identity key for this device (ie, the Curve25519 key)\n     *\n     * @returns base64-encoded identity key of this device\n     */\n    public getIdentityKey(): string | undefined {\n        return this.keys.get(`curve25519:${this.deviceId}`);\n    }\n}\n","/*\nCopyright 2015 - 2022 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\n/**\n * Enum for event statuses.\n * @readonly\n */\nexport enum EventStatus {\n    /** The event was not sent and will no longer be retried. */\n    NOT_SENT = \"not_sent\",\n\n    /** The message is being encrypted */\n    ENCRYPTING = \"encrypting\",\n\n    /** The event is in the process of being sent. */\n    SENDING = \"sending\",\n\n    /** The event is in a queue waiting to be sent. */\n    QUEUED = \"queued\",\n\n    /** The event has been sent to the server, but we have not yet received the echo. */\n    SENT = \"sent\",\n\n    /** The event was cancelled before it was successfully sent. */\n    CANCELLED = \"cancelled\",\n}\n","/*\nCopyright 2016 - 2021 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { EventTimeline, type IAddEventOptions } from \"./event-timeline.ts\";\nimport { type MatrixEvent } from \"./event.ts\";\nimport { logger } from \"../logger.ts\";\nimport { type Room, RoomEvent } from \"./room.ts\";\nimport { type Filter } from \"../filter.ts\";\nimport { type RoomState } from \"./room-state.ts\";\nimport { TypedEventEmitter } from \"./typed-event-emitter.ts\";\nimport { RelationsContainer } from \"./relations-container.ts\";\nimport { type MatrixClient } from \"../client.ts\";\nimport { type Thread, type ThreadFilterType } from \"./thread.ts\";\n\nconst DEBUG = true;\n\n/* istanbul ignore next */\nlet debuglog: (...args: any[]) => void;\nif (DEBUG) {\n    // using bind means that we get to keep useful line numbers in the console\n    debuglog = logger.log.bind(logger);\n} else {\n    /* istanbul ignore next */\n    debuglog = function (): void {};\n}\n\ninterface IOpts {\n    // Set to true to enable improved timeline support.\n    timelineSupport?: boolean;\n    // The filter object, if any, for this timelineSet.\n    filter?: Filter;\n    pendingEvents?: boolean;\n}\n\nexport enum DuplicateStrategy {\n    Ignore = \"ignore\",\n    Replace = \"replace\",\n}\n\nexport interface IRoomTimelineData {\n    // the timeline the event was added to/removed from\n    timeline: EventTimeline;\n    // true if the event was a real-time event added to the end of the live timeline\n    liveEvent?: boolean;\n}\n\nexport interface IAddEventToTimelineOptions\n    extends Pick<IAddEventOptions, \"toStartOfTimeline\" | \"roomState\" | \"timelineWasEmpty\" | \"addToState\"> {\n    /** Whether the sync response came from cache */\n    fromCache?: boolean;\n}\n\nexport interface IAddLiveEventOptions\n    extends Pick<IAddEventToTimelineOptions, \"fromCache\" | \"roomState\" | \"timelineWasEmpty\" | \"addToState\"> {\n    /** Applies to events in the timeline only. If this is 'replace' then if a\n     * duplicate is encountered, the event passed to this function will replace\n     * the existing event in the timeline. If this is not specified, or is\n     * 'ignore', then the event passed to this function will be ignored\n     * entirely, preserving the existing event in the timeline. Events are\n     * identical based on their event ID <b>only</b>. */\n    duplicateStrategy?: DuplicateStrategy;\n}\n\ntype EmittedEvents = RoomEvent.Timeline | RoomEvent.TimelineReset;\n\nexport type EventTimelineSetHandlerMap = {\n    /**\n     * Fires whenever the timeline in a room is updated.\n     * @param event - The matrix event which caused this event to fire.\n     * @param room - The room, if any, whose timeline was updated.\n     * @param toStartOfTimeline - True if this event was added to the start\n     * @param removed - True if this event has just been removed from the timeline\n     * (beginning; oldest) of the timeline e.g. due to pagination.\n     *\n     * @param data - more data about the event\n     *\n     * @example\n     * ```\n     * matrixClient.on(\"Room.timeline\",\n     *                 function(event, room, toStartOfTimeline, removed, data) {\n     *   if (!toStartOfTimeline && data.liveEvent) {\n     *     var messageToAppend = room.timeline.[room.timeline.length - 1];\n     *   }\n     * });\n     * ```\n     */\n    [RoomEvent.Timeline]: (\n        event: MatrixEvent,\n        room: Room | undefined,\n        toStartOfTimeline: boolean | undefined,\n        removed: boolean,\n        data: IRoomTimelineData,\n    ) => void;\n    /**\n     * Fires whenever the live timeline in a room is reset.\n     *\n     * When we get a 'limited' sync (for example, after a network outage), we reset\n     * the live timeline to be empty before adding the recent events to the new\n     * timeline. This event is fired after the timeline is reset, and before the\n     * new events are added.\n     *\n     * @param room - The room whose live timeline was reset, if any\n     * @param timelineSet - timelineSet room whose live timeline was reset\n     * @param resetAllTimelines - True if all timelines were reset.\n     */\n    [RoomEvent.TimelineReset]: (\n        room: Room | undefined,\n        timelineSet: EventTimelineSet,\n        resetAllTimelines: boolean,\n    ) => void;\n};\n\nexport class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTimelineSetHandlerMap> {\n    public readonly relations: RelationsContainer;\n    private readonly timelineSupport: boolean;\n    private readonly displayPendingEvents: boolean;\n    private liveTimeline: EventTimeline;\n    private timelines: EventTimeline[];\n    private _eventIdToTimeline = new Map<string, EventTimeline>();\n    private filter?: Filter;\n\n    /**\n     * Construct a set of EventTimeline objects, typically on behalf of a given\n     * room.  A room may have multiple EventTimelineSets for different levels\n     * of filtering.  The global notification list is also an EventTimelineSet, but\n     * lacks a room.\n     *\n     * <p>This is an ordered sequence of timelines, which may or may not\n     * be continuous. Each timeline lists a series of events, as well as tracking\n     * the room state at the start and the end of the timeline (if appropriate).\n     * It also tracks forward and backward pagination tokens, as well as containing\n     * links to the next timeline in the sequence.\n     *\n     * <p>There is one special timeline - the 'live' timeline, which represents the\n     * timeline to which events are being added in real-time as they are received\n     * from the /sync API. Note that you should not retain references to this\n     * timeline - even if it is the current timeline right now, it may not remain\n     * so if the server gives us a timeline gap in /sync.\n     *\n     * <p>In order that we can find events from their ids later, we also maintain a\n     * map from event_id to timeline and index.\n     *\n     * @param room - Room for this timelineSet. May be null for non-room cases, such as the\n     * notification timeline.\n     * @param opts - Options inherited from Room.\n     * @param client - the Matrix client which owns this EventTimelineSet,\n     * can be omitted if room is specified.\n     * @param thread - the thread to which this timeline set relates.\n     * @param threadListType - the type of thread list represented, if any\n     * (e.g., All threads or My threads)\n     */\n    public constructor(\n        public readonly room: Room | undefined,\n        opts: IOpts = {},\n        client?: MatrixClient,\n        public readonly thread?: Thread,\n        public readonly threadListType: ThreadFilterType | null = null,\n    ) {\n        super();\n\n        this.timelineSupport = Boolean(opts.timelineSupport);\n        this.liveTimeline = new EventTimeline(this);\n        this.displayPendingEvents = opts.pendingEvents !== false;\n\n        // just a list - *not* ordered.\n        this.timelines = [this.liveTimeline];\n        this._eventIdToTimeline = new Map<string, EventTimeline>();\n\n        this.filter = opts.filter;\n\n        this.relations = this.room?.relations ?? new RelationsContainer(room?.client ?? client!);\n    }\n\n    /**\n     * Get all the timelines in this set\n     * @returns the timelines in this set\n     */\n    public getTimelines(): EventTimeline[] {\n        return this.timelines;\n    }\n\n    /**\n     * Get the filter object this timeline set is filtered on, if any\n     * @returns the optional filter for this timelineSet\n     */\n    public getFilter(): Filter | undefined {\n        return this.filter;\n    }\n\n    /**\n     * Set the filter object this timeline set is filtered on\n     * (passed to the server when paginating via /messages).\n     * @param filter - the filter for this timelineSet\n     */\n    public setFilter(filter?: Filter): void {\n        this.filter = filter;\n    }\n\n    /**\n     * Get the list of pending sent events for this timelineSet's room, filtered\n     * by the timelineSet's filter if appropriate.\n     *\n     * @returns A list of the sent events\n     * waiting for remote echo.\n     *\n     * @throws If `opts.pendingEventOrdering` was not 'detached'\n     */\n    public getPendingEvents(): MatrixEvent[] {\n        if (!this.room || !this.displayPendingEvents) {\n            return [];\n        }\n\n        return this.room.getPendingEvents();\n    }\n    /**\n     * Get the live timeline for this room.\n     *\n     * @returns live timeline\n     */\n    public getLiveTimeline(): EventTimeline {\n        return this.liveTimeline;\n    }\n\n    /**\n     * Set the live timeline for this room.\n     *\n     * @returns live timeline\n     */\n    public setLiveTimeline(timeline: EventTimeline): void {\n        this.liveTimeline = timeline;\n    }\n\n    /**\n     * Return the timeline (if any) this event is in.\n     * @param eventId - the eventId being sought\n     * @returns timeline\n     */\n    public eventIdToTimeline(eventId: string): EventTimeline | undefined {\n        return this._eventIdToTimeline.get(eventId);\n    }\n\n    /**\n     * Track a new event as if it were in the same timeline as an old event,\n     * replacing it.\n     * @param oldEventId -  event ID of the original event\n     * @param newEventId -  event ID of the replacement event\n     */\n    public replaceEventId(oldEventId: string, newEventId: string): void {\n        const existingTimeline = this._eventIdToTimeline.get(oldEventId);\n        if (existingTimeline) {\n            this._eventIdToTimeline.delete(oldEventId);\n            this._eventIdToTimeline.set(newEventId, existingTimeline);\n        }\n    }\n\n    /**\n     * Reset the live timeline, and start a new one.\n     *\n     * <p>This is used when /sync returns a 'limited' timeline.\n     *\n     * @param backPaginationToken -   token for back-paginating the new timeline\n     * @param forwardPaginationToken - token for forward-paginating the old live timeline,\n     * if absent or null, all timelines are reset.\n     *\n     * @remarks\n     * Fires {@link RoomEvent.TimelineReset}\n     */\n    public resetLiveTimeline(backPaginationToken?: string, forwardPaginationToken?: string): void {\n        // Each EventTimeline has RoomState objects tracking the state at the start\n        // and end of that timeline. The copies at the end of the live timeline are\n        // special because they will have listeners attached to monitor changes to\n        // the current room state, so we move this RoomState from the end of the\n        // current live timeline to the end of the new one and, if necessary,\n        // replace it with a newly created one. We also make a copy for the start\n        // of the new timeline.\n\n        // if timeline support is disabled, forget about the old timelines\n        const resetAllTimelines = !this.timelineSupport || !forwardPaginationToken;\n\n        const oldTimeline = this.liveTimeline;\n        const newTimeline = resetAllTimelines\n            ? oldTimeline.forkLive(EventTimeline.FORWARDS)\n            : oldTimeline.fork(EventTimeline.FORWARDS);\n\n        if (resetAllTimelines) {\n            this.timelines = [newTimeline];\n            this._eventIdToTimeline = new Map<string, EventTimeline>();\n        } else {\n            this.timelines.push(newTimeline);\n        }\n\n        if (forwardPaginationToken) {\n            // Now set the forward pagination token on the old live timeline\n            // so it can be forward-paginated.\n            oldTimeline.setPaginationToken(forwardPaginationToken, EventTimeline.FORWARDS);\n        }\n\n        // make sure we set the pagination token before firing timelineReset,\n        // otherwise clients which start back-paginating will fail, and then get\n        // stuck without realising that they *can* back-paginate.\n        newTimeline.setPaginationToken(backPaginationToken ?? null, EventTimeline.BACKWARDS);\n\n        // Now we can swap the live timeline to the new one.\n        this.liveTimeline = newTimeline;\n        this.emit(RoomEvent.TimelineReset, this.room, this, resetAllTimelines);\n    }\n\n    /**\n     * Get the timeline which contains the given event, if any\n     *\n     * @param eventId -  event ID to look for\n     * @returns timeline containing\n     * the given event, or null if unknown\n     */\n    public getTimelineForEvent(eventId?: string): EventTimeline | null {\n        if (eventId === null || eventId === undefined) {\n            return null;\n        }\n        const res = this._eventIdToTimeline.get(eventId);\n        return res === undefined ? null : res;\n    }\n\n    /**\n     * Get an event which is stored in our timelines\n     *\n     * @param eventId -  event ID to look for\n     * @returns the given event, or undefined if unknown\n     */\n    public findEventById(eventId: string): MatrixEvent | undefined {\n        const tl = this.getTimelineForEvent(eventId);\n        if (!tl) {\n            return undefined;\n        }\n        return tl.getEvents().find(function (ev) {\n            return ev.getId() == eventId;\n        });\n    }\n\n    /**\n     * Add a new timeline to this timeline list\n     *\n     * @returns newly-created timeline\n     */\n    public addTimeline(): EventTimeline {\n        if (!this.timelineSupport) {\n            throw new Error(\n                \"timeline support is disabled. Set the 'timelineSupport'\" +\n                    \" parameter to true when creating MatrixClient to enable\" +\n                    \" it.\",\n            );\n        }\n\n        const timeline = new EventTimeline(this);\n        this.timelines.push(timeline);\n        return timeline;\n    }\n\n    /**\n     * Add events to a timeline\n     *\n     * <p>Will fire \"Room.timeline\" for each event added.\n     *\n     * @param events - A list of events to add.\n     *\n     * @param toStartOfTimeline -   True to add these events to the start\n     * (oldest) instead of the end (newest) of the timeline. If true, the oldest\n     * event will be the <b>last</b> element of 'events'.\n     *\n     * @param timeline -   timeline to\n     *    add events to.\n     *\n     * @param paginationToken -   token for the next batch of events\n     *\n     * @remarks\n     * Fires {@link RoomEvent.Timeline}\n     *\n     */\n    public addEventsToTimeline(\n        events: MatrixEvent[],\n        toStartOfTimeline: boolean,\n        addToState: boolean,\n        timeline: EventTimeline,\n        paginationToken?: string | null,\n    ): void {\n        if (!timeline) {\n            throw new Error(\"'timeline' not specified for EventTimelineSet.addEventsToTimeline\");\n        }\n\n        if (!toStartOfTimeline && timeline == this.liveTimeline) {\n            throw new Error(\n                \"EventTimelineSet.addEventsToTimeline cannot be used for adding events to \" +\n                    \"the live timeline - use Room.addLiveEvents instead\",\n            );\n        }\n\n        if (this.filter) {\n            events = this.filter.filterRoomTimeline(events);\n            if (!events.length) {\n                return;\n            }\n        }\n\n        const direction = toStartOfTimeline ? EventTimeline.BACKWARDS : EventTimeline.FORWARDS;\n        const inverseDirection = toStartOfTimeline ? EventTimeline.FORWARDS : EventTimeline.BACKWARDS;\n\n        // Adding events to timelines can be quite complicated. The following\n        // illustrates some of the corner-cases.\n        //\n        // Let's say we start by knowing about four timelines. timeline3 and\n        // timeline4 are neighbours:\n        //\n        //    timeline1    timeline2    timeline3    timeline4\n        //      [M]          [P]          [S] <------> [T]\n        //\n        // Now we paginate timeline1, and get the following events from the server:\n        // [M, N, P, R, S, T, U].\n        //\n        // 1. First, we ignore event M, since we already know about it.\n        //\n        // 2. Next, we append N to timeline 1.\n        //\n        // 3. Next, we don't add event P, since we already know about it,\n        //    but we do link together the timelines. We now have:\n        //\n        //    timeline1    timeline2    timeline3    timeline4\n        //      [M, N] <---> [P]          [S] <------> [T]\n        //\n        // 4. Now we add event R to timeline2:\n        //\n        //    timeline1    timeline2    timeline3    timeline4\n        //      [M, N] <---> [P, R]       [S] <------> [T]\n        //\n        //    Note that we have switched the timeline we are working on from\n        //    timeline1 to timeline2.\n        //\n        // 5. We ignore event S, but again join the timelines:\n        //\n        //    timeline1    timeline2    timeline3    timeline4\n        //      [M, N] <---> [P, R] <---> [S] <------> [T]\n        //\n        // 6. We ignore event T, and the timelines are already joined, so there\n        //    is nothing to do.\n        //\n        // 7. Finally, we add event U to timeline4:\n        //\n        //    timeline1    timeline2    timeline3    timeline4\n        //      [M, N] <---> [P, R] <---> [S] <------> [T, U]\n        //\n        // The important thing to note in the above is what happened when we\n        // already knew about a given event:\n        //\n        //   - if it was appropriate, we joined up the timelines (steps 3, 5).\n        //   - in any case, we started adding further events to the timeline which\n        //       contained the event we knew about (steps 3, 5, 6).\n        //\n        //\n        // So much for adding events to the timeline. But what do we want to do\n        // with the pagination token?\n        //\n        // In the case above, we will be given a pagination token which tells us how to\n        // get events beyond 'U' - in this case, it makes sense to store this\n        // against timeline4. But what if timeline4 already had 'U' and beyond? in\n        // that case, our best bet is to throw away the pagination token we were\n        // given and stick with whatever token timeline4 had previously. In short,\n        // we want to only store the pagination token if the last event we receive\n        // is one we didn't previously know about.\n        //\n        // We make an exception for this if it turns out that we already knew about\n        // *all* of the events, and we weren't able to join up any timelines. When\n        // that happens, it means our existing pagination token is faulty, since it\n        // is only telling us what we already know. Rather than repeatedly\n        // paginating with the same token, we might as well use the new pagination\n        // token in the hope that we eventually work our way out of the mess.\n\n        let didUpdate = false;\n        let lastEventWasNew = false;\n        for (const event of events) {\n            const eventId = event.getId()!;\n\n            const existingTimeline = this._eventIdToTimeline.get(eventId);\n\n            if (!existingTimeline) {\n                // we don't know about this event yet. Just add it to the timeline.\n                this.addEventToTimeline(event, timeline, {\n                    toStartOfTimeline,\n                    addToState,\n                });\n                lastEventWasNew = true;\n                didUpdate = true;\n                continue;\n            }\n\n            lastEventWasNew = false;\n\n            if (existingTimeline == timeline) {\n                debuglog(\"Event \" + eventId + \" already in timeline \" + timeline);\n                continue;\n            }\n\n            const neighbour = timeline.getNeighbouringTimeline(direction);\n            if (neighbour) {\n                // this timeline already has a neighbour in the relevant direction;\n                // let's assume the timelines are already correctly linked up, and\n                // skip over to it.\n                //\n                // there's probably some edge-case here where we end up with an\n                // event which is in a timeline a way down the chain, and there is\n                // a break in the chain somewhere. But I can't really imagine how\n                // that would happen, so I'm going to ignore it for now.\n                //\n                if (existingTimeline == neighbour) {\n                    debuglog(\"Event \" + eventId + \" in neighbouring timeline - \" + \"switching to \" + existingTimeline);\n                } else {\n                    debuglog(\"Event \" + eventId + \" already in a different \" + \"timeline \" + existingTimeline);\n                }\n                timeline = existingTimeline;\n                continue;\n            }\n\n            // time to join the timelines.\n            logger.info(\n                \"Already have timeline for \" + eventId + \" - joining timeline \" + timeline + \" to \" + existingTimeline,\n            );\n\n            // Variables to keep the line length limited below.\n            const existingIsLive = existingTimeline === this.liveTimeline;\n            const timelineIsLive = timeline === this.liveTimeline;\n\n            const backwardsIsLive = direction === EventTimeline.BACKWARDS && existingIsLive;\n            const forwardsIsLive = direction === EventTimeline.FORWARDS && timelineIsLive;\n\n            if (backwardsIsLive || forwardsIsLive) {\n                // The live timeline should never be spliced into a non-live position.\n                // We use independent logging to better discover the problem at a glance.\n                if (backwardsIsLive) {\n                    logger.warn(\n                        \"Refusing to set a preceding existingTimeLine on our \" +\n                            \"timeline as the existingTimeLine is live (\" +\n                            existingTimeline +\n                            \")\",\n                    );\n                }\n                if (forwardsIsLive) {\n                    logger.warn(\n                        \"Refusing to set our preceding timeline on a existingTimeLine \" +\n                            \"as our timeline is live (\" +\n                            timeline +\n                            \")\",\n                    );\n                }\n                continue; // abort splicing - try next event\n            }\n\n            timeline.setNeighbouringTimeline(existingTimeline, direction);\n            existingTimeline.setNeighbouringTimeline(timeline, inverseDirection);\n\n            timeline = existingTimeline;\n            didUpdate = true;\n        }\n\n        // see above - if the last event was new to us, or if we didn't find any\n        // new information, we update the pagination token for whatever\n        // timeline we ended up on.\n        if (lastEventWasNew || !didUpdate) {\n            if (direction === EventTimeline.FORWARDS && timeline === this.liveTimeline) {\n                logger.warn({ lastEventWasNew, didUpdate }); // for debugging\n                logger.warn(\n                    `Refusing to set forwards pagination token of live timeline ` + `${timeline} to ${paginationToken}`,\n                );\n                return;\n            }\n            timeline.setPaginationToken(paginationToken ?? null, direction);\n        }\n    }\n\n    /**\n     * Add an event to the end of this live timeline.\n     *\n     * @param event - Event to be added\n     * @param options - addLiveEvent options\n     */\n    public addLiveEvent(\n        event: MatrixEvent,\n        { duplicateStrategy, fromCache, roomState, timelineWasEmpty, addToState }: IAddLiveEventOptions,\n    ): void {\n        if (this.filter) {\n            const events = this.filter.filterRoomTimeline([event]);\n            if (!events.length) {\n                return;\n            }\n        }\n\n        const timeline = this._eventIdToTimeline.get(event.getId()!);\n        if (timeline) {\n            if (duplicateStrategy === DuplicateStrategy.Replace) {\n                debuglog(\"EventTimelineSet.addLiveEvent: replacing duplicate event \" + event.getId());\n                const tlEvents = timeline.getEvents();\n                for (let j = 0; j < tlEvents.length; j++) {\n                    if (tlEvents[j].getId() === event.getId()) {\n                        // still need to set the right metadata on this event\n                        if (!roomState) {\n                            roomState = timeline.getState(EventTimeline.FORWARDS);\n                        }\n                        EventTimeline.setEventMetadata(event, roomState!, false);\n                        tlEvents[j] = event;\n\n                        // XXX: we need to fire an event when this happens.\n                        break;\n                    }\n                }\n            } else {\n                debuglog(\"EventTimelineSet.addLiveEvent: ignoring duplicate event \" + event.getId());\n            }\n            return;\n        }\n\n        this.addEventToTimeline(event, this.liveTimeline, {\n            toStartOfTimeline: false,\n            fromCache,\n            roomState,\n            timelineWasEmpty,\n            addToState,\n        });\n    }\n\n    /**\n     * Add event to the given timeline, and emit Room.timeline. Assumes\n     * we have already checked we don't know about this event.\n     *\n     * Will fire \"Room.timeline\" for each event added.\n     *\n     * @param event - the event to add\n     * @param timeline - the timeline onto which to add it\n     * @param options - addEventToTimeline options\n     *\n     * @remarks\n     * Fires {@link RoomEvent.Timeline}\n     */\n    public addEventToTimeline(\n        event: MatrixEvent,\n        timeline: EventTimeline,\n        { toStartOfTimeline, fromCache = false, roomState, timelineWasEmpty, addToState }: IAddEventToTimelineOptions,\n    ): void {\n        if (timeline.getTimelineSet() !== this) {\n            throw new Error(`EventTimelineSet.addEventToTimeline: Timeline=${timeline.toString()} does not belong \" +\n                \"in timelineSet(threadId=${this.thread?.id})`);\n        }\n\n        const eventId = event.getId()!;\n        this.relations.aggregateParentEvent(event);\n        this.relations.aggregateChildEvent(event, this);\n\n        // Make sure events don't get mixed in timelines they shouldn't be in (e.g. a\n        // threaded message should not be in the main timeline).\n        //\n        // We can only run this check for timelines with a `room` because `canContain`\n        // requires it\n        if (this.room && !this.canContain(event)) {\n            let eventDebugString = `event=${eventId}`;\n            if (event.threadRootId) {\n                eventDebugString += `(belongs to thread=${event.threadRootId})`;\n            }\n            logger.warn(\n                `EventTimelineSet.addEventToTimeline: Ignoring ${eventDebugString} that does not belong ` +\n                    `in timeline=${timeline.toString()} timelineSet(threadId=${this.thread?.id})`,\n            );\n            return;\n        }\n\n        timeline.addEvent(event, {\n            toStartOfTimeline,\n            roomState,\n            timelineWasEmpty,\n            addToState,\n        });\n        this._eventIdToTimeline.set(eventId, timeline);\n\n        const data: IRoomTimelineData = {\n            timeline: timeline,\n            liveEvent: !toStartOfTimeline && timeline == this.liveTimeline && !fromCache,\n        };\n        this.emit(RoomEvent.Timeline, event, this.room, Boolean(toStartOfTimeline), false, data);\n    }\n\n    /**\n     * Insert event to the given timeline, and emit Room.timeline. Assumes\n     * we have already checked we don't know about this event.\n     *\n     * TEMPORARY: until we have recursive relations, we need this function\n     * to exist to allow us to insert events in timeline order, which is our\n     * best guess for Sync Order.\n     * This is a copy of addEventToTimeline above, modified to insert the event\n     * after the event it relates to, and before any event with a later\n     * timestamp. This is our best guess at Sync Order.\n     *\n     * Will fire \"Room.timeline\" for each event added.\n     *\n     * @internal\n     *\n     * @remarks\n     * Fires {@link RoomEvent.Timeline}\n     */\n    public insertEventIntoTimeline(\n        event: MatrixEvent,\n        timeline: EventTimeline,\n        roomState: RoomState,\n        addToState: boolean,\n    ): void {\n        if (timeline.getTimelineSet() !== this) {\n            throw new Error(`EventTimelineSet.insertEventIntoTimeline: Timeline=${timeline.toString()} does not belong \" +\n                \"in timelineSet(threadId=${this.thread?.id})`);\n        }\n\n        const eventId = event.getId()!;\n        this.relations.aggregateParentEvent(event);\n        this.relations.aggregateChildEvent(event, this);\n\n        // Make sure events don't get mixed in timelines they shouldn't be in (e.g. a\n        // threaded message should not be in the main timeline).\n        //\n        // We can only run this check for timelines with a `room` because `canContain`\n        // requires it\n        if (this.room && !this.canContain(event)) {\n            let eventDebugString = `event=${eventId}`;\n            if (event.threadRootId) {\n                eventDebugString += `(belongs to thread=${event.threadRootId})`;\n            }\n            logger.warn(\n                `EventTimelineSet.insertEventIntoTimeline: Ignoring ${eventDebugString} that does not belong ` +\n                    `in timeline=${timeline.toString()} timelineSet(threadId=${this.thread?.id})`,\n            );\n            return;\n        }\n\n        // Find the event that this event is related to - the \"parent\"\n        const parentEventId = event.relationEventId;\n        if (!parentEventId) {\n            // Not related to anything - we just append\n            this.addEventToTimeline(event, timeline, {\n                toStartOfTimeline: false,\n                fromCache: false,\n                timelineWasEmpty: false,\n                roomState,\n                addToState,\n            });\n            return;\n        }\n\n        const parentEvent = this.findEventById(parentEventId);\n\n        const timelineEvents = timeline.getEvents();\n\n        // Start searching from the parent event, or if it's not loaded, start\n        // at the beginning and insert purely using timestamp order.\n        const parentIndex = parentEvent !== undefined ? timelineEvents.indexOf(parentEvent) : 0;\n        let insertIndex = parentIndex;\n        for (; insertIndex < timelineEvents.length; insertIndex++) {\n            const nextEvent = timelineEvents[insertIndex];\n            if (nextEvent.getTs() > event.getTs()) {\n                // We found an event later than ours, so insert before that.\n                break;\n            }\n        }\n        // If we got to the end of the loop, insertIndex points at the end of\n        // the list.\n\n        timeline.insertEvent(event, insertIndex, roomState, addToState);\n        this._eventIdToTimeline.set(eventId, timeline);\n\n        const data: IRoomTimelineData = {\n            timeline: timeline,\n            // The purpose of this method is inserting events in the middle of the\n            // timeline, so the events are, by definition, not live (whether or not\n            // we're adding them to the live timeline).\n            liveEvent: false,\n        };\n        this.emit(RoomEvent.Timeline, event, this.room, false, false, data);\n    }\n\n    /**\n     * Replaces event with ID oldEventId with one with newEventId, if oldEventId is\n     * recognised.  Otherwise, add to the live timeline.  Used to handle remote echos.\n     *\n     * @param localEvent -     the new event to be added to the timeline\n     * @param oldEventId -          the ID of the original event\n     * @param newEventId -         the ID of the replacement event\n     *\n     * @remarks\n     * Fires {@link RoomEvent.Timeline}\n     */\n    public handleRemoteEcho(localEvent: MatrixEvent, oldEventId: string, newEventId: string): void {\n        // XXX: why don't we infer newEventId from localEvent?\n        const existingTimeline = this._eventIdToTimeline.get(oldEventId);\n        if (existingTimeline) {\n            this._eventIdToTimeline.delete(oldEventId);\n            this._eventIdToTimeline.set(newEventId, existingTimeline);\n        } else if (!this.filter || this.filter.filterRoomTimeline([localEvent]).length) {\n            this.addEventToTimeline(localEvent, this.liveTimeline, {\n                toStartOfTimeline: false,\n                addToState: false,\n            });\n        }\n    }\n\n    /**\n     * Removes a single event from this room.\n     *\n     * @param eventId -  The id of the event to remove\n     *\n     * @returns the removed event, or null if the event was not found\n     * in this room.\n     */\n    public removeEvent(eventId: string): MatrixEvent | null {\n        const timeline = this._eventIdToTimeline.get(eventId);\n        if (!timeline) {\n            return null;\n        }\n\n        const removed = timeline.removeEvent(eventId);\n        if (removed) {\n            this._eventIdToTimeline.delete(eventId);\n            const data = {\n                timeline: timeline,\n            };\n            this.emit(RoomEvent.Timeline, removed, this.room, undefined, true, data);\n        }\n        return removed;\n    }\n\n    /**\n     * Determine where two events appear in the timeline relative to one another\n     *\n     * @param eventId1 -   The id of the first event\n     * @param eventId2 -   The id of the second event\n\n     * @returns -1 if eventId1 precedes eventId2, and +1 eventId1 succeeds\n     * eventId2. 0 if they are the same event; null if we can't tell (either\n     * because we don't know about one of the events, or because they are in\n     * separate timelines which don't join up).\n     */\n    public compareEventOrdering(eventId1: string, eventId2: string): number | null {\n        if (eventId1 == eventId2) {\n            // optimise this case\n            return 0;\n        }\n\n        const timeline1 = this._eventIdToTimeline.get(eventId1);\n        const timeline2 = this._eventIdToTimeline.get(eventId2);\n\n        if (timeline1 === undefined) {\n            return null;\n        }\n        if (timeline2 === undefined) {\n            return null;\n        }\n\n        if (timeline1 === timeline2) {\n            // both events are in the same timeline - figure out their relative indices\n            let idx1: number | undefined = undefined;\n            let idx2: number | undefined = undefined;\n            const events = timeline1.getEvents();\n            for (let idx = 0; idx < events.length && (idx1 === undefined || idx2 === undefined); idx++) {\n                const evId = events[idx].getId();\n                if (evId == eventId1) {\n                    idx1 = idx;\n                }\n                if (evId == eventId2) {\n                    idx2 = idx;\n                }\n            }\n            const difference = idx1! - idx2!;\n\n            // Return the sign of difference.\n            if (difference < 0) {\n                return -1;\n            } else if (difference > 0) {\n                return 1;\n            } else {\n                return 0;\n            }\n        }\n\n        // the events are in different timelines. Iterate through the\n        // linkedlist to see which comes first.\n\n        // first work forwards from timeline1\n        let tl: EventTimeline | null = timeline1;\n        while (tl) {\n            if (tl === timeline2) {\n                // timeline1 is before timeline2\n                return -1;\n            }\n            tl = tl.getNeighbouringTimeline(EventTimeline.FORWARDS);\n        }\n\n        // now try backwards from timeline1\n        tl = timeline1;\n        while (tl) {\n            if (tl === timeline2) {\n                // timeline2 is before timeline1\n                return 1;\n            }\n            tl = tl.getNeighbouringTimeline(EventTimeline.BACKWARDS);\n        }\n\n        // the timelines are not contiguous.\n        return null;\n    }\n\n    /**\n     * Determine whether a given event can sanely be added to this event timeline set,\n     * for timeline sets relating to a thread, only return true for events in the same\n     * thread timeline, for timeline sets not relating to a thread only return true\n     * for events which should be shown in the main room timeline.\n     * Requires the `room` property to have been set at EventTimelineSet construction time.\n     *\n     * @param event - the event to check whether it belongs to this timeline set.\n     * @throws Error if `room` was not set when constructing this timeline set.\n     * @returns whether the event belongs to this timeline set.\n     */\n    public canContain(event: MatrixEvent): boolean {\n        if (!this.room) {\n            throw new Error(\n                \"Cannot call `EventTimelineSet::canContain without a `room` set. \" +\n                    \"Set the room when creating the EventTimelineSet to call this method.\",\n            );\n        }\n\n        const { threadId, shouldLiveInRoom, shouldLiveInThread } = this.room.eventShouldLiveIn(event);\n\n        if (this.thread) {\n            return this.thread.id === threadId;\n        }\n\n        if (!shouldLiveInRoom && !shouldLiveInThread) {\n            logger.warn(\n                `EventTimelineSet:canContain event encountered which cannot be added to any timeline roomId=${\n                    this.room?.roomId\n                } eventId=${event.getId()} threadId=${event.threadRootId}`,\n            );\n        }\n\n        return shouldLiveInRoom;\n    }\n}\n","/*\nCopyright 2016 - 2021 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { type IMarkerFoundOptions, RoomState } from \"./room-state.ts\";\nimport { type EventTimelineSet } from \"./event-timeline-set.ts\";\nimport { type MatrixEvent } from \"./event.ts\";\nimport { type Filter } from \"../filter.ts\";\nimport { EventType } from \"../@types/event.ts\";\n\nexport interface IInitialiseStateOptions extends Pick<IMarkerFoundOptions, \"timelineWasEmpty\"> {\n    // This is a separate interface without any extra stuff currently added on\n    // top of `IMarkerFoundOptions` just because it feels like they have\n    // different concerns. One shouldn't necessarily look to add to\n    // `IMarkerFoundOptions` just because they want to add an extra option to\n    // `initialiseState`.\n}\n\nexport interface IAddEventOptions extends Pick<IMarkerFoundOptions, \"timelineWasEmpty\"> {\n    /** Whether to insert the new event at the start of the timeline where the\n     * oldest events are (timeline is in chronological order, oldest to most\n     * recent) */\n    toStartOfTimeline: boolean;\n    /** The state events to reconcile metadata from */\n    roomState?: RoomState;\n    /** Whether to add timeline events to the state as was done in legacy sync v2.\n     * If true then timeline events will be added to the state.\n     * In sync v2 with org.matrix.msc4222.use_state_after and simplified sliding sync,\n     * all state arrives explicitly and timeline events should not be added. */\n    addToState: boolean;\n}\n\nexport enum Direction {\n    Backward = \"b\",\n    Forward = \"f\",\n}\n\nexport class EventTimeline {\n    /**\n     * Symbolic constant for methods which take a 'direction' argument:\n     * refers to the start of the timeline, or backwards in time.\n     */\n    public static readonly BACKWARDS = Direction.Backward;\n\n    /**\n     * Symbolic constant for methods which take a 'direction' argument:\n     * refers to the end of the timeline, or forwards in time.\n     */\n    public static readonly FORWARDS = Direction.Forward;\n\n    /**\n     * Static helper method to set sender and target properties\n     *\n     * @param event -   the event whose metadata is to be set\n     * @param stateContext -  the room state to be queried\n     * @param toStartOfTimeline -  if true the event's forwardLooking flag is set false\n     */\n    public static setEventMetadata(event: MatrixEvent, stateContext: RoomState, toStartOfTimeline: boolean): void {\n        event.setMetadata(stateContext, toStartOfTimeline);\n    }\n\n    private readonly roomId: string | null;\n    private readonly name: string;\n    private events: MatrixEvent[] = [];\n    private baseIndex = 0;\n\n    private startState?: RoomState;\n    private endState?: RoomState;\n    // If we have a roomId then we delegate pagination token storage to the room state objects `startState` and\n    // `endState`, but for things like the notification timeline which mix multiple rooms we store the tokens ourselves.\n    private startToken: string | null = null;\n    private endToken: string | null = null;\n\n    private prevTimeline: EventTimeline | null = null;\n    private nextTimeline: EventTimeline | null = null;\n    public paginationRequests: Record<Direction, Promise<boolean> | null> = {\n        [Direction.Backward]: null,\n        [Direction.Forward]: null,\n    };\n\n    /**\n     * Construct a new EventTimeline\n     *\n     * <p>An EventTimeline represents a contiguous sequence of events in a room.\n     *\n     * <p>As well as keeping track of the events themselves, it stores the state of\n     * the room at the beginning and end of the timeline, and pagination tokens for\n     * going backwards and forwards in the timeline.\n     *\n     * <p>In order that clients can meaningfully maintain an index into a timeline,\n     * the EventTimeline object tracks a 'baseIndex'. This starts at zero, but is\n     * incremented when events are prepended to the timeline. The index of an event\n     * relative to baseIndex therefore remains constant.\n     *\n     * <p>Once a timeline joins up with its neighbour, they are linked together into a\n     * doubly-linked list.\n     *\n     * @param eventTimelineSet - the set of timelines this is part of\n     */\n    public constructor(private readonly eventTimelineSet: EventTimelineSet) {\n        this.roomId = eventTimelineSet.room?.roomId ?? null;\n        if (this.roomId) {\n            this.startState = new RoomState(this.roomId);\n            this.endState = new RoomState(this.roomId);\n        }\n\n        // this is used by client.js\n        this.paginationRequests = { b: null, f: null };\n\n        this.name = this.roomId + \":\" + new Date().toISOString();\n    }\n\n    /**\n     * Initialise the start and end state with the given events\n     *\n     * <p>This can only be called before any events are added.\n     *\n     * @param stateEvents - list of state events to initialise the\n     * state with.\n     * @throws Error if an attempt is made to call this after addEvent is called.\n     */\n    public initialiseState(stateEvents: MatrixEvent[], { timelineWasEmpty }: IInitialiseStateOptions = {}): void {\n        if (this.events.length > 0) {\n            throw new Error(\"Cannot initialise state after events are added\");\n        }\n\n        this.startState?.setStateEvents(stateEvents, { timelineWasEmpty });\n        this.endState?.setStateEvents(stateEvents, { timelineWasEmpty });\n    }\n\n    /**\n     * Forks the (live) timeline, taking ownership of the existing directional state of this timeline.\n     * All attached listeners will keep receiving state updates from the new live timeline state.\n     * The end state of this timeline gets replaced with an independent copy of the current RoomState,\n     * and will need a new pagination token if it ever needs to paginate forwards.\n\n     * @param direction -   EventTimeline.BACKWARDS to get the state at the\n     *   start of the timeline; EventTimeline.FORWARDS to get the state at the end\n     *   of the timeline.\n     *\n     * @returns the new timeline\n     */\n    public forkLive(direction: Direction): EventTimeline {\n        const forkState = this.getState(direction);\n        const timeline = new EventTimeline(this.eventTimelineSet);\n        timeline.startState = forkState?.clone();\n        // Now clobber the end state of the new live timeline with that from the\n        // previous live timeline. It will be identical except that we'll keep\n        // using the same RoomMember objects for the 'live' set of members with any\n        // listeners still attached\n        timeline.endState = forkState;\n        // Firstly, we just stole the current timeline's end state, so it needs a new one.\n        // Make an immutable copy of the state so back pagination will get the correct sentinels.\n        this.endState = forkState?.clone();\n        return timeline;\n    }\n\n    /**\n     * Creates an independent timeline, inheriting the directional state from this timeline.\n     *\n     * @param direction -   EventTimeline.BACKWARDS to get the state at the\n     *   start of the timeline; EventTimeline.FORWARDS to get the state at the end\n     *   of the timeline.\n     *\n     * @returns the new timeline\n     */\n    public fork(direction: Direction): EventTimeline {\n        const forkState = this.getState(direction);\n        const timeline = new EventTimeline(this.eventTimelineSet);\n        timeline.startState = forkState?.clone();\n        timeline.endState = forkState?.clone();\n        return timeline;\n    }\n\n    /**\n     * Get the ID of the room for this timeline\n     * @returns room ID\n     */\n    public getRoomId(): string | null {\n        return this.roomId;\n    }\n\n    /**\n     * Get the filter for this timeline's timelineSet (if any)\n     * @returns filter\n     */\n    public getFilter(): Filter | undefined {\n        return this.eventTimelineSet.getFilter();\n    }\n\n    /**\n     * Get the timelineSet for this timeline\n     * @returns timelineSet\n     */\n    public getTimelineSet(): EventTimelineSet {\n        return this.eventTimelineSet;\n    }\n\n    /**\n     * Get the base index.\n     *\n     * <p>This is an index which is incremented when events are prepended to the\n     * timeline. An individual event therefore stays at the same index in the array\n     * relative to the base index (although note that a given event's index may\n     * well be less than the base index, thus giving that event a negative relative\n     * index).\n     */\n    public getBaseIndex(): number {\n        return this.baseIndex;\n    }\n\n    /**\n     * Get the list of events in this context\n     *\n     * @returns An array of MatrixEvents\n     */\n    public getEvents(): MatrixEvent[] {\n        return this.events;\n    }\n\n    /**\n     * Get the room state at the start/end of the timeline\n     *\n     * @param direction -   EventTimeline.BACKWARDS to get the state at the\n     *   start of the timeline; EventTimeline.FORWARDS to get the state at the end\n     *   of the timeline.\n     *\n     * @returns state at the start/end of the timeline\n     */\n    public getState(direction: Direction): RoomState | undefined {\n        if (direction == EventTimeline.BACKWARDS) {\n            return this.startState;\n        } else if (direction == EventTimeline.FORWARDS) {\n            return this.endState;\n        } else {\n            throw new Error(\"Invalid direction '\" + direction + \"'\");\n        }\n    }\n\n    /**\n     * Get a pagination token\n     *\n     * @param direction - EventTimeline.BACKWARDS to get the pagination\n     *   token for going backwards in time; EventTimeline.FORWARDS to get the\n     *   pagination token for going forwards in time.\n     *\n     * @returns pagination token\n     */\n    public getPaginationToken(direction: Direction): string | null {\n        if (this.roomId) {\n            return this.getState(direction)!.paginationToken;\n        } else if (direction === Direction.Backward) {\n            return this.startToken;\n        } else {\n            return this.endToken;\n        }\n    }\n\n    /**\n     * Set a pagination token\n     *\n     * @param token -       pagination token\n     *\n     * @param direction -    EventTimeline.BACKWARDS to set the pagination\n     *   token for going backwards in time; EventTimeline.FORWARDS to set the\n     *   pagination token for going forwards in time.\n     */\n    public setPaginationToken(token: string | null, direction: Direction): void {\n        if (this.roomId) {\n            this.getState(direction)!.paginationToken = token;\n        } else if (direction === Direction.Backward) {\n            this.startToken = token;\n        } else {\n            this.endToken = token;\n        }\n    }\n\n    /**\n     * Get the next timeline in the series\n     *\n     * @param direction - EventTimeline.BACKWARDS to get the previous\n     *   timeline; EventTimeline.FORWARDS to get the next timeline.\n     *\n     * @returns previous or following timeline, if they have been\n     * joined up.\n     */\n    public getNeighbouringTimeline(direction: Direction): EventTimeline | null {\n        if (direction == EventTimeline.BACKWARDS) {\n            return this.prevTimeline;\n        } else if (direction == EventTimeline.FORWARDS) {\n            return this.nextTimeline;\n        } else {\n            throw new Error(\"Invalid direction '\" + direction + \"'\");\n        }\n    }\n\n    /**\n     * Set the next timeline in the series\n     *\n     * @param neighbour - previous/following timeline\n     *\n     * @param direction - EventTimeline.BACKWARDS to set the previous\n     *   timeline; EventTimeline.FORWARDS to set the next timeline.\n     *\n     * @throws Error if an attempt is made to set the neighbouring timeline when\n     * it is already set.\n     */\n    public setNeighbouringTimeline(neighbour: EventTimeline, direction: Direction): void {\n        if (this.getNeighbouringTimeline(direction)) {\n            throw new Error(\n                \"timeline already has a neighbouring timeline - \" +\n                    \"cannot reset neighbour (direction: \" +\n                    direction +\n                    \")\",\n            );\n        }\n\n        if (direction == EventTimeline.BACKWARDS) {\n            this.prevTimeline = neighbour;\n        } else if (direction == EventTimeline.FORWARDS) {\n            this.nextTimeline = neighbour;\n        } else {\n            throw new Error(\"Invalid direction '\" + direction + \"'\");\n        }\n\n        // make sure we don't try to paginate this timeline\n        this.setPaginationToken(null, direction);\n    }\n\n    /**\n     * Add a new event to the timeline, and update the state\n     *\n     * @param event - new event\n     * @param options - addEvent options\n     */\n    public addEvent(\n        event: MatrixEvent,\n        { toStartOfTimeline, roomState, timelineWasEmpty, addToState }: IAddEventOptions,\n    ): void {\n        if (!roomState) {\n            roomState = toStartOfTimeline ? this.startState : this.endState;\n        }\n\n        const timelineSet = this.getTimelineSet();\n\n        if (timelineSet.room) {\n            EventTimeline.setEventMetadata(event, roomState!, toStartOfTimeline);\n\n            // modify state but only on unfiltered timelineSets\n            if (addToState && event.isState() && timelineSet.room.getUnfilteredTimelineSet() === timelineSet) {\n                roomState?.setStateEvents([event], { timelineWasEmpty });\n                // it is possible that the act of setting the state event means we\n                // can set more metadata (specifically sender/target props), so try\n                // it again if the prop wasn't previously set. It may also mean that\n                // the sender/target is updated (if the event set was a room member event)\n                // so we want to use the *updated* member (new avatar/name) instead.\n                //\n                // However, we do NOT want to do this on member events if we're going\n                // back in time, else we'll set the .sender value for BEFORE the given\n                // member event, whereas we want to set the .sender value for the ACTUAL\n                // member event itself.\n                if (!event.sender || (event.getType() === EventType.RoomMember && !toStartOfTimeline)) {\n                    EventTimeline.setEventMetadata(event, roomState!, toStartOfTimeline);\n                }\n            }\n        }\n\n        let insertIndex: number;\n\n        if (toStartOfTimeline) {\n            insertIndex = 0;\n        } else {\n            insertIndex = this.events.length;\n        }\n\n        this.events.splice(insertIndex, 0, event); // insert element\n        if (toStartOfTimeline) {\n            this.baseIndex++;\n        }\n    }\n\n    /**\n     * Insert a new event into the timeline, and update the state.\n     *\n     * TEMPORARY: until we have recursive relations, we need this function\n     * to exist to allow us to insert events in timeline order, which is our\n     * best guess for Sync Order.\n     * This is a copy of addEvent above, modified to allow inserting an event at\n     * a specific index.\n     *\n     * @internal\n     */\n    public insertEvent(event: MatrixEvent, insertIndex: number, roomState: RoomState, addToState: boolean): void {\n        const timelineSet = this.getTimelineSet();\n\n        if (timelineSet.room) {\n            EventTimeline.setEventMetadata(event, roomState, false);\n\n            // modify state but only on unfiltered timelineSets\n            if (addToState && event.isState() && timelineSet.room.getUnfilteredTimelineSet() === timelineSet) {\n                roomState.setStateEvents([event], {});\n                // it is possible that the act of setting the state event means we\n                // can set more metadata (specifically sender/target props), so try\n                // it again if the prop wasn't previously set. It may also mean that\n                // the sender/target is updated (if the event set was a room member event)\n                // so we want to use the *updated* member (new avatar/name) instead.\n                //\n                // However, we do NOT want to do this on member events if we're going\n                // back in time, else we'll set the .sender value for BEFORE the given\n                // member event, whereas we want to set the .sender value for the ACTUAL\n                // member event itself.\n                if (!event.sender || event.getType() === EventType.RoomMember) {\n                    EventTimeline.setEventMetadata(event, roomState, false);\n                }\n            }\n        }\n\n        this.events.splice(insertIndex, 0, event); // insert element\n    }\n\n    /**\n     * Remove an event from the timeline\n     *\n     * @param eventId -  ID of event to be removed\n     * @returns removed event, or null if not found\n     */\n    public removeEvent(eventId: string): MatrixEvent | null {\n        for (let i = this.events.length - 1; i >= 0; i--) {\n            const ev = this.events[i];\n            if (ev.getId() == eventId) {\n                this.events.splice(i, 1);\n                if (i < this.baseIndex) {\n                    this.baseIndex--;\n                }\n                return ev;\n            }\n        }\n        return null;\n    }\n\n    /**\n     * Return a string to identify this timeline, for debugging\n     *\n     * @returns name for this timeline\n     */\n    public toString(): string {\n        return this.name;\n    }\n}\n","/*\nCopyright 2015 - 2023 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\n/**\n * This is an internal module. See {@link MatrixEvent} and {@link RoomEvent} for\n * the public classes.\n */\n\nimport { type ExtensibleEvent, ExtensibleEvents, type Optional } from \"matrix-events-sdk\";\n\nimport type { IEventDecryptionResult } from \"../@types/crypto.ts\";\nimport { logger } from \"../logger.ts\";\nimport {\n    EVENT_VISIBILITY_CHANGE_TYPE,\n    EventType,\n    type MsgType,\n    RelationType,\n    ToDeviceMessageId,\n    UNSIGNED_THREAD_ID_FIELD,\n    UNSIGNED_MEMBERSHIP_FIELD,\n} from \"../@types/event.ts\";\nimport { deepSortedObjectEntries, internaliseString } from \"../utils.ts\";\nimport { type RoomMember } from \"./room-member.ts\";\nimport { type Thread, THREAD_RELATION_TYPE, ThreadEvent, type ThreadEventHandlerMap } from \"./thread.ts\";\nimport { type IActionsObject } from \"../pushprocessor.ts\";\nimport { TypedReEmitter } from \"../ReEmitter.ts\";\nimport { type MatrixError } from \"../http-api/index.ts\";\nimport { TypedEventEmitter } from \"./typed-event-emitter.ts\";\nimport { type EventStatus } from \"./event-status.ts\";\nimport { type CryptoBackend, DecryptionError } from \"../common-crypto/CryptoBackend.ts\";\nimport { type IAnnotatedPushRule } from \"../@types/PushRules.ts\";\nimport { type Room } from \"./room.ts\";\nimport { EventTimeline } from \"./event-timeline.ts\";\nimport { type Membership } from \"../@types/membership.ts\";\nimport { DecryptionFailureCode } from \"../crypto-api/index.ts\";\nimport { type RoomState } from \"./room-state.ts\";\nimport { type EmptyObject } from \"../@types/common.ts\";\n\nexport { EventStatus } from \"./event-status.ts\";\n\n/* eslint-disable camelcase */\nexport interface IContent {\n    [key: string]: any;\n    \"msgtype\"?: MsgType | string;\n    \"membership\"?: Membership;\n    \"avatar_url\"?: string;\n    \"displayname\"?: string;\n    \"m.relates_to\"?: IEventRelation;\n\n    \"m.mentions\"?: IMentions;\n}\n\ntype StrippedState = Required<Pick<IEvent, \"content\" | \"state_key\" | \"type\" | \"sender\">>;\n\nexport interface IUnsigned {\n    [key: string]: any;\n    \"age\"?: number;\n    \"prev_sender\"?: string;\n    \"prev_content\"?: IContent;\n    \"redacted_because\"?: IEvent;\n    \"replaces_state\"?: string;\n    \"transaction_id\"?: string;\n    \"invite_room_state\"?: StrippedState[];\n    \"m.relations\"?: Record<RelationType | string, any>; // No common pattern for aggregated relations\n    [UNSIGNED_THREAD_ID_FIELD.name]?: string;\n}\n\nexport interface IThreadBundledRelationship {\n    latest_event: IEvent;\n    count: number;\n    current_user_participated?: boolean;\n}\n\nexport interface IEvent {\n    event_id: string;\n    type: string;\n    content: IContent;\n    sender: string;\n    room_id?: string;\n    origin_server_ts: number;\n    txn_id?: string;\n    state_key?: string;\n    membership?: Membership;\n    unsigned: IUnsigned;\n    redacts?: string;\n}\n\nexport interface IAggregatedRelation {\n    origin_server_ts: number;\n    event_id?: string;\n    sender?: string;\n    type?: string;\n    count?: number;\n    key?: string;\n}\n\nexport interface IEventRelation {\n    \"rel_type\"?: RelationType | string;\n    \"event_id\"?: string;\n    \"is_falling_back\"?: boolean;\n    \"m.in_reply_to\"?: {\n        event_id?: string;\n    };\n    \"key\"?: string;\n}\n\nexport interface IMentions {\n    user_ids?: string[];\n    room?: boolean;\n}\n\nexport interface PushDetails {\n    rule?: IAnnotatedPushRule;\n    actions?: IActionsObject;\n}\n\n/**\n * When an event is a visibility change event, as per MSC3531,\n * the visibility change implied by the event.\n */\nexport interface IVisibilityChange {\n    /**\n     * If `true`, the target event should be made visible.\n     * Otherwise, it should be hidden.\n     */\n    visible: boolean;\n\n    /**\n     * The event id affected.\n     */\n    eventId: string;\n\n    /**\n     * Optionally, a human-readable reason explaining why\n     * the event was hidden. Ignored if the event was made\n     * visible.\n     */\n    reason: string | null;\n}\n\nexport interface IMarkedUnreadEvent {\n    unread: boolean;\n}\n\nexport interface IClearEvent {\n    room_id?: string;\n    type: string;\n    content: Omit<IContent, \"membership\" | \"avatar_url\" | \"displayname\" | \"m.relates_to\">;\n    unsigned?: IUnsigned;\n}\n/* eslint-enable camelcase */\n\ninterface IKeyRequestRecipient {\n    userId: string;\n    deviceId: \"*\" | string;\n}\n\nexport interface IDecryptOptions {\n    /** Whether to emit {@link MatrixEventEvent.Decrypted} events on successful decryption. Defaults to true.\n     */\n    emit?: boolean;\n\n    /**\n     * True if this is a retry, after receiving an update to the session key. (Enables more logging.)\n     *\n     * This is only intended for use within the js-sdk.\n     *\n     * @internal\n     */\n    isRetry?: boolean;\n\n    /**\n     * Whether the message should be re-decrypted if it was previously successfully decrypted with an untrusted key.\n     * Defaults to `false`.\n     */\n    forceRedecryptIfUntrusted?: boolean;\n}\n\n/**\n * Message hiding, as specified by https://github.com/matrix-org/matrix-doc/pull/3531.\n */\nexport type MessageVisibility = IMessageVisibilityHidden | IMessageVisibilityVisible;\n/**\n * Variant of `MessageVisibility` for the case in which the message should be displayed.\n */\nexport interface IMessageVisibilityVisible {\n    readonly visible: true;\n}\n/**\n * Variant of `MessageVisibility` for the case in which the message should be hidden.\n */\nexport interface IMessageVisibilityHidden {\n    readonly visible: false;\n    /**\n     * Optionally, a human-readable reason to show to the user indicating why the\n     * message has been hidden (e.g. \"Message Pending Moderation\").\n     */\n    readonly reason: string | null;\n}\n// A singleton implementing `IMessageVisibilityVisible`.\nconst MESSAGE_VISIBLE: IMessageVisibilityVisible = Object.freeze({ visible: true });\n\nexport enum MatrixEventEvent {\n    /**\n     * An event has been decrypted, or we have failed to decrypt it.\n     *\n     * The payload consists of:\n     *\n     *  * `event` - The {@link MatrixEvent} which we attempted to decrypt.\n     *\n     *  * `err` - The error that occurred during decryption, or `undefined` if no error occurred.\n     *     Avoid use of this: {@link MatrixEvent.decryptionFailureReason} is more useful.\n     */\n    Decrypted = \"Event.decrypted\",\n\n    BeforeRedaction = \"Event.beforeRedaction\",\n    VisibilityChange = \"Event.visibilityChange\",\n    LocalEventIdReplaced = \"Event.localEventIdReplaced\",\n    Status = \"Event.status\",\n    Replaced = \"Event.replaced\",\n    RelationsCreated = \"Event.relationsCreated\",\n    SentinelUpdated = \"Event.sentinelUpdated\",\n}\n\nexport type MatrixEventEmittedEvents = MatrixEventEvent | ThreadEvent.Update;\n\nexport type MatrixEventHandlerMap = {\n    [MatrixEventEvent.Decrypted]: (event: MatrixEvent, err?: Error) => void;\n    [MatrixEventEvent.BeforeRedaction]: (event: MatrixEvent, redactionEvent: MatrixEvent) => void;\n    [MatrixEventEvent.VisibilityChange]: (event: MatrixEvent, visible: boolean) => void;\n    [MatrixEventEvent.LocalEventIdReplaced]: (event: MatrixEvent) => void;\n    [MatrixEventEvent.Status]: (event: MatrixEvent, status: EventStatus | null) => void;\n    [MatrixEventEvent.Replaced]: (event: MatrixEvent) => void;\n    [MatrixEventEvent.RelationsCreated]: (relationType: string, eventType: string) => void;\n    [MatrixEventEvent.SentinelUpdated]: () => void;\n} & Pick<ThreadEventHandlerMap, ThreadEvent.Update>;\n\nexport class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, MatrixEventHandlerMap> {\n    // applied push rule and action for this event\n    private pushDetails: PushDetails = {};\n    private _replacingEvent: MatrixEvent | null = null;\n    private _localRedactionEvent: MatrixEvent | null = null;\n    private _isCancelled = false;\n    private clearEvent?: IClearEvent;\n\n    /* Message hiding, as specified by https://github.com/matrix-org/matrix-doc/pull/3531.\n\n    Note: We're returning this object, so any value stored here MUST be frozen.\n    */\n    private visibility: MessageVisibility = MESSAGE_VISIBLE;\n\n    // Not all events will be extensible-event compatible, so cache a flag in\n    // addition to a falsy cached event value. We check the flag later on in\n    // a public getter to decide if the cache is valid.\n    private _hasCachedExtEv = false;\n    private _cachedExtEv: Optional<ExtensibleEvent> = undefined;\n\n    /** If we failed to decrypt this event, the reason for the failure. Otherwise, `null`. */\n    private _decryptionFailureReason: DecryptionFailureCode | null = null;\n\n    /* curve25519 key which we believe belongs to the sender of the event. See\n     * getSenderKey()\n     */\n    private senderCurve25519Key: string | null = null;\n\n    /* ed25519 key which the sender of this event (for olm) or the creator of\n     * the megolm session (for megolm) claims to own. See getClaimedEd25519Key()\n     */\n    private claimedEd25519Key: string | null = null;\n\n    /* curve25519 keys of devices involved in telling us about the\n     * senderCurve25519Key and claimedEd25519Key.\n     * See getForwardingCurve25519KeyChain().\n     */\n    private forwardingCurve25519KeyChain: string[] = [];\n\n    /* where the decryption key is untrusted\n     */\n    private untrusted: boolean | null = null;\n\n    /* if we have a process decrypting this event, a Promise which resolves\n     * when it is finished. Normally null.\n     */\n    private decryptionPromise: Promise<void> | null = null;\n\n    /* flag to indicate if we should retry decrypting this event after the\n     * first attempt (eg, we have received new data which means that a second\n     * attempt may succeed)\n     */\n    private retryDecryption = false;\n\n    /* The txnId with which this event was sent if it was during this session,\n     * allows for a unique ID which does not change when the event comes back down sync.\n     */\n    private txnId?: string;\n\n    /**\n     * A reference to the thread this event belongs to\n     */\n    private thread?: Thread;\n    private threadId?: string;\n\n    /* Set an approximate timestamp for the event relative the local clock.\n     * This will inherently be approximate because it doesn't take into account\n     * the time between the server putting the 'age' field on the event as it sent\n     * it to us and the time we're now constructing this event, but that's better\n     * than assuming the local clock is in sync with the origin HS's clock.\n     */\n    public localTimestamp: number;\n\n    /**\n     * The room member who sent this event, or null e.g.\n     * this is a presence event. This is only guaranteed to be set for events that\n     * appear in a timeline, ie. do not guarantee that it will be set on state\n     * events.\n     * @privateRemarks\n     * Should be read-only\n     */\n    public sender: RoomMember | null = null;\n\n    /**\n     * The room member who is the target of this event, e.g.\n     * the invitee, the person being banned, etc.\n     * @privateRemarks\n     * Should be read-only\n     */\n    public target: RoomMember | null = null;\n\n    /**\n     * Update the sentinels and forwardLooking flag for this event.\n     * @param stateContext -  the room state to be queried\n     * @param toStartOfTimeline -  if true the event's forwardLooking flag is set false\n     * @internal\n     */\n    public setMetadata(stateContext: RoomState, toStartOfTimeline: boolean): void {\n        // If an event is an m.room.member state event then we should set the sentinels again in case setEventMetadata\n        // was already called before the state was applied and thus the sentinel points at the member from before this event.\n        const affectsSelf =\n            this.isState() && this.getType() === EventType.RoomMember && this.getSender() === this.getStateKey();\n\n        let changed = false;\n        // When we try to generate a sentinel member before we have that member\n        // in the members object, we still generate a sentinel but it doesn't\n        // have a membership event, so test to see if events.member is set. We\n        // check this to avoid overriding non-sentinel members by sentinel ones\n        // when adding the event to a filtered timeline\n        if (affectsSelf || !this.sender?.events?.member) {\n            const newSender = stateContext.getSentinelMember(this.getSender()!);\n            if (newSender !== this.sender) changed = true;\n            this.sender = newSender;\n        }\n        if (affectsSelf || (!this.target?.events?.member && this.getType() === EventType.RoomMember)) {\n            const newTarget = stateContext.getSentinelMember(this.getStateKey()!);\n            if (newTarget !== this.target) changed = true;\n            this.target = newTarget;\n        }\n\n        if (this.isState()) {\n            // room state has no concept of 'old' or 'current', but we want the\n            // room state to regress back to previous values if toStartOfTimeline\n            // is set, which means inspecting prev_content if it exists. This\n            // is done by toggling the forwardLooking flag.\n            if (toStartOfTimeline) {\n                this.forwardLooking = false;\n            }\n        }\n\n        if (changed) {\n            this.emit(MatrixEventEvent.SentinelUpdated);\n        }\n    }\n\n    /**\n     * The sending status of the event.\n     * @privateRemarks\n     * Should be read-only\n     */\n    public status: EventStatus | null = null;\n    /**\n     * most recent error associated with sending the event, if any\n     * @privateRemarks\n     * Should be read-only. May not be a MatrixError.\n     */\n    public error: MatrixError | null = null;\n    /**\n     * True if this event is 'forward looking', meaning\n     * that getDirectionalContent() will return event.content and not event.prev_content.\n     * Only state events may be backwards looking\n     * Default: true. <strong>This property is experimental and may change.</strong>\n     * @privateRemarks\n     * Should be read-only\n     */\n    public forwardLooking = true;\n\n    private readonly reEmitter: TypedReEmitter<MatrixEventEmittedEvents, MatrixEventHandlerMap>;\n\n    /**\n     * Construct a Matrix Event object\n     *\n     * @param event - The raw (possibly encrypted) event. <b>Do not access\n     * this property</b> directly unless you absolutely have to. Prefer the getter\n     * methods defined on this class. Using the getter methods shields your app\n     * from changes to event JSON between Matrix versions.\n     */\n    public constructor(public event: Partial<IEvent> = {}) {\n        super();\n\n        // intern the values of matrix events to force share strings and reduce the\n        // amount of needless string duplication. This can save moderate amounts of\n        // memory (~10% on a 350MB heap).\n        // 'membership' at the event level (rather than the content level) is a legacy\n        // field that Element never otherwise looks at, but it will still take up a lot\n        // of space if we don't intern it.\n        ([\"state_key\", \"type\", \"sender\", \"room_id\", \"membership\"] as const).forEach((prop) => {\n            if (typeof event[prop] !== \"string\") return;\n            event[prop] = internaliseString(event[prop]!);\n        });\n\n        ([\"membership\", \"avatar_url\", \"displayname\"] as const).forEach((prop) => {\n            if (typeof event.content?.[prop] !== \"string\") return;\n            event.content[prop] = internaliseString(event.content[prop]!);\n        });\n\n        ([\"rel_type\"] as const).forEach((prop) => {\n            if (typeof event.content?.[\"m.relates_to\"]?.[prop] !== \"string\") return;\n            event.content[\"m.relates_to\"][prop] = internaliseString(event.content[\"m.relates_to\"][prop]!);\n        });\n\n        this.txnId = event.txn_id;\n        // The localTimestamp is calculated using the age.\n        // Some events lack an `age` property, either because they are EDUs such as typing events,\n        // or due to server-side bugs such as https://github.com/matrix-org/synapse/issues/8429.\n        // The fallback in these cases will be to use the origin_server_ts.\n        // For EDUs, the origin_server_ts also is not defined so we use Date.now().\n        const age = this.getAge();\n        this.localTimestamp = age !== undefined ? Date.now() - age : (this.getTs() ?? Date.now());\n        this.reEmitter = new TypedReEmitter(this);\n    }\n\n    /**\n     * Unstable getter to try and get an extensible event. Note that this might\n     * return a falsy value if the event could not be parsed as an extensible\n     * event.\n     *\n     * @deprecated Use stable functions where possible.\n     */\n    public get unstableExtensibleEvent(): Optional<ExtensibleEvent> {\n        if (!this._hasCachedExtEv) {\n            this._cachedExtEv = ExtensibleEvents.parse(this.getEffectiveEvent());\n        }\n        return this._cachedExtEv;\n    }\n\n    private invalidateExtensibleEvent(): void {\n        // just reset the flag - that'll trick the getter into parsing a new event\n        this._hasCachedExtEv = false;\n    }\n\n    /**\n     * Gets the event as it would appear if it had been sent unencrypted.\n     *\n     * If the event is encrypted, we attempt to mock up an event as it would have looked had the sender not encrypted it.\n     * If the event is not encrypted, a copy of it is simply returned as-is.\n     *\n     * @returns A shallow copy of the event, in wire format, as it would have been had it not been encrypted.\n     */\n    public getEffectiveEvent(): IEvent {\n        const content = Object.assign({}, this.getContent()); // clone for mutation\n\n        if (this.getWireType() === EventType.RoomMessageEncrypted) {\n            // Encrypted events sometimes aren't symmetrical on the `content` so we'll copy\n            // that over too, but only for missing properties. We don't copy over mismatches\n            // between the plain and decrypted copies of `content` because we assume that the\n            // app is relying on the decrypted version, so we want to expose that as a source\n            // of truth here too.\n            for (const [key, value] of Object.entries(this.getWireContent())) {\n                // Skip fields from the encrypted event schema though - we don't want to leak\n                // these.\n                if ([\"algorithm\", \"ciphertext\", \"device_id\", \"sender_key\", \"session_id\"].includes(key)) {\n                    continue;\n                }\n\n                if (content[key] === undefined) content[key] = value;\n            }\n        }\n\n        // clearEvent doesn't have all the fields, so we'll copy what we can from this.event.\n        // We also copy over our \"fixed\" content key.\n        return Object.assign({}, this.event, this.clearEvent, { content }) as IEvent;\n    }\n\n    /**\n     * Get the event_id for this event.\n     * @returns The event ID, e.g. <code>$143350589368169JsLZx:localhost\n     * </code>\n     */\n    public getId(): string | undefined {\n        return this.event.event_id;\n    }\n\n    /**\n     * Get the user_id for this event.\n     * @returns The user ID, e.g. `@alice:matrix.org`\n     */\n    public getSender(): string | undefined {\n        return this.event.sender; // v2 / v1\n    }\n\n    /**\n     * Get the (decrypted, if necessary) type of event.\n     *\n     * @returns The event type, e.g. `m.room.message`\n     */\n    public getType(): EventType | string {\n        if (this.clearEvent) {\n            return this.clearEvent.type;\n        }\n        return this.event.type!;\n    }\n\n    /**\n     * Get the (possibly encrypted) type of the event that will be sent to the\n     * homeserver.\n     *\n     * @returns The event type.\n     */\n    public getWireType(): EventType | string {\n        return this.event.type!;\n    }\n\n    /**\n     * Get the room_id for this event. This will return `undefined`\n     * for `m.presence` events.\n     * @returns The room ID, e.g. <code>!cURbafjkfsMDVwdRDQ:matrix.org\n     * </code>\n     */\n    public getRoomId(): string | undefined {\n        return this.event.room_id;\n    }\n\n    /**\n     * Get the timestamp of this event.\n     * @returns The event timestamp, e.g. `1433502692297`\n     */\n    public getTs(): number {\n        return this.event.origin_server_ts!;\n    }\n\n    /**\n     * Get the timestamp of this event, as a Date object.\n     * @returns The event date, e.g. `new Date(1433502692297)`\n     */\n    public getDate(): Date | null {\n        return this.event.origin_server_ts ? new Date(this.event.origin_server_ts) : null;\n    }\n\n    /**\n     * Get a string containing details of this event\n     *\n     * This is intended for logging, to help trace errors. Example output:\n     *\n     * @example\n     * ```\n     * id=$HjnOHV646n0SjLDAqFrgIjim7RCpB7cdMXFrekWYAn type=m.room.encrypted\n     * sender=@user:example.com room=!room:example.com ts=2022-10-25T17:30:28.404Z\n     * ```\n     */\n    public getDetails(): string {\n        const room = this.getRoomId();\n        if (room) {\n            // in-room event\n            return `id=${this.getId()} type=${this.getWireType()} sender=${this.getSender()} room=${room} ts=${this.getDate()?.toISOString()}`;\n        } else {\n            // to-device event\n            const msgid = this.getContent()[ToDeviceMessageId];\n            return `msgid=${msgid} type=${this.getWireType()} sender=${this.getSender()}`;\n        }\n    }\n\n    /**\n     * Get the (decrypted, if necessary) event content JSON, even if the event\n     * was replaced by another event.\n     *\n     * @returns The event content JSON, or an empty object.\n     */\n    public getOriginalContent<T = IContent>(): T {\n        if (this._localRedactionEvent) {\n            return {} as T;\n        }\n        if (this.clearEvent) {\n            return (this.clearEvent.content ?? {}) as T;\n        }\n        return (this.event.content ?? {}) as T;\n    }\n\n    /**\n     * Get the (decrypted, if necessary) event content JSON,\n     * or the content from the replacing event, if any.\n     * See `makeReplaced`.\n     *\n     * @returns The event content JSON, or an empty object.\n     */\n    public getContent<T extends IContent = IContent>(): T {\n        if (this._localRedactionEvent) {\n            return {} as T;\n        } else if (this._replacingEvent) {\n            return this._replacingEvent.getContent()[\"m.new_content\"] ?? {};\n        } else {\n            return this.getOriginalContent();\n        }\n    }\n\n    /**\n     * Get the (possibly encrypted) event content JSON that will be sent to the\n     * homeserver.\n     *\n     * @returns The event content JSON, or an empty object.\n     */\n    public getWireContent(): IContent {\n        return this.event.content || {};\n    }\n\n    /**\n     * Get the event ID of the thread head\n     */\n    public get threadRootId(): string | undefined {\n        // don't allow state events to be threaded as per the spec\n        if (this.isState()) {\n            return undefined;\n        }\n        const relatesTo = this.getWireContent()?.[\"m.relates_to\"];\n        if (relatesTo?.rel_type === THREAD_RELATION_TYPE.name) {\n            return relatesTo.event_id;\n        }\n        if (this.thread) {\n            return this.thread.id;\n        }\n        if (this.threadId !== undefined) {\n            return this.threadId;\n        }\n        const unsigned = this.getUnsigned();\n        if (typeof unsigned[UNSIGNED_THREAD_ID_FIELD.name] === \"string\") {\n            return unsigned[UNSIGNED_THREAD_ID_FIELD.name];\n        }\n        return undefined;\n    }\n\n    /**\n     * A helper to check if an event is a thread's head or not\n     */\n    public get isThreadRoot(): boolean {\n        // don't allow state events to be threaded as per the spec\n        if (this.isState()) {\n            return false;\n        }\n\n        const threadDetails = this.getServerAggregatedRelation<IThreadBundledRelationship>(THREAD_RELATION_TYPE.name);\n\n        // Bundled relationships only returned when the sync response is limited\n        // hence us having to check both bundled relation and inspect the thread\n        // model\n        return !!threadDetails || this.threadRootId === this.getId();\n    }\n\n    public get replyEventId(): string | undefined {\n        return this.getWireContent()[\"m.relates_to\"]?.[\"m.in_reply_to\"]?.event_id;\n    }\n\n    public get relationEventId(): string | undefined {\n        return this.getWireContent()?.[\"m.relates_to\"]?.event_id;\n    }\n\n    /**\n     * Get the previous event content JSON. This will only return something for\n     * state events which exist in the timeline.\n     * @returns The previous event content JSON, or an empty object.\n     */\n    public getPrevContent(): IContent {\n        // v2 then v1 then default\n        return this.getUnsigned().prev_content || {};\n    }\n\n    /**\n     * Get either 'content' or 'prev_content' depending on if this event is\n     * 'forward-looking' or not. This can be modified via event.forwardLooking.\n     * In practice, this means we get the chronologically earlier content value\n     * for this event (this method should surely be called getEarlierContent)\n     * <strong>This method is experimental and may change.</strong>\n     * @returns event.content if this event is forward-looking, else\n     * event.prev_content.\n     */\n    public getDirectionalContent(): IContent {\n        return this.forwardLooking ? this.getContent() : this.getPrevContent();\n    }\n\n    /**\n     * Get the age of this event. This represents the age of the event when the\n     * event arrived at the device, and not the age of the event when this\n     * function was called.\n     * Can only be returned once the server has echo'ed back\n     * @returns The age of this event in milliseconds.\n     */\n    public getAge(): number | undefined {\n        return this.getUnsigned().age;\n    }\n\n    /**\n     * Get the age of the event when this function was called.\n     * This is the 'age' field adjusted according to how long this client has\n     * had the event.\n     * @returns The age of this event in milliseconds.\n     */\n    public getLocalAge(): number {\n        return Date.now() - this.localTimestamp;\n    }\n\n    /**\n     * Get the event state_key if it has one. This will return <code>undefined\n     * </code> for message events.\n     * @returns The event's `state_key`.\n     */\n    public getStateKey(): string | undefined {\n        return this.event.state_key;\n    }\n\n    /**\n     * Check if this event is a state event.\n     * @returns True if this is a state event.\n     */\n    public isState(): boolean {\n        return this.event.state_key !== undefined;\n    }\n\n    /**\n     * Get the user's room membership at the time the event was sent, as reported\n     * by the server.  This uses MSC4115.\n     *\n     * @returns The user's room membership, or `undefined` if the server does\n     *   not report it.\n     */\n    public getMembershipAtEvent(): Optional<Membership | string> {\n        const unsigned = this.getUnsigned();\n        return UNSIGNED_MEMBERSHIP_FIELD.findIn<Membership | string>(unsigned);\n    }\n\n    /**\n     * Replace the content of this event with encrypted versions.\n     * (This is used when sending an event; it should not be used by applications).\n     *\n     * @internal\n     *\n     * @param cryptoType - type of the encrypted event - typically\n     * <tt>\"m.room.encrypted\"</tt>\n     *\n     * @param cryptoContent - raw 'content' for the encrypted event.\n     *\n     * @param senderCurve25519Key - curve25519 key to record for the\n     *   sender of this event.\n     *   See {@link MatrixEvent#getSenderKey}.\n     *\n     * @param claimedEd25519Key - claimed ed25519 key to record for the\n     *   sender if this event.\n     *   See {@link MatrixEvent#getClaimedEd25519Key}\n     */\n    public makeEncrypted(\n        cryptoType: string,\n        cryptoContent: object,\n        senderCurve25519Key: string,\n        claimedEd25519Key: string,\n    ): void {\n        // keep the plain-text data for 'view source'\n        this.clearEvent = {\n            type: this.event.type!,\n            content: this.event.content!,\n        };\n        this.event.type = cryptoType;\n        this.event.content = cryptoContent;\n        this.senderCurve25519Key = senderCurve25519Key;\n        this.claimedEd25519Key = claimedEd25519Key;\n    }\n\n    /**\n     * Check if this event is currently being decrypted.\n     *\n     * @returns True if this event is currently being decrypted, else false.\n     */\n    public isBeingDecrypted(): boolean {\n        return this.decryptionPromise != null;\n    }\n\n    public getDecryptionPromise(): Promise<void> | null {\n        return this.decryptionPromise;\n    }\n\n    /**\n     * Check if this event is an encrypted event which we failed to decrypt\n     *\n     * (This implies that we might retry decryption at some point in the future)\n     *\n     * @returns True if this event is an encrypted event which we\n     *     couldn't decrypt.\n     */\n    public isDecryptionFailure(): boolean {\n        return this._decryptionFailureReason !== null;\n    }\n\n    /** If we failed to decrypt this event, the reason for the failure. Otherwise, `null`. */\n    public get decryptionFailureReason(): DecryptionFailureCode | null {\n        return this._decryptionFailureReason;\n    }\n\n    /**\n     * True if this event is an encrypted event which we failed to decrypt, the receiver's device is unverified and\n     * the sender has disabled encrypting to unverified devices.\n     *\n     * @deprecated: Prefer `event.decryptionFailureReason === DecryptionFailureCode.MEGOLM_KEY_WITHHELD_FOR_UNVERIFIED_DEVICE`.\n     */\n    public get isEncryptedDisabledForUnverifiedDevices(): boolean {\n        return this.decryptionFailureReason === DecryptionFailureCode.MEGOLM_KEY_WITHHELD_FOR_UNVERIFIED_DEVICE;\n    }\n\n    public shouldAttemptDecryption(): boolean {\n        if (this.isRedacted()) return false;\n        if (this.isBeingDecrypted()) return false;\n        if (this.clearEvent) return false;\n        if (!this.isEncrypted()) return false;\n\n        return true;\n    }\n\n    /**\n     * Start the process of trying to decrypt this event.\n     *\n     * (This is used within the SDK: it isn't intended for use by applications)\n     *\n     * @internal\n     *\n     * @param crypto - crypto module\n     *\n     * @returns promise which resolves (to undefined) when the decryption\n     * attempt is completed.\n     */\n    public async attemptDecryption(crypto: CryptoBackend, options: IDecryptOptions = {}): Promise<void> {\n        // start with a couple of sanity checks.\n        if (!this.isEncrypted()) {\n            throw new Error(\"Attempt to decrypt event which isn't encrypted\");\n        }\n\n        const alreadyDecrypted = this.clearEvent && !this.isDecryptionFailure();\n        const forceRedecrypt = options.forceRedecryptIfUntrusted && this.isKeySourceUntrusted();\n        if (alreadyDecrypted && !forceRedecrypt) {\n            // we may want to just ignore this? let's start with rejecting it.\n            throw new Error(\"Attempt to decrypt event which has already been decrypted\");\n        }\n\n        // if we already have a decryption attempt in progress, then it may\n        // fail because it was using outdated info. We now have reason to\n        // succeed where it failed before, but we don't want to have multiple\n        // attempts going at the same time, so just set a flag that says we have\n        // new info.\n        //\n        if (this.decryptionPromise) {\n            logger.log(`Event ${this.getId()} already being decrypted; queueing a retry`);\n            this.retryDecryption = true;\n            return this.decryptionPromise;\n        }\n\n        this.decryptionPromise = this.decryptionLoop(crypto, options);\n        return this.decryptionPromise;\n    }\n\n    /**\n     * Calculate the recipients for keyshare requests.\n     *\n     * @param userId - the user who received this event.\n     *\n     * @returns array of recipients\n     */\n    public getKeyRequestRecipients(userId: string): IKeyRequestRecipient[] {\n        // send the request to all of our own devices\n        const recipients = [\n            {\n                userId,\n                deviceId: \"*\",\n            },\n        ];\n\n        return recipients;\n    }\n\n    private async decryptionLoop(crypto: CryptoBackend, options: IDecryptOptions = {}): Promise<void> {\n        // make sure that this method never runs completely synchronously.\n        // (doing so would mean that we would clear decryptionPromise *before*\n        // it is set in attemptDecryption - and hence end up with a stuck\n        // `decryptionPromise`).\n        await Promise.resolve();\n\n        // eslint-disable-next-line no-constant-condition\n        while (true) {\n            this.retryDecryption = false;\n\n            let err: Error | undefined = undefined;\n            try {\n                const res = await crypto.decryptEvent(this);\n                if (options.isRetry === true) {\n                    logger.info(`Decrypted event on retry (${this.getDetails()})`);\n                }\n                this.setClearData(res);\n                this._decryptionFailureReason = null;\n            } catch (e) {\n                const detailedError = e instanceof DecryptionError ? (<DecryptionError>e).detailedString : String(e);\n\n                err = e as Error;\n\n                // see if we have a retry queued.\n                //\n                // NB: make sure to keep this check in the same tick of the\n                //   event loop as `decryptionPromise = null` below - otherwise we\n                //   risk a race:\n                //\n                //   * A: we check retryDecryption here and see that it is\n                //        false\n                //   * B: we get a second call to attemptDecryption, which sees\n                //        that decryptionPromise is set so sets\n                //        retryDecryption\n                //   * A: we continue below, clear decryptionPromise, and\n                //        never do the retry.\n                //\n                if (this.retryDecryption) {\n                    // decryption error, but we have a retry queued.\n                    logger.log(`Error decrypting event (${this.getDetails()}), but retrying: ${detailedError}`);\n                    continue;\n                }\n\n                // decryption error, no retries queued. Warn about the error and\n                // set it to m.bad.encrypted.\n                //\n                // the detailedString already includes the name and message of the error, and the stack isn't much use,\n                // so we don't bother to log `e` separately.\n                logger.warn(`Error decrypting event (${this.getDetails()}): ${detailedError}`);\n\n                this.setClearDataForDecryptionFailure(String(e));\n                this._decryptionFailureReason =\n                    e instanceof DecryptionError ? (<DecryptionError>e).code : DecryptionFailureCode.UNKNOWN_ERROR;\n            }\n\n            // Make sure we clear 'decryptionPromise' before sending the 'Event.decrypted' event,\n            // otherwise the app will be confused to see `isBeingDecrypted` still set when\n            // there isn't an `Event.decrypted` on the way.\n            //\n            // see also notes on retryDecryption above.\n            //\n            this.decryptionPromise = null;\n            this.retryDecryption = false;\n\n            // Before we emit the event, clear the push actions so that they can be recalculated\n            // by relevant code. We do this because the clear event has now changed, making it\n            // so that existing rules can be re-run over the applicable properties. Stuff like\n            // highlighting when the user's name is mentioned rely on this happening. We also want\n            // to set the push actions before emitting so that any notification listeners don't\n            // pick up the wrong contents.\n            this.setPushDetails();\n\n            if (options.emit !== false) {\n                this.emit(MatrixEventEvent.Decrypted, this, err);\n            }\n\n            return;\n        }\n    }\n\n    /**\n     * Update the cleartext data on this event.\n     *\n     * (This is used after decrypting an event; it should not be used by applications).\n     *\n     * @internal\n     *\n     * @param decryptionResult - the decryption result, including the plaintext and some key info\n     */\n    private setClearData(decryptionResult: IEventDecryptionResult): void {\n        this.clearEvent = decryptionResult.clearEvent;\n        this.senderCurve25519Key = decryptionResult.senderCurve25519Key ?? null;\n        this.claimedEd25519Key = decryptionResult.claimedEd25519Key ?? null;\n        this.forwardingCurve25519KeyChain = decryptionResult.forwardingCurve25519KeyChain || [];\n        this.untrusted = decryptionResult.untrusted || false;\n        this.invalidateExtensibleEvent();\n    }\n\n    /**\n     * Update the cleartext data on this event after a decryption failure.\n     *\n     * @param reason - the textual reason for the failure\n     */\n    private setClearDataForDecryptionFailure(reason: string): void {\n        this.clearEvent = {\n            type: EventType.RoomMessage,\n            content: {\n                msgtype: \"m.bad.encrypted\",\n                body: `** Unable to decrypt: ${reason} **`,\n            },\n        };\n        this.senderCurve25519Key = null;\n        this.claimedEd25519Key = null;\n        this.forwardingCurve25519KeyChain = [];\n        this.untrusted = false;\n        this.invalidateExtensibleEvent();\n    }\n\n    /**\n     * Gets the cleartext content for this event. If the event is not encrypted,\n     * or encryption has not been completed, this will return null.\n     *\n     * @returns The cleartext (decrypted) content for the event\n     */\n    public getClearContent(): IContent | null {\n        return this.clearEvent ? this.clearEvent.content : null;\n    }\n\n    /**\n     * Check if the event is encrypted.\n     * @returns True if this event is encrypted.\n     */\n    public isEncrypted(): boolean {\n        return !this.isState() && this.event.type === EventType.RoomMessageEncrypted;\n    }\n\n    /**\n     * The curve25519 key for the device that we think sent this event\n     *\n     * For an Olm-encrypted event, this is inferred directly from the DH\n     * exchange at the start of the session: the curve25519 key is involved in\n     * the DH exchange, so only a device which holds the private part of that\n     * key can establish such a session.\n     *\n     * For a megolm-encrypted event, it is inferred from the Olm message which\n     * established the megolm session\n     */\n    public getSenderKey(): string | null {\n        return this.senderCurve25519Key;\n    }\n\n    /**\n     * The additional keys the sender of this encrypted event claims to possess.\n     *\n     * Just a wrapper for #getClaimedEd25519Key (q.v.)\n     */\n    public getKeysClaimed(): Partial<Record<\"ed25519\", string>> {\n        if (!this.claimedEd25519Key) return {};\n\n        return {\n            ed25519: this.claimedEd25519Key,\n        };\n    }\n\n    /**\n     * Get the ed25519 the sender of this event claims to own.\n     *\n     * For Olm messages, this claim is encoded directly in the plaintext of the\n     * event itself. For megolm messages, it is implied by the m.room_key event\n     * which established the megolm session.\n     *\n     * Until we download the device list of the sender, it's just a claim: the\n     * device list gives a proof that the owner of the curve25519 key used for\n     * this event (and returned by #getSenderKey) also owns the ed25519 key by\n     * signing the public curve25519 key with the ed25519 key.\n     *\n     * In general, applications should not use this method directly, but should\n     * instead use {@link crypto-api!CryptoApi#getEncryptionInfoForEvent}.\n     */\n    public getClaimedEd25519Key(): string | null {\n        return this.claimedEd25519Key;\n    }\n\n    /**\n     * Get the curve25519 keys of the devices which were involved in telling us\n     * about the claimedEd25519Key and sender curve25519 key.\n     *\n     * Normally this will be empty, but in the case of a forwarded megolm\n     * session, the sender keys are sent to us by another device (the forwarding\n     * device), which we need to trust to do this. In that case, the result will\n     * be a list consisting of one entry.\n     *\n     * If the device that sent us the key (A) got it from another device which\n     * it wasn't prepared to vouch for (B), the result will be [A, B]. And so on.\n     *\n     * @returns base64-encoded curve25519 keys, from oldest to newest.\n     */\n    public getForwardingCurve25519KeyChain(): string[] {\n        return this.forwardingCurve25519KeyChain;\n    }\n\n    /**\n     * Whether the decryption key was obtained from an untrusted source. If so,\n     * we cannot verify the authenticity of the message.\n     */\n    public isKeySourceUntrusted(): boolean | undefined {\n        return !!this.untrusted;\n    }\n\n    public getUnsigned(): IUnsigned {\n        return this.event.unsigned || {};\n    }\n\n    public setUnsigned(unsigned: IUnsigned): void {\n        this.event.unsigned = unsigned;\n    }\n\n    public unmarkLocallyRedacted(): boolean {\n        const value = this._localRedactionEvent;\n        this._localRedactionEvent = null;\n        if (this.event.unsigned) {\n            this.event.unsigned.redacted_because = undefined;\n        }\n        return !!value;\n    }\n\n    public markLocallyRedacted(redactionEvent: MatrixEvent): void {\n        if (this._localRedactionEvent) return;\n        this.emit(MatrixEventEvent.BeforeRedaction, this, redactionEvent);\n        this._localRedactionEvent = redactionEvent;\n        if (!this.event.unsigned) {\n            this.event.unsigned = {};\n        }\n        this.event.unsigned.redacted_because = redactionEvent.event as IEvent;\n    }\n\n    /**\n     * Change the visibility of an event, as per https://github.com/matrix-org/matrix-doc/pull/3531 .\n     *\n     * @param visibilityChange - event holding a hide/unhide payload, or nothing\n     *   if the event is being reset to its original visibility (presumably\n     *   by a visibility event being redacted).\n     *\n     * @remarks\n     * Fires {@link MatrixEventEvent.VisibilityChange} if `visibilityEvent`\n     *   caused a change in the actual visibility of this event, either by making it\n     *   visible (if it was hidden), by making it hidden (if it was visible) or by\n     *   changing the reason (if it was hidden).\n     */\n    public applyVisibilityEvent(visibilityChange?: IVisibilityChange): void {\n        const visible = visibilityChange?.visible ?? true;\n        const reason = visibilityChange?.reason ?? null;\n        let change = false;\n        if (this.visibility.visible !== visible) {\n            change = true;\n        } else if (!this.visibility.visible && this.visibility[\"reason\"] !== reason) {\n            change = true;\n        }\n        if (change) {\n            if (visible) {\n                this.visibility = MESSAGE_VISIBLE;\n            } else {\n                this.visibility = Object.freeze({\n                    visible: false,\n                    reason,\n                });\n            }\n            this.emit(MatrixEventEvent.VisibilityChange, this, visible);\n        }\n    }\n\n    /**\n     * Return instructions to display or hide the message.\n     *\n     * @returns Instructions determining whether the message\n     * should be displayed.\n     */\n    public messageVisibility(): MessageVisibility {\n        // Note: We may return `this.visibility` without fear, as\n        // this is a shallow frozen object.\n        return this.visibility;\n    }\n\n    /**\n     * Update the content of an event in the same way it would be by the server\n     * if it were redacted before it was sent to us\n     *\n     * @param redactionEvent - event causing the redaction\n     * @param room - the room in which the event exists\n     */\n    public makeRedacted(redactionEvent: MatrixEvent, room: Room): void {\n        // quick sanity-check\n        if (!redactionEvent.event) {\n            throw new Error(\"invalid redactionEvent in makeRedacted\");\n        }\n\n        this._localRedactionEvent = null;\n\n        this.emit(MatrixEventEvent.BeforeRedaction, this, redactionEvent);\n\n        this._replacingEvent = null;\n        // we attempt to replicate what we would see from the server if\n        // the event had been redacted before we saw it.\n        //\n        // The server removes (most of) the content of the event, and adds a\n        // \"redacted_because\" key to the unsigned section containing the\n        // redacted event.\n        if (!this.event.unsigned) {\n            this.event.unsigned = {};\n        }\n        this.event.unsigned.redacted_because = redactionEvent.event as IEvent;\n\n        for (const key in this.event) {\n            if (this.event.hasOwnProperty(key) && !REDACT_KEEP_KEYS.has(key)) {\n                delete this.event[key as keyof IEvent];\n            }\n        }\n\n        // If the event is encrypted prune the decrypted bits\n        if (this.isEncrypted()) {\n            this.clearEvent = undefined;\n        }\n\n        const keeps =\n            this.getType() in REDACT_KEEP_CONTENT_MAP\n                ? REDACT_KEEP_CONTENT_MAP[this.getType() as keyof typeof REDACT_KEEP_CONTENT_MAP]\n                : {};\n        const content = this.getContent();\n        for (const key in content) {\n            if (content.hasOwnProperty(key) && !keeps[key]) {\n                delete content[key];\n            }\n        }\n\n        // If the redacted event was in a thread (but not thread root), move it\n        // to the main timeline. This will change if MSC3389 is merged.\n        if (!this.isThreadRoot && this.threadRootId && this.threadRootId !== this.getId()) {\n            this.moveAllRelatedToMainTimeline(room);\n            redactionEvent.moveToMainTimeline(room);\n        }\n\n        this.invalidateExtensibleEvent();\n    }\n\n    private moveAllRelatedToMainTimeline(room: Room): void {\n        const thread = this.thread;\n        this.moveToMainTimeline(room);\n\n        // If we dont have access to the thread, we can only move this\n        // event, not things related to it.\n        if (thread) {\n            for (const event of thread.events) {\n                if (event.getRelation()?.event_id === this.getId()) {\n                    event.moveAllRelatedToMainTimeline(room);\n                }\n            }\n        }\n    }\n\n    private moveToMainTimeline(room: Room): void {\n        // Remove it from its thread\n        this.thread?.timelineSet.removeEvent(this.getId()!);\n        this.setThread(undefined);\n\n        // And insert it into the main timeline\n        const timeline = room.getLiveTimeline();\n        // We use insertEventIntoTimeline to insert it in timestamp order,\n        // because we don't know where it should go (until we have MSC4033).\n        timeline\n            .getTimelineSet()\n            .insertEventIntoTimeline(this, timeline, timeline.getState(EventTimeline.FORWARDS)!, false);\n    }\n\n    /**\n     * Check if this event has been redacted\n     *\n     * @returns True if this event has been redacted\n     */\n    public isRedacted(): boolean {\n        return Boolean(this.getUnsigned().redacted_because);\n    }\n\n    /**\n     * Check if this event is a redaction of another event\n     *\n     * @returns True if this event is a redaction\n     */\n    public isRedaction(): boolean {\n        return this.getType() === EventType.RoomRedaction;\n    }\n\n    /**\n     * Return the visibility change caused by this event,\n     * as per https://github.com/matrix-org/matrix-doc/pull/3531.\n     *\n     * @returns If the event is a well-formed visibility change event,\n     * an instance of `IVisibilityChange`, otherwise `null`.\n     */\n    public asVisibilityChange(): IVisibilityChange | null {\n        if (!EVENT_VISIBILITY_CHANGE_TYPE.matches(this.getType())) {\n            // Not a visibility change event.\n            return null;\n        }\n        const relation = this.getRelation();\n        if (!relation || relation.rel_type != \"m.reference\") {\n            // Ill-formed, ignore this event.\n            return null;\n        }\n        const eventId = relation.event_id;\n        if (!eventId) {\n            // Ill-formed, ignore this event.\n            return null;\n        }\n        const content = this.getWireContent();\n        const visible = !!content.visible;\n        const reason = content.reason;\n        if (reason && typeof reason != \"string\") {\n            // Ill-formed, ignore this event.\n            return null;\n        }\n        // Well-formed visibility change event.\n        return {\n            visible,\n            reason,\n            eventId,\n        };\n    }\n\n    /**\n     * Check if this event alters the visibility of another event,\n     * as per https://github.com/matrix-org/matrix-doc/pull/3531.\n     *\n     * @returns True if this event alters the visibility\n     * of another event.\n     */\n    public isVisibilityEvent(): boolean {\n        return EVENT_VISIBILITY_CHANGE_TYPE.matches(this.getType());\n    }\n\n    /**\n     * Get the (decrypted, if necessary) redaction event JSON\n     * if event was redacted\n     *\n     * @returns The redaction event JSON, or an empty object\n     */\n    public getRedactionEvent(): IEvent | EmptyObject | null {\n        if (!this.isRedacted()) return null;\n\n        if (this.clearEvent?.unsigned) {\n            return this.clearEvent?.unsigned.redacted_because ?? null;\n        } else if (this.event.unsigned?.redacted_because) {\n            return this.event.unsigned.redacted_because;\n        } else {\n            return {};\n        }\n    }\n\n    /**\n     * Get the push actions, if known, for this event\n     *\n     * @returns push actions\n     */\n    public getPushActions(): IActionsObject | null {\n        return this.pushDetails.actions || null;\n    }\n\n    /**\n     * Get the push details, if known, for this event\n     *\n     * @returns push actions\n     */\n    public getPushDetails(): PushDetails {\n        return this.pushDetails;\n    }\n\n    /**\n     * Set the push details for this event.\n     *\n     * @param pushActions - push actions\n     * @param rule - the executed push rule\n     */\n    public setPushDetails(pushActions?: IActionsObject, rule?: IAnnotatedPushRule): void {\n        this.pushDetails = {\n            actions: pushActions,\n            rule,\n        };\n    }\n\n    /**\n     * Replace the `event` property and recalculate any properties based on it.\n     * @param event - the object to assign to the `event` property\n     */\n    public handleRemoteEcho(event: object): void {\n        const oldUnsigned = this.getUnsigned();\n        const oldId = this.getId();\n        this.event = event;\n        // if this event was redacted before it was sent, it's locally marked as redacted.\n        // At this point, we've received the remote echo for the event, but not yet for\n        // the redaction that we are sending ourselves. Preserve the locally redacted\n        // state by copying over redacted_because so we don't get a flash of\n        // redacted, not-redacted, redacted as remote echos come in\n        if (oldUnsigned.redacted_because) {\n            if (!this.event.unsigned) {\n                this.event.unsigned = {};\n            }\n            this.event.unsigned.redacted_because = oldUnsigned.redacted_because;\n        }\n        // successfully sent.\n        this.setStatus(null);\n        if (this.getId() !== oldId) {\n            // emit the event if it changed\n            this.emit(MatrixEventEvent.LocalEventIdReplaced, this);\n        }\n\n        this.localTimestamp = Date.now() - (this.getAge() ?? 0);\n    }\n\n    /**\n     * Whether the event is in any phase of sending, send failure, waiting for\n     * remote echo, etc.\n     */\n    public isSending(): boolean {\n        return !!this.status;\n    }\n\n    /**\n     * Update the event's sending status and emit an event as well.\n     *\n     * @param status - The new status\n     */\n    public setStatus(status: EventStatus | null): void {\n        this.status = status;\n        this.emit(MatrixEventEvent.Status, this, status);\n    }\n\n    public replaceLocalEventId(eventId: string): void {\n        this.event.event_id = eventId;\n        this.emit(MatrixEventEvent.LocalEventIdReplaced, this);\n    }\n\n    /**\n     * Get whether the event is a relation event, and of a given type if\n     * `relType` is passed in. State events cannot be relation events\n     *\n     * @param relType - if given, checks that the relation is of the\n     * given type\n     */\n    public isRelation(relType?: string): boolean {\n        // Relation info is lifted out of the encrypted content when sent to\n        // encrypted rooms, so we have to check `getWireContent` for this.\n        const relation = this.getWireContent()?.[\"m.relates_to\"];\n        if (\n            this.isState() &&\n            !!relation?.rel_type &&\n            ([RelationType.Replace, RelationType.Thread] as string[]).includes(relation.rel_type)\n        ) {\n            // State events cannot be m.replace or m.thread relations\n            return false;\n        }\n        return !!(relation?.rel_type && relation.event_id && (relType ? relation.rel_type === relType : true));\n    }\n\n    /**\n     * Get relation info for the event, if any.\n     */\n    public getRelation(): IEventRelation | null {\n        if (!this.isRelation()) {\n            return null;\n        }\n        return this.getWireContent()[\"m.relates_to\"] ?? null;\n    }\n\n    /**\n     * Set an event that replaces the content of this event, through an m.replace relation.\n     *\n     * @param newEvent - the event with the replacing content, if any.\n     *\n     * @remarks\n     * Fires {@link MatrixEventEvent.Replaced}\n     */\n    public makeReplaced(newEvent?: MatrixEvent): void {\n        // don't allow redacted events to be replaced.\n        // if newEvent is null we allow to go through though,\n        // as with local redaction, the replacing event might get\n        // cancelled, which should be reflected on the target event.\n        if (this.isRedacted() && newEvent) {\n            return;\n        }\n        // don't allow state events to be replaced using this mechanism as per MSC2676\n        if (this.isState()) {\n            return;\n        }\n        if (this._replacingEvent !== newEvent) {\n            this._replacingEvent = newEvent ?? null;\n            this.emit(MatrixEventEvent.Replaced, this);\n            this.invalidateExtensibleEvent();\n        }\n    }\n\n    /**\n     * Returns the status of any associated edit or redaction\n     * (not for reactions/annotations as their local echo doesn't affect the original event),\n     * or else the status of the event.\n     */\n    public getAssociatedStatus(): EventStatus | null {\n        if (this._replacingEvent) {\n            return this._replacingEvent.status;\n        } else if (this._localRedactionEvent) {\n            return this._localRedactionEvent.status;\n        }\n        return this.status;\n    }\n\n    public getServerAggregatedRelation<T>(relType: RelationType | string): T | undefined {\n        return this.getUnsigned()[\"m.relations\"]?.[relType];\n    }\n\n    /**\n     * Returns the event ID of the event replacing the content of this event, if any.\n     */\n    public replacingEventId(): string | undefined {\n        const replaceRelation = this.getServerAggregatedRelation<IAggregatedRelation>(RelationType.Replace);\n        if (replaceRelation) {\n            return replaceRelation.event_id;\n        } else if (this._replacingEvent) {\n            return this._replacingEvent.getId();\n        }\n    }\n\n    /**\n     * Returns the event replacing the content of this event, if any.\n     * Replacements are aggregated on the server, so this would only\n     * return an event in case it came down the sync, or for local echo of edits.\n     */\n    public replacingEvent(): MatrixEvent | null {\n        return this._replacingEvent;\n    }\n\n    /**\n     * Returns the origin_server_ts of the event replacing the content of this event, if any.\n     */\n    public replacingEventDate(): Date | undefined {\n        const replaceRelation = this.getServerAggregatedRelation<IAggregatedRelation>(RelationType.Replace);\n        if (replaceRelation) {\n            const ts = replaceRelation.origin_server_ts;\n            if (Number.isFinite(ts)) {\n                return new Date(ts);\n            }\n        } else if (this._replacingEvent) {\n            return this._replacingEvent.getDate() ?? undefined;\n        }\n    }\n\n    /**\n     * Returns the event that wants to redact this event, but hasn't been sent yet.\n     * @returns the event\n     */\n    public localRedactionEvent(): MatrixEvent | null {\n        return this._localRedactionEvent;\n    }\n\n    /**\n     * For relations and redactions, returns the event_id this event is referring to.\n     */\n    public getAssociatedId(): string | undefined {\n        const relation = this.getRelation();\n        if (this.replyEventId) {\n            return this.replyEventId;\n        } else if (relation) {\n            return relation.event_id;\n        } else if (this.isRedaction()) {\n            return this.event.redacts;\n        }\n    }\n\n    /**\n     * Checks if this event is associated with another event. See `getAssociatedId`.\n     */\n    public hasAssociation(): boolean {\n        return !!this.getAssociatedId();\n    }\n\n    /**\n     * Update the related id with a new one.\n     *\n     * Used to replace a local id with remote one before sending\n     * an event with a related id.\n     *\n     * @param eventId - the new event id\n     */\n    public updateAssociatedId(eventId: string): void {\n        const relation = this.getRelation();\n        if (relation) {\n            relation.event_id = eventId;\n        } else if (this.isRedaction()) {\n            this.event.redacts = eventId;\n        }\n    }\n\n    /**\n     * Flags an event as cancelled due to future conditions. For example, a verification\n     * request event in the same sync transaction may be flagged as cancelled to warn\n     * listeners that a cancellation event is coming down the same pipe shortly.\n     * @param cancelled - Whether the event is to be cancelled or not.\n     */\n    public flagCancelled(cancelled = true): void {\n        this._isCancelled = cancelled;\n    }\n\n    /**\n     * Gets whether or not the event is flagged as cancelled. See flagCancelled() for\n     * more information.\n     * @returns True if the event is cancelled, false otherwise.\n     */\n    public isCancelled(): boolean {\n        return this._isCancelled;\n    }\n\n    /**\n     * Get a copy/snapshot of this event. The returned copy will be loosely linked\n     * back to this instance, though will have \"frozen\" event information. Other\n     * properties of this MatrixEvent instance will be copied verbatim, which can\n     * mean they are in reference to this instance despite being on the copy too.\n     * The reference the snapshot uses does not change, however members aside from\n     * the underlying event will not be deeply cloned, thus may be mutated internally.\n     * For example, the sender profile will be copied over at snapshot time, and\n     * the sender profile internally may mutate without notice to the consumer.\n     *\n     * This is meant to be used to snapshot the event details themselves, not the\n     * features (such as sender) surrounding the event.\n     * @returns A snapshot of this event.\n     */\n    public toSnapshot(): MatrixEvent {\n        const ev = new MatrixEvent(JSON.parse(JSON.stringify(this.event)));\n        for (const [p, v] of Object.entries(this)) {\n            if (p !== \"event\") {\n                // exclude the thing we just cloned\n                // @ts-ignore - XXX: this is just nasty\n                ev[p as keyof MatrixEvent] = v;\n            }\n        }\n        return ev;\n    }\n\n    /**\n     * Determines if this event is equivalent to the given event. This only checks\n     * the event object itself, not the other properties of the event. Intended for\n     * use with toSnapshot() to identify events changing.\n     * @param otherEvent - The other event to check against.\n     * @returns True if the events are the same, false otherwise.\n     */\n    public isEquivalentTo(otherEvent?: MatrixEvent): boolean {\n        if (!otherEvent) return false;\n        if (otherEvent === this) return true;\n        const myProps = deepSortedObjectEntries(this.event);\n        const theirProps = deepSortedObjectEntries(otherEvent.event);\n        return JSON.stringify(myProps) === JSON.stringify(theirProps);\n    }\n\n    /**\n     * Summarise the event as JSON.\n     *\n     * If encrypted, include both the decrypted and encrypted view of the event.\n     *\n     * This is named `toJSON` for use with `JSON.stringify` which checks objects\n     * for functions named `toJSON` and will call them to customise the output\n     * if they are defined.\n     *\n     * **WARNING** Do not log the result of this method; otherwise, it will end up\n     * in rageshakes, leading to a privacy violation.\n     *\n     * @deprecated Prefer to use {@link MatrixEvent#getEffectiveEvent} or similar.\n     * This method will be removed soon; it is too easy to use it accidentally\n     * and cause a privacy violation (cf https://github.com/vector-im/element-web/issues/26380).\n     * In any case, the value it returns is not a faithful serialization of the object.\n     */\n    public toJSON(): object {\n        const event = this.getEffectiveEvent();\n\n        if (!this.isEncrypted()) {\n            return event;\n        }\n\n        return {\n            decrypted: event,\n            encrypted: this.event,\n        };\n    }\n\n    public setTxnId(txnId: string): void {\n        this.txnId = txnId;\n    }\n\n    public getTxnId(): string | undefined {\n        return this.txnId;\n    }\n\n    /**\n     * Set the instance of a thread associated with the current event\n     * @param thread - the thread\n     */\n    public setThread(thread?: Thread): void {\n        // don't allow state events to be threaded as per the spec\n        if (this.isState()) {\n            return;\n        }\n        if (this.thread) {\n            this.reEmitter.stopReEmitting(this.thread, [ThreadEvent.Update]);\n        }\n        this.thread = thread;\n        this.setThreadId(thread?.id);\n        if (thread) {\n            this.reEmitter.reEmit(thread, [ThreadEvent.Update]);\n        }\n    }\n\n    /**\n     * Get the instance of the thread associated with the current event\n     */\n    public getThread(): Thread | undefined {\n        return this.thread;\n    }\n\n    public setThreadId(threadId?: string): void {\n        this.threadId = threadId;\n    }\n}\n\n/* REDACT_KEEP_KEYS gives the keys we keep when an event is redacted\n *\n * This is specified here:\n *  http://matrix.org/speculator/spec/HEAD/client_server/latest.html#redactions\n *\n * Also:\n *  - We keep 'unsigned' since that is created by the local server\n *  - We keep user_id for backwards-compat with v1\n */\nconst REDACT_KEEP_KEYS = new Set([\n    \"event_id\",\n    \"type\",\n    \"room_id\",\n    \"user_id\",\n    \"sender\",\n    \"state_key\",\n    \"prev_state\",\n    \"content\",\n    \"unsigned\",\n    \"origin_server_ts\",\n]);\n\n// a map from state event type to the .content keys we keep when an event is redacted\nconst REDACT_KEEP_CONTENT_MAP: Record<string, Record<string, 1>> = {\n    [EventType.RoomMember]: { membership: 1 },\n    [EventType.RoomJoinRules]: { join_rule: 1 },\n    [EventType.RoomPowerLevels]: {\n        ban: 1,\n        events: 1,\n        events_default: 1,\n        kick: 1,\n        redact: 1,\n        state_default: 1,\n        users: 1,\n        users_default: 1,\n    },\n} as const;\n","/*\nCopyright 2022 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { UnstableValue } from \"matrix-events-sdk\";\n\n/// The event type storing the user's individual policies.\n///\n/// Exported for testing purposes.\nexport const POLICIES_ACCOUNT_EVENT_TYPE = new UnstableValue(\"m.policies\", \"org.matrix.msc3847.policies\");\n\n/// The key within the user's individual policies storing the user's ignored invites.\n///\n/// Exported for testing purposes.\nexport const IGNORE_INVITES_ACCOUNT_EVENT_KEY = new UnstableValue(\n    \"m.ignore.invites\",\n    \"org.matrix.msc3847.ignore.invites\",\n);\n\n/// The types of recommendations understood.\nexport enum PolicyRecommendation {\n    Ban = \"m.ban\",\n}\n\n/**\n * The various scopes for policies.\n */\nexport enum PolicyScope {\n    /**\n     * The policy deals with an individual user, e.g. reject invites\n     * from this user.\n     */\n    User = \"m.policy.user\",\n\n    /**\n     * The policy deals with a room, e.g. reject invites towards\n     * a specific room.\n     */\n    Room = \"m.policy.room\",\n\n    /**\n     * The policy deals with a server, e.g. reject invites from\n     * this server.\n     */\n    Server = \"m.policy.server\",\n}\n","/*\nCopyright 2022 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { type MatrixClient } from \"../client.ts\";\nimport { type IContent, type MatrixEvent } from \"./event.ts\";\nimport { EventTimeline } from \"./event-timeline.ts\";\nimport { Preset } from \"../@types/partials.ts\";\nimport { globToRegexp } from \"../utils.ts\";\nimport { type Room } from \"./room.ts\";\nimport { EventType, type StateEvents } from \"../@types/event.ts\";\nimport {\n    IGNORE_INVITES_ACCOUNT_EVENT_KEY,\n    POLICIES_ACCOUNT_EVENT_TYPE,\n    PolicyRecommendation,\n    PolicyScope,\n} from \"./invites-ignorer-types.ts\";\n\nexport { IGNORE_INVITES_ACCOUNT_EVENT_KEY, POLICIES_ACCOUNT_EVENT_TYPE, PolicyRecommendation, PolicyScope };\n\nconst scopeToEventTypeMap: Record<PolicyScope, keyof StateEvents> = {\n    [PolicyScope.User]: EventType.PolicyRuleUser,\n    [PolicyScope.Room]: EventType.PolicyRuleRoom,\n    [PolicyScope.Server]: EventType.PolicyRuleServer,\n};\n\n/**\n * A container for ignored invites.\n *\n * # Performance\n *\n * This implementation is extremely naive. It expects that we are dealing\n * with a very short list of sources (e.g. only one). If real-world\n * applications turn out to require longer lists, we may need to rework\n * our data structures.\n */\nexport class IgnoredInvites {\n    public constructor(private readonly client: MatrixClient) {}\n\n    /**\n     * Add a new rule.\n     *\n     * @param scope - The scope for this rule.\n     * @param entity - The entity covered by this rule. Globs are supported.\n     * @param reason - A human-readable reason for introducing this new rule.\n     * @returns The event id for the new rule.\n     */\n    public async addRule(scope: PolicyScope, entity: string, reason: string): Promise<string> {\n        const target = await this.getOrCreateTargetRoom();\n        const response = await this.client.sendStateEvent(target.roomId, scopeToEventTypeMap[scope], {\n            entity,\n            reason,\n            recommendation: PolicyRecommendation.Ban,\n        });\n        return response.event_id;\n    }\n\n    /**\n     * Remove a rule.\n     */\n    public async removeRule(event: MatrixEvent): Promise<void> {\n        await this.client.redactEvent(event.getRoomId()!, event.getId()!);\n    }\n\n    /**\n     * Add a new room to the list of sources. If the user isn't a member of the\n     * room, attempt to join it.\n     *\n     * @param roomId - A valid room id. If this room is already in the list\n     * of sources, it will not be duplicated.\n     * @returns `true` if the source was added, `false` if it was already present.\n     * @throws If `roomId` isn't the id of a room that the current user is already\n     * member of or can join.\n     *\n     * # Safety\n     *\n     * This method will rewrite the `Policies` object in the user's account data.\n     * This rewrite is inherently racy and could overwrite or be overwritten by\n     * other concurrent rewrites of the same object.\n     */\n    public async addSource(roomId: string): Promise<boolean> {\n        // We attempt to join the room *before* calling\n        // `await this.getOrCreateSourceRooms()` to decrease the duration\n        // of the racy section.\n        await this.client.joinRoom(roomId);\n        // Race starts.\n        const sources = (await this.getOrCreateSourceRooms()).map((room) => room.roomId);\n        if (sources.includes(roomId)) {\n            return false;\n        }\n        sources.push(roomId);\n        await this.withIgnoreInvitesPolicies((ignoreInvitesPolicies) => {\n            ignoreInvitesPolicies.sources = sources;\n        });\n\n        // Race ends.\n        return true;\n    }\n\n    /**\n     * Find out whether an invite should be ignored.\n     *\n     * @param params\n     * @param params.sender - The user id for the user who issued the invite.\n     * @param params.roomId - The room to which the user is invited.\n     * @returns A rule matching the entity, if any was found, `null` otherwise.\n     */\n    public async getRuleForInvite({\n        sender,\n        roomId,\n    }: {\n        sender: string;\n        roomId: string;\n    }): Promise<Readonly<MatrixEvent | null>> {\n        // In this implementation, we perform a very naive lookup:\n        // - search in each policy room;\n        // - turn each (potentially glob) rule entity into a regexp.\n        //\n        // Real-world testing will tell us whether this is performant enough.\n        // In the (unfortunately likely) case it isn't, there are several manners\n        // in which we could optimize this:\n        // - match several entities per go;\n        // - pre-compile each rule entity into a regexp;\n        // - pre-compile entire rooms into a single regexp.\n        const policyRooms = await this.getOrCreateSourceRooms();\n        const senderServer = sender.split(\":\")[1];\n        const roomServer = roomId.split(\":\")[1];\n        for (const room of policyRooms) {\n            const state = room.getUnfilteredTimelineSet().getLiveTimeline().getState(EventTimeline.FORWARDS)!;\n\n            for (const { scope, entities } of [\n                { scope: PolicyScope.Room, entities: [roomId] },\n                { scope: PolicyScope.User, entities: [sender] },\n                { scope: PolicyScope.Server, entities: [senderServer, roomServer] },\n            ]) {\n                const events = state.getStateEvents(scopeToEventTypeMap[scope]);\n                for (const event of events) {\n                    const content = event.getContent();\n                    if (content?.recommendation != PolicyRecommendation.Ban) {\n                        // Ignoring invites only looks at `m.ban` recommendations.\n                        continue;\n                    }\n                    const glob = content?.entity;\n                    if (!glob) {\n                        // Invalid event.\n                        continue;\n                    }\n                    let regexp: RegExp;\n                    try {\n                        regexp = new RegExp(globToRegexp(glob));\n                    } catch {\n                        // Assume invalid event.\n                        continue;\n                    }\n                    for (const entity of entities) {\n                        if (entity && regexp.test(entity)) {\n                            return event;\n                        }\n                    }\n                    // No match.\n                }\n            }\n        }\n        return null;\n    }\n\n    /**\n     * Get the target room, i.e. the room in which any new rule should be written.\n     *\n     * If there is no target room setup, a target room is created.\n     *\n     * Note: This method is public for testing reasons. Most clients should not need\n     * to call it directly.\n     *\n     * # Safety\n     *\n     * This method will rewrite the `Policies` object in the user's account data.\n     * This rewrite is inherently racy and could overwrite or be overwritten by\n     * other concurrent rewrites of the same object.\n     */\n    public async getOrCreateTargetRoom(): Promise<Room> {\n        const ignoreInvitesPolicies = this.getIgnoreInvitesPolicies();\n        let target = ignoreInvitesPolicies.target;\n        // Validate `target`. If it is invalid, trash out the current `target`\n        // and create a new room.\n        if (typeof target !== \"string\") {\n            target = null;\n        }\n        if (target) {\n            // Check that the room exists and is valid.\n            const room = this.client.getRoom(target);\n            if (room) {\n                return room;\n            } else {\n                target = null;\n            }\n        }\n        // We need to create our own policy room for ignoring invites.\n        target = (\n            await this.client.createRoom({\n                name: \"Individual Policy Room\",\n                preset: Preset.PrivateChat,\n            })\n        ).room_id;\n        await this.withIgnoreInvitesPolicies((ignoreInvitesPolicies) => {\n            ignoreInvitesPolicies.target = target;\n        });\n\n        // Since we have just called `createRoom`, `getRoom` should not be `null`.\n        return this.client.getRoom(target)!;\n    }\n\n    /**\n     * Get the list of source rooms, i.e. the rooms from which rules need to be read.\n     *\n     * If no source rooms are setup, the target room is used as sole source room.\n     *\n     * Note: This method is public for testing reasons. Most clients should not need\n     * to call it directly.\n     *\n     * # Safety\n     *\n     * This method will rewrite the `Policies` object in the user's account data.\n     * This rewrite is inherently racy and could overwrite or be overwritten by\n     * other concurrent rewrites of the same object.\n     */\n    public async getOrCreateSourceRooms(): Promise<Room[]> {\n        const ignoreInvitesPolicies = this.getIgnoreInvitesPolicies();\n        let sources: string[] = ignoreInvitesPolicies.sources;\n\n        // Validate `sources`. If it is invalid, trash out the current `sources`\n        // and create a new list of sources from `target`.\n        let hasChanges = false;\n        if (!Array.isArray(sources)) {\n            // `sources` could not be an array.\n            hasChanges = true;\n            sources = [];\n        }\n        let sourceRooms = sources\n            // `sources` could contain non-string / invalid room ids\n            .filter((roomId) => typeof roomId === \"string\")\n            .map((roomId) => this.client.getRoom(roomId))\n            .filter((room) => !!room) as Room[];\n        if (sourceRooms.length != sources.length) {\n            hasChanges = true;\n        }\n        if (sourceRooms.length == 0) {\n            // `sources` could be empty (possibly because we've removed\n            // invalid content)\n            const target = await this.getOrCreateTargetRoom();\n            hasChanges = true;\n            sourceRooms = [target];\n        }\n        if (hasChanges) {\n            // Reload `policies`/`ignoreInvitesPolicies` in case it has been changed\n            // during or by our call to `this.getTargetRoom()`.\n            await this.withIgnoreInvitesPolicies((ignoreInvitesPolicies) => {\n                ignoreInvitesPolicies.sources = sources;\n            });\n        }\n        return sourceRooms;\n    }\n\n    /**\n     * Fetch the `IGNORE_INVITES_POLICIES` object from account data.\n     *\n     * If both an unstable prefix version and a stable prefix version are available,\n     * it will return the stable prefix version preferentially.\n     *\n     * The result is *not* validated but is guaranteed to be a non-null object.\n     *\n     * @returns A non-null object.\n     */\n    private getIgnoreInvitesPolicies(): { [key: string]: any } {\n        return this.getPoliciesAndIgnoreInvitesPolicies().ignoreInvitesPolicies;\n    }\n\n    /**\n     * Modify in place the `IGNORE_INVITES_POLICIES` object from account data.\n     */\n    private async withIgnoreInvitesPolicies(\n        cb: (ignoreInvitesPolicies: { [key: string]: any }) => void,\n    ): Promise<void> {\n        const { policies, ignoreInvitesPolicies } = this.getPoliciesAndIgnoreInvitesPolicies();\n        cb(ignoreInvitesPolicies);\n        policies[IGNORE_INVITES_ACCOUNT_EVENT_KEY.name] = ignoreInvitesPolicies;\n        await this.client.setAccountData(POLICIES_ACCOUNT_EVENT_TYPE.name, policies);\n    }\n\n    /**\n     * As `getIgnoreInvitesPolicies` but also return the `POLICIES_ACCOUNT_EVENT_TYPE`\n     * object.\n     */\n    private getPoliciesAndIgnoreInvitesPolicies(): {\n        policies: { [key: string]: any };\n        ignoreInvitesPolicies: { [key: string]: any };\n    } {\n        let policies: IContent = {};\n        for (const key of [POLICIES_ACCOUNT_EVENT_TYPE.name, POLICIES_ACCOUNT_EVENT_TYPE.altName]) {\n            if (!key) {\n                continue;\n            }\n            const value = this.client.getAccountData(key)?.getContent();\n            if (value) {\n                policies = value;\n                break;\n            }\n        }\n\n        let ignoreInvitesPolicies = {};\n        let hasIgnoreInvitesPolicies = false;\n        for (const key of [IGNORE_INVITES_ACCOUNT_EVENT_KEY.name, IGNORE_INVITES_ACCOUNT_EVENT_KEY.altName]) {\n            if (!key) {\n                continue;\n            }\n            const value = policies[key];\n            if (value && typeof value == \"object\") {\n                ignoreInvitesPolicies = value;\n                hasIgnoreInvitesPolicies = true;\n                break;\n            }\n        }\n        if (!hasIgnoreInvitesPolicies) {\n            policies[IGNORE_INVITES_ACCOUNT_EVENT_KEY.name] = ignoreInvitesPolicies;\n        }\n\n        return { policies, ignoreInvitesPolicies };\n    }\n}\n","/*\nCopyright 2023 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { M_POLL_START } from \"matrix-events-sdk\";\n\nimport { M_POLL_END, M_POLL_RESPONSE } from \"../@types/polls.ts\";\nimport { type MatrixClient } from \"../client.ts\";\nimport { type PollStartEvent } from \"../extensible_events_v1/PollStartEvent.ts\";\nimport { type MatrixEvent } from \"./event.ts\";\nimport { Relations } from \"./relations.ts\";\nimport { type Room } from \"./room.ts\";\nimport { TypedEventEmitter } from \"./typed-event-emitter.ts\";\n\nexport enum PollEvent {\n    New = \"Poll.new\",\n    End = \"Poll.end\",\n    Update = \"Poll.update\",\n    Responses = \"Poll.Responses\",\n    Destroy = \"Poll.Destroy\",\n    UndecryptableRelations = \"Poll.UndecryptableRelations\",\n}\n\nexport type PollEventHandlerMap = {\n    [PollEvent.Update]: (event: MatrixEvent, poll: Poll) => void;\n    [PollEvent.Destroy]: (pollIdentifier: string) => void;\n    [PollEvent.End]: () => void;\n    [PollEvent.Responses]: (responses: Relations) => void;\n    [PollEvent.UndecryptableRelations]: (count: number) => void;\n};\n\nconst filterResponseRelations = (\n    relationEvents: MatrixEvent[],\n    pollEndTimestamp: number,\n): {\n    responseEvents: MatrixEvent[];\n} => {\n    const responseEvents = relationEvents.filter((event) => {\n        if (event.isDecryptionFailure()) {\n            return;\n        }\n        return (\n            M_POLL_RESPONSE.matches(event.getType()) &&\n            // From MSC3381:\n            // \"Votes sent on or before the end event's timestamp are valid votes\"\n            event.getTs() <= pollEndTimestamp\n        );\n    });\n\n    return { responseEvents };\n};\n\nexport class Poll extends TypedEventEmitter<Exclude<PollEvent, PollEvent.New>, PollEventHandlerMap> {\n    public readonly roomId: string;\n    public readonly pollEvent: PollStartEvent;\n    private _isFetchingResponses = false;\n    private relationsNextBatch: string | undefined;\n    private responses: null | Relations = null;\n    private endEvent: MatrixEvent | undefined;\n    /**\n     * Keep track of undecryptable relations\n     * As incomplete result sets affect poll results\n     */\n    private undecryptableRelationEventIds = new Set<string>();\n\n    public constructor(\n        public readonly rootEvent: MatrixEvent,\n        private matrixClient: MatrixClient,\n        private room: Room,\n    ) {\n        super();\n        if (!this.rootEvent.getRoomId() || !this.rootEvent.getId()) {\n            throw new Error(\"Invalid poll start event.\");\n        }\n        this.roomId = this.rootEvent.getRoomId()!;\n        this.pollEvent = this.rootEvent.unstableExtensibleEvent as unknown as PollStartEvent;\n    }\n\n    public get pollId(): string {\n        return this.rootEvent.getId()!;\n    }\n\n    public get endEventId(): string | undefined {\n        return this.endEvent?.getId();\n    }\n\n    public get isEnded(): boolean {\n        return !!this.endEvent;\n    }\n\n    public get isFetchingResponses(): boolean {\n        return this._isFetchingResponses;\n    }\n\n    public get undecryptableRelationsCount(): number {\n        return this.undecryptableRelationEventIds.size;\n    }\n\n    public async getResponses(): Promise<Relations> {\n        // if we have already fetched some responses\n        // just return them\n        if (this.responses) {\n            return this.responses;\n        }\n\n        // if there is no fetching in progress\n        // start fetching\n        if (!this.isFetchingResponses) {\n            await this.fetchResponses();\n        }\n        // return whatever responses we got from the first page\n        return this.responses!;\n    }\n\n    /**\n     *\n     * @param event - event with a relation to the rootEvent\n     * @returns void\n     */\n    public onNewRelation(event: MatrixEvent): void {\n        if (M_POLL_END.matches(event.getType()) && this.validateEndEvent(event)) {\n            this.endEvent = event;\n            this.refilterResponsesOnEnd();\n            this.emit(PollEvent.End);\n        }\n\n        // wait for poll responses to be initialised\n        if (!this.responses) {\n            return;\n        }\n\n        const pollEndTimestamp = this.endEvent?.getTs() || Number.MAX_SAFE_INTEGER;\n        const { responseEvents } = filterResponseRelations([event], pollEndTimestamp);\n\n        this.countUndecryptableEvents([event]);\n\n        if (responseEvents.length) {\n            responseEvents.forEach((event) => {\n                this.responses!.addEvent(event);\n            });\n\n            this.emit(PollEvent.Responses, this.responses);\n        }\n    }\n\n    private async fetchResponses(): Promise<void> {\n        this._isFetchingResponses = true;\n\n        // we want:\n        // - stable and unstable M_POLL_RESPONSE\n        // - stable and unstable M_POLL_END\n        // so make one api call and filter by event type client side\n        const allRelations = await this.matrixClient.relations(\n            this.roomId,\n            this.rootEvent.getId()!,\n            \"m.reference\",\n            undefined,\n            {\n                from: this.relationsNextBatch || undefined,\n            },\n        );\n\n        await Promise.all(allRelations.events.map((event) => this.matrixClient.decryptEventIfNeeded(event)));\n\n        const responses =\n            this.responses ||\n            new Relations(\"m.reference\", M_POLL_RESPONSE.name, this.matrixClient, [M_POLL_RESPONSE.altName!]);\n\n        const pollEndEvent = allRelations.events.find((event) => M_POLL_END.matches(event.getType()));\n\n        if (this.validateEndEvent(pollEndEvent)) {\n            this.endEvent = pollEndEvent;\n            this.refilterResponsesOnEnd();\n            this.emit(PollEvent.End);\n        }\n\n        const pollCloseTimestamp = this.endEvent?.getTs() || Number.MAX_SAFE_INTEGER;\n\n        const { responseEvents } = filterResponseRelations(allRelations.events, pollCloseTimestamp);\n\n        responseEvents.forEach((event) => {\n            responses.addEvent(event);\n        });\n\n        this.relationsNextBatch = allRelations.nextBatch ?? undefined;\n        this.responses = responses;\n        this.countUndecryptableEvents(allRelations.events);\n\n        // while there are more pages of relations\n        // fetch them\n        if (this.relationsNextBatch) {\n            // don't await\n            // we want to return the first page as soon as possible\n            this.fetchResponses();\n        } else {\n            // no more pages\n            this._isFetchingResponses = false;\n        }\n\n        // emit after updating _isFetchingResponses state\n        this.emit(PollEvent.Responses, this.responses);\n    }\n\n    /**\n     * Only responses made before the poll ended are valid\n     * Refilter after an end event is recieved\n     * To ensure responses are valid\n     */\n    private refilterResponsesOnEnd(): void {\n        if (!this.responses) {\n            return;\n        }\n\n        const pollEndTimestamp = this.endEvent?.getTs() || Number.MAX_SAFE_INTEGER;\n        this.responses.getRelations().forEach((event) => {\n            if (event.getTs() > pollEndTimestamp) {\n                this.responses?.removeEvent(event);\n            }\n        });\n\n        this.emit(PollEvent.Responses, this.responses);\n    }\n\n    private countUndecryptableEvents = (events: MatrixEvent[]): void => {\n        const undecryptableEventIds = events\n            .filter((event) => event.isDecryptionFailure())\n            .map((event) => event.getId()!);\n\n        const previousCount = this.undecryptableRelationsCount;\n        this.undecryptableRelationEventIds = new Set([...this.undecryptableRelationEventIds, ...undecryptableEventIds]);\n\n        if (this.undecryptableRelationsCount !== previousCount) {\n            this.emit(PollEvent.UndecryptableRelations, this.undecryptableRelationsCount);\n        }\n    };\n\n    private validateEndEvent(endEvent?: MatrixEvent): boolean {\n        if (!endEvent) {\n            return false;\n        }\n        /**\n         * Repeated end events are ignored -\n         * only the first (valid) closure event by origin_server_ts is counted.\n         */\n        if (this.endEvent && this.endEvent.getTs() < endEvent.getTs()) {\n            return false;\n        }\n\n        /**\n         * MSC3381\n         * If a m.poll.end event is received from someone other than the poll creator or user with permission to redact\n         * others' messages in the room, the event must be ignored by clients due to being invalid.\n         */\n        const roomCurrentState = this.room.currentState;\n        const endEventSender = endEvent.getSender();\n        return (\n            !!endEventSender &&\n            (endEventSender === this.rootEvent.getSender() ||\n                roomCurrentState.maySendRedactionForEvent(this.rootEvent, endEventSender))\n        );\n    }\n}\n\n/**\n * Tests whether the event is a start, response or end poll event.\n *\n * @param event - Event to test\n * @returns true if the event is a poll event, else false\n */\nexport const isPollEvent = (event: MatrixEvent): boolean => {\n    const eventType = event.getType();\n    return M_POLL_START.matches(eventType) || M_POLL_RESPONSE.matches(eventType) || M_POLL_END.matches(eventType);\n};\n","/*\nCopyright 2022 The Matrix.org Foundation C.I.C.\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n    http://www.apache.org/licenses/LICENSE-2.0\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport {\n    type CachedReceipt,\n    MAIN_ROOM_TIMELINE,\n    type Receipt,\n    type ReceiptCache,\n    ReceiptType,\n    type WrappedReceipt,\n} from \"../@types/read_receipts.ts\";\nimport { type ListenerMap, TypedEventEmitter } from \"./typed-event-emitter.ts\";\nimport { isSupportedReceiptType } from \"../utils.ts\";\nimport { MatrixEvent } from \"./event.ts\";\nimport { EventType } from \"../@types/event.ts\";\nimport { type EventTimelineSet } from \"./event-timeline-set.ts\";\nimport { MapWithDefault } from \"../utils.ts\";\nimport { NotificationCountType } from \"./room.ts\";\nimport { logger } from \"../logger.ts\";\nimport { inMainTimelineForReceipt, threadIdForReceipt } from \"../client.ts\";\n\n/**\n * Create a synthetic receipt for the given event\n * @param userId - The user ID if the receipt sender\n * @param event - The event that is to be acknowledged\n * @param receiptType - The type of receipt\n * @param unthreaded - the receipt is unthreaded\n * @returns a new event with the synthetic receipt in it\n */\nexport function synthesizeReceipt(\n    userId: string,\n    event: MatrixEvent,\n    receiptType: ReceiptType,\n    unthreaded = false,\n): MatrixEvent {\n    return new MatrixEvent({\n        content: {\n            [event.getId()!]: {\n                [receiptType]: {\n                    [userId]: {\n                        ts: event.getTs(),\n                        ...(!unthreaded && { thread_id: threadIdForReceipt(event) }),\n                    },\n                },\n            },\n        },\n        type: EventType.Receipt,\n        room_id: event.getRoomId(),\n    });\n}\n\nconst ReceiptPairRealIndex = 0;\nconst ReceiptPairSyntheticIndex = 1;\n\nexport abstract class ReadReceipt<\n    Events extends string,\n    Arguments extends ListenerMap<Events>,\n    SuperclassArguments extends ListenerMap<any> = Arguments,\n> extends TypedEventEmitter<Events, Arguments, SuperclassArguments> {\n    // receipts should clobber based on receipt_type and user_id pairs hence\n    // the form of this structure. This is sub-optimal for the exposed APIs\n    // which pass in an event ID and get back some receipts, so we also store\n    // a pre-cached list for this purpose.\n    // Map: receipt type → user Id → receipt\n    private receipts = new MapWithDefault<\n        string,\n        Map<string, [realReceipt: WrappedReceipt | null, syntheticReceipt: WrappedReceipt | null]>\n    >(() => new Map());\n    private receiptCacheByEventId: ReceiptCache = new Map();\n\n    public abstract getUnfilteredTimelineSet(): EventTimelineSet;\n    public abstract get timeline(): MatrixEvent[];\n\n    /**\n     * Gets the latest receipt for a given user in the room\n     * @param userId - The id of the user for which we want the receipt\n     * @param ignoreSynthesized - Whether to ignore synthesized receipts or not\n     * @param receiptType - Optional. The type of the receipt we want to get\n     * @returns the latest receipts of the chosen type for the chosen user\n     */\n    public getReadReceiptForUserId(\n        userId: string,\n        ignoreSynthesized = false,\n        receiptType = ReceiptType.Read,\n    ): WrappedReceipt | null {\n        const [realReceipt, syntheticReceipt] = this.receipts.get(receiptType)?.get(userId) ?? [null, null];\n        if (ignoreSynthesized) {\n            return realReceipt;\n        }\n\n        return syntheticReceipt ?? realReceipt;\n    }\n\n    private compareReceipts(a: WrappedReceipt, b: WrappedReceipt): number {\n        // Try compare them in our unfiltered timeline set order, falling back to receipt timestamp which should be\n        // relatively sane as receipts are set only by the originating homeserver so as long as its clock doesn't\n        // jump around then it should be valid.\n        return this.getUnfilteredTimelineSet().compareEventOrdering(a.eventId, b.eventId) ?? a.data.ts - b.data.ts;\n    }\n\n    /**\n     * Get the ID of the event that a given user has read up to, or null if:\n     * - we have received no read receipts for them, or\n     * - the receipt we have points at an event we don't have, or\n     * - the thread ID in the receipt does not match the thread root of the\n     *   referenced event.\n     *\n     * (The event might not exist if it is not loaded, and the thread ID might\n     * not match if the event has moved thread because it was redacted.)\n     *\n     * @param userId - The user ID to get read receipt event ID for\n     * @param ignoreSynthesized - If true, return only receipts that have been\n     *                            sent by the server, not implicit ones generated\n     *                            by the JS SDK.\n     * @returns ID of the latest existing event that the given user has read, or null.\n     */\n    public getEventReadUpTo(userId: string, ignoreSynthesized = false): string | null {\n        // Find what the latest receipt says is the latest event we have read\n        const latestReceipt = this.getLatestReceipt(userId, ignoreSynthesized);\n\n        if (!latestReceipt) {\n            return null;\n        }\n\n        return this.receiptPointsAtConsistentEvent(latestReceipt) ? latestReceipt.eventId : null;\n    }\n\n    /**\n     * Returns true if the event pointed at by this receipt exists, and its\n     * threadRootId is consistent with the thread information in the receipt.\n     */\n    private receiptPointsAtConsistentEvent(receipt: WrappedReceipt): boolean {\n        const event = this.findEventById(receipt.eventId);\n        if (!event) {\n            // If the receipt points at a non-existent event, we have multiple\n            // possibilities:\n            //\n            // 1. We don't have the event because it's not loaded yet - probably\n            //    it's old and we're best off ignoring the receipt - we can just\n            //    send a new one when we read a new event.\n            //\n            // 2. We have a bug e.g. we misclassified this event into the wrong\n            //    thread.\n            //\n            // 3. The referenced event moved out of this thread (e.g. because it\n            //    was deleted.)\n            //\n            // 4. The receipt had the incorrect thread ID (due to a bug in a\n            // client, or malicious behaviour).\n\n            // This receipt is not \"valid\" because it doesn't point at an event\n            // we have. We want to pretend it doesn't exist.\n            return false;\n        }\n\n        if (!receipt.data?.thread_id) {\n            // If this is an unthreaded receipt, it could point at any event, so\n            // there is no need to validate further - this receipt is valid.\n            return true;\n        }\n        // Otherwise it is a threaded receipt...\n\n        if (receipt.data.thread_id === MAIN_ROOM_TIMELINE) {\n            // The receipt is for the main timeline: we check that the event is\n            // in the main timeline.\n\n            // Check if the event is in the main timeline\n            const eventIsInMainTimeline = inMainTimelineForReceipt(event);\n\n            if (eventIsInMainTimeline) {\n                // The receipt is for the main timeline, and so is the event, so\n                // the receipt is valid.\n                return true;\n            }\n        } else {\n            // The receipt is for a different thread (not the main timeline)\n\n            if (event.threadRootId === receipt.data.thread_id) {\n                // If the receipt and event agree on the thread ID, the receipt\n                // is valid.\n                return true;\n            }\n        }\n\n        // The receipt thread ID disagrees with the event thread ID. There are 2\n        // possibilities:\n        //\n        // 1. The event moved to a different thread after the receipt was\n        //    created. This can happen if the event was redacted because that\n        //    moves it to the main timeline.\n        //\n        // 2. There is a bug somewhere - either we put the event into the wrong\n        //    thread, or someone sent an incorrect receipt.\n        //\n        // In many cases, we won't get here because the call to findEventById\n        // would have already returned null. We include this check to cover\n        // cases when `this` is a  room, meaning findEventById will find events\n        // in any thread, and to be defensive against unforeseen code paths.\n        logger.warn(\n            `Ignoring receipt because its thread_id (${receipt.data.thread_id}) disagrees ` +\n                `with the thread root (${event.threadRootId}) of the referenced event ` +\n                `(event ID = ${receipt.eventId})`,\n        );\n\n        // This receipt is not \"valid\" because it disagrees with us about what\n        // thread the event is in. We want to pretend it doesn't exist.\n        return false;\n    }\n\n    private getLatestReceipt(userId: string, ignoreSynthesized: boolean): WrappedReceipt | null {\n        // XXX: This is very very ugly and I hope I won't have to ever add a new\n        // receipt type here again. IMHO this should be done by the server in\n        // some more intelligent manner or the client should just use timestamps\n\n        const publicReadReceipt = this.getReadReceiptForUserId(userId, ignoreSynthesized, ReceiptType.Read);\n        const privateReadReceipt = this.getReadReceiptForUserId(userId, ignoreSynthesized, ReceiptType.ReadPrivate);\n\n        // If we have both, compare them\n        let comparison: number | null | undefined;\n        if (publicReadReceipt?.eventId && privateReadReceipt?.eventId) {\n            comparison = this.compareReceipts(publicReadReceipt, privateReadReceipt);\n        }\n\n        // The public receipt is more likely to drift out of date so the private\n        // one has precedence\n        if (!comparison) return privateReadReceipt ?? publicReadReceipt ?? null;\n\n        // If public read receipt is older, return the private one\n        return (comparison < 0 ? privateReadReceipt : publicReadReceipt) ?? null;\n    }\n\n    public addReceiptToStructure(\n        eventId: string,\n        receiptType: ReceiptType,\n        userId: string,\n        receipt: Receipt,\n        synthetic: boolean,\n    ): void {\n        const receiptTypesMap = this.receipts.getOrCreate(receiptType);\n        let pair = receiptTypesMap.get(userId);\n\n        if (!pair) {\n            pair = [null, null];\n            receiptTypesMap.set(userId, pair);\n        }\n\n        let existingReceipt = pair[ReceiptPairRealIndex];\n        if (synthetic) {\n            existingReceipt = pair[ReceiptPairSyntheticIndex] ?? pair[ReceiptPairRealIndex];\n        }\n\n        const wrappedReceipt: WrappedReceipt = {\n            eventId,\n            data: receipt,\n        };\n\n        if (existingReceipt) {\n            // We only want to add this receipt if we think it is later than the one we already have.\n            // This is managed server-side, but because we synthesize RRs locally we have to do it here too.\n            const ordering = this.compareReceipts(existingReceipt, wrappedReceipt);\n            if (ordering >= 0) {\n                return;\n            }\n        }\n\n        const realReceipt = synthetic ? pair[ReceiptPairRealIndex] : wrappedReceipt;\n        const syntheticReceipt = synthetic ? wrappedReceipt : pair[ReceiptPairSyntheticIndex];\n\n        let ordering: number | null = null;\n        if (realReceipt && syntheticReceipt) {\n            ordering = this.getUnfilteredTimelineSet().compareEventOrdering(\n                realReceipt.eventId,\n                syntheticReceipt.eventId,\n            );\n        }\n\n        const preferSynthetic = ordering === null || ordering < 0;\n\n        // we don't bother caching just real receipts by event ID as there's nothing that would read it.\n        // Take the current cached receipt before we overwrite the pair elements.\n        const cachedReceipt = pair[ReceiptPairSyntheticIndex] ?? pair[ReceiptPairRealIndex];\n\n        if (synthetic && preferSynthetic) {\n            pair[ReceiptPairSyntheticIndex] = wrappedReceipt;\n        } else if (!synthetic) {\n            pair[ReceiptPairRealIndex] = wrappedReceipt;\n\n            if (!preferSynthetic) {\n                pair[ReceiptPairSyntheticIndex] = null;\n            }\n        }\n\n        const newCachedReceipt = pair[ReceiptPairSyntheticIndex] ?? pair[ReceiptPairRealIndex];\n        if (cachedReceipt === newCachedReceipt) return;\n\n        // clean up any previous cache entry\n        if (cachedReceipt && this.receiptCacheByEventId.get(cachedReceipt.eventId)) {\n            const previousEventId = cachedReceipt.eventId;\n            // Remove the receipt we're about to clobber out of existence from the cache\n            this.receiptCacheByEventId.set(\n                previousEventId,\n                this.receiptCacheByEventId.get(previousEventId)!.filter((r) => {\n                    return r.type !== receiptType || r.userId !== userId;\n                }),\n            );\n\n            if (this.receiptCacheByEventId.get(previousEventId)!.length < 1) {\n                this.receiptCacheByEventId.delete(previousEventId); // clean up the cache keys\n            }\n        }\n\n        // cache the new one\n        if (!this.receiptCacheByEventId.get(eventId)) {\n            this.receiptCacheByEventId.set(eventId, []);\n        }\n        this.receiptCacheByEventId.get(eventId)!.push({\n            userId: userId,\n            type: receiptType as ReceiptType,\n            data: receipt,\n        });\n    }\n\n    /**\n     * Get a list of receipts for the given event.\n     * @param event - the event to get receipts for\n     * @returns A list of receipts with a userId, type and data keys or\n     * an empty list.\n     */\n    public getReceiptsForEvent(event: MatrixEvent): CachedReceipt[] {\n        return this.receiptCacheByEventId.get(event.getId()!) || [];\n    }\n\n    public abstract addReceipt(event: MatrixEvent, synthetic: boolean): void;\n\n    public abstract setUnread(type: NotificationCountType, count: number): void;\n\n    /**\n     * Look in this room/thread's timeline to find an event. If `this` is a\n     * room, we look in all threads, but if `this` is a thread, we look only\n     * inside this thread.\n     */\n    public abstract findEventById(eventId: string): MatrixEvent | undefined;\n\n    /**\n     * This issue should also be addressed on synapse's side and is tracked as part\n     * of https://github.com/matrix-org/synapse/issues/14837\n     *\n     * Retrieves the read receipt for the logged in user and checks if it matches\n     * the last event in the room and whether that event originated from the logged\n     * in user.\n     * Under those conditions we can consider the context as read. This is useful\n     * because we never send read receipts against our own events\n     * @param userId - the logged in user\n     */\n    public fixupNotifications(userId: string): void {\n        const receipt = this.getReadReceiptForUserId(userId, false);\n\n        const lastEvent = this.timeline[this.timeline.length - 1];\n        if (lastEvent && receipt?.eventId === lastEvent.getId() && userId === lastEvent.getSender()) {\n            this.setUnread(NotificationCountType.Total, 0);\n            this.setUnread(NotificationCountType.Highlight, 0);\n        }\n    }\n\n    /**\n     * Add a temporary local-echo receipt to the room to reflect in the\n     * client the fact that we've sent one.\n     * @param userId - The user ID if the receipt sender\n     * @param e - The event that is to be acknowledged\n     * @param receiptType - The type of receipt\n     * @param unthreaded - the receipt is unthreaded\n     */\n    public addLocalEchoReceipt(userId: string, e: MatrixEvent, receiptType: ReceiptType, unthreaded = false): void {\n        this.addReceipt(synthesizeReceipt(userId, e, receiptType, unthreaded), true);\n    }\n\n    /**\n     * Get a list of user IDs who have <b>read up to</b> the given event.\n     * @param event - the event to get read receipts for.\n     * @returns A list of user IDs.\n     */\n    public getUsersReadUpTo(event: MatrixEvent): string[] {\n        return this.getReceiptsForEvent(event)\n            .filter(function (receipt) {\n                return isSupportedReceiptType(receipt.type);\n            })\n            .map(function (receipt) {\n                return receipt.userId;\n            });\n    }\n\n    /**\n     * Determines if the given user has read a particular event ID with the known\n     * history of the room. This is not a definitive check as it relies only on\n     * what is available to the room at the time of execution.\n     * @param userId - The user ID to check the read state of.\n     * @param eventId - The event ID to check if the user read.\n     * @returns True if the user has read the event, false otherwise.\n     */\n    public abstract hasUserReadEvent(userId: string, eventId: string): boolean;\n\n    /**\n     * Returns the most recent unthreaded receipt for a given user\n     * @param userId - the MxID of the User\n     * @returns an unthreaded Receipt. Can be undefined if receipts have been disabled\n     * or a user chooses to use private read receipts (or we have simply not received\n     * a receipt from this user yet).\n     *\n     * @deprecated use `hasUserReadEvent` or `getEventReadUpTo` instead\n     */\n    public abstract getLastUnthreadedReceiptFor(userId: string): Receipt | undefined;\n}\n","/*\nCopyright 2022 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { type Relations, type RelationsEvent, type EventHandlerMap } from \"./relations.ts\";\nimport { type MatrixEvent } from \"./event.ts\";\nimport { type Listener } from \"./typed-event-emitter.ts\";\n\nexport class RelatedRelations {\n    private relations: Relations[];\n\n    public constructor(relations: Relations[]) {\n        this.relations = relations.filter((r) => !!r);\n    }\n\n    public getRelations(): MatrixEvent[] {\n        return this.relations.reduce<MatrixEvent[]>((c, p) => [...c, ...p.getRelations()], []);\n    }\n\n    public on<T extends RelationsEvent>(ev: T, fn: Listener<RelationsEvent, EventHandlerMap, T>): void {\n        this.relations.forEach((r) => r.on(ev, fn));\n    }\n\n    public off<T extends RelationsEvent>(ev: T, fn: Listener<RelationsEvent, EventHandlerMap, T>): void {\n        this.relations.forEach((r) => r.off(ev, fn));\n    }\n}\n","/*\nCopyright 2022 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { Relations } from \"./relations.ts\";\nimport { type EventType, type RelationType } from \"../@types/event.ts\";\nimport { EventStatus, type MatrixEvent, MatrixEventEvent } from \"./event.ts\";\nimport { type EventTimelineSet } from \"./event-timeline-set.ts\";\nimport { type MatrixClient } from \"../client.ts\";\nimport { type Room } from \"./room.ts\";\n\nexport class RelationsContainer {\n    // A tree of objects to access a set of related children for an event, as in:\n    // this.relations.get(parentEventId).get(relationType).get(relationEventType)\n    private relations = new Map<string, Map<RelationType | string, Map<EventType | string, Relations>>>();\n\n    public constructor(\n        private readonly client: MatrixClient,\n        private readonly room?: Room,\n    ) {}\n\n    /**\n     * Get a collection of child events to a given event in this timeline set.\n     *\n     * @param eventId - The ID of the event that you'd like to access child events for.\n     * For example, with annotations, this would be the ID of the event being annotated.\n     * @param relationType - The type of relationship involved, such as \"m.annotation\", \"m.reference\", \"m.replace\", etc.\n     * @param eventType - The relation event's type, such as \"m.reaction\", etc.\n     * @throws If `eventId</code>, <code>relationType</code> or <code>eventType`\n     * are not valid.\n     *\n     * @returns\n     * A container for relation events or undefined if there are no relation events for\n     * the relationType.\n     */\n    public getChildEventsForEvent(\n        eventId: string,\n        relationType: RelationType | string,\n        eventType: EventType | string,\n    ): Relations | undefined {\n        return this.relations.get(eventId)?.get(relationType)?.get(eventType);\n    }\n\n    public getAllChildEventsForEvent(parentEventId: string): MatrixEvent[] {\n        const relationsForEvent =\n            this.relations.get(parentEventId) ?? new Map<RelationType | string, Map<EventType | string, Relations>>();\n        const events: MatrixEvent[] = [];\n        for (const relationsRecord of relationsForEvent.values()) {\n            for (const relations of relationsRecord.values()) {\n                events.push(...relations.getRelations());\n            }\n        }\n        return events;\n    }\n\n    /**\n     * Set an event as the target event if any Relations exist for it already.\n     * Child events can point to other child events as their parent, so this method may be\n     * called for events which are also logically child events.\n     *\n     * @param event - The event to check as relation target.\n     */\n    public aggregateParentEvent(event: MatrixEvent): void {\n        const relationsForEvent = this.relations.get(event.getId()!);\n        if (!relationsForEvent) return;\n\n        for (const relationsWithRelType of relationsForEvent.values()) {\n            for (const relationsWithEventType of relationsWithRelType.values()) {\n                relationsWithEventType.setTargetEvent(event);\n            }\n        }\n    }\n\n    /**\n     * Add relation events to the relevant relation collection.\n     *\n     * @param event - The new child event to be aggregated.\n     * @param timelineSet - The event timeline set within which to search for the related event if any.\n     */\n    public aggregateChildEvent(event: MatrixEvent, timelineSet?: EventTimelineSet): void {\n        if (event.isRedacted() || event.status === EventStatus.CANCELLED) {\n            return;\n        }\n\n        const relation = event.getRelation();\n        if (!relation) return;\n\n        const onEventDecrypted = (): void => {\n            if (event.isDecryptionFailure()) {\n                // This could for example happen if the encryption keys are not yet available.\n                // The event may still be decrypted later. Register the listener again.\n                event.once(MatrixEventEvent.Decrypted, onEventDecrypted);\n                return;\n            }\n\n            this.aggregateChildEvent(event, timelineSet);\n        };\n\n        // If the event is currently encrypted, wait until it has been decrypted.\n        if (event.isBeingDecrypted() || event.shouldAttemptDecryption()) {\n            event.once(MatrixEventEvent.Decrypted, onEventDecrypted);\n            return;\n        }\n\n        const { event_id: relatesToEventId, rel_type: relationType } = relation;\n        const eventType = event.getType();\n\n        let relationsForEvent = this.relations.get(relatesToEventId!);\n        if (!relationsForEvent) {\n            relationsForEvent = new Map<RelationType | string, Map<EventType | string, Relations>>();\n            this.relations.set(relatesToEventId!, relationsForEvent);\n        }\n\n        let relationsWithRelType = relationsForEvent.get(relationType!);\n        if (!relationsWithRelType) {\n            relationsWithRelType = new Map<EventType | string, Relations>();\n            relationsForEvent.set(relationType!, relationsWithRelType);\n        }\n\n        let relationsWithEventType = relationsWithRelType.get(eventType);\n        if (!relationsWithEventType) {\n            relationsWithEventType = new Relations(relationType!, eventType, this.client);\n            relationsWithRelType.set(eventType, relationsWithEventType);\n\n            const room = this.room ?? timelineSet?.room;\n            const relatesToEvent =\n                timelineSet?.findEventById(relatesToEventId!) ??\n                room?.findEventById(relatesToEventId!) ??\n                room?.getPendingEvent(relatesToEventId!);\n            if (relatesToEvent) {\n                relationsWithEventType.setTargetEvent(relatesToEvent);\n            }\n        }\n\n        relationsWithEventType.addEvent(event);\n    }\n}\n","/*\nCopyright 2019, 2021, 2023 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { EventStatus, type IAggregatedRelation, type MatrixEvent, MatrixEventEvent } from \"./event.ts\";\nimport { logger } from \"../logger.ts\";\nimport { RelationType } from \"../@types/event.ts\";\nimport { TypedEventEmitter } from \"./typed-event-emitter.ts\";\nimport { type MatrixClient } from \"../client.ts\";\nimport { Room } from \"./room.ts\";\nimport { type CryptoBackend } from \"../common-crypto/CryptoBackend.ts\";\n\nexport enum RelationsEvent {\n    Add = \"Relations.add\",\n    Remove = \"Relations.remove\",\n    Redaction = \"Relations.redaction\",\n}\n\nexport type EventHandlerMap = {\n    [RelationsEvent.Add]: (event: MatrixEvent) => void;\n    [RelationsEvent.Remove]: (event: MatrixEvent) => void;\n    [RelationsEvent.Redaction]: (event: MatrixEvent) => void;\n};\n\nconst matchesEventType = (eventType: string, targetEventType: string, altTargetEventTypes: string[] = []): boolean =>\n    [targetEventType, ...altTargetEventTypes].includes(eventType);\n\n/**\n * A container for relation events that supports easy access to common ways of\n * aggregating such events. Each instance holds events that of a single relation\n * type and event type. All of the events also relate to the same original event.\n *\n * The typical way to get one of these containers is via\n * EventTimelineSet#getRelationsForEvent.\n */\nexport class Relations extends TypedEventEmitter<RelationsEvent, EventHandlerMap> {\n    private relationEventIds = new Set<string>();\n    private relations = new Set<MatrixEvent>();\n    private annotationsByKey: Record<string, Set<MatrixEvent>> = {};\n    private annotationsBySender: Record<string, Set<MatrixEvent>> = {};\n    private sortedAnnotationsByKey: [string, Set<MatrixEvent>][] = [];\n    private targetEvent: MatrixEvent | null = null;\n    private creationEmitted = false;\n    private readonly client: MatrixClient;\n\n    /**\n     * @param relationType - The type of relation involved, such as \"m.annotation\", \"m.reference\", \"m.replace\", etc.\n     * @param eventType - The relation event's type, such as \"m.reaction\", etc.\n     * @param client - The client which created this instance. For backwards compatibility also accepts a Room.\n     * @param altEventTypes - alt event types for relation events, for example to support unstable prefixed event types\n     */\n    public constructor(\n        public readonly relationType: RelationType | string,\n        public readonly eventType: string,\n        client: MatrixClient | Room,\n        public readonly altEventTypes?: string[],\n    ) {\n        super();\n        this.client = client instanceof Room ? client.client : client;\n    }\n\n    /**\n     * Add relation events to this collection.\n     *\n     * @param event - The new relation event to be added.\n     */\n    public async addEvent(event: MatrixEvent): Promise<void> {\n        if (this.relationEventIds.has(event.getId()!)) {\n            return;\n        }\n\n        const relation = event.getRelation();\n        if (!relation) {\n            logger.error(\"Event must have relation info\");\n            return;\n        }\n\n        const relationType = relation.rel_type;\n        const eventType = event.getType();\n\n        if (this.relationType !== relationType || !matchesEventType(eventType, this.eventType, this.altEventTypes)) {\n            logger.error(\"Event relation info doesn't match this container\");\n            return;\n        }\n\n        // If the event is in the process of being sent, listen for cancellation\n        // so we can remove the event from the collection.\n        if (event.isSending()) {\n            event.on(MatrixEventEvent.Status, this.onEventStatus);\n        }\n\n        this.relations.add(event);\n        this.relationEventIds.add(event.getId()!);\n\n        if (this.relationType === RelationType.Annotation) {\n            this.addAnnotationToAggregation(event);\n        } else if (this.relationType === RelationType.Replace && this.targetEvent && !this.targetEvent.isState()) {\n            const lastReplacement = await this.getLastReplacement();\n            this.targetEvent.makeReplaced(lastReplacement!);\n        }\n\n        event.on(MatrixEventEvent.BeforeRedaction, this.onBeforeRedaction);\n\n        this.emit(RelationsEvent.Add, event);\n\n        this.maybeEmitCreated();\n    }\n\n    /**\n     * Remove relation event from this collection.\n     *\n     * @param event - The relation event to remove.\n     */\n    public async removeEvent(event: MatrixEvent): Promise<void> {\n        if (!this.relations.has(event)) {\n            return;\n        }\n\n        this.relations.delete(event);\n\n        if (this.relationType === RelationType.Annotation) {\n            this.removeAnnotationFromAggregation(event);\n        } else if (this.relationType === RelationType.Replace && this.targetEvent && !this.targetEvent.isState()) {\n            const lastReplacement = await this.getLastReplacement();\n            this.targetEvent.makeReplaced(lastReplacement!);\n        }\n\n        this.emit(RelationsEvent.Remove, event);\n    }\n\n    /**\n     * Listens for event status changes to remove cancelled events.\n     *\n     * @param event - The event whose status has changed\n     * @param status - The new status\n     */\n    private onEventStatus = (event: MatrixEvent, status: EventStatus | null): void => {\n        if (!event.isSending()) {\n            // Sending is done, so we don't need to listen anymore\n            event.removeListener(MatrixEventEvent.Status, this.onEventStatus);\n            return;\n        }\n        if (status !== EventStatus.CANCELLED) {\n            return;\n        }\n        // Event was cancelled, remove from the collection\n        event.removeListener(MatrixEventEvent.Status, this.onEventStatus);\n        this.removeEvent(event);\n    };\n\n    /**\n     * Get all relation events in this collection.\n     *\n     * These are currently in the order of insertion to this collection, which\n     * won't match timeline order in the case of scrollback.\n     * TODO: Tweak `addEvent` to insert correctly for scrollback.\n     *\n     * Relation events in insertion order.\n     */\n    public getRelations(): MatrixEvent[] {\n        return [...this.relations];\n    }\n\n    private addAnnotationToAggregation(event: MatrixEvent): void {\n        const { key } = event.getRelation() ?? {};\n        if (!key) return;\n\n        let eventsForKey = this.annotationsByKey[key];\n        if (!eventsForKey) {\n            eventsForKey = this.annotationsByKey[key] = new Set();\n            this.sortedAnnotationsByKey.push([key, eventsForKey]);\n        }\n        // Add the new event to the set for this key\n        eventsForKey.add(event);\n        // Re-sort the [key, events] pairs in descending order of event count\n        this.sortedAnnotationsByKey.sort((a, b) => {\n            const aEvents = a[1];\n            const bEvents = b[1];\n            return bEvents.size - aEvents.size;\n        });\n\n        const sender = event.getSender()!;\n        let eventsFromSender = this.annotationsBySender[sender];\n        if (!eventsFromSender) {\n            eventsFromSender = this.annotationsBySender[sender] = new Set();\n        }\n        // Add the new event to the set for this sender\n        eventsFromSender.add(event);\n    }\n\n    private removeAnnotationFromAggregation(event: MatrixEvent): void {\n        const { key } = event.getRelation() ?? {};\n        if (!key) return;\n\n        const eventsForKey = this.annotationsByKey[key];\n        if (eventsForKey) {\n            eventsForKey.delete(event);\n\n            // Re-sort the [key, events] pairs in descending order of event count\n            this.sortedAnnotationsByKey.sort((a, b) => {\n                const aEvents = a[1];\n                const bEvents = b[1];\n                return bEvents.size - aEvents.size;\n            });\n        }\n\n        const sender = event.getSender()!;\n        const eventsFromSender = this.annotationsBySender[sender];\n        if (eventsFromSender) {\n            eventsFromSender.delete(event);\n        }\n    }\n\n    /**\n     * For relations that have been redacted, we want to remove them from\n     * aggregation data sets and emit an update event.\n     *\n     * To do so, we listen for `Event.beforeRedaction`, which happens:\n     *   - after the server accepted the redaction and remote echoed back to us\n     *   - before the original event has been marked redacted in the client\n     *\n     * @param redactedEvent - The original relation event that is about to be redacted.\n     */\n    private onBeforeRedaction = async (redactedEvent: MatrixEvent): Promise<void> => {\n        if (!this.relations.has(redactedEvent)) {\n            return;\n        }\n\n        this.relations.delete(redactedEvent);\n\n        if (this.relationType === RelationType.Annotation) {\n            // Remove the redacted annotation from aggregation by key\n            this.removeAnnotationFromAggregation(redactedEvent);\n        } else if (this.relationType === RelationType.Replace && this.targetEvent && !this.targetEvent.isState()) {\n            const lastReplacement = await this.getLastReplacement();\n            this.targetEvent.makeReplaced(lastReplacement!);\n        }\n\n        redactedEvent.removeListener(MatrixEventEvent.BeforeRedaction, this.onBeforeRedaction);\n\n        this.emit(RelationsEvent.Redaction, redactedEvent);\n    };\n\n    /**\n     * Get all events in this collection grouped by key and sorted by descending\n     * event count in each group.\n     *\n     * This is currently only supported for the annotation relation type.\n     *\n     * An array of [key, events] pairs sorted by descending event count.\n     * The events are stored in a Set (which preserves insertion order).\n     */\n    public getSortedAnnotationsByKey(): [string, Set<MatrixEvent>][] | null {\n        if (this.relationType !== RelationType.Annotation) {\n            // Other relation types are not grouped currently.\n            return null;\n        }\n\n        return this.sortedAnnotationsByKey;\n    }\n\n    /**\n     * Get all events in this collection grouped by sender.\n     *\n     * This is currently only supported for the annotation relation type.\n     *\n     * An object with each relation sender as a key and the matching Set of\n     * events for that sender as a value.\n     */\n    public getAnnotationsBySender(): Record<string, Set<MatrixEvent>> | null {\n        if (this.relationType !== RelationType.Annotation) {\n            // Other relation types are not grouped currently.\n            return null;\n        }\n\n        return this.annotationsBySender;\n    }\n\n    /**\n     * Returns the most recent (and allowed) m.replace relation, if any.\n     *\n     * This is currently only supported for the m.replace relation type,\n     * once the target event is known, see `addEvent`.\n     */\n    public async getLastReplacement(): Promise<MatrixEvent | null> {\n        if (this.relationType !== RelationType.Replace) {\n            // Aggregating on last only makes sense for this relation type\n            return null;\n        }\n        if (!this.targetEvent) {\n            // Don't know which replacements to accept yet.\n            // This method shouldn't be called before the original\n            // event is known anyway.\n            return null;\n        }\n\n        // the all-knowning server tells us that the event at some point had\n        // this timestamp for its replacement, so any following replacement should definitely not be less\n        const replaceRelation = this.targetEvent.getServerAggregatedRelation<IAggregatedRelation>(RelationType.Replace);\n        const minTs = replaceRelation?.origin_server_ts;\n\n        const lastReplacement = this.getRelations().reduce<MatrixEvent | null>((last, event) => {\n            if (event.getSender() !== this.targetEvent!.getSender()) {\n                return last;\n            }\n            if (minTs && minTs > event.getTs()) {\n                return last;\n            }\n            if (last && last.getTs() > event.getTs()) {\n                return last;\n            }\n            return event;\n        }, null);\n\n        if (lastReplacement?.shouldAttemptDecryption() && this.client.getCrypto()) {\n            // Dirty but we are expecting to pass the cryptoBackend which is not accessible here\n            await lastReplacement.attemptDecryption(this.client.getCrypto() as CryptoBackend);\n        } else if (lastReplacement?.isBeingDecrypted()) {\n            await lastReplacement.getDecryptionPromise();\n        }\n\n        return lastReplacement;\n    }\n\n    /*\n     * @param targetEvent - the event the relations are related to.\n     */\n    public async setTargetEvent(event: MatrixEvent): Promise<void> {\n        if (this.targetEvent) {\n            return;\n        }\n        this.targetEvent = event;\n\n        if (this.relationType === RelationType.Replace && !this.targetEvent.isState()) {\n            const replacement = await this.getLastReplacement();\n            // this is the initial update, so only call it if we already have something\n            // to not emit Event.replaced needlessly\n            if (replacement) {\n                this.targetEvent.makeReplaced(replacement);\n            }\n        }\n\n        this.maybeEmitCreated();\n    }\n\n    private maybeEmitCreated(): void {\n        if (this.creationEmitted) {\n            return;\n        }\n        // Only emit we're \"created\" once we have a target event instance _and_\n        // at least one related event.\n        if (!this.targetEvent || !this.relations.size) {\n            return;\n        }\n        this.creationEmitted = true;\n        this.targetEvent.emit(MatrixEventEvent.RelationsCreated, this.relationType, this.eventType);\n    }\n}\n","/*\nCopyright 2015 - 2021 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { getHttpUriForMxc } from \"../content-repo.ts\";\nimport { removeDirectionOverrideChars, removeHiddenChars } from \"../utils.ts\";\nimport { type User } from \"./user.ts\";\nimport { type MatrixEvent } from \"./event.ts\";\nimport { type RoomState } from \"./room-state.ts\";\nimport { logger } from \"../logger.ts\";\nimport { TypedEventEmitter } from \"./typed-event-emitter.ts\";\nimport { EventType } from \"../@types/event.ts\";\nimport { KnownMembership, type Membership } from \"../@types/membership.ts\";\n\nexport enum RoomMemberEvent {\n    Membership = \"RoomMember.membership\",\n    Name = \"RoomMember.name\",\n    PowerLevel = \"RoomMember.powerLevel\",\n    Typing = \"RoomMember.typing\",\n}\n\nexport type RoomMemberEventHandlerMap = {\n    /**\n     * Fires whenever any room member's membership state changes.\n     * @param event - The matrix event which caused this event to fire.\n     * @param member - The member whose RoomMember.membership changed.\n     * @param oldMembership - The previous membership state. Null if it's a new member.\n     * @example\n     * ```\n     * matrixClient.on(\"RoomMember.membership\", function(event, member, oldMembership){\n     *   var newState = member.membership;\n     * });\n     * ```\n     */\n    [RoomMemberEvent.Membership]: (event: MatrixEvent, member: RoomMember, oldMembership?: string) => void;\n    /**\n     * Fires whenever any room member's name changes.\n     * @param event - The matrix event which caused this event to fire.\n     * @param member - The member whose RoomMember.name changed.\n     * @param oldName - The previous name. Null if the member didn't have a name previously.\n     * @example\n     * ```\n     * matrixClient.on(\"RoomMember.name\", function(event, member){\n     *   var newName = member.name;\n     * });\n     * ```\n     */\n    [RoomMemberEvent.Name]: (event: MatrixEvent, member: RoomMember, oldName: string | null) => void;\n    /**\n     * Fires whenever any room member's power level changes.\n     * @param event - The matrix event which caused this event to fire.\n     * @param member - The member whose RoomMember.powerLevel changed.\n     * @example\n     * ```\n     * matrixClient.on(\"RoomMember.powerLevel\", function(event, member){\n     *   var newPowerLevel = member.powerLevel;\n     *   var newNormPowerLevel = member.powerLevelNorm;\n     * });\n     * ```\n     */\n    [RoomMemberEvent.PowerLevel]: (event: MatrixEvent, member: RoomMember) => void;\n    /**\n     * Fires whenever any room member's typing state changes.\n     * @param event - The matrix event which caused this event to fire.\n     * @param member - The member whose RoomMember.typing changed.\n     * @example\n     * ```\n     * matrixClient.on(\"RoomMember.typing\", function(event, member){\n     *   var isTyping = member.typing;\n     * });\n     * ```\n     */\n    [RoomMemberEvent.Typing]: (event: MatrixEvent, member: RoomMember) => void;\n};\n\nexport class RoomMember extends TypedEventEmitter<RoomMemberEvent, RoomMemberEventHandlerMap> {\n    private _isOutOfBand = false;\n    private modified = -1;\n    public requestedProfileInfo = false; // used by sync.ts\n\n    // XXX these should be read-only\n    /**\n     * True if the room member is currently typing.\n     */\n    public typing = false;\n    /**\n     * The human-readable name for this room member. This will be\n     * disambiguated with a suffix of \" (\\@user_id:matrix.org)\" if another member shares the\n     * same displayname.\n     */\n    public name: string;\n    /**\n     * The ambiguous displayname of this room member.\n     */\n    public rawDisplayName: string;\n    /**\n     * The power level for this room member.\n     */\n    public powerLevel = 0;\n    /**\n     * The normalised power level (0-100) for this room member.\n     */\n    public powerLevelNorm = 0;\n    /**\n     * The User object for this room member, if one exists.\n     */\n    public user?: User;\n    /**\n     * The membership state for this room member e.g. 'join'.\n     */\n    public membership?: Membership;\n    /**\n     * True if the member's name is disambiguated.\n     */\n    public disambiguate = false;\n    /**\n     * The events describing this RoomMember.\n     */\n    public events: {\n        /**\n         * The m.room.member event for this RoomMember.\n         */\n        member?: MatrixEvent;\n    } = {};\n\n    /**\n     * Construct a new room member.\n     *\n     * @param roomId - The room ID of the member.\n     * @param userId - The user ID of the member.\n     */\n    public constructor(\n        public readonly roomId: string,\n        public readonly userId: string,\n    ) {\n        super();\n\n        this.name = userId;\n        this.rawDisplayName = userId;\n        this.updateModifiedTime();\n    }\n\n    /**\n     * Mark the member as coming from a channel that is not sync\n     */\n    public markOutOfBand(): void {\n        this._isOutOfBand = true;\n    }\n\n    /**\n     * @returns does the member come from a channel that is not sync?\n     * This is used to store the member seperately\n     * from the sync state so it available across browser sessions.\n     */\n    public isOutOfBand(): boolean {\n        return this._isOutOfBand;\n    }\n\n    /**\n     * Update this room member's membership event. May fire \"RoomMember.name\" if\n     * this event updates this member's name.\n     * @param event - The `m.room.member` event\n     * @param roomState - Optional. The room state to take into account\n     * when calculating (e.g. for disambiguating users with the same name).\n     *\n     * @remarks\n     * Fires {@link RoomMemberEvent.Name}\n     * Fires {@link RoomMemberEvent.Membership}\n     */\n    public setMembershipEvent(event: MatrixEvent, roomState?: RoomState): void {\n        const displayName = event.getDirectionalContent().displayname ?? \"\";\n\n        if (event.getType() !== EventType.RoomMember) {\n            return;\n        }\n\n        this._isOutOfBand = false;\n\n        this.events.member = event;\n\n        const oldMembership = this.membership;\n        this.membership = event.getDirectionalContent().membership;\n        if (this.membership === undefined) {\n            // logging to diagnose https://github.com/vector-im/element-web/issues/20962\n            // (logs event content, although only of membership events)\n            logger.trace(\n                `membership event with membership undefined (forwardLooking: ${event.forwardLooking})!`,\n                event.getContent(),\n                `prevcontent is `,\n                event.getPrevContent(),\n            );\n        }\n\n        this.disambiguate = shouldDisambiguate(this.userId, displayName, roomState);\n\n        const oldName = this.name;\n        this.name = calculateDisplayName(this.userId, displayName, this.disambiguate);\n\n        // not quite raw: we strip direction override chars so it can safely be inserted into\n        // blocks of text without breaking the text direction\n        this.rawDisplayName = removeDirectionOverrideChars(event.getDirectionalContent().displayname ?? \"\");\n        if (!this.rawDisplayName || !removeHiddenChars(this.rawDisplayName)) {\n            this.rawDisplayName = this.userId;\n        }\n\n        if (oldMembership !== this.membership) {\n            this.updateModifiedTime();\n            this.emit(RoomMemberEvent.Membership, event, this, oldMembership);\n        }\n        if (oldName !== this.name) {\n            this.updateModifiedTime();\n            this.emit(RoomMemberEvent.Name, event, this, oldName);\n        }\n    }\n\n    /**\n     * Update this room member's power level event. May fire\n     * \"RoomMember.powerLevel\" if this event updates this member's power levels.\n     * @param powerLevelEvent - The `m.room.power_levels` event\n     *\n     * @remarks\n     * Fires {@link RoomMemberEvent.PowerLevel}\n     */\n    public setPowerLevelEvent(powerLevelEvent: MatrixEvent): void {\n        if (powerLevelEvent.getType() !== EventType.RoomPowerLevels || powerLevelEvent.getStateKey() !== \"\") {\n            return;\n        }\n\n        const evContent = powerLevelEvent.getDirectionalContent();\n\n        let maxLevel = evContent.users_default || 0;\n        const users: { [userId: string]: number } = evContent.users || {};\n        Object.values(users).forEach((lvl: number) => {\n            maxLevel = Math.max(maxLevel, lvl);\n        });\n        const oldPowerLevel = this.powerLevel;\n        const oldPowerLevelNorm = this.powerLevelNorm;\n\n        if (users[this.userId] !== undefined && Number.isInteger(users[this.userId])) {\n            this.powerLevel = users[this.userId];\n        } else if (evContent.users_default !== undefined) {\n            this.powerLevel = evContent.users_default;\n        } else {\n            this.powerLevel = 0;\n        }\n        this.powerLevelNorm = 0;\n        if (maxLevel > 0) {\n            this.powerLevelNorm = (this.powerLevel * 100) / maxLevel;\n        }\n\n        // emit for changes in powerLevelNorm as well (since the app will need to\n        // redraw everyone's level if the max has changed)\n        if (oldPowerLevel !== this.powerLevel || oldPowerLevelNorm !== this.powerLevelNorm) {\n            this.updateModifiedTime();\n            this.emit(RoomMemberEvent.PowerLevel, powerLevelEvent, this);\n        }\n    }\n\n    /**\n     * Update this room member's typing event. May fire \"RoomMember.typing\" if\n     * this event changes this member's typing state.\n     * @param event - The typing event\n     *\n     * @remarks\n     * Fires {@link RoomMemberEvent.Typing}\n     */\n    public setTypingEvent(event: MatrixEvent): void {\n        if (event.getType() !== \"m.typing\") {\n            return;\n        }\n        const oldTyping = this.typing;\n        this.typing = false;\n        const typingList = event.getContent().user_ids;\n        if (!Array.isArray(typingList)) {\n            // malformed event :/ bail early. TODO: whine?\n            return;\n        }\n        if (typingList.indexOf(this.userId) !== -1) {\n            this.typing = true;\n        }\n        if (oldTyping !== this.typing) {\n            this.updateModifiedTime();\n            this.emit(RoomMemberEvent.Typing, event, this);\n        }\n    }\n\n    /**\n     * Update the last modified time to the current time.\n     */\n    private updateModifiedTime(): void {\n        this.modified = Date.now();\n    }\n\n    /**\n     * Get the timestamp when this RoomMember was last updated. This timestamp is\n     * updated when properties on this RoomMember are updated.\n     * It is updated <i>before</i> firing events.\n     * @returns The timestamp\n     */\n    public getLastModifiedTime(): number {\n        return this.modified;\n    }\n\n    public isKicked(): boolean {\n        return (\n            this.membership === KnownMembership.Leave &&\n            this.events.member !== undefined &&\n            this.events.member.getSender() !== this.events.member.getStateKey()\n        );\n    }\n\n    /**\n     * If this member was invited with the is_direct flag set, return\n     * the user that invited this member\n     * @returns user id of the inviter\n     */\n    public getDMInviter(): string | undefined {\n        // when not available because that room state hasn't been loaded in,\n        // we don't really know, but more likely to not be a direct chat\n        if (this.events.member) {\n            // TODO: persist the is_direct flag on the member as more member events\n            //       come in caused by displayName changes.\n\n            // the is_direct flag is set on the invite member event.\n            // This is copied on the prev_content section of the join member event\n            // when the invite is accepted.\n\n            const memberEvent = this.events.member;\n            let memberContent = memberEvent.getContent();\n            let inviteSender: string | undefined = memberEvent.getSender();\n\n            if (memberContent.membership === KnownMembership.Join) {\n                memberContent = memberEvent.getPrevContent();\n                inviteSender = memberEvent.getUnsigned().prev_sender;\n            }\n\n            if (memberContent.membership === KnownMembership.Invite && memberContent.is_direct) {\n                return inviteSender;\n            }\n        }\n    }\n\n    /**\n     * Get the avatar URL for a room member.\n     * @param baseUrl - The base homeserver URL See\n     * {@link MatrixClient#getHomeserverUrl}.\n     * @param width - The desired width of the thumbnail.\n     * @param height - The desired height of the thumbnail.\n     * @param resizeMethod - The thumbnail resize method to use, either\n     * \"crop\" or \"scale\".\n     * @param allowDefault - (optional) Passing false causes this method to\n     * return null if the user has no avatar image. Otherwise, a default image URL\n     * will be returned. Default: true. (Deprecated)\n     * @param allowDirectLinks - (optional) If true, the avatar URL will be\n     * returned even if it is a direct hyperlink rather than a matrix content URL.\n     * If false, any non-matrix content URLs will be ignored. Setting this option to\n     * true will expose URLs that, if fetched, will leak information about the user\n     * to anyone who they share a room with.\n     * @param useAuthentication - (optional) If true, the caller supports authenticated\n     * media and wants an authentication-required URL. Note that server support for\n     * authenticated media will not be checked - it is the caller's responsibility\n     * to do so before calling this function. Note also that useAuthentication\n     * implies allowRedirects. Defaults to false (unauthenticated endpoints).\n     * @returns the avatar URL or null.\n     */\n    public getAvatarUrl(\n        baseUrl: string,\n        width: number,\n        height: number,\n        resizeMethod: string,\n        allowDefault = true,\n        allowDirectLinks: boolean,\n        useAuthentication: boolean = false,\n    ): string | null {\n        const rawUrl = this.getMxcAvatarUrl();\n\n        if (!rawUrl && !allowDefault) {\n            return null;\n        }\n        const httpUrl = getHttpUriForMxc(\n            baseUrl,\n            rawUrl,\n            width,\n            height,\n            resizeMethod,\n            allowDirectLinks,\n            undefined,\n            useAuthentication,\n        );\n        if (httpUrl) {\n            return httpUrl;\n        }\n        return null;\n    }\n\n    /**\n     * get the mxc avatar url, either from a state event, or from a lazily loaded member\n     * @returns the mxc avatar url\n     */\n    public getMxcAvatarUrl(): string | undefined {\n        if (this.events.member) {\n            return this.events.member.getDirectionalContent().avatar_url;\n        } else if (this.user) {\n            return this.user.avatarUrl;\n        }\n    }\n}\n\nconst MXID_PATTERN = /@.+:.+/;\nconst LTR_RTL_PATTERN = /[\\u200E\\u200F\\u202A-\\u202F]/;\n\nfunction shouldDisambiguate(selfUserId: string, displayName?: string, roomState?: RoomState): boolean {\n    if (!displayName || displayName === selfUserId) return false;\n    if (!roomState) return false;\n\n    const strippedDisplayName = removeHiddenChars(displayName);\n\n    // First check if the displayname is something we consider truthy\n    // after stripping it of zero width characters and padding spaces\n    if (!strippedDisplayName) return false;\n\n    // Next check if the name contains something that look like a mxid\n    // If it does, it may be someone trying to impersonate someone else\n    // Show full mxid in this case\n    if (MXID_PATTERN.test(strippedDisplayName)) return true;\n\n    // Also show mxid if the display name contains any LTR/RTL characters as these\n    // make it very difficult for us to find similar *looking* display names\n    // E.g \"Mark\" could be cloned by writing \"kraM\" but in RTL.\n    if (LTR_RTL_PATTERN.test(displayName)) return true;\n\n    // Also show mxid if there are other people with the same or similar\n    // displayname, after hidden character removal.\n    const userIds = roomState.getUserIdsWithDisplayName(displayName);\n    if (userIds.some((u) => u !== selfUserId)) return true;\n\n    return false;\n}\n\nfunction calculateDisplayName(selfUserId: string, displayName: string | undefined, disambiguate: boolean): string {\n    if (!displayName || displayName === selfUserId) return selfUserId;\n\n    if (disambiguate) return removeDirectionOverrideChars(displayName) + \" (\" + selfUserId + \")\";\n\n    // First check if the displayname is something we consider truthy\n    // after stripping it of zero width characters and padding spaces\n    if (!removeHiddenChars(displayName)) return selfUserId;\n\n    // We always strip the direction override characters (LRO and RLO).\n    // These override the text direction for all subsequent characters\n    // in the paragraph so if display names contained these, they'd\n    // need to be wrapped in something to prevent this from leaking out\n    // (which we can do in HTML but not text) or we'd need to add\n    // control characters to the string to reset any overrides (eg.\n    // adding PDF characters at the end). As far as we can see,\n    // there should be no reason these would be necessary - rtl display\n    // names should flip into the correct direction automatically based on\n    // the characters, and you can still embed rtl in ltr or vice versa\n    // with the embed chars or marker chars.\n    return removeDirectionOverrideChars(displayName);\n}\n","/*\nCopyright 2015 - 2021 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { RoomMember } from \"./room-member.ts\";\nimport { logger } from \"../logger.ts\";\nimport { isNumber, removeHiddenChars } from \"../utils.ts\";\nimport { EventType, UNSTABLE_MSC2716_MARKER } from \"../@types/event.ts\";\nimport { type IEvent, type MatrixEvent, MatrixEventEvent } from \"./event.ts\";\nimport { type MatrixClient } from \"../client.ts\";\nimport { GuestAccess, HistoryVisibility, JoinRule } from \"../@types/partials.ts\";\nimport { TypedEventEmitter } from \"./typed-event-emitter.ts\";\nimport {\n    Beacon,\n    BeaconEvent,\n    type BeaconEventHandlerMap,\n    getBeaconInfoIdentifier,\n    type BeaconIdentifier,\n} from \"./beacon.ts\";\nimport { TypedReEmitter } from \"../ReEmitter.ts\";\nimport { M_BEACON, M_BEACON_INFO } from \"../@types/beacon.ts\";\nimport { KnownMembership } from \"../@types/membership.ts\";\nimport { type RoomJoinRulesEventContent } from \"../@types/state_events.ts\";\n\nexport interface IMarkerFoundOptions {\n    /** Whether the timeline was empty before the marker event arrived in the\n     *  room. This could be happen in a variety of cases:\n     *  1. From the initial sync\n     *  2. It's the first state we're seeing after joining the room\n     *  3. Or whether it's coming from `syncFromCache`\n     *\n     * A marker event refers to `UNSTABLE_MSC2716_MARKER` and indicates that\n     * history was imported somewhere back in time. It specifically points to an\n     * MSC2716 insertion event where the history was imported at. Marker events\n     * are sent as state events so they are easily discoverable by clients and\n     * homeservers and don't get lost in timeline gaps.\n     */\n    timelineWasEmpty?: boolean;\n}\n\n// possible statuses for out-of-band member loading\nenum OobStatus {\n    NotStarted,\n    InProgress,\n    Finished,\n}\n\nexport interface IPowerLevelsContent {\n    users?: Record<string, number>;\n    events?: Record<string, number>;\n    notifications?: Partial<Record<\"room\", number>>;\n    // eslint-disable-next-line camelcase\n    users_default?: number;\n    // eslint-disable-next-line camelcase\n    events_default?: number;\n    // eslint-disable-next-line camelcase\n    state_default?: number;\n    ban?: number;\n    invite?: number;\n    kick?: number;\n    redact?: number;\n}\n\nexport enum RoomStateEvent {\n    Events = \"RoomState.events\",\n    Members = \"RoomState.members\",\n    NewMember = \"RoomState.newMember\",\n    Update = \"RoomState.update\", // signals batches of updates without specificity\n    BeaconLiveness = \"RoomState.BeaconLiveness\",\n    Marker = \"RoomState.Marker\",\n}\n\nexport type RoomStateEventHandlerMap = {\n    /**\n     * Fires whenever the event dictionary in room state is updated.\n     * This does not guarantee that any related objects (like RoomMember) have been updated.\n     * Use RoomStateEvent.Update for that.\n     * @param event - The matrix event which caused this event to fire.\n     * @param state - The room state whose RoomState.events dictionary\n     * was updated.\n     * @param prevEvent - The event being replaced by the new state, if\n     * known. Note that this can differ from `getPrevContent()` on the new state event\n     * as this is the store's view of the last state, not the previous state provided\n     * by the server.\n     * @example\n     * ```\n     * matrixClient.on(\"RoomState.events\", function(event, state, prevEvent){\n     *   var newStateEvent = event;\n     * });\n     * ```\n     */\n    [RoomStateEvent.Events]: (event: MatrixEvent, state: RoomState, prevEvent: MatrixEvent | null) => void;\n    /**\n     * Fires whenever a member in the members dictionary is updated in any way.\n     * @param event - The matrix event which caused this event to fire.\n     * @param state - The room state whose RoomState.members dictionary\n     * was updated.\n     * @param member - The room member that was updated.\n     * @example\n     * ```\n     * matrixClient.on(\"RoomState.members\", function(event, state, member){\n     *   var newMembershipState = member.membership;\n     * });\n     * ```\n     */\n    [RoomStateEvent.Members]: (event: MatrixEvent, state: RoomState, member: RoomMember) => void;\n    /**\n     * Fires whenever a member is added to the members dictionary. The RoomMember\n     * will not be fully populated yet (e.g. no membership state) but will already\n     * be available in the members dictionary.\n     * @param event - The matrix event which caused this event to fire.\n     * @param state - The room state whose RoomState.members dictionary\n     * was updated with a new entry.\n     * @param member - The room member that was added.\n     * @example\n     * ```\n     * matrixClient.on(\"RoomState.newMember\", function(event, state, member){\n     *   // add event listeners on 'member'\n     * });\n     * ```\n     */\n    [RoomStateEvent.NewMember]: (event: MatrixEvent, state: RoomState, member: RoomMember) => void;\n    [RoomStateEvent.Update]: (state: RoomState) => void;\n    [RoomStateEvent.BeaconLiveness]: (state: RoomState, hasLiveBeacons: boolean) => void;\n    [RoomStateEvent.Marker]: (event: MatrixEvent, setStateOptions?: IMarkerFoundOptions) => void;\n    [BeaconEvent.New]: (event: MatrixEvent, beacon: Beacon) => void;\n};\n\ntype EmittedEvents = RoomStateEvent | BeaconEvent;\ntype EventHandlerMap = RoomStateEventHandlerMap & BeaconEventHandlerMap;\n\ntype KeysMatching<T, V> = { [K in keyof T]-?: T[K] extends V ? K : never }[keyof T];\n\nexport class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap> {\n    public readonly reEmitter = new TypedReEmitter<EmittedEvents, EventHandlerMap>(this);\n    private sentinels: Record<string, RoomMember> = {}; // userId: RoomMember\n    // stores fuzzy matches to a list of userIDs (applies utils.removeHiddenChars to keys)\n    private displayNameToUserIds = new Map<string, string[]>();\n    private userIdsToDisplayNames: Record<string, string> = {};\n    private tokenToInvite: Record<string, MatrixEvent> = {}; // 3pid invite state_key to m.room.member invite\n    private joinedMemberCount: number | null = null; // cache of the number of joined members\n    // joined members count from summary api\n    // once set, we know the server supports the summary api\n    // and we should only trust that\n    // we could also only trust that before OOB members\n    // are loaded but doesn't seem worth the hassle atm\n    private summaryJoinedMemberCount: number | null = null;\n    // same for invited member count\n    private invitedMemberCount: number | null = null;\n    private summaryInvitedMemberCount: number | null = null;\n    private modified = -1;\n\n    // XXX: Should be read-only\n    // The room member dictionary, keyed on the user's ID.\n    public members: Record<string, RoomMember> = {}; // userId: RoomMember\n    // The state events dictionary, keyed on the event type and then the state_key value.\n    public events = new Map<string, Map<string, MatrixEvent>>(); // Map<eventType, Map<stateKey, MatrixEvent>>\n    // The pagination token for this state.\n    public paginationToken: string | null = null;\n\n    public readonly beacons = new Map<BeaconIdentifier, Beacon>();\n    private _liveBeaconIds: BeaconIdentifier[] = [];\n\n    /**\n     * Construct room state.\n     *\n     * Room State represents the state of the room at a given point.\n     * It can be mutated by adding state events to it.\n     * There are two types of room member associated with a state event:\n     * normal member objects (accessed via getMember/getMembers) which mutate\n     * with the state to represent the current state of that room/user, e.g.\n     * the object returned by `getMember('@bob:example.com')` will mutate to\n     * get a different display name if Bob later changes his display name\n     * in the room.\n     * There are also 'sentinel' members (accessed via getSentinelMember).\n     * These also represent the state of room members at the point in time\n     * represented by the RoomState object, but unlike objects from getMember,\n     * sentinel objects will always represent the room state as at the time\n     * getSentinelMember was called, so if Bob subsequently changes his display\n     * name, a room member object previously acquired with getSentinelMember\n     * will still have his old display name. Calling getSentinelMember again\n     * after the display name change will return a new RoomMember object\n     * with Bob's new display name.\n     *\n     * @param roomId - Optional. The ID of the room which has this state.\n     * If none is specified it just tracks paginationTokens, useful for notifTimelineSet\n     * @param oobMemberFlags - Optional. The state of loading out of bound members.\n     * As the timeline might get reset while they are loading, this state needs to be inherited\n     * and shared when the room state is cloned for the new timeline.\n     * This should only be passed from clone.\n     */\n    public constructor(\n        public readonly roomId: string,\n        private oobMemberFlags = { status: OobStatus.NotStarted },\n    ) {\n        super();\n        this.updateModifiedTime();\n    }\n\n    /**\n     * Returns the number of joined members in this room\n     * This method caches the result.\n     * @returns The number of members in this room whose membership is 'join'\n     */\n    public getJoinedMemberCount(): number {\n        if (this.summaryJoinedMemberCount !== null) {\n            return this.summaryJoinedMemberCount;\n        }\n        if (this.joinedMemberCount === null) {\n            this.joinedMemberCount = this.getMembers().reduce((count, m) => {\n                return m.membership === KnownMembership.Join ? count + 1 : count;\n            }, 0);\n        }\n        return this.joinedMemberCount;\n    }\n\n    /**\n     * Set the joined member count explicitly (like from summary part of the sync response)\n     * @param count - the amount of joined members\n     */\n    public setJoinedMemberCount(count: number): void {\n        this.summaryJoinedMemberCount = count;\n    }\n\n    /**\n     * Returns the number of invited members in this room\n     * @returns The number of members in this room whose membership is 'invite'\n     */\n    public getInvitedMemberCount(): number {\n        if (this.summaryInvitedMemberCount !== null) {\n            return this.summaryInvitedMemberCount;\n        }\n        if (this.invitedMemberCount === null) {\n            this.invitedMemberCount = this.getMembers().reduce((count, m) => {\n                return m.membership === KnownMembership.Invite ? count + 1 : count;\n            }, 0);\n        }\n        return this.invitedMemberCount;\n    }\n\n    /**\n     * Set the amount of invited members in this room\n     * @param count - the amount of invited members\n     */\n    public setInvitedMemberCount(count: number): void {\n        this.summaryInvitedMemberCount = count;\n    }\n\n    /**\n     * Get all RoomMembers in this room.\n     * @returns A list of RoomMembers.\n     */\n    public getMembers(): RoomMember[] {\n        return Object.values(this.members);\n    }\n\n    /**\n     * Get all RoomMembers in this room, excluding the user IDs provided.\n     * @param excludedIds - The user IDs to exclude.\n     * @returns A list of RoomMembers.\n     */\n    public getMembersExcept(excludedIds: string[]): RoomMember[] {\n        return this.getMembers().filter((m) => !excludedIds.includes(m.userId));\n    }\n\n    /**\n     * Get a room member by their user ID.\n     * @param userId - The room member's user ID.\n     * @returns The member or null if they do not exist.\n     */\n    public getMember(userId: string): RoomMember | null {\n        return this.members[userId] || null;\n    }\n\n    /**\n     * Get a room member whose properties will not change with this room state. You\n     * typically want this if you want to attach a RoomMember to a MatrixEvent which\n     * may no longer be represented correctly by Room.currentState or Room.oldState.\n     * The term 'sentinel' refers to the fact that this RoomMember is an unchanging\n     * guardian for state at this particular point in time.\n     * @param userId - The room member's user ID.\n     * @returns The member or null if they do not exist.\n     */\n    public getSentinelMember(userId: string): RoomMember | null {\n        if (!userId) return null;\n        let sentinel = this.sentinels[userId];\n\n        if (sentinel === undefined) {\n            sentinel = new RoomMember(this.roomId, userId);\n            const member = this.members[userId];\n            if (member?.events.member) {\n                sentinel.setMembershipEvent(member.events.member, this);\n            }\n            this.sentinels[userId] = sentinel;\n        }\n        return sentinel;\n    }\n\n    /**\n     * Get state events from the state of the room.\n     * @param eventType - The event type of the state event.\n     * @returns A list of events\n     */\n    public getStateEvents(eventType: EventType | string): MatrixEvent[];\n    /**\n     * Get state events from the state of the room.\n     * @param eventType - The event type of the state event.\n     * @param stateKey - The state_key of the state event.\n     * @returns A single event (or null if no match found).\n     */\n    public getStateEvents(eventType: EventType | string, stateKey: string): MatrixEvent | null;\n    public getStateEvents(eventType: EventType | string, stateKey?: string): MatrixEvent[] | MatrixEvent | null {\n        if (!this.events.has(eventType)) {\n            // no match\n            return stateKey === undefined ? [] : null;\n        }\n        if (stateKey === undefined) {\n            // return all values\n            return Array.from(this.events.get(eventType)!.values());\n        }\n        const event = this.events.get(eventType)!.get(stateKey);\n        return event ? event : null;\n    }\n\n    public get hasLiveBeacons(): boolean {\n        return !!this.liveBeaconIds?.length;\n    }\n\n    public get liveBeaconIds(): BeaconIdentifier[] {\n        return this._liveBeaconIds;\n    }\n\n    /**\n     * Creates a copy of this room state so that mutations to either won't affect the other.\n     * @returns the copy of the room state\n     */\n    public clone(): RoomState {\n        const copy = new RoomState(this.roomId, this.oobMemberFlags);\n\n        // Ugly hack: because setStateEvents will mark\n        // members as susperseding future out of bound members\n        // if loading is in progress (through oobMemberFlags)\n        // since these are not new members, we're merely copying them\n        // set the status to not started\n        // after copying, we set back the status\n        const status = this.oobMemberFlags.status;\n        this.oobMemberFlags.status = OobStatus.NotStarted;\n\n        Array.from(this.events.values()).forEach((eventsByStateKey) => {\n            copy.setStateEvents(Array.from(eventsByStateKey.values()));\n        });\n\n        // Ugly hack: see above\n        this.oobMemberFlags.status = status;\n\n        if (this.summaryInvitedMemberCount !== null) {\n            copy.setInvitedMemberCount(this.getInvitedMemberCount());\n        }\n        if (this.summaryJoinedMemberCount !== null) {\n            copy.setJoinedMemberCount(this.getJoinedMemberCount());\n        }\n\n        // copy out of band flags if needed\n        if (this.oobMemberFlags.status == OobStatus.Finished) {\n            // copy markOutOfBand flags\n            this.getMembers().forEach((member) => {\n                if (member.isOutOfBand()) {\n                    copy.getMember(member.userId)?.markOutOfBand();\n                }\n            });\n        }\n\n        return copy;\n    }\n\n    /**\n     * Add previously unknown state events.\n     * When lazy loading members while back-paginating,\n     * the relevant room state for the timeline chunk at the end\n     * of the chunk can be set with this method.\n     * @param events - state events to prepend\n     */\n    public setUnknownStateEvents(events: MatrixEvent[]): void {\n        const unknownStateEvents = events.filter((event) => {\n            return !this.events.has(event.getType()) || !this.events.get(event.getType())!.has(event.getStateKey()!);\n        });\n\n        this.setStateEvents(unknownStateEvents);\n    }\n\n    /**\n     * Add an array of one or more state MatrixEvents, overwriting any existing\n     * state with the same `{type, stateKey}` tuple. Will fire \"RoomState.events\"\n     * for every event added. May fire \"RoomState.members\" if there are\n     * `m.room.member` events. May fire \"RoomStateEvent.Marker\" if there are\n     * `UNSTABLE_MSC2716_MARKER` events.\n     * @param stateEvents - a list of state events for this room.\n     *\n     * @remarks\n     * Fires {@link RoomStateEvent.Members}\n     * Fires {@link RoomStateEvent.NewMember}\n     * Fires {@link RoomStateEvent.Events}\n     * Fires {@link RoomStateEvent.Marker}\n     */\n    public setStateEvents(stateEvents: MatrixEvent[], markerFoundOptions?: IMarkerFoundOptions): void {\n        this.updateModifiedTime();\n\n        // update the core event dict\n        stateEvents.forEach((event) => {\n            if (event.getRoomId() !== this.roomId || !event.isState()) return;\n\n            if (M_BEACON_INFO.matches(event.getType())) {\n                this.setBeacon(event);\n            }\n\n            const lastStateEvent = this.getStateEventMatching(event);\n            this.setStateEvent(event);\n            if (event.getType() === EventType.RoomMember) {\n                this.updateDisplayNameCache(event.getStateKey()!, event.getContent().displayname ?? \"\");\n                this.updateThirdPartyTokenCache(event);\n            }\n            this.emit(RoomStateEvent.Events, event, this, lastStateEvent);\n        });\n\n        this.onBeaconLivenessChange();\n        // update higher level data structures. This needs to be done AFTER the\n        // core event dict as these structures may depend on other state events in\n        // the given array (e.g. disambiguating display names in one go to do both\n        // clashing names rather than progressively which only catches 1 of them).\n        stateEvents.forEach((event) => {\n            if (event.getRoomId() !== this.roomId || !event.isState()) return;\n\n            if (event.getType() === EventType.RoomMember) {\n                const userId = event.getStateKey()!;\n\n                // leave events apparently elide the displayname or avatar_url,\n                // so let's fake one up so that we don't leak user ids\n                // into the timeline\n                if (\n                    event.getContent().membership === KnownMembership.Leave ||\n                    event.getContent().membership === KnownMembership.Ban\n                ) {\n                    event.getContent().avatar_url = event.getContent().avatar_url || event.getPrevContent().avatar_url;\n                    event.getContent().displayname =\n                        event.getContent().displayname || event.getPrevContent().displayname;\n                }\n\n                const member = this.getOrCreateMember(userId, event);\n                member.setMembershipEvent(event, this);\n                this.updateMember(member);\n                this.emit(RoomStateEvent.Members, event, this, member);\n            } else if (event.getType() === EventType.RoomPowerLevels) {\n                // events with unknown state keys should be ignored\n                // and should not aggregate onto members power levels\n                if (event.getStateKey() !== \"\") {\n                    return;\n                }\n                const members = Object.values(this.members);\n                members.forEach((member) => {\n                    // We only propagate `RoomState.members` event if the\n                    // power levels has been changed\n                    // large room suffer from large re-rendering especially when not needed\n                    const oldLastModified = member.getLastModifiedTime();\n                    member.setPowerLevelEvent(event);\n                    if (oldLastModified !== member.getLastModifiedTime()) {\n                        this.emit(RoomStateEvent.Members, event, this, member);\n                    }\n                });\n\n                // assume all our sentinels are now out-of-date\n                this.sentinels = {};\n            } else if (UNSTABLE_MSC2716_MARKER.matches(event.getType())) {\n                this.emit(RoomStateEvent.Marker, event, markerFoundOptions);\n            }\n        });\n\n        this.emit(RoomStateEvent.Update, this);\n    }\n\n    public async processBeaconEvents(events: MatrixEvent[], matrixClient: MatrixClient): Promise<void> {\n        if (\n            !events.length ||\n            // discard locations if we have no beacons\n            !this.beacons.size\n        ) {\n            return;\n        }\n\n        const beaconByEventIdDict = [...this.beacons.values()].reduce<Record<string, Beacon>>((dict, beacon) => {\n            dict[beacon.beaconInfoId] = beacon;\n            return dict;\n        }, {});\n\n        const processBeaconRelation = (beaconInfoEventId: string, event: MatrixEvent): void => {\n            if (!M_BEACON.matches(event.getType())) {\n                return;\n            }\n\n            const beacon = beaconByEventIdDict[beaconInfoEventId];\n\n            if (beacon) {\n                beacon.addLocations([event]);\n            }\n        };\n\n        for (const event of events) {\n            const relatedToEventId = event.getRelation()?.event_id;\n            // not related to a beacon we know about; discard\n            if (!relatedToEventId || !beaconByEventIdDict[relatedToEventId]) return;\n            if (!M_BEACON.matches(event.getType()) && !event.isEncrypted()) return;\n\n            try {\n                await matrixClient.decryptEventIfNeeded(event);\n                processBeaconRelation(relatedToEventId, event);\n            } catch {\n                if (event.isDecryptionFailure()) {\n                    // add an event listener for once the event is decrypted.\n                    event.once(MatrixEventEvent.Decrypted, async () => {\n                        processBeaconRelation(relatedToEventId, event);\n                    });\n                }\n            }\n        }\n    }\n\n    /**\n     * Looks up a member by the given userId, and if it doesn't exist,\n     * create it and emit the `RoomState.newMember` event.\n     * This method makes sure the member is added to the members dictionary\n     * before emitting, as this is done from setStateEvents and setOutOfBandMember.\n     * @param userId - the id of the user to look up\n     * @param event - the membership event for the (new) member. Used to emit.\n     * @returns the member, existing or newly created.\n     *\n     * @remarks\n     * Fires {@link RoomStateEvent.NewMember}\n     */\n    private getOrCreateMember(userId: string, event: MatrixEvent): RoomMember {\n        let member = this.members[userId];\n        if (!member) {\n            member = new RoomMember(this.roomId, userId);\n            // add member to members before emitting any events,\n            // as event handlers often lookup the member\n            this.members[userId] = member;\n            this.emit(RoomStateEvent.NewMember, event, this, member);\n        }\n        return member;\n    }\n\n    private setStateEvent(event: MatrixEvent): void {\n        if (!this.events.has(event.getType())) {\n            this.events.set(event.getType(), new Map());\n        }\n        this.events.get(event.getType())!.set(event.getStateKey()!, event);\n    }\n\n    /**\n     * @experimental\n     */\n    private setBeacon(event: MatrixEvent): void {\n        const beaconIdentifier = getBeaconInfoIdentifier(event);\n\n        if (this.beacons.has(beaconIdentifier)) {\n            const beacon = this.beacons.get(beaconIdentifier)!;\n\n            if (event.isRedacted()) {\n                if (beacon.beaconInfoId === (<IEvent>event.getRedactionEvent())?.redacts) {\n                    beacon.destroy();\n                    this.beacons.delete(beaconIdentifier);\n                }\n                return;\n            }\n\n            return beacon.update(event);\n        }\n\n        if (event.isRedacted()) {\n            return;\n        }\n\n        const beacon = new Beacon(event);\n\n        this.reEmitter.reEmit<BeaconEvent, BeaconEvent>(beacon, [\n            BeaconEvent.New,\n            BeaconEvent.Update,\n            BeaconEvent.Destroy,\n            BeaconEvent.LivenessChange,\n        ]);\n\n        this.emit(BeaconEvent.New, event, beacon);\n        beacon.on(BeaconEvent.LivenessChange, this.onBeaconLivenessChange.bind(this));\n        beacon.on(BeaconEvent.Destroy, this.onBeaconLivenessChange.bind(this));\n\n        this.beacons.set(beacon.identifier, beacon);\n    }\n\n    /**\n     * @experimental\n     * Check liveness of room beacons\n     * emit RoomStateEvent.BeaconLiveness event\n     */\n    private onBeaconLivenessChange(): void {\n        this._liveBeaconIds = Array.from(this.beacons.values())\n            .filter((beacon) => beacon.isLive)\n            .map((beacon) => beacon.identifier);\n\n        this.emit(RoomStateEvent.BeaconLiveness, this, this.hasLiveBeacons);\n    }\n\n    private getStateEventMatching(event: MatrixEvent): MatrixEvent | null {\n        return this.events.get(event.getType())?.get(event.getStateKey()!) ?? null;\n    }\n\n    private updateMember(member: RoomMember): void {\n        // this member may have a power level already, so set it.\n        const pwrLvlEvent = this.getStateEvents(EventType.RoomPowerLevels, \"\");\n        if (pwrLvlEvent) {\n            member.setPowerLevelEvent(pwrLvlEvent);\n        }\n\n        // blow away the sentinel which is now outdated\n        delete this.sentinels[member.userId];\n\n        this.members[member.userId] = member;\n        this.joinedMemberCount = null;\n        this.invitedMemberCount = null;\n    }\n\n    /**\n     * Get the out-of-band members loading state, whether loading is needed or not.\n     * Note that loading might be in progress and hence isn't needed.\n     * @returns whether or not the members of this room need to be loaded\n     */\n    public needsOutOfBandMembers(): boolean {\n        return this.oobMemberFlags.status === OobStatus.NotStarted;\n    }\n\n    /**\n     * Check if loading of out-of-band-members has completed\n     *\n     * @returns true if the full membership list of this room has been loaded. False if it is not started or is in\n     *    progress.\n     */\n    public outOfBandMembersReady(): boolean {\n        return this.oobMemberFlags.status === OobStatus.Finished;\n    }\n\n    /**\n     * Mark this room state as waiting for out-of-band members,\n     * ensuring it doesn't ask for them to be requested again\n     * through needsOutOfBandMembers\n     */\n    public markOutOfBandMembersStarted(): void {\n        if (this.oobMemberFlags.status !== OobStatus.NotStarted) {\n            return;\n        }\n        this.oobMemberFlags.status = OobStatus.InProgress;\n    }\n\n    /**\n     * Mark this room state as having failed to fetch out-of-band members\n     */\n    public markOutOfBandMembersFailed(): void {\n        if (this.oobMemberFlags.status !== OobStatus.InProgress) {\n            return;\n        }\n        this.oobMemberFlags.status = OobStatus.NotStarted;\n    }\n\n    /**\n     * Clears the loaded out-of-band members\n     */\n    public clearOutOfBandMembers(): void {\n        let count = 0;\n        Object.keys(this.members).forEach((userId) => {\n            const member = this.members[userId];\n            if (member.isOutOfBand()) {\n                ++count;\n                delete this.members[userId];\n            }\n        });\n        logger.log(`LL: RoomState removed ${count} members...`);\n        this.oobMemberFlags.status = OobStatus.NotStarted;\n    }\n\n    /**\n     * Sets the loaded out-of-band members.\n     * @param stateEvents - array of membership state events\n     */\n    public setOutOfBandMembers(stateEvents: MatrixEvent[]): void {\n        logger.log(`LL: RoomState about to set ${stateEvents.length} OOB members ...`);\n        if (this.oobMemberFlags.status !== OobStatus.InProgress) {\n            return;\n        }\n        logger.log(`LL: RoomState put in finished state ...`);\n        this.oobMemberFlags.status = OobStatus.Finished;\n        stateEvents.forEach((e) => this.setOutOfBandMember(e));\n        this.emit(RoomStateEvent.Update, this);\n    }\n\n    /**\n     * Sets a single out of band member, used by both setOutOfBandMembers and clone\n     * @param stateEvent - membership state event\n     */\n    private setOutOfBandMember(stateEvent: MatrixEvent): void {\n        if (stateEvent.getType() !== EventType.RoomMember) {\n            return;\n        }\n        const userId = stateEvent.getStateKey()!;\n        const existingMember = this.getMember(userId);\n        // never replace members received as part of the sync\n        if (existingMember && !existingMember.isOutOfBand()) {\n            return;\n        }\n\n        const member = this.getOrCreateMember(userId, stateEvent);\n        member.setMembershipEvent(stateEvent, this);\n        // needed to know which members need to be stored seperately\n        // as they are not part of the sync accumulator\n        // this is cleared by setMembershipEvent so when it's updated through /sync\n        member.markOutOfBand();\n\n        this.updateDisplayNameCache(member.userId, member.name);\n\n        this.setStateEvent(stateEvent);\n        this.updateMember(member);\n        this.emit(RoomStateEvent.Members, stateEvent, this, member);\n    }\n\n    /**\n     * Set the current typing event for this room.\n     * @param event - The typing event\n     */\n    public setTypingEvent(event: MatrixEvent): void {\n        Object.values(this.members).forEach(function (member) {\n            member.setTypingEvent(event);\n        });\n    }\n\n    /**\n     * Get the m.room.member event which has the given third party invite token.\n     *\n     * @param token - The token\n     * @returns The m.room.member event or null\n     */\n    public getInviteForThreePidToken(token: string): MatrixEvent | null {\n        return this.tokenToInvite[token] || null;\n    }\n\n    /**\n     * Update the last modified time to the current time.\n     */\n    private updateModifiedTime(): void {\n        this.modified = Date.now();\n    }\n\n    /**\n     * Get the timestamp when this room state was last updated. This timestamp is\n     * updated when this object has received new state events.\n     * @returns The timestamp\n     */\n    public getLastModifiedTime(): number {\n        return this.modified;\n    }\n\n    /**\n     * Get user IDs with the specified or similar display names.\n     * @param displayName - The display name to get user IDs from.\n     * @returns An array of user IDs or an empty array.\n     */\n    public getUserIdsWithDisplayName(displayName: string): string[] {\n        return this.displayNameToUserIds.get(removeHiddenChars(displayName)) ?? [];\n    }\n\n    /**\n     * Returns true if userId is in room, event is not redacted and either sender of\n     * mxEvent or has power level sufficient to redact events other than their own.\n     * @param mxEvent - The event to test permission for\n     * @param userId - The user ID of the user to test permission for\n     * @returns true if the given used ID can redact given event\n     */\n    public maySendRedactionForEvent(mxEvent: MatrixEvent, userId: string): boolean {\n        const member = this.getMember(userId);\n        if (!member || member.membership === KnownMembership.Leave) return false;\n\n        if (mxEvent.status || mxEvent.isRedacted()) return false;\n\n        // The user may have been the sender, but they can't redact their own message\n        // if redactions are blocked.\n        const canRedact = this.maySendEvent(EventType.RoomRedaction, userId);\n\n        if (!canRedact) return false;\n        if (mxEvent.getSender() === userId) return true;\n\n        return this.hasSufficientPowerLevelFor(\"redact\", member.powerLevel);\n    }\n\n    /**\n     * Returns true if the given power level is sufficient for action\n     * @param action - The type of power level to check\n     * @param powerLevel - The power level of the member\n     * @returns true if the given power level is sufficient\n     */\n    public hasSufficientPowerLevelFor(\n        action: KeysMatching<Required<IPowerLevelsContent>, number>,\n        powerLevel: number,\n    ): boolean {\n        const powerLevelsEvent = this.getStateEvents(EventType.RoomPowerLevels, \"\");\n\n        let powerLevels: IPowerLevelsContent = {};\n        if (powerLevelsEvent) {\n            powerLevels = powerLevelsEvent.getContent();\n        }\n\n        let requiredLevel = 50;\n        if (isNumber(powerLevels[action])) {\n            requiredLevel = powerLevels[action]!;\n        }\n\n        return powerLevel >= requiredLevel;\n    }\n\n    /**\n     * Short-form for maySendEvent('m.room.message', userId)\n     * @param userId - The user ID of the user to test permission for\n     * @returns true if the given user ID should be permitted to send\n     *                   message events into the given room.\n     */\n    public maySendMessage(userId: string): boolean {\n        return this.maySendEventOfType(EventType.RoomMessage, userId, false);\n    }\n\n    /**\n     * Returns true if the given user ID has permission to send a normal\n     * event of type `eventType` into this room.\n     * @param eventType - The type of event to test\n     * @param userId - The user ID of the user to test permission for\n     * @returns true if the given user ID should be permitted to send\n     *                        the given type of event into this room,\n     *                        according to the room's state.\n     */\n    public maySendEvent(eventType: EventType | string, userId: string): boolean {\n        return this.maySendEventOfType(eventType, userId, false);\n    }\n\n    /**\n     * Returns true if the given MatrixClient has permission to send a state\n     * event of type `stateEventType` into this room.\n     * @param stateEventType - The type of state events to test\n     * @param cli - The client to test permission for\n     * @returns true if the given client should be permitted to send\n     *                        the given type of state event into this room,\n     *                        according to the room's state.\n     */\n    public mayClientSendStateEvent(stateEventType: EventType | string, cli: MatrixClient): boolean {\n        if (cli.isGuest() || !cli.credentials.userId) {\n            return false;\n        }\n        return this.maySendStateEvent(stateEventType, cli.credentials.userId);\n    }\n\n    /**\n     * Returns true if the given user ID has permission to send a state\n     * event of type `stateEventType` into this room.\n     * @param stateEventType - The type of state events to test\n     * @param userId - The user ID of the user to test permission for\n     * @returns true if the given user ID should be permitted to send\n     *                        the given type of state event into this room,\n     *                        according to the room's state.\n     */\n    public maySendStateEvent(stateEventType: EventType | string, userId: string): boolean {\n        return this.maySendEventOfType(stateEventType, userId, true);\n    }\n\n    /**\n     * Returns true if the given user ID has permission to send a normal or state\n     * event of type `eventType` into this room.\n     * @param eventType - The type of event to test\n     * @param userId - The user ID of the user to test permission for\n     * @param state - If true, tests if the user may send a state\n     event of this type. Otherwise tests whether\n     they may send a regular event.\n     * @returns true if the given user ID should be permitted to send\n     *                        the given type of event into this room,\n     *                        according to the room's state.\n     */\n    private maySendEventOfType(eventType: EventType | string, userId: string, state: boolean): boolean {\n        const powerLevelsEvent = this.getStateEvents(EventType.RoomPowerLevels, \"\");\n\n        let powerLevels: IPowerLevelsContent;\n        let eventsLevels: Record<EventType | string, number> = {};\n\n        let stateDefault = 0;\n        let eventsDefault = 0;\n        let powerLevel = 0;\n        if (powerLevelsEvent) {\n            powerLevels = powerLevelsEvent.getContent();\n            eventsLevels = powerLevels.events || {};\n\n            if (Number.isSafeInteger(powerLevels.state_default)) {\n                stateDefault = powerLevels.state_default!;\n            } else {\n                stateDefault = 50;\n            }\n\n            const userPowerLevel = powerLevels.users && powerLevels.users[userId];\n            if (Number.isSafeInteger(userPowerLevel)) {\n                powerLevel = userPowerLevel!;\n            } else if (Number.isSafeInteger(powerLevels.users_default)) {\n                powerLevel = powerLevels.users_default!;\n            }\n\n            if (Number.isSafeInteger(powerLevels.events_default)) {\n                eventsDefault = powerLevels.events_default!;\n            }\n        }\n\n        let requiredLevel = state ? stateDefault : eventsDefault;\n        if (Number.isSafeInteger(eventsLevels[eventType])) {\n            requiredLevel = eventsLevels[eventType];\n        }\n        return powerLevel >= requiredLevel;\n    }\n\n    /**\n     * Returns true if the given user ID has permission to trigger notification\n     * of type `notifLevelKey`\n     * @param notifLevelKey - The level of notification to test (eg. 'room')\n     * @param userId - The user ID of the user to test permission for\n     * @returns true if the given user ID has permission to trigger a\n     *                        notification of this type.\n     */\n    public mayTriggerNotifOfType(notifLevelKey: string, userId: string): boolean {\n        const member = this.getMember(userId);\n        if (!member) {\n            return false;\n        }\n\n        const powerLevelsEvent = this.getStateEvents(EventType.RoomPowerLevels, \"\");\n\n        let notifLevel = 50;\n        if (\n            powerLevelsEvent &&\n            powerLevelsEvent.getContent() &&\n            powerLevelsEvent.getContent().notifications &&\n            isNumber(powerLevelsEvent.getContent().notifications[notifLevelKey])\n        ) {\n            notifLevel = powerLevelsEvent.getContent().notifications[notifLevelKey];\n        }\n\n        return member.powerLevel >= notifLevel;\n    }\n\n    /**\n     * Returns the join rule based on the m.room.join_rule state event, defaulting to `invite`.\n     * @returns the join_rule applied to this room\n     */\n    public getJoinRule(): JoinRule {\n        const joinRuleEvent = this.getStateEvents(EventType.RoomJoinRules, \"\");\n        const joinRuleContent: Partial<RoomJoinRulesEventContent> = joinRuleEvent?.getContent() ?? {};\n        return joinRuleContent[\"join_rule\"] || JoinRule.Invite;\n    }\n\n    /**\n     * Returns the history visibility based on the m.room.history_visibility state event, defaulting to `shared`.\n     * @returns the history_visibility applied to this room\n     */\n    public getHistoryVisibility(): HistoryVisibility {\n        const historyVisibilityEvent = this.getStateEvents(EventType.RoomHistoryVisibility, \"\");\n        const historyVisibilityContent = historyVisibilityEvent?.getContent() ?? {};\n        return historyVisibilityContent[\"history_visibility\"] || HistoryVisibility.Shared;\n    }\n\n    /**\n     * Returns the guest access based on the m.room.guest_access state event, defaulting to `shared`.\n     * @returns the guest_access applied to this room\n     */\n    public getGuestAccess(): GuestAccess {\n        const guestAccessEvent = this.getStateEvents(EventType.RoomGuestAccess, \"\");\n        const guestAccessContent = guestAccessEvent?.getContent() ?? {};\n        return guestAccessContent[\"guest_access\"] || GuestAccess.Forbidden;\n    }\n\n    /**\n     * Find the predecessor room based on this room state.\n     *\n     * @param msc3946ProcessDynamicPredecessor - if true, look for an\n     * m.room.predecessor state event and use it if found (MSC3946).\n     * @returns null if this room has no predecessor. Otherwise, returns\n     * the roomId, last eventId and viaServers of the predecessor room.\n     *\n     * If msc3946ProcessDynamicPredecessor is true, use m.predecessor events\n     * as well as m.room.create events to find predecessors.\n     *\n     * Note: if an m.predecessor event is used, eventId may be undefined\n     * since last_known_event_id is optional.\n     *\n     * Note: viaServers may be undefined, and will definitely be undefined if\n     * this predecessor comes from a RoomCreate event (rather than a\n     * RoomPredecessor, which has the optional via_servers property).\n     */\n    public findPredecessor(\n        msc3946ProcessDynamicPredecessor = false,\n    ): { roomId: string; eventId?: string; viaServers?: string[] } | null {\n        // Note: the tests for this function are against Room.findPredecessor,\n        // which just calls through to here.\n\n        if (msc3946ProcessDynamicPredecessor) {\n            const predecessorEvent = this.getStateEvents(EventType.RoomPredecessor, \"\");\n            if (predecessorEvent) {\n                const content = predecessorEvent.getContent<{\n                    predecessor_room_id: string;\n                    last_known_event_id?: string;\n                    via_servers?: string[];\n                }>();\n                const roomId = content.predecessor_room_id;\n                let eventId = content.last_known_event_id;\n                if (typeof eventId !== \"string\") {\n                    eventId = undefined;\n                }\n                let viaServers = content.via_servers;\n                if (!Array.isArray(viaServers)) {\n                    viaServers = undefined;\n                }\n                if (typeof roomId === \"string\") {\n                    return { roomId, eventId, viaServers };\n                }\n            }\n        }\n\n        const createEvent = this.getStateEvents(EventType.RoomCreate, \"\");\n        if (createEvent) {\n            const predecessor = createEvent.getContent<{\n                predecessor?: Partial<{\n                    room_id: string;\n                    event_id: string;\n                }>;\n            }>()[\"predecessor\"];\n            if (predecessor) {\n                const roomId = predecessor[\"room_id\"];\n                if (typeof roomId === \"string\") {\n                    let eventId = predecessor[\"event_id\"];\n                    if (typeof eventId !== \"string\" || eventId === \"\") {\n                        eventId = undefined;\n                    }\n                    return { roomId, eventId };\n                }\n            }\n        }\n        return null;\n    }\n\n    private updateThirdPartyTokenCache(memberEvent: MatrixEvent): void {\n        if (!memberEvent.getContent().third_party_invite) {\n            return;\n        }\n        const token = (memberEvent.getContent().third_party_invite.signed || {}).token;\n        if (!token) {\n            return;\n        }\n        const threePidInvite = this.getStateEvents(EventType.RoomThirdPartyInvite, token);\n        if (!threePidInvite) {\n            return;\n        }\n        this.tokenToInvite[token] = memberEvent;\n    }\n\n    private updateDisplayNameCache(userId: string, displayName: string): void {\n        const oldName = this.userIdsToDisplayNames[userId];\n        delete this.userIdsToDisplayNames[userId];\n        if (oldName) {\n            // Remove the old name from the cache.\n            // We clobber the user_id > name lookup but the name -> [user_id] lookup\n            // means we need to remove that user ID from that array rather than nuking\n            // the lot.\n            const strippedOldName = removeHiddenChars(oldName);\n\n            const existingUserIds = this.displayNameToUserIds.get(strippedOldName);\n            if (existingUserIds) {\n                // remove this user ID from this array\n                const filteredUserIDs = existingUserIds.filter((id) => id !== userId);\n                this.displayNameToUserIds.set(strippedOldName, filteredUserIDs);\n            }\n        }\n\n        this.userIdsToDisplayNames[userId] = displayName;\n\n        const strippedDisplayname = displayName && removeHiddenChars(displayName);\n        // an empty stripped displayname (undefined/'') will be set to MXID in room-member.js\n        if (strippedDisplayname) {\n            const arr = this.displayNameToUserIds.get(strippedDisplayname) ?? [];\n            arr.push(userId);\n            this.displayNameToUserIds.set(strippedDisplayname, arr);\n        }\n    }\n}\n","/*\nCopyright 2015 - 2021 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nexport interface IRoomSummary {\n    \"m.heroes\": string[];\n    \"m.joined_member_count\"?: number;\n    \"m.invited_member_count\"?: number;\n}\n\ninterface IInfo {\n    /** The title of the room (e.g. `m.room.name`) */\n    title: string;\n    /** The description of the room (e.g. `m.room.topic`) */\n    desc?: string;\n    /** The number of joined users. */\n    numMembers?: number;\n    /** The list of aliases for this room. */\n    aliases?: string[];\n    /** The timestamp for this room. */\n    timestamp?: number;\n}\n\n/**\n * Construct a new Room Summary. A summary can be used for display on a recent\n * list, without having to load the entire room list into memory.\n * @param roomId - Required. The ID of this room.\n * @param info - Optional. The summary info. Additional keys are supported.\n */\nexport class RoomSummary {\n    public constructor(\n        public readonly roomId: string,\n        info?: IInfo,\n    ) {}\n}\n","/*\nCopyright 2023 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { MAIN_ROOM_TIMELINE, type Receipt, type ReceiptContent } from \"../@types/read_receipts.ts\";\nimport { threadIdForReceipt } from \"../client.ts\";\nimport { type Room, RoomEvent } from \"./room.ts\";\nimport { type MatrixEvent } from \"./event.ts\";\nimport { logger } from \"../logger.ts\";\n\n/**\n * The latest receipts we have for a room.\n */\nexport class RoomReceipts {\n    private room: Room;\n    private threadedReceipts: ThreadedReceipts;\n    private unthreadedReceipts: ReceiptsByUser;\n    private danglingReceipts: DanglingReceipts;\n\n    public constructor(room: Room) {\n        this.room = room;\n        this.threadedReceipts = new ThreadedReceipts(room);\n        this.unthreadedReceipts = new ReceiptsByUser(room);\n        this.danglingReceipts = new DanglingReceipts();\n        // We listen for timeline events so we can process dangling receipts\n        room.on(RoomEvent.Timeline, this.onTimelineEvent);\n    }\n\n    /**\n     * Remember the receipt information supplied. For each receipt:\n     *\n     * If we don't have the event for this receipt, store it as \"dangling\" so we\n     * can process it later.\n     *\n     * Otherwise store it per-user in either the threaded store for its\n     * thread_id, or the unthreaded store if there is no thread_id.\n     *\n     * Ignores any receipt that is before an existing receipt for the same user\n     * (in the same thread, if applicable). \"Before\" is defined by the\n     * unfilteredTimelineSet of the room.\n     */\n    public add(receiptContent: ReceiptContent, synthetic: boolean): void {\n        /*\n            Transform this structure:\n            {\n              \"$EVENTID\": {\n                \"m.read|m.read.private\": {\n                  \"@user:example.org\": {\n                    \"ts\": 1661,\n                    \"thread_id\": \"main|$THREAD_ROOT_ID\" // or missing/undefined for an unthreaded receipt\n                  }\n                }\n              },\n              ...\n            }\n            into maps of:\n            threaded :: threadid :: userId :: ReceiptInfo\n            unthreaded :: userId :: ReceiptInfo\n            dangling :: eventId :: DanglingReceipt\n        */\n        for (const [eventId, eventReceipt] of Object.entries(receiptContent)) {\n            for (const [receiptType, receiptsByUser] of Object.entries(eventReceipt)) {\n                for (const [userId, receipt] of Object.entries(receiptsByUser)) {\n                    const referencedEvent = this.room.findEventById(eventId);\n                    if (!referencedEvent) {\n                        this.danglingReceipts.add(\n                            new DanglingReceipt(eventId, receiptType, userId, receipt, synthetic),\n                        );\n                    } else if (receipt.thread_id) {\n                        this.threadedReceipts.set(\n                            receipt.thread_id,\n                            eventId,\n                            receiptType,\n                            userId,\n                            receipt.ts,\n                            synthetic,\n                        );\n                    } else {\n                        this.unthreadedReceipts.set(eventId, receiptType, userId, receipt.ts, synthetic);\n                    }\n                }\n            }\n        }\n    }\n\n    /**\n     * Look for dangling receipts for the given event ID,\n     * and add them to the thread of unthread receipts if found.\n     * @param event - the event to look for\n     */\n    private onTimelineEvent = (event: MatrixEvent): void => {\n        const eventId = event.getId();\n        if (!eventId) return;\n\n        const danglingReceipts = this.danglingReceipts.remove(eventId);\n\n        danglingReceipts?.forEach((danglingReceipt) => {\n            // The receipt is a thread receipt\n            if (danglingReceipt.receipt.thread_id) {\n                this.threadedReceipts.set(\n                    danglingReceipt.receipt.thread_id,\n                    danglingReceipt.eventId,\n                    danglingReceipt.receiptType,\n                    danglingReceipt.userId,\n                    danglingReceipt.receipt.ts,\n                    danglingReceipt.synthetic,\n                );\n            } else {\n                this.unthreadedReceipts.set(\n                    eventId,\n                    danglingReceipt.receiptType,\n                    danglingReceipt.userId,\n                    danglingReceipt.receipt.ts,\n                    danglingReceipt.synthetic,\n                );\n            }\n        });\n    };\n\n    public hasUserReadEvent(userId: string, eventId: string): boolean {\n        const unthreaded = this.unthreadedReceipts.get(userId);\n        if (unthreaded) {\n            if (isAfterOrSame(unthreaded.eventId, eventId, this.room)) {\n                // The unthreaded receipt is after this event, so we have read it.\n                return true;\n            }\n        }\n\n        const event = this.room.findEventById(eventId);\n        if (!event) {\n            // We don't know whether the user has read it - default to caution and say no.\n            // This shouldn't really happen and feels like it ought to be an exception: let's\n            // log a warn for now.\n            logger.warn(\n                `hasUserReadEvent event ID ${eventId} not found in room ${this.room.roomId}: this shouldn't happen!`,\n            );\n            return false;\n        }\n\n        const threadId = threadIdForReceipt(event);\n        const threaded = this.threadedReceipts.get(threadId, userId);\n        if (threaded) {\n            if (isAfterOrSame(threaded.eventId, eventId, this.room)) {\n                // The threaded receipt is after this event, so we have read it.\n                return true;\n            }\n        }\n\n        // TODO: what if they sent the second-last event in the thread?\n        if (this.userSentLatestEventInThread(threadId, userId)) {\n            // The user sent the latest message in this event's thread, so we\n            // consider everything in the thread to be read.\n            //\n            // Note: maybe we don't need this because synthetic receipts should\n            // do this job for us?\n            return true;\n        }\n\n        // Neither of the receipts were after the event, so it's unread.\n        return false;\n    }\n\n    /**\n     * @returns true if the thread with this ID can be found, and the supplied\n     *          user sent the latest message in it.\n     */\n    private userSentLatestEventInThread(threadId: string, userId: string): boolean {\n        const timeline =\n            threadId === MAIN_ROOM_TIMELINE\n                ? this.room.getLiveTimeline().getEvents()\n                : this.room.getThread(threadId)?.timeline;\n\n        return !!(timeline && timeline.length > 0 && timeline[timeline.length - 1].getSender() === userId);\n    }\n}\n\n// --- implementation details ---\n\n/**\n * The information \"inside\" a receipt once it has been stored inside\n * RoomReceipts - what eventId it refers to, its type, and its ts.\n *\n * Does not contain userId or threadId since these are stored as keys of the\n * maps in RoomReceipts.\n */\nclass ReceiptInfo {\n    public constructor(\n        public eventId: string,\n        public receiptType: string,\n        public ts: number,\n    ) {}\n}\n\n/**\n * Everything we know about a receipt that is \"dangling\" because we can't find\n * the event to which it refers.\n */\nclass DanglingReceipt {\n    public constructor(\n        public eventId: string,\n        public receiptType: string,\n        public userId: string,\n        public receipt: Receipt,\n        public synthetic: boolean,\n    ) {}\n}\n\nclass UserReceipts {\n    private room: Room;\n\n    /**\n     * The real receipt for this user.\n     */\n    private real: ReceiptInfo | undefined;\n\n    /**\n     * The synthetic receipt for this user. If this is defined, it is later than real.\n     */\n    private synthetic: ReceiptInfo | undefined;\n\n    public constructor(room: Room) {\n        this.room = room;\n        this.real = undefined;\n        this.synthetic = undefined;\n    }\n\n    public set(synthetic: boolean, receiptInfo: ReceiptInfo): void {\n        if (synthetic) {\n            this.synthetic = receiptInfo;\n        } else {\n            this.real = receiptInfo;\n        }\n\n        // Preserve the invariant: synthetic is only defined if it's later than real\n        if (this.synthetic && this.real) {\n            if (isAfterOrSame(this.real.eventId, this.synthetic.eventId, this.room)) {\n                this.synthetic = undefined;\n            }\n        }\n    }\n\n    /**\n     * Return the latest receipt we have - synthetic if we have one (and it's\n     * later), otherwise real.\n     */\n    public get(): ReceiptInfo | undefined {\n        // Relies on the invariant that synthetic is only defined if it's later than real.\n        return this.synthetic ?? this.real;\n    }\n\n    /**\n     * Return the latest receipt we have of the specified type (synthetic or not).\n     */\n    public getByType(synthetic: boolean): ReceiptInfo | undefined {\n        return synthetic ? this.synthetic : this.real;\n    }\n}\n\n/**\n * The latest receipt info we have, either for a single thread, or all the\n * unthreaded receipts for a room.\n *\n * userId: ReceiptInfo\n */\nclass ReceiptsByUser {\n    private room: Room;\n\n    /** map of userId: UserReceipts */\n    private data: Map<string, UserReceipts>;\n\n    public constructor(room: Room) {\n        this.room = room;\n        this.data = new Map<string, UserReceipts>();\n    }\n\n    /**\n     * Add the supplied receipt to our structure, if it is not earlier than the\n     * one we already hold for this user.\n     */\n    public set(eventId: string, receiptType: string, userId: string, ts: number, synthetic: boolean): void {\n        const userReceipts = getOrCreate(this.data, userId, () => new UserReceipts(this.room));\n\n        const existingReceipt = userReceipts.getByType(synthetic);\n        if (existingReceipt && isAfter(existingReceipt.eventId, eventId, this.room)) {\n            // The new receipt is before the existing one - don't store it.\n            return;\n        }\n\n        // Possibilities:\n        //\n        // 1. there was no existing receipt, or\n        // 2. the existing receipt was before this one, or\n        // 3. we were unable to compare the receipts.\n        //\n        // In the case of 3 it's difficult to decide what to do, so the\n        // most-recently-received receipt wins.\n        //\n        // Case 3 can only happen if the events for these receipts have\n        // disappeared, which is quite unlikely since the new one has just been\n        // checked, and the old one was checked before it was inserted here.\n        //\n        // We go ahead and store this receipt (replacing the other if it exists)\n        userReceipts.set(synthetic, new ReceiptInfo(eventId, receiptType, ts));\n    }\n\n    /**\n     * Find the latest receipt we have for this user. (Note - there is only one\n     * receipt per user, because we are already inside a specific thread or\n     * unthreaded list.)\n     *\n     * If there is a later synthetic receipt for this user, return that.\n     * Otherwise, return the real receipt.\n     *\n     * @returns the found receipt info, or undefined if we have no receipt for this user.\n     */\n    public get(userId: string): ReceiptInfo | undefined {\n        return this.data.get(userId)?.get();\n    }\n}\n\n/**\n * The latest threaded receipts we have for a room.\n */\nclass ThreadedReceipts {\n    private room: Room;\n\n    /** map of threadId: ReceiptsByUser */\n    private data: Map<string, ReceiptsByUser>;\n\n    public constructor(room: Room) {\n        this.room = room;\n        this.data = new Map<string, ReceiptsByUser>();\n    }\n\n    /**\n     * Add the supplied receipt to our structure, if it is not earlier than one\n     * we already hold for this user in this thread.\n     */\n    public set(\n        threadId: string,\n        eventId: string,\n        receiptType: string,\n        userId: string,\n        ts: number,\n        synthetic: boolean,\n    ): void {\n        const receiptsByUser = getOrCreate(this.data, threadId, () => new ReceiptsByUser(this.room));\n        receiptsByUser.set(eventId, receiptType, userId, ts, synthetic);\n    }\n\n    /**\n     * Find the latest threaded receipt for the supplied user in the supplied thread.\n     *\n     * @returns the found receipt info or undefined if we don't have one.\n     */\n    public get(threadId: string, userId: string): ReceiptInfo | undefined {\n        return this.data.get(threadId)?.get(userId);\n    }\n}\n\n/**\n * All the receipts that we have received but can't process because we can't\n * find the event they refer to.\n *\n * We hold on to them so we can process them if their event arrives later.\n */\nclass DanglingReceipts {\n    /**\n     * eventId: DanglingReceipt[]\n     */\n    private data = new Map<string, Array<DanglingReceipt>>();\n\n    /**\n     * Remember the supplied dangling receipt.\n     */\n    public add(danglingReceipt: DanglingReceipt): void {\n        const danglingReceipts = getOrCreate(this.data, danglingReceipt.eventId, () => []);\n        danglingReceipts.push(danglingReceipt);\n    }\n\n    /**\n     * Remove and return the dangling receipts for the given event ID.\n     * @param eventId - the event ID to look for\n     * @returns the found dangling receipts, or undefined if we don't have one.\n     */\n    public remove(eventId: string): Array<DanglingReceipt> | undefined {\n        const danglingReceipts = this.data.get(eventId);\n        this.data.delete(eventId);\n        return danglingReceipts;\n    }\n}\n\nfunction getOrCreate<K, V>(m: Map<K, V>, key: K, createFn: () => V): V {\n    const found = m.get(key);\n    if (found) {\n        return found;\n    } else {\n        const created = createFn();\n        m.set(key, created);\n        return created;\n    }\n}\n\n/**\n * Is left after right (or the same)?\n *\n * Only returns true if both events can be found, and left is after or the same\n * as right.\n *\n * @returns left \\>= right\n */\nfunction isAfterOrSame(leftEventId: string, rightEventId: string, room: Room): boolean {\n    const comparison = room.compareEventOrdering(leftEventId, rightEventId);\n    return comparison !== null && comparison >= 0;\n}\n\n/**\n * Is left strictly after right?\n *\n * Only returns true if both events can be found, and left is strictly after right.\n *\n * @returns left \\> right\n */\nfunction isAfter(leftEventId: string, rightEventId: string, room: Room): boolean {\n    const comparison = room.compareEventOrdering(leftEventId, rightEventId);\n    return comparison !== null && comparison > 0;\n}\n","/*\nCopyright 2023 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { type MatrixEvent } from \"./event.ts\";\nimport { type Room } from \"./room.ts\";\nimport { inMainTimelineForReceipt, threadIdForReceipt } from \"../client.ts\";\n\n/**\n * Determine the order of two events in a room.\n *\n * In principle this should use the same order as the server, but in practice\n * this is difficult for events that were not received over the Sync API. See\n * MSC4033 for details.\n *\n * This implementation leans on the order of events within their timelines, and\n * falls back to comparing event timestamps when they are in different\n * timelines.\n *\n * See https://github.com/matrix-org/matrix-js-sdk/issues/3325 for where we are\n * tracking the work to fix this.\n *\n * @param room - the room we are looking in\n * @param leftEventId - the id of the first event\n * @param rightEventId - the id of the second event\n\n * @returns -1 if left \\< right, 1 if left \\> right, 0 if left == right, null if\n *          we can't tell (because we can't find the events).\n */\nexport function compareEventOrdering(room: Room, leftEventId: string, rightEventId: string): number | null {\n    const leftEvent = room.findEventById(leftEventId);\n    const rightEvent = room.findEventById(rightEventId);\n\n    if (!leftEvent || !rightEvent) {\n        // Without the events themselves, we can't find their thread or\n        // timeline, or guess based on timestamp, so we just don't know.\n        return null;\n    }\n\n    // Check whether the events are in the main timeline\n    const isLeftEventInMainTimeline = inMainTimelineForReceipt(leftEvent);\n    const isRightEventInMainTimeline = inMainTimelineForReceipt(rightEvent);\n\n    if (isLeftEventInMainTimeline && isRightEventInMainTimeline) {\n        return compareEventsInMainTimeline(room, leftEventId, rightEventId, leftEvent, rightEvent);\n    } else {\n        // At least one event is not in the timeline, so we can't use the room's\n        // unfiltered timeline set.\n        return compareEventsInThreads(leftEventId, rightEventId, leftEvent, rightEvent);\n    }\n}\n\nfunction compareEventsInMainTimeline(\n    room: Room,\n    leftEventId: string,\n    rightEventId: string,\n    leftEvent: MatrixEvent,\n    rightEvent: MatrixEvent,\n): number | null {\n    // Get the timeline set that contains all the events.\n    const timelineSet = room.getUnfilteredTimelineSet();\n\n    // If they are in the same timeline, compareEventOrdering does what we need\n    const compareSameTimeline = timelineSet.compareEventOrdering(leftEventId, rightEventId);\n    if (compareSameTimeline !== null) {\n        return compareSameTimeline;\n    }\n\n    // Find which timeline each event is in. Refuse to provide an ordering if we\n    // can't find either of the events.\n\n    const leftTimeline = timelineSet.getTimelineForEvent(leftEventId);\n    if (leftTimeline === timelineSet.getLiveTimeline()) {\n        // The left event is part of the live timeline, so it must be after the\n        // right event (since they are not in the same timeline or we would have\n        // returned after compareEventOrdering.\n        return 1;\n    }\n\n    const rightTimeline = timelineSet.getTimelineForEvent(rightEventId);\n    if (rightTimeline === timelineSet.getLiveTimeline()) {\n        // The right event is part of the live timeline, so it must be after the\n        // left event.\n        return -1;\n    }\n\n    // They are in older timeline sets (because they were fetched by paging up).\n    return guessOrderBasedOnTimestamp(leftEvent, rightEvent);\n}\n\nfunction compareEventsInThreads(\n    leftEventId: string,\n    rightEventId: string,\n    leftEvent: MatrixEvent,\n    rightEvent: MatrixEvent,\n): number | null {\n    const leftEventThreadId = threadIdForReceipt(leftEvent);\n    const rightEventThreadId = threadIdForReceipt(rightEvent);\n\n    const leftThread = leftEvent.getThread();\n\n    if (leftThread && leftEventThreadId === rightEventThreadId) {\n        // They are in the same thread, so we can ask the thread's timeline to\n        // figure it out for us\n        return leftThread.timelineSet.compareEventOrdering(leftEventId, rightEventId);\n    } else {\n        return guessOrderBasedOnTimestamp(leftEvent, rightEvent);\n    }\n}\n\n/**\n * Guess the order of events based on server timestamp. This is not good, but\n * difficult to avoid without MSC4033.\n *\n * See https://github.com/matrix-org/matrix-js-sdk/issues/3325\n */\nfunction guessOrderBasedOnTimestamp(leftEvent: MatrixEvent, rightEvent: MatrixEvent): number {\n    const leftTs = leftEvent.getTs();\n    const rightTs = rightEvent.getTs();\n    if (leftTs < rightTs) {\n        return -1;\n    } else if (leftTs > rightTs) {\n        return 1;\n    } else {\n        return 0;\n    }\n}\n","/*\nCopyright 2015 - 2023 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { M_POLL_START, type Optional } from \"matrix-events-sdk\";\n\nimport {\n    EventTimelineSet,\n    DuplicateStrategy,\n    type IAddLiveEventOptions,\n    type EventTimelineSetHandlerMap,\n} from \"./event-timeline-set.ts\";\nimport { Direction, EventTimeline } from \"./event-timeline.ts\";\nimport { getHttpUriForMxc } from \"../content-repo.ts\";\nimport { removeElement } from \"../utils.ts\";\nimport { normalize, noUnsafeEventProps } from \"../utils.ts\";\nimport {\n    type IEvent,\n    type IThreadBundledRelationship,\n    MatrixEvent,\n    MatrixEventEvent,\n    type MatrixEventHandlerMap,\n} from \"./event.ts\";\nimport { EventStatus } from \"./event-status.ts\";\nimport { RoomMember } from \"./room-member.ts\";\nimport { type IRoomSummary, RoomSummary } from \"./room-summary.ts\";\nimport { logger } from \"../logger.ts\";\nimport { TypedReEmitter } from \"../ReEmitter.ts\";\nimport {\n    EventType,\n    RoomCreateTypeField,\n    RoomType,\n    UNSTABLE_ELEMENT_FUNCTIONAL_USERS,\n    EVENT_VISIBILITY_CHANGE_TYPE,\n    RelationType,\n    UNSIGNED_THREAD_ID_FIELD,\n} from \"../@types/event.ts\";\nimport { type MatrixClient, PendingEventOrdering } from \"../client.ts\";\nimport { type GuestAccess, type HistoryVisibility, type JoinRule, type ResizeMethod } from \"../@types/partials.ts\";\nimport { Filter, type IFilterDefinition } from \"../filter.ts\";\nimport { type RoomState, RoomStateEvent, type RoomStateEventHandlerMap } from \"./room-state.ts\";\nimport { BeaconEvent, type BeaconEventHandlerMap } from \"./beacon.ts\";\nimport {\n    Thread,\n    ThreadEvent,\n    type ThreadEventHandlerMap as ThreadHandlerMap,\n    FILTER_RELATED_BY_REL_TYPES,\n    THREAD_RELATION_TYPE,\n    FILTER_RELATED_BY_SENDERS,\n    ThreadFilterType,\n} from \"./thread.ts\";\nimport {\n    type CachedReceiptStructure,\n    MAIN_ROOM_TIMELINE,\n    type Receipt,\n    type ReceiptContent,\n    ReceiptType,\n} from \"../@types/read_receipts.ts\";\nimport { type IStateEventWithRoomId } from \"../@types/search.ts\";\nimport { RelationsContainer } from \"./relations-container.ts\";\nimport { ReadReceipt, synthesizeReceipt } from \"./read-receipt.ts\";\nimport { isPollEvent, Poll, PollEvent } from \"./poll.ts\";\nimport { RoomReceipts } from \"./room-receipts.ts\";\nimport { compareEventOrdering } from \"./compare-event-ordering.ts\";\nimport * as utils from \"../utils.ts\";\nimport { KnownMembership, type Membership } from \"../@types/membership.ts\";\nimport { type Capabilities, type IRoomVersionsCapability, RoomVersionStability } from \"../serverCapabilities.ts\";\n\n// These constants are used as sane defaults when the homeserver doesn't support\n// the m.room_versions capability. In practice, KNOWN_SAFE_ROOM_VERSION should be\n// the same as the common default room version whereas SAFE_ROOM_VERSIONS are the\n// room versions which are considered okay for people to run without being asked\n// to upgrade (ie: \"stable\"). Eventually, we should remove these when all homeservers\n// return an m.room_versions capability.\nexport const KNOWN_SAFE_ROOM_VERSION = \"10\";\nconst SAFE_ROOM_VERSIONS = [\"1\", \"2\", \"3\", \"4\", \"5\", \"6\", \"7\", \"8\", \"9\", \"10\"];\n\ninterface IOpts {\n    /**\n     * Controls where pending messages appear in a room's timeline.\n     * If \"<b>chronological</b>\", messages will appear in the timeline when the call to `sendEvent` was made.\n     * If \"<b>detached</b>\", pending messages will appear in a separate list,\n     * accessible via {@link Room#getPendingEvents}.\n     * Default: \"chronological\".\n     */\n    pendingEventOrdering?: PendingEventOrdering;\n    /**\n     * Set to true to enable improved timeline support.\n     */\n    timelineSupport?: boolean;\n    lazyLoadMembers?: boolean;\n}\n\nexport interface IRecommendedVersion {\n    version: string;\n    needsUpgrade: boolean;\n    urgent: boolean;\n}\n\n// When inserting a visibility event affecting event `eventId`, we\n// need to scan through existing visibility events for `eventId`.\n// In theory, this could take an unlimited amount of time if:\n//\n// - the visibility event was sent by a moderator; and\n// - `eventId` already has many visibility changes (usually, it should\n//   be 2 or less); and\n// - for some reason, the visibility changes are received out of order\n//   (usually, this shouldn't happen at all).\n//\n// For this reason, we limit the number of events to scan through,\n// expecting that a broken visibility change for a single event in\n// an extremely uncommon case (possibly a DoS) is a small\n// price to pay to keep matrix-js-sdk responsive.\nconst MAX_NUMBER_OF_VISIBILITY_EVENTS_TO_SCAN_THROUGH = 30;\n\nexport type NotificationCount = Partial<Record<NotificationCountType, number>>;\n\nexport enum NotificationCountType {\n    Highlight = \"highlight\",\n    Total = \"total\",\n}\n\nexport interface ICreateFilterOpts {\n    // Populate the filtered timeline with already loaded events in the room\n    // timeline. Useful to disable for some filters that can't be achieved by the\n    // client in an efficient manner\n    prepopulateTimeline?: boolean;\n    useSyncEvents?: boolean;\n    pendingEvents?: boolean;\n}\n\nexport enum RoomEvent {\n    MyMembership = \"Room.myMembership\",\n    Tags = \"Room.tags\",\n    AccountData = \"Room.accountData\",\n    Receipt = \"Room.receipt\",\n    Name = \"Room.name\",\n    Redaction = \"Room.redaction\",\n    RedactionCancelled = \"Room.redactionCancelled\",\n    LocalEchoUpdated = \"Room.localEchoUpdated\",\n    Timeline = \"Room.timeline\",\n    TimelineReset = \"Room.timelineReset\",\n    TimelineRefresh = \"Room.TimelineRefresh\",\n    OldStateUpdated = \"Room.OldStateUpdated\",\n    CurrentStateUpdated = \"Room.CurrentStateUpdated\",\n    HistoryImportedWithinTimeline = \"Room.historyImportedWithinTimeline\",\n    UnreadNotifications = \"Room.UnreadNotifications\",\n    Summary = \"Room.Summary\",\n}\n\nexport type RoomEmittedEvents =\n    | RoomEvent\n    | RoomStateEvent.Events\n    | RoomStateEvent.Members\n    | RoomStateEvent.NewMember\n    | RoomStateEvent.Update\n    | RoomStateEvent.Marker\n    | ThreadEvent.New\n    | ThreadEvent.Update\n    | ThreadEvent.NewReply\n    | ThreadEvent.Delete\n    | MatrixEventEvent.BeforeRedaction\n    | BeaconEvent.New\n    | BeaconEvent.Update\n    | BeaconEvent.Destroy\n    | BeaconEvent.LivenessChange\n    | PollEvent.New;\n\nexport type RoomEventHandlerMap = {\n    /**\n     * Fires when the logged in user's membership in the room is updated.\n     *\n     * @param room - The room in which the membership has been updated\n     * @param membership - The new membership value\n     * @param prevMembership - The previous membership value\n     */\n    [RoomEvent.MyMembership]: (room: Room, membership: Membership, prevMembership?: Membership) => void;\n    /**\n     * Fires whenever a room's tags are updated.\n     * @param event - The tags event\n     * @param room - The room whose Room.tags was updated.\n     * @example\n     * ```\n     * matrixClient.on(\"Room.tags\", function(event, room){\n     *   var newTags = event.getContent().tags;\n     *   if (newTags[\"favourite\"]) showStar(room);\n     * });\n     * ```\n     */\n    [RoomEvent.Tags]: (event: MatrixEvent, room: Room) => void;\n    /**\n     * Fires whenever a room's account_data is updated.\n     * @param event - The account_data event\n     * @param room - The room whose account_data was updated.\n     * @param prevEvent - The event being replaced by\n     * the new account data, if known.\n     * @example\n     * ```\n     * matrixClient.on(\"Room.accountData\", function(event, room, oldEvent){\n     *   if (event.getType() === \"m.room.colorscheme\") {\n     *       applyColorScheme(event.getContents());\n     *   }\n     * });\n     * ```\n     */\n    [RoomEvent.AccountData]: (event: MatrixEvent, room: Room, prevEvent?: MatrixEvent) => void;\n    /**\n     * Fires whenever a receipt is received for a room\n     * @param event - The receipt event\n     * @param room - The room whose receipts was updated.\n     * @example\n     * ```\n     * matrixClient.on(\"Room.receipt\", function(event, room){\n     *   var receiptContent = event.getContent();\n     * });\n     * ```\n     */\n    [RoomEvent.Receipt]: (event: MatrixEvent, room: Room) => void;\n    /**\n     * Fires whenever the name of a room is updated.\n     * @param room - The room whose Room.name was updated.\n     * @example\n     * ```\n     * matrixClient.on(\"Room.name\", function(room){\n     *   var newName = room.name;\n     * });\n     * ```\n     */\n    [RoomEvent.Name]: (room: Room) => void;\n    /**\n     * Fires when an event we had previously received is redacted.\n     *\n     * (Note this is *not* fired when the redaction happens before we receive the\n     * event).\n     *\n     * @param event - The matrix redaction event\n     * @param room - The room containing the redacted event\n     * @param threadId - The thread containing the redacted event (before it was redacted)\n     */\n    [RoomEvent.Redaction]: (event: MatrixEvent, room: Room, threadId?: string) => void;\n    /**\n     * Fires when an event that was previously redacted isn't anymore.\n     * This happens when the redaction couldn't be sent and\n     * was subsequently cancelled by the user. Redactions have a local echo\n     * which is undone in this scenario.\n     *\n     * @param event - The matrix redaction event that was cancelled.\n     * @param room - The room containing the unredacted event\n     */\n    [RoomEvent.RedactionCancelled]: (event: MatrixEvent, room: Room) => void;\n    /**\n     * Fires when the status of a transmitted event is updated.\n     *\n     * <p>When an event is first transmitted, a temporary copy of the event is\n     * inserted into the timeline, with a temporary event id, and a status of\n     * 'SENDING'.\n     *\n     * <p>Once the echo comes back from the server, the content of the event\n     * (MatrixEvent.event) is replaced by the complete event from the homeserver,\n     * thus updating its event id, as well as server-generated fields such as the\n     * timestamp. Its status is set to null.\n     *\n     * <p>Once the /send request completes, if the remote echo has not already\n     * arrived, the event is updated with a new event id and the status is set to\n     * 'SENT'. The server-generated fields are of course not updated yet.\n     *\n     * <p>If the /send fails, In this case, the event's status is set to\n     * 'NOT_SENT'. If it is later resent, the process starts again, setting the\n     * status to 'SENDING'. Alternatively, the message may be cancelled, which\n     * removes the event from the room, and sets the status to 'CANCELLED'.\n     *\n     * <p>This event is raised to reflect each of the transitions above.\n     *\n     * @param event - The matrix event which has been updated\n     *\n     * @param room - The room containing the redacted event\n     *\n     * @param oldEventId - The previous event id (the temporary event id,\n     *    except when updating a successfully-sent event when its echo arrives)\n     *\n     * @param oldStatus - The previous event status.\n     */\n    [RoomEvent.LocalEchoUpdated]: (\n        event: MatrixEvent,\n        room: Room,\n        oldEventId?: string,\n        oldStatus?: EventStatus | null,\n    ) => void;\n    [RoomEvent.OldStateUpdated]: (room: Room, previousRoomState: RoomState, roomState: RoomState) => void;\n    [RoomEvent.CurrentStateUpdated]: (room: Room, previousRoomState: RoomState, roomState: RoomState) => void;\n    [RoomEvent.HistoryImportedWithinTimeline]: (markerEvent: MatrixEvent, room: Room) => void;\n    [RoomEvent.UnreadNotifications]: (unreadNotifications?: NotificationCount, threadId?: string) => void;\n    [RoomEvent.TimelineRefresh]: (room: Room, eventTimelineSet: EventTimelineSet) => void;\n    /**\n     * Fires when a new room summary is returned by `/sync`.\n     *\n     * See https://spec.matrix.org/v1.8/client-server-api/#_matrixclientv3sync_roomsummary\n     * for full details\n     * @param summary - the room summary object\n     */\n    [RoomEvent.Summary]: (summary: IRoomSummary) => void;\n    [ThreadEvent.New]: (thread: Thread, toStartOfTimeline: boolean) => void;\n    /**\n     * Fires when a new poll instance is added to the room state\n     * @param poll - the new poll\n     */\n    [PollEvent.New]: (poll: Poll) => void;\n} & Pick<ThreadHandlerMap, ThreadEvent.Update | ThreadEvent.NewReply | ThreadEvent.Delete> &\n    EventTimelineSetHandlerMap &\n    Pick<MatrixEventHandlerMap, MatrixEventEvent.BeforeRedaction> &\n    Pick<\n        RoomStateEventHandlerMap,\n        | RoomStateEvent.Events\n        | RoomStateEvent.Members\n        | RoomStateEvent.NewMember\n        | RoomStateEvent.Update\n        | RoomStateEvent.Marker\n        | BeaconEvent.New\n    > &\n    Pick<BeaconEventHandlerMap, BeaconEvent.Update | BeaconEvent.Destroy | BeaconEvent.LivenessChange>;\n\nexport class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {\n    public readonly reEmitter: TypedReEmitter<RoomEmittedEvents, RoomEventHandlerMap>;\n    private txnToEvent: Map<string, MatrixEvent> = new Map(); // Pending in-flight requests { string: MatrixEvent }\n    private notificationCounts: NotificationCount = {};\n    private readonly threadNotifications = new Map<string, NotificationCount>();\n    public readonly cachedThreadReadReceipts = new Map<string, CachedReceiptStructure[]>();\n    // Useful to know at what point the current user has started using threads in this room\n    private oldestThreadedReceiptTs = Infinity;\n    /**\n     * A record of the latest unthread receipts per user\n     * This is useful in determining whether a user has read a thread or not\n     */\n    private unthreadedReceipts = new Map<string, Receipt>();\n    private readonly timelineSets: EventTimelineSet[];\n    public readonly polls: Map<string, Poll> = new Map<string, Poll>();\n\n    /**\n     * Empty array if the timeline sets have not been initialised. After initialisation:\n     * 0: All threads\n     * 1: Threads the current user has participated in\n     */\n    public readonly threadsTimelineSets: [] | [EventTimelineSet, EventTimelineSet] = [];\n\n    // any filtered timeline sets we're maintaining for this room\n    private readonly filteredTimelineSets: Record<string, EventTimelineSet> = {}; // filter_id: timelineSet\n    private timelineNeedsRefresh = false;\n    private readonly pendingEventList?: MatrixEvent[];\n    // read by megolm via getter; boolean value - null indicates \"use global value\"\n    private blacklistUnverifiedDevices?: boolean;\n    private selfMembership?: Membership;\n    private summaryHeroes: string[] | null = null;\n    // flags to stop logspam about missing m.room.create events\n    private getTypeWarning = false;\n    private getVersionWarning = false;\n    private membersPromise?: Promise<boolean>;\n\n    // XXX: These should be read-only\n    /**\n     * The human-readable display name for this room.\n     */\n    public name: string;\n    /**\n     * The un-homoglyphed name for this room.\n     */\n    public normalizedName: string;\n    /**\n     * Dict of room tags; the keys are the tag name and the values\n     * are any metadata associated with the tag - e.g. `{ \"fav\" : { order: 1 } }`\n     */\n    public tags: Record<string, Record<string, any>> = {}; // $tagName: { $metadata: $value }\n    /**\n     * accountData Dict of per-room account_data events; the keys are the\n     * event type and the values are the events.\n     */\n    public accountData: Map<string, MatrixEvent> = new Map(); // $eventType: $event\n    /**\n     * The room summary.\n     */\n    public summary: RoomSummary | null = null;\n    /**\n     * oldState The state of the room at the time of the oldest event in the live timeline.\n     *\n     * @deprecated Present for backwards compatibility.\n     *             Use getLiveTimeline().getState(EventTimeline.BACKWARDS) instead\n     */\n    public oldState!: RoomState;\n    /**\n     * currentState The state of the room at the time of the newest event in the timeline.\n     *\n     * @deprecated Present for backwards compatibility.\n     *             Use getLiveTimeline().getState(EventTimeline.FORWARDS) instead.\n     */\n    public currentState!: RoomState;\n\n    public readonly relations;\n\n    /**\n     * A collection of events known by the client\n     * This is not a comprehensive list of the threads that exist in this room\n     */\n    private threads = new Map<string, Thread>();\n\n    /**\n     * A mapping of eventId to all visibility changes to apply\n     * to the event, by chronological order, as per\n     * https://github.com/matrix-org/matrix-doc/pull/3531\n     *\n     * # Invariants\n     *\n     * - within each list, all events are classed by\n     *   chronological order;\n     * - all events are events such that\n     *  `asVisibilityEvent()` returns a non-null `IVisibilityChange`;\n     * - within each list with key `eventId`, all events\n     *   are in relation to `eventId`.\n     *\n     * @experimental\n     */\n    private visibilityEvents = new Map<string, MatrixEvent[]>();\n\n    /**\n     * The latest receipts (synthetic and real) for each user in each thread\n     * (and unthreaded).\n     */\n    private roomReceipts = new RoomReceipts(this);\n\n    /**\n     * Construct a new Room.\n     *\n     * <p>For a room, we store an ordered sequence of timelines, which may or may not\n     * be continuous. Each timeline lists a series of events, as well as tracking\n     * the room state at the start and the end of the timeline. It also tracks\n     * forward and backward pagination tokens, as well as containing links to the\n     * next timeline in the sequence.\n     *\n     * <p>There is one special timeline - the 'live' timeline, which represents the\n     * timeline to which events are being added in real-time as they are received\n     * from the /sync API. Note that you should not retain references to this\n     * timeline - even if it is the current timeline right now, it may not remain\n     * so if the server gives us a timeline gap in /sync.\n     *\n     * <p>In order that we can find events from their ids later, we also maintain a\n     * map from event_id to timeline and index.\n     *\n     * @param roomId - Required. The ID of this room.\n     * @param client - Required. The client, used to lazy load members.\n     * @param myUserId - Required. The ID of the syncing user.\n     * @param opts - Configuration options\n     */\n    public constructor(\n        public readonly roomId: string,\n        public readonly client: MatrixClient,\n        public readonly myUserId: string,\n        private readonly opts: IOpts = {},\n    ) {\n        super();\n\n        // In some cases, we add listeners for every displayed Matrix event, so it's\n        // common to have quite a few more than the default limit.\n        this.setMaxListeners(100);\n        this.reEmitter = new TypedReEmitter(this);\n\n        opts.pendingEventOrdering = opts.pendingEventOrdering || PendingEventOrdering.Chronological;\n\n        this.name = roomId;\n        this.normalizedName = roomId;\n\n        this.relations = new RelationsContainer(this.client, this);\n\n        // Listen to our own receipt event as a more modular way of processing our own\n        // receipts. No need to remove the listener: it's on ourself anyway.\n        this.on(RoomEvent.Receipt, this.onReceipt);\n\n        // all our per-room timeline sets. the first one is the unfiltered ones;\n        // the subsequent ones are the filtered ones in no particular order.\n        this.timelineSets = [new EventTimelineSet(this, opts)];\n        this.reEmitter.reEmit(this.getUnfilteredTimelineSet(), [RoomEvent.Timeline, RoomEvent.TimelineReset]);\n\n        this.fixUpLegacyTimelineFields();\n\n        if (this.opts.pendingEventOrdering === PendingEventOrdering.Detached) {\n            this.pendingEventList = [];\n            this.client.store.getPendingEvents(this.roomId).then((events) => {\n                const mapper = this.client.getEventMapper({\n                    toDevice: false,\n                    decrypt: false,\n                });\n                events.forEach(async (serializedEvent: Partial<IEvent>) => {\n                    const event = mapper(serializedEvent);\n                    await client.decryptEventIfNeeded(event);\n                    event.setStatus(EventStatus.NOT_SENT);\n                    this.addPendingEvent(event, event.getTxnId()!);\n                });\n            });\n        }\n\n        // awaited by getEncryptionTargetMembers while room members are loading\n        if (!this.opts.lazyLoadMembers) {\n            this.membersPromise = Promise.resolve(false);\n        } else {\n            this.membersPromise = undefined;\n        }\n    }\n\n    private threadTimelineSetsPromise: Promise<[EventTimelineSet, EventTimelineSet]> | null = null;\n    public async createThreadsTimelineSets(): Promise<[EventTimelineSet, EventTimelineSet] | null> {\n        if (this.threadTimelineSetsPromise) {\n            return this.threadTimelineSetsPromise;\n        }\n\n        if (this.client?.supportsThreads()) {\n            try {\n                this.threadTimelineSetsPromise = Promise.all([\n                    this.createThreadTimelineSet(),\n                    this.createThreadTimelineSet(ThreadFilterType.My),\n                ]);\n                const timelineSets = await this.threadTimelineSetsPromise;\n                this.threadsTimelineSets[0] = timelineSets[0];\n                this.threadsTimelineSets[1] = timelineSets[1];\n                return timelineSets;\n            } catch {\n                this.threadTimelineSetsPromise = null;\n                return null;\n            }\n        }\n        return null;\n    }\n\n    /**\n     * Bulk decrypt critical events in a room\n     *\n     * Critical events represents the minimal set of events to decrypt\n     * for a typical UI to function properly\n     *\n     * - Last event of every room (to generate likely message preview)\n     * - All events up to the read receipt (to calculate an accurate notification count)\n     *\n     * @returns Signals when all events have been decrypted\n     */\n    public async decryptCriticalEvents(): Promise<void> {\n        if (!this.client.getCrypto()) return;\n\n        const readReceiptEventId = this.getEventReadUpTo(this.client.getUserId()!, true);\n        const events = this.getLiveTimeline().getEvents();\n        const readReceiptTimelineIndex = events.findIndex((matrixEvent) => {\n            return matrixEvent.event.event_id === readReceiptEventId;\n        });\n\n        const decryptionPromises = events\n            .slice(readReceiptTimelineIndex)\n            .reverse()\n            .map((event) => this.client.decryptEventIfNeeded(event));\n\n        await Promise.allSettled(decryptionPromises);\n    }\n\n    /**\n     * Bulk decrypt events in a room\n     *\n     * @returns Signals when all events have been decrypted\n     */\n    public async decryptAllEvents(): Promise<void> {\n        if (!this.client.getCrypto()) return;\n\n        const decryptionPromises = this.getUnfilteredTimelineSet()\n            .getLiveTimeline()\n            .getEvents()\n            .slice(0) // copy before reversing\n            .reverse()\n            .map((event) => this.client.decryptEventIfNeeded(event));\n\n        await Promise.allSettled(decryptionPromises);\n    }\n\n    /**\n     * Gets the creator of the room\n     * @returns The creator of the room, or null if it could not be determined\n     */\n    public getCreator(): string | null {\n        const createEvent = this.currentState.getStateEvents(EventType.RoomCreate, \"\");\n        return createEvent?.getSender() ?? null;\n    }\n\n    /**\n     * Gets the version of the room\n     * @returns The version of the room, or null if it could not be determined\n     */\n    public getVersion(): string {\n        const createEvent = this.currentState.getStateEvents(EventType.RoomCreate, \"\");\n        if (!createEvent) {\n            if (!this.getVersionWarning) {\n                logger.warn(\"[getVersion] Room \" + this.roomId + \" does not have an m.room.create event\");\n                this.getVersionWarning = true;\n            }\n            return \"1\";\n        }\n        return createEvent.getContent()[\"room_version\"] ?? \"1\";\n    }\n\n    /**\n     * Determines the recommended room version for the room. This returns an\n     * object with 3 properties: `version` as the new version the\n     * room should be upgraded to (may be the same as the current version);\n     * `needsUpgrade` to indicate if the room actually can be\n     * upgraded (ie: does the current version not match?); and `urgent`\n     * to indicate if the new version patches a vulnerability in a previous\n     * version.\n     * @returns\n     * Resolves to the version the room should be upgraded to.\n     */\n    public async getRecommendedVersion(): Promise<IRecommendedVersion> {\n        let capabilities: Capabilities = {};\n        try {\n            capabilities = await this.client.getCapabilities();\n        } catch {}\n        let versionCap = capabilities[\"m.room_versions\"];\n        if (!versionCap) {\n            versionCap = {\n                default: KNOWN_SAFE_ROOM_VERSION,\n                available: {},\n            };\n            for (const safeVer of SAFE_ROOM_VERSIONS) {\n                versionCap.available[safeVer] = RoomVersionStability.Stable;\n            }\n        }\n\n        let result = this.checkVersionAgainstCapability(versionCap);\n        if (result.urgent && result.needsUpgrade) {\n            // Something doesn't feel right: we shouldn't need to update\n            // because the version we're on should be in the protocol's\n            // namespace. This usually means that the server was updated\n            // before the client was, making us think the newest possible\n            // room version is not stable. As a solution, we'll refresh\n            // the capability we're using to determine this.\n            logger.warn(\n                \"Refreshing room version capability because the server looks \" +\n                    \"to be supporting a newer room version we don't know about.\",\n            );\n\n            try {\n                capabilities = await this.client.fetchCapabilities();\n            } catch (e) {\n                logger.warn(\"Failed to refresh room version capabilities\", e);\n            }\n            versionCap = capabilities[\"m.room_versions\"];\n            if (!versionCap) {\n                logger.warn(\"No room version capability - assuming upgrade required.\");\n                return result;\n            } else {\n                result = this.checkVersionAgainstCapability(versionCap);\n            }\n        }\n\n        return result;\n    }\n\n    private checkVersionAgainstCapability(versionCap: IRoomVersionsCapability): IRecommendedVersion {\n        const currentVersion = this.getVersion();\n        logger.log(`[${this.roomId}] Current version: ${currentVersion}`);\n        logger.log(`[${this.roomId}] Version capability: `, versionCap);\n\n        const result: IRecommendedVersion = {\n            version: currentVersion,\n            needsUpgrade: false,\n            urgent: false,\n        };\n\n        // If the room is on the default version then nothing needs to change\n        if (currentVersion === versionCap.default) return result;\n\n        const stableVersions = Object.keys(versionCap.available).filter((v) => versionCap.available[v] === \"stable\");\n\n        // Check if the room is on an unstable version. We determine urgency based\n        // off the version being in the Matrix spec namespace or not (if the version\n        // is in the current namespace and unstable, the room is probably vulnerable).\n        if (!stableVersions.includes(currentVersion)) {\n            result.version = versionCap.default;\n            result.needsUpgrade = true;\n            result.urgent = !!this.getVersion().match(/^[0-9]+[0-9.]*$/g);\n            if (result.urgent) {\n                logger.warn(`URGENT upgrade required on ${this.roomId}`);\n            } else {\n                logger.warn(`Non-urgent upgrade required on ${this.roomId}`);\n            }\n            return result;\n        }\n\n        // The room is on a stable, but non-default, version by this point.\n        // No upgrade needed.\n        return result;\n    }\n\n    /**\n     * Determines whether the given user is permitted to perform a room upgrade\n     * @param userId - The ID of the user to test against\n     * @returns True if the given user is permitted to upgrade the room\n     */\n    public userMayUpgradeRoom(userId: string): boolean {\n        return this.currentState.maySendStateEvent(EventType.RoomTombstone, userId);\n    }\n\n    /**\n     * Get the list of pending sent events for this room\n     *\n     * @returns A list of the sent events\n     * waiting for remote echo.\n     *\n     * @throws If `opts.pendingEventOrdering` was not 'detached'\n     */\n    public getPendingEvents(): MatrixEvent[] {\n        if (!this.pendingEventList) {\n            throw new Error(\n                \"Cannot call getPendingEvents with pendingEventOrdering == \" + this.opts.pendingEventOrdering,\n            );\n        }\n\n        return this.pendingEventList;\n    }\n\n    /**\n     * Removes a pending event for this room\n     *\n     * @returns True if an element was removed.\n     */\n    public removePendingEvent(eventId: string): boolean {\n        if (!this.pendingEventList) {\n            throw new Error(\n                \"Cannot call removePendingEvent with pendingEventOrdering == \" + this.opts.pendingEventOrdering,\n            );\n        }\n\n        const removed = removeElement(\n            this.pendingEventList,\n            function (ev) {\n                return ev.getId() == eventId;\n            },\n            false,\n        );\n\n        this.savePendingEvents();\n\n        return removed;\n    }\n\n    /**\n     * Check whether the pending event list contains a given event by ID.\n     * If pending event ordering is not \"detached\" then this returns false.\n     *\n     * @param eventId - The event ID to check for.\n     */\n    public hasPendingEvent(eventId: string): boolean {\n        return this.pendingEventList?.some((event) => event.getId() === eventId) ?? false;\n    }\n\n    /**\n     * Get a specific event from the pending event list, if configured, null otherwise.\n     *\n     * @param eventId - The event ID to check for.\n     */\n    public getPendingEvent(eventId: string): MatrixEvent | null {\n        return this.pendingEventList?.find((event) => event.getId() === eventId) ?? null;\n    }\n\n    /**\n     * Get the live unfiltered timeline for this room.\n     *\n     * @returns live timeline\n     */\n    public getLiveTimeline(): EventTimeline {\n        return this.getUnfilteredTimelineSet().getLiveTimeline();\n    }\n\n    /**\n     * The live event timeline for this room, with the oldest event at index 0.\n     *\n     * @deprecated Present for backwards compatibility.\n     *             Use getLiveTimeline().getEvents() instead\n     */\n    public get timeline(): MatrixEvent[] {\n        return this.getLiveTimeline().getEvents();\n    }\n\n    /**\n     * Get the timestamp of the last message in the room\n     *\n     * @returns the timestamp of the last message in the room\n     */\n    public getLastActiveTimestamp(): number {\n        const timeline = this.getLiveTimeline();\n        const events = timeline.getEvents();\n        if (events.length) {\n            const lastEvent = events[events.length - 1];\n            return lastEvent.getTs();\n        } else {\n            return Number.MIN_SAFE_INTEGER;\n        }\n    }\n\n    /**\n     * Returns the last live event of this room.\n     * \"last\" means latest timestamp.\n     * Instead of using timestamps, it would be better to do the comparison based on the order of the homeserver DAG.\n     * Unfortunately, this information is currently not available in the client.\n     * See {@link https://github.com/matrix-org/matrix-js-sdk/issues/3325}.\n     * \"live of this room\" means from all live timelines: the room and the threads.\n     *\n     * @returns MatrixEvent if there is a last event; else undefined.\n     */\n    public getLastLiveEvent(): MatrixEvent | undefined {\n        const roomEvents = this.getLiveTimeline().getEvents();\n        const lastRoomEvent = roomEvents[roomEvents.length - 1] as MatrixEvent | undefined;\n        const lastThread = this.getLastThread();\n\n        if (!lastThread) return lastRoomEvent;\n\n        const lastThreadEvent = lastThread.events[lastThread.events.length - 1];\n\n        return (lastRoomEvent?.getTs() ?? 0) > (lastThreadEvent?.getTs() ?? 0) ? lastRoomEvent : lastThreadEvent;\n    }\n\n    /**\n     * Returns the last thread of this room.\n     * \"last\" means latest timestamp of the last thread event.\n     * Instead of using timestamps, it would be better to do the comparison based on the order of the homeserver DAG.\n     * Unfortunately, this information is currently not available in the client.\n     * See {@link https://github.com/matrix-org/matrix-js-sdk/issues/3325}.\n     *\n     * @returns the thread with the most recent event in its live time line. undefined if there is no thread.\n     */\n    public getLastThread(): Thread | undefined {\n        return this.getThreads().reduce<Thread | undefined>((lastThread: Thread | undefined, thread: Thread) => {\n            if (!lastThread) return thread;\n\n            const threadEvent = thread.events[thread.events.length - 1];\n            const lastThreadEvent = lastThread.events[lastThread.events.length - 1];\n\n            if ((threadEvent?.getTs() ?? 0) >= (lastThreadEvent?.getTs() ?? 0)) {\n                // Last message of current thread is newer → new last thread.\n                // Equal also means newer, because it was added to the thread map later.\n                return thread;\n            }\n\n            return lastThread;\n        }, undefined);\n    }\n\n    /**\n     * @returns the membership type (join | leave | invite | knock) for the logged in user\n     */\n    public getMyMembership(): Membership {\n        return this.selfMembership ?? KnownMembership.Leave;\n    }\n\n    /**\n     * If this room is a DM we're invited to,\n     * try to find out who invited us\n     * @returns user id of the inviter\n     */\n    public getDMInviter(): string | undefined {\n        const me = this.getMember(this.myUserId);\n        if (me) {\n            return me.getDMInviter();\n        }\n\n        if (this.selfMembership === KnownMembership.Invite) {\n            // fall back to summary information\n            const memberCount = this.getInvitedAndJoinedMemberCount();\n            if (memberCount === 2) {\n                return this.summaryHeroes?.[0];\n            }\n        }\n    }\n\n    /**\n     * Assuming this room is a DM room, tries to guess with which user.\n     * @returns user id of the other member (could be syncing user)\n     */\n    public guessDMUserId(): string {\n        const me = this.getMember(this.myUserId);\n        if (me) {\n            const inviterId = me.getDMInviter();\n            if (inviterId) {\n                return inviterId;\n            }\n        }\n        // Remember, we're assuming this room is a DM, so returning the first member we find should be fine\n        if (Array.isArray(this.summaryHeroes) && this.summaryHeroes.length) {\n            return this.summaryHeroes[0];\n        }\n        const members = this.currentState.getMembers();\n        const anyMember = members.find((m) => m.userId !== this.myUserId);\n        if (anyMember) {\n            return anyMember.userId;\n        }\n        // it really seems like I'm the only user in the room\n        // so I probably created a room with just me in it\n        // and marked it as a DM. Ok then\n        return this.myUserId;\n    }\n\n    /**\n     * Gets the \"functional members\" in this room.\n     *\n     * Returns the list of userIDs from the `io.element.functional_members` event. Does not consider the\n     * current membership states of those users.\n     *\n     * @see https://github.com/element-hq/element-meta/blob/develop/spec/functional_members.md.\n     */\n    private getFunctionalMembers(): string[] {\n        const mFunctionalMembers = this.currentState.getStateEvents(UNSTABLE_ELEMENT_FUNCTIONAL_USERS.name, \"\");\n        if (Array.isArray(mFunctionalMembers?.getContent().service_members)) {\n            return mFunctionalMembers!.getContent().service_members;\n        }\n        return [];\n    }\n\n    public getAvatarFallbackMember(): RoomMember | undefined {\n        const functionalMembers = this.getFunctionalMembers();\n\n        // Only generate a fallback avatar if the conversation is with a single specific other user (a \"DM\").\n        let nonFunctionalMemberCount = 0;\n        this.getMembers()!.forEach((m) => {\n            if (m.membership !== \"join\" && m.membership !== \"invite\") return;\n            if (functionalMembers.includes(m.userId)) return;\n            nonFunctionalMemberCount++;\n        });\n        if (nonFunctionalMemberCount > 2) return;\n\n        // Prefer the list of heroes, if present. It should only include the single other user in the DM.\n        const nonFunctionalHeroes = this.summaryHeroes?.filter((h) => !functionalMembers.includes(h));\n        const hasHeroes = Array.isArray(nonFunctionalHeroes) && nonFunctionalHeroes.length;\n        if (hasHeroes) {\n            const availableMember = nonFunctionalHeroes\n                .map((userId) => {\n                    return this.getMember(userId);\n                })\n                .find((member) => !!member);\n            if (availableMember) {\n                return availableMember;\n            }\n        }\n\n        // Consider *all*, including previous, members, to generate the avatar for DMs where the other user left.\n        // Needed to generate a matching avatar for rooms named \"Empty Room (was Alice)\".\n        const members = this.getMembers();\n        const nonFunctionalMembers = members?.filter((m) => !functionalMembers.includes(m.userId));\n        if (nonFunctionalMembers.length <= 2) {\n            const availableMember = nonFunctionalMembers.find((m) => {\n                return m.userId !== this.myUserId;\n            });\n            if (availableMember) {\n                return availableMember;\n            }\n        }\n\n        // If all else failed, but the homeserver gave us heroes that previously could not be found in the room members,\n        // trust and try falling back to a hero, creating a one-off member for it\n        if (hasHeroes) {\n            const availableUser = nonFunctionalHeroes\n                .map((userId) => {\n                    return this.client.getUser(userId);\n                })\n                .find((user) => !!user);\n            if (availableUser) {\n                const member = new RoomMember(this.roomId, availableUser.userId);\n                member.user = availableUser;\n                return member;\n            }\n        }\n    }\n\n    /**\n     * Sets the membership this room was received as during sync\n     * @param membership - join | leave | invite\n     */\n    public updateMyMembership(membership: Membership): void {\n        const prevMembership = this.selfMembership;\n        this.selfMembership = membership;\n        if (prevMembership !== membership) {\n            if (membership === KnownMembership.Leave) {\n                this.cleanupAfterLeaving();\n            }\n            this.emit(RoomEvent.MyMembership, this, membership, prevMembership);\n        }\n    }\n\n    private async loadMembersFromServer(): Promise<IStateEventWithRoomId[]> {\n        const lastSyncToken = this.client.store.getSyncToken();\n        const response = await this.client.members(\n            this.roomId,\n            undefined,\n            KnownMembership.Leave,\n            lastSyncToken ?? undefined,\n        );\n        return response.chunk;\n    }\n\n    private async loadMembers(): Promise<{ memberEvents: MatrixEvent[]; fromServer: boolean }> {\n        // were the members loaded from the server?\n        let fromServer = false;\n        let rawMembersEvents = await this.client.store.getOutOfBandMembers(this.roomId);\n        // If the room is encrypted, we always fetch members from the server at\n        // least once, in case the latest state wasn't persisted properly. Note\n        // that this function is only called once (unless loading the members\n        // fails), since loadMembersIfNeeded always returns this.membersPromise\n        // if set, which will be the result of the first (successful) call.\n        if (rawMembersEvents === null || this.hasEncryptionStateEvent()) {\n            fromServer = true;\n            rawMembersEvents = await this.loadMembersFromServer();\n            logger.log(`LL: got ${rawMembersEvents.length} ` + `members from server for room ${this.roomId}`);\n        }\n        const memberEvents = rawMembersEvents.filter(noUnsafeEventProps).map(this.client.getEventMapper());\n        return { memberEvents, fromServer };\n    }\n\n    /**\n     * Check if loading of out-of-band-members has completed\n     *\n     * @returns true if the full membership list of this room has been loaded (including if lazy-loading is disabled).\n     *    False if the load is not started or is in progress.\n     */\n    public membersLoaded(): boolean {\n        if (!this.opts.lazyLoadMembers) {\n            return true;\n        }\n\n        return this.currentState.outOfBandMembersReady();\n    }\n\n    /**\n     * Preloads the member list in case lazy loading\n     * of memberships is in use. Can be called multiple times,\n     * it will only preload once.\n     * @returns when preloading is done and\n     * accessing the members on the room will take\n     * all members in the room into account\n     */\n    public loadMembersIfNeeded(): Promise<boolean> {\n        if (this.membersPromise) {\n            return this.membersPromise;\n        }\n\n        // mark the state so that incoming messages while\n        // the request is in flight get marked as superseding\n        // the OOB members\n        this.currentState.markOutOfBandMembersStarted();\n\n        const inMemoryUpdate = this.loadMembers()\n            .then((result) => {\n                this.currentState.setOutOfBandMembers(result.memberEvents);\n                return result.fromServer;\n            })\n            .catch((err) => {\n                // allow retries on fail\n                this.membersPromise = undefined;\n                this.currentState.markOutOfBandMembersFailed();\n                throw err;\n            });\n        // update members in storage, but don't wait for it\n        inMemoryUpdate\n            .then((fromServer) => {\n                if (fromServer) {\n                    const oobMembers = this.currentState\n                        .getMembers()\n                        .filter((m) => m.isOutOfBand())\n                        .map((m) => m.events.member?.event as IStateEventWithRoomId);\n                    logger.log(`LL: telling store to write ${oobMembers.length}` + ` members for room ${this.roomId}`);\n                    const store = this.client.store;\n                    return (\n                        store\n                            .setOutOfBandMembers(this.roomId, oobMembers)\n                            // swallow any IDB error as we don't want to fail\n                            // because of this\n                            .catch((err) => {\n                                logger.log(\"LL: storing OOB room members failed, oh well\", err);\n                            })\n                    );\n                }\n            })\n            .catch((err) => {\n                // as this is not awaited anywhere,\n                // at least show the error in the console\n                logger.error(err);\n            });\n\n        this.membersPromise = inMemoryUpdate;\n\n        return this.membersPromise;\n    }\n\n    /**\n     * Removes the lazily loaded members from storage if needed\n     */\n    public async clearLoadedMembersIfNeeded(): Promise<void> {\n        if (this.opts.lazyLoadMembers && this.membersPromise) {\n            await this.loadMembersIfNeeded();\n            await this.client.store.clearOutOfBandMembers(this.roomId);\n            this.currentState.clearOutOfBandMembers();\n            this.membersPromise = undefined;\n        }\n    }\n\n    /**\n     * called when sync receives this room in the leave section\n     * to do cleanup after leaving a room. Possibly called multiple times.\n     */\n    private cleanupAfterLeaving(): void {\n        this.clearLoadedMembersIfNeeded().catch((err) => {\n            logger.error(`error after clearing loaded members from ` + `room ${this.roomId} after leaving`);\n            logger.log(err);\n        });\n    }\n\n    /**\n     * Empty out the current live timeline and re-request it. This is used when\n     * historical messages are imported into the room via MSC2716 `/batch_send`\n     * because the client may already have that section of the timeline loaded.\n     * We need to force the client to throw away their current timeline so that\n     * when they back paginate over the area again with the historical messages\n     * in between, it grabs the newly imported messages. We can listen for\n     * `UNSTABLE_MSC2716_MARKER`, in order to tell when historical messages are ready\n     * to be discovered in the room and the timeline needs a refresh. The SDK\n     * emits a `RoomEvent.HistoryImportedWithinTimeline` event when we detect a\n     * valid marker and can check the needs refresh status via\n     * `room.getTimelineNeedsRefresh()`.\n     */\n    public async refreshLiveTimeline(): Promise<void> {\n        const liveTimelineBefore = this.getLiveTimeline();\n        const forwardPaginationToken = liveTimelineBefore.getPaginationToken(EventTimeline.FORWARDS);\n        const backwardPaginationToken = liveTimelineBefore.getPaginationToken(EventTimeline.BACKWARDS);\n        const eventsBefore = liveTimelineBefore.getEvents();\n        const mostRecentEventInTimeline = eventsBefore[eventsBefore.length - 1];\n        logger.log(\n            `[refreshLiveTimeline for ${this.roomId}] at ` +\n                `mostRecentEventInTimeline=${mostRecentEventInTimeline && mostRecentEventInTimeline.getId()} ` +\n                `liveTimelineBefore=${liveTimelineBefore.toString()} ` +\n                `forwardPaginationToken=${forwardPaginationToken} ` +\n                `backwardPaginationToken=${backwardPaginationToken}`,\n        );\n\n        // Get the main TimelineSet\n        const timelineSet = this.getUnfilteredTimelineSet();\n\n        let newTimeline: Optional<EventTimeline>;\n        // If there isn't any event in the timeline, let's go fetch the latest\n        // event and construct a timeline from it.\n        //\n        // This should only really happen if the user ran into an error\n        // with refreshing the timeline before which left them in a blank\n        // timeline from `resetLiveTimeline`.\n        if (!mostRecentEventInTimeline) {\n            newTimeline = await this.client.getLatestTimeline(timelineSet);\n        } else {\n            // Empty out all of `this.timelineSets`. But we also need to keep the\n            // same `timelineSet` references around so the React code updates\n            // properly and doesn't ignore the room events we emit because it checks\n            // that the `timelineSet` references are the same. We need the\n            // `timelineSet` empty so that the `client.getEventTimeline(...)` call\n            // later, will call `/context` and create a new timeline instead of\n            // returning the same one.\n            this.resetLiveTimeline(null, null);\n\n            // Make the UI timeline show the new blank live timeline we just\n            // reset so that if the network fails below it's showing the\n            // accurate state of what we're working with instead of the\n            // disconnected one in the TimelineWindow which is just hanging\n            // around by reference.\n            this.emit(RoomEvent.TimelineRefresh, this, timelineSet);\n\n            // Use `client.getEventTimeline(...)` to construct a new timeline from a\n            // `/context` response state and events for the most recent event before\n            // we reset everything. The `timelineSet` we pass in needs to be empty\n            // in order for this function to call `/context` and generate a new\n            // timeline.\n            newTimeline = await this.client.getEventTimeline(timelineSet, mostRecentEventInTimeline.getId()!);\n        }\n\n        // If a racing `/sync` beat us to creating a new timeline, use that\n        // instead because it's the latest in the room and any new messages in\n        // the scrollback will include the history.\n        const liveTimeline = timelineSet.getLiveTimeline();\n        if (\n            !liveTimeline ||\n            (liveTimeline.getPaginationToken(Direction.Forward) === null &&\n                liveTimeline.getPaginationToken(Direction.Backward) === null &&\n                liveTimeline.getEvents().length === 0)\n        ) {\n            logger.log(`[refreshLiveTimeline for ${this.roomId}] using our new live timeline`);\n            // Set the pagination token back to the live sync token (`null`) instead\n            // of using the `/context` historical token (ex. `t12-13_0_0_0_0_0_0_0_0`)\n            // so that it matches the next response from `/sync` and we can properly\n            // continue the timeline.\n            newTimeline!.setPaginationToken(forwardPaginationToken, EventTimeline.FORWARDS);\n\n            // Set our new fresh timeline as the live timeline to continue syncing\n            // forwards and back paginating from.\n            timelineSet.setLiveTimeline(newTimeline!);\n            // Fixup `this.oldstate` so that `scrollback` has the pagination tokens\n            // available\n            this.fixUpLegacyTimelineFields();\n        } else {\n            logger.log(\n                `[refreshLiveTimeline for ${this.roomId}] \\`/sync\\` or some other request beat us to creating a new ` +\n                    `live timeline after we reset it. We'll use that instead since any events in the scrollback from ` +\n                    `this timeline will include the history.`,\n            );\n        }\n\n        // The timeline has now been refreshed ✅\n        this.setTimelineNeedsRefresh(false);\n\n        // Emit an event which clients can react to and re-load the timeline\n        // from the SDK\n        this.emit(RoomEvent.TimelineRefresh, this, timelineSet);\n    }\n\n    /**\n     * Reset the live timeline of all timelineSets, and start new ones.\n     *\n     * <p>This is used when /sync returns a 'limited' timeline.\n     *\n     * @param backPaginationToken -   token for back-paginating the new timeline\n     * @param forwardPaginationToken - token for forward-paginating the old live timeline,\n     * if absent or null, all timelines are reset, removing old ones (including the previous live\n     * timeline which would otherwise be unable to paginate forwards without this token).\n     * Removing just the old live timeline whilst preserving previous ones is not supported.\n     */\n    public resetLiveTimeline(backPaginationToken?: string | null, forwardPaginationToken?: string | null): void {\n        for (const timelineSet of this.timelineSets) {\n            timelineSet.resetLiveTimeline(backPaginationToken ?? undefined, forwardPaginationToken ?? undefined);\n        }\n        for (const thread of this.threads.values()) {\n            thread.resetLiveTimeline(backPaginationToken, forwardPaginationToken);\n        }\n\n        this.fixUpLegacyTimelineFields();\n    }\n\n    /**\n     * Fix up this.timeline, this.oldState and this.currentState\n     *\n     * @internal\n     */\n    private fixUpLegacyTimelineFields(): void {\n        const previousOldState = this.oldState;\n        const previousCurrentState = this.currentState;\n\n        // maintain this.oldState and this.currentState as references to the\n        // state at the start and end of that timeline. These are more\n        // for backwards-compatibility than anything else.\n        this.oldState = this.getLiveTimeline().getState(EventTimeline.BACKWARDS)!;\n        this.currentState = this.getLiveTimeline().getState(EventTimeline.FORWARDS)!;\n\n        // Let people know to register new listeners for the new state\n        // references. The reference won't necessarily change every time so only\n        // emit when we see a change.\n        if (previousOldState !== this.oldState) {\n            this.emit(RoomEvent.OldStateUpdated, this, previousOldState, this.oldState);\n        }\n\n        if (previousCurrentState !== this.currentState) {\n            this.emit(RoomEvent.CurrentStateUpdated, this, previousCurrentState, this.currentState);\n\n            // Re-emit various events on the current room state\n            // TODO: If currentState really only exists for backwards\n            // compatibility, shouldn't we be doing this some other way?\n            this.reEmitter.stopReEmitting(previousCurrentState, [\n                RoomStateEvent.Events,\n                RoomStateEvent.Members,\n                RoomStateEvent.NewMember,\n                RoomStateEvent.Update,\n                RoomStateEvent.Marker,\n                BeaconEvent.New,\n                BeaconEvent.Update,\n                BeaconEvent.Destroy,\n                BeaconEvent.LivenessChange,\n            ]);\n            this.reEmitter.reEmit(this.currentState, [\n                RoomStateEvent.Events,\n                RoomStateEvent.Members,\n                RoomStateEvent.NewMember,\n                RoomStateEvent.Update,\n                RoomStateEvent.Marker,\n                BeaconEvent.New,\n                BeaconEvent.Update,\n                BeaconEvent.Destroy,\n                BeaconEvent.LivenessChange,\n            ]);\n        }\n    }\n\n    private onReceipt(event: MatrixEvent): void {\n        if (this.hasEncryptionStateEvent()) {\n            this.clearNotificationsOnReceipt(event);\n        }\n    }\n\n    private clearNotificationsOnReceipt(event: MatrixEvent): void {\n        // Like above, we have to listen for read receipts from ourselves in order to\n        // correctly handle notification counts on encrypted rooms.\n        // This fixes https://github.com/vector-im/element-web/issues/9421\n\n        // Figure out if we've read something or if it's just informational\n        // We need to work out what threads we've just recieved receipts for, so we\n        // know which ones to update. If we've received an unthreaded receipt, we'll\n        // need to update all threads.\n        let threadIds: string[] = [];\n        let hasUnthreadedReceipt = false;\n\n        const content = event.getContent();\n\n        for (const receiptGroup of Object.values(content)) {\n            for (const [receiptType, userReceipt] of Object.entries(receiptGroup)) {\n                if (!utils.isSupportedReceiptType(receiptType)) continue;\n                if (!userReceipt) continue;\n\n                for (const [userId, singleReceipt] of Object.entries(userReceipt)) {\n                    if (!singleReceipt || typeof singleReceipt !== \"object\") continue;\n                    const typedSingleReceipt = singleReceipt as Record<string, any>;\n                    if (userId !== this.client.getUserId()) continue;\n                    if (typedSingleReceipt.thread_id === undefined) {\n                        hasUnthreadedReceipt = true;\n                    } else if (typeof typedSingleReceipt.thread_id === \"string\") {\n                        threadIds.push(typedSingleReceipt.thread_id);\n                    }\n                }\n            }\n        }\n\n        if (hasUnthreadedReceipt) {\n            // If we have an unthreaded receipt, we need to update any threads that have a notification\n            // in them (because we know the receipt can't go backwards so we don't need to check any with\n            // no notifications: the number can only decrease from a receipt).\n            threadIds = this.getThreads()\n                .filter(\n                    (thread) =>\n                        this.getThreadUnreadNotificationCount(thread.id, NotificationCountType.Total) > 0 ||\n                        this.getThreadUnreadNotificationCount(thread.id, NotificationCountType.Highlight) > 0,\n                )\n                .map((thread) => thread.id);\n            threadIds.push(\"main\");\n        }\n\n        for (const threadId of threadIds) {\n            // Work backwards to determine how many events are unread. We also set\n            // a limit for how back we'll look to avoid spinning CPU for too long.\n            // If we hit the limit, we assume the count is unchanged.\n            const maxHistory = 20;\n            const timeline = threadId === \"main\" ? this.getLiveTimeline() : this.getThread(threadId)?.liveTimeline;\n\n            if (!timeline) {\n                logger.warn(`Couldn't find timeline for thread ID ${threadId} in room ${this.roomId}`);\n                continue;\n            }\n\n            const events = timeline.getEvents();\n\n            let highlightCount = 0;\n\n            for (let i = events.length - 1; i >= 0; i--) {\n                if (i === events.length - maxHistory) return; // limit reached\n\n                const event = events[i];\n\n                if (this.hasUserReadEvent(this.client.getUserId()!, event.getId()!)) {\n                    // If the user has read the event, then the counting is done.\n                    break;\n                }\n\n                const pushActions = this.client.getPushActionsForEvent(event);\n                highlightCount += pushActions?.tweaks?.highlight ? 1 : 0;\n            }\n\n            // Note: we don't need to handle 'total' notifications because the counts\n            // will come from the server.\n            if (threadId === \"main\") {\n                this.setUnreadNotificationCount(NotificationCountType.Highlight, highlightCount);\n            } else {\n                this.setThreadUnreadNotificationCount(threadId, NotificationCountType.Highlight, highlightCount);\n            }\n        }\n    }\n\n    /**\n     * Return the timeline sets for this room.\n     * @returns array of timeline sets for this room\n     */\n    public getTimelineSets(): EventTimelineSet[] {\n        return this.timelineSets;\n    }\n\n    /**\n     * Helper to return the main unfiltered timeline set for this room\n     * @returns room's unfiltered timeline set\n     */\n    public getUnfilteredTimelineSet(): EventTimelineSet {\n        return this.timelineSets[0];\n    }\n\n    /**\n     * Get the timeline which contains the given event from the unfiltered set, if any\n     *\n     * @param eventId -  event ID to look for\n     * @returns timeline containing\n     * the given event, or null if unknown\n     */\n    public getTimelineForEvent(eventId: string): EventTimeline | null {\n        const event = this.findEventById(eventId);\n        const thread = this.findThreadForEvent(event);\n        if (thread) {\n            return thread.timelineSet.getTimelineForEvent(eventId);\n        } else {\n            return this.getUnfilteredTimelineSet().getTimelineForEvent(eventId);\n        }\n    }\n\n    /**\n     * Add a new timeline to this room's unfiltered timeline set\n     *\n     * @returns newly-created timeline\n     */\n    public addTimeline(): EventTimeline {\n        return this.getUnfilteredTimelineSet().addTimeline();\n    }\n\n    /**\n     * Whether the timeline needs to be refreshed in order to pull in new\n     * historical messages that were imported.\n     * @param value - The value to set\n     */\n    public setTimelineNeedsRefresh(value: boolean): void {\n        this.timelineNeedsRefresh = value;\n    }\n\n    /**\n     * Whether the timeline needs to be refreshed in order to pull in new\n     * historical messages that were imported.\n     * @returns .\n     */\n    public getTimelineNeedsRefresh(): boolean {\n        return this.timelineNeedsRefresh;\n    }\n\n    /**\n     * Get an event which is stored in our unfiltered timeline set, or in a thread\n     *\n     * @param eventId - event ID to look for\n     * @returns the given event, or undefined if unknown\n     */\n    public findEventById(eventId: string): MatrixEvent | undefined {\n        let event = this.getUnfilteredTimelineSet().findEventById(eventId);\n\n        if (!event) {\n            const threads = this.getThreads();\n            for (let i = 0; i < threads.length; i++) {\n                const thread = threads[i];\n                event = thread.findEventById(eventId);\n                if (event) {\n                    return event;\n                }\n            }\n        }\n\n        return event;\n    }\n\n    /**\n     * Get one of the notification counts for this room\n     * @param type - The type of notification count to get. default: 'total'\n     * @returns The notification count, or undefined if there is no count\n     *                  for this type.\n     */\n    public getUnreadNotificationCount(type = NotificationCountType.Total): number {\n        let count = this.getRoomUnreadNotificationCount(type);\n        for (const threadNotification of this.threadNotifications.values()) {\n            count += threadNotification[type] ?? 0;\n        }\n        return count;\n    }\n\n    /**\n     * Get the notification for the event context (room or thread timeline)\n     */\n    public getUnreadCountForEventContext(type = NotificationCountType.Total, event: MatrixEvent): number {\n        const isThreadEvent = !!event.threadRootId && !event.isThreadRoot;\n\n        return (\n            (isThreadEvent\n                ? this.getThreadUnreadNotificationCount(event.threadRootId, type)\n                : this.getRoomUnreadNotificationCount(type)) ?? 0\n        );\n    }\n\n    /**\n     * Get one of the notification counts for this room\n     * @param type - The type of notification count to get. default: 'total'\n     * @returns The notification count, or undefined if there is no count\n     *                  for this type.\n     */\n    public getRoomUnreadNotificationCount(type = NotificationCountType.Total): number {\n        return this.notificationCounts[type] ?? 0;\n    }\n\n    /**\n     * Get one of the notification counts for a thread\n     * @param threadId - the root event ID\n     * @param type - The type of notification count to get. default: 'total'\n     * @returns The notification count, or undefined if there is no count\n     *          for this type.\n     */\n    public getThreadUnreadNotificationCount(threadId: string, type = NotificationCountType.Total): number {\n        return this.threadNotifications.get(threadId)?.[type] ?? 0;\n    }\n\n    /**\n     * Checks if the current room has unread thread notifications\n     * @returns\n     */\n    public hasThreadUnreadNotification(): boolean {\n        for (const notification of this.threadNotifications.values()) {\n            if ((notification.highlight ?? 0) > 0 || (notification.total ?? 0) > 0) {\n                return true;\n            }\n        }\n        return false;\n    }\n\n    /**\n     * Swet one of the notification count for a thread\n     * @param threadId - the root event ID\n     * @param type - The type of notification count to get. default: 'total'\n     * @returns\n     */\n    public setThreadUnreadNotificationCount(threadId: string, type: NotificationCountType, count: number): void {\n        const notification: NotificationCount = {\n            highlight: this.threadNotifications.get(threadId)?.highlight,\n            total: this.threadNotifications.get(threadId)?.total,\n            ...{\n                [type]: count,\n            },\n        };\n\n        this.threadNotifications.set(threadId, notification);\n\n        this.emit(RoomEvent.UnreadNotifications, notification, threadId);\n    }\n\n    /**\n     * @returns the notification count type for all the threads in the room\n     */\n    public get threadsAggregateNotificationType(): NotificationCountType | null {\n        let type: NotificationCountType | null = null;\n        for (const threadNotification of this.threadNotifications.values()) {\n            if ((threadNotification.highlight ?? 0) > 0) {\n                return NotificationCountType.Highlight;\n            } else if ((threadNotification.total ?? 0) > 0 && !type) {\n                type = NotificationCountType.Total;\n            }\n        }\n        return type;\n    }\n\n    /**\n     * Resets the total thread notifications for all threads in this room to zero,\n     * excluding any threads whose IDs are given in `exceptThreadIds`.\n     *\n     * If the room is not encrypted, also resets the highlight notification count to zero\n     * for the same set of threads.\n     *\n     * This is intended for use from the sync code since we calculate highlight notification\n     * counts locally from decrypted messages. We want to partially trust the total from the\n     * server such that we clear notifications when read receipts arrive. The weird name is\n     * intended to reflect this. You probably do not want to use this.\n     *\n     * @param exceptThreadIds - The thread IDs to exclude from the reset.\n     */\n    public resetThreadUnreadNotificationCountFromSync(exceptThreadIds: string[] = []): void {\n        const isEncrypted = this.hasEncryptionStateEvent();\n\n        for (const [threadId, notifs] of this.threadNotifications) {\n            if (!exceptThreadIds.includes(threadId)) {\n                notifs.total = 0;\n                if (!isEncrypted) {\n                    notifs.highlight = 0;\n                }\n            }\n        }\n\n        this.emit(RoomEvent.UnreadNotifications);\n    }\n\n    /**\n     * Set one of the notification counts for this room\n     * @param type - The type of notification count to set.\n     * @param count - The new count\n     */\n    public setUnreadNotificationCount(type: NotificationCountType, count: number): void {\n        this.notificationCounts[type] = count;\n        this.emit(RoomEvent.UnreadNotifications, this.notificationCounts);\n    }\n\n    public setUnread(type: NotificationCountType, count: number): void {\n        return this.setUnreadNotificationCount(type, count);\n    }\n\n    public setSummary(summary: IRoomSummary): void {\n        const heroes = summary[\"m.heroes\"];\n        const joinedCount = summary[\"m.joined_member_count\"];\n        const invitedCount = summary[\"m.invited_member_count\"];\n        if (Number.isInteger(joinedCount)) {\n            this.currentState.setJoinedMemberCount(joinedCount!);\n        }\n        if (Number.isInteger(invitedCount)) {\n            this.currentState.setInvitedMemberCount(invitedCount!);\n        }\n        if (Array.isArray(heroes)) {\n            // be cautious about trusting server values,\n            // and make sure heroes doesn't contain our own id\n            // just to be sure\n            this.summaryHeroes = heroes.filter((userId) => {\n                return userId !== this.myUserId;\n            });\n        }\n\n        this.emit(RoomEvent.Summary, summary);\n    }\n\n    /**\n     * Whether to send encrypted messages to devices within this room.\n     * @param value - true to blacklist unverified devices, null\n     * to use the global value for this room.\n     */\n    public setBlacklistUnverifiedDevices(value: boolean): void {\n        this.blacklistUnverifiedDevices = value;\n    }\n\n    /**\n     * Whether to send encrypted messages to devices within this room.\n     * @returns true if blacklisting unverified devices, null\n     * if the global value should be used for this room.\n     */\n    public getBlacklistUnverifiedDevices(): boolean | null {\n        if (this.blacklistUnverifiedDevices === undefined) return null;\n        return this.blacklistUnverifiedDevices;\n    }\n\n    /**\n     * Get the avatar URL for a room if one was set.\n     * @param baseUrl - The homeserver base URL. See\n     * {@link MatrixClient#getHomeserverUrl}.\n     * @param width - The desired width of the thumbnail.\n     * @param height - The desired height of the thumbnail.\n     * @param resizeMethod - The thumbnail resize method to use, either\n     * \"crop\" or \"scale\".\n     * @param allowDefault - True to allow an identicon for this room if an\n     * avatar URL wasn't explicitly set. Default: true. (Deprecated)\n     * @param useAuthentication - (optional) If true, the caller supports authenticated\n     * media and wants an authentication-required URL. Note that server support for\n     * authenticated media will not be checked - it is the caller's responsibility\n     * to do so before calling this function. Note also that useAuthentication\n     * implies allowRedirects. Defaults to false (unauthenticated endpoints).\n     * @returns the avatar URL or null.\n     */\n    public getAvatarUrl(\n        baseUrl: string,\n        width: number,\n        height: number,\n        resizeMethod: ResizeMethod,\n        allowDefault = true,\n        useAuthentication: boolean = false,\n    ): string | null {\n        const roomAvatarEvent = this.currentState.getStateEvents(EventType.RoomAvatar, \"\");\n        if (!roomAvatarEvent && !allowDefault) {\n            return null;\n        }\n\n        const mainUrl = roomAvatarEvent ? roomAvatarEvent.getContent().url : null;\n        if (mainUrl) {\n            return getHttpUriForMxc(\n                baseUrl,\n                mainUrl,\n                width,\n                height,\n                resizeMethod,\n                undefined,\n                undefined,\n                useAuthentication,\n            );\n        }\n\n        return null;\n    }\n\n    /**\n     * Get the mxc avatar url for the room, if one was set.\n     * @returns the mxc avatar url or falsy\n     */\n    public getMxcAvatarUrl(): string | null {\n        return this.currentState.getStateEvents(EventType.RoomAvatar, \"\")?.getContent()?.url || null;\n    }\n\n    /**\n     * Get this room's canonical alias\n     * The alias returned by this function may not necessarily\n     * still point to this room.\n     * @returns The room's canonical alias, or null if there is none\n     */\n    public getCanonicalAlias(): string | null {\n        const canonicalAlias = this.currentState.getStateEvents(EventType.RoomCanonicalAlias, \"\");\n        if (canonicalAlias) {\n            return canonicalAlias.getContent().alias || null;\n        }\n        return null;\n    }\n\n    /**\n     * Get this room's alternative aliases\n     * @returns The room's alternative aliases, or an empty array\n     */\n    public getAltAliases(): string[] {\n        const canonicalAlias = this.currentState.getStateEvents(EventType.RoomCanonicalAlias, \"\");\n        if (canonicalAlias) {\n            return canonicalAlias.getContent().alt_aliases || [];\n        }\n        return [];\n    }\n\n    /**\n     * Add events to a timeline\n     *\n     * <p>Will fire \"Room.timeline\" for each event added.\n     *\n     * @param events - A list of events to add.\n     *\n     * @param toStartOfTimeline -   True to add these events to the start\n     * (oldest) instead of the end (newest) of the timeline. If true, the oldest\n     * event will be the <b>last</b> element of 'events'.\n     *\n     * @param timeline -   timeline to\n     *    add events to.\n     *\n     * @param paginationToken -   token for the next batch of events\n     *\n     * @remarks\n     * Fires {@link RoomEvent.Timeline}\n     */\n    public addEventsToTimeline(\n        events: MatrixEvent[],\n        toStartOfTimeline: boolean,\n        addToState: boolean,\n        timeline: EventTimeline,\n        paginationToken?: string,\n    ): void {\n        timeline.getTimelineSet().addEventsToTimeline(events, toStartOfTimeline, addToState, timeline, paginationToken);\n    }\n\n    /**\n     * Get the instance of the thread associated with the current event\n     * @param eventId - the ID of the current event\n     * @returns a thread instance if known\n     */\n    public getThread(eventId: string): Thread | null {\n        return this.threads.get(eventId) ?? null;\n    }\n\n    /**\n     * Get all the known threads in the room\n     */\n    public getThreads(): Thread[] {\n        return Array.from(this.threads.values());\n    }\n\n    /**\n     * Get a member from the current room state.\n     * @param userId - The user ID of the member.\n     * @returns The member or `null`.\n     */\n    public getMember(userId: string): RoomMember | null {\n        return this.currentState.getMember(userId);\n    }\n\n    /**\n     * Get all currently loaded members from the current\n     * room state.\n     * @returns Room members\n     */\n    public getMembers(): RoomMember[] {\n        return this.currentState.getMembers();\n    }\n\n    /**\n     * Get a list of members whose membership state is \"join\".\n     * @returns A list of currently joined members.\n     */\n    public getJoinedMembers(): RoomMember[] {\n        return this.getMembersWithMembership(KnownMembership.Join);\n    }\n\n    /**\n     * Returns the number of joined members in this room\n     * This method caches the result.\n     * This is a wrapper around the method of the same name in roomState, returning\n     * its result for the room's current state.\n     * @returns The number of members in this room whose membership is 'join'\n     */\n    public getJoinedMemberCount(): number {\n        return this.currentState.getJoinedMemberCount();\n    }\n\n    /**\n     * Returns the number of invited members in this room\n     * @returns The number of members in this room whose membership is 'invite'\n     */\n    public getInvitedMemberCount(): number {\n        return this.currentState.getInvitedMemberCount();\n    }\n\n    /**\n     * Returns the number of invited + joined members in this room\n     * @returns The number of members in this room whose membership is 'invite' or 'join'\n     */\n    public getInvitedAndJoinedMemberCount(): number {\n        return this.getInvitedMemberCount() + this.getJoinedMemberCount();\n    }\n\n    /**\n     * Get a list of members with given membership state.\n     * @param membership - The membership state.\n     * @returns A list of members with the given membership state.\n     */\n    public getMembersWithMembership(membership: Membership): RoomMember[] {\n        return this.currentState.getMembers().filter(function (m) {\n            return m.membership === membership;\n        });\n    }\n\n    /**\n     * Get a list of members we should be encrypting for in this room\n     * @returns A list of members who\n     * we should encrypt messages for in this room.\n     */\n    public async getEncryptionTargetMembers(): Promise<RoomMember[]> {\n        await this.loadMembersIfNeeded();\n        let members = this.getMembersWithMembership(KnownMembership.Join);\n        if (this.shouldEncryptForInvitedMembers()) {\n            members = members.concat(this.getMembersWithMembership(KnownMembership.Invite));\n        }\n        return members;\n    }\n\n    /**\n     * Determine whether we should encrypt messages for invited users in this room\n     * @returns if we should encrypt messages for invited users\n     */\n    public shouldEncryptForInvitedMembers(): boolean {\n        const ev = this.currentState.getStateEvents(EventType.RoomHistoryVisibility, \"\");\n        return ev?.getContent()?.history_visibility !== \"joined\";\n    }\n\n    /**\n     * Get the default room name (i.e. what a given user would see if the\n     * room had no m.room.name)\n     * @param userId - The userId from whose perspective we want\n     * to calculate the default name\n     * @returns The default room name\n     */\n    public getDefaultRoomName(userId: string): string {\n        return this.calculateRoomName(userId, true);\n    }\n\n    /**\n     * Check if the given user_id has the given membership state.\n     * @param userId - The user ID to check.\n     * @param membership - The membership e.g. `'join'`\n     * @returns True if this user_id has the given membership state.\n     */\n    public hasMembershipState(userId: string, membership: Membership): boolean {\n        const member = this.getMember(userId);\n        if (!member) {\n            return false;\n        }\n        return member.membership === membership;\n    }\n\n    /**\n     * Add a timelineSet for this room with the given filter\n     * @param filter - The filter to be applied to this timelineSet\n     * @param opts - Configuration options\n     * @returns The timelineSet\n     */\n    public getOrCreateFilteredTimelineSet(\n        filter: Filter,\n        { prepopulateTimeline = true, useSyncEvents = true, pendingEvents = true }: ICreateFilterOpts = {},\n    ): EventTimelineSet {\n        if (this.filteredTimelineSets[filter.filterId!]) {\n            return this.filteredTimelineSets[filter.filterId!];\n        }\n        const opts = Object.assign({ filter, pendingEvents }, this.opts);\n        const timelineSet = new EventTimelineSet(this, opts);\n        this.reEmitter.reEmit(timelineSet, [RoomEvent.Timeline, RoomEvent.TimelineReset]);\n        if (useSyncEvents) {\n            this.filteredTimelineSets[filter.filterId!] = timelineSet;\n            this.timelineSets.push(timelineSet);\n        }\n\n        const unfilteredLiveTimeline = this.getLiveTimeline();\n        // Not all filter are possible to replicate client-side only\n        // When that's the case we do not want to prepopulate from the live timeline\n        // as we would get incorrect results compared to what the server would send back\n        if (prepopulateTimeline) {\n            // populate up the new timelineSet with filtered events from our live\n            // unfiltered timeline.\n            //\n            // XXX: This is risky as our timeline\n            // may have grown huge and so take a long time to filter.\n            // see https://github.com/vector-im/vector-web/issues/2109\n\n            unfilteredLiveTimeline.getEvents().forEach(function (event) {\n                timelineSet.addLiveEvent(event, { addToState: false }); // Filtered timeline sets should not track state\n            });\n\n            // find the earliest unfiltered timeline\n            let timeline = unfilteredLiveTimeline;\n            while (timeline.getNeighbouringTimeline(EventTimeline.BACKWARDS)) {\n                timeline = timeline.getNeighbouringTimeline(EventTimeline.BACKWARDS)!;\n            }\n\n            timelineSet\n                .getLiveTimeline()\n                .setPaginationToken(timeline.getPaginationToken(EventTimeline.BACKWARDS), EventTimeline.BACKWARDS);\n        } else if (useSyncEvents) {\n            const livePaginationToken = unfilteredLiveTimeline.getPaginationToken(Direction.Forward);\n            timelineSet.getLiveTimeline().setPaginationToken(livePaginationToken, Direction.Backward);\n        }\n\n        // alternatively, we could try to do something like this to try and re-paginate\n        // in the filtered events from nothing, but Mark says it's an abuse of the API\n        // to do so:\n        //\n        // timelineSet.resetLiveTimeline(\n        //      unfilteredLiveTimeline.getPaginationToken(EventTimeline.FORWARDS)\n        // );\n\n        return timelineSet;\n    }\n\n    private async getThreadListFilter(filterType = ThreadFilterType.All): Promise<Filter> {\n        const myUserId = this.client.getUserId()!;\n        const filter = new Filter(myUserId);\n\n        const definition: IFilterDefinition = {\n            room: {\n                timeline: {\n                    [FILTER_RELATED_BY_REL_TYPES.name]: [THREAD_RELATION_TYPE.name],\n                },\n            },\n        };\n\n        if (filterType === ThreadFilterType.My) {\n            definition!.room!.timeline![FILTER_RELATED_BY_SENDERS.name] = [myUserId];\n        }\n\n        filter.setDefinition(definition);\n        const filterId = await this.client.getOrCreateFilter(`THREAD_PANEL_${this.roomId}_${filterType}`, filter);\n\n        filter.filterId = filterId;\n\n        return filter;\n    }\n\n    private async createThreadTimelineSet(filterType?: ThreadFilterType): Promise<EventTimelineSet> {\n        let timelineSet: EventTimelineSet;\n        if (Thread.hasServerSideListSupport) {\n            timelineSet = new EventTimelineSet(\n                this,\n                {\n                    ...this.opts,\n                    pendingEvents: false,\n                },\n                undefined,\n                undefined,\n                filterType ?? ThreadFilterType.All,\n            );\n            this.reEmitter.reEmit(timelineSet, [RoomEvent.Timeline, RoomEvent.TimelineReset]);\n        } else if (Thread.hasServerSideSupport) {\n            const filter = await this.getThreadListFilter(filterType);\n\n            timelineSet = this.getOrCreateFilteredTimelineSet(filter, {\n                prepopulateTimeline: false,\n                useSyncEvents: false,\n                pendingEvents: false,\n            });\n        } else {\n            timelineSet = new EventTimelineSet(this, {\n                pendingEvents: false,\n            });\n\n            Array.from(this.threads).forEach(([, thread]) => {\n                if (thread.length === 0) return;\n                const currentUserParticipated = thread.timeline.some((event) => {\n                    return event.getSender() === this.client.getUserId();\n                });\n                if (filterType !== ThreadFilterType.My || currentUserParticipated) {\n                    timelineSet.getLiveTimeline().addEvent(thread.rootEvent!, {\n                        toStartOfTimeline: false,\n                        addToState: false,\n                    });\n                }\n            });\n        }\n\n        return timelineSet;\n    }\n\n    private threadsReady = false;\n\n    /**\n     * Takes the given thread root events and creates threads for them.\n     */\n    public processThreadRoots(events: MatrixEvent[], toStartOfTimeline: boolean): void {\n        if (!this.client.supportsThreads()) return;\n        for (const rootEvent of events) {\n            EventTimeline.setEventMetadata(rootEvent, this.currentState, toStartOfTimeline);\n            if (!this.getThread(rootEvent.getId()!)) {\n                this.createThread(rootEvent.getId()!, rootEvent, [], toStartOfTimeline);\n            }\n        }\n    }\n\n    /**\n     * Fetch the bare minimum of room threads required for the thread list to work reliably.\n     * With server support that means fetching one page.\n     * Without server support that means fetching as much at once as the server allows us to.\n     */\n    public async fetchRoomThreads(): Promise<void> {\n        if (this.threadsReady || !this.client.supportsThreads()) {\n            return;\n        }\n\n        if (Thread.hasServerSideListSupport) {\n            await Promise.all([\n                this.fetchRoomThreadList(ThreadFilterType.All),\n                this.fetchRoomThreadList(ThreadFilterType.My),\n            ]);\n        } else {\n            const allThreadsFilter = await this.getThreadListFilter();\n\n            const { chunk: events } = await this.client.createMessagesRequest(\n                this.roomId,\n                \"\",\n                Number.MAX_SAFE_INTEGER,\n                Direction.Backward,\n                allThreadsFilter,\n            );\n\n            if (!events.length) return;\n\n            // Sorted by last_reply origin_server_ts\n            const threadRoots = events.map(this.client.getEventMapper()).sort((eventA, eventB) => {\n                /**\n                 * `origin_server_ts` in a decentralised world is far from ideal\n                 * but for lack of any better, we will have to use this\n                 * Long term the sorting should be handled by homeservers and this\n                 * is only meant as a short term patch\n                 */\n                const threadAMetadata = eventA.getServerAggregatedRelation<IThreadBundledRelationship>(\n                    THREAD_RELATION_TYPE.name,\n                )!;\n                const threadBMetadata = eventB.getServerAggregatedRelation<IThreadBundledRelationship>(\n                    THREAD_RELATION_TYPE.name,\n                )!;\n                return threadAMetadata.latest_event.origin_server_ts - threadBMetadata.latest_event.origin_server_ts;\n            });\n\n            let latestMyThreadsRootEvent: MatrixEvent | undefined;\n            const roomState = this.getLiveTimeline().getState(EventTimeline.FORWARDS);\n            for (const rootEvent of threadRoots) {\n                const opts = {\n                    duplicateStrategy: DuplicateStrategy.Ignore,\n                    fromCache: false,\n                    addToState: false,\n                    roomState,\n                };\n                this.threadsTimelineSets[0]?.addLiveEvent(rootEvent, opts);\n\n                const threadRelationship = rootEvent.getServerAggregatedRelation<IThreadBundledRelationship>(\n                    THREAD_RELATION_TYPE.name,\n                );\n                if (threadRelationship?.current_user_participated) {\n                    this.threadsTimelineSets[1]?.addLiveEvent(rootEvent, opts);\n                    latestMyThreadsRootEvent = rootEvent;\n                }\n            }\n\n            this.processThreadRoots(threadRoots, true);\n\n            this.client.decryptEventIfNeeded(threadRoots[threadRoots.length - 1]);\n            if (latestMyThreadsRootEvent) {\n                this.client.decryptEventIfNeeded(latestMyThreadsRootEvent);\n            }\n        }\n\n        this.on(ThreadEvent.NewReply, this.onThreadReply);\n        this.on(ThreadEvent.Update, this.onThreadUpdate);\n        this.on(ThreadEvent.Delete, this.onThreadDelete);\n        this.threadsReady = true;\n    }\n\n    /**\n     * Process a list of poll events.\n     *\n     * @param events - List of events\n     */\n    public async processPollEvents(events: MatrixEvent[]): Promise<void> {\n        for (const event of events) {\n            try {\n                // Continue if the event is a clear text, non-poll event.\n                if (!event.isEncrypted() && !isPollEvent(event)) continue;\n\n                /**\n                 * Try to decrypt the event. Promise resolution does not guarantee a successful decryption.\n                 * Retry is handled in {@link processPollEvent}.\n                 */\n                await this.client.decryptEventIfNeeded(event);\n                this.processPollEvent(event);\n            } catch (err) {\n                logger.warn(\"Error processing poll event\", event.getId(), err);\n            }\n        }\n    }\n\n    /**\n     * Processes poll events:\n     * If the event has a decryption failure, it will listen for decryption and tries again.\n     * If it is a poll start event (`m.poll.start`),\n     * it creates and stores a Poll model and emits a PollEvent.New event.\n     * If the event is related to a poll, it will add it to the poll.\n     * Noop for other cases.\n     *\n     * @param event - Event that could be a poll event\n     */\n    private async processPollEvent(event: MatrixEvent): Promise<void> {\n        if (event.isDecryptionFailure()) {\n            event.once(MatrixEventEvent.Decrypted, (maybeDecryptedEvent: MatrixEvent) => {\n                this.processPollEvent(maybeDecryptedEvent);\n            });\n            return;\n        }\n\n        if (M_POLL_START.matches(event.getType())) {\n            try {\n                const poll = new Poll(event, this.client, this);\n                this.polls.set(event.getId()!, poll);\n                this.emit(PollEvent.New, poll);\n\n                // remove the poll when redacted\n                event.once(MatrixEventEvent.BeforeRedaction, (redactedEvent: MatrixEvent) => {\n                    this.polls.delete(redactedEvent.getId()!);\n                });\n            } catch {}\n            // poll creation can fail for malformed poll start events\n            return;\n        }\n\n        const relationEventId = event.relationEventId;\n\n        if (relationEventId && this.polls.has(relationEventId)) {\n            const poll = this.polls.get(relationEventId);\n            poll?.onNewRelation(event);\n        }\n    }\n\n    /**\n     * Fetch a single page of threadlist messages for the specific thread filter\n     * @internal\n     */\n    private async fetchRoomThreadList(filter?: ThreadFilterType): Promise<void> {\n        if (!this.client.supportsThreads()) return;\n        if (this.threadsTimelineSets.length === 0) return;\n\n        const timelineSet = filter === ThreadFilterType.My ? this.threadsTimelineSets[1] : this.threadsTimelineSets[0];\n\n        const { chunk: events, end } = await this.client.createThreadListMessagesRequest(\n            this.roomId,\n            null,\n            undefined,\n            Direction.Backward,\n            timelineSet.threadListType,\n            timelineSet.getFilter(),\n        );\n\n        timelineSet.getLiveTimeline().setPaginationToken(end ?? null, Direction.Backward);\n\n        if (!events.length) return;\n\n        const matrixEvents = events.map(this.client.getEventMapper());\n        this.processThreadRoots(matrixEvents, true);\n        const roomState = this.getLiveTimeline().getState(EventTimeline.FORWARDS);\n        for (const rootEvent of matrixEvents) {\n            timelineSet.addLiveEvent(rootEvent, {\n                duplicateStrategy: DuplicateStrategy.Replace,\n                fromCache: false,\n                roomState,\n                addToState: false,\n            });\n        }\n    }\n\n    private onThreadUpdate(thread: Thread): void {\n        this.updateThreadRootEvents(thread, false, false);\n    }\n\n    private onThreadReply(thread: Thread): void {\n        this.updateThreadRootEvents(thread, false, true);\n    }\n\n    private onThreadDelete(thread: Thread): void {\n        this.threads.delete(thread.id);\n\n        const timeline = this.getTimelineForEvent(thread.id);\n        const roomEvent = timeline?.getEvents()?.find((it) => it.getId() === thread.id);\n        if (roomEvent) {\n            thread.clearEventMetadata(roomEvent);\n        } else {\n            logger.debug(\"onThreadDelete: Could not find root event in room timeline\");\n        }\n        for (const timelineSet of this.threadsTimelineSets) {\n            timelineSet.removeEvent(thread.id);\n        }\n    }\n\n    /**\n     * Forget the timelineSet for this room with the given filter\n     *\n     * @param filter - the filter whose timelineSet is to be forgotten\n     */\n    public removeFilteredTimelineSet(filter: Filter): void {\n        const timelineSet = this.filteredTimelineSets[filter.filterId!];\n        delete this.filteredTimelineSets[filter.filterId!];\n        const i = this.timelineSets.indexOf(timelineSet);\n        if (i > -1) {\n            this.timelineSets.splice(i, 1);\n        }\n    }\n\n    /**\n     * Determine which timeline(s) a given event should live in\n     * Thread roots live in both the main timeline and their corresponding thread timeline\n     * Relations, redactions, replies to thread relation events live only in the thread timeline\n     * Relations (other than m.thread), redactions, replies to a thread root live only in the main timeline\n     * Relations, redactions, replies where the parent cannot be found live in no timelines but should be aggregated regardless.\n     * Otherwise, the event lives in the main timeline only.\n     *\n     * Note: when a redaction is applied, the redacted event, events relating\n     * to it, and the redaction event itself, will all move to the main thread.\n     * This method classifies them as inside the thread of the redacted event.\n     * They are moved later as part of makeRedacted.\n     * This will change if MSC3389 is merged.\n     */\n    public eventShouldLiveIn(\n        event: MatrixEvent,\n        events?: MatrixEvent[],\n        roots?: Set<string>,\n    ): {\n        shouldLiveInRoom: boolean;\n        shouldLiveInThread: boolean;\n        threadId?: string;\n    } {\n        if (!this.client?.supportsThreads()) {\n            return {\n                shouldLiveInRoom: true,\n                shouldLiveInThread: false,\n            };\n        }\n\n        // A thread root is the only event shown in both timelines\n        if (event.isThreadRoot || roots?.has(event.getId()!)) {\n            return {\n                shouldLiveInRoom: true,\n                shouldLiveInThread: true,\n                threadId: event.getId(),\n            };\n        }\n\n        const isThreadRelation = event.isRelation(THREAD_RELATION_TYPE.name);\n        const parentEventId = event.getAssociatedId();\n        const threadRootId = event.threadRootId;\n\n        // Where the parent is the thread root and this is a non-thread relation this should live only in the main timeline\n        if (!!parentEventId && !isThreadRelation && (threadRootId === parentEventId || roots?.has(parentEventId!))) {\n            return {\n                shouldLiveInRoom: true,\n                shouldLiveInThread: false,\n            };\n        }\n\n        let parentEvent: MatrixEvent | undefined;\n        if (parentEventId) {\n            parentEvent = this.findEventById(parentEventId) ?? events?.find((e) => e.getId() === parentEventId);\n        }\n\n        // Treat non-thread-relations, redactions, and replies as extensions of their parents so evaluate parentEvent instead\n        if (parentEvent && !isThreadRelation) {\n            return this.eventShouldLiveIn(parentEvent, events, roots);\n        }\n\n        // A thread relation (1st and 2nd order) is always only shown in a thread\n        if (threadRootId != undefined) {\n            return {\n                shouldLiveInRoom: false,\n                shouldLiveInThread: true,\n                threadId: threadRootId,\n            };\n        }\n\n        // Due to replies not being typical relations and being used as fallbacks for threads relations\n        // If we bypass the if case above then we know we are not a thread, so if we are still a reply\n        // then we know that we must be in the main timeline. Same goes if we have no associated parent event.\n        if (!parentEventId || !!event.replyEventId) {\n            return {\n                shouldLiveInRoom: true,\n                shouldLiveInThread: false,\n            };\n        }\n\n        // We've exhausted all scenarios,\n        // we cannot assume that it lives in the main timeline as this may be a relation for an unknown thread\n        // adding the event in the wrong timeline causes stuck notifications and can break ability to send read receipts\n        return {\n            shouldLiveInRoom: false,\n            shouldLiveInThread: false,\n        };\n    }\n\n    public findThreadForEvent(event?: MatrixEvent): Thread | null {\n        if (!event) return null;\n\n        const { threadId } = this.eventShouldLiveIn(event);\n        return threadId ? this.getThread(threadId) : null;\n    }\n\n    private addThreadedEvents(threadId: string, events: MatrixEvent[], toStartOfTimeline = false): void {\n        const thread = this.getThread(threadId);\n        if (thread) {\n            thread.addEvents(events, toStartOfTimeline);\n        } else {\n            const rootEvent = this.findEventById(threadId) ?? events.find((e) => e.getId() === threadId);\n            this.createThread(threadId, rootEvent, events, toStartOfTimeline);\n        }\n    }\n\n    /**\n     * Adds events to a thread's timeline. Will fire \"Thread.update\"\n     */\n    public processThreadedEvents(events: MatrixEvent[], toStartOfTimeline: boolean): void {\n        events.forEach(this.applyRedaction);\n\n        const eventsByThread: { [threadId: string]: MatrixEvent[] } = {};\n        for (const event of events) {\n            const { threadId, shouldLiveInThread } = this.eventShouldLiveIn(event);\n            if (shouldLiveInThread && !eventsByThread[threadId!]) {\n                eventsByThread[threadId!] = [];\n            }\n            eventsByThread[threadId!]?.push(event);\n        }\n\n        Object.entries(eventsByThread).map(([threadId, threadEvents]) =>\n            this.addThreadedEvents(threadId, threadEvents, toStartOfTimeline),\n        );\n    }\n\n    private updateThreadRootEvents = (thread: Thread, toStartOfTimeline: boolean, recreateEvent: boolean): void => {\n        if (thread.length) {\n            this.updateThreadRootEvent(this.threadsTimelineSets?.[0], thread, toStartOfTimeline, recreateEvent);\n            if (thread.hasCurrentUserParticipated) {\n                this.updateThreadRootEvent(this.threadsTimelineSets?.[1], thread, toStartOfTimeline, recreateEvent);\n            }\n        }\n    };\n\n    private updateThreadRootEvent = (\n        timelineSet: Optional<EventTimelineSet>,\n        thread: Thread,\n        toStartOfTimeline: boolean,\n        recreateEvent: boolean,\n    ): void => {\n        if (timelineSet && thread.rootEvent) {\n            if (recreateEvent) {\n                timelineSet.removeEvent(thread.id);\n            }\n            if (Thread.hasServerSideSupport) {\n                timelineSet.addLiveEvent(thread.rootEvent, {\n                    duplicateStrategy: DuplicateStrategy.Replace,\n                    fromCache: false,\n                    roomState: this.currentState,\n                    addToState: false,\n                });\n            } else {\n                timelineSet.addEventToTimeline(thread.rootEvent, timelineSet.getLiveTimeline(), {\n                    toStartOfTimeline,\n                    addToState: false,\n                });\n            }\n        }\n    };\n\n    public createThread(\n        threadId: string,\n        rootEvent: MatrixEvent | undefined,\n        events: MatrixEvent[] = [],\n        toStartOfTimeline: boolean,\n    ): Thread {\n        if (this.threads.has(threadId)) {\n            return this.threads.get(threadId)!;\n        }\n\n        if (rootEvent) {\n            const relatedEvents = this.relations.getAllChildEventsForEvent(rootEvent.getId()!);\n            if (relatedEvents?.length) {\n                // Include all relations of the root event, given it'll be visible in both timelines,\n                // except `m.replace` as that will already be applied atop the event using `MatrixEvent::makeReplaced`\n                events = events.concat(relatedEvents.filter((e) => !e.isRelation(RelationType.Replace)));\n            }\n        }\n\n        const thread = new Thread(threadId, rootEvent, {\n            room: this,\n            client: this.client,\n            pendingEventOrdering: this.opts.pendingEventOrdering,\n            receipts: this.cachedThreadReadReceipts.get(threadId) ?? [],\n        });\n\n        // Add the re-emitter before we start adding events to the thread so we don't miss events\n        this.reEmitter.reEmit(thread, [\n            ThreadEvent.Delete,\n            ThreadEvent.Update,\n            ThreadEvent.NewReply,\n            RoomEvent.Timeline,\n            RoomEvent.TimelineReset,\n        ]);\n\n        // All read receipts should now come down from sync, we do not need to keep\n        // a reference to the cached receipts anymore.\n        this.cachedThreadReadReceipts.delete(threadId);\n\n        // If we managed to create a thread and figure out its `id` then we can use it\n        // This has to happen before thread.addEvents, because that adds events to the eventtimeline, and the\n        // eventtimeline sometimes looks up thread information via the room.\n        this.threads.set(thread.id, thread);\n\n        // This is necessary to be able to jump to events in threads:\n        // If we jump to an event in a thread where neither the event, nor the root,\n        // nor any thread event are loaded yet, we'll load the event as well as the thread root, create the thread,\n        // and pass the event through this.\n        thread.addEvents(events, false);\n\n        // We need to update the thread root events, but the thread may not be ready yet.\n        // If it isn't, it will fire ThreadEvent.Update when it is and we'll call updateThreadRootEvents then.\n        if (this.threadsReady && thread.initialEventsFetched) {\n            this.updateThreadRootEvents(thread, toStartOfTimeline, false);\n        }\n        this.emit(ThreadEvent.New, thread, toStartOfTimeline);\n\n        return thread;\n    }\n\n    private applyRedaction = (event: MatrixEvent): void => {\n        if (event.isRedaction()) {\n            const redactId = event.event.redacts;\n\n            // if we know about this event, redact its contents now.\n            const redactedEvent = redactId ? this.findEventById(redactId) : undefined;\n            if (redactedEvent) {\n                const threadRootId = redactedEvent.threadRootId;\n                redactedEvent.makeRedacted(event, this);\n\n                // If this is in the current state, replace it with the redacted version\n                if (redactedEvent.isState()) {\n                    const currentStateEvent = this.currentState.getStateEvents(\n                        redactedEvent.getType(),\n                        redactedEvent.getStateKey()!,\n                    );\n                    if (currentStateEvent?.getId() === redactedEvent.getId()) {\n                        this.currentState.setStateEvents([redactedEvent]);\n                    }\n                }\n\n                this.emit(RoomEvent.Redaction, event, this, threadRootId);\n\n                // TODO: we stash user displaynames (among other things) in\n                // RoomMember objects which are then attached to other events\n                // (in the sender and target fields). We should get those\n                // RoomMember objects to update themselves when the events that\n                // they are based on are changed.\n\n                // Remove any visibility change on this event.\n                this.visibilityEvents.delete(redactId!);\n\n                // If this event is a visibility change event, remove it from the\n                // list of visibility changes and update any event affected by it.\n                if (redactedEvent.isVisibilityEvent()) {\n                    this.redactVisibilityChangeEvent(event);\n                }\n            }\n\n            // FIXME: apply redactions to notification list\n\n            // NB: We continue to add the redaction event to the timeline so\n            // clients can say \"so and so redacted an event\" if they wish to. Also\n            // this may be needed to trigger an update.\n        }\n    };\n\n    private processLiveEvent(event: MatrixEvent): void {\n        this.applyRedaction(event);\n\n        // Implement MSC3531: hiding messages.\n        if (event.isVisibilityEvent()) {\n            // This event changes the visibility of another event, record\n            // the visibility change, inform clients if necessary.\n            this.applyNewVisibilityEvent(event);\n        }\n        // If any pending visibility change is waiting for this (older) event,\n        this.applyPendingVisibilityEvents(event);\n\n        // Sliding Sync modifications:\n        // The proxy cannot guarantee every sent event will have a transaction_id field, so we need\n        // to check the event ID against the list of pending events if there is no transaction ID\n        // field. Only do this for events sent by us though as it's potentially expensive to loop\n        // the pending events map.\n        const txnId = event.getUnsigned().transaction_id;\n        if (!txnId && event.getSender() === this.myUserId) {\n            // check the txn map for a matching event ID\n            for (const [tid, localEvent] of this.txnToEvent) {\n                if (localEvent.getId() === event.getId()) {\n                    logger.debug(\"processLiveEvent: found sent event without txn ID: \", tid, event.getId());\n                    // update the unsigned field so we can re-use the same codepaths\n                    const unsigned = event.getUnsigned();\n                    unsigned.transaction_id = tid;\n                    event.setUnsigned(unsigned);\n                    break;\n                }\n            }\n        }\n    }\n\n    /**\n     * Add an event to the end of this room's live timelines. Will fire\n     * \"Room.timeline\".\n     *\n     * @param event - Event to be added\n     * @param addLiveEventOptions - addLiveEvent options\n     * @internal\n     *\n     * @remarks\n     * Fires {@link RoomEvent.Timeline}\n     */\n    private addLiveEvent(event: MatrixEvent, addLiveEventOptions: IAddLiveEventOptions): void {\n        const { duplicateStrategy, timelineWasEmpty, fromCache, addToState } = addLiveEventOptions;\n\n        // add to our timeline sets\n        for (const timelineSet of this.timelineSets) {\n            timelineSet.addLiveEvent(event, {\n                duplicateStrategy,\n                fromCache,\n                timelineWasEmpty,\n                addToState,\n            });\n        }\n\n        // synthesize and inject implicit read receipts\n        // Done after adding the event because otherwise the app would get a read receipt\n        // pointing to an event that wasn't yet in the timeline\n        // Don't synthesize RR for m.room.redaction as this causes the RR to go missing.\n        if (event.sender && event.getType() !== EventType.RoomRedaction) {\n            this.addReceipt(synthesizeReceipt(event.sender.userId, event, ReceiptType.Read), true);\n\n            // Any live events from a user could be taken as implicit\n            // presence information: evidence that they are currently active.\n            // ...except in a world where we use 'user.currentlyActive' to reduce\n            // presence spam, this isn't very useful - we'll get a transition when\n            // they are no longer currently active anyway. So don't bother to\n            // reset the lastActiveAgo and lastPresenceTs from the RoomState's user.\n        }\n    }\n\n    /**\n     * Add a pending outgoing event to this room.\n     *\n     * <p>The event is added to either the pendingEventList, or the live timeline,\n     * depending on the setting of opts.pendingEventOrdering.\n     *\n     * <p>This is an internal method, intended for use by MatrixClient.\n     *\n     * @param event - The event to add.\n     *\n     * @param txnId - Transaction id for this outgoing event\n     *\n     * @throws if the event doesn't have status SENDING, or we aren't given a\n     * unique transaction id.\n     *\n     * @remarks\n     * Fires {@link RoomEvent.LocalEchoUpdated}\n     */\n    public addPendingEvent(event: MatrixEvent, txnId: string): void {\n        if (event.status !== EventStatus.SENDING && event.status !== EventStatus.NOT_SENT) {\n            throw new Error(\"addPendingEvent called on an event with status \" + event.status);\n        }\n\n        if (this.txnToEvent.get(txnId)) {\n            throw new Error(\"addPendingEvent called on an event with known txnId \" + txnId);\n        }\n\n        // call setEventMetadata to set up event.sender etc\n        // as event is shared over all timelineSets, we set up its metadata based\n        // on the unfiltered timelineSet.\n        EventTimeline.setEventMetadata(event, this.getLiveTimeline().getState(EventTimeline.FORWARDS)!, false);\n\n        this.txnToEvent.set(txnId, event);\n        if (this.pendingEventList) {\n            if (this.pendingEventList.some((e) => e.status === EventStatus.NOT_SENT)) {\n                logger.warn(\"Setting event as NOT_SENT due to messages in the same state\");\n                event.setStatus(EventStatus.NOT_SENT);\n            }\n            this.pendingEventList.push(event);\n            this.savePendingEvents();\n            if (event.isRelation()) {\n                // For pending events, add them to the relations collection immediately.\n                // (The alternate case below already covers this as part of adding to\n                // the timeline set.)\n                this.aggregateNonLiveRelation(event);\n            }\n\n            if (event.isRedaction()) {\n                const redactId = event.event.redacts;\n                let redactedEvent = this.pendingEventList.find((e) => e.getId() === redactId);\n                if (!redactedEvent && redactId) {\n                    redactedEvent = this.findEventById(redactId);\n                }\n                if (redactedEvent) {\n                    redactedEvent.markLocallyRedacted(event);\n                    this.emit(RoomEvent.Redaction, event, this, redactedEvent.threadRootId);\n                }\n            }\n        } else {\n            for (const timelineSet of this.timelineSets) {\n                if (timelineSet.getFilter()) {\n                    if (timelineSet.getFilter()!.filterRoomTimeline([event]).length) {\n                        timelineSet.addEventToTimeline(event, timelineSet.getLiveTimeline(), {\n                            toStartOfTimeline: false,\n                            addToState: false, // We don't support localEcho of state events yet\n                        });\n                    }\n                } else {\n                    timelineSet.addEventToTimeline(event, timelineSet.getLiveTimeline(), {\n                        toStartOfTimeline: false,\n                        addToState: false, // We don't support localEcho of state events yet\n                    });\n                }\n            }\n        }\n\n        this.emit(RoomEvent.LocalEchoUpdated, event, this);\n    }\n\n    /**\n     * Persists all pending events to local storage\n     *\n     * If the current room is encrypted only encrypted events will be persisted\n     * all messages that are not yet encrypted will be discarded\n     *\n     * This is because the flow of EVENT_STATUS transition is\n     * `queued => sending => encrypting => sending => sent`\n     *\n     * Steps 3 and 4 are skipped for unencrypted room.\n     * It is better to discard an unencrypted message rather than persisting\n     * it locally for everyone to read\n     */\n    private savePendingEvents(): void {\n        if (this.pendingEventList) {\n            const pendingEvents = this.pendingEventList\n                .map((event) => {\n                    return {\n                        ...event.event,\n                        txn_id: event.getTxnId(),\n                    };\n                })\n                .filter((event) => {\n                    // Filter out the unencrypted messages if the room is encrypted\n                    const isEventEncrypted = event.type === EventType.RoomMessageEncrypted;\n                    const isRoomEncrypted = this.hasEncryptionStateEvent();\n                    return isEventEncrypted || !isRoomEncrypted;\n                });\n\n            this.client.store.setPendingEvents(this.roomId, pendingEvents);\n        }\n    }\n\n    /**\n     * Used to aggregate the local echo for a relation, and also\n     * for re-applying a relation after it's redaction has been cancelled,\n     * as the local echo for the redaction of the relation would have\n     * un-aggregated the relation. Note that this is different from regular messages,\n     * which are just kept detached for their local echo.\n     *\n     * Also note that live events are aggregated in the live EventTimelineSet.\n     * @param event - the relation event that needs to be aggregated.\n     */\n    private aggregateNonLiveRelation(event: MatrixEvent): void {\n        this.relations.aggregateChildEvent(event);\n    }\n\n    public getEventForTxnId(txnId: string): MatrixEvent | undefined {\n        return this.txnToEvent.get(txnId);\n    }\n\n    /**\n     * Deal with the echo of a message we sent.\n     *\n     * <p>We move the event to the live timeline if it isn't there already, and\n     * update it.\n     *\n     * @param remoteEvent -   The event received from\n     *    /sync\n     * @param localEvent -    The local echo, which\n     *    should be either in the pendingEventList or the timeline.\n     *\n     * @internal\n     *\n     * @remarks\n     * Fires {@link RoomEvent.LocalEchoUpdated}\n     */\n    public handleRemoteEcho(remoteEvent: MatrixEvent, localEvent: MatrixEvent): void {\n        const oldEventId = localEvent.getId()!;\n        const newEventId = remoteEvent.getId()!;\n        const oldStatus = localEvent.status;\n\n        logger.debug(`Got remote echo for event ${oldEventId} -> ${newEventId} old status ${oldStatus}`);\n\n        // no longer pending\n        this.txnToEvent.delete(remoteEvent.getUnsigned().transaction_id!);\n\n        // if it's in the pending list, remove it\n        if (this.pendingEventList) {\n            this.removePendingEvent(oldEventId);\n        }\n\n        // replace the event source (this will preserve the plaintext payload if\n        // any, which is good, because we don't want to try decoding it again).\n        localEvent.handleRemoteEcho(remoteEvent.event);\n\n        const { shouldLiveInRoom, threadId } = this.eventShouldLiveIn(remoteEvent);\n        const thread = threadId ? this.getThread(threadId) : null;\n        thread?.setEventMetadata(localEvent);\n        thread?.timelineSet.handleRemoteEcho(localEvent, oldEventId, newEventId);\n\n        if (shouldLiveInRoom) {\n            for (const timelineSet of this.timelineSets) {\n                // if it's already in the timeline, update the timeline map. If it's not, add it.\n                timelineSet.handleRemoteEcho(localEvent, oldEventId, newEventId);\n            }\n        }\n\n        this.emit(RoomEvent.LocalEchoUpdated, localEvent, this, oldEventId, oldStatus);\n    }\n\n    /**\n     * Update the status / event id on a pending event, to reflect its transmission\n     * progress.\n     *\n     * <p>This is an internal method.\n     *\n     * @param event -      local echo event\n     * @param newStatus -  status to assign\n     * @param newEventId -      new event id to assign. Ignored unless newStatus == EventStatus.SENT.\n     *\n     * @remarks\n     * Fires {@link RoomEvent.LocalEchoUpdated}\n     */\n    public updatePendingEvent(event: MatrixEvent, newStatus: EventStatus, newEventId?: string): void {\n        logger.log(\n            `setting pendingEvent status to ${newStatus} in ${event.getRoomId()} ` +\n                `event ID ${event.getId()} -> ${newEventId}`,\n        );\n\n        // if the message was sent, we expect an event id\n        if (newStatus == EventStatus.SENT && !newEventId) {\n            throw new Error(\"updatePendingEvent called with status=SENT, but no new event id\");\n        }\n\n        // SENT races against /sync, so we have to special-case it.\n        if (newStatus == EventStatus.SENT) {\n            const timeline = this.getTimelineForEvent(newEventId!);\n            if (timeline) {\n                // we've already received the event via the event stream.\n                // nothing more to do here, assuming the transaction ID was correctly matched.\n                // Let's check that.\n                const remoteEvent = this.findEventById(newEventId!);\n                const remoteTxnId = remoteEvent?.getUnsigned().transaction_id;\n                if (!remoteTxnId && remoteEvent) {\n                    // This code path is mostly relevant for the Sliding Sync proxy.\n                    // The remote event did not contain a transaction ID, so we did not handle\n                    // the remote echo yet. Handle it now.\n                    const unsigned = remoteEvent.getUnsigned();\n                    unsigned.transaction_id = event.getTxnId();\n                    remoteEvent.setUnsigned(unsigned);\n                    // the remote event is _already_ in the timeline, so we need to remove it so\n                    // we can convert the local event into the final event.\n                    this.removeEvent(remoteEvent.getId()!);\n                    this.handleRemoteEcho(remoteEvent, event);\n                }\n                return;\n            }\n        }\n\n        const oldStatus = event.status;\n        const oldEventId = event.getId()!;\n\n        if (!oldStatus) {\n            throw new Error(\"updatePendingEventStatus called on an event which is not a local echo.\");\n        }\n\n        const allowed = ALLOWED_TRANSITIONS[oldStatus];\n        if (!allowed?.includes(newStatus)) {\n            throw new Error(`Invalid EventStatus transition ${oldStatus}->${newStatus}`);\n        }\n\n        event.setStatus(newStatus);\n\n        if (newStatus == EventStatus.SENT) {\n            // update the event id\n            event.replaceLocalEventId(newEventId!);\n\n            const { shouldLiveInRoom, threadId } = this.eventShouldLiveIn(event);\n            const thread = threadId ? this.getThread(threadId) : undefined;\n            thread?.setEventMetadata(event);\n            thread?.timelineSet.replaceEventId(oldEventId, newEventId!);\n\n            if (shouldLiveInRoom) {\n                // if the event was already in the timeline (which will be the case if\n                // opts.pendingEventOrdering==chronological), we need to update the\n                // timeline map.\n                for (const timelineSet of this.timelineSets) {\n                    timelineSet.replaceEventId(oldEventId, newEventId!);\n                }\n            }\n        } else if (newStatus == EventStatus.CANCELLED) {\n            // remove it from the pending event list, or the timeline.\n            if (this.pendingEventList) {\n                const removedEvent = this.getPendingEvent(oldEventId);\n                this.removePendingEvent(oldEventId);\n                if (removedEvent?.isRedaction()) {\n                    this.revertRedactionLocalEcho(removedEvent);\n                }\n            }\n            this.removeEvent(oldEventId);\n        }\n        this.savePendingEvents();\n\n        this.emit(RoomEvent.LocalEchoUpdated, event, this, oldEventId, oldStatus);\n    }\n\n    private revertRedactionLocalEcho(redactionEvent: MatrixEvent): void {\n        const redactId = redactionEvent.event.redacts;\n        if (!redactId) {\n            return;\n        }\n        const redactedEvent = this.getUnfilteredTimelineSet().findEventById(redactId);\n        if (redactedEvent) {\n            redactedEvent.unmarkLocallyRedacted();\n            // re-render after undoing redaction\n            this.emit(RoomEvent.RedactionCancelled, redactionEvent, this);\n            // reapply relation now redaction failed\n            if (redactedEvent.isRelation()) {\n                this.aggregateNonLiveRelation(redactedEvent);\n            }\n        }\n    }\n\n    private assertTimelineSetsAreLive(): void {\n        for (let i = 0; i < this.timelineSets.length; i++) {\n            const liveTimeline = this.timelineSets[i].getLiveTimeline();\n            if (liveTimeline.getPaginationToken(EventTimeline.FORWARDS)) {\n                throw new Error(\n                    \"live timeline \" +\n                        i +\n                        \" is no longer live - it has a pagination token \" +\n                        \"(\" +\n                        liveTimeline.getPaginationToken(EventTimeline.FORWARDS) +\n                        \")\",\n                );\n            }\n            if (liveTimeline.getNeighbouringTimeline(EventTimeline.FORWARDS)) {\n                throw new Error(`live timeline ${i} is no longer live - it has a neighbouring timeline`);\n            }\n        }\n    }\n\n    /**\n     * Add some events to this room. This can include state events, message\n     * events and typing notifications. These events are treated as \"live\" so\n     * they will go to the end of the timeline.\n     *\n     * @param events - A list of events to add.\n     * @param addLiveEventOptions - addLiveEvent options\n     * @throws If `duplicateStrategy` is not falsey, 'replace' or 'ignore'.\n     */\n    public async addLiveEvents(events: MatrixEvent[], addLiveEventOptions: IAddLiveEventOptions): Promise<void> {\n        const { duplicateStrategy, fromCache, timelineWasEmpty = false, addToState } = addLiveEventOptions;\n        if (duplicateStrategy && [\"replace\", \"ignore\"].indexOf(duplicateStrategy) === -1) {\n            throw new Error(\"duplicateStrategy MUST be either 'replace' or 'ignore'\");\n        }\n\n        // sanity check that the live timeline is still live\n        this.assertTimelineSetsAreLive();\n\n        const threadRoots = this.findThreadRoots(events);\n        const eventsByThread: { [threadId: string]: MatrixEvent[] } = {};\n\n        const options: IAddLiveEventOptions = {\n            duplicateStrategy,\n            fromCache,\n            timelineWasEmpty,\n            addToState,\n        };\n\n        // List of extra events to check for being parents of any relations encountered\n        const neighbouringEvents = [...events];\n\n        for (const event of events) {\n            // TODO: We should have a filter to say \"only add state event types X Y Z to the timeline\".\n            this.processLiveEvent(event);\n\n            if (event.getUnsigned().transaction_id) {\n                const existingEvent = this.txnToEvent.get(event.getUnsigned().transaction_id!);\n                if (existingEvent) {\n                    // remote echo of an event we sent earlier\n                    this.handleRemoteEcho(event, existingEvent);\n                    continue; // we can skip adding the event to the timeline sets, it is already there\n                }\n            }\n\n            let {\n                shouldLiveInRoom,\n                shouldLiveInThread,\n                threadId = \"\",\n            } = this.eventShouldLiveIn(event, neighbouringEvents, threadRoots);\n\n            if (!shouldLiveInThread && !shouldLiveInRoom && event.isRelation()) {\n                try {\n                    const parentEvent = new MatrixEvent(\n                        await this.client.fetchRoomEvent(this.roomId, event.relationEventId!),\n                    );\n                    neighbouringEvents.push(parentEvent);\n                    if (parentEvent.threadRootId) {\n                        threadRoots.add(parentEvent.threadRootId);\n                        const unsigned = event.getUnsigned();\n                        unsigned[UNSIGNED_THREAD_ID_FIELD.name] = parentEvent.threadRootId;\n                        event.setUnsigned(unsigned);\n                    }\n\n                    ({\n                        shouldLiveInRoom,\n                        shouldLiveInThread,\n                        threadId = \"\",\n                    } = this.eventShouldLiveIn(event, neighbouringEvents, threadRoots));\n                } catch (e) {\n                    logger.error(\"Failed to load parent event of unhandled relation\", e);\n                }\n            }\n\n            if (shouldLiveInThread && !eventsByThread[threadId]) {\n                eventsByThread[threadId] = [];\n            }\n            eventsByThread[threadId]?.push(event);\n\n            if (shouldLiveInRoom) {\n                this.addLiveEvent(event, options);\n            } else if (!shouldLiveInThread && event.isRelation()) {\n                this.relations.aggregateChildEvent(event);\n            }\n        }\n\n        Object.entries(eventsByThread).forEach(([threadId, threadEvents]) => {\n            this.addThreadedEvents(threadId, threadEvents, false);\n        });\n    }\n\n    public partitionThreadedEvents(\n        events: MatrixEvent[],\n    ): [timelineEvents: MatrixEvent[], threadedEvents: MatrixEvent[], unknownRelations: MatrixEvent[]] {\n        // Indices to the events array, for readability\n        const ROOM = 0;\n        const THREAD = 1;\n        const UNKNOWN_RELATION = 2;\n        if (this.client.supportsThreads()) {\n            const threadRoots = this.findThreadRoots(events);\n            return events.reduce<[MatrixEvent[], MatrixEvent[], MatrixEvent[]]>(\n                (memo, event: MatrixEvent) => {\n                    const { shouldLiveInRoom, shouldLiveInThread, threadId } = this.eventShouldLiveIn(\n                        event,\n                        events,\n                        threadRoots,\n                    );\n\n                    if (shouldLiveInRoom) {\n                        memo[ROOM].push(event);\n                    }\n\n                    if (shouldLiveInThread) {\n                        event.setThreadId(threadId ?? \"\");\n                        memo[THREAD].push(event);\n                    }\n\n                    if (!shouldLiveInThread && !shouldLiveInRoom) {\n                        memo[UNKNOWN_RELATION].push(event);\n                    }\n\n                    return memo;\n                },\n                [[], [], []],\n            );\n        } else {\n            // When `threadSupport` is disabled treat all events as timelineEvents\n            return [events as MatrixEvent[], [] as MatrixEvent[], [] as MatrixEvent[]];\n        }\n    }\n\n    /**\n     * Given some events, find the IDs of all the thread roots that are referred to by them.\n     */\n    private findThreadRoots(events: MatrixEvent[]): Set<string> {\n        const threadRoots = new Set<string>();\n        for (const event of events) {\n            const threadRootId = event.threadRootId;\n            if (threadRootId != undefined) {\n                threadRoots.add(threadRootId);\n            }\n        }\n        return threadRoots;\n    }\n\n    /**\n     * Add a receipt event to the room.\n     * @param event - The m.receipt event.\n     * @param synthetic - True if this event is implicit.\n     */\n    public addReceipt(event: MatrixEvent, synthetic = false): void {\n        const content = event.getContent<ReceiptContent>();\n\n        this.roomReceipts.add(content, synthetic);\n\n        // TODO: delete the following code when it has been replaced by RoomReceipts\n        Object.keys(content).forEach((eventId: string) => {\n            Object.keys(content[eventId]).forEach((receiptType: ReceiptType | string) => {\n                Object.keys(content[eventId][receiptType]).forEach((userId: string) => {\n                    const receipt = content[eventId][receiptType][userId] as Receipt;\n                    const receiptForMainTimeline = !receipt.thread_id || receipt.thread_id === MAIN_ROOM_TIMELINE;\n                    const receiptDestination: Thread | this | undefined = receiptForMainTimeline\n                        ? this\n                        : this.threads.get(receipt.thread_id ?? \"\");\n\n                    if (receiptDestination) {\n                        receiptDestination.addReceiptToStructure(\n                            eventId,\n                            receiptType as ReceiptType,\n                            userId,\n                            receipt,\n                            synthetic,\n                        );\n\n                        // If the read receipt sent for the logged in user matches\n                        // the last event of the live timeline, then we know for a fact\n                        // that the user has read that message, so we can mark the room\n                        // as read and not wait for the remote echo from synapse.\n                        //\n                        // This needs to be done after the initial sync as we do not want this\n                        // logic to run whilst the room is being initialised\n                        //\n                        // We only do this for non-synthetic receipts, because\n                        // our intention is to do this when the user really did\n                        // just read a message, not when we are e.g. receiving\n                        // an event during the sync. More explanation at:\n                        // https://github.com/matrix-org/matrix-js-sdk/issues/3684\n                        if (!synthetic && this.client.isInitialSyncComplete() && userId === this.client.getUserId()) {\n                            const lastEvent = receiptDestination.timeline[receiptDestination.timeline.length - 1];\n                            if (lastEvent && eventId === lastEvent.getId() && userId === lastEvent.getSender()) {\n                                receiptDestination.setUnread(NotificationCountType.Total, 0);\n                                receiptDestination.setUnread(NotificationCountType.Highlight, 0);\n                            }\n                        }\n                    } else {\n                        // The thread does not exist locally, keep the read receipt\n                        // in a cache locally, and re-apply  the `addReceipt` logic\n                        // when the thread is created\n                        this.cachedThreadReadReceipts.set(receipt.thread_id!, [\n                            ...(this.cachedThreadReadReceipts.get(receipt.thread_id!) ?? []),\n                            { eventId, receiptType, userId, receipt, synthetic },\n                        ]);\n                    }\n\n                    const me = this.client.getUserId();\n                    // Track the time of the current user's oldest threaded receipt in the room.\n                    if (userId === me && !receiptForMainTimeline && receipt.ts < this.oldestThreadedReceiptTs) {\n                        this.oldestThreadedReceiptTs = receipt.ts;\n                    }\n\n                    // Track each user's unthreaded read receipt.\n                    if (!receipt.thread_id && receipt.ts > (this.unthreadedReceipts.get(userId)?.ts ?? 0)) {\n                        this.unthreadedReceipts.set(userId, receipt);\n                    }\n                });\n            });\n        });\n        // End of code to delete when replaced by RoomReceipts\n\n        // send events after we've regenerated the structure & cache, otherwise things that\n        // listened for the event would read stale data.\n        this.emit(RoomEvent.Receipt, event, this);\n    }\n\n    /**\n     * Adds/handles ephemeral events such as typing notifications and read receipts.\n     * @param events - A list of events to process\n     */\n    public addEphemeralEvents(events: MatrixEvent[]): void {\n        for (const event of events) {\n            if (event.getType() === EventType.Typing) {\n                this.currentState.setTypingEvent(event);\n            } else if (event.getType() === EventType.Receipt) {\n                this.addReceipt(event);\n            } // else ignore - life is too short for us to care about these events\n        }\n    }\n\n    /**\n     * Removes events from this room.\n     * @param eventIds - A list of eventIds to remove.\n     */\n    public removeEvents(eventIds: string[]): void {\n        for (const eventId of eventIds) {\n            this.removeEvent(eventId);\n        }\n    }\n\n    /**\n     * Removes a single event from this room.\n     *\n     * @param eventId -  The id of the event to remove\n     *\n     * @returns true if the event was removed from any of the room's timeline sets\n     */\n    public removeEvent(eventId: string): boolean {\n        let removedAny = false;\n        for (const timelineSet of this.timelineSets) {\n            const removed = timelineSet.removeEvent(eventId);\n            if (removed) {\n                if (removed.isRedaction()) {\n                    this.revertRedactionLocalEcho(removed);\n                }\n                removedAny = true;\n            }\n        }\n        return removedAny;\n    }\n\n    /**\n     * Recalculate various aspects of the room, including the room name and\n     * room summary. Call this any time the room's current state is modified.\n     * May fire \"Room.name\" if the room name is updated.\n     *\n     * @remarks\n     * Fires {@link RoomEvent.Name}\n     */\n    public recalculate(): void {\n        // set fake stripped state events if this is an invite room so logic remains\n        // consistent elsewhere.\n        const membershipEvent = this.currentState.getStateEvents(EventType.RoomMember, this.myUserId);\n        if (membershipEvent) {\n            const membership = membershipEvent.getContent().membership;\n            this.updateMyMembership(membership!);\n\n            if (membership === KnownMembership.Invite) {\n                const strippedStateEvents = membershipEvent.getUnsigned().invite_room_state || [];\n                strippedStateEvents.forEach((strippedEvent) => {\n                    const existingEvent = this.currentState.getStateEvents(strippedEvent.type, strippedEvent.state_key);\n                    if (!existingEvent) {\n                        // set the fake stripped event instead\n                        this.currentState.setStateEvents([\n                            new MatrixEvent({\n                                type: strippedEvent.type,\n                                state_key: strippedEvent.state_key,\n                                content: strippedEvent.content,\n                                event_id: \"$fake\" + Date.now(),\n                                room_id: this.roomId,\n                                sender: this.myUserId, // technically a lie\n                            }),\n                        ]);\n                    }\n                });\n            }\n        }\n\n        const oldName = this.name;\n        this.name = this.calculateRoomName(this.myUserId);\n        this.normalizedName = normalize(this.name);\n        this.summary = new RoomSummary(this.roomId, {\n            title: this.name,\n        });\n\n        if (oldName !== this.name) {\n            this.emit(RoomEvent.Name, this);\n        }\n    }\n\n    /**\n     * Update the room-tag event for the room.  The previous one is overwritten.\n     * @param event - the m.tag event\n     */\n    public addTags(event: MatrixEvent): void {\n        // event content looks like:\n        // content: {\n        //    tags: {\n        //       $tagName: { $metadata: $value },\n        //       $tagName: { $metadata: $value },\n        //    }\n        // }\n\n        // XXX: do we need to deep copy here?\n        this.tags = event.getContent().tags || {};\n\n        // XXX: we could do a deep-comparison to see if the tags have really\n        // changed - but do we want to bother?\n        this.emit(RoomEvent.Tags, event, this);\n    }\n\n    /**\n     * Update the account_data events for this room, overwriting events of the same type.\n     * @param events - an array of account_data events to add\n     */\n    public addAccountData(events: MatrixEvent[]): void {\n        for (const event of events) {\n            if (event.getType() === \"m.tag\") {\n                this.addTags(event);\n            }\n            const eventType = event.getType();\n            const lastEvent = this.accountData.get(eventType);\n            this.accountData.set(eventType, event);\n            this.emit(RoomEvent.AccountData, event, this, lastEvent);\n        }\n    }\n\n    /**\n     * Access account_data event of given event type for this room\n     * @param type - the type of account_data event to be accessed\n     * @returns the account_data event in question\n     */\n    public getAccountData(type: EventType | string): MatrixEvent | undefined {\n        return this.accountData.get(type);\n    }\n\n    /**\n     * Returns whether the syncing user has permission to send a message in the room\n     * @returns true if the user should be permitted to send\n     *                   message events into the room.\n     */\n    public maySendMessage(): boolean {\n        return (\n            this.getMyMembership() === KnownMembership.Join &&\n            (this.hasEncryptionStateEvent()\n                ? this.currentState.maySendEvent(EventType.RoomMessageEncrypted, this.myUserId)\n                : this.currentState.maySendEvent(EventType.RoomMessage, this.myUserId))\n        );\n    }\n\n    /**\n     * Returns whether the given user has permissions to issue an invite for this room.\n     * @param userId - the ID of the Matrix user to check permissions for\n     * @returns true if the user should be permitted to issue invites for this room.\n     */\n    public canInvite(userId: string): boolean {\n        let canInvite = this.getMyMembership() === KnownMembership.Join;\n        const powerLevelsEvent = this.currentState.getStateEvents(EventType.RoomPowerLevels, \"\");\n        const powerLevels = powerLevelsEvent && powerLevelsEvent.getContent();\n        const me = this.getMember(userId);\n        if (powerLevels && me && powerLevels.invite > me.powerLevel) {\n            canInvite = false;\n        }\n        return canInvite;\n    }\n\n    /**\n     * Returns the join rule based on the m.room.join_rule state event, defaulting to `invite`.\n     * @returns the join_rule applied to this room\n     */\n    public getJoinRule(): JoinRule {\n        return this.currentState.getJoinRule();\n    }\n\n    /**\n     * Returns the history visibility based on the m.room.history_visibility state event, defaulting to `shared`.\n     * @returns the history_visibility applied to this room\n     */\n    public getHistoryVisibility(): HistoryVisibility {\n        return this.currentState.getHistoryVisibility();\n    }\n\n    /**\n     * Returns the history visibility based on the m.room.history_visibility state event, defaulting to `shared`.\n     * @returns the history_visibility applied to this room\n     */\n    public getGuestAccess(): GuestAccess {\n        return this.currentState.getGuestAccess();\n    }\n\n    /**\n     * Returns the type of the room from the `m.room.create` event content or undefined if none is set\n     * @returns the type of the room.\n     */\n    public getType(): RoomType | string | undefined {\n        const createEvent = this.currentState.getStateEvents(EventType.RoomCreate, \"\");\n        if (!createEvent) {\n            if (!this.getTypeWarning) {\n                logger.warn(\"[getType] Room \" + this.roomId + \" does not have an m.room.create event\");\n                this.getTypeWarning = true;\n            }\n            return undefined;\n        }\n        return createEvent.getContent()[RoomCreateTypeField];\n    }\n\n    /**\n     * Returns whether the room is a space-room as defined by MSC1772.\n     * @returns true if the room's type is RoomType.Space\n     */\n    public isSpaceRoom(): boolean {\n        return this.getType() === RoomType.Space;\n    }\n\n    /**\n     * Returns whether the room is a call-room as defined by MSC3417.\n     * @returns true if the room's type is RoomType.UnstableCall\n     */\n    public isCallRoom(): boolean {\n        return this.getType() === RoomType.UnstableCall;\n    }\n\n    /**\n     * Returns whether the room is a video room.\n     * @returns true if the room's type is RoomType.ElementVideo\n     */\n    public isElementVideoRoom(): boolean {\n        return this.getType() === RoomType.ElementVideo;\n    }\n\n    /**\n     * Find the predecessor of this room.\n     *\n     * @param msc3946ProcessDynamicPredecessor - if true, look for an\n     * m.room.predecessor state event and use it if found (MSC3946).\n     * @returns null if this room has no predecessor. Otherwise, returns\n     * the roomId, last eventId and viaServers of the predecessor room.\n     *\n     * If msc3946ProcessDynamicPredecessor is true, use m.predecessor events\n     * as well as m.room.create events to find predecessors.\n     *\n     * Note: if an m.predecessor event is used, eventId may be undefined\n     * since last_known_event_id is optional.\n     *\n     * Note: viaServers may be undefined, and will definitely be undefined if\n     * this predecessor comes from a RoomCreate event (rather than a\n     * RoomPredecessor, which has the optional via_servers property).\n     */\n    public findPredecessor(\n        msc3946ProcessDynamicPredecessor = false,\n    ): { roomId: string; eventId?: string; viaServers?: string[] } | null {\n        const currentState = this.getLiveTimeline().getState(EventTimeline.FORWARDS);\n        if (!currentState) {\n            return null;\n        }\n        return currentState.findPredecessor(msc3946ProcessDynamicPredecessor);\n    }\n\n    private roomNameGenerator(state: RoomNameState): string {\n        if (this.client.roomNameGenerator) {\n            const name = this.client.roomNameGenerator(this.roomId, state);\n            if (name !== null) {\n                return name;\n            }\n        }\n\n        switch (state.type) {\n            case RoomNameType.Actual:\n                return state.name;\n            case RoomNameType.Generated:\n                switch (state.subtype) {\n                    case \"Inviting\":\n                        return `Inviting ${memberNamesToRoomName(state.names, state.count)}`;\n                    default:\n                        return memberNamesToRoomName(state.names, state.count);\n                }\n            case RoomNameType.EmptyRoom:\n                if (state.oldName) {\n                    return `Empty room (was ${state.oldName})`;\n                } else {\n                    return \"Empty room\";\n                }\n        }\n    }\n\n    /**\n     * This is an internal method. Calculates the name of the room from the current\n     * room state.\n     * @param userId - The client's user ID. Used to filter room members\n     * correctly.\n     * @param ignoreRoomNameEvent - Return the implicit room name that we'd see if there\n     * was no m.room.name event.\n     * @returns The calculated room name.\n     */\n    private calculateRoomName(userId: string, ignoreRoomNameEvent = false): string {\n        if (!ignoreRoomNameEvent) {\n            // check for an alias, if any. for now, assume first alias is the\n            // official one.\n            const mRoomName = this.currentState.getStateEvents(EventType.RoomName, \"\");\n            if (mRoomName?.getContent().name) {\n                return this.roomNameGenerator({\n                    type: RoomNameType.Actual,\n                    name: mRoomName.getContent().name,\n                });\n            }\n        }\n\n        const alias = this.getCanonicalAlias();\n        if (alias) {\n            return this.roomNameGenerator({\n                type: RoomNameType.Actual,\n                name: alias,\n            });\n        }\n\n        const joinedMemberCount = this.currentState.getJoinedMemberCount();\n        const invitedMemberCount = this.currentState.getInvitedMemberCount();\n        // -1 because these numbers include the syncing user\n        let inviteJoinCount = joinedMemberCount + invitedMemberCount - 1;\n\n        // get service members (e.g. helper bots) for exclusion\n        const excludedUserIds = this.getFunctionalMembers();\n\n        // get members that are NOT ourselves and are actually in the room.\n        let otherNames: string[] = [];\n        if (this.summaryHeroes) {\n            // if we have a summary, the member state events should be in the room state\n            this.summaryHeroes.forEach((userId) => {\n                // filter service members\n                if (excludedUserIds.includes(userId)) {\n                    inviteJoinCount--;\n                    return;\n                }\n                const member = this.getMember(userId);\n                otherNames.push(member ? member.name : userId);\n            });\n        } else {\n            let otherMembers = this.currentState.getMembers().filter((m) => {\n                return (\n                    m.userId !== userId &&\n                    (m.membership === KnownMembership.Invite || m.membership === KnownMembership.Join)\n                );\n            });\n            otherMembers = otherMembers.filter(({ userId }) => {\n                // filter service members\n                if (excludedUserIds.includes(userId)) {\n                    inviteJoinCount--;\n                    return false;\n                }\n                return true;\n            });\n            // make sure members have stable order\n            const collator = new Intl.Collator();\n            otherMembers.sort((a, b) => collator.compare(a.userId, b.userId));\n            // only 5 first members, immitate summaryHeroes\n            otherMembers = otherMembers.slice(0, 5);\n            otherNames = otherMembers.map((m) => m.name);\n        }\n\n        if (inviteJoinCount) {\n            return this.roomNameGenerator({\n                type: RoomNameType.Generated,\n                names: otherNames,\n                count: inviteJoinCount,\n            });\n        }\n\n        const myMembership = this.getMyMembership();\n        // if I have created a room and invited people through\n        // 3rd party invites\n        if (myMembership == KnownMembership.Join) {\n            const thirdPartyInvites = this.currentState.getStateEvents(EventType.RoomThirdPartyInvite);\n\n            if (thirdPartyInvites?.length) {\n                const thirdPartyNames = thirdPartyInvites.map((i) => {\n                    return i.getContent().display_name;\n                });\n\n                return this.roomNameGenerator({\n                    type: RoomNameType.Generated,\n                    subtype: \"Inviting\",\n                    names: thirdPartyNames,\n                    count: thirdPartyNames.length + 1,\n                });\n            }\n        }\n\n        // let's try to figure out who was here before\n        let leftNames = otherNames;\n        // if we didn't have heroes, try finding them in the room state\n        if (!leftNames.length) {\n            leftNames = this.currentState\n                .getMembers()\n                .filter((m) => {\n                    return (\n                        m.userId !== userId &&\n                        m.membership !== KnownMembership.Invite &&\n                        m.membership !== KnownMembership.Join\n                    );\n                })\n                .map((m) => m.name);\n        }\n\n        let oldName: string | undefined;\n        if (leftNames.length) {\n            oldName = this.roomNameGenerator({\n                type: RoomNameType.Generated,\n                names: leftNames,\n                count: leftNames.length + 1,\n            });\n        }\n\n        return this.roomNameGenerator({\n            type: RoomNameType.EmptyRoom,\n            oldName,\n        });\n    }\n\n    /**\n     * When we receive a new visibility change event:\n     *\n     * - store this visibility change alongside the timeline, in case we\n     *   later need to apply it to an event that we haven't received yet;\n     * - if we have already received the event whose visibility has changed,\n     *   patch it to reflect the visibility change and inform listeners.\n     */\n    private applyNewVisibilityEvent(event: MatrixEvent): void {\n        const visibilityChange = event.asVisibilityChange();\n        if (!visibilityChange) {\n            // The event is ill-formed.\n            return;\n        }\n\n        // Ignore visibility change events that are not emitted by moderators.\n        const userId = event.getSender();\n        if (!userId) {\n            return;\n        }\n        const isPowerSufficient =\n            (EVENT_VISIBILITY_CHANGE_TYPE.name &&\n                this.currentState.maySendStateEvent(EVENT_VISIBILITY_CHANGE_TYPE.name, userId)) ||\n            (EVENT_VISIBILITY_CHANGE_TYPE.altName &&\n                this.currentState.maySendStateEvent(EVENT_VISIBILITY_CHANGE_TYPE.altName, userId));\n        if (!isPowerSufficient) {\n            // Powerlevel is insufficient.\n            return;\n        }\n\n        // Record this change in visibility.\n        // If the event is not in our timeline and we only receive it later,\n        // we may need to apply the visibility change at a later date.\n\n        const visibilityEventsOnOriginalEvent = this.visibilityEvents.get(visibilityChange.eventId);\n        if (visibilityEventsOnOriginalEvent) {\n            // It would be tempting to simply erase the latest visibility change\n            // but we need to record all of the changes in case the latest change\n            // is ever redacted.\n            //\n            // In practice, linear scans through `visibilityEvents` should be fast.\n            // However, to protect against a potential DoS attack, we limit the\n            // number of iterations in this loop.\n            let index = visibilityEventsOnOriginalEvent.length - 1;\n            const min = Math.max(\n                0,\n                visibilityEventsOnOriginalEvent.length - MAX_NUMBER_OF_VISIBILITY_EVENTS_TO_SCAN_THROUGH,\n            );\n            for (; index >= min; --index) {\n                const target = visibilityEventsOnOriginalEvent[index];\n                if (target.getTs() < event.getTs()) {\n                    break;\n                }\n            }\n            if (index === -1) {\n                visibilityEventsOnOriginalEvent.unshift(event);\n            } else {\n                visibilityEventsOnOriginalEvent.splice(index + 1, 0, event);\n            }\n        } else {\n            this.visibilityEvents.set(visibilityChange.eventId, [event]);\n        }\n\n        // Finally, let's check if the event is already in our timeline.\n        // If so, we need to patch it and inform listeners.\n\n        const originalEvent = this.findEventById(visibilityChange.eventId);\n        if (!originalEvent) {\n            return;\n        }\n        originalEvent.applyVisibilityEvent(visibilityChange);\n    }\n\n    private redactVisibilityChangeEvent(event: MatrixEvent): void {\n        // Sanity checks.\n        if (!event.isVisibilityEvent) {\n            throw new Error(\"expected a visibility change event\");\n        }\n        const relation = event.getRelation();\n        const originalEventId = relation?.event_id;\n        const visibilityEventsOnOriginalEvent = this.visibilityEvents.get(originalEventId!);\n        if (!visibilityEventsOnOriginalEvent) {\n            // No visibility changes on the original event.\n            // In particular, this change event was not recorded,\n            // most likely because it was ill-formed.\n            return;\n        }\n        const index = visibilityEventsOnOriginalEvent.findIndex((change) => change.getId() === event.getId());\n        if (index === -1) {\n            // This change event was not recorded, most likely because\n            // it was ill-formed.\n            return;\n        }\n        // Remove visibility change.\n        visibilityEventsOnOriginalEvent.splice(index, 1);\n\n        // If we removed the latest visibility change event, propagate changes.\n        if (index === visibilityEventsOnOriginalEvent.length) {\n            const originalEvent = this.findEventById(originalEventId!);\n            if (!originalEvent) {\n                return;\n            }\n            if (index === 0) {\n                // We have just removed the only visibility change event.\n                this.visibilityEvents.delete(originalEventId!);\n                originalEvent.applyVisibilityEvent();\n            } else {\n                const newEvent = visibilityEventsOnOriginalEvent[visibilityEventsOnOriginalEvent.length - 1];\n                const newVisibility = newEvent.asVisibilityChange();\n                if (!newVisibility) {\n                    // Event is ill-formed.\n                    // This breaks our invariant.\n                    throw new Error(\"at this stage, visibility changes should be well-formed\");\n                }\n                originalEvent.applyVisibilityEvent(newVisibility);\n            }\n        }\n    }\n\n    /**\n     * When we receive an event whose visibility has been altered by\n     * a (more recent) visibility change event, patch the event in\n     * place so that clients now not to display it.\n     *\n     * @param event - Any matrix event. If this event has at least one a\n     * pending visibility change event, apply the latest visibility\n     * change event.\n     */\n    private applyPendingVisibilityEvents(event: MatrixEvent): void {\n        const visibilityEvents = this.visibilityEvents.get(event.getId()!);\n        if (!visibilityEvents || visibilityEvents.length == 0) {\n            // No pending visibility change in store.\n            return;\n        }\n        const visibilityEvent = visibilityEvents[visibilityEvents.length - 1];\n        const visibilityChange = visibilityEvent.asVisibilityChange();\n        if (!visibilityChange) {\n            return;\n        }\n        if (visibilityChange.visible) {\n            // Events are visible by default, no need to apply a visibility change.\n            // Note that we need to keep the visibility changes in `visibilityEvents`,\n            // in case we later fetch an older visibility change event that is superseded\n            // by `visibilityChange`.\n        }\n        if (visibilityEvent.getTs() < event.getTs()) {\n            // Something is wrong, the visibility change cannot happen before the\n            // event. Presumably an ill-formed event.\n            return;\n        }\n        event.applyVisibilityEvent(visibilityChange);\n    }\n\n    /**\n     * Find when a client has gained thread capabilities by inspecting the oldest\n     * threaded receipt\n     * @returns the timestamp of the oldest threaded receipt\n     */\n    public getOldestThreadedReceiptTs(): number {\n        return this.oldestThreadedReceiptTs;\n    }\n\n    /**\n     * Determines if the given user has read a particular event ID with the known\n     * history of the room. This is not a definitive check as it relies only on\n     * what is available to the room at the time of execution.\n     *\n     * @param userId - The user ID to check the read state of.\n     * @param eventId - The event ID to check if the user read.\n     * @returns true if the user has read the event, false otherwise.\n     */\n    public hasUserReadEvent(userId: string, eventId: string): boolean {\n        return this.roomReceipts.hasUserReadEvent(userId, eventId);\n    }\n\n    /**\n     * Returns the most recent unthreaded receipt for a given user\n     * @param userId - the MxID of the User\n     * @returns an unthreaded Receipt. Can be undefined if receipts have been disabled\n     * or a user chooses to use private read receipts (or we have simply not received\n     * a receipt from this user yet).\n     */\n    public getLastUnthreadedReceiptFor(userId: string): Receipt | undefined {\n        return this.unthreadedReceipts.get(userId);\n    }\n\n    /**\n     * This issue should also be addressed on synapse's side and is tracked as part\n     * of https://github.com/matrix-org/synapse/issues/14837\n     *\n     *\n     * We consider a room  fully read if the current user has sent\n     * the last event in the live timeline of that context and if the read receipt\n     * we have on record matches.\n     * This also detects all unread threads and applies the same logic to those\n     * contexts\n     */\n    public fixupNotifications(userId: string): void {\n        super.fixupNotifications(userId);\n\n        const unreadThreads = this.getThreads().filter(\n            (thread) => this.getThreadUnreadNotificationCount(thread.id, NotificationCountType.Total) > 0,\n        );\n\n        for (const thread of unreadThreads) {\n            thread.fixupNotifications(userId);\n        }\n    }\n\n    /**\n     * Determine the order of two events in this room.\n     *\n     * In principle this should use the same order as the server, but in practice\n     * this is difficult for events that were not received over the Sync API. See\n     * MSC4033 for details.\n     *\n     * This implementation leans on the order of events within their timelines, and\n     * falls back to comparing event timestamps when they are in different\n     * timelines.\n     *\n     * See https://github.com/matrix-org/matrix-js-sdk/issues/3325 for where we are\n     * tracking the work to fix this.\n     *\n     * @param leftEventId - the id of the first event\n     * @param rightEventId - the id of the second event\n\n     * @returns -1 if left \\< right, 1 if left \\> right, 0 if left == right, null if\n     *          we can't tell (because we can't find the events).\n     */\n    public compareEventOrdering(leftEventId: string, rightEventId: string): number | null {\n        return compareEventOrdering(this, leftEventId, rightEventId);\n    }\n\n    /**\n     * Return true if this room has an `m.room.encryption` state event.\n     *\n     * If this returns `true`, events sent to this room should be encrypted (and `MatrixClient.sendEvent` and friends\n     * will encrypt outgoing events).\n     */\n    public hasEncryptionStateEvent(): boolean {\n        return Boolean(\n            this.getLiveTimeline().getState(EventTimeline.FORWARDS)?.getStateEvents(EventType.RoomEncryption, \"\"),\n        );\n    }\n}\n\n// a map from current event status to a list of allowed next statuses\nconst ALLOWED_TRANSITIONS: Record<EventStatus, EventStatus[]> = {\n    [EventStatus.ENCRYPTING]: [EventStatus.SENDING, EventStatus.NOT_SENT, EventStatus.CANCELLED],\n    [EventStatus.SENDING]: [EventStatus.ENCRYPTING, EventStatus.QUEUED, EventStatus.NOT_SENT, EventStatus.SENT],\n    [EventStatus.QUEUED]: [EventStatus.SENDING, EventStatus.NOT_SENT, EventStatus.CANCELLED],\n    [EventStatus.SENT]: [],\n    [EventStatus.NOT_SENT]: [EventStatus.SENDING, EventStatus.QUEUED, EventStatus.CANCELLED],\n    [EventStatus.CANCELLED]: [],\n};\n\nexport enum RoomNameType {\n    EmptyRoom,\n    Generated,\n    Actual,\n}\n\nexport interface EmptyRoomNameState {\n    type: RoomNameType.EmptyRoom;\n    oldName?: string;\n}\n\nexport interface GeneratedRoomNameState {\n    type: RoomNameType.Generated;\n    subtype?: \"Inviting\";\n    names: string[];\n    count: number;\n}\n\nexport interface ActualRoomNameState {\n    type: RoomNameType.Actual;\n    name: string;\n}\n\nexport type RoomNameState = EmptyRoomNameState | GeneratedRoomNameState | ActualRoomNameState;\n\n// Can be overriden by IMatrixClientCreateOpts::memberNamesToRoomNameFn\nfunction memberNamesToRoomName(names: string[], count: number): string {\n    const countWithoutMe = count - 1;\n    if (!names.length) {\n        return \"Empty room\";\n    } else if (names.length === 1 && countWithoutMe <= 1) {\n        return names[0];\n    } else if (names.length === 2 && countWithoutMe <= 2) {\n        return `${names[0]} and ${names[1]}`;\n    } else {\n        const plural = countWithoutMe > 1;\n        if (plural) {\n            return `${names[0]} and ${countWithoutMe} others`;\n        } else {\n            return `${names[0]} and 1 other`;\n        }\n    }\n}\n","/*\nCopyright 2015 - 2021 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { type MatrixEvent } from \"./event.ts\";\nimport { Direction } from \"./event-timeline.ts\";\n\nexport class EventContext {\n    private timeline: MatrixEvent[];\n    private ourEventIndex = 0;\n    private paginateTokens: Record<Direction, string | null> = {\n        [Direction.Backward]: null,\n        [Direction.Forward]: null,\n    };\n\n    /**\n     * Construct a new EventContext\n     *\n     * An eventcontext is used for circumstances such as search results, when we\n     * have a particular event of interest, and a bunch of events before and after\n     * it.\n     *\n     * It also stores pagination tokens for going backwards and forwards in the\n     * timeline.\n     *\n     * @param ourEvent - the event at the centre of this context\n     */\n    public constructor(public readonly ourEvent: MatrixEvent) {\n        this.timeline = [ourEvent];\n    }\n\n    /**\n     * Get the main event of interest\n     *\n     * This is a convenience function for getTimeline()[getOurEventIndex()].\n     *\n     * @returns The event at the centre of this context.\n     */\n    public getEvent(): MatrixEvent {\n        return this.timeline[this.ourEventIndex];\n    }\n\n    /**\n     * Get the list of events in this context\n     *\n     * @returns An array of MatrixEvents\n     */\n    public getTimeline(): MatrixEvent[] {\n        return this.timeline;\n    }\n\n    /**\n     * Get the index in the timeline of our event\n     */\n    public getOurEventIndex(): number {\n        return this.ourEventIndex;\n    }\n\n    /**\n     * Get a pagination token.\n     *\n     * @param backwards -   true to get the pagination token for going\n     */\n    public getPaginateToken(backwards = false): string | null {\n        return this.paginateTokens[backwards ? Direction.Backward : Direction.Forward];\n    }\n\n    /**\n     * Set a pagination token.\n     *\n     * Generally this will be used only by the matrix js sdk.\n     *\n     * @param token -        pagination token\n     * @param backwards -   true to set the pagination token for going\n     *                                   backwards in time\n     */\n    public setPaginateToken(token?: string, backwards = false): void {\n        this.paginateTokens[backwards ? Direction.Backward : Direction.Forward] = token ?? null;\n    }\n\n    /**\n     * Add more events to the timeline\n     *\n     * @param events -      new events, in timeline order\n     * @param atStart -   true to insert new events at the start\n     */\n    public addEvents(events: MatrixEvent[], atStart = false): void {\n        // TODO: should we share logic with Room.addEventsToTimeline?\n        // Should Room even use EventContext?\n\n        if (atStart) {\n            this.timeline = events.concat(this.timeline);\n            this.ourEventIndex += events.length;\n        } else {\n            this.timeline = this.timeline.concat(events);\n        }\n    }\n}\n","/*\nCopyright 2015 - 2021 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { EventContext } from \"./event-context.ts\";\nimport { type EventMapper } from \"../event-mapper.ts\";\nimport { type IResultContext, type ISearchResult } from \"../@types/search.ts\";\n\nexport class SearchResult {\n    /**\n     * Create a SearchResponse from the response to /search\n     */\n\n    public static fromJson(jsonObj: ISearchResult, eventMapper: EventMapper): SearchResult {\n        const jsonContext = jsonObj.context || ({} as IResultContext);\n        let eventsBefore = (jsonContext.events_before || []).map(eventMapper);\n        let eventsAfter = (jsonContext.events_after || []).map(eventMapper);\n\n        const context = new EventContext(eventMapper(jsonObj.result));\n\n        // Filter out any contextual events which do not correspond to the same timeline (thread or room)\n        const threadRootId = context.ourEvent.threadRootId;\n        eventsBefore = eventsBefore.filter((e) => e.threadRootId === threadRootId);\n        eventsAfter = eventsAfter.filter((e) => e.threadRootId === threadRootId);\n\n        context.setPaginateToken(jsonContext.start, true);\n        context.addEvents(eventsBefore, true);\n        context.addEvents(eventsAfter, false);\n        context.setPaginateToken(jsonContext.end, false);\n\n        return new SearchResult(jsonObj.rank, context);\n    }\n\n    /**\n     * Construct a new SearchResult\n     *\n     * @param rank -   where this SearchResult ranks in the results\n     * @param context -  the matching event and its\n     *    context\n     */\n    public constructor(\n        public readonly rank: number,\n        public readonly context: EventContext,\n    ) {}\n}\n","/*\nCopyright 2021 - 2023 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { type Optional } from \"matrix-events-sdk\";\n\nimport { type MatrixClient, PendingEventOrdering } from \"../client.ts\";\nimport { TypedReEmitter } from \"../ReEmitter.ts\";\nimport { RelationType } from \"../@types/event.ts\";\nimport { type IThreadBundledRelationship, MatrixEvent, MatrixEventEvent } from \"./event.ts\";\nimport { Direction, EventTimeline } from \"./event-timeline.ts\";\nimport { EventTimelineSet, type EventTimelineSetHandlerMap } from \"./event-timeline-set.ts\";\nimport { type NotificationCountType, type Room, RoomEvent } from \"./room.ts\";\nimport { type RoomState } from \"./room-state.ts\";\nimport { ServerControlledNamespacedValue } from \"../NamespacedValue.ts\";\nimport { logger } from \"../logger.ts\";\nimport { ReadReceipt } from \"./read-receipt.ts\";\nimport { type CachedReceiptStructure, type Receipt, ReceiptType } from \"../@types/read_receipts.ts\";\nimport { Feature, ServerSupport } from \"../feature.ts\";\n\nexport enum ThreadEvent {\n    New = \"Thread.new\",\n    Update = \"Thread.update\",\n    NewReply = \"Thread.newReply\",\n    ViewThread = \"Thread.viewThread\",\n    Delete = \"Thread.delete\",\n}\n\nexport type ThreadEmittedEvents = Exclude<ThreadEvent, ThreadEvent.New> | RoomEvent.Timeline | RoomEvent.TimelineReset;\n\nexport type ThreadEventHandlerMap = {\n    [ThreadEvent.Update]: (thread: Thread) => void;\n    [ThreadEvent.NewReply]: (thread: Thread, event: MatrixEvent) => void;\n    [ThreadEvent.ViewThread]: () => void;\n    [ThreadEvent.Delete]: (thread: Thread) => void;\n} & EventTimelineSetHandlerMap;\n\ninterface IThreadOpts {\n    room: Room;\n    client: MatrixClient;\n    pendingEventOrdering?: PendingEventOrdering;\n    receipts?: CachedReceiptStructure[];\n}\n\nexport enum FeatureSupport {\n    None = 0,\n    Experimental = 1,\n    Stable = 2,\n}\n\nexport function determineFeatureSupport(stable: boolean, unstable: boolean): FeatureSupport {\n    if (stable) {\n        return FeatureSupport.Stable;\n    } else if (unstable) {\n        return FeatureSupport.Experimental;\n    } else {\n        return FeatureSupport.None;\n    }\n}\n\nexport class Thread extends ReadReceipt<ThreadEmittedEvents, ThreadEventHandlerMap> {\n    public static hasServerSideSupport = FeatureSupport.None;\n    public static hasServerSideListSupport = FeatureSupport.None;\n    public static hasServerSideFwdPaginationSupport = FeatureSupport.None;\n\n    /**\n     * A reference to all the events ID at the bottom of the threads\n     */\n    public readonly timelineSet: EventTimelineSet;\n\n    private _currentUserParticipated = false;\n\n    private reEmitter: TypedReEmitter<ThreadEmittedEvents, ThreadEventHandlerMap>;\n\n    /**\n     * The last event in this thread, if we don't yet have this in the timeline.\n     *\n     * When we run {@link processRootEvent} (which I think happens during the\n     * setting-up of the thread), we set this to the event pointed to by the\n     * server in `latest_event` [1] that came through with the thread root.\n     *\n     * [1]: https://spec.matrix.org/v1.8/client-server-api/#server-side-aggregation-of-mthread-relationships\n     *\n     * Later, when we have populated the timeline, this is set to undefined, so\n     * that methods like {@link replyToEvent} fall through to use lastReply,\n     * which looks in the timeline for the latest event that is a \"thread reply\"\n     * i.e. directly refers to the thread root with an m.thread relation.\n     *\n     * So it looks like this is only really relevant when initialEventsFetched\n     * is false, because as soon as the initial events have been fetched, we\n     * should have a proper chunk of timeline from the pagination fetch.\n     *\n     * If all replies in this thread are redacted, this is set to the root\n     * event. I'm not clear what the meaning of this is, since usually after the\n     * initial events have been fetched, lastEvent should be undefined.\n     * In fact, the whole usage inside onRedaction looks suspect - it may be\n     * that we were thinking lastEvent always refers to the actual last event,\n     * but it only does so before initialEventsFetched becomes true.\n     *\n     * The usage of lastEvent inside {@link onEcho} looks suspicious, since I'd\n     * think we probably mean {@link replyToEvent} there - we are trying not to\n     * echo a duplicate event, and we probably want that behaviour even after\n     * initialEventsFetched has become true.\n     *\n     * -- andyb\n     */\n    private lastEvent: MatrixEvent | undefined;\n\n    private replyCount = 0;\n    private lastPendingEvent: MatrixEvent | undefined;\n    private pendingReplyCount = 0;\n\n    public readonly room: Room;\n    public readonly client: MatrixClient;\n    private readonly pendingEventOrdering: PendingEventOrdering;\n    private processRootEventPromise?: Promise<void>;\n\n    /**\n     * Whether or not we need to fetch the initial set of events for the thread. We can\n     * only do this if the server has support for it, so if it doesn't we just pretend\n     * that we've already fetched them.\n     */\n    public initialEventsFetched = !Thread.hasServerSideSupport;\n    private initalEventFetchProm: Promise<boolean> | undefined;\n\n    /**\n     * An array of events to add to the timeline once the thread has been initialised\n     * with server suppport.\n     */\n    public replayEvents: MatrixEvent[] | null = [];\n\n    public constructor(\n        public readonly id: string,\n        public rootEvent: MatrixEvent | undefined,\n        opts: IThreadOpts,\n    ) {\n        super();\n\n        // each Event in the thread adds a reemitter, so we could hit the listener limit.\n        this.setMaxListeners(1000);\n\n        if (!opts?.room) {\n            // Logging/debugging for https://github.com/vector-im/element-web/issues/22141\n            // Hope is that we end up with a more obvious stack trace.\n            throw new Error(\"element-web#22141: A thread requires a room in order to function\");\n        }\n\n        this.room = opts.room;\n        this.client = opts.client;\n        this.pendingEventOrdering = opts.pendingEventOrdering ?? PendingEventOrdering.Chronological;\n        this.timelineSet = new EventTimelineSet(\n            this.room,\n            {\n                timelineSupport: true,\n                pendingEvents: true,\n            },\n            this.client,\n            this,\n        );\n        this.reEmitter = new TypedReEmitter(this);\n\n        this.reEmitter.reEmit(this.timelineSet, [RoomEvent.Timeline, RoomEvent.TimelineReset]);\n\n        this.room.on(MatrixEventEvent.BeforeRedaction, this.onBeforeRedaction);\n        this.room.on(RoomEvent.Redaction, this.onRedaction);\n        this.room.on(RoomEvent.LocalEchoUpdated, this.onLocalEcho);\n        this.room.on(RoomEvent.TimelineReset, this.onTimelineReset);\n        this.timelineSet.on(RoomEvent.Timeline, this.onTimelineEvent);\n\n        this.processReceipts(opts.receipts);\n\n        // even if this thread is thought to be originating from this client, we initialise it as we may be in a\n        // gappy sync and a thread around this event may already exist.\n        this.updateThreadMetadata();\n        this.setEventMetadata(this.rootEvent);\n    }\n\n    private onTimelineReset = async (): Promise<void> => {\n        // We hit a gappy sync, ask the server for an update\n        await this.processRootEventPromise;\n        this.processRootEventPromise = undefined;\n    };\n\n    private async fetchRootEvent(): Promise<void> {\n        // Always fetch the root event, even if we already have it, so we can get the latest\n        // state (via unsigned).\n        try {\n            const eventData = await this.client.fetchRoomEvent(this.roomId, this.id);\n            const mapper = this.client.getEventMapper();\n            this.rootEvent = mapper(eventData); // will merge with existing event object if such is known\n        } catch (e) {\n            logger.error(\"Failed to fetch thread root to construct thread with\", e);\n        }\n        await this.processEvent(this.rootEvent);\n    }\n\n    public static setServerSideSupport(status: FeatureSupport): void {\n        Thread.hasServerSideSupport = status;\n        // XXX: This global latching behaviour is really unexpected and means that you can't undo when moving to a server without support\n        if (status !== FeatureSupport.Stable) {\n            FILTER_RELATED_BY_SENDERS.setPreferUnstable(true);\n            FILTER_RELATED_BY_REL_TYPES.setPreferUnstable(true);\n            THREAD_RELATION_TYPE.setPreferUnstable(true);\n        }\n    }\n\n    public static setServerSideListSupport(status: FeatureSupport): void {\n        Thread.hasServerSideListSupport = status;\n    }\n\n    public static setServerSideFwdPaginationSupport(status: FeatureSupport): void {\n        Thread.hasServerSideFwdPaginationSupport = status;\n    }\n\n    private onBeforeRedaction = (event: MatrixEvent, redaction: MatrixEvent): void => {\n        if (\n            event?.isRelation(THREAD_RELATION_TYPE.name) &&\n            this.room.eventShouldLiveIn(event).threadId === this.id &&\n            event.getId() !== this.id && // the root event isn't counted in the length so ignore this redaction\n            !redaction.status // only respect it when it succeeds\n        ) {\n            this.replyCount--;\n            this.updatePendingReplyCount();\n            this.emit(ThreadEvent.Update, this);\n        }\n    };\n\n    private onRedaction = async (event: MatrixEvent, room: Room, threadRootId?: string): Promise<void> => {\n        if (threadRootId !== this.id) return; // ignore redactions for other timelines\n        if (this.replyCount <= 0) {\n            for (const threadEvent of this.timeline) {\n                this.clearEventMetadata(threadEvent);\n            }\n            this.lastEvent = this.rootEvent;\n            this._currentUserParticipated = false;\n            this.emit(ThreadEvent.Delete, this);\n        } else {\n            if (this.lastEvent?.getId() === event.getAssociatedId()) {\n                // XXX: If our last event got redacted we query the server for the last event once again\n                await this.processRootEventPromise;\n                this.processRootEventPromise = undefined;\n            }\n            await this.updateThreadMetadata();\n        }\n    };\n\n    private onTimelineEvent = (\n        event: MatrixEvent,\n        room: Room | undefined,\n        toStartOfTimeline: boolean | undefined,\n    ): void => {\n        // Add a synthesized receipt when paginating forward in the timeline\n        if (!toStartOfTimeline) {\n            const sender = event.getSender();\n            if (sender && room && this.shouldSendLocalEchoReceipt(sender, event)) {\n                room.addLocalEchoReceipt(sender, event, ReceiptType.Read);\n            }\n            if (event.getId() !== this.id && event.isRelation(THREAD_RELATION_TYPE.name)) {\n                this.replyCount++;\n            }\n        }\n        this.onEcho(event, toStartOfTimeline ?? false);\n    };\n\n    private shouldSendLocalEchoReceipt(sender: string, event: MatrixEvent): boolean {\n        const recursionSupport = this.client.canSupport.get(Feature.RelationsRecursion) ?? ServerSupport.Unsupported;\n\n        if (recursionSupport === ServerSupport.Unsupported) {\n            // Normally we add a local receipt, but if we don't have\n            // recursion support, then events may arrive out of order, so we\n            // only create a receipt if it's after our existing receipt.\n            const oldReceiptEventId = this.getReadReceiptForUserId(sender)?.eventId;\n            if (oldReceiptEventId) {\n                const receiptEvent = this.findEventById(oldReceiptEventId);\n                if (receiptEvent && receiptEvent.getTs() > event.getTs()) {\n                    return false;\n                }\n            }\n        }\n\n        return true;\n    }\n\n    private onLocalEcho = (event: MatrixEvent): void => {\n        this.onEcho(event, false);\n    };\n\n    private onEcho = async (event: MatrixEvent, toStartOfTimeline: boolean): Promise<void> => {\n        if (event.threadRootId !== this.id) return; // ignore echoes for other timelines\n        if (this.lastEvent === event) return; // ignore duplicate events\n        await this.updateThreadMetadata();\n        if (!event.isRelation(THREAD_RELATION_TYPE.name)) return; // don't send a new reply event for reactions or edits\n        if (toStartOfTimeline) return; // ignore messages added to the start of the timeline\n        // Clear the lastEvent and instead start tracking locally using lastReply\n        this.lastEvent = undefined;\n        this.emit(ThreadEvent.NewReply, this, event);\n    };\n\n    public get roomState(): RoomState {\n        return this.room.getLiveTimeline().getState(EventTimeline.FORWARDS)!;\n    }\n\n    private addEventToTimeline(event: MatrixEvent, toStartOfTimeline: boolean): void {\n        if (!this.findEventById(event.getId()!)) {\n            this.timelineSet.addEventToTimeline(event, this.liveTimeline, {\n                toStartOfTimeline,\n                fromCache: false,\n                roomState: this.roomState,\n                addToState: false,\n            });\n        }\n    }\n\n    /**\n     * TEMPORARY. Only call this when MSC3981 is not available, and we have some\n     * late-arriving events to insert, because we recursively found them as part\n     * of populating a thread. When we have MSC3981 we won't need it, because\n     * they will all be supplied by the homeserver in one request, and they will\n     * already be in the right order in that response.\n     * This is a copy of addEventToTimeline above, modified to call\n     * insertEventIntoTimeline so this event is inserted into our best guess of\n     * the right place based on timestamp. (We should be using Sync Order but we\n     * don't have it.)\n     *\n     * @internal\n     */\n    public insertEventIntoTimeline(event: MatrixEvent): void {\n        const eventId = event.getId();\n        if (!eventId) {\n            return;\n        }\n        // If the event is already in this thread, bail out\n        if (this.findEventById(eventId)) {\n            return;\n        }\n        this.timelineSet.insertEventIntoTimeline(event, this.liveTimeline, this.roomState, false);\n    }\n\n    public addEvents(events: MatrixEvent[], toStartOfTimeline: boolean): void {\n        events.forEach((ev) => this.addEvent(ev, toStartOfTimeline, false));\n        this.updateThreadMetadata();\n    }\n\n    /**\n     * Add an event to the thread and updates\n     * the tail/root references if needed\n     * Will fire \"Thread.update\"\n     * @param event - The event to add\n     * @param toStartOfTimeline - whether the event is being added\n     * to the start (and not the end) of the timeline.\n     * @param emit - whether to emit the Update event if the thread was updated or not.\n     */\n    public addEvent(event: MatrixEvent, toStartOfTimeline: boolean, emit = true): void {\n        // Modify this event to point at our room's state, and mark its thread\n        // as this.\n        this.setEventMetadata(event);\n\n        // Decide whether this event is going to be added at the end of the timeline.\n        const lastReply = this.lastReply();\n        const isNewestReply = !lastReply || event.localTimestamp >= lastReply!.localTimestamp;\n\n        if (!Thread.hasServerSideSupport) {\n            // When there's no server-side support, just add it to the end of the timeline.\n            this.addEventToTimeline(event, toStartOfTimeline);\n            this.client.decryptEventIfNeeded(event);\n        } else if (event.isRelation(RelationType.Annotation) || event.isRelation(RelationType.Replace)) {\n            this.addRelatedThreadEvent(event, toStartOfTimeline);\n            return;\n        } else if (!toStartOfTimeline && isNewestReply) {\n            // When we've asked for the event to be added to the end,\n            // and this event belongs at the end, add it.\n            this.addEventToTimeline(event, false);\n            this.fetchEditsWhereNeeded(event);\n        } else {\n            // Otherwise, we should add it, but we suspect it is out of order.\n            // This may be because we've just created the thread object and are\n            // still fetching events, in which case add it where we think is sensible\n            // and it will be removed and replaced with the events from the pagination\n            // request once that completes.\n            if (toStartOfTimeline) {\n                // If we're adding at the start of the timeline, it doesn't\n                // matter that it's out of order.\n                this.addEventToTimeline(event, toStartOfTimeline);\n            } else {\n                // We think this event might be out of order, because isNewestReply\n                // is false (otherwise we would have gone into the earlier if\n                // clause), so try to insert it in the right place based on\n                // timestamp.\n                this.insertEventIntoTimeline(event);\n            }\n        }\n\n        if (\n            event.getId() !== this.id &&\n            event.isRelation(THREAD_RELATION_TYPE.name) &&\n            !toStartOfTimeline &&\n            isNewestReply\n        ) {\n            // Clear the last event as we have the latest end of the timeline\n            this.lastEvent = undefined;\n        }\n\n        if (emit) {\n            this.emit(ThreadEvent.NewReply, this, event);\n            this.updateThreadMetadata();\n        }\n    }\n\n    private addRelatedThreadEvent(event: MatrixEvent, toStartOfTimeline: boolean): void {\n        // If this event is not a direct member of the thread, but is a\n        // reference to something that is, then we have two cases:\n\n        if (!this.initialEventsFetched) {\n            // Case 1: we haven't yet fetched events from the server. In\n            // this case, when we do, the events we get back might only be\n            // the first-order ones, so this event (which is second-order -\n            // a reference to something directly in the thread) needs to be\n            // kept so we can replay it when the first-order ones turn up.\n\n            /**\n             * A thread can be fully discovered via a single sync response\n             * And when that's the case we still ask the server to do an initialisation\n             * as it's the safest to ensure we have everything.\n             * However when we are in that scenario we might loose annotation or edits\n             *\n             * This fix keeps a reference to those events and replay them once the thread\n             * has been initialised properly.\n             */\n            this.replayEvents?.push(event);\n        } else {\n            // Case 2: this is happening later, and we have a timeline. In\n            // this case, these events might be out-of order.\n            //\n            // Specifically, if the server doesn't support recursion, so we\n            // only get these events through sync, they might be coming\n            // later than the first-order ones, so we insert them based on\n            // timestamp (despite the problems with this documented in\n            // #3325).\n            //\n            // If the server does support recursion, we should have got all\n            // the interspersed events from the server when we fetched the\n            // initial events, so if they are coming via sync they should be\n            // the latest ones, so we can add them as normal.\n            //\n            // (Note that both insertEventIntoTimeline and addEventToTimeline\n            // do nothing if we have seen this event before.)\n\n            const recursionSupport =\n                this.client.canSupport.get(Feature.RelationsRecursion) ?? ServerSupport.Unsupported;\n\n            if (recursionSupport === ServerSupport.Unsupported) {\n                this.insertEventIntoTimeline(event);\n            } else {\n                this.addEventToTimeline(event, toStartOfTimeline);\n            }\n        }\n        // Apply annotations and replace relations to the relations of the timeline only\n        this.timelineSet.relations?.aggregateParentEvent(event);\n        this.timelineSet.relations?.aggregateChildEvent(event, this.timelineSet);\n    }\n\n    public async processEvent(event: Optional<MatrixEvent>): Promise<void> {\n        if (event) {\n            this.setEventMetadata(event);\n            await this.fetchEditsWhereNeeded(event);\n        }\n    }\n\n    /**\n     * Processes the receipts that were caught during initial sync\n     * When clients become aware of a thread, they try to retrieve those read receipts\n     * and apply them to the current thread\n     * @param receipts - A collection of the receipts cached from initial sync\n     */\n    private processReceipts(receipts: CachedReceiptStructure[] = []): void {\n        for (const { eventId, receiptType, userId, receipt, synthetic } of receipts) {\n            this.addReceiptToStructure(eventId, receiptType as ReceiptType, userId, receipt, synthetic);\n        }\n    }\n\n    private getRootEventBundledRelationship(rootEvent = this.rootEvent): IThreadBundledRelationship | undefined {\n        return rootEvent?.getServerAggregatedRelation<IThreadBundledRelationship>(THREAD_RELATION_TYPE.name);\n    }\n\n    private async processRootEvent(): Promise<void> {\n        const bundledRelationship = this.getRootEventBundledRelationship();\n        if (Thread.hasServerSideSupport && bundledRelationship) {\n            this.replyCount = bundledRelationship.count;\n            this._currentUserParticipated = !!bundledRelationship.current_user_participated;\n\n            const mapper = this.client.getEventMapper();\n            // re-insert roomId\n            this.lastEvent = mapper({\n                ...bundledRelationship.latest_event,\n                room_id: this.roomId,\n            });\n            this.updatePendingReplyCount();\n            await this.processEvent(this.lastEvent);\n        }\n    }\n\n    private updatePendingReplyCount(): void {\n        const unfilteredPendingEvents =\n            this.pendingEventOrdering === PendingEventOrdering.Detached ? this.room.getPendingEvents() : this.events;\n        const pendingEvents = unfilteredPendingEvents.filter(\n            (ev) =>\n                ev.threadRootId === this.id &&\n                ev.isRelation(THREAD_RELATION_TYPE.name) &&\n                ev.status !== null &&\n                ev.getId() !== this.lastEvent?.getId(),\n        );\n        this.lastPendingEvent = pendingEvents.length ? pendingEvents[pendingEvents.length - 1] : undefined;\n        this.pendingReplyCount = pendingEvents.length;\n    }\n\n    /**\n     * Reset the live timeline of all timelineSets, and start new ones.\n     *\n     * <p>This is used when /sync returns a 'limited' timeline. 'Limited' means that there's a gap between the messages\n     * /sync returned, and the last known message in our timeline. In such a case, our live timeline isn't live anymore\n     * and has to be replaced by a new one. To make sure we can continue paginating our timelines correctly, we have to\n     * set new pagination tokens on the old and the new timeline.\n     *\n     * @param backPaginationToken -   token for back-paginating the new timeline\n     * @param forwardPaginationToken - token for forward-paginating the old live timeline,\n     * if absent or null, all timelines are reset, removing old ones (including the previous live\n     * timeline which would otherwise be unable to paginate forwards without this token).\n     * Removing just the old live timeline whilst preserving previous ones is not supported.\n     */\n    public async resetLiveTimeline(\n        backPaginationToken?: string | null,\n        forwardPaginationToken?: string | null,\n    ): Promise<void> {\n        const oldLive = this.liveTimeline;\n        this.timelineSet.resetLiveTimeline(backPaginationToken ?? undefined, forwardPaginationToken ?? undefined);\n        const newLive = this.liveTimeline;\n\n        // FIXME: Remove the following as soon as https://github.com/matrix-org/synapse/issues/14830 is resolved.\n        //\n        // The pagination API for thread timelines currently can't handle the type of pagination tokens returned by sync\n        //\n        // To make this work anyway, we'll have to transform them into one of the types that the API can handle.\n        // One option is passing the tokens to /messages, which can handle sync tokens, and returns the right format.\n        // /messages does not return new tokens on requests with a limit of 0.\n        // This means our timelines might overlap a slight bit, but that's not an issue, as we deduplicate messages\n        // anyway.\n\n        let newBackward: string | undefined;\n        let oldForward: string | undefined;\n        if (backPaginationToken) {\n            const res = await this.client.createMessagesRequest(this.roomId, backPaginationToken, 1, Direction.Forward);\n            newBackward = res.end;\n        }\n        if (forwardPaginationToken) {\n            const res = await this.client.createMessagesRequest(\n                this.roomId,\n                forwardPaginationToken,\n                1,\n                Direction.Backward,\n            );\n            oldForward = res.start;\n        }\n        // Only replace the token if we don't have paginated away from this position already. This situation doesn't\n        // occur today, but if the above issue is resolved, we'd have to go down this path.\n        if (forwardPaginationToken && oldLive.getPaginationToken(Direction.Forward) === forwardPaginationToken) {\n            oldLive.setPaginationToken(oldForward ?? null, Direction.Forward);\n        }\n        if (backPaginationToken && newLive.getPaginationToken(Direction.Backward) === backPaginationToken) {\n            newLive.setPaginationToken(newBackward ?? null, Direction.Backward);\n        }\n    }\n\n    private async updateThreadFromRootEvent(): Promise<void> {\n        if (Thread.hasServerSideSupport) {\n            // Ensure we show *something* as soon as possible, we'll update it as soon as we get better data, but we\n            // don't want the thread preview to be empty if we can avoid it\n            if (!this.initialEventsFetched && !this.lastEvent) {\n                await this.processRootEvent();\n            }\n            await this.fetchRootEvent();\n        }\n        await this.processRootEvent();\n    }\n\n    private async updateThreadMetadata(): Promise<void> {\n        this.updatePendingReplyCount();\n\n        if (!this.processRootEventPromise) {\n            // We only want to do this once otherwise we end up rolling back to the last unsigned summary we have for the thread\n            this.processRootEventPromise = this.updateThreadFromRootEvent();\n        }\n        await this.processRootEventPromise;\n\n        if (!this.initialEventsFetched) {\n            if (this.initalEventFetchProm) {\n                await this.initalEventFetchProm;\n            } else {\n                // fetch initial events to allow proper pagination\n                try {\n                    // clear out any events that were added before the pagination request\n                    // completed (eg. from sync). They'll be replaced by those from the pagination.\n                    // Really, we should do this after the pagination request completes, but\n                    // paginateEventTimeline does the request and adds the events in one go, so\n                    // this would need a refactor in order to do. It's therefore possible there's\n                    // a remaining race where an event comes in while the pagination request is\n                    // happening.\n                    this.timelineSet.resetLiveTimeline();\n                    // if the thread has regular events, this will just load the last reply.\n                    // if the thread is newly created, this will load the root event.\n                    if (this.replyCount === 0 && this.rootEvent) {\n                        this.timelineSet.addEventsToTimeline([this.rootEvent], true, false, this.liveTimeline, null);\n                        this.liveTimeline.setPaginationToken(null, Direction.Backward);\n                    } else {\n                        this.initalEventFetchProm = this.client.paginateEventTimeline(this.liveTimeline, {\n                            backwards: true,\n                        });\n                        await this.initalEventFetchProm;\n                    }\n                    // We have now fetched the initial events, so set the flag. We need to do this before\n                    // we actually add the events, so `this.addEvents` knows that it can now safely add\n                    // them rather than buffer them in the pending event list. The main thing is that this\n                    // must remain false while the async fetch happens, so we don't try to add events before\n                    // the pagination has finished. The important thing is that we're not await-ing anything\n                    // else between setting this and adding events, so no races.\n                    this.initialEventsFetched = true;\n                    for (const event of this.replayEvents!) {\n                        this.addEvent(event, false);\n                    }\n                    this.replayEvents = null;\n                    // just to make sure that, if we've created a timeline window for this thread before the thread itself\n                    // existed (e.g. when creating a new thread), we'll make sure the panel is force refreshed correctly.\n                    this.emit(RoomEvent.TimelineReset, this.room, this.timelineSet, true);\n                } catch (e) {\n                    logger.error(\"Failed to load start of newly created thread: \", e);\n                    this.initialEventsFetched = false;\n                }\n            }\n        }\n\n        this.emit(ThreadEvent.Update, this);\n    }\n\n    // XXX: Workaround for https://github.com/matrix-org/matrix-spec-proposals/pull/2676/files#r827240084\n    private async fetchEditsWhereNeeded(...events: MatrixEvent[]): Promise<unknown> {\n        const recursionSupport = this.client.canSupport.get(Feature.RelationsRecursion) ?? ServerSupport.Unsupported;\n        if (recursionSupport === ServerSupport.Unsupported) {\n            return Promise.all(\n                events.filter(isAnEncryptedThreadMessage).map(async (event: MatrixEvent) => {\n                    try {\n                        const relations = await this.client.relations(\n                            this.roomId,\n                            event.getId()!,\n                            RelationType.Replace,\n                            event.getType(),\n                            {\n                                limit: 1,\n                            },\n                        );\n                        if (relations.events.length) {\n                            const editEvent = relations.events[0];\n                            event.makeReplaced(editEvent);\n                            this.insertEventIntoTimeline(editEvent);\n                        }\n                    } catch (e) {\n                        logger.error(\"Failed to load edits for encrypted thread event\", e);\n                    }\n                }),\n            );\n        }\n    }\n\n    public setEventMetadata(event: Optional<MatrixEvent>): void {\n        if (event) {\n            EventTimeline.setEventMetadata(event, this.roomState, false);\n            event.setThread(this);\n        }\n    }\n\n    public clearEventMetadata(event: Optional<MatrixEvent>): void {\n        if (event) {\n            event.setThread(undefined);\n            delete event.event?.unsigned?.[\"m.relations\"]?.[THREAD_RELATION_TYPE.name];\n        }\n    }\n\n    /**\n     * Finds an event by ID in the current thread\n     */\n    public findEventById(eventId: string): MatrixEvent | undefined {\n        return this.timelineSet.findEventById(eventId);\n    }\n\n    /**\n     * Return last reply to the thread, if known.\n     */\n    public lastReply(\n        matches: (ev: MatrixEvent) => boolean = (ev): boolean => ev.isRelation(THREAD_RELATION_TYPE.name),\n    ): MatrixEvent | null {\n        for (let i = this.timeline.length - 1; i >= 0; i--) {\n            const event = this.timeline[i];\n            if (matches(event)) {\n                return event;\n            }\n        }\n        return null;\n    }\n\n    public get roomId(): string {\n        return this.room.roomId;\n    }\n\n    /**\n     * The number of messages in the thread\n     * Only count rel_type=m.thread as we want to\n     * exclude annotations from that number\n     */\n    public get length(): number {\n        return this.replyCount + this.pendingReplyCount;\n    }\n\n    /**\n     * A getter for the last event of the thread.\n     * This might be a synthesized event, if so, it will not emit any events to listeners.\n     */\n    public get replyToEvent(): Optional<MatrixEvent> {\n        return this.lastPendingEvent ?? this.lastEvent ?? this.lastReply();\n    }\n\n    /**\n     * The live event timeline for this thread.\n     * @deprecated Present for backwards compatibility.\n     *             Use this.events instead\n     * @returns The live event timeline for this thread.\n     */\n    public get timeline(): MatrixEvent[] {\n        return this.events;\n    }\n\n    public get events(): MatrixEvent[] {\n        return this.liveTimeline.getEvents();\n    }\n\n    public has(eventId: string): boolean {\n        return this.timelineSet.findEventById(eventId) instanceof MatrixEvent;\n    }\n\n    public get hasCurrentUserParticipated(): boolean {\n        return this._currentUserParticipated;\n    }\n\n    public get liveTimeline(): EventTimeline {\n        return this.timelineSet.getLiveTimeline();\n    }\n\n    public getUnfilteredTimelineSet(): EventTimelineSet {\n        return this.timelineSet;\n    }\n\n    public addReceipt(event: MatrixEvent, synthetic: boolean): void {\n        throw new Error(\"Unsupported function on the thread model\");\n    }\n\n    /**\n     * Get the ID of the event that a given user has read up to within this thread,\n     * or null if we have received no read receipt (at all) from them.\n     * @param userId - The user ID to get read receipt event ID for\n     * @param ignoreSynthesized - If true, return only receipts that have been\n     *                            sent by the server, not implicit ones generated\n     *                            by the JS SDK.\n     * @returns ID of the latest event that the given user has read, or null.\n     */\n    public getEventReadUpTo(userId: string, ignoreSynthesized?: boolean): string | null {\n        // TODO: we think the implementation here is not right. Here is a sketch\n        // of the right answer:\n        //\n        // for event in timeline.events.reversed():\n        //     if room.hasUserReadEvent(event):\n        //         return event\n        // return null\n        //\n        // If this is too slow, we might be able to improve it by trying walking\n        // forward from the threaded receipt in this thread. We could alternate\n        // between backwards-from-front and forwards-from-threaded-receipt to\n        // improve our chances of hitting the right answer sooner.\n        //\n        // Either way, it's still fundamentally slow because we have to walk\n        // events.\n        //\n        // We also might just want to limit the time we spend on this by giving\n        // up after, say, 100 events.\n        //\n        // --- andyb\n\n        const isCurrentUser = userId === this.client.getUserId();\n        const lastReply = this.timeline[this.timeline.length - 1];\n        if (isCurrentUser && lastReply) {\n            // If the last activity in a thread is prior to the first threaded read receipt\n            // sent in the room (suggesting that it was sent before the user started\n            // using a client that supported threaded read receipts), we want to\n            // consider this thread as read.\n            const beforeFirstThreadedReceipt = lastReply.getTs() < this.room.getOldestThreadedReceiptTs();\n            const lastReplyId = lastReply.getId();\n            // Some unsent events do not have an ID, we do not want to consider them read\n            if (beforeFirstThreadedReceipt && lastReplyId) {\n                return lastReplyId;\n            }\n        }\n\n        const readUpToId = super.getEventReadUpTo(userId, ignoreSynthesized);\n\n        // Check whether the unthreaded read receipt for that user is more recent\n        // than the read receipt inside that thread.\n        if (lastReply) {\n            const unthreadedReceipt = this.room.getLastUnthreadedReceiptFor(userId);\n            if (!unthreadedReceipt) {\n                return readUpToId;\n            }\n\n            for (let i = this.timeline?.length - 1; i >= 0; --i) {\n                const ev = this.timeline[i];\n                // If we encounter the `readUpToId` we do not need to look further\n                // there is no \"more recent\" unthreaded read receipt\n                if (ev.getId() === readUpToId) return readUpToId;\n\n                // Inspecting events from most recent to oldest, we're checking\n                // whether an unthreaded read receipt is more recent that the current event.\n                // We usually prefer relying on the order of the DAG but in this scenario\n                // it is not possible and we have to rely on timestamp\n                if (ev.getTs() < unthreadedReceipt.ts) return ev.getId() ?? readUpToId;\n            }\n        }\n\n        return readUpToId;\n    }\n\n    /**\n     * Determine if the given user has read a particular event.\n     *\n     * It is invalid to call this method with an event that is not part of this thread.\n     *\n     * This is not a definitive check as it only checks the events that have been\n     * loaded client-side at the time of execution.\n     * @param userId - The user ID to check the read state of.\n     * @param eventId - The event ID to check if the user read.\n     * @returns True if the user has read the event, false otherwise.\n     */\n    public hasUserReadEvent(userId: string, eventId: string): boolean {\n        if (userId === this.client.getUserId()) {\n            // Consider an event read if it's part of a thread that is before the\n            // first threaded receipt sent in that room. It is likely that it is\n            // part of a thread that was created before MSC3771 was implemented.\n            // Or before the last unthreaded receipt for the logged in user\n            const beforeFirstThreadedReceipt =\n                (this.lastReply()?.getTs() ?? 0) < this.room.getOldestThreadedReceiptTs();\n            const unthreadedReceiptTs = this.room.getLastUnthreadedReceiptFor(userId)?.ts ?? 0;\n            const beforeLastUnthreadedReceipt = (this?.lastReply()?.getTs() ?? 0) < unthreadedReceiptTs;\n            if (beforeFirstThreadedReceipt || beforeLastUnthreadedReceipt) {\n                return true;\n            }\n        }\n\n        return this.room.hasUserReadEvent(userId, eventId);\n    }\n\n    public setUnread(type: NotificationCountType, count: number): void {\n        return this.room.setThreadUnreadNotificationCount(this.id, type, count);\n    }\n\n    /**\n     * Returns the most recent unthreaded receipt for a given user\n     * @param userId - the MxID of the User\n     * @returns an unthreaded Receipt. Can be undefined if receipts have been disabled\n     * or a user chooses to use private read receipts (or we have simply not received\n     * a receipt from this user yet).\n     */\n    public getLastUnthreadedReceiptFor(userId: string): Receipt | undefined {\n        return this.room.getLastUnthreadedReceiptFor(userId);\n    }\n}\n\n/**\n * Decide whether an event deserves to have its potential edits fetched.\n *\n * @returns true if this event is encrypted and is a message that is part of a\n * thread - either inside it, or a root.\n */\nfunction isAnEncryptedThreadMessage(event: MatrixEvent): boolean {\n    return event.isEncrypted() && (event.isRelation(THREAD_RELATION_TYPE.name) || event.isThreadRoot);\n}\n\nexport const FILTER_RELATED_BY_SENDERS = new ServerControlledNamespacedValue(\n    \"related_by_senders\",\n    \"io.element.relation_senders\",\n);\nexport const FILTER_RELATED_BY_REL_TYPES = new ServerControlledNamespacedValue(\n    \"related_by_rel_types\",\n    \"io.element.relation_types\",\n);\nexport const THREAD_RELATION_TYPE = new ServerControlledNamespacedValue(\"m.thread\", \"io.element.thread\");\n\nexport enum ThreadFilterType {\n    \"My\",\n    \"All\",\n}\n\nexport function threadFilterTypeToFilter(type: ThreadFilterType | null): \"all\" | \"participated\" {\n    switch (type) {\n        case ThreadFilterType.My:\n            return \"participated\";\n        default:\n            return \"all\";\n    }\n}\n","/*\nCopyright 2021 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\n// eslint-disable-next-line no-restricted-imports\nimport { EventEmitter } from \"events\";\n\n/** Events emitted by EventEmitter itself */\nexport enum EventEmitterEvents {\n    NewListener = \"newListener\",\n    RemoveListener = \"removeListener\",\n    Error = \"error\",\n}\n\ntype AnyListener = (...args: any) => any;\n\n/** Base class for types mapping from event name to the type of listeners to that event */\nexport type ListenerMap<E extends string> = { [eventName in E]: AnyListener };\n\ntype EventEmitterEventListener = (eventName: string, listener: AnyListener) => void;\ntype EventEmitterErrorListener = (error: Error) => void;\n\n/**\n * The expected type of a listener function for a particular event.\n *\n * Type parameters:\n *   * `E` - List of all events emitted by the `TypedEventEmitter`. Normally an enum type.\n *   * `A` - A type providing mappings from event names to listener types.\n *   * `T` - The name of the actual event that this listener is for. Normally one of the types in `E` or\n *           {@link EventEmitterEvents}.\n */\nexport type Listener<E extends string, A extends ListenerMap<E>, T extends E | EventEmitterEvents> = T extends E\n    ? A[T]\n    : T extends EventEmitterEvents\n      ? EventEmitterErrorListener\n      : EventEmitterEventListener;\n\n/**\n * Typed Event Emitter class which can act as a Base Model for all our model\n * and communication events.\n * This makes it much easier for us to distinguish between events, as we now need\n * to properly type this, so that our events are not stringly-based and prone\n * to silly typos.\n *\n * Type parameters:\n *  * `Events` - List of all events emitted by this `TypedEventEmitter`. Normally an enum type.\n *  * `Arguments` - A {@link ListenerMap} type providing mappings from event names to listener types.\n *  * `SuperclassArguments` - TODO: not really sure. Alternative listener mappings, I think? But only honoured for `.emit`?\n */\nexport class TypedEventEmitter<\n    Events extends string,\n    Arguments extends ListenerMap<Events>,\n    SuperclassArguments extends ListenerMap<any> = Arguments,\n> extends EventEmitter {\n    /**\n     * Alias for {@link on}.\n     */\n    public addListener<T extends Events | EventEmitterEvents>(\n        event: T,\n        listener: Listener<Events, Arguments, T>,\n    ): this {\n        return super.addListener(event, listener);\n    }\n\n    /**\n     * Synchronously calls each of the listeners registered for the event named\n     * `event`, in the order they were registered, passing the supplied arguments\n     * to each.\n     *\n     * @param event - The name of the event to emit\n     * @param args - Arguments to pass to the listener\n     * @returns `true` if the event had listeners, `false` otherwise.\n     */\n    public emit<T extends Events>(event: T, ...args: Parameters<SuperclassArguments[T]>): boolean;\n    public emit<T extends Events>(event: T, ...args: Parameters<Arguments[T]>): boolean;\n    public emit<T extends Events>(event: T, ...args: any[]): boolean {\n        return super.emit(event, ...args);\n    }\n\n    /**\n     * Similar to `emit` but calls all listeners within a `Promise.all` and returns the promise chain\n     * @param event - The name of the event to emit\n     * @param args - Arguments to pass to the listener\n     * @returns `true` if the event had listeners, `false` otherwise.\n     */\n    public async emitPromised<T extends Events>(\n        event: T,\n        ...args: Parameters<SuperclassArguments[T]>\n    ): Promise<boolean>;\n    public async emitPromised<T extends Events>(event: T, ...args: Parameters<Arguments[T]>): Promise<boolean>;\n    public async emitPromised<T extends Events>(event: T, ...args: any[]): Promise<boolean> {\n        const listeners = this.listeners(event);\n        return Promise.allSettled(listeners.map((l) => l(...args))).then(() => {\n            return listeners.length > 0;\n        });\n    }\n\n    /**\n     * Returns the number of listeners listening to the event named `event`.\n     *\n     * @param event - The name of the event being listened for\n     */\n    public listenerCount(event: Events | EventEmitterEvents): number {\n        return super.listenerCount(event);\n    }\n\n    /**\n     * Returns a copy of the array of listeners for the event named `event`.\n     */\n    public listeners(event: Events | EventEmitterEvents): ReturnType<EventEmitter[\"listeners\"]> {\n        return super.listeners(event);\n    }\n\n    /**\n     * Alias for {@link removeListener}\n     */\n    public off<T extends Events | EventEmitterEvents>(event: T, listener: Listener<Events, Arguments, T>): this {\n        return super.off(event, listener);\n    }\n\n    /**\n     * Adds the `listener` function to the end of the listeners array for the\n     * event named `event`.\n     *\n     * No checks are made to see if the `listener` has already been added. Multiple calls\n     * passing the same combination of `event` and `listener` will result in the `listener`\n     * being added, and called, multiple times.\n     *\n     * By default, event listeners are invoked in the order they are added. The\n     * {@link prependListener} method can be used as an alternative to add the\n     * event listener to the beginning of the listeners array.\n     *\n     * @param event - The name of the event.\n     * @param listener - The callback function\n     *\n     * @returns a reference to the `EventEmitter`, so that calls can be chained.\n     */\n    public on<T extends Events | EventEmitterEvents>(event: T, listener: Listener<Events, Arguments, T>): this {\n        return super.on(event, listener);\n    }\n\n    /**\n     * Adds a **one-time** `listener` function for the event named `event`. The\n     * next time `event` is triggered, this listener is removed and then invoked.\n     *\n     * Returns a reference to the `EventEmitter`, so that calls can be chained.\n     *\n     * By default, event listeners are invoked in the order they are added.\n     * The {@link prependOnceListener} method can be used as an alternative to add the\n     * event listener to the beginning of the listeners array.\n     *\n     * @param event - The name of the event.\n     * @param listener - The callback function\n     *\n     * @returns a reference to the `EventEmitter`, so that calls can be chained.\n     */\n    public once<T extends Events | EventEmitterEvents>(event: T, listener: Listener<Events, Arguments, T>): this {\n        return super.once(event, listener);\n    }\n\n    /**\n     * Adds the `listener` function to the _beginning_ of the listeners array for the\n     * event named `event`.\n     *\n     * No checks are made to see if the `listener` has already been added. Multiple calls\n     * passing the same combination of `event` and `listener` will result in the `listener`\n     * being added, and called, multiple times.\n     *\n     * @param event - The name of the event.\n     * @param listener - The callback function\n     *\n     * @returns a reference to the `EventEmitter`, so that calls can be chained.\n     */\n    public prependListener<T extends Events | EventEmitterEvents>(\n        event: T,\n        listener: Listener<Events, Arguments, T>,\n    ): this {\n        return super.prependListener(event, listener);\n    }\n\n    /**\n     * Adds a **one-time**`listener` function for the event named `event` to the _beginning_ of the listeners array.\n     * The next time `event` is triggered, this listener is removed, and then invoked.\n     *\n     * @param event - The name of the event.\n     * @param listener - The callback function\n     *\n     * @returns a reference to the `EventEmitter`, so that calls can be chained.\n     */\n    public prependOnceListener<T extends Events | EventEmitterEvents>(\n        event: T,\n        listener: Listener<Events, Arguments, T>,\n    ): this {\n        return super.prependOnceListener(event, listener);\n    }\n\n    /**\n     * Removes all listeners, or those of the specified `event`.\n     *\n     * It is bad practice to remove listeners added elsewhere in the code,\n     * particularly when the `EventEmitter` instance was created by some other\n     * component or module (e.g. sockets or file streams).\n     *\n     * @param event - The name of the event. If undefined, all listeners everywhere are removed.\n     * @returns a reference to the `EventEmitter`, so that calls can be chained.\n     */\n    public removeAllListeners(event?: Events | EventEmitterEvents): this {\n        // EventEmitter::removeAllListeners uses `arguments.length` to determine undefined case\n        if (event === undefined) {\n            return super.removeAllListeners();\n        }\n        return super.removeAllListeners(event);\n    }\n\n    /**\n     * Removes the specified `listener` from the listener array for the event named `event`.\n     *\n     * @returns a reference to the `EventEmitter`, so that calls can be chained.\n     */\n    public removeListener<T extends Events | EventEmitterEvents>(\n        event: T,\n        listener: Listener<Events, Arguments, T>,\n    ): this {\n        return super.removeListener(event, listener);\n    }\n\n    /**\n     * Returns a copy of the array of listeners for the event named `eventName`,\n     * including any wrappers (such as those created by `.once()`).\n     */\n    public rawListeners(event: Events | EventEmitterEvents): ReturnType<EventEmitter[\"rawListeners\"]> {\n        return super.rawListeners(event);\n    }\n}\n","/*\nCopyright 2015 - 2021 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { type MatrixClient } from \"../matrix.ts\";\nimport { type MatrixEvent } from \"./event.ts\";\nimport { TypedEventEmitter } from \"./typed-event-emitter.ts\";\n\nexport enum UserEvent {\n    DisplayName = \"User.displayName\",\n    AvatarUrl = \"User.avatarUrl\",\n    Presence = \"User.presence\",\n    CurrentlyActive = \"User.currentlyActive\",\n    LastPresenceTs = \"User.lastPresenceTs\",\n}\n\nexport type UserEventHandlerMap = {\n    /**\n     * Fires whenever any user's display name changes.\n     * @param event - The matrix event which caused this event to fire.\n     * @param user - The user whose User.displayName changed.\n     * @example\n     * ```\n     * matrixClient.on(\"User.displayName\", function(event, user){\n     *   var newName = user.displayName;\n     * });\n     * ```\n     */\n    [UserEvent.DisplayName]: (event: MatrixEvent | undefined, user: User) => void;\n    /**\n     * Fires whenever any user's avatar URL changes.\n     * @param event - The matrix event which caused this event to fire.\n     * @param user - The user whose User.avatarUrl changed.\n     * @example\n     * ```\n     * matrixClient.on(\"User.avatarUrl\", function(event, user){\n     *   var newUrl = user.avatarUrl;\n     * });\n     * ```\n     */\n    [UserEvent.AvatarUrl]: (event: MatrixEvent | undefined, user: User) => void;\n    /**\n     * Fires whenever any user's presence changes.\n     * @param event - The matrix event which caused this event to fire.\n     * @param user - The user whose User.presence changed.\n     * @example\n     * ```\n     * matrixClient.on(\"User.presence\", function(event, user){\n     *   var newPresence = user.presence;\n     * });\n     * ```\n     */\n    [UserEvent.Presence]: (event: MatrixEvent | undefined, user: User) => void;\n    /**\n     * Fires whenever any user's currentlyActive changes.\n     * @param event - The matrix event which caused this event to fire.\n     * @param user - The user whose User.currentlyActive changed.\n     * @example\n     * ```\n     * matrixClient.on(\"User.currentlyActive\", function(event, user){\n     *   var newCurrentlyActive = user.currentlyActive;\n     * });\n     * ```\n     */\n    [UserEvent.CurrentlyActive]: (event: MatrixEvent | undefined, user: User) => void;\n    /**\n     * Fires whenever any user's lastPresenceTs changes,\n     * ie. whenever any presence event is received for a user.\n     * @param event - The matrix event which caused this event to fire.\n     * @param user - The user whose User.lastPresenceTs changed.\n     * @example\n     * ```\n     * matrixClient.on(\"User.lastPresenceTs\", function(event, user){\n     *   var newlastPresenceTs = user.lastPresenceTs;\n     * });\n     * ```\n     */\n    [UserEvent.LastPresenceTs]: (event: MatrixEvent | undefined, user: User) => void;\n};\n\nexport class User extends TypedEventEmitter<UserEvent, UserEventHandlerMap> {\n    private modified = -1;\n\n    /**\n     * The 'displayname' of the user if known.\n     * @privateRemarks\n     * Should be read-only\n     */\n    public displayName?: string;\n    public rawDisplayName?: string;\n    /**\n     * The 'avatar_url' of the user if known.\n     * @privateRemarks\n     * Should be read-only\n     */\n    public avatarUrl?: string;\n    /**\n     * The presence status message if known.\n     * @privateRemarks\n     * Should be read-only\n     */\n    public presenceStatusMsg?: string;\n    /**\n     * The presence enum if known.\n     * @privateRemarks\n     * Should be read-only\n     */\n    public presence = \"offline\";\n    /**\n     * Timestamp (ms since the epoch) for when we last received presence data for this user.\n     * We can subtract lastActiveAgo from this to approximate an absolute value for when a user was last active.\n     * @privateRemarks\n     * Should be read-only\n     */\n    public lastActiveAgo = 0;\n    /**\n     * The time elapsed in ms since the user interacted proactively with the server,\n     * or we saw a message from the user\n     * @privateRemarks\n     * Should be read-only\n     */\n    public lastPresenceTs = 0;\n    /**\n     * Whether we should consider lastActiveAgo to be an approximation\n     * and that the user should be seen as active 'now'\n     * @privateRemarks\n     * Should be read-only\n     */\n    public currentlyActive = false;\n    /**\n     * The events describing this user.\n     * @privateRemarks\n     * Should be read-only\n     */\n    public events: {\n        /** The m.presence event for this user. */\n        presence?: MatrixEvent;\n        profile?: MatrixEvent;\n    } = {};\n\n    /**\n     * Construct a new User. A User must have an ID and can optionally have extra information associated with it.\n     * @param userId - Required. The ID of this user.\n     * @deprecated use `User.createUser`\n     */\n    public constructor(public readonly userId: string) {\n        super();\n        this.displayName = userId;\n        this.rawDisplayName = userId;\n        this.updateModifiedTime();\n    }\n\n    /**\n     * Construct a new User whose events will also emit on MatrixClient.\n     * A User must have an ID and can optionally have extra information associated with it.\n     * @param userId - Required. The ID of this user.\n     * @param client - An instance of MatrixClient object\n     * @returns User object with reEmitter setup on client\n     */\n    public static createUser(userId: string, client: MatrixClient): User {\n        const user = new User(userId);\n        client.reEmitter.reEmit(user, [\n            UserEvent.AvatarUrl,\n            UserEvent.DisplayName,\n            UserEvent.Presence,\n            UserEvent.CurrentlyActive,\n            UserEvent.LastPresenceTs,\n        ]);\n        return user;\n    }\n\n    /**\n     * Update this User with the given presence event. May fire \"User.presence\",\n     * \"User.avatarUrl\" and/or \"User.displayName\" if this event updates this user's\n     * properties.\n     * @param event - The `m.presence` event.\n     *\n     * @remarks\n     * Fires {@link UserEvent.Presence}\n     * Fires {@link UserEvent.DisplayName}\n     * Fires {@link UserEvent.AvatarUrl}\n     */\n    public setPresenceEvent(event: MatrixEvent): void {\n        if (event.getType() !== \"m.presence\") {\n            return;\n        }\n        const firstFire = this.events.presence === null;\n        this.events.presence = event;\n\n        const eventsToFire: UserEvent[] = [];\n        if (event.getContent().presence !== this.presence || firstFire) {\n            eventsToFire.push(UserEvent.Presence);\n        }\n        if (event.getContent().avatar_url && event.getContent().avatar_url !== this.avatarUrl) {\n            eventsToFire.push(UserEvent.AvatarUrl);\n        }\n        if (event.getContent().displayname && event.getContent().displayname !== this.displayName) {\n            eventsToFire.push(UserEvent.DisplayName);\n        }\n        if (\n            event.getContent().currently_active !== undefined &&\n            event.getContent().currently_active !== this.currentlyActive\n        ) {\n            eventsToFire.push(UserEvent.CurrentlyActive);\n        }\n\n        this.presence = event.getContent().presence;\n        eventsToFire.push(UserEvent.LastPresenceTs);\n\n        if (event.getContent().status_msg) {\n            this.presenceStatusMsg = event.getContent().status_msg;\n        }\n        if (event.getContent().displayname) {\n            this.displayName = event.getContent().displayname;\n        }\n        if (event.getContent().avatar_url) {\n            this.avatarUrl = event.getContent().avatar_url;\n        }\n        this.lastActiveAgo = event.getContent().last_active_ago;\n        this.lastPresenceTs = Date.now();\n        this.currentlyActive = event.getContent().currently_active;\n\n        this.updateModifiedTime();\n\n        for (const eventToFire of eventsToFire) {\n            this.emit(eventToFire, event, this);\n        }\n    }\n\n    /**\n     * Manually set this user's display name. No event is emitted in response to this\n     * as there is no underlying MatrixEvent to emit with.\n     * @param name - The new display name.\n     */\n    public setDisplayName(name: string): void {\n        const oldName = this.displayName;\n        this.displayName = name;\n        if (name !== oldName) {\n            this.updateModifiedTime();\n        }\n    }\n\n    /**\n     * Manually set this user's non-disambiguated display name. No event is emitted\n     * in response to this as there is no underlying MatrixEvent to emit with.\n     * @param name - The new display name.\n     */\n    public setRawDisplayName(name?: string): void {\n        this.rawDisplayName = name;\n    }\n\n    /**\n     * Manually set this user's avatar URL. No event is emitted in response to this\n     * as there is no underlying MatrixEvent to emit with.\n     * @param url - The new avatar URL.\n     */\n    public setAvatarUrl(url?: string): void {\n        const oldUrl = this.avatarUrl;\n        this.avatarUrl = url;\n        if (url !== oldUrl) {\n            this.updateModifiedTime();\n        }\n    }\n\n    /**\n     * Update the last modified time to the current time.\n     */\n    private updateModifiedTime(): void {\n        this.modified = Date.now();\n    }\n\n    /**\n     * Get the timestamp when this User was last updated. This timestamp is\n     * updated when this User receives a new Presence event which has updated a\n     * property on this object. It is updated <i>before</i> firing events.\n     * @returns The timestamp\n     */\n    public getLastModifiedTime(): number {\n        return this.modified;\n    }\n\n    /**\n     * Get the absolute timestamp when this User was last known active on the server.\n     * It is *NOT* accurate if this.currentlyActive is true.\n     * @returns The timestamp\n     */\n    public getLastActiveTs(): number {\n        return this.lastPresenceTs - this.lastActiveAgo;\n    }\n}\n","/*\nCopyright 2023 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { type IdTokenClaims, Log, OidcClient, SigninResponse, SigninState, WebStorageStateStore } from \"oidc-client-ts\";\n\nimport { logger } from \"../logger.ts\";\nimport { secureRandomString } from \"../randomstring.ts\";\nimport { OidcError } from \"./error.ts\";\nimport {\n    type BearerTokenResponse,\n    type UserState,\n    validateBearerTokenResponse,\n    type ValidatedAuthMetadata,\n    validateIdToken,\n    validateStoredUserState,\n} from \"./validate.ts\";\nimport { sha256 } from \"../digest.ts\";\nimport { encodeUnpaddedBase64Url } from \"../base64.ts\";\n\n// reexport for backwards compatibility\nexport type { BearerTokenResponse };\n\n/**\n * Authorization parameters which are used in the authentication request of an OIDC auth code flow.\n *\n * See https://openid.net/specs/openid-connect-basic-1_0.html#RequestParameters.\n */\nexport type AuthorizationParams = {\n    state: string;\n    scope: string;\n    redirectUri: string;\n    codeVerifier: string;\n    nonce: string;\n};\n\n/**\n * @experimental\n * Generate the scope used in authorization request with OIDC OP\n * @returns scope\n */\nexport const generateScope = (deviceId?: string): string => {\n    const safeDeviceId = deviceId ?? secureRandomString(10);\n    return `openid urn:matrix:org.matrix.msc2967.client:api:* urn:matrix:org.matrix.msc2967.client:device:${safeDeviceId}`;\n};\n\n// https://www.rfc-editor.org/rfc/rfc7636\nconst generateCodeChallenge = async (codeVerifier: string): Promise<string> => {\n    if (!globalThis.crypto.subtle) {\n        // @TODO(kerrya) should this be allowed? configurable?\n        logger.warn(\"A secure context is required to generate code challenge. Using plain text code challenge\");\n        return codeVerifier;\n    }\n\n    const hashBuffer = await sha256(codeVerifier);\n    return encodeUnpaddedBase64Url(hashBuffer);\n};\n\n/**\n * Generate authorization params to pass to {@link generateAuthorizationUrl}.\n *\n * Used as part of an authorization code OIDC flow: see https://openid.net/specs/openid-connect-basic-1_0.html#CodeFlow.\n *\n * @param redirectUri - absolute url for OP to redirect to after authorization\n * @returns AuthorizationParams\n */\nexport const generateAuthorizationParams = ({ redirectUri }: { redirectUri: string }): AuthorizationParams => ({\n    scope: generateScope(),\n    redirectUri,\n    state: secureRandomString(8),\n    nonce: secureRandomString(8),\n    codeVerifier: secureRandomString(64), // https://tools.ietf.org/html/rfc7636#section-4.1 length needs to be 43-128 characters\n});\n\n/**\n * @deprecated use generateOidcAuthorizationUrl\n * Generate a URL to attempt authorization with the OP\n * See https://openid.net/specs/openid-connect-basic-1_0.html#CodeRequest\n * @param authorizationUrl - endpoint to attempt authorization with the OP\n * @param clientId - id of this client as registered with the OP\n * @param authorizationParams - params to be used in the url\n * @returns a Promise with the url as a string\n */\nexport const generateAuthorizationUrl = async (\n    authorizationUrl: string,\n    clientId: string,\n    { scope, redirectUri, state, nonce, codeVerifier }: AuthorizationParams,\n): Promise<string> => {\n    const url = new URL(authorizationUrl);\n    url.searchParams.append(\"response_mode\", \"query\");\n    url.searchParams.append(\"response_type\", \"code\");\n    url.searchParams.append(\"redirect_uri\", redirectUri);\n    url.searchParams.append(\"client_id\", clientId);\n    url.searchParams.append(\"state\", state);\n    url.searchParams.append(\"scope\", scope);\n    url.searchParams.append(\"nonce\", nonce);\n\n    url.searchParams.append(\"code_challenge_method\", \"S256\");\n    url.searchParams.append(\"code_challenge\", await generateCodeChallenge(codeVerifier));\n\n    return url.toString();\n};\n\n/**\n * @experimental\n * Generate a URL to attempt authorization with the OP\n * See https://openid.net/specs/openid-connect-basic-1_0.html#CodeRequest\n * @param metadata - validated metadata from OP discovery\n * @param clientId - this client's id as registered with the OP\n * @param homeserverUrl - used to establish the session on return from the OP\n * @param identityServerUrl - used to establish the session on return from the OP\n * @param nonce - state\n * @param prompt - indicates to the OP which flow the user should see - eg login or registration\n *          See https://openid.net/specs/openid-connect-prompt-create-1_0.html#name-prompt-parameter\n * @param urlState - value to append to the opaque state identifier to uniquely identify the callback\n * @returns a Promise with the url as a string\n */\nexport const generateOidcAuthorizationUrl = async ({\n    metadata,\n    redirectUri,\n    clientId,\n    homeserverUrl,\n    identityServerUrl,\n    nonce,\n    prompt,\n    urlState,\n}: {\n    clientId: string;\n    metadata: ValidatedAuthMetadata;\n    homeserverUrl: string;\n    identityServerUrl?: string;\n    redirectUri: string;\n    nonce: string;\n    prompt?: string;\n    urlState?: string;\n}): Promise<string> => {\n    const scope = generateScope();\n    const oidcClient = new OidcClient({\n        ...metadata,\n        client_id: clientId,\n        redirect_uri: redirectUri,\n        authority: metadata.issuer,\n        response_mode: \"query\",\n        response_type: \"code\",\n        scope,\n        stateStore: new WebStorageStateStore({ prefix: \"mx_oidc_\", store: window.sessionStorage }),\n    });\n    const userState: UserState = { homeserverUrl, nonce, identityServerUrl };\n    const request = await oidcClient.createSigninRequest({\n        state: userState,\n        nonce,\n        prompt,\n        url_state: urlState,\n    });\n\n    return request.url;\n};\n\n/**\n * Normalize token_type to use capital case to make consuming the token response easier\n * token_type is case insensitive, and it is spec-compliant for OPs to return token_type: \"bearer\"\n * Later, when used in auth headers it is case sensitive and must be Bearer\n * See: https://datatracker.ietf.org/doc/html/rfc6749#section-4.1.4\n *\n * @param response - validated token response\n * @returns response with token_type set to 'Bearer'\n */\nconst normalizeBearerTokenResponseTokenType = (response: SigninResponse): BearerTokenResponse =>\n    ({\n        id_token: response.id_token,\n        scope: response.scope,\n        expires_at: response.expires_at,\n        refresh_token: response.refresh_token,\n        access_token: response.access_token,\n        token_type: \"Bearer\",\n    }) as BearerTokenResponse;\n\n/**\n * @experimental\n * Attempt to exchange authorization code for bearer token.\n *\n * Takes the authorization code returned by the OpenID Provider via the authorization URL, and makes a\n * request to the Token Endpoint, to obtain the access token, refresh token, etc.\n *\n * @param code - authorization code as returned by OP during authorization\n * @param storedAuthorizationParams - stored params from start of oidc login flow\n * @returns valid bearer token response\n * @throws An `Error` with `message` set to an entry in {@link OidcError},\n *      when the request fails, or the returned token response is invalid.\n */\nexport const completeAuthorizationCodeGrant = async (\n    code: string,\n    state: string,\n): Promise<{\n    oidcClientSettings: { clientId: string; issuer: string };\n    tokenResponse: BearerTokenResponse;\n    homeserverUrl: string;\n    idTokenClaims: IdTokenClaims;\n    identityServerUrl?: string;\n}> => {\n    /**\n     * Element Web strips and changes the url on starting the app\n     * Use the code and state from query params to rebuild a url\n     * so that oidc-client can parse it\n     */\n    const reconstructedUrl = new URL(window.location.origin);\n    reconstructedUrl.searchParams.append(\"code\", code);\n    reconstructedUrl.searchParams.append(\"state\", state);\n\n    // set oidc-client to use our logger\n    Log.setLogger(logger);\n    try {\n        const response = new SigninResponse(reconstructedUrl.searchParams);\n\n        const stateStore = new WebStorageStateStore({ prefix: \"mx_oidc_\", store: window.sessionStorage });\n\n        // retrieve the state we put in storage at the start of oidc auth flow\n        const stateString = await stateStore.get(response.state!);\n        if (!stateString) {\n            throw new Error(OidcError.MissingOrInvalidStoredState);\n        }\n\n        // hydrate the sign in state and create a client\n        // the stored sign in state includes oidc configuration we set at the start of the oidc login flow\n        const signInState = await SigninState.fromStorageString(stateString);\n        const client = new OidcClient({ ...signInState, stateStore });\n\n        // validate the code and state, and attempt to swap the code for tokens\n        const signinResponse = await client.processSigninResponse(reconstructedUrl.href);\n\n        // extra values we stored at the start of the login flow\n        // used to complete login in the client\n        const userState = signinResponse.userState;\n        validateStoredUserState(userState);\n\n        // throws when response is invalid\n        validateBearerTokenResponse(signinResponse);\n        // throws when token is invalid\n        validateIdToken(signinResponse.id_token, client.settings.authority, client.settings.client_id, userState.nonce);\n        const normalizedTokenResponse = normalizeBearerTokenResponseTokenType(signinResponse);\n\n        return {\n            oidcClientSettings: {\n                clientId: client.settings.client_id,\n                issuer: client.settings.authority,\n            },\n            tokenResponse: normalizedTokenResponse,\n            homeserverUrl: userState.homeserverUrl,\n            identityServerUrl: userState.identityServerUrl,\n            idTokenClaims: signinResponse.profile,\n        };\n    } catch (error) {\n        logger.error(\"Oidc login failed\", error);\n        const errorType = (error as Error).message;\n\n        // rethrow errors that we recognise\n        if (Object.values(OidcError).includes(errorType as any)) {\n            throw error;\n        }\n        throw new Error(OidcError.CodeExchangeFailed);\n    }\n};\n","/*\nCopyright 2023 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\n/**\n * Errors expected to be encountered during OIDC discovery, client registration, and authentication.\n * Not intended to be displayed directly to the user.\n */\nexport enum OidcError {\n    NotSupported = \"OIDC authentication not supported\",\n    Misconfigured = \"OIDC is misconfigured\",\n    General = \"Something went wrong with OIDC discovery\",\n    OpSupport = \"Configured OIDC OP does not support required functions\",\n    DynamicRegistrationNotSupported = \"Dynamic registration not supported\",\n    DynamicRegistrationFailed = \"Dynamic registration failed\",\n    DynamicRegistrationInvalid = \"Dynamic registration invalid response\",\n    CodeExchangeFailed = \"Failed to exchange code for token\",\n    InvalidBearerTokenResponse = \"Invalid bearer token response\",\n    InvalidIdToken = \"Invalid ID token\",\n    MissingOrInvalidStoredState = \"State required to finish logging in is not found in storage.\",\n}\n","/*\nCopyright 2023 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { MetadataService, OidcClientSettingsStore } from \"oidc-client-ts\";\n\nimport { validateAuthMetadata } from \"./validate.ts\";\nimport { Method, timeoutSignal } from \"../http-api/index.ts\";\nimport { type OidcClientConfig } from \"./index.ts\";\n\n/**\n * @experimental\n * Discover and validate delegated auth configuration\n * - delegated auth issuer openid-configuration is reachable\n * - delegated auth issuer openid-configuration is configured correctly for us\n * Fetches https://oidc-issuer.example.com/.well-known/openid-configuration and other files linked therein.\n * When successful, validated metadata is returned\n * @param issuer - the OIDC issuer as returned by the /auth_issuer API\n * @returns validated authentication metadata and optionally signing keys\n * @throws when delegated auth config is invalid or unreachable\n * @deprecated in favour of {@link MatrixClient#getAuthMetadata}\n */\nexport const discoverAndValidateOIDCIssuerWellKnown = async (issuer: string): Promise<OidcClientConfig> => {\n    const issuerOpenIdConfigUrl = new URL(\".well-known/openid-configuration\", issuer);\n    const issuerWellKnownResponse = await fetch(issuerOpenIdConfigUrl, {\n        method: Method.Get,\n        signal: timeoutSignal(5000),\n    });\n    const issuerWellKnown = await issuerWellKnownResponse.json();\n    return validateAuthMetadataAndKeys(issuerWellKnown);\n};\n\n/**\n * @experimental\n * Validate the authentication metadata and fetch the signing keys from the jwks_uri in the metadata\n * @param authMetadata - the authentication metadata to validate\n * @returns validated authentication metadata and signing keys\n */\nexport const validateAuthMetadataAndKeys = async (authMetadata: unknown): Promise<OidcClientConfig> => {\n    const validatedIssuerConfig = validateAuthMetadata(authMetadata);\n\n    // create a temporary settings store, so we can use metadata service for discovery\n    const settings = new OidcClientSettingsStore({\n        authority: validatedIssuerConfig.issuer,\n        metadata: validatedIssuerConfig,\n        redirect_uri: \"\", // Not known yet, this is here to make the type checker happy\n        client_id: \"\", // Not known yet, this is here to make the type checker happy\n    });\n    const metadataService = new MetadataService(settings);\n\n    return {\n        ...validatedIssuerConfig,\n        signingKeys: await metadataService.getSigningKeys(),\n    };\n};\n","/*\nCopyright 2023 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { type OidcClientConfig } from \"./index.ts\";\nimport { OidcError } from \"./error.ts\";\nimport { Method } from \"../http-api/index.ts\";\nimport { logger } from \"../logger.ts\";\nimport { type NonEmptyArray } from \"../@types/common.ts\";\n\n/**\n * Client metadata passed to registration endpoint\n */\nexport type OidcRegistrationClientMetadata = {\n    clientName: OidcRegistrationRequestBody[\"client_name\"];\n    clientUri: OidcRegistrationRequestBody[\"client_uri\"];\n    logoUri?: OidcRegistrationRequestBody[\"logo_uri\"];\n    applicationType: OidcRegistrationRequestBody[\"application_type\"];\n    redirectUris: OidcRegistrationRequestBody[\"redirect_uris\"];\n    contacts: OidcRegistrationRequestBody[\"contacts\"];\n    tosUri: OidcRegistrationRequestBody[\"tos_uri\"];\n    policyUri: OidcRegistrationRequestBody[\"policy_uri\"];\n};\n\n/**\n * Request body for dynamic registration as defined by https://github.com/matrix-org/matrix-spec-proposals/pull/2966\n */\ninterface OidcRegistrationRequestBody {\n    client_name?: string;\n    client_uri: string;\n    logo_uri?: string;\n    contacts?: string[];\n    tos_uri?: string;\n    policy_uri?: string;\n    redirect_uris?: NonEmptyArray<string>;\n    response_types?: NonEmptyArray<string>;\n    grant_types?: NonEmptyArray<string>;\n    id_token_signed_response_alg?: string;\n    token_endpoint_auth_method: string;\n    application_type: \"web\" | \"native\";\n}\n\nexport const DEVICE_CODE_SCOPE = \"urn:ietf:params:oauth:grant-type:device_code\";\n\n// Check that URIs have a common base, as per the MSC2966 definition\nconst urlHasCommonBase = (base: URL, urlStr?: string): boolean => {\n    if (!urlStr) return false;\n    const url = new URL(urlStr);\n    if (url.protocol !== base.protocol) return false;\n    if (url.hostname !== base.hostname && !url.hostname.endsWith(`.${base.hostname}`)) return false;\n    return true;\n};\n\n/**\n * Attempts dynamic registration against the configured registration endpoint.\n * Will ignore any URIs that do not use client_uri as a common base as per the spec.\n * @param delegatedAuthConfig - Auth config from {@link discoverAndValidateOIDCIssuerWellKnown}\n * @param clientMetadata - The metadata for the client which to register\n * @returns Promise<string> resolved with registered clientId\n * @throws when registration is not supported, on failed request or invalid response\n */\nexport const registerOidcClient = async (\n    delegatedAuthConfig: OidcClientConfig,\n    clientMetadata: OidcRegistrationClientMetadata,\n): Promise<string> => {\n    if (!delegatedAuthConfig.registration_endpoint) {\n        throw new Error(OidcError.DynamicRegistrationNotSupported);\n    }\n\n    const grantTypes: NonEmptyArray<string> = [\"authorization_code\", \"refresh_token\"];\n    if (grantTypes.some((scope) => !delegatedAuthConfig.grant_types_supported.includes(scope))) {\n        throw new Error(OidcError.DynamicRegistrationNotSupported);\n    }\n\n    const commonBase = new URL(clientMetadata.clientUri);\n\n    // https://openid.net/specs/openid-connect-registration-1_0.html\n    const metadata: OidcRegistrationRequestBody = {\n        client_name: clientMetadata.clientName,\n        client_uri: clientMetadata.clientUri,\n        response_types: [\"code\"],\n        grant_types: grantTypes,\n        redirect_uris: clientMetadata.redirectUris,\n        id_token_signed_response_alg: \"RS256\",\n        token_endpoint_auth_method: \"none\",\n        application_type: clientMetadata.applicationType,\n        contacts: clientMetadata.contacts,\n        logo_uri: urlHasCommonBase(commonBase, clientMetadata.logoUri) ? clientMetadata.logoUri : undefined,\n        policy_uri: urlHasCommonBase(commonBase, clientMetadata.policyUri) ? clientMetadata.policyUri : undefined,\n        tos_uri: urlHasCommonBase(commonBase, clientMetadata.tosUri) ? clientMetadata.tosUri : undefined,\n    };\n\n    const headers = {\n        \"Accept\": \"application/json\",\n        \"Content-Type\": \"application/json\",\n    };\n\n    try {\n        const response = await fetch(delegatedAuthConfig.registration_endpoint, {\n            method: Method.Post,\n            headers,\n            body: JSON.stringify(metadata),\n        });\n\n        if (response.status >= 400) {\n            throw new Error(OidcError.DynamicRegistrationFailed);\n        }\n\n        const body = await response.json();\n        const clientId = body[\"client_id\"];\n        if (!clientId || typeof clientId !== \"string\") {\n            throw new Error(OidcError.DynamicRegistrationInvalid);\n        }\n\n        return clientId;\n    } catch (error) {\n        if (Object.values(OidcError).includes((error as Error).message as OidcError)) {\n            throw error;\n        } else {\n            logger.error(\"Dynamic registration request failed\", error);\n            throw new Error(OidcError.DynamicRegistrationFailed);\n        }\n    }\n};\n","/*\nCopyright 2023 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { type IdTokenClaims, OidcClient, WebStorageStateStore } from \"oidc-client-ts\";\n\nimport { type AccessTokens } from \"../http-api/index.ts\";\nimport { generateScope } from \"./authorize.ts\";\nimport { discoverAndValidateOIDCIssuerWellKnown } from \"./discovery.ts\";\nimport { logger } from \"../logger.ts\";\n\n/**\n * @experimental\n * Class responsible for refreshing OIDC access tokens\n *\n * Client implementations will likely want to override {@link persistTokens} to persist tokens after successful refresh\n *\n */\nexport class OidcTokenRefresher {\n    /**\n     * Promise which will complete once the OidcClient has been initialised\n     * and is ready to start refreshing tokens.\n     *\n     * Will reject if the client initialisation fails.\n     */\n    public readonly oidcClientReady!: Promise<void>;\n    private oidcClient!: OidcClient;\n    private inflightRefreshRequest?: Promise<AccessTokens>;\n\n    public constructor(\n        /**\n         * The OIDC issuer as returned by the /auth_issuer API\n         */\n        issuer: string,\n        /**\n         * id of this client as registered with the OP\n         */\n        clientId: string,\n        /**\n         * redirectUri as registered with OP\n         */\n        redirectUri: string,\n        /**\n         * Device ID of current session\n         */\n        deviceId: string,\n        /**\n         * idTokenClaims as returned from authorization grant\n         * used to validate tokens\n         */\n        private readonly idTokenClaims: IdTokenClaims,\n    ) {\n        this.oidcClientReady = this.initialiseOidcClient(issuer, clientId, deviceId, redirectUri);\n    }\n\n    private async initialiseOidcClient(\n        issuer: string,\n        clientId: string,\n        deviceId: string,\n        redirectUri: string,\n    ): Promise<void> {\n        try {\n            const config = await discoverAndValidateOIDCIssuerWellKnown(issuer);\n\n            const scope = generateScope(deviceId);\n\n            this.oidcClient = new OidcClient({\n                metadata: config,\n                signingKeys: config.signingKeys ?? undefined,\n                client_id: clientId,\n                scope,\n                redirect_uri: redirectUri,\n                authority: config.issuer,\n                stateStore: new WebStorageStateStore({ prefix: \"mx_oidc_\", store: window.sessionStorage }),\n            });\n        } catch (error) {\n            logger.error(\"Failed to initialise OIDC client.\", error);\n            throw new Error(\"Failed to initialise OIDC client.\");\n        }\n    }\n\n    /**\n     * Attempt token refresh using given refresh token\n     * @param refreshToken - refresh token to use in request with token issuer\n     * @returns tokens - Promise that resolves with new access and refresh tokens\n     * @throws when token refresh fails\n     */\n    public async doRefreshAccessToken(refreshToken: string): Promise<AccessTokens> {\n        if (!this.inflightRefreshRequest) {\n            this.inflightRefreshRequest = this.getNewTokens(refreshToken);\n        }\n        try {\n            const tokens = await this.inflightRefreshRequest;\n            return tokens;\n        } finally {\n            this.inflightRefreshRequest = undefined;\n        }\n    }\n\n    /**\n     * Persist the new tokens, called after tokens are successfully refreshed.\n     *\n     * This function is intended to be overriden by the consumer when persistence is necessary.\n     *\n     * @param tokens.accessToken - new access token\n     * @param tokens.refreshToken - OPTIONAL new refresh token\n     */\n    public async persistTokens(tokens: { accessToken: string; refreshToken?: string }): Promise<void> {\n        // NOOP\n    }\n\n    private async getNewTokens(refreshToken: string): Promise<AccessTokens> {\n        if (!this.oidcClient) {\n            throw new Error(\"Cannot get new token before OIDC client is initialised.\");\n        }\n\n        const refreshTokenState = {\n            refresh_token: refreshToken,\n            session_state: \"test\",\n            data: undefined,\n            profile: this.idTokenClaims,\n        };\n\n        const response = await this.oidcClient.useRefreshToken({\n            state: refreshTokenState,\n            timeoutInSeconds: 300,\n        });\n\n        const tokens = {\n            accessToken: response.access_token,\n            refreshToken: response.refresh_token,\n        };\n\n        await this.persistTokens(tokens);\n\n        return tokens;\n    }\n}\n","export class InvalidTokenError extends Error {\n}\nInvalidTokenError.prototype.name = \"InvalidTokenError\";\nfunction b64DecodeUnicode(str) {\n    return decodeURIComponent(atob(str).replace(/(.)/g, (m, p) => {\n        let code = p.charCodeAt(0).toString(16).toUpperCase();\n        if (code.length < 2) {\n            code = \"0\" + code;\n        }\n        return \"%\" + code;\n    }));\n}\nfunction base64UrlDecode(str) {\n    let output = str.replace(/-/g, \"+\").replace(/_/g, \"/\");\n    switch (output.length % 4) {\n        case 0:\n            break;\n        case 2:\n            output += \"==\";\n            break;\n        case 3:\n            output += \"=\";\n            break;\n        default:\n            throw new Error(\"base64 string is not of the correct length\");\n    }\n    try {\n        return b64DecodeUnicode(output);\n    }\n    catch (err) {\n        return atob(output);\n    }\n}\nexport function jwtDecode(token, options) {\n    if (typeof token !== \"string\") {\n        throw new InvalidTokenError(\"Invalid token specified: must be a string\");\n    }\n    options || (options = {});\n    const pos = options.header === true ? 0 : 1;\n    const part = token.split(\".\")[pos];\n    if (typeof part !== \"string\") {\n        throw new InvalidTokenError(`Invalid token specified: missing part #${pos + 1}`);\n    }\n    let decoded;\n    try {\n        decoded = base64UrlDecode(part);\n    }\n    catch (e) {\n        throw new InvalidTokenError(`Invalid token specified: invalid base64 for part #${pos + 1} (${e.message})`);\n    }\n    try {\n        return JSON.parse(decoded);\n    }\n    catch (e) {\n        throw new InvalidTokenError(`Invalid token specified: invalid json for part #${pos + 1} (${e.message})`);\n    }\n}\n","/*\nCopyright 2023 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { jwtDecode } from \"jwt-decode\";\nimport { type IdTokenClaims, type OidcMetadata, type SigninResponse } from \"oidc-client-ts\";\n\nimport { logger } from \"../logger.ts\";\nimport { OidcError } from \"./error.ts\";\n\n/**\n * Metadata from OIDC authority discovery\n * With validated properties required in type\n */\nexport type ValidatedAuthMetadata = Partial<OidcMetadata> &\n    Pick<\n        OidcMetadata,\n        | \"issuer\"\n        | \"authorization_endpoint\"\n        | \"token_endpoint\"\n        | \"revocation_endpoint\"\n        | \"response_types_supported\"\n        | \"grant_types_supported\"\n        | \"code_challenge_methods_supported\"\n    > & {\n        // MSC2965 extensions to the OIDC spec\n        account_management_uri?: string;\n        account_management_actions_supported?: string[];\n        // The OidcMetadata type from oidc-client-ts does not include `prompt_values_supported`\n        // even though it is part of the OIDC spec\n        prompt_values_supported?: string[];\n    };\n\nconst isRecord = (value: unknown): value is Record<string, unknown> =>\n    !!value && typeof value === \"object\" && !Array.isArray(value);\nconst requiredStringProperty = (wellKnown: Record<string, unknown>, key: string): boolean => {\n    if (!wellKnown[key] || !optionalStringProperty(wellKnown, key)) {\n        logger.error(`Missing or invalid property: ${key}`);\n        return false;\n    }\n    return true;\n};\nconst optionalStringProperty = (wellKnown: Record<string, unknown>, key: string): boolean => {\n    if (!!wellKnown[key] && typeof wellKnown[key] !== \"string\") {\n        logger.error(`Invalid property: ${key}`);\n        return false;\n    }\n    return true;\n};\nconst optionalStringArrayProperty = (wellKnown: Record<string, unknown>, key: string): boolean => {\n    if (\n        !!wellKnown[key] &&\n        (!Array.isArray(wellKnown[key]) || !(<unknown[]>wellKnown[key]).every((v) => typeof v === \"string\"))\n    ) {\n        logger.error(`Invalid property: ${key}`);\n        return false;\n    }\n    return true;\n};\nconst requiredArrayValue = (wellKnown: Record<string, unknown>, key: string, value: any): boolean => {\n    const array = wellKnown[key];\n    if (!array || !Array.isArray(array) || !array.includes(value)) {\n        logger.error(`Invalid property: ${key}. ${value} is required.`);\n        return false;\n    }\n    return true;\n};\n\n/**\n * Validates issuer `.well-known/openid-configuration`\n * As defined in RFC5785 https://openid.net/specs/openid-connect-discovery-1_0.html\n * validates that OP is compatible with Element's OIDC flow\n * @param authMetadata - json object\n * @returns valid issuer config\n * @throws Error - when issuer config is not found or is invalid\n */\nexport const validateAuthMetadata = (authMetadata: unknown): ValidatedAuthMetadata => {\n    if (!isRecord(authMetadata)) {\n        logger.error(\"Issuer configuration not found or malformed\");\n        throw new Error(OidcError.OpSupport);\n    }\n\n    const isInvalid = [\n        requiredStringProperty(authMetadata, \"issuer\"),\n        requiredStringProperty(authMetadata, \"authorization_endpoint\"),\n        requiredStringProperty(authMetadata, \"token_endpoint\"),\n        requiredStringProperty(authMetadata, \"revocation_endpoint\"),\n        optionalStringProperty(authMetadata, \"registration_endpoint\"),\n        optionalStringProperty(authMetadata, \"account_management_uri\"),\n        optionalStringProperty(authMetadata, \"device_authorization_endpoint\"),\n        optionalStringArrayProperty(authMetadata, \"account_management_actions_supported\"),\n        requiredArrayValue(authMetadata, \"response_types_supported\", \"code\"),\n        requiredArrayValue(authMetadata, \"grant_types_supported\", \"authorization_code\"),\n        requiredArrayValue(authMetadata, \"code_challenge_methods_supported\", \"S256\"),\n        optionalStringArrayProperty(authMetadata, \"prompt_values_supported\"),\n    ].some((isValid) => !isValid);\n\n    if (!isInvalid) {\n        return authMetadata as ValidatedAuthMetadata;\n    }\n\n    logger.error(\"Issuer configuration not valid\");\n    throw new Error(OidcError.OpSupport);\n};\n\nexport const decodeIdToken = (token: string): IdTokenClaims => {\n    try {\n        return jwtDecode<IdTokenClaims>(token);\n    } catch (error) {\n        logger.error(\"Could not decode id_token\", error);\n        throw error;\n    }\n};\n\n/**\n * Validate idToken\n * https://openid.net/specs/openid-connect-core-1_0.html#IDTokenValidation\n * @param idToken - id token from token endpoint\n * @param issuer - issuer for the OP as found during discovery\n * @param clientId - this client's id as registered with the OP\n * @param nonce - nonce used in the authentication request\n * @throws when id token is invalid\n */\nexport const validateIdToken = (\n    idToken: string | undefined,\n    issuer: string,\n    clientId: string,\n    nonce: string | undefined,\n): void => {\n    try {\n        if (!idToken) {\n            throw new Error(\"No ID token\");\n        }\n        const claims = decodeIdToken(idToken);\n\n        // The Issuer Identifier for the OpenID Provider MUST exactly match the value of the iss (issuer) Claim.\n        if (claims.iss !== issuer) {\n            throw new Error(\"Invalid issuer\");\n        }\n        /**\n         * The Client MUST validate that the aud (audience) Claim contains its client_id value registered at the Issuer identified by the iss (issuer) Claim as an audience.\n         * The aud (audience) Claim MAY contain an array with more than one element.\n         * The ID Token MUST be rejected if the ID Token does not list the Client as a valid audience, or if it contains additional audiences not trusted by the Client.\n         * EW: Don't accept tokens with other untrusted audiences\n         * */\n        const sanitisedAuds = typeof claims.aud === \"string\" ? [claims.aud] : claims.aud;\n        if (!sanitisedAuds.includes(clientId)) {\n            throw new Error(\"Invalid audience\");\n        }\n\n        /**\n         * If a nonce value was sent in the Authentication Request, a nonce Claim MUST be present and its value checked\n         * to verify that it is the same value as the one that was sent in the Authentication Request.\n         */\n        if (nonce !== undefined && claims.nonce !== nonce) {\n            throw new Error(\"Invalid nonce\");\n        }\n\n        /**\n         * The current time MUST be before the time represented by the exp Claim.\n         *  exp is an epoch timestamp in seconds\n         * */\n        if (!claims.exp || Date.now() > claims.exp * 1000) {\n            throw new Error(\"Invalid expiry\");\n        }\n    } catch (error) {\n        logger.error(\"Invalid ID token\", error);\n        throw new Error(OidcError.InvalidIdToken);\n    }\n};\n\n/**\n * State we ask OidcClient to store when starting oidc authorization flow (in `generateOidcAuthorizationUrl`)\n * so that we can access it on return from the OP and complete login\n */\nexport type UserState = {\n    /**\n     * Remember which server we were trying to login to\n     */\n    homeserverUrl: string;\n    identityServerUrl?: string;\n    /**\n     * Used to validate id token\n     */\n    nonce: string;\n};\n/**\n * Validate stored user state exists and is valid\n * @param userState - userState returned by oidcClient.processSigninResponse\n * @throws when userState is invalid\n */\nexport function validateStoredUserState(userState: unknown): asserts userState is UserState {\n    if (!isRecord(userState)) {\n        logger.error(\"Stored user state not found\");\n        throw new Error(OidcError.MissingOrInvalidStoredState);\n    }\n    const isInvalid = [\n        requiredStringProperty(userState, \"homeserverUrl\"),\n        requiredStringProperty(userState, \"nonce\"),\n        optionalStringProperty(userState, \"identityServerUrl\"),\n    ].some((isValid) => !isValid);\n\n    if (isInvalid) {\n        throw new Error(OidcError.MissingOrInvalidStoredState);\n    }\n}\n\n/**\n * The expected response type from the token endpoint during authorization code flow\n * Normalized to always use capitalized 'Bearer' for token_type\n *\n * See https://datatracker.ietf.org/doc/html/rfc6749#section-4.1.4,\n * https://openid.net/specs/openid-connect-basic-1_0.html#TokenOK.\n */\nexport type BearerTokenResponse = {\n    token_type: \"Bearer\";\n    access_token: string;\n    scope: string;\n    refresh_token?: string;\n    expires_in?: number;\n    // from oidc-client-ts\n    expires_at?: number;\n    id_token: string;\n};\n\n/**\n * Make required properties required in type\n */\ntype ValidSignInResponse = SigninResponse &\n    BearerTokenResponse & {\n        token_type: \"Bearer\" | \"bearer\";\n    };\n\nconst isValidBearerTokenResponse = (response: unknown): response is ValidSignInResponse =>\n    isRecord(response) &&\n    requiredStringProperty(response, \"token_type\") &&\n    // token_type is case insensitive, some OPs return `token_type: \"bearer\"`\n    (response[\"token_type\"] as string).toLowerCase() === \"bearer\" &&\n    requiredStringProperty(response, \"access_token\") &&\n    requiredStringProperty(response, \"refresh_token\") &&\n    (!(\"expires_in\" in response) || typeof response[\"expires_in\"] === \"number\");\n\nexport function validateBearerTokenResponse(response: unknown): asserts response is ValidSignInResponse {\n    if (!isValidBearerTokenResponse(response)) {\n        throw new Error(OidcError.InvalidBearerTokenResponse);\n    }\n}\n","/*\nCopyright 2015 - 2021 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { deepCompare, escapeRegExp, globToRegexp, isNullOrUndefined } from \"./utils.ts\";\nimport { logger } from \"./logger.ts\";\nimport { type MatrixClient } from \"./client.ts\";\nimport { type MatrixEvent } from \"./models/event.ts\";\nimport {\n    ConditionKind,\n    type IAnnotatedPushRule,\n    type ICallStartedCondition,\n    type ICallStartedPrefixCondition,\n    type IContainsDisplayNameCondition,\n    type IEventMatchCondition,\n    type IEventPropertyContainsCondition,\n    type IEventPropertyIsCondition,\n    type IPushRule,\n    type IPushRules,\n    type IRoomMemberCountCondition,\n    type ISenderNotificationPermissionCondition,\n    type PushRuleAction,\n    PushRuleActionName,\n    type PushRuleCondition,\n    PushRuleKind,\n    type PushRuleSet,\n    RuleId,\n    TweakName,\n} from \"./@types/PushRules.ts\";\nimport { EventType } from \"./@types/event.ts\";\n\nconst RULEKINDS_IN_ORDER = [\n    PushRuleKind.Override,\n    PushRuleKind.ContentSpecific,\n    PushRuleKind.RoomSpecific,\n    PushRuleKind.SenderSpecific,\n    PushRuleKind.Underride,\n];\n\n// The default override rules to apply to the push rules that arrive from the server.\n// We do this for two reasons:\n//   1. Synapse is unlikely to send us the push rule in an incremental sync - see\n//      https://github.com/matrix-org/synapse/pull/4867#issuecomment-481446072 for\n//      more details.\n//   2. We often want to start using push rules ahead of the server supporting them,\n//      and so we can put them here.\nconst DEFAULT_OVERRIDE_RULES: Record<string, IPushRule> = {\n    \".m.rule.is_room_mention\": {\n        // Matrix v1.7\n        rule_id: \".m.rule.is_room_mention\",\n        default: true,\n        enabled: true,\n        conditions: [\n            {\n                kind: ConditionKind.EventPropertyIs,\n                key: \"content.m\\\\.mentions.room\",\n                value: true,\n            },\n            {\n                kind: ConditionKind.SenderNotificationPermission,\n                key: \"room\",\n            },\n        ],\n        actions: [\n            PushRuleActionName.Notify,\n            {\n                set_tweak: TweakName.Highlight,\n            },\n        ],\n    },\n    \".m.rule.reaction\": {\n        // For homeservers which don't support MSC2153 yet\n        rule_id: \".m.rule.reaction\",\n        default: true,\n        enabled: true,\n        conditions: [\n            {\n                kind: ConditionKind.EventMatch,\n                key: \"type\",\n                pattern: \"m.reaction\",\n            },\n        ],\n        actions: [PushRuleActionName.DontNotify],\n    },\n    \".org.matrix.msc3786.rule.room.server_acl\": {\n        // For homeservers which don't support MSC3786 yet\n        rule_id: \".org.matrix.msc3786.rule.room.server_acl\",\n        default: true,\n        enabled: true,\n        conditions: [\n            {\n                kind: ConditionKind.EventMatch,\n                key: \"type\",\n                pattern: EventType.RoomServerAcl,\n            },\n            {\n                kind: ConditionKind.EventMatch,\n                key: \"state_key\",\n                pattern: \"\",\n            },\n        ],\n        actions: [],\n    },\n};\n\n// A special rule id for `EXPECTED_DEFAULT_OVERRIDE_RULE_IDS` and friends which denotes where user-defined rules live in the order.\nconst UserDefinedRules = Symbol(\"UserDefinedRules\");\n\ntype OrderedRules = Array<string | typeof UserDefinedRules>;\n\nconst EXPECTED_DEFAULT_OVERRIDE_RULE_IDS: OrderedRules = [\n    RuleId.Master,\n    UserDefinedRules,\n    RuleId.SuppressNotices,\n    RuleId.InviteToSelf,\n    RuleId.MemberEvent,\n    RuleId.IsUserMention,\n    RuleId.ContainsDisplayName,\n    RuleId.IsRoomMention,\n    RuleId.AtRoomNotification,\n    RuleId.Tombstone,\n    \".m.rule.reaction\",\n    \".m.rule.room.server_acl\",\n    \".org.matrix.msc3786.rule.room.server_acl\",\n    \".m.rule.suppress_edits\",\n];\n\nconst DEFAULT_UNDERRIDE_RULES: Record<string, IPushRule> = {\n    \".org.matrix.msc3914.rule.room.call\": {\n        // For homeservers which don't support MSC3914 yet\n        rule_id: \".org.matrix.msc3914.rule.room.call\",\n        default: true,\n        enabled: true,\n        conditions: [\n            {\n                kind: ConditionKind.EventMatch,\n                key: \"type\",\n                pattern: \"org.matrix.msc3401.call\",\n            },\n            {\n                kind: ConditionKind.CallStarted,\n            },\n        ],\n        actions: [PushRuleActionName.Notify, { set_tweak: TweakName.Sound, value: \"default\" }],\n    },\n};\n\nconst EXPECTED_DEFAULT_UNDERRIDE_RULE_IDS: OrderedRules = [\n    UserDefinedRules,\n    RuleId.IncomingCall,\n    \".org.matrix.msc3914.rule.room.call\",\n    RuleId.EncryptedDM,\n    RuleId.DM,\n    RuleId.Message,\n    RuleId.EncryptedMessage,\n];\n\n/**\n * Make sure that each of the rules listed in `defaultRuleIds` is listed in the given set of push rules.\n *\n * @param kind - the kind of push rule set being merged.\n * @param incomingRules - the existing set of known push rules for the user.\n * @param defaultRules - a lookup table for the default definitions of push rules.\n * @param orderedRuleIds - the IDs of the expected push rules, in order.\n *\n * @returns A copy of `incomingRules`, with any missing default rules inserted in the right place.\n */\nfunction mergeRulesWithDefaults(\n    kind: PushRuleKind,\n    incomingRules: IPushRule[],\n    defaultRules: Record<string, IPushRule>,\n    orderedRuleIds: OrderedRules,\n): IPushRule[] {\n    // Split the incomingRules into defaults and custom\n    const incomingDefaultRules = incomingRules.filter((rule) => rule.default);\n    const incomingCustomRules = incomingRules.filter((rule) => !rule.default);\n\n    function insertDefaultPushRule(ruleId: OrderedRules[number]): void {\n        if (ruleId === UserDefinedRules) {\n            // Re-insert any user-defined rules that were in `incomingRules`\n            newRules.push(...incomingCustomRules);\n        } else if (ruleId in defaultRules) {\n            logger.warn(`Adding default global ${kind} push rule ${ruleId}`);\n            newRules.push(defaultRules[ruleId]);\n        } else {\n            logger.warn(`Missing default global ${kind} push rule ${ruleId}`);\n        }\n    }\n\n    let nextExpectedRuleIdIndex = 0;\n    const newRules: IPushRule[] = [];\n    // Merge our expected rules (including the incoming custom rules) into the incoming default rules.\n    for (const rule of incomingDefaultRules) {\n        const ruleIndex = orderedRuleIds.indexOf(rule.rule_id);\n        if (ruleIndex === -1) {\n            // an unrecognised rule; copy it over\n            newRules.push(rule);\n            continue;\n        }\n        while (ruleIndex > nextExpectedRuleIdIndex) {\n            // insert new rules\n            const defaultRuleId = orderedRuleIds[nextExpectedRuleIdIndex];\n            insertDefaultPushRule(defaultRuleId);\n            nextExpectedRuleIdIndex += 1;\n        }\n        // copy over the existing rule\n        newRules.push(rule);\n        nextExpectedRuleIdIndex += 1;\n    }\n\n    // Now copy over any remaining default rules\n    for (const ruleId of orderedRuleIds.slice(nextExpectedRuleIdIndex)) {\n        insertDefaultPushRule(ruleId);\n    }\n\n    return newRules;\n}\n\nexport interface IActionsObject {\n    /** Whether this event should notify the user or not. */\n    notify: boolean;\n    /** How this event should be notified. */\n    tweaks: Partial<Record<TweakName, any>>;\n}\n\nexport class PushProcessor {\n    /**\n     * Construct a Push Processor.\n     * @param client - The Matrix client object to use\n     */\n    public constructor(private readonly client: MatrixClient) {}\n\n    /**\n     * Maps the original key from the push rules to a list of property names\n     * after unescaping.\n     */\n    private readonly parsedKeys = new Map<string, string[]>();\n\n    /**\n     * Convert a list of actions into a object with the actions as keys and their values\n     * @example\n     * eg. `[ 'notify', { set_tweak: 'sound', value: 'default' } ]`\n     *     becomes `{ notify: true, tweaks: { sound: 'default' } }`\n     * @param actionList - The actions list\n     *\n     * @returns A object with key 'notify' (true or false) and an object of actions\n     */\n    public static actionListToActionsObject(actionList: PushRuleAction[]): IActionsObject {\n        const actionObj: IActionsObject = { notify: false, tweaks: {} };\n        for (const action of actionList) {\n            if (action === PushRuleActionName.Notify) {\n                actionObj.notify = true;\n            } else if (typeof action === \"object\") {\n                if (action.value === undefined) {\n                    action.value = true;\n                }\n                actionObj.tweaks[action.set_tweak] = action.value;\n            }\n        }\n        return actionObj;\n    }\n\n    /**\n     * Rewrites conditions on a client's push rules to match the defaults\n     * where applicable. Useful for upgrading push rules to more strict\n     * conditions when the server is falling behind on defaults.\n     * @param incomingRules - The client's existing push rules\n     * @param userId - The Matrix ID of the client.\n     * @returns The rewritten rules\n     */\n    public static rewriteDefaultRules(incomingRules: IPushRules, userId: string | undefined = undefined): IPushRules {\n        let newRules: IPushRules = JSON.parse(JSON.stringify(incomingRules)); // deep clone\n\n        // These lines are mostly to make the tests happy. We shouldn't run into these\n        // properties missing in practice.\n        if (!newRules) newRules = {} as IPushRules;\n        if (!newRules.global) newRules.global = {} as PushRuleSet;\n        if (!newRules.global.override) newRules.global.override = [];\n        if (!newRules.global.underride) newRules.global.underride = [];\n\n        // Merge the client-level defaults with the ones from the server\n        newRules.global.override = mergeRulesWithDefaults(\n            PushRuleKind.Override,\n            newRules.global.override,\n            DEFAULT_OVERRIDE_RULES,\n            EXPECTED_DEFAULT_OVERRIDE_RULE_IDS,\n        );\n\n        newRules.global.underride = mergeRulesWithDefaults(\n            PushRuleKind.Underride,\n            newRules.global.underride,\n            DEFAULT_UNDERRIDE_RULES,\n            EXPECTED_DEFAULT_UNDERRIDE_RULE_IDS,\n        );\n\n        return newRules;\n    }\n\n    /**\n     * Pre-caches the parsed keys for push rules and cleans out any obsolete cache\n     * entries. Should be called after push rules are updated.\n     * @param newRules - The new push rules.\n     */\n    public updateCachedPushRuleKeys(newRules: IPushRules): void {\n        // These lines are mostly to make the tests happy. We shouldn't run into these\n        // properties missing in practice.\n        if (!newRules) newRules = {} as IPushRules;\n        if (!newRules.global) newRules.global = {} as PushRuleSet;\n        if (!newRules.global.override) newRules.global.override = [];\n        if (!newRules.global.room) newRules.global.room = [];\n        if (!newRules.global.sender) newRules.global.sender = [];\n        if (!newRules.global.underride) newRules.global.underride = [];\n\n        // Process the 'key' property on event_match conditions pre-cache the\n        // values and clean-out any unused values.\n        const toRemoveKeys = new Set(this.parsedKeys.keys());\n        for (const ruleset of [\n            newRules.global.override,\n            newRules.global.room,\n            newRules.global.sender,\n            newRules.global.underride,\n        ]) {\n            for (const rule of ruleset) {\n                if (!rule.conditions) {\n                    continue;\n                }\n\n                for (const condition of rule.conditions) {\n                    if (condition.kind !== ConditionKind.EventMatch) {\n                        continue;\n                    }\n\n                    // Ensure we keep this key.\n                    toRemoveKeys.delete(condition.key);\n\n                    // Pre-process the key.\n                    this.parsedKeys.set(condition.key, PushProcessor.partsForDottedKey(condition.key));\n                }\n            }\n        }\n        // Any keys that were previously cached, but are no longer needed should\n        // be removed.\n        toRemoveKeys.forEach((k) => this.parsedKeys.delete(k));\n    }\n\n    private static cachedGlobToRegex: Record<string, RegExp> = {}; // $glob: RegExp\n\n    private matchingRuleFromKindSet(ev: MatrixEvent, kindset: PushRuleSet): IAnnotatedPushRule | null {\n        for (const kind of RULEKINDS_IN_ORDER) {\n            const ruleset = kindset[kind];\n            if (!ruleset) {\n                continue;\n            }\n\n            for (const rule of ruleset) {\n                if (!rule.enabled) {\n                    continue;\n                }\n\n                const rawrule = this.templateRuleToRaw(kind, rule);\n                if (!rawrule) {\n                    continue;\n                }\n\n                if (this.ruleMatchesEvent(rawrule, ev)) {\n                    return {\n                        ...rule,\n                        kind,\n                    };\n                }\n            }\n        }\n        return null;\n    }\n\n    private templateRuleToRaw(\n        kind: PushRuleKind,\n        tprule: IPushRule,\n    ): Pick<IPushRule, \"rule_id\" | \"actions\" | \"conditions\"> | null {\n        const rawrule: Pick<IPushRule, \"rule_id\" | \"actions\" | \"conditions\"> = {\n            rule_id: tprule.rule_id,\n            actions: tprule.actions,\n            conditions: [],\n        };\n        switch (kind) {\n            case PushRuleKind.Underride:\n            case PushRuleKind.Override:\n                rawrule.conditions = tprule.conditions;\n                break;\n            case PushRuleKind.RoomSpecific:\n                if (!tprule.rule_id) {\n                    return null;\n                }\n                rawrule.conditions!.push({\n                    kind: ConditionKind.EventMatch,\n                    key: \"room_id\",\n                    value: tprule.rule_id,\n                });\n                break;\n            case PushRuleKind.SenderSpecific:\n                if (!tprule.rule_id) {\n                    return null;\n                }\n                rawrule.conditions!.push({\n                    kind: ConditionKind.EventMatch,\n                    key: \"user_id\",\n                    value: tprule.rule_id,\n                });\n                break;\n            case PushRuleKind.ContentSpecific:\n                if (!tprule.pattern) {\n                    return null;\n                }\n                rawrule.conditions!.push({\n                    kind: ConditionKind.EventMatch,\n                    key: \"content.body\",\n                    pattern: tprule.pattern,\n                });\n                break;\n        }\n        return rawrule;\n    }\n\n    private eventFulfillsCondition(cond: PushRuleCondition, ev: MatrixEvent): boolean {\n        switch (cond.kind) {\n            case ConditionKind.EventMatch:\n                return this.eventFulfillsEventMatchCondition(cond, ev);\n            case ConditionKind.EventPropertyIs:\n                return this.eventFulfillsEventPropertyIsCondition(cond, ev);\n            case ConditionKind.EventPropertyContains:\n                return this.eventFulfillsEventPropertyContains(cond, ev);\n            case ConditionKind.ContainsDisplayName:\n                return this.eventFulfillsDisplayNameCondition(cond, ev);\n            case ConditionKind.RoomMemberCount:\n                return this.eventFulfillsRoomMemberCountCondition(cond, ev);\n            case ConditionKind.SenderNotificationPermission:\n                return this.eventFulfillsSenderNotifPermCondition(cond, ev);\n            case ConditionKind.CallStarted:\n            case ConditionKind.CallStartedPrefix:\n                return this.eventFulfillsCallStartedCondition(cond, ev);\n        }\n\n        // unknown conditions: we previously matched all unknown conditions,\n        // but given that rules can be added to the base rules on a server,\n        // it's probably better to not match unknown conditions.\n        return false;\n    }\n\n    private eventFulfillsSenderNotifPermCondition(\n        cond: ISenderNotificationPermissionCondition,\n        ev: MatrixEvent,\n    ): boolean {\n        const notifLevelKey = cond[\"key\"];\n        if (!notifLevelKey) {\n            return false;\n        }\n\n        const room = this.client.getRoom(ev.getRoomId());\n        if (!room?.currentState) {\n            return false;\n        }\n\n        // Note that this should not be the current state of the room but the state at\n        // the point the event is in the DAG. Unfortunately the js-sdk does not store\n        // this.\n        return room.currentState.mayTriggerNotifOfType(notifLevelKey, ev.getSender()!);\n    }\n\n    private eventFulfillsRoomMemberCountCondition(cond: IRoomMemberCountCondition, ev: MatrixEvent): boolean {\n        if (!cond.is) {\n            return false;\n        }\n\n        const room = this.client.getRoom(ev.getRoomId());\n        if (!room || !room.currentState || !room.currentState.members) {\n            return false;\n        }\n\n        const memberCount = room.currentState.getJoinedMemberCount();\n\n        const m = cond.is.match(/^([=<>]*)(\\d*)$/);\n        if (!m) {\n            return false;\n        }\n        const ineq = m[1];\n        const rhs = parseInt(m[2]);\n        if (isNaN(rhs)) {\n            return false;\n        }\n        switch (ineq) {\n            case \"\":\n            case \"==\":\n                return memberCount == rhs;\n            case \"<\":\n                return memberCount < rhs;\n            case \">\":\n                return memberCount > rhs;\n            case \"<=\":\n                return memberCount <= rhs;\n            case \">=\":\n                return memberCount >= rhs;\n            default:\n                return false;\n        }\n    }\n\n    private eventFulfillsDisplayNameCondition(cond: IContainsDisplayNameCondition, ev: MatrixEvent): boolean {\n        let content = ev.getContent();\n        if (ev.isEncrypted() && ev.getClearContent()) {\n            content = ev.getClearContent()!;\n        }\n        if (!content || !content.body || typeof content.body != \"string\") {\n            return false;\n        }\n\n        const room = this.client.getRoom(ev.getRoomId());\n        const member = room?.currentState?.getMember(this.client.credentials.userId!);\n        if (!member) {\n            return false;\n        }\n\n        const displayName = member.name;\n\n        // N.B. we can't use \\b as it chokes on unicode. however \\W seems to be okay\n        // as shorthand for [^0-9A-Za-z_].\n        const pat = new RegExp(\"(^|\\\\W)\" + escapeRegExp(displayName) + \"(\\\\W|$)\", \"i\");\n        return content.body.search(pat) > -1;\n    }\n\n    /**\n     * Check whether the given event matches the push rule condition by fetching\n     * the property from the event and comparing against the condition's glob-based\n     * pattern.\n     * @param cond - The push rule condition to check for a match.\n     * @param ev - The event to check for a match.\n     */\n    private eventFulfillsEventMatchCondition(cond: IEventMatchCondition, ev: MatrixEvent): boolean {\n        if (!cond.key) {\n            return false;\n        }\n\n        const val = this.valueForDottedKey(cond.key, ev);\n        if (typeof val !== \"string\") {\n            return false;\n        }\n\n        // XXX This does not match in a case-insensitive manner.\n        //\n        // See https://spec.matrix.org/v1.5/client-server-api/#conditions-1\n        if (cond.value) {\n            return cond.value === val;\n        }\n\n        if (typeof cond.pattern !== \"string\") {\n            return false;\n        }\n\n        const regex =\n            cond.key === \"content.body\"\n                ? this.createCachedRegex(\"(^|\\\\W)\", cond.pattern, \"(\\\\W|$)\")\n                : this.createCachedRegex(\"^\", cond.pattern, \"$\");\n\n        return !!val.match(regex);\n    }\n\n    /**\n     * Check whether the given event matches the push rule condition by fetching\n     * the property from the event and comparing exactly against the condition's\n     * value.\n     * @param cond - The push rule condition to check for a match.\n     * @param ev - The event to check for a match.\n     */\n    private eventFulfillsEventPropertyIsCondition(cond: IEventPropertyIsCondition, ev: MatrixEvent): boolean {\n        if (!cond.key || cond.value === undefined) {\n            return false;\n        }\n        return cond.value === this.valueForDottedKey(cond.key, ev);\n    }\n\n    /**\n     * Check whether the given event matches the push rule condition by fetching\n     * the property from the event and comparing exactly against the condition's\n     * value.\n     * @param cond - The push rule condition to check for a match.\n     * @param ev - The event to check for a match.\n     */\n    private eventFulfillsEventPropertyContains(cond: IEventPropertyContainsCondition, ev: MatrixEvent): boolean {\n        if (!cond.key || cond.value === undefined) {\n            return false;\n        }\n        const val = this.valueForDottedKey(cond.key, ev);\n        if (!Array.isArray(val)) {\n            return false;\n        }\n        return val.includes(cond.value);\n    }\n\n    private eventFulfillsCallStartedCondition(\n        _cond: ICallStartedCondition | ICallStartedPrefixCondition,\n        ev: MatrixEvent,\n    ): boolean {\n        // Since servers don't support properly sending push notification\n        // about MSC3401 call events, we do the handling ourselves\n        return (\n            [\"m.ring\", \"m.prompt\"].includes(ev.getContent()[\"m.intent\"]) &&\n            !(\"m.terminated\" in ev.getContent()) &&\n            (ev.getPrevContent()[\"m.terminated\"] !== ev.getContent()[\"m.terminated\"] ||\n                deepCompare(ev.getPrevContent(), {}))\n        );\n    }\n\n    private createCachedRegex(prefix: string, glob: string, suffix: string): RegExp {\n        if (PushProcessor.cachedGlobToRegex[glob]) {\n            return PushProcessor.cachedGlobToRegex[glob];\n        }\n        PushProcessor.cachedGlobToRegex[glob] = new RegExp(\n            prefix + globToRegexp(glob) + suffix,\n            \"i\", // Case insensitive\n        );\n        return PushProcessor.cachedGlobToRegex[glob];\n    }\n\n    /**\n     * Parse the key into the separate fields to search by splitting on\n     * unescaped \".\", and then removing any escape characters.\n     *\n     * @param str - The key of the push rule condition: a dotted field.\n     * @returns The unescaped parts to fetch.\n     * @internal\n     */\n    public static partsForDottedKey(str: string): string[] {\n        const result: string[] = [];\n\n        // The current field and whether the previous character was the escape\n        // character (a backslash).\n        let part = \"\";\n        let escaped = false;\n\n        // Iterate over each character, and decide whether to append to the current\n        // part (following the escape rules) or to start a new part (based on the\n        // field separator).\n        for (const c of str) {\n            // If the previous character was the escape character (a backslash)\n            // then decide what to append to the current part.\n            if (escaped) {\n                if (c === \"\\\\\" || c === \".\") {\n                    // An escaped backslash or dot just gets added.\n                    part += c;\n                } else {\n                    // A character that shouldn't be escaped gets the backslash prepended.\n                    part += \"\\\\\" + c;\n                }\n                // This always resets being escaped.\n                escaped = false;\n                continue;\n            }\n\n            if (c == \".\") {\n                // The field separator creates a new part.\n                result.push(part);\n                part = \"\";\n            } else if (c == \"\\\\\") {\n                // A backslash adds no characters, but starts an escape sequence.\n                escaped = true;\n            } else {\n                // Otherwise, just add the current character.\n                part += c;\n            }\n        }\n\n        // Ensure the final part is included. If there's an open escape sequence\n        // it should be included.\n        if (escaped) {\n            part += \"\\\\\";\n        }\n        result.push(part);\n\n        return result;\n    }\n\n    /**\n     * For a dotted field and event, fetch the value at that position, if one\n     * exists.\n     *\n     * @param key - The key of the push rule condition: a dotted field to fetch.\n     * @param ev - The matrix event to fetch the field from.\n     * @returns The value at the dotted path given by key.\n     */\n    private valueForDottedKey(key: string, ev: MatrixEvent): any {\n        // The key should already have been parsed via updateCachedPushRuleKeys,\n        // but if it hasn't (maybe via an old consumer of the SDK which hasn't\n        // been updated?) then lazily calculate it here.\n        let parts = this.parsedKeys.get(key);\n        if (parts === undefined) {\n            parts = PushProcessor.partsForDottedKey(key);\n            this.parsedKeys.set(key, parts);\n        }\n        let val: any;\n\n        // special-case the first component to deal with encrypted messages\n        const firstPart = parts[0];\n        let currentIndex = 0;\n        if (firstPart === \"content\") {\n            val = ev.getContent();\n            ++currentIndex;\n        } else if (firstPart === \"type\") {\n            val = ev.getType();\n            ++currentIndex;\n        } else {\n            // use the raw event for any other fields\n            val = ev.event;\n        }\n\n        for (; currentIndex < parts.length; ++currentIndex) {\n            // The previous iteration resulted in null or undefined, bail (and\n            // avoid the type error of attempting to retrieve a property).\n            if (isNullOrUndefined(val)) {\n                return undefined;\n            }\n\n            const thisPart = parts[currentIndex];\n            val = val[thisPart];\n        }\n        return val;\n    }\n\n    private matchingRuleForEventWithRulesets(ev: MatrixEvent, rulesets?: IPushRules): IAnnotatedPushRule | null {\n        if (!rulesets) {\n            return null;\n        }\n\n        if (ev.getSender() === this.client.getSafeUserId()) {\n            return null;\n        }\n\n        return this.matchingRuleFromKindSet(ev, rulesets.global);\n    }\n\n    private pushActionsForEventAndRulesets(\n        ev: MatrixEvent,\n        rulesets?: IPushRules,\n    ): {\n        actions?: IActionsObject;\n        rule?: IAnnotatedPushRule;\n    } {\n        const rule = this.matchingRuleForEventWithRulesets(ev, rulesets);\n        if (!rule) {\n            return {};\n        }\n\n        const actionObj = PushProcessor.actionListToActionsObject(rule.actions);\n\n        // Some actions are implicit in some situations: we add those here\n        if (actionObj.tweaks.highlight === undefined) {\n            // if it isn't specified, highlight if it's a content\n            // rule but otherwise not\n            actionObj.tweaks.highlight = rule.kind == PushRuleKind.ContentSpecific;\n        }\n\n        return { actions: actionObj, rule };\n    }\n\n    public ruleMatchesEvent(rule: Partial<IPushRule> & Pick<IPushRule, \"conditions\">, ev: MatrixEvent): boolean {\n        // Disable the deprecated mentions push rules if the new mentions property exists.\n        if (\n            this.client.supportsIntentionalMentions() &&\n            ev.getContent()[\"m.mentions\"] !== undefined &&\n            (rule.rule_id === RuleId.ContainsUserName ||\n                rule.rule_id === RuleId.ContainsDisplayName ||\n                rule.rule_id === RuleId.AtRoomNotification)\n        ) {\n            return false;\n        }\n\n        return !rule.conditions?.some((cond) => !this.eventFulfillsCondition(cond, ev));\n    }\n\n    /**\n     * Get the user's push actions for the given event\n     */\n    public actionsForEvent(ev: MatrixEvent): IActionsObject {\n        const { actions } = this.pushActionsForEventAndRulesets(ev, this.client.pushRules);\n        return actions || ({} as IActionsObject);\n    }\n\n    public actionsAndRuleForEvent(ev: MatrixEvent): {\n        actions?: IActionsObject;\n        rule?: IAnnotatedPushRule;\n    } {\n        return this.pushActionsForEventAndRulesets(ev, this.client.pushRules);\n    }\n\n    /**\n     * Get one of the users push rules by its ID\n     *\n     * @param ruleId - The ID of the rule to search for\n     * @returns The push rule, or null if no such rule was found\n     */\n    public getPushRuleById(ruleId: string): IPushRule | null {\n        const result = this.getPushRuleAndKindById(ruleId);\n        return result?.rule ?? null;\n    }\n\n    /**\n     * Get one of the users push rules by its ID\n     *\n     * @param ruleId - The ID of the rule to search for\n     * @returns rule The push rule, or null if no such rule was found\n     * @returns kind - The PushRuleKind of the rule to search for\n     */\n    public getPushRuleAndKindById(ruleId: string): { rule: IPushRule; kind: PushRuleKind } | null {\n        for (const scope of [\"global\"] as const) {\n            if (this.client.pushRules?.[scope] === undefined) continue;\n\n            for (const kind of RULEKINDS_IN_ORDER) {\n                if (this.client.pushRules[scope][kind] === undefined) continue;\n\n                for (const rule of this.client.pushRules[scope][kind]!) {\n                    if (rule.rule_id === ruleId) return { rule, kind };\n                }\n            }\n        }\n        return null;\n    }\n}\n","/*\nCopyright 2018 New Vector Ltd\nCopyright 2019 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { encodeUnpaddedBase64Url } from \"./base64.ts\";\n\n/**\n * String representing the lowercase latin alphabet for use in {@link secureRandomStringFrom}\n * (can be combined with other such exports or other characters by appending strings)\n */\nexport const LOWERCASE = \"abcdefghijklmnopqrstuvwxyz\";\n\n/**\n * String representing the uppercase latin alphabet for use in secureRandomStringFrom\n * (can be combined with other such exports or other characters by appending strings)\n */\nexport const UPPERCASE = \"ABCDEFGHIJKLMNOPQRSTUVWXYZ\";\n\n/**\n * String representing the arabic numerals for use in secureRandomStringFrom\n * (can be combined with other such exports or other characters by appending strings)\n */\nexport const DIGITS = \"0123456789\";\n\nexport function secureRandomBase64Url(len: number): string {\n    const key = new Uint8Array(len);\n    globalThis.crypto.getRandomValues(key);\n\n    return encodeUnpaddedBase64Url(key);\n}\n\n/**\n * Generates a random string of uppercase and lowercase letters plus digits using a\n * cryptographically secure random number generator.\n * @param len The length of the string to generate\n * @returns Random string of uppercase and lowercase letters plus digits of length `len`\n */\nexport function secureRandomString(len: number): string {\n    return secureRandomStringFrom(len, UPPERCASE + LOWERCASE + DIGITS);\n}\n\n/**\n * Generate a cryptographically secure random string using characters given.\n *\n * @param len - The length of the string to generate (must be positive and less than 32768).\n * @param chars - The characters to use in the random string (between 2 and 256 characters long).\n * @returns Random string of characters of length `len`.\n */\nexport function secureRandomStringFrom(len: number, chars: string): string {\n    // This is intended for latin strings so 256 possibilities should be more than enough and\n    // means we can use random bytes, minimising the amount of entropy we need to ask for.\n    if (chars.length < 2 || chars.length > 256) {\n        throw new Error(\"Character set must be between 2 and 256 characters long\");\n    }\n\n    if (len < 1 || len > 32768) {\n        throw new Error(\"Requested random string length must be between 1 and 32768\");\n    }\n\n    // We'll generate random unsigned bytes, so get the largest number less than 256 that is a multiple\n    // of the length of the character set: We'll need to discard any random values that are larger than\n    // this as we can't possibly map them onto the character set while keeping each character equally\n    // likely to be chosen (minus 1 to convert to indices in a string). (Essentially, we're using a d8\n    // to choose between 7 possibilities and re-rolling on an 8, keeping all 7 outcomes equally likely.)\n    // Our random values must be strictly less than this\n    const randomValueCutoff = 256 - (256 % chars.length);\n\n    // Grab 30% more entropy than we need. This should be enough that we can discard the values that are\n    // too high without having to go back and grab more unless we're super unlucky.\n    const entropyBuffer = new Uint8Array(Math.floor(len * 1.3));\n    // Mark all of this buffer as used to start with (we haven't populated it with entropy yet) so it will\n    // be filled on the first iteration.\n    let entropyBufferPos = entropyBuffer.length;\n\n    const result = [];\n    while (result.length < len) {\n        if (entropyBufferPos === entropyBuffer.length) {\n            globalThis.crypto.getRandomValues(entropyBuffer);\n            entropyBufferPos = 0;\n        }\n\n        const randomByte = entropyBuffer[entropyBufferPos++];\n\n        if (randomByte < randomValueCutoff) {\n            result.push(chars[randomByte % chars.length]);\n        }\n    }\n\n    return result.join(\"\");\n}\n","/*\nCopyright 2015 - 2021 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\n/**\n * This is an internal module which manages queuing, scheduling and retrying\n * of requests.\n */\nimport { logger } from \"./logger.ts\";\nimport { type MatrixEvent } from \"./models/event.ts\";\nimport { EventType } from \"./@types/event.ts\";\nimport { defer, type IDeferred, removeElement } from \"./utils.ts\";\nimport { calculateRetryBackoff, type MatrixError } from \"./http-api/index.ts\";\nimport { type ISendEventResponse } from \"./@types/requests.ts\";\n\nconst DEBUG = false; // set true to enable console logging.\n\ninterface IQueueEntry<T> {\n    event: MatrixEvent;\n    defer: IDeferred<T>;\n    attempts: number;\n}\n\n/**\n * The function to invoke to process (send) events in the queue.\n * @param event - The event to send.\n * @returns Resolved/rejected depending on the outcome of the request.\n */\ntype ProcessFunction<T> = (event: MatrixEvent) => Promise<T>;\n\n// eslint-disable-next-line camelcase\nexport class MatrixScheduler<T = ISendEventResponse> {\n    /**\n     * Default retry algorithm for the matrix scheduler. Retries events up to 4 times with exponential backoff.\n     * @param attempts - Number of attempts that have been made, including the one that just failed (ie. starting at 1)\n     * @see retryAlgorithm\n     */\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    public static RETRY_BACKOFF_RATELIMIT(event: MatrixEvent | null, attempts: number, err: MatrixError): number {\n        return calculateRetryBackoff(err, attempts, false);\n    }\n\n    /**\n     * Queues `m.room.message` events and lets other events continue\n     * concurrently.\n     * @see queueAlgorithm\n     */\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    public static QUEUE_MESSAGES(event: MatrixEvent): string | null {\n        // enqueue messages or events that associate with another event (redactions and relations)\n        if (event.getType() === EventType.RoomMessage || event.hasAssociation()) {\n            // put these events in the 'message' queue.\n            return \"message\";\n        }\n        // allow all other events continue concurrently.\n        return null;\n    }\n\n    // queueName: [{\n    //  event: MatrixEvent,  // event to send\n    //  defer: Deferred,  // defer to resolve/reject at the END of the retries\n    //  attempts: Number  // number of times we've called processFn\n    // }, ...]\n    private readonly queues: Record<string, IQueueEntry<T>[]> = {};\n    private activeQueues: string[] = [];\n    private procFn: ProcessFunction<T> | null = null;\n\n    /**\n     * Construct a scheduler for Matrix. Requires\n     * {@link MatrixScheduler#setProcessFunction} to be provided\n     * with a way of processing events.\n     * @param retryAlgorithm - Optional. The retry\n     * algorithm to apply when determining when to try to send an event again.\n     * Defaults to {@link MatrixScheduler.RETRY_BACKOFF_RATELIMIT}.\n     * @param queueAlgorithm - Optional. The queuing\n     * algorithm to apply when determining which events should be sent before the\n     * given event. Defaults to {@link MatrixScheduler.QUEUE_MESSAGES}.\n     */\n    public constructor(\n        /**\n         * The retry algorithm to apply when retrying events. To stop retrying, return\n         * `-1`. If this event was part of a queue, it will be removed from\n         * the queue.\n         * @param event - The event being retried.\n         * @param attempts - The number of failed attempts. This will always be \\>= 1.\n         * @param err - The most recent error message received when trying\n         * to send this event.\n         * @returns The number of milliseconds to wait before trying again. If\n         * this is 0, the request will be immediately retried. If this is\n         * `-1`, the event will be marked as\n         * {@link EventStatus.NOT_SENT} and will not be retried.\n         */\n        public readonly retryAlgorithm = MatrixScheduler.RETRY_BACKOFF_RATELIMIT,\n        /**\n         * The queuing algorithm to apply to events. This function must be idempotent as\n         * it may be called multiple times with the same event. All queues created are\n         * serviced in a FIFO manner. To send the event ASAP, return `null`\n         * which will not put this event in a queue. Events that fail to send that form\n         * part of a queue will be removed from the queue and the next event in the\n         * queue will be sent.\n         * @param event - The event to be sent.\n         * @returns The name of the queue to put the event into. If a queue with\n         * this name does not exist, it will be created. If this is `null`,\n         * the event is not put into a queue and will be sent concurrently.\n         */\n        public readonly queueAlgorithm = MatrixScheduler.QUEUE_MESSAGES,\n    ) {}\n\n    /**\n     * Retrieve a queue based on an event. The event provided does not need to be in\n     * the queue.\n     * @param event - An event to get the queue for.\n     * @returns A shallow copy of events in the queue or null.\n     * Modifying this array will not modify the list itself. Modifying events in\n     * this array <i>will</i> modify the underlying event in the queue.\n     * @see MatrixScheduler.removeEventFromQueue To remove an event from the queue.\n     */\n    public getQueueForEvent(event: MatrixEvent): MatrixEvent[] | null {\n        const name = this.queueAlgorithm(event);\n        if (!name || !this.queues[name]) {\n            return null;\n        }\n        return this.queues[name].map(function (obj) {\n            return obj.event;\n        });\n    }\n\n    /**\n     * Remove this event from the queue. The event is equal to another event if they\n     * have the same ID returned from event.getId().\n     * @param event - The event to remove.\n     * @returns True if this event was removed.\n     */\n    public removeEventFromQueue(event: MatrixEvent): boolean {\n        const name = this.queueAlgorithm(event);\n        if (!name || !this.queues[name]) {\n            return false;\n        }\n        let removed = false;\n        removeElement(this.queues[name], (element) => {\n            if (element.event.getId() === event.getId()) {\n                // XXX we should probably reject the promise?\n                // https://github.com/matrix-org/matrix-js-sdk/issues/496\n                removed = true;\n                return true;\n            }\n            return false;\n        });\n        return removed;\n    }\n\n    /**\n     * Set the process function. Required for events in the queue to be processed.\n     * If set after events have been added to the queue, this will immediately start\n     * processing them.\n     * @param fn - The function that can process events\n     * in the queue.\n     */\n    public setProcessFunction(fn: ProcessFunction<T>): void {\n        this.procFn = fn;\n        this.startProcessingQueues();\n    }\n\n    /**\n     * Queue an event if it is required and start processing queues.\n     * @param event - The event that may be queued.\n     * @returns A promise if the event was queued, which will be\n     * resolved or rejected in due time, else null.\n     */\n    public queueEvent(event: MatrixEvent): Promise<T> | null {\n        const queueName = this.queueAlgorithm(event);\n        if (!queueName) {\n            return null;\n        }\n        // add the event to the queue and make a deferred for it.\n        if (!this.queues[queueName]) {\n            this.queues[queueName] = [];\n        }\n        const deferred = defer<T>();\n        this.queues[queueName].push({\n            event: event,\n            defer: deferred,\n            attempts: 0,\n        });\n        debuglog(\"Queue algorithm dumped event %s into queue '%s'\", event.getId(), queueName);\n        this.startProcessingQueues();\n        return deferred.promise;\n    }\n\n    private startProcessingQueues(): void {\n        if (!this.procFn) return;\n        // for each inactive queue with events in them\n        Object.keys(this.queues)\n            .filter((queueName) => {\n                return this.activeQueues.indexOf(queueName) === -1 && this.queues[queueName].length > 0;\n            })\n            .forEach((queueName) => {\n                // mark the queue as active\n                this.activeQueues.push(queueName);\n                // begin processing the head of the queue\n                debuglog(\"Spinning up queue: '%s'\", queueName);\n                this.processQueue(queueName);\n            });\n    }\n\n    private processQueue = (queueName: string): void => {\n        // get head of queue\n        const obj = this.peekNextEvent(queueName);\n        if (!obj) {\n            this.disableQueue(queueName);\n            return;\n        }\n        debuglog(\"Queue '%s' has %s pending events\", queueName, this.queues[queueName].length);\n        // fire the process function and if it resolves, resolve the deferred. Else\n        // invoke the retry algorithm.\n\n        // First wait for a resolved promise, so the resolve handlers for\n        // the deferred of the previously sent event can run.\n        // This way enqueued relations/redactions to enqueued events can receive\n        // the remove id of their target before being sent.\n        Promise.resolve()\n            .then(() => {\n                return this.procFn!(obj.event);\n            })\n            .then(\n                (res) => {\n                    // remove this from the queue\n                    this.removeNextEvent(queueName);\n                    debuglog(\"Queue '%s' sent event %s\", queueName, obj.event.getId());\n                    obj.defer.resolve(res);\n                    // keep processing\n                    this.processQueue(queueName);\n                },\n                (err) => {\n                    obj.attempts += 1;\n                    // ask the retry algorithm when/if we should try again\n                    const waitTimeMs = this.retryAlgorithm(obj.event, obj.attempts, err);\n                    debuglog(\n                        \"retry(%s) err=%s event_id=%s waitTime=%s\",\n                        obj.attempts,\n                        err,\n                        obj.event.getId(),\n                        waitTimeMs,\n                    );\n                    if (waitTimeMs === -1) {\n                        // give up (you quitter!)\n                        logger.info(\"Queue '%s' giving up on event %s\", queueName, obj.event.getId());\n                        // remove this from the queue\n                        this.clearQueue(queueName, err);\n                    } else {\n                        setTimeout(this.processQueue, waitTimeMs, queueName);\n                    }\n                },\n            );\n    };\n\n    private disableQueue(queueName: string): void {\n        // queue is empty. Mark as inactive and stop recursing.\n        const index = this.activeQueues.indexOf(queueName);\n        if (index >= 0) {\n            this.activeQueues.splice(index, 1);\n        }\n        logger.info(\"Stopping queue '%s' as it is now empty\", queueName);\n    }\n\n    private clearQueue(queueName: string, err: unknown): void {\n        logger.info(\"clearing queue '%s'\", queueName);\n        let obj: IQueueEntry<T> | undefined;\n        while ((obj = this.removeNextEvent(queueName))) {\n            obj.defer.reject(err);\n        }\n        this.disableQueue(queueName);\n    }\n\n    private peekNextEvent(queueName: string): IQueueEntry<T> | undefined {\n        const queue = this.queues[queueName];\n        if (!Array.isArray(queue)) {\n            return undefined;\n        }\n        return queue[0];\n    }\n\n    private removeNextEvent(queueName: string): IQueueEntry<T> | undefined {\n        const queue = this.queues[queueName];\n        if (!Array.isArray(queue)) {\n            return undefined;\n        }\n        return queue.shift();\n    }\n}\n\n/* istanbul ignore next */\nfunction debuglog(...args: any[]): void {\n    if (DEBUG) {\n        logger.log(...args);\n    }\n}\n","/*\nCopyright 2021-2023 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\n/**\n * Implementation of server-side secret storage\n *\n * @see https://spec.matrix.org/v1.6/client-server-api/#storage\n */\n\nimport { type TypedEventEmitter } from \"./models/typed-event-emitter.ts\";\nimport { ClientEvent, type ClientEventHandlerMap } from \"./client.ts\";\nimport { type MatrixEvent } from \"./models/event.ts\";\nimport { secureRandomString } from \"./randomstring.ts\";\nimport { logger } from \"./logger.ts\";\nimport encryptAESSecretStorageItem from \"./utils/encryptAESSecretStorageItem.ts\";\nimport decryptAESSecretStorageItem from \"./utils/decryptAESSecretStorageItem.ts\";\nimport { type AESEncryptedSecretStoragePayload } from \"./@types/AESEncryptedSecretStoragePayload.ts\";\nimport { type AccountDataEvents, type SecretStorageAccountDataEvents } from \"./@types/event.ts\";\nimport { type EmptyObject } from \"./@types/common.ts\";\n\nexport const SECRET_STORAGE_ALGORITHM_V1_AES = \"m.secret_storage.v1.aes-hmac-sha2\";\n\n/**\n * Common base interface for Secret Storage Keys.\n *\n * The common properties for all encryption keys used in server-side secret storage.\n *\n * @see https://spec.matrix.org/v1.6/client-server-api/#key-storage\n */\nexport interface SecretStorageKeyDescriptionCommon {\n    /** A human-readable name for this key. */\n    // XXX: according to the spec, this is optional\n    name: string;\n\n    /** The encryption algorithm used with this key. */\n    algorithm: string;\n\n    /** Information for deriving this key from a passphrase. */\n    // XXX: according to the spec, this is optional\n    passphrase: PassphraseInfo;\n}\n\n/**\n * Properties for a SSSS key using the `m.secret_storage.v1.aes-hmac-sha2` algorithm.\n *\n * Corresponds to `AesHmacSha2KeyDescription` in the specification.\n *\n * @see https://spec.matrix.org/v1.6/client-server-api/#msecret_storagev1aes-hmac-sha2\n */\nexport interface SecretStorageKeyDescriptionAesV1 extends SecretStorageKeyDescriptionCommon {\n    // XXX: strictly speaking, we should be able to enforce the algorithm here. But\n    //   this interface ends up being incorrectly used where other algorithms are in use (notably\n    //   in device-dehydration support), and unpicking that is too much like hard work\n    //   at the moment.\n    // algorithm: \"m.secret_storage.v1.aes-hmac-sha2\";\n\n    /** The 16-byte AES initialization vector, encoded as base64. */\n    iv: string;\n\n    /** The MAC of the result of encrypting 32 bytes of 0, encoded as base64. */\n    mac: string;\n}\n\n/**\n * Union type for secret storage keys.\n *\n * For now, this is only {@link SecretStorageKeyDescriptionAesV1}, but other interfaces may be added in future.\n */\nexport type SecretStorageKeyDescription = SecretStorageKeyDescriptionAesV1;\n\n/**\n * Information on how to generate the key from a passphrase.\n *\n * @see https://spec.matrix.org/v1.6/client-server-api/#deriving-keys-from-passphrases\n */\nexport interface PassphraseInfo {\n    /** The algorithm to be used to derive the key. */\n    algorithm: \"m.pbkdf2\";\n\n    /** The number of PBKDF2 iterations to use. */\n    iterations: number;\n\n    /** The salt to be used for PBKDF2. */\n    salt: string;\n\n    /** The number of bits to generate. Defaults to 256. */\n    bits?: number;\n}\n\n/**\n * Options for {@link ServerSideSecretStorageImpl#addKey}.\n */\nexport interface AddSecretStorageKeyOpts {\n    /** Information for deriving the key from a passphrase if any. */\n    passphrase?: PassphraseInfo;\n    /** Optional name of the key. */\n    name?: string;\n    /** The private key. Will be used to generate the key check values in the key info; it will not be stored on the server */\n    key: Uint8Array;\n}\n\n/**\n * Return type for {@link ServerSideSecretStorageImpl#getKey}.\n */\nexport type SecretStorageKeyTuple = [keyId: string, keyInfo: SecretStorageKeyDescription];\n\n/**\n * Return type for {@link ServerSideSecretStorageImpl#addKey}.\n */\nexport type SecretStorageKeyObject = {\n    /** The ID of the key */\n    keyId: string;\n    /**  details about the key */\n    keyInfo: SecretStorageKeyDescription;\n};\n\n/** Interface for managing account data on the server.\n *\n * A subset of {@link MatrixClient}.\n */\nexport interface AccountDataClient extends TypedEventEmitter<ClientEvent.AccountData, ClientEventHandlerMap> {\n    /**\n     * Get account data event of given type for the current user. This variant\n     * gets account data directly from the homeserver if the local store is not\n     * ready, which can be useful very early in startup before the initial sync.\n     *\n     * @param eventType - The type of account data\n     * @returns The contents of the given account data event, or `null` if the event is not found\n     */\n    getAccountDataFromServer: <K extends keyof AccountDataEvents>(eventType: K) => Promise<AccountDataEvents[K] | null>;\n\n    /**\n     * Set account data event for the current user, with retries\n     *\n     * @param eventType - The type of account data\n     * @param content - the content object to be set\n     * @returns an empty object\n     */\n    setAccountData: <K extends keyof AccountDataEvents>(\n        eventType: K,\n        content: AccountDataEvents[K] | Record<string, never>,\n    ) => Promise<EmptyObject>;\n}\n\n/**\n *  Application callbacks for use with {@link SecretStorage.ServerSideSecretStorageImpl}\n */\nexport interface SecretStorageCallbacks {\n    /**\n     * Called to retrieve a secret storage encryption key\n     *\n     * Before a secret can be stored in server-side storage, it must be encrypted with one or more\n     * keys. Similarly, after it has been retrieved from storage, it must be decrypted with one of\n     * the keys it was encrypted with. These encryption keys are known as \"secret storage keys\".\n     *\n     * Descriptions of the secret storage keys are also stored in server-side storage, per the\n     * [matrix specification](https://spec.matrix.org/v1.6/client-server-api/#key-storage), so\n     * before a key can be used in this way, it must have been stored on the server. This is\n     * done via {@link ServerSideSecretStorage#addKey}.\n     *\n     * Obviously the keys themselves are not stored server-side, so the js-sdk calls this callback\n     * in order to retrieve a secret storage key from the application.\n     *\n     * @param keys - An options object, containing only the property `keys`.\n     *\n     * @param name - the name of the *secret* (NB: not the encryption key) being stored or retrieved.\n     *    This is the \"event type\" stored in account data.\n     *\n     * @returns a pair [`keyId`, `privateKey`], where `keyId` is one of the keys from the `keys` parameter,\n     *    and `privateKey` is the raw private encryption key, as appropriate for the encryption algorithm.\n     *    (For `m.secret_storage.v1.aes-hmac-sha2`, it is the input to an HKDF as defined in the\n     *    [specification](https://spec.matrix.org/v1.6/client-server-api/#msecret_storagev1aes-hmac-sha2).)\n     *\n     *    Alternatively, if none of the keys are known, may return `null` — in which case the original\n     *    storage/retrieval operation will fail with an exception.\n     */\n    getSecretStorageKey?: (\n        keys: {\n            /**\n             * details of the secret storage keys required: a map from the key ID\n             * (excluding the `m.secret_storage.key.` prefix) to details of the key.\n             *\n             * When storing a secret, `keys` will contain exactly one entry; this method will be called\n             * once for each secret storage key to be used for encryption.\n             *\n             * For secret retrieval, `keys` may contain several entries, and the application can return\n             * any one of the requested keys.\n             */\n            keys: Record<string, SecretStorageKeyDescription>;\n        },\n        name: string,\n    ) => Promise<[string, Uint8Array] | null>;\n}\n\n/**\n * Account Data event types which can store secret-storage-encrypted information.\n */\nexport type SecretStorageKey = keyof SecretStorageAccountDataEvents;\n\n/**\n * Account Data event content type for storing secret-storage-encrypted information.\n *\n * See https://spec.matrix.org/v1.13/client-server-api/#msecret_storagev1aes-hmac-sha2-1\n */\nexport interface SecretInfo {\n    encrypted: {\n        [keyId: string]: AESEncryptedSecretStoragePayload;\n    };\n}\n\ninterface Decryptors {\n    encrypt: (plaintext: string) => Promise<AESEncryptedSecretStoragePayload>;\n    decrypt: (ciphertext: AESEncryptedSecretStoragePayload) => Promise<string>;\n}\n\n/**\n * Interface provided by SecretStorage implementations\n *\n * Normally this will just be an {@link ServerSideSecretStorageImpl}, but for backwards\n * compatibility some methods allow other implementations.\n */\nexport interface ServerSideSecretStorage {\n    /**\n     * Add a key for encrypting secrets.\n     *\n     * @param algorithm - the algorithm used by the key.\n     * @param opts - the options for the algorithm.  The properties used\n     *     depend on the algorithm given.\n     * @param keyId - the ID of the key.  If not given, a random\n     *     ID will be generated.\n     *\n     * @returns details about the key.\n     */\n    addKey(algorithm: string, opts: AddSecretStorageKeyOpts, keyId?: string): Promise<SecretStorageKeyObject>;\n\n    /**\n     * Get the key information for a given ID.\n     *\n     * @param keyId - The ID of the key to check\n     *     for. Defaults to the default key ID if not provided.\n     * @returns If the key was found, the return value is an array of\n     *     the form [keyId, keyInfo].  Otherwise, null is returned.\n     *     XXX: why is this an array when addKey returns an object?\n     */\n    getKey(keyId?: string | null): Promise<SecretStorageKeyTuple | null>;\n\n    /**\n     * Check whether we have a key with a given ID.\n     *\n     * @param keyId - The ID of the key to check\n     *     for. Defaults to the default key ID if not provided.\n     * @returns Whether we have the key.\n     */\n    hasKey(keyId?: string): Promise<boolean>;\n\n    /**\n     * Check whether a key matches what we expect based on the key info\n     *\n     * @param key - the key to check\n     * @param info - the key info\n     *\n     * @returns whether or not the key matches\n     */\n    checkKey(key: Uint8Array, info: SecretStorageKeyDescriptionAesV1): Promise<boolean>;\n\n    /**\n     * Store an encrypted secret on the server.\n     *\n     * Details of the encryption keys to be used must previously have been stored in account data\n     * (for example, via {@link ServerSideSecretStorageImpl#addKey}. {@link SecretStorageCallbacks#getSecretStorageKey} will be called to obtain a secret storage\n     * key to decrypt the secret.\n     *\n     * If the secret is `null`, the secret value in the account data will be set to an empty object.\n     * This is considered as \"removing\" the secret.\n     *\n     * @param name - The name of the secret - i.e., the \"event type\" to be stored in the account data\n     * @param secret - The secret contents.\n     * @param keys - The IDs of the keys to use to encrypt the secret, or null/undefined to use the default key\n     *     (will throw if no default key is set).\n     */\n    store(name: string, secret: string | null, keys?: string[] | null): Promise<void>;\n\n    /**\n     * Get a secret from storage, and decrypt it.\n     *\n     * @param name - the name of the secret - i.e., the \"event type\" stored in the account data\n     *\n     * @returns the decrypted contents of the secret, or \"undefined\" if `name` is not found in\n     *    the user's account data.\n     */\n    get(name: string): Promise<string | undefined>;\n\n    /**\n     * Check if a secret is stored on the server.\n     *\n     * @param name - the name of the secret\n     *\n     * @returns map of key name to key info the secret is encrypted\n     *     with, or null if it is not present or not encrypted with a trusted\n     *     key\n     */\n    isStored(name: SecretStorageKey): Promise<Record<string, SecretStorageKeyDescriptionAesV1> | null>;\n\n    /**\n     * Get the current default key ID for encrypting secrets.\n     *\n     * @returns The default key ID or null if no default key ID is set\n     */\n    getDefaultKeyId(): Promise<string | null>;\n\n    /**\n     * Set the default key ID for encrypting secrets.\n     *\n     * If keyId is `null`, the default key id value in the account data will be set to an empty object.\n     * This is considered as \"disabling\" the default key.\n     *\n     * @param keyId - The new default key ID\n     */\n    setDefaultKeyId(keyId: string | null): Promise<void>;\n}\n\n/**\n * Implementation of Server-side secret storage.\n *\n * Secret *sharing* is *not* implemented here: this class is strictly about the storage component of\n * SSSS.\n *\n * @see https://spec.matrix.org/v1.6/client-server-api/#storage\n */\nexport class ServerSideSecretStorageImpl implements ServerSideSecretStorage {\n    /**\n     * Construct a new `SecretStorage`.\n     *\n     * Normally, it is unnecessary to call this directly, since MatrixClient automatically constructs one.\n     * However, it may be useful to construct a new `SecretStorage`, if custom `callbacks` are required, for example.\n     *\n     * @param accountDataAdapter - interface for fetching and setting account data on the server. Normally an instance\n     *   of {@link MatrixClient}.\n     * @param callbacks - application level callbacks for retrieving secret keys\n     */\n    public constructor(\n        private readonly accountDataAdapter: AccountDataClient,\n        private readonly callbacks: SecretStorageCallbacks,\n    ) {}\n\n    /**\n     * Get the current default key ID for encrypting secrets.\n     *\n     * @returns The default key ID or null if no default key ID is set\n     */\n    public async getDefaultKeyId(): Promise<string | null> {\n        const defaultKey = await this.accountDataAdapter.getAccountDataFromServer(\"m.secret_storage.default_key\");\n        if (!defaultKey) return null;\n        return defaultKey.key ?? null;\n    }\n\n    /**\n     * Implementation of {@link ServerSideSecretStorage#setDefaultKeyId}.\n     */\n    public setDefaultKeyId(keyId: string | null): Promise<void> {\n        return new Promise<void>((resolve, reject) => {\n            const listener = (ev: MatrixEvent): void => {\n                if (ev.getType() !== \"m.secret_storage.default_key\") {\n                    //  Different account data item\n                    return;\n                }\n\n                // If keyId === null, the content should be an empty object.\n                // Otherwise, the `key` in the content object should match keyId.\n                const content = ev.getContent();\n                const isSameKey = keyId === null ? Object.keys(content).length === 0 : content.key === keyId;\n                if (isSameKey) {\n                    this.accountDataAdapter.removeListener(ClientEvent.AccountData, listener);\n                    resolve();\n                }\n            };\n            this.accountDataAdapter.on(ClientEvent.AccountData, listener);\n\n            // The spec [1] says that the value of the account data entry should be an object with a `key` property.\n            // It doesn't specify how to delete the default key; we do it by setting the account data to an empty object.\n            //\n            // [1]: https://spec.matrix.org/v1.13/client-server-api/#key-storage\n            const newValue: Record<string, never> | { key: string } = keyId === null ? {} : { key: keyId };\n            this.accountDataAdapter.setAccountData(\"m.secret_storage.default_key\", newValue).catch((e) => {\n                this.accountDataAdapter.removeListener(ClientEvent.AccountData, listener);\n                reject(e);\n            });\n        });\n    }\n\n    /**\n     * Add a key for encrypting secrets.\n     *\n     * @param algorithm - the algorithm used by the key.\n     * @param opts - the options for the algorithm.  The properties used\n     *     depend on the algorithm given.\n     * @param keyId - the ID of the key.  If not given, a random\n     *     ID will be generated.\n     *\n     * @returns An object with:\n     *     keyId: the ID of the key\n     *     keyInfo: details about the key (iv, mac, passphrase)\n     */\n    public async addKey(\n        algorithm: string,\n        opts: AddSecretStorageKeyOpts,\n        keyId?: string,\n    ): Promise<SecretStorageKeyObject> {\n        if (algorithm !== SECRET_STORAGE_ALGORITHM_V1_AES) {\n            throw new Error(`Unknown key algorithm ${algorithm}`);\n        }\n\n        const keyInfo = { algorithm } as SecretStorageKeyDescriptionAesV1;\n\n        if (opts.name) {\n            keyInfo.name = opts.name;\n        }\n\n        if (opts.passphrase) {\n            keyInfo.passphrase = opts.passphrase;\n        }\n\n        const { iv, mac } = await calculateKeyCheck(opts.key);\n        keyInfo.iv = iv;\n        keyInfo.mac = mac;\n\n        // Create a unique key id. XXX: this is racey.\n        if (!keyId) {\n            do {\n                keyId = secureRandomString(32);\n            } while (await this.accountDataAdapter.getAccountDataFromServer(`m.secret_storage.key.${keyId}`));\n        }\n\n        await this.accountDataAdapter.setAccountData(`m.secret_storage.key.${keyId}`, keyInfo);\n\n        return {\n            keyId,\n            keyInfo,\n        };\n    }\n\n    /**\n     * Get the key information for a given ID.\n     *\n     * @param keyId - The ID of the key to check\n     *     for. Defaults to the default key ID if not provided.\n     * @returns If the key was found, the return value is an array of\n     *     the form [keyId, keyInfo].  Otherwise, null is returned.\n     *     XXX: why is this an array when addKey returns an object?\n     */\n    public async getKey(keyId?: string | null): Promise<SecretStorageKeyTuple | null> {\n        if (!keyId) {\n            keyId = await this.getDefaultKeyId();\n        }\n        if (!keyId) {\n            return null;\n        }\n\n        const keyInfo = await this.accountDataAdapter.getAccountDataFromServer(`m.secret_storage.key.${keyId}`);\n        return keyInfo ? [keyId, keyInfo] : null;\n    }\n\n    /**\n     * Check whether we have a key with a given ID.\n     *\n     * @param keyId - The ID of the key to check\n     *     for. Defaults to the default key ID if not provided.\n     * @returns Whether we have the key.\n     */\n    public async hasKey(keyId?: string): Promise<boolean> {\n        const key = await this.getKey(keyId);\n        return Boolean(key);\n    }\n\n    /**\n     * Check whether a key matches what we expect based on the key info\n     *\n     * @param key - the key to check\n     * @param info - the key info\n     *\n     * @returns whether or not the key matches\n     */\n    public async checkKey(key: Uint8Array, info: SecretStorageKeyDescriptionAesV1): Promise<boolean> {\n        if (info.algorithm === SECRET_STORAGE_ALGORITHM_V1_AES) {\n            if (info.mac) {\n                const { mac } = await calculateKeyCheck(key, info.iv);\n                return trimTrailingEquals(info.mac) === trimTrailingEquals(mac);\n            } else {\n                // if we have no information, we have to assume the key is right\n                return true;\n            }\n        } else {\n            throw new Error(\"Unknown algorithm\");\n        }\n    }\n\n    /**\n     * Implementation of {@link ServerSideSecretStorage#store}.\n     */\n    public async store(name: SecretStorageKey, secret: string | null, keys?: string[] | null): Promise<void> {\n        if (secret === null) {\n            // remove secret\n            await this.accountDataAdapter.setAccountData(name, {});\n            return;\n        }\n\n        const encrypted: Record<string, AESEncryptedSecretStoragePayload> = {};\n\n        if (!keys) {\n            const defaultKeyId = await this.getDefaultKeyId();\n            if (!defaultKeyId) {\n                throw new Error(\"No keys specified and no default key present\");\n            }\n            keys = [defaultKeyId];\n        }\n\n        if (keys.length === 0) {\n            throw new Error(\"Zero keys given to encrypt with!\");\n        }\n\n        for (const keyId of keys) {\n            // get key information from key storage\n            const keyInfo = await this.accountDataAdapter.getAccountDataFromServer(`m.secret_storage.key.${keyId}`);\n            if (!keyInfo) {\n                throw new Error(\"Unknown key: \" + keyId);\n            }\n\n            // encrypt secret, based on the algorithm\n            if (keyInfo.algorithm === SECRET_STORAGE_ALGORITHM_V1_AES) {\n                const keys = { [keyId]: keyInfo };\n                const [, encryption] = await this.getSecretStorageKey(keys, name);\n                encrypted[keyId] = await encryption.encrypt(secret);\n            } else {\n                logger.warn(\"unknown algorithm for secret storage key \" + keyId + \": \" + keyInfo.algorithm);\n                // do nothing if we don't understand the encryption algorithm\n            }\n        }\n\n        // save encrypted secret\n        await this.accountDataAdapter.setAccountData(name, { encrypted });\n    }\n\n    /**\n     * Get a secret from storage, and decrypt it.\n     *\n     * {@link SecretStorageCallbacks#getSecretStorageKey} will be called to obtain a secret storage\n     * key to decrypt the secret.\n     *\n     * @param name - the name of the secret - i.e., the \"event type\" stored in the account data\n     *\n     * @returns the decrypted contents of the secret, or \"undefined\" if `name` is not found in\n     *    the user's account data.\n     */\n    public async get(name: SecretStorageKey): Promise<string | undefined> {\n        const secretInfo = await this.accountDataAdapter.getAccountDataFromServer(name);\n        if (!secretInfo) {\n            return;\n        }\n        if (!secretInfo.encrypted) {\n            throw new Error(\"Content is not encrypted!\");\n        }\n\n        // get possible keys to decrypt\n        const keys: Record<string, SecretStorageKeyDescriptionAesV1> = {};\n        for (const keyId of Object.keys(secretInfo.encrypted)) {\n            // get key information from key storage\n            const keyInfo = await this.accountDataAdapter.getAccountDataFromServer(`m.secret_storage.key.${keyId}`);\n            const encInfo = secretInfo.encrypted[keyId];\n            // only use keys we understand the encryption algorithm of\n            if (keyInfo?.algorithm === SECRET_STORAGE_ALGORITHM_V1_AES) {\n                if (encInfo.iv && encInfo.ciphertext && encInfo.mac) {\n                    keys[keyId] = keyInfo;\n                }\n            }\n        }\n\n        if (Object.keys(keys).length === 0) {\n            throw new Error(\n                `Could not decrypt ${name} because none of ` +\n                    `the keys it is encrypted with are for a supported algorithm`,\n            );\n        }\n\n        // fetch private key from app\n        const [keyId, decryption] = await this.getSecretStorageKey(keys, name);\n        const encInfo = secretInfo.encrypted[keyId];\n\n        return decryption.decrypt(encInfo);\n    }\n\n    /**\n     * Check if a secret is stored on the server.\n     *\n     * @param name - the name of the secret\n     *\n     * @returns map of key name to key info the secret is encrypted\n     *     with, or null if it is not present or not encrypted with a trusted\n     *     key\n     */\n    public async isStored(name: SecretStorageKey): Promise<Record<string, SecretStorageKeyDescriptionAesV1> | null> {\n        // check if secret exists\n        const secretInfo = await this.accountDataAdapter.getAccountDataFromServer(name);\n        if (!secretInfo?.encrypted) return null;\n\n        const ret: Record<string, SecretStorageKeyDescriptionAesV1> = {};\n\n        // filter secret encryption keys with supported algorithm\n        for (const keyId of Object.keys(secretInfo.encrypted)) {\n            // get key information from key storage\n            const keyInfo = await this.accountDataAdapter.getAccountDataFromServer(`m.secret_storage.key.${keyId}`);\n            if (!keyInfo) continue;\n            const encInfo = secretInfo.encrypted[keyId];\n\n            // only use keys we understand the encryption algorithm of\n            if (keyInfo.algorithm === SECRET_STORAGE_ALGORITHM_V1_AES) {\n                if (encInfo.iv && encInfo.ciphertext && encInfo.mac) {\n                    ret[keyId] = keyInfo;\n                }\n            }\n        }\n        return Object.keys(ret).length ? ret : null;\n    }\n\n    private async getSecretStorageKey(\n        keys: Record<string, SecretStorageKeyDescriptionAesV1>,\n        name: string,\n    ): Promise<[string, Decryptors]> {\n        if (!this.callbacks.getSecretStorageKey) {\n            throw new Error(\"No getSecretStorageKey callback supplied\");\n        }\n\n        const returned = await this.callbacks.getSecretStorageKey({ keys }, name);\n\n        if (!returned) {\n            throw new Error(\"getSecretStorageKey callback returned falsey\");\n        }\n        if (returned.length < 2) {\n            throw new Error(\"getSecretStorageKey callback returned invalid data\");\n        }\n\n        const [keyId, privateKey] = returned;\n        if (!keys[keyId]) {\n            throw new Error(\"App returned unknown key from getSecretStorageKey!\");\n        }\n\n        if (keys[keyId].algorithm === SECRET_STORAGE_ALGORITHM_V1_AES) {\n            const decryption = {\n                encrypt: function (secret: string): Promise<AESEncryptedSecretStoragePayload> {\n                    return encryptAESSecretStorageItem(secret, privateKey, name);\n                },\n                decrypt: function (encInfo: AESEncryptedSecretStoragePayload): Promise<string> {\n                    return decryptAESSecretStorageItem(encInfo, privateKey, name);\n                },\n            };\n            return [keyId, decryption];\n        } else {\n            throw new Error(\"Unknown key type: \" + keys[keyId].algorithm);\n        }\n    }\n}\n\n/** trim trailing instances of '=' from a string\n *\n * @internal\n *\n * @param input - input string\n */\nexport function trimTrailingEquals(input: string): string {\n    // according to Sonar and CodeQL, a regex such as /=+$/ is superlinear.\n    // Not sure I believe it, but it's easy enough to work around.\n\n    // find the number of characters before the trailing =\n    let i = input.length;\n    while (i >= 1 && input.charCodeAt(i - 1) == 0x3d) i--;\n\n    // trim to the calculated length\n    if (i < input.length) {\n        return input.substring(0, i);\n    } else {\n        return input;\n    }\n}\n\n// string of zeroes, for calculating the key check\nconst ZERO_STR = \"\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\";\n\n/**\n * Calculate the MAC for checking the key.\n * See https://spec.matrix.org/v1.11/client-server-api/#msecret_storagev1aes-hmac-sha2, steps 3 and 4.\n *\n * @param key - the key to use\n * @param iv - The initialization vector as a base64-encoded string.\n *     If omitted, a random initialization vector will be created.\n * @returns An object that contains, `mac` and `iv` properties.\n */\nexport function calculateKeyCheck(key: Uint8Array, iv?: string): Promise<AESEncryptedSecretStoragePayload> {\n    return encryptAESSecretStorageItem(ZERO_STR, key, \"\", iv);\n}\n","/*\nCopyright 2024 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { type IHttpOpts, type MatrixHttpApi, Method } from \"./http-api/index.ts\";\nimport { logger } from \"./logger.ts\";\n\n// How often we update the server capabilities.\n// 6 hours - an arbitrary value, but they should change very infrequently.\nconst CAPABILITIES_CACHE_MS = 6 * 60 * 60 * 1000;\n\n// How long we want before retrying if we couldn't fetch\nconst CAPABILITIES_RETRY_MS = 30 * 1000;\n\nexport interface ICapability {\n    enabled: boolean;\n}\n\nexport interface IChangePasswordCapability extends ICapability {}\n\nexport interface IThreadsCapability extends ICapability {}\n\nexport interface IGetLoginTokenCapability extends ICapability {}\n\nexport interface ISetDisplayNameCapability extends ICapability {}\n\nexport interface ISetAvatarUrlCapability extends ICapability {}\n\nexport interface IProfileFieldsCapability extends ICapability {}\n\nexport enum RoomVersionStability {\n    Stable = \"stable\",\n    Unstable = \"unstable\",\n}\n\nexport interface IRoomVersionsCapability {\n    default: string;\n    available: Record<string, RoomVersionStability>;\n}\n\n/**\n * A representation of the capabilities advertised by a homeserver as defined by\n * [Capabilities negotiation](https://spec.matrix.org/v1.6/client-server-api/#get_matrixclientv3capabilities).\n */\nexport interface Capabilities {\n    [key: string]: any;\n    \"m.change_password\"?: IChangePasswordCapability;\n    \"m.room_versions\"?: IRoomVersionsCapability;\n    \"io.element.thread\"?: IThreadsCapability;\n    \"m.get_login_token\"?: IGetLoginTokenCapability;\n    \"org.matrix.msc3882.get_login_token\"?: IGetLoginTokenCapability;\n    \"m.set_displayname\"?: ISetDisplayNameCapability;\n    \"m.set_avatar_url\"?: ISetAvatarUrlCapability;\n    \"uk.tcpip.msc4133.profile_fields\"?: IProfileFieldsCapability;\n}\n\ntype CapabilitiesResponse = {\n    capabilities: Capabilities;\n};\n\n/**\n * Manages storing and periodically refreshing the server capabilities.\n */\nexport class ServerCapabilities {\n    private capabilities?: Capabilities;\n    private retryTimeout?: ReturnType<typeof setTimeout>;\n    private refreshTimeout?: ReturnType<typeof setInterval>;\n\n    public constructor(private readonly http: MatrixHttpApi<IHttpOpts & { onlyData: true }>) {}\n\n    /**\n     * Starts periodically fetching the server capabilities.\n     */\n    public start(): void {\n        this.poll().then();\n    }\n\n    /**\n     * Stops the service\n     */\n    public stop(): void {\n        this.clearTimeouts();\n    }\n\n    /**\n     * Returns the cached capabilities, or undefined if none are cached.\n     * @returns the current capabilities, if any.\n     */\n    public getCachedCapabilities(): Capabilities | undefined {\n        return this.capabilities;\n    }\n\n    /**\n     * Fetches the latest server capabilities from the homeserver and returns them, or rejects\n     * on failure.\n     */\n    public fetchCapabilities = async (): Promise<Capabilities> => {\n        const resp = await this.http.authedRequest<CapabilitiesResponse>(Method.Get, \"/capabilities\");\n        this.capabilities = resp[\"capabilities\"];\n        return this.capabilities;\n    };\n\n    private poll = async (): Promise<void> => {\n        try {\n            await this.fetchCapabilities();\n            this.clearTimeouts();\n            this.refreshTimeout = setTimeout(this.poll, CAPABILITIES_CACHE_MS);\n            logger.debug(\"Fetched new server capabilities\");\n        } catch (e) {\n            this.clearTimeouts();\n            const howLong = Math.floor(CAPABILITIES_RETRY_MS + Math.random() * 5000);\n            this.retryTimeout = setTimeout(this.poll, howLong);\n            logger.warn(`Failed to refresh capabilities: retrying in ${howLong}ms`, e);\n        }\n    };\n\n    private clearTimeouts(): void {\n        if (this.refreshTimeout) {\n            clearInterval(this.refreshTimeout);\n            this.refreshTimeout = undefined;\n        }\n        if (this.retryTimeout) {\n            clearTimeout(this.retryTimeout);\n            this.retryTimeout = undefined;\n        }\n    }\n}\n","/*\nCopyright 2019 - 2021 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nexport enum SERVICE_TYPES {\n    IS = \"SERVICE_TYPE_IS\", // An identity server\n    IM = \"SERVICE_TYPE_IM\", // An integration manager\n}\n","/*\nCopyright 2022 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport type { SyncCryptoCallbacks } from \"./common-crypto/CryptoBackend.ts\";\nimport { NotificationCountType, Room, RoomEvent } from \"./models/room.ts\";\nimport { logger } from \"./logger.ts\";\nimport { promiseMapSeries } from \"./utils.ts\";\nimport { EventTimeline } from \"./models/event-timeline.ts\";\nimport { ClientEvent, type IStoredClientOpts, type MatrixClient } from \"./client.ts\";\nimport {\n    type ISyncStateData,\n    SyncState,\n    _createAndReEmitRoom,\n    type SyncApiOptions,\n    defaultClientOpts,\n    defaultSyncApiOpts,\n    type SetPresence,\n    mapToDeviceEvent,\n} from \"./sync.ts\";\nimport { type MatrixEvent } from \"./models/event.ts\";\nimport {\n    type IMinimalEvent,\n    type IRoomEvent,\n    type IStateEvent,\n    type IStrippedState,\n    type ISyncResponse,\n} from \"./sync-accumulator.ts\";\nimport { MatrixError } from \"./http-api/index.ts\";\nimport {\n    type Extension,\n    ExtensionState,\n    type MSC3575RoomData,\n    type MSC3575SlidingSyncResponse,\n    type SlidingSync,\n    SlidingSyncEvent,\n    SlidingSyncState,\n} from \"./sliding-sync.ts\";\nimport { EventType } from \"./@types/event.ts\";\nimport { type IPushRules } from \"./@types/PushRules.ts\";\nimport { RoomStateEvent } from \"./models/room-state.ts\";\nimport { RoomMemberEvent } from \"./models/room-member.ts\";\nimport { KnownMembership } from \"./@types/membership.ts\";\n\n// Number of consecutive failed syncs that will lead to a syncState of ERROR as opposed\n// to RECONNECTING. This is needed to inform the client of server issues when the\n// keepAlive is successful but the server /sync fails.\nconst FAILED_SYNC_ERROR_THRESHOLD = 3;\n\ntype ExtensionE2EERequest = {\n    enabled: boolean;\n};\n\ntype ExtensionE2EEResponse = Pick<\n    ISyncResponse,\n    | \"device_lists\"\n    | \"device_one_time_keys_count\"\n    | \"device_unused_fallback_key_types\"\n    | \"org.matrix.msc2732.device_unused_fallback_key_types\"\n>;\n\nclass ExtensionE2EE implements Extension<ExtensionE2EERequest, ExtensionE2EEResponse> {\n    public constructor(private readonly crypto: SyncCryptoCallbacks) {}\n\n    public name(): string {\n        return \"e2ee\";\n    }\n\n    public when(): ExtensionState {\n        return ExtensionState.PreProcess;\n    }\n\n    public onRequest(isInitial: boolean): ExtensionE2EERequest | undefined {\n        if (!isInitial) {\n            return undefined;\n        }\n        return {\n            enabled: true, // this is sticky so only send it on the initial request\n        };\n    }\n\n    public async onResponse(data: ExtensionE2EEResponse): Promise<void> {\n        // Handle device list updates\n        if (data.device_lists) {\n            await this.crypto.processDeviceLists(data.device_lists);\n        }\n\n        // Handle one_time_keys_count and unused_fallback_key_types\n        await this.crypto.processKeyCounts(\n            data.device_one_time_keys_count,\n            data[\"device_unused_fallback_key_types\"] || data[\"org.matrix.msc2732.device_unused_fallback_key_types\"],\n        );\n\n        this.crypto.onSyncCompleted({});\n    }\n}\n\ntype ExtensionToDeviceRequest = {\n    since?: string;\n    limit?: number;\n    enabled?: boolean;\n};\n\ntype ExtensionToDeviceResponse = {\n    events: Required<ISyncResponse>[\"to_device\"][\"events\"];\n    next_batch: string | null;\n};\n\nclass ExtensionToDevice implements Extension<ExtensionToDeviceRequest, ExtensionToDeviceResponse> {\n    private nextBatch: string | null = null;\n\n    public constructor(\n        private readonly client: MatrixClient,\n        private readonly cryptoCallbacks?: SyncCryptoCallbacks,\n    ) {}\n\n    public name(): string {\n        return \"to_device\";\n    }\n\n    public when(): ExtensionState {\n        return ExtensionState.PreProcess;\n    }\n\n    public onRequest(isInitial: boolean): ExtensionToDeviceRequest {\n        const extReq: ExtensionToDeviceRequest = {\n            since: this.nextBatch !== null ? this.nextBatch : undefined,\n        };\n        if (isInitial) {\n            extReq[\"limit\"] = 100;\n            extReq[\"enabled\"] = true;\n        }\n        return extReq;\n    }\n\n    public async onResponse(data: ExtensionToDeviceResponse): Promise<void> {\n        const cancelledKeyVerificationTxns: string[] = [];\n        let events = data[\"events\"] || [];\n        if (events.length > 0 && this.cryptoCallbacks) {\n            events = await this.cryptoCallbacks.preprocessToDeviceMessages(events);\n        }\n        events\n            .map(mapToDeviceEvent)\n            .map((toDeviceEvent) => {\n                // map is a cheap inline forEach\n                // We want to flag m.key.verification.start events as cancelled\n                // if there's an accompanying m.key.verification.cancel event, so\n                // we pull out the transaction IDs from the cancellation events\n                // so we can flag the verification events as cancelled in the loop\n                // below.\n                if (toDeviceEvent.getType() === \"m.key.verification.cancel\") {\n                    const txnId: string | undefined = toDeviceEvent.getContent()[\"transaction_id\"];\n                    if (txnId) {\n                        cancelledKeyVerificationTxns.push(txnId);\n                    }\n                }\n\n                // as mentioned above, .map is a cheap inline forEach, so return\n                // the unmodified event.\n                return toDeviceEvent;\n            })\n            .forEach((toDeviceEvent) => {\n                const content = toDeviceEvent.getContent();\n                if (toDeviceEvent.getType() == \"m.room.message\" && content.msgtype == \"m.bad.encrypted\") {\n                    // the mapper already logged a warning.\n                    logger.log(\"Ignoring undecryptable to-device event from \" + toDeviceEvent.getSender());\n                    return;\n                }\n\n                if (\n                    toDeviceEvent.getType() === \"m.key.verification.start\" ||\n                    toDeviceEvent.getType() === \"m.key.verification.request\"\n                ) {\n                    const txnId = content[\"transaction_id\"];\n                    if (cancelledKeyVerificationTxns.includes(txnId)) {\n                        toDeviceEvent.flagCancelled();\n                    }\n                }\n\n                this.client.emit(ClientEvent.ToDeviceEvent, toDeviceEvent);\n            });\n\n        this.nextBatch = data.next_batch;\n    }\n}\n\ntype ExtensionAccountDataRequest = {\n    enabled: boolean;\n};\n\ntype ExtensionAccountDataResponse = {\n    global: IMinimalEvent[];\n    rooms: Record<string, IMinimalEvent[]>;\n};\n\nclass ExtensionAccountData implements Extension<ExtensionAccountDataRequest, ExtensionAccountDataResponse> {\n    public constructor(private readonly client: MatrixClient) {}\n\n    public name(): string {\n        return \"account_data\";\n    }\n\n    public when(): ExtensionState {\n        return ExtensionState.PostProcess;\n    }\n\n    public onRequest(isInitial: boolean): ExtensionAccountDataRequest | undefined {\n        if (!isInitial) {\n            return undefined;\n        }\n        return {\n            enabled: true,\n        };\n    }\n\n    public async onResponse(data: ExtensionAccountDataResponse): Promise<void> {\n        if (data.global && data.global.length > 0) {\n            this.processGlobalAccountData(data.global);\n        }\n\n        for (const roomId in data.rooms) {\n            const accountDataEvents = mapEvents(this.client, roomId, data.rooms[roomId]);\n            const room = this.client.getRoom(roomId);\n            if (!room) {\n                logger.warn(\"got account data for room but room doesn't exist on client:\", roomId);\n                continue;\n            }\n            room.addAccountData(accountDataEvents);\n            accountDataEvents.forEach((e) => {\n                this.client.emit(ClientEvent.Event, e);\n            });\n        }\n    }\n\n    private processGlobalAccountData(globalAccountData: IMinimalEvent[]): void {\n        const events = mapEvents(this.client, undefined, globalAccountData);\n        const prevEventsMap = events.reduce<Record<string, MatrixEvent | undefined>>((m, c) => {\n            m[c.getType()] = this.client.store.getAccountData(c.getType());\n            return m;\n        }, {});\n        this.client.store.storeAccountDataEvents(events);\n        events.forEach((accountDataEvent) => {\n            // Honour push rules that come down the sync stream but also\n            // honour push rules that were previously cached. Base rules\n            // will be updated when we receive push rules via getPushRules\n            // (see sync) before syncing over the network.\n            if (accountDataEvent.getType() === EventType.PushRules) {\n                const rules = accountDataEvent.getContent<IPushRules>();\n                this.client.setPushRules(rules);\n            }\n            const prevEvent = prevEventsMap[accountDataEvent.getType()];\n            this.client.emit(ClientEvent.AccountData, accountDataEvent, prevEvent);\n            return accountDataEvent;\n        });\n    }\n}\n\ntype ExtensionTypingRequest = {\n    enabled: boolean;\n};\n\ntype ExtensionTypingResponse = {\n    rooms: Record<string, IMinimalEvent>;\n};\n\nclass ExtensionTyping implements Extension<ExtensionTypingRequest, ExtensionTypingResponse> {\n    public constructor(private readonly client: MatrixClient) {}\n\n    public name(): string {\n        return \"typing\";\n    }\n\n    public when(): ExtensionState {\n        return ExtensionState.PostProcess;\n    }\n\n    public onRequest(isInitial: boolean): ExtensionTypingRequest | undefined {\n        if (!isInitial) {\n            return undefined; // don't send a JSON object for subsequent requests, we don't need to.\n        }\n        return {\n            enabled: true,\n        };\n    }\n\n    public async onResponse(data: ExtensionTypingResponse): Promise<void> {\n        if (!data?.rooms) {\n            return;\n        }\n\n        for (const roomId in data.rooms) {\n            processEphemeralEvents(this.client, roomId, [data.rooms[roomId]]);\n        }\n    }\n}\n\ntype ExtensionReceiptsRequest = {\n    enabled: boolean;\n};\n\ntype ExtensionReceiptsResponse = {\n    rooms: Record<string, IMinimalEvent>;\n};\n\nclass ExtensionReceipts implements Extension<ExtensionReceiptsRequest, ExtensionReceiptsResponse> {\n    public constructor(private readonly client: MatrixClient) {}\n\n    public name(): string {\n        return \"receipts\";\n    }\n\n    public when(): ExtensionState {\n        return ExtensionState.PostProcess;\n    }\n\n    public onRequest(isInitial: boolean): ExtensionReceiptsRequest | undefined {\n        if (isInitial) {\n            return {\n                enabled: true,\n            };\n        }\n        return undefined; // don't send a JSON object for subsequent requests, we don't need to.\n    }\n\n    public async onResponse(data: ExtensionReceiptsResponse): Promise<void> {\n        if (!data?.rooms) {\n            return;\n        }\n\n        for (const roomId in data.rooms) {\n            processEphemeralEvents(this.client, roomId, [data.rooms[roomId]]);\n        }\n    }\n}\n\n/**\n * A copy of SyncApi such that it can be used as a drop-in replacement for sync v2. For the actual\n * sliding sync API, see sliding-sync.ts or the class SlidingSync.\n */\nexport class SlidingSyncSdk {\n    private readonly opts: IStoredClientOpts;\n    private readonly syncOpts: SyncApiOptions;\n    private syncState: SyncState | null = null;\n    private syncStateData?: ISyncStateData;\n    private lastPos: string | null = null;\n    private failCount = 0;\n    private notifEvents: MatrixEvent[] = []; // accumulator of sync events in the current sync response\n\n    public constructor(\n        private readonly slidingSync: SlidingSync,\n        private readonly client: MatrixClient,\n        opts?: IStoredClientOpts,\n        syncOpts?: SyncApiOptions,\n    ) {\n        this.opts = defaultClientOpts(opts);\n        this.syncOpts = defaultSyncApiOpts(syncOpts);\n\n        if (client.getNotifTimelineSet()) {\n            client.reEmitter.reEmit(client.getNotifTimelineSet()!, [RoomEvent.Timeline, RoomEvent.TimelineReset]);\n        }\n\n        this.slidingSync.on(SlidingSyncEvent.Lifecycle, this.onLifecycle.bind(this));\n        this.slidingSync.on(SlidingSyncEvent.RoomData, this.onRoomData.bind(this));\n        const extensions: Extension<any, any>[] = [\n            new ExtensionToDevice(this.client, this.syncOpts.cryptoCallbacks),\n            new ExtensionAccountData(this.client),\n            new ExtensionTyping(this.client),\n            new ExtensionReceipts(this.client),\n        ];\n        if (this.syncOpts.cryptoCallbacks) {\n            extensions.push(new ExtensionE2EE(this.syncOpts.cryptoCallbacks));\n        }\n        extensions.forEach((ext) => {\n            this.slidingSync.registerExtension(ext);\n        });\n    }\n\n    private async onRoomData(roomId: string, roomData: MSC3575RoomData): Promise<void> {\n        let room = this.client.store.getRoom(roomId);\n        if (!room) {\n            if (!roomData.initial) {\n                logger.debug(\"initial flag not set but no stored room exists for room \", roomId, roomData);\n                return;\n            }\n            room = _createAndReEmitRoom(this.client, roomId, this.opts);\n        }\n        await this.processRoomData(this.client, room!, roomData);\n    }\n\n    private onLifecycle(state: SlidingSyncState, resp: MSC3575SlidingSyncResponse | null, err?: Error): void {\n        if (err) {\n            logger.debug(\"onLifecycle\", state, err);\n        }\n        switch (state) {\n            case SlidingSyncState.Complete:\n                this.purgeNotifications();\n                if (!resp) {\n                    break;\n                }\n                // Element won't stop showing the initial loading spinner unless we fire SyncState.Prepared\n                if (!this.lastPos) {\n                    this.updateSyncState(SyncState.Prepared, {\n                        oldSyncToken: undefined,\n                        nextSyncToken: resp.pos,\n                        catchingUp: false,\n                        fromCache: false,\n                    });\n                }\n                // Conversely, Element won't show the room list unless there is at least 1x SyncState.Syncing\n                // so hence for the very first sync we will fire prepared then immediately syncing.\n                this.updateSyncState(SyncState.Syncing, {\n                    oldSyncToken: this.lastPos!,\n                    nextSyncToken: resp.pos,\n                    catchingUp: false,\n                    fromCache: false,\n                });\n                this.lastPos = resp.pos;\n                break;\n            case SlidingSyncState.RequestFinished:\n                if (err) {\n                    this.failCount += 1;\n                    this.updateSyncState(\n                        this.failCount > FAILED_SYNC_ERROR_THRESHOLD ? SyncState.Error : SyncState.Reconnecting,\n                        {\n                            error: new MatrixError(err),\n                        },\n                    );\n                    if (this.shouldAbortSync(new MatrixError(err))) {\n                        return; // shouldAbortSync actually stops syncing too so we don't need to do anything.\n                    }\n                } else {\n                    this.failCount = 0;\n                }\n                break;\n        }\n    }\n\n    /**\n     * Sync rooms the user has left.\n     * @returns Resolved when they've been added to the store.\n     */\n    public async syncLeftRooms(): Promise<Room[]> {\n        return []; // TODO\n    }\n\n    /**\n     * Peek into a room. This will result in the room in question being synced so it\n     * is accessible via getRooms(). Live updates for the room will be provided.\n     * @param roomId - The room ID to peek into.\n     * @returns A promise which resolves once the room has been added to the\n     * store.\n     */\n    public async peek(roomId: string): Promise<Room> {\n        return null!; // TODO\n    }\n\n    /**\n     * Stop polling for updates in the peeked room. NOPs if there is no room being\n     * peeked.\n     */\n    public stopPeeking(): void {\n        // TODO\n    }\n\n    /**\n     * Specify the set_presence value to be used for subsequent calls to the Sync API.\n     * @param presence - the presence to specify to set_presence of sync calls\n     */\n    public setPresence(presence?: SetPresence): void {\n        // TODO not possible in sliding sync yet\n    }\n\n    /**\n     * Returns the current state of this sync object\n     * @see MatrixClient#event:\"sync\"\n     */\n    public getSyncState(): SyncState | null {\n        return this.syncState;\n    }\n\n    /**\n     * Returns the additional data object associated with\n     * the current sync state, or null if there is no\n     * such data.\n     * Sync errors, if available, are put in the 'error' key of\n     * this object.\n     */\n    public getSyncStateData(): ISyncStateData | null {\n        return this.syncStateData ?? null;\n    }\n\n    // Helper functions which set up JS SDK structs are below and are identical to the sync v2 counterparts\n\n    public createRoom(roomId: string): Room {\n        // XXX cargoculted from sync.ts\n        const { timelineSupport } = this.client;\n        const room = new Room(roomId, this.client, this.client.getUserId()!, {\n            lazyLoadMembers: this.opts.lazyLoadMembers,\n            pendingEventOrdering: this.opts.pendingEventOrdering,\n            timelineSupport,\n        });\n        this.client.reEmitter.reEmit(room, [\n            RoomEvent.Name,\n            RoomEvent.Redaction,\n            RoomEvent.RedactionCancelled,\n            RoomEvent.Receipt,\n            RoomEvent.Tags,\n            RoomEvent.LocalEchoUpdated,\n            RoomEvent.AccountData,\n            RoomEvent.MyMembership,\n            RoomEvent.Timeline,\n            RoomEvent.TimelineReset,\n        ]);\n        this.registerStateListeners(room);\n        return room;\n    }\n\n    private registerStateListeners(room: Room): void {\n        // XXX cargoculted from sync.ts\n        // we need to also re-emit room state and room member events, so hook it up\n        // to the client now. We need to add a listener for RoomState.members in\n        // order to hook them correctly.\n        this.client.reEmitter.reEmit(room.currentState, [\n            RoomStateEvent.Events,\n            RoomStateEvent.Members,\n            RoomStateEvent.NewMember,\n            RoomStateEvent.Update,\n        ]);\n        room.currentState.on(RoomStateEvent.NewMember, (event, state, member) => {\n            member.user = this.client.getUser(member.userId) ?? undefined;\n            this.client.reEmitter.reEmit(member, [\n                RoomMemberEvent.Name,\n                RoomMemberEvent.Typing,\n                RoomMemberEvent.PowerLevel,\n                RoomMemberEvent.Membership,\n            ]);\n        });\n    }\n\n    /*\n    private deregisterStateListeners(room: Room): void { // XXX cargoculted from sync.ts\n        // could do with a better way of achieving this.\n        room.currentState.removeAllListeners(RoomStateEvent.Events);\n        room.currentState.removeAllListeners(RoomStateEvent.Members);\n        room.currentState.removeAllListeners(RoomStateEvent.NewMember);\n    } */\n\n    private shouldAbortSync(error: MatrixError): boolean {\n        if (error.errcode === \"M_UNKNOWN_TOKEN\") {\n            // The logout already happened, we just need to stop.\n            logger.warn(\"Token no longer valid - assuming logout\");\n            this.stop();\n            this.updateSyncState(SyncState.Error, { error });\n            return true;\n        }\n        return false;\n    }\n\n    private async processRoomData(client: MatrixClient, room: Room, roomData: MSC3575RoomData): Promise<void> {\n        roomData = ensureNameEvent(client, room.roomId, roomData);\n        const stateEvents = mapEvents(this.client, room.roomId, roomData.required_state);\n        // Prevent events from being decrypted ahead of time\n        // this helps large account to speed up faster\n        // room::decryptCriticalEvent is in charge of decrypting all the events\n        // required for a client to function properly\n        let timelineEvents = mapEvents(this.client, room.roomId, roomData.timeline, false);\n        const ephemeralEvents: MatrixEvent[] = []; // TODO this.mapSyncEventsFormat(joinObj.ephemeral);\n\n        // TODO: handle threaded / beacon events\n\n        if (roomData.initial) {\n            // we should not know about any of these timeline entries if this is a genuinely new room.\n            // If we do, then we've effectively done scrollback (e.g requesting timeline_limit: 1 for\n            // this room, then timeline_limit: 50).\n            const knownEvents = new Set<string>();\n            room.getLiveTimeline()\n                .getEvents()\n                .forEach((e) => {\n                    knownEvents.add(e.getId()!);\n                });\n            // all unknown events BEFORE a known event must be scrollback e.g:\n            //       D E   <-- what we know\n            // A B C D E F <-- what we just received\n            // means:\n            // A B C       <-- scrollback\n            //       D E   <-- dupes\n            //           F <-- new event\n            // We bucket events based on if we have seen a known event yet.\n            const oldEvents: MatrixEvent[] = [];\n            const newEvents: MatrixEvent[] = [];\n            let seenKnownEvent = false;\n            for (let i = timelineEvents.length - 1; i >= 0; i--) {\n                const recvEvent = timelineEvents[i];\n                if (knownEvents.has(recvEvent.getId()!)) {\n                    seenKnownEvent = true;\n                    continue; // don't include this event, it's a dupe\n                }\n                if (seenKnownEvent) {\n                    // old -> new\n                    oldEvents.push(recvEvent);\n                } else {\n                    // old -> new\n                    newEvents.unshift(recvEvent);\n                }\n            }\n            timelineEvents = newEvents;\n            if (oldEvents.length > 0) {\n                // old events are scrollback, insert them now\n                room.addEventsToTimeline(oldEvents, true, false, room.getLiveTimeline(), roomData.prev_batch);\n            }\n        }\n\n        const encrypted = room.hasEncryptionStateEvent();\n        // we do this first so it's correct when any of the events fire\n        if (roomData.notification_count != null) {\n            room.setUnreadNotificationCount(NotificationCountType.Total, roomData.notification_count);\n        }\n\n        if (roomData.highlight_count != null) {\n            // We track unread notifications ourselves in encrypted rooms, so don't\n            // bother setting it here. We trust our calculations better than the\n            // server's for this case, and therefore will assume that our non-zero\n            // count is accurate.\n            if (!encrypted || (encrypted && room.getUnreadNotificationCount(NotificationCountType.Highlight) <= 0)) {\n                room.setUnreadNotificationCount(NotificationCountType.Highlight, roomData.highlight_count);\n            }\n        }\n\n        if (Number.isInteger(roomData.invited_count)) {\n            room.currentState.setInvitedMemberCount(roomData.invited_count!);\n        }\n        if (Number.isInteger(roomData.joined_count)) {\n            room.currentState.setJoinedMemberCount(roomData.joined_count!);\n        }\n\n        if (roomData.invite_state) {\n            const inviteStateEvents = mapEvents(this.client, room.roomId, roomData.invite_state);\n            await this.injectRoomEvents(room, inviteStateEvents);\n            if (roomData.initial) {\n                room.recalculate();\n                this.client.store.storeRoom(room);\n                this.client.emit(ClientEvent.Room, room);\n            }\n            inviteStateEvents.forEach((e) => {\n                this.client.emit(ClientEvent.Event, e);\n            });\n            room.updateMyMembership(KnownMembership.Invite);\n            return;\n        }\n\n        if (roomData.initial) {\n            // set the back-pagination token. Do this *before* adding any\n            // events so that clients can start back-paginating.\n            room.getLiveTimeline().setPaginationToken(roomData.prev_batch ?? null, EventTimeline.BACKWARDS);\n        }\n\n        /* TODO\n        else if (roomData.limited) {\n\n            let limited = true;\n\n            // we've got a limited sync, so we *probably* have a gap in the\n            // timeline, so should reset. But we might have been peeking or\n            // paginating and already have some of the events, in which\n            // case we just want to append any subsequent events to the end\n            // of the existing timeline.\n            //\n            // This is particularly important in the case that we already have\n            // *all* of the events in the timeline - in that case, if we reset\n            // the timeline, we'll end up with an entirely empty timeline,\n            // which we'll try to paginate but not get any new events (which\n            // will stop us linking the empty timeline into the chain).\n            //\n            for (let i = timelineEvents.length - 1; i >= 0; i--) {\n                const eventId = timelineEvents[i].getId();\n                if (room.getTimelineForEvent(eventId)) {\n                    logger.debug(\"Already have event \" + eventId + \" in limited \" +\n                        \"sync - not resetting\");\n                    limited = false;\n\n                    // we might still be missing some of the events before i;\n                    // we don't want to be adding them to the end of the\n                    // timeline because that would put them out of order.\n                    timelineEvents.splice(0, i);\n\n                    // XXX: there's a problem here if the skipped part of the\n                    // timeline modifies the state set in stateEvents, because\n                    // we'll end up using the state from stateEvents rather\n                    // than the later state from timelineEvents. We probably\n                    // need to wind stateEvents forward over the events we're\n                    // skipping.\n                    break;\n                }\n            }\n\n            if (limited) {\n                room.resetLiveTimeline(\n                    roomData.prev_batch,\n                    null, // TODO this.syncOpts.canResetEntireTimeline(room.roomId) ? null : syncEventData.oldSyncToken,\n                );\n\n                // We have to assume any gap in any timeline is\n                // reason to stop incrementally tracking notifications and\n                // reset the timeline.\n                this.client.resetNotifTimelineSet();\n                this.registerStateListeners(room);\n            }\n        } */\n\n        await this.injectRoomEvents(room, stateEvents, timelineEvents, roomData.num_live);\n\n        // we deliberately don't add ephemeral events to the timeline\n        room.addEphemeralEvents(ephemeralEvents);\n\n        // local fields must be set before any async calls because call site assumes\n        // synchronous execution prior to emitting SlidingSyncState.Complete\n        room.updateMyMembership(KnownMembership.Join);\n\n        room.recalculate();\n        if (roomData.initial) {\n            client.store.storeRoom(room);\n            client.emit(ClientEvent.Room, room);\n        }\n\n        // check if any timeline events should bing and add them to the notifEvents array:\n        // we'll purge this once we've fully processed the sync response\n        this.addNotifications(timelineEvents);\n\n        const processRoomEvent = async (e: MatrixEvent): Promise<void> => {\n            client.emit(ClientEvent.Event, e);\n            if (e.isState() && e.getType() == EventType.RoomEncryption && this.syncOpts.cryptoCallbacks) {\n                await this.syncOpts.cryptoCallbacks.onCryptoEvent(room, e);\n            }\n        };\n\n        await promiseMapSeries(stateEvents, processRoomEvent);\n        await promiseMapSeries(timelineEvents, processRoomEvent);\n        ephemeralEvents.forEach(function (e) {\n            client.emit(ClientEvent.Event, e);\n        });\n\n        // Decrypt only the last message in all rooms to make sure we can generate a preview\n        // And decrypt all events after the recorded read receipt to ensure an accurate\n        // notification count\n        room.decryptCriticalEvents();\n    }\n\n    /**\n     * Injects events into a room's model.\n     * @param stateEventList - A list of state events. This is the state\n     * at the *END* of the timeline list if it is supplied.\n     * @param timelineEventList - A list of timeline events. Lower index\n     * is earlier in time. Higher index is later.\n     * @param numLive - the number of events in timelineEventList which just happened,\n     * supplied from the server.\n     */\n    public async injectRoomEvents(\n        room: Room,\n        stateEventList: MatrixEvent[],\n        timelineEventList: MatrixEvent[] = [],\n        numLive: number = 0,\n    ): Promise<void> {\n        // If there are no events in the timeline yet, initialise it with\n        // the given state events\n        const liveTimeline = room.getLiveTimeline();\n        const timelineWasEmpty = liveTimeline.getEvents().length == 0;\n        if (timelineWasEmpty) {\n            // Passing these events into initialiseState will freeze them, so we need\n            // to compute and cache the push actions for them now, otherwise sync dies\n            // with an attempt to assign to read only property.\n            // XXX: This is pretty horrible and is assuming all sorts of behaviour from\n            // these functions that it shouldn't be. We should probably either store the\n            // push actions cache elsewhere so we can freeze MatrixEvents, or otherwise\n            // find some solution where MatrixEvents are immutable but allow for a cache\n            // field.\n            for (const ev of stateEventList) {\n                this.client.getPushActionsForEvent(ev);\n            }\n            liveTimeline.initialiseState(stateEventList);\n        }\n\n        // If the timeline wasn't empty, we process the state events here: they're\n        // defined as updates to the state before the start of the timeline, so this\n        // starts to roll the state forward.\n        // XXX: That's what we *should* do, but this can happen if we were previously\n        // peeking in a room, in which case we obviously do *not* want to add the\n        // state events here onto the end of the timeline. Historically, the js-sdk\n        // has just set these new state events on the old and new state. This seems\n        // very wrong because there could be events in the timeline that diverge the\n        // state, in which case this is going to leave things out of sync. However,\n        // for now I think it;s best to behave the same as the code has done previously.\n        if (!timelineWasEmpty) {\n            // XXX: As above, don't do this...\n            //room.addLiveEvents(stateEventList || []);\n            // Do this instead...\n            room.oldState.setStateEvents(stateEventList);\n            room.currentState.setStateEvents(stateEventList);\n        }\n\n        // the timeline is broken into 'live' events which just happened and normal timeline events\n        // which are still to be appended to the end of the live timeline but happened a while ago.\n        // The live events are marked as fromCache=false to ensure that downstream components know\n        // this is a live event, not historical (from a remote server cache).\n\n        let liveTimelineEvents: MatrixEvent[] = [];\n        if (numLive > 0) {\n            // last numLive events are live\n            liveTimelineEvents = timelineEventList.slice(-1 * numLive);\n            // everything else is not live\n            timelineEventList = timelineEventList.slice(0, -1 * liveTimelineEvents.length);\n        }\n\n        // Execute the timeline events.\n        // This also needs to be done before running push rules on the events as they need\n        // to be decorated with sender etc.\n        await room.addLiveEvents(timelineEventList, {\n            fromCache: true,\n            addToState: false,\n        });\n        if (liveTimelineEvents.length > 0) {\n            await room.addLiveEvents(liveTimelineEvents, {\n                fromCache: false,\n                addToState: false,\n            });\n        }\n\n        room.recalculate();\n\n        // resolve invites now we have set the latest state\n        this.resolveInvites(room);\n    }\n\n    private resolveInvites(room: Room): void {\n        if (!room || !this.opts.resolveInvitesToProfiles) {\n            return;\n        }\n        const client = this.client;\n        // For each invited room member we want to give them a displayname/avatar url\n        // if they have one (the m.room.member invites don't contain this).\n        room.getMembersWithMembership(KnownMembership.Invite).forEach(function (member) {\n            if (member.requestedProfileInfo) return;\n            member.requestedProfileInfo = true;\n            // try to get a cached copy first.\n            const user = client.getUser(member.userId);\n            let promise: ReturnType<MatrixClient[\"getProfileInfo\"]>;\n            if (user) {\n                promise = Promise.resolve({\n                    avatar_url: user.avatarUrl,\n                    displayname: user.displayName,\n                });\n            } else {\n                promise = client.getProfileInfo(member.userId);\n            }\n            promise.then(\n                function (info) {\n                    // slightly naughty by doctoring the invite event but this means all\n                    // the code paths remain the same between invite/join display name stuff\n                    // which is a worthy trade-off for some minor pollution.\n                    const inviteEvent = member.events.member!;\n                    if (inviteEvent.getContent().membership !== KnownMembership.Invite) {\n                        // between resolving and now they have since joined, so don't clobber\n                        return;\n                    }\n                    inviteEvent.getContent().avatar_url = info.avatar_url;\n                    inviteEvent.getContent().displayname = info.displayname;\n                    // fire listeners\n                    member.setMembershipEvent(inviteEvent, room.currentState);\n                },\n                function (_err) {\n                    // OH WELL.\n                },\n            );\n        });\n    }\n\n    public retryImmediately(): boolean {\n        return true;\n    }\n\n    /**\n     * Main entry point. Blocks until stop() is called.\n     */\n    public async sync(): Promise<void> {\n        logger.debug(\"Sliding sync init loop\");\n\n        //   1) We need to get push rules so we can check if events should bing as we get\n        //      them from /sync.\n        while (!this.client.isGuest()) {\n            try {\n                logger.debug(\"Getting push rules...\");\n                const result = await this.client.getPushRules();\n                logger.debug(\"Got push rules\");\n                this.client.pushRules = result;\n                break;\n            } catch (err) {\n                logger.error(\"Getting push rules failed\", err);\n                if (this.shouldAbortSync(<MatrixError>err)) {\n                    return;\n                }\n            }\n        }\n\n        // start syncing\n        await this.slidingSync.start();\n    }\n\n    /**\n     * Stops the sync object from syncing.\n     */\n    public stop(): void {\n        logger.debug(\"SyncApi.stop\");\n        this.slidingSync.stop();\n    }\n\n    /**\n     * Sets the sync state and emits an event to say so\n     * @param newState - The new state string\n     * @param data - Object of additional data to emit in the event\n     */\n    private updateSyncState(newState: SyncState, data?: ISyncStateData): void {\n        const old = this.syncState;\n        this.syncState = newState;\n        this.syncStateData = data;\n        this.client.emit(ClientEvent.Sync, this.syncState, old, data);\n    }\n\n    /**\n     * Takes a list of timelineEvents and adds and adds to notifEvents\n     * as appropriate.\n     * This must be called after the room the events belong to has been stored.\n     *\n     * @param timelineEventList - A list of timeline events. Lower index\n     * is earlier in time. Higher index is later.\n     */\n    private addNotifications(timelineEventList: MatrixEvent[]): void {\n        // gather our notifications into this.notifEvents\n        if (!this.client.getNotifTimelineSet()) {\n            return;\n        }\n        for (const timelineEvent of timelineEventList) {\n            const pushActions = this.client.getPushActionsForEvent(timelineEvent);\n            if (pushActions && pushActions.notify && pushActions.tweaks && pushActions.tweaks.highlight) {\n                this.notifEvents.push(timelineEvent);\n            }\n        }\n    }\n\n    /**\n     * Purge any events in the notifEvents array. Used after a /sync has been complete.\n     * This should not be called at a per-room scope (e.g in onRoomData) because otherwise the ordering\n     * will be messed up e.g room A gets a bing, room B gets a newer bing, but both in the same /sync\n     * response. If we purge at a per-room scope then we could process room B before room A leading to\n     * room B appearing earlier in the notifications timeline, even though it has the higher origin_server_ts.\n     */\n    private purgeNotifications(): void {\n        this.notifEvents.sort(function (a, b) {\n            return a.getTs() - b.getTs();\n        });\n        this.notifEvents.forEach((event) => {\n            this.client.getNotifTimelineSet()?.addLiveEvent(event, { addToState: false });\n        });\n        this.notifEvents = [];\n    }\n}\n\nfunction ensureNameEvent(client: MatrixClient, roomId: string, roomData: MSC3575RoomData): MSC3575RoomData {\n    // make sure m.room.name is in required_state if there is a name, replacing anything previously\n    // there if need be. This ensures clients transparently 'calculate' the right room name. Native\n    // sliding sync clients should just read the \"name\" field.\n    if (!roomData.name) {\n        return roomData;\n    }\n    for (const stateEvent of roomData.required_state) {\n        if (stateEvent.type === EventType.RoomName && stateEvent.state_key === \"\") {\n            stateEvent.content = {\n                name: roomData.name,\n            };\n            return roomData;\n        }\n    }\n    roomData.required_state.push({\n        event_id: \"$fake-sliding-sync-name-event-\" + roomId,\n        state_key: \"\",\n        type: EventType.RoomName,\n        content: {\n            name: roomData.name,\n        },\n        sender: client.getUserId()!,\n        origin_server_ts: new Date().getTime(),\n    });\n    return roomData;\n}\n\ntype TaggedEvent = (IStrippedState | IRoomEvent | IStateEvent | IMinimalEvent) & { room_id?: string };\n\n// Helper functions which set up JS SDK structs are below and are identical to the sync v2 counterparts,\n// just outside the class.\nfunction mapEvents(client: MatrixClient, roomId: string | undefined, events: object[], decrypt = true): MatrixEvent[] {\n    const mapper = client.getEventMapper({ decrypt });\n    return (events as TaggedEvent[]).map(function (e) {\n        e.room_id = roomId;\n        return mapper(e);\n    });\n}\n\nfunction processEphemeralEvents(client: MatrixClient, roomId: string, ephEvents: IMinimalEvent[]): void {\n    const ephemeralEvents = mapEvents(client, roomId, ephEvents);\n    const room = client.getRoom(roomId);\n    if (!room) {\n        logger.warn(\"got ephemeral events for room but room doesn't exist on client:\", roomId);\n        return;\n    }\n    room.addEphemeralEvents(ephemeralEvents);\n    ephemeralEvents.forEach((e) => {\n        client.emit(ClientEvent.Event, e);\n    });\n}\n","/*\nCopyright 2022 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { logger } from \"./logger.ts\";\nimport { type MatrixClient } from \"./client.ts\";\nimport { type IRoomEvent, type IStateEvent } from \"./sync-accumulator.ts\";\nimport { TypedEventEmitter } from \"./models/typed-event-emitter.ts\";\nimport { sleep, type IDeferred, defer } from \"./utils.ts\";\nimport { type HTTPError } from \"./http-api/index.ts\";\n\n// /sync requests allow you to set a timeout= but the request may continue\n// beyond that and wedge forever, so we need to track how long we are willing\n// to keep open the connection. This constant is *ADDED* to the timeout= value\n// to determine the max time we're willing to wait.\nconst BUFFER_PERIOD_MS = 10 * 1000;\n\nexport const MSC3575_WILDCARD = \"*\";\nexport const MSC3575_STATE_KEY_ME = \"$ME\";\nexport const MSC3575_STATE_KEY_LAZY = \"$LAZY\";\n\n/**\n * Represents a subscription to a room or set of rooms. Controls which events are returned.\n */\nexport interface MSC3575RoomSubscription {\n    required_state?: string[][];\n    timeline_limit?: number;\n    include_old_rooms?: MSC3575RoomSubscription;\n}\n\n/**\n * Controls which rooms are returned in a given list.\n */\nexport interface MSC3575Filter {\n    is_dm?: boolean;\n    is_encrypted?: boolean;\n    is_invite?: boolean;\n    room_name_like?: string;\n    room_types?: string[];\n    not_room_types?: string[];\n    spaces?: string[];\n    tags?: string[];\n    not_tags?: string[];\n}\n\n/**\n * Represents a list subscription.\n */\nexport interface MSC3575List extends MSC3575RoomSubscription {\n    ranges: number[][];\n    sort?: string[];\n    filters?: MSC3575Filter;\n    slow_get_all_rooms?: boolean;\n}\n\n/**\n * A complete Sliding Sync request.\n */\nexport interface MSC3575SlidingSyncRequest {\n    // json body params\n    lists?: Record<string, MSC3575List>;\n    unsubscribe_rooms?: string[];\n    room_subscriptions?: Record<string, MSC3575RoomSubscription>;\n    extensions?: object;\n    txn_id?: string;\n\n    // query params\n    pos?: string;\n    timeout?: number;\n    clientTimeout?: number;\n}\n\nexport interface MSC3575RoomData {\n    name: string;\n    required_state: IStateEvent[];\n    timeline: (IRoomEvent | IStateEvent)[];\n    notification_count?: number;\n    highlight_count?: number;\n    joined_count?: number;\n    invited_count?: number;\n    invite_state?: IStateEvent[];\n    initial?: boolean;\n    limited?: boolean;\n    is_dm?: boolean;\n    prev_batch?: string;\n    num_live?: number;\n}\n\ninterface ListResponse {\n    count: number;\n    ops: Operation[];\n}\n\ninterface BaseOperation {\n    op: string;\n}\n\ninterface DeleteOperation extends BaseOperation {\n    op: \"DELETE\";\n    index: number;\n}\n\ninterface InsertOperation extends BaseOperation {\n    op: \"INSERT\";\n    index: number;\n    room_id: string;\n}\n\ninterface InvalidateOperation extends BaseOperation {\n    op: \"INVALIDATE\";\n    range: [number, number];\n}\n\ninterface SyncOperation extends BaseOperation {\n    op: \"SYNC\";\n    range: [number, number];\n    room_ids: string[];\n}\n\ntype Operation = DeleteOperation | InsertOperation | InvalidateOperation | SyncOperation;\n\n/**\n * A complete Sliding Sync response\n */\nexport interface MSC3575SlidingSyncResponse {\n    pos: string;\n    txn_id?: string;\n    lists: Record<string, ListResponse>;\n    rooms: Record<string, MSC3575RoomData>;\n    extensions: Record<string, object>;\n}\n\nexport enum SlidingSyncState {\n    /**\n     * Fired by SlidingSyncEvent.Lifecycle event immediately before processing the response.\n     */\n    RequestFinished = \"FINISHED\",\n    /**\n     * Fired by SlidingSyncEvent.Lifecycle event immediately after all room data listeners have been\n     * invoked, but before list listeners.\n     */\n    Complete = \"COMPLETE\",\n}\n\n/**\n * Internal Class. SlidingList represents a single list in sliding sync. The list can have filters,\n * multiple sliding windows, and maintains the index-\\>room_id mapping.\n */\nclass SlidingList {\n    private list!: MSC3575List;\n    private isModified?: boolean;\n\n    // returned data\n    public roomIndexToRoomId: Record<number, string> = {};\n    public joinedCount = 0;\n\n    /**\n     * Construct a new sliding list.\n     * @param list - The range, sort and filter values to use for this list.\n     */\n    public constructor(list: MSC3575List) {\n        this.replaceList(list);\n    }\n\n    /**\n     * Mark this list as modified or not. Modified lists will return sticky params with calls to getList.\n     * This is useful for the first time the list is sent, or if the list has changed in some way.\n     * @param modified - True to mark this list as modified so all sticky parameters will be re-sent.\n     */\n    public setModified(modified: boolean): void {\n        this.isModified = modified;\n    }\n\n    /**\n     * Update the list range for this list. Does not affect modified status as list ranges are non-sticky.\n     * @param newRanges - The new ranges for the list\n     */\n    public updateListRange(newRanges: number[][]): void {\n        this.list.ranges = JSON.parse(JSON.stringify(newRanges));\n    }\n\n    /**\n     * Replace list parameters. All fields will be replaced with the new list parameters.\n     * @param list - The new list parameters\n     */\n    public replaceList(list: MSC3575List): void {\n        list.filters = list.filters ?? {};\n        list.ranges = list.ranges ?? [];\n        this.list = JSON.parse(JSON.stringify(list));\n        this.isModified = true;\n\n        // reset values as the join count may be very different (if filters changed) including the rooms\n        // (e.g. sort orders or sliding window ranges changed)\n\n        // the constantly changing sliding window ranges. Not an array for performance reasons\n        // E.g. tracking ranges 0-99, 500-599, we don't want to have a 600 element array\n        this.roomIndexToRoomId = {};\n        // the total number of joined rooms according to the server, always >= len(roomIndexToRoomId)\n        this.joinedCount = 0;\n    }\n\n    /**\n     * Return a copy of the list suitable for a request body.\n     * @param forceIncludeAllParams - True to forcibly include all params even if the list\n     * hasn't been modified. Callers may want to do this if they are modifying the list prior to calling\n     * updateList.\n     */\n    public getList(forceIncludeAllParams: boolean): MSC3575List {\n        let list = {\n            ranges: JSON.parse(JSON.stringify(this.list.ranges)),\n        };\n        if (this.isModified || forceIncludeAllParams) {\n            list = JSON.parse(JSON.stringify(this.list));\n        }\n        return list;\n    }\n\n    /**\n     * Check if a given index is within the list range. This is required even though the /sync API\n     * provides explicit updates with index positions because of the following situation:\n     *   0 1 2 3 4 5 6 7 8   indexes\n     *   a b c       d e f   COMMANDS: SYNC 0 2 a b c; SYNC 6 8 d e f;\n     *   a b c       d _ f   COMMAND: DELETE 7;\n     *   e a b c       d f   COMMAND: INSERT 0 e;\n     *   c=3 is wrong as we are not tracking it, ergo we need to see if `i` is in range else drop it\n     * @param i - The index to check\n     * @returns True if the index is within a sliding window\n     */\n    public isIndexInRange(i: number): boolean {\n        for (const r of this.list.ranges) {\n            if (r[0] <= i && i <= r[1]) {\n                return true;\n            }\n        }\n        return false;\n    }\n}\n\n/**\n * When onResponse extensions should be invoked: before or after processing the main response.\n */\nexport enum ExtensionState {\n    // Call onResponse before processing the response body. This is useful when your extension is\n    // preparing the ground for the response body e.g. processing to-device messages before the\n    // encrypted event arrives.\n    PreProcess = \"ExtState.PreProcess\",\n    // Call onResponse after processing the response body. This is useful when your extension is\n    // decorating data from the client, and you rely on MatrixClient.getRoom returning the Room object\n    // e.g. room account data.\n    PostProcess = \"ExtState.PostProcess\",\n}\n\n/**\n * An interface that must be satisfied to register extensions\n */\nexport interface Extension<Req extends object, Res extends object> {\n    /**\n     * The extension name to go under 'extensions' in the request body.\n     * @returns The JSON key.\n     */\n    name(): string;\n    /**\n     * A function which is called when the request JSON is being formed.\n     * Returns the data to insert under this key.\n     * @param isInitial - True when this is part of the initial request (send sticky params)\n     * @returns The request JSON to send.\n     */\n    onRequest(isInitial: boolean): Req | undefined;\n    /**\n     * A function which is called when there is response JSON under this extension.\n     * @param data - The response JSON under the extension name.\n     */\n    onResponse(data: Res): Promise<void>;\n    /**\n     * Controls when onResponse should be called.\n     * @returns The state when it should be called.\n     */\n    when(): ExtensionState;\n}\n\n/**\n * Events which can be fired by the SlidingSync class. These are designed to provide different levels\n * of information when processing sync responses.\n *  - RoomData: concerns rooms, useful for SlidingSyncSdk to update its knowledge of rooms.\n *  - Lifecycle: concerns callbacks at various well-defined points in the sync process.\n *  - List: concerns lists, useful for UI layers to re-render room lists.\n * Specifically, the order of event invocation is:\n *  - Lifecycle (state=RequestFinished)\n *  - RoomData (N times)\n *  - Lifecycle (state=Complete)\n *  - List (at most once per list)\n */\nexport enum SlidingSyncEvent {\n    /**\n     * This event fires when there are updates for a room. Fired as and when rooms are encountered\n     * in the response.\n     */\n    RoomData = \"SlidingSync.RoomData\",\n    /**\n     * This event fires at various points in the /sync loop lifecycle.\n     *  - SlidingSyncState.RequestFinished: Fires after we receive a valid response but before the\n     * response has been processed. Perform any pre-process steps here. If there was a problem syncing,\n     * `err` will be set (e.g network errors).\n     *  - SlidingSyncState.Complete: Fires after all SlidingSyncEvent.RoomData have been fired but before\n     * SlidingSyncEvent.List.\n     */\n    Lifecycle = \"SlidingSync.Lifecycle\",\n    /**\n     * This event fires whenever there has been a change to this list index. It fires exactly once\n     * per list, even if there were multiple operations for the list.\n     * It fires AFTER Lifecycle and RoomData events.\n     */\n    List = \"SlidingSync.List\",\n}\n\nexport type SlidingSyncEventHandlerMap = {\n    [SlidingSyncEvent.RoomData]: (roomId: string, roomData: MSC3575RoomData) => Promise<void> | void;\n    [SlidingSyncEvent.Lifecycle]: (\n        state: SlidingSyncState,\n        resp: MSC3575SlidingSyncResponse | null,\n        err?: Error,\n    ) => void;\n    [SlidingSyncEvent.List]: (listKey: string, joinedCount: number, roomIndexToRoomId: Record<number, string>) => void;\n};\n\n/**\n * SlidingSync is a high-level data structure which controls the majority of sliding sync.\n * It has no hooks into JS SDK except for needing a MatrixClient to perform the HTTP request.\n * This means this class (and everything it uses) can be used in isolation from JS SDK if needed.\n * To hook this up with the JS SDK, you need to use SlidingSyncSdk.\n */\nexport class SlidingSync extends TypedEventEmitter<SlidingSyncEvent, SlidingSyncEventHandlerMap> {\n    private lists: Map<string, SlidingList>;\n    private listModifiedCount = 0;\n    private terminated = false;\n    // flag set when resend() is called because we cannot rely on detecting AbortError in JS SDK :(\n    private needsResend = false;\n    // the txn_id to send with the next request.\n    private txnId: string | null = null;\n    // a list (in chronological order of when they were sent) of objects containing the txn ID and\n    // a defer to resolve/reject depending on whether they were successfully sent or not.\n    private txnIdDefers: (IDeferred<string> & { txnId: string })[] = [];\n    // map of extension name to req/resp handler\n    private extensions: Record<string, Extension<any, any>> = {};\n\n    private desiredRoomSubscriptions = new Set<string>(); // the *desired* room subscriptions\n    private confirmedRoomSubscriptions = new Set<string>();\n\n    // map of custom subscription name to the subscription\n    private customSubscriptions: Map<string, MSC3575RoomSubscription> = new Map();\n    // map of room ID to custom subscription name\n    private roomIdToCustomSubscription: Map<string, string> = new Map();\n\n    private pendingReq?: Promise<MSC3575SlidingSyncResponse>;\n    private abortController?: AbortController;\n\n    /**\n     * Create a new sliding sync instance\n     * @param proxyBaseUrl - The base URL of the sliding sync proxy\n     * @param lists - The lists to use for sliding sync.\n     * @param roomSubscriptionInfo - The params to use for room subscriptions.\n     * @param client - The client to use for /sync calls.\n     * @param timeoutMS - The number of milliseconds to wait for a response.\n     */\n    public constructor(\n        private readonly proxyBaseUrl: string,\n        lists: Map<string, MSC3575List>,\n        private roomSubscriptionInfo: MSC3575RoomSubscription,\n        private readonly client: MatrixClient,\n        private readonly timeoutMS: number,\n    ) {\n        super();\n        this.lists = new Map<string, SlidingList>();\n        lists.forEach((list, key) => {\n            this.lists.set(key, new SlidingList(list));\n        });\n    }\n\n    /**\n     * Add a custom room subscription, referred to by an arbitrary name. If a subscription with this\n     * name already exists, it is replaced. No requests are sent by calling this method.\n     * @param name - The name of the subscription. Only used to reference this subscription in\n     * useCustomSubscription.\n     * @param sub - The subscription information.\n     */\n    public addCustomSubscription(name: string, sub: MSC3575RoomSubscription): void {\n        if (this.customSubscriptions.has(name)) {\n            logger.warn(`addCustomSubscription: ${name} already exists as a custom subscription, ignoring.`);\n            return;\n        }\n        this.customSubscriptions.set(name, sub);\n    }\n\n    /**\n     * Use a custom subscription previously added via addCustomSubscription. No requests are sent\n     * by calling this method. Use modifyRoomSubscriptions to resend subscription information.\n     * @param roomId - The room to use the subscription in.\n     * @param name - The name of the subscription. If this name is unknown, the default subscription\n     * will be used.\n     */\n    public useCustomSubscription(roomId: string, name: string): void {\n        // We already know about this custom subscription, as it is immutable,\n        // we don't need to unconfirm the subscription.\n        if (this.roomIdToCustomSubscription.get(roomId) === name) {\n            return;\n        }\n        this.roomIdToCustomSubscription.set(roomId, name);\n        // unconfirm this subscription so a resend() will send it up afresh.\n        this.confirmedRoomSubscriptions.delete(roomId);\n    }\n\n    /**\n     * Get the room index data for a list.\n     * @param key - The list key\n     * @returns The list data which contains the rooms in this list\n     */\n    public getListData(key: string): { joinedCount: number; roomIndexToRoomId: Record<number, string> } | null {\n        const data = this.lists.get(key);\n        if (!data) {\n            return null;\n        }\n        return {\n            joinedCount: data.joinedCount,\n            roomIndexToRoomId: Object.assign({}, data.roomIndexToRoomId),\n        };\n    }\n\n    /**\n     * Get the full request list parameters for a list index. This function is provided for callers to use\n     * in conjunction with setList to update fields on an existing list.\n     * @param key - The list key to get the params for.\n     * @returns A copy of the list params or undefined.\n     */\n    public getListParams(key: string): MSC3575List | null {\n        const params = this.lists.get(key);\n        if (!params) {\n            return null;\n        }\n        return params.getList(true);\n    }\n\n    /**\n     * Set new ranges for an existing list. Calling this function when _only_ the ranges have changed\n     * is more efficient than calling setList(index,list) as this function won't resend sticky params,\n     * whereas setList always will.\n     * @param key - The list key to modify\n     * @param ranges - The new ranges to apply.\n     * @returns A promise which resolves to the transaction ID when it has been received down sync\n     * (or rejects with the transaction ID if the action was not applied e.g the request was cancelled\n     * immediately after sending, in which case the action will be applied in the subsequent request)\n     */\n    public setListRanges(key: string, ranges: number[][]): Promise<string> {\n        const list = this.lists.get(key);\n        if (!list) {\n            return Promise.reject(new Error(\"no list with key \" + key));\n        }\n        list.updateListRange(ranges);\n        return this.resend();\n    }\n\n    /**\n     * Add or replace a list. Calling this function will interrupt the /sync request to resend new\n     * lists.\n     * @param key - The key to modify\n     * @param list - The new list parameters.\n     * @returns A promise which resolves to the transaction ID when it has been received down sync\n     * (or rejects with the transaction ID if the action was not applied e.g the request was cancelled\n     * immediately after sending, in which case the action will be applied in the subsequent request)\n     */\n    public setList(key: string, list: MSC3575List): Promise<string> {\n        const existingList = this.lists.get(key);\n        if (existingList) {\n            existingList.replaceList(list);\n            this.lists.set(key, existingList);\n        } else {\n            this.lists.set(key, new SlidingList(list));\n        }\n        this.listModifiedCount += 1;\n        return this.resend();\n    }\n\n    /**\n     * Get the room subscriptions for the sync API.\n     * @returns A copy of the desired room subscriptions.\n     */\n    public getRoomSubscriptions(): Set<string> {\n        return new Set(Array.from(this.desiredRoomSubscriptions));\n    }\n\n    /**\n     * Modify the room subscriptions for the sync API. Calling this function will interrupt the\n     * /sync request to resend new subscriptions. If the /sync stream has not started, this will\n     * prepare the room subscriptions for when start() is called.\n     * @param s - The new desired room subscriptions.\n     * @returns A promise which resolves to the transaction ID when it has been received down sync\n     * (or rejects with the transaction ID if the action was not applied e.g the request was cancelled\n     * immediately after sending, in which case the action will be applied in the subsequent request)\n     */\n    public modifyRoomSubscriptions(s: Set<string>): Promise<string> {\n        this.desiredRoomSubscriptions = s;\n        return this.resend();\n    }\n\n    /**\n     * Modify which events to retrieve for room subscriptions. Invalidates all room subscriptions\n     * such that they will be sent up afresh.\n     * @param rs - The new room subscription fields to fetch.\n     * @returns A promise which resolves to the transaction ID when it has been received down sync\n     * (or rejects with the transaction ID if the action was not applied e.g the request was cancelled\n     * immediately after sending, in which case the action will be applied in the subsequent request)\n     */\n    public modifyRoomSubscriptionInfo(rs: MSC3575RoomSubscription): Promise<string> {\n        this.roomSubscriptionInfo = rs;\n        this.confirmedRoomSubscriptions = new Set<string>();\n        return this.resend();\n    }\n\n    /**\n     * Register an extension to send with the /sync request.\n     * @param ext - The extension to register.\n     */\n    public registerExtension(ext: Extension<any, any>): void {\n        if (this.extensions[ext.name()]) {\n            throw new Error(`registerExtension: ${ext.name()} already exists as an extension`);\n        }\n        this.extensions[ext.name()] = ext;\n    }\n\n    private getExtensionRequest(isInitial: boolean): Record<string, object | undefined> {\n        const ext: Record<string, object | undefined> = {};\n        Object.keys(this.extensions).forEach((extName) => {\n            ext[extName] = this.extensions[extName].onRequest(isInitial);\n        });\n        return ext;\n    }\n\n    private async onPreExtensionsResponse(ext: Record<string, object>): Promise<void> {\n        await Promise.all(\n            Object.keys(ext).map(async (extName) => {\n                if (this.extensions[extName].when() == ExtensionState.PreProcess) {\n                    await this.extensions[extName].onResponse(ext[extName]);\n                }\n            }),\n        );\n    }\n\n    private async onPostExtensionsResponse(ext: Record<string, object>): Promise<void> {\n        await Promise.all(\n            Object.keys(ext).map(async (extName) => {\n                if (this.extensions[extName].when() == ExtensionState.PostProcess) {\n                    await this.extensions[extName].onResponse(ext[extName]);\n                }\n            }),\n        );\n    }\n\n    /**\n     * Invoke all attached room data listeners.\n     * @param roomId - The room which received some data.\n     * @param roomData - The raw sliding sync response JSON.\n     */\n    private async invokeRoomDataListeners(roomId: string, roomData: MSC3575RoomData): Promise<void> {\n        if (!roomData.required_state) {\n            roomData.required_state = [];\n        }\n        if (!roomData.timeline) {\n            roomData.timeline = [];\n        }\n        await this.emitPromised(SlidingSyncEvent.RoomData, roomId, roomData);\n    }\n\n    /**\n     * Invoke all attached lifecycle listeners.\n     * @param state - The Lifecycle state\n     * @param resp - The raw sync response JSON\n     * @param err - Any error that occurred when making the request e.g. network errors.\n     */\n    private invokeLifecycleListeners(\n        state: SlidingSyncState,\n        resp: MSC3575SlidingSyncResponse | null,\n        err?: Error,\n    ): void {\n        this.emit(SlidingSyncEvent.Lifecycle, state, resp, err);\n    }\n\n    private shiftRight(listKey: string, hi: number, low: number): void {\n        const list = this.lists.get(listKey);\n        if (!list) {\n            return;\n        }\n        //     l   h\n        // 0,1,2,3,4 <- before\n        // 0,1,2,2,3 <- after, hi is deleted and low is duplicated\n        for (let i = hi; i > low; i--) {\n            if (list.isIndexInRange(i)) {\n                list.roomIndexToRoomId[i] = list.roomIndexToRoomId[i - 1];\n            }\n        }\n    }\n\n    private shiftLeft(listKey: string, hi: number, low: number): void {\n        const list = this.lists.get(listKey);\n        if (!list) {\n            return;\n        }\n        //     l   h\n        // 0,1,2,3,4 <- before\n        // 0,1,3,4,4 <- after, low is deleted and hi is duplicated\n        for (let i = low; i < hi; i++) {\n            if (list.isIndexInRange(i)) {\n                list.roomIndexToRoomId[i] = list.roomIndexToRoomId[i + 1];\n            }\n        }\n    }\n\n    private removeEntry(listKey: string, index: number): void {\n        const list = this.lists.get(listKey);\n        if (!list) {\n            return;\n        }\n        // work out the max index\n        let max = -1;\n        for (const n in list.roomIndexToRoomId) {\n            if (Number(n) > max) {\n                max = Number(n);\n            }\n        }\n        if (max < 0 || index > max) {\n            return;\n        }\n        // Everything higher than the gap needs to be shifted left.\n        this.shiftLeft(listKey, max, index);\n        delete list.roomIndexToRoomId[max];\n    }\n\n    private addEntry(listKey: string, index: number): void {\n        const list = this.lists.get(listKey);\n        if (!list) {\n            return;\n        }\n        // work out the max index\n        let max = -1;\n        for (const n in list.roomIndexToRoomId) {\n            if (Number(n) > max) {\n                max = Number(n);\n            }\n        }\n        if (max < 0 || index > max) {\n            return;\n        }\n        // Everything higher than the gap needs to be shifted right, +1 so we don't delete the highest element\n        this.shiftRight(listKey, max + 1, index);\n    }\n\n    private processListOps(list: ListResponse, listKey: string): void {\n        let gapIndex = -1;\n        const listData = this.lists.get(listKey);\n        if (!listData) {\n            return;\n        }\n        list.ops.forEach((op: Operation) => {\n            if (!listData) {\n                return;\n            }\n            switch (op.op) {\n                case \"DELETE\": {\n                    logger.debug(\"DELETE\", listKey, op.index, \";\");\n                    delete listData.roomIndexToRoomId[op.index];\n                    if (gapIndex !== -1) {\n                        // we already have a DELETE operation to process, so process it.\n                        this.removeEntry(listKey, gapIndex);\n                    }\n                    gapIndex = op.index;\n                    break;\n                }\n                case \"INSERT\": {\n                    logger.debug(\"INSERT\", listKey, op.index, op.room_id, \";\");\n                    if (listData.roomIndexToRoomId[op.index]) {\n                        // something is in this space, shift items out of the way\n                        if (gapIndex < 0) {\n                            // we haven't been told where to shift from, so make way for a new room entry.\n                            this.addEntry(listKey, op.index);\n                        } else if (gapIndex > op.index) {\n                            // the gap is further down the list, shift every element to the right\n                            // starting at the gap so we can just shift each element in turn:\n                            // [A,B,C,_] gapIndex=3, op.index=0\n                            // [A,B,C,C] i=3\n                            // [A,B,B,C] i=2\n                            // [A,A,B,C] i=1\n                            // Terminate. We'll assign into op.index next.\n                            this.shiftRight(listKey, gapIndex, op.index);\n                        } else if (gapIndex < op.index) {\n                            // the gap is further up the list, shift every element to the left\n                            // starting at the gap so we can just shift each element in turn\n                            this.shiftLeft(listKey, op.index, gapIndex);\n                        }\n                    }\n                    // forget the gap, we don't need it anymore. This is outside the check for\n                    // a room being present in this index position because INSERTs always universally\n                    // forget the gap, not conditionally based on the presence of a room in the INSERT\n                    // position. Without this, DELETE 0; INSERT 0; would do the wrong thing.\n                    gapIndex = -1;\n                    listData.roomIndexToRoomId[op.index] = op.room_id;\n                    break;\n                }\n                case \"INVALIDATE\": {\n                    const startIndex = op.range[0];\n                    for (let i = startIndex; i <= op.range[1]; i++) {\n                        delete listData.roomIndexToRoomId[i];\n                    }\n                    logger.debug(\"INVALIDATE\", listKey, op.range[0], op.range[1], \";\");\n                    break;\n                }\n                case \"SYNC\": {\n                    const startIndex = op.range[0];\n                    for (let i = startIndex; i <= op.range[1]; i++) {\n                        const roomId = op.room_ids[i - startIndex];\n                        if (!roomId) {\n                            break; // we are at the end of list\n                        }\n                        listData.roomIndexToRoomId[i] = roomId;\n                    }\n                    logger.debug(\"SYNC\", listKey, op.range[0], op.range[1], (op.room_ids || []).join(\" \"), \";\");\n                    break;\n                }\n            }\n        });\n        if (gapIndex !== -1) {\n            // we already have a DELETE operation to process, so process it\n            // Everything higher than the gap needs to be shifted left.\n            this.removeEntry(listKey, gapIndex);\n        }\n    }\n\n    /**\n     * Resend a Sliding Sync request. Used when something has changed in the request. Resolves with\n     * the transaction ID of this request on success. Rejects with the transaction ID of this request\n     * on failure.\n     */\n    public resend(): Promise<string> {\n        if (this.needsResend && this.txnIdDefers.length > 0) {\n            // we already have a resend queued, so just return the same promise\n            return this.txnIdDefers[this.txnIdDefers.length - 1].promise;\n        }\n        this.needsResend = true;\n        this.txnId = this.client.makeTxnId();\n        const d = defer<string>();\n        this.txnIdDefers.push({\n            ...d,\n            txnId: this.txnId,\n        });\n        this.abortController?.abort();\n        this.abortController = new AbortController();\n        return d.promise;\n    }\n\n    private resolveTransactionDefers(txnId?: string): void {\n        if (!txnId) {\n            return;\n        }\n        // find the matching index\n        let txnIndex = -1;\n        for (let i = 0; i < this.txnIdDefers.length; i++) {\n            if (this.txnIdDefers[i].txnId === txnId) {\n                txnIndex = i;\n                break;\n            }\n        }\n        if (txnIndex === -1) {\n            // this shouldn't happen; we shouldn't be seeing txn_ids for things we don't know about,\n            // whine about it.\n            logger.warn(`resolveTransactionDefers: seen ${txnId} but it isn't a pending txn, ignoring.`);\n            return;\n        }\n        // This list is sorted in time, so if the input txnId ACKs in the middle of this array,\n        // then everything before it that hasn't been ACKed yet never will and we should reject them.\n        for (let i = 0; i < txnIndex; i++) {\n            this.txnIdDefers[i].reject(this.txnIdDefers[i].txnId);\n        }\n        this.txnIdDefers[txnIndex].resolve(txnId);\n        // clear out settled promises, including the one we resolved.\n        this.txnIdDefers = this.txnIdDefers.slice(txnIndex + 1);\n    }\n\n    /**\n     * Stop syncing with the server.\n     */\n    public stop(): void {\n        this.terminated = true;\n        this.abortController?.abort();\n        // remove all listeners so things can be GC'd\n        this.removeAllListeners(SlidingSyncEvent.Lifecycle);\n        this.removeAllListeners(SlidingSyncEvent.List);\n        this.removeAllListeners(SlidingSyncEvent.RoomData);\n    }\n\n    /**\n     * Re-setup this connection e.g in the event of an expired session.\n     */\n    private resetup(): void {\n        logger.warn(\"SlidingSync: resetting connection info\");\n        // any pending txn ID defers will be forgotten already by the server, so clear them out\n        this.txnIdDefers.forEach((d) => {\n            d.reject(d.txnId);\n        });\n        this.txnIdDefers = [];\n        // resend sticky params and de-confirm all subscriptions\n        this.lists.forEach((l) => {\n            l.setModified(true);\n        });\n        this.confirmedRoomSubscriptions = new Set<string>(); // leave desired ones alone though!\n        // reset the connection as we might be wedged\n        this.needsResend = true;\n        this.abortController?.abort();\n        this.abortController = new AbortController();\n    }\n\n    /**\n     * Start syncing with the server. Blocks until stopped.\n     */\n    public async start(): Promise<void> {\n        this.abortController = new AbortController();\n\n        let currentPos: string | undefined;\n        while (!this.terminated) {\n            this.needsResend = false;\n            let doNotUpdateList = false;\n            let resp: MSC3575SlidingSyncResponse | undefined;\n            try {\n                const listModifiedCount = this.listModifiedCount;\n                const reqLists: Record<string, MSC3575List> = {};\n                this.lists.forEach((l: SlidingList, key: string) => {\n                    reqLists[key] = l.getList(false);\n                });\n                const reqBody: MSC3575SlidingSyncRequest = {\n                    lists: reqLists,\n                    pos: currentPos,\n                    timeout: this.timeoutMS,\n                    clientTimeout: this.timeoutMS + BUFFER_PERIOD_MS,\n                    extensions: this.getExtensionRequest(currentPos === undefined),\n                };\n                // check if we are (un)subscribing to a room and modify request this one time for it\n                const newSubscriptions = difference(this.desiredRoomSubscriptions, this.confirmedRoomSubscriptions);\n                const unsubscriptions = difference(this.confirmedRoomSubscriptions, this.desiredRoomSubscriptions);\n                if (unsubscriptions.size > 0) {\n                    reqBody.unsubscribe_rooms = Array.from(unsubscriptions);\n                }\n                if (newSubscriptions.size > 0) {\n                    reqBody.room_subscriptions = {};\n                    for (const roomId of newSubscriptions) {\n                        const customSubName = this.roomIdToCustomSubscription.get(roomId);\n                        let sub = this.roomSubscriptionInfo;\n                        if (customSubName && this.customSubscriptions.has(customSubName)) {\n                            sub = this.customSubscriptions.get(customSubName)!;\n                        }\n                        reqBody.room_subscriptions[roomId] = sub;\n                    }\n                }\n                if (this.txnId) {\n                    reqBody.txn_id = this.txnId;\n                    this.txnId = null;\n                }\n                this.pendingReq = this.client.slidingSync(reqBody, this.proxyBaseUrl, this.abortController.signal);\n                resp = await this.pendingReq;\n                currentPos = resp.pos;\n                // update what we think we're subscribed to.\n                for (const roomId of newSubscriptions) {\n                    this.confirmedRoomSubscriptions.add(roomId);\n                }\n                for (const roomId of unsubscriptions) {\n                    this.confirmedRoomSubscriptions.delete(roomId);\n                }\n                if (listModifiedCount !== this.listModifiedCount) {\n                    // the lists have been modified whilst we were waiting for 'await' to return, but the abort()\n                    // call did nothing. It is NOT SAFE to modify the list array now. We'll process the response but\n                    // not update list pointers.\n                    logger.debug(\"list modified during await call, not updating list\");\n                    doNotUpdateList = true;\n                }\n                // mark all these lists as having been sent as sticky so we don't keep sending sticky params\n                this.lists.forEach((l) => {\n                    l.setModified(false);\n                });\n                // set default empty values so we don't need to null check\n                resp.lists = resp.lists ?? {};\n                resp.rooms = resp.rooms ?? {};\n                resp.extensions = resp.extensions ?? {};\n                Object.keys(resp.lists).forEach((key: string) => {\n                    const list = this.lists.get(key);\n                    if (!list || !resp) {\n                        return;\n                    }\n                    list.joinedCount = resp.lists[key].count;\n                });\n                this.invokeLifecycleListeners(SlidingSyncState.RequestFinished, resp);\n            } catch (err) {\n                if ((<HTTPError>err).httpStatus) {\n                    this.invokeLifecycleListeners(SlidingSyncState.RequestFinished, null, <Error>err);\n                    if ((<HTTPError>err).httpStatus === 400) {\n                        // session probably expired TODO: assign an errcode\n                        // so drop state and re-request\n                        this.resetup();\n                        currentPos = undefined;\n                        await sleep(50); // in case the 400 was for something else; don't tightloop\n                        continue;\n                    } // else fallthrough to generic error handling\n                } else if (this.needsResend || (<Error>err).name === \"AbortError\") {\n                    continue; // don't sleep as we caused this error by abort()ing the request.\n                }\n                logger.error(err);\n                await sleep(5000);\n            }\n            if (!resp) {\n                continue;\n            }\n            await this.onPreExtensionsResponse(resp.extensions);\n\n            for (const roomId in resp.rooms) {\n                await this.invokeRoomDataListeners(roomId, resp!.rooms[roomId]);\n            }\n\n            const listKeysWithUpdates: Set<string> = new Set();\n            if (!doNotUpdateList) {\n                for (const [key, list] of Object.entries(resp.lists)) {\n                    list.ops = list.ops ?? [];\n                    if (list.ops.length > 0) {\n                        listKeysWithUpdates.add(key);\n                    }\n                    this.processListOps(list, key);\n                }\n            }\n            this.invokeLifecycleListeners(SlidingSyncState.Complete, resp);\n            await this.onPostExtensionsResponse(resp.extensions);\n            listKeysWithUpdates.forEach((listKey: string) => {\n                const list = this.lists.get(listKey);\n                if (!list) {\n                    return;\n                }\n                this.emit(SlidingSyncEvent.List, listKey, list.joinedCount, Object.assign({}, list.roomIndexToRoomId));\n            });\n\n            this.resolveTransactionDefers(resp.txn_id);\n        }\n    }\n}\n\nconst difference = (setA: Set<string>, setB: Set<string>): Set<string> => {\n    const diff = new Set(setA);\n    for (const elem of setB) {\n        diff.delete(elem);\n    }\n    return diff;\n};\n","/*\nCopyright 2023 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { type IMinimalEvent } from \"./sync-accumulator.ts\";\nimport { EventType } from \"./@types/event.ts\";\nimport { isSupportedReceiptType, MapWithDefault, recursiveMapToObject } from \"./utils.ts\";\nimport { type IContent } from \"./models/event.ts\";\nimport { type ReceiptContent, type ReceiptType } from \"./@types/read_receipts.ts\";\n\ninterface AccumulatedReceipt {\n    data: IMinimalEvent;\n    type: ReceiptType;\n    eventId: string;\n}\n\n/**\n * Summarises the read receipts within a room. Used by the sync accumulator.\n *\n * Given receipts for users, picks the most recently-received one and provides\n * the results in a new fake receipt event returned from\n * buildAccumulatedReceiptEvent().\n *\n * Handles unthreaded receipts and receipts in each thread separately, so the\n * returned event contains the most recently received unthreaded receipt, and\n * the most recently received receipt in each thread.\n */\nexport class ReceiptAccumulator {\n    /** user_id -\\> most-recently-received unthreaded receipt */\n    private unthreadedReadReceipts: Map<string, AccumulatedReceipt> = new Map();\n\n    /** thread_id -\\> user_id -\\> most-recently-received receipt for this thread */\n    private threadedReadReceipts: MapWithDefault<string, Map<string, AccumulatedReceipt>> = new MapWithDefault(\n        () => new Map(),\n    );\n\n    /**\n     * Provide an unthreaded receipt for this user. Overwrites any other\n     * unthreaded receipt we have for this user.\n     */\n    private setUnthreaded(userId: string, receipt: AccumulatedReceipt): void {\n        this.unthreadedReadReceipts.set(userId, receipt);\n    }\n\n    /**\n     * Provide a receipt for this user in this thread. Overwrites any other\n     * receipt we have for this user in this thread.\n     */\n    private setThreaded(threadId: string, userId: string, receipt: AccumulatedReceipt): void {\n        this.threadedReadReceipts.getOrCreate(threadId).set(userId, receipt);\n    }\n\n    /**\n     * @returns an iterator of pairs of [userId, AccumulatedReceipt] - all the\n     *          most recently-received unthreaded receipts for each user.\n     */\n    private allUnthreaded(): IterableIterator<[string, AccumulatedReceipt]> {\n        return this.unthreadedReadReceipts.entries();\n    }\n\n    /**\n     * @returns an iterator of pairs of [userId, AccumulatedReceipt] - all the\n     *          most recently-received threaded receipts for each user, in all\n     *          threads.\n     */\n    private *allThreaded(): IterableIterator<[string, AccumulatedReceipt]> {\n        for (const receiptsForThread of this.threadedReadReceipts.values()) {\n            for (const e of receiptsForThread.entries()) {\n                yield e;\n            }\n        }\n    }\n\n    /**\n     * Given a list of ephemeral events, find the receipts and store the\n     * relevant ones to be returned later from buildAccumulatedReceiptEvent().\n     */\n    public consumeEphemeralEvents(events: IMinimalEvent[] | undefined): void {\n        events?.forEach((e) => {\n            if (e.type !== EventType.Receipt || !e.content) {\n                // This means we'll drop unknown ephemeral events but that\n                // seems okay.\n                return;\n            }\n\n            // Handle m.receipt events. They clobber based on:\n            //   (user_id, receipt_type)\n            // but they are keyed in the event as:\n            //   content:{ $event_id: { $receipt_type: { $user_id: {json} }}}\n            // so store them in the former so we can accumulate receipt deltas\n            // quickly and efficiently (we expect a lot of them). Fold the\n            // receipt type into the key name since we only have 1 at the\n            // moment (m.read) and nested JSON objects are slower and more\n            // of a hassle to work with. We'll inflate this back out when\n            // getJSON() is called.\n            Object.keys(e.content).forEach((eventId) => {\n                Object.entries<ReceiptContent>(e.content[eventId]).forEach(([key, value]) => {\n                    if (!isSupportedReceiptType(key)) return;\n\n                    for (const userId of Object.keys(value)) {\n                        const data = e.content[eventId][key][userId];\n\n                        const receipt = {\n                            data: e.content[eventId][key][userId],\n                            type: key as ReceiptType,\n                            eventId,\n                        };\n\n                        // In a world that supports threads, read receipts normally have\n                        // a `thread_id` which is either the thread they belong in or\n                        // `MAIN_ROOM_TIMELINE`, so we normally use `setThreaded(...)`\n                        // here. The `MAIN_ROOM_TIMELINE` is just treated as another\n                        // thread.\n                        //\n                        // We still encounter read receipts that are \"unthreaded\"\n                        // (missing the `thread_id` property). These come from clients\n                        // that don't support threads, and from threaded clients that\n                        // are doing a \"Mark room as read\" operation. Unthreaded\n                        // receipts mark everything \"before\" them as read, in all\n                        // threads, where \"before\" means in Sync Order i.e. the order\n                        // the events were received from the homeserver in a sync.\n                        // [Note: we have some bugs where we use timestamp order instead\n                        // of Sync Order, because we don't correctly remember the Sync\n                        // Order. See #3325.]\n                        //\n                        // Calling the wrong method will cause incorrect behavior like\n                        // messages re-appearing as \"new\" when you already read them\n                        // previously.\n                        if (!data.thread_id) {\n                            this.setUnthreaded(userId, receipt);\n                        } else {\n                            this.setThreaded(data.thread_id, userId, receipt);\n                        }\n                    }\n                });\n            });\n        });\n    }\n\n    /**\n     * Build a receipt event that contains all relevant information for this\n     * room, taking the most recently received receipt for each user in an\n     * unthreaded context, and in each thread.\n     */\n    public buildAccumulatedReceiptEvent(roomId: string): IMinimalEvent | null {\n        const receiptEvent: IMinimalEvent = {\n            type: EventType.Receipt,\n            room_id: roomId,\n            content: {\n                // $event_id: { \"m.read\": { $user_id: $json } }\n            } as IContent,\n        };\n\n        const receiptEventContent: MapWithDefault<\n            string,\n            MapWithDefault<ReceiptType, Map<string, object>>\n        > = new MapWithDefault(() => new MapWithDefault(() => new Map()));\n\n        for (const [userId, receiptData] of this.allUnthreaded()) {\n            receiptEventContent\n                .getOrCreate(receiptData.eventId)\n                .getOrCreate(receiptData.type)\n                .set(userId, receiptData.data);\n        }\n\n        for (const [userId, receiptData] of this.allThreaded()) {\n            receiptEventContent\n                .getOrCreate(receiptData.eventId)\n                .getOrCreate(receiptData.type)\n                .set(userId, receiptData.data);\n        }\n\n        receiptEvent.content = recursiveMapToObject(receiptEventContent);\n\n        return receiptEventContent.size > 0 ? receiptEvent : null;\n    }\n}\n","/*\nCopyright 2017 - 2023 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\n/**\n * This is an internal module. See {@link SyncAccumulator} for the public class.\n */\n\nimport { logger } from \"./logger.ts\";\nimport { deepCopy } from \"./utils.ts\";\nimport { type IContent, type IUnsigned } from \"./models/event.ts\";\nimport { type IRoomSummary } from \"./models/room-summary.ts\";\nimport { type EventType } from \"./@types/event.ts\";\nimport { UNREAD_THREAD_NOTIFICATIONS } from \"./@types/sync.ts\";\nimport { ReceiptAccumulator } from \"./receipt-accumulator.ts\";\n\ninterface IOpts {\n    /**\n     * The ideal maximum number of timeline entries to keep in the sync response.\n     * This is best-effort, as clients do not always have a back-pagination token for each event,\n     * so it's possible there may be slightly *less* than this value. There will never be more.\n     * This cannot be 0 or else it makes it impossible to scroll back in a room.\n     * Default: 50.\n     */\n    maxTimelineEntries?: number;\n}\n\nexport interface IMinimalEvent {\n    content: IContent;\n    type: EventType | string;\n    room_id?: string;\n    unsigned?: IUnsigned;\n}\n\nexport interface IEphemeral {\n    events: IMinimalEvent[];\n}\n\n/* eslint-disable camelcase */\ninterface UnreadNotificationCounts {\n    highlight_count?: number;\n    notification_count?: number;\n}\n\nexport interface IRoomEvent extends IMinimalEvent {\n    event_id: string;\n    sender: string;\n    origin_server_ts: number;\n}\n\nexport interface IStateEvent extends IRoomEvent {\n    prev_content?: IContent;\n    state_key: string;\n}\n\ninterface IState {\n    events: IStateEvent[];\n}\n\nexport interface ITimeline {\n    events: Array<IRoomEvent | IStateEvent>;\n    limited?: boolean;\n    prev_batch: string | null;\n}\n\nexport interface IJoinedRoom {\n    \"summary\": IRoomSummary;\n    // One of `state` or `state_after` is required.\n    \"state\"?: IState;\n    \"org.matrix.msc4222.state_after\"?: IState; // https://github.com/matrix-org/matrix-spec-proposals/pull/4222\n    \"timeline\": ITimeline;\n    \"ephemeral\": IEphemeral;\n    \"account_data\": IAccountData;\n    \"unread_notifications\": UnreadNotificationCounts;\n    \"unread_thread_notifications\"?: Record<string, UnreadNotificationCounts>;\n    \"org.matrix.msc3773.unread_thread_notifications\"?: Record<string, UnreadNotificationCounts>;\n}\n\nexport interface IStrippedState {\n    content: IContent;\n    state_key: string;\n    type: EventType | string;\n    sender: string;\n}\n\nexport interface IInviteState {\n    events: IStrippedState[];\n}\n\nexport interface IKnockState {\n    events: IStrippedState[];\n}\n\nexport interface IInvitedRoom {\n    invite_state: IInviteState;\n}\n\nexport interface ILeftRoom {\n    // One of `state` or `state_after` is required.\n    \"state\"?: IState;\n    \"org.matrix.msc4222.state_after\"?: IState;\n    \"timeline\": ITimeline;\n    \"account_data\": IAccountData;\n}\n\nexport interface IKnockedRoom {\n    knock_state: IKnockState;\n}\n\nexport interface IRooms {\n    [Category.Join]: Record<string, IJoinedRoom>;\n    [Category.Invite]: Record<string, IInvitedRoom>;\n    [Category.Leave]: Record<string, ILeftRoom>;\n    [Category.Knock]: Record<string, IKnockedRoom>;\n}\n\ninterface IPresence {\n    events: IMinimalEvent[];\n}\n\ninterface IAccountData {\n    events: IMinimalEvent[];\n}\n\nexport interface IToDeviceEvent {\n    content: IContent;\n    sender: string;\n    type: string;\n}\n\ninterface IToDevice {\n    events: IToDeviceEvent[];\n}\n\nexport interface IDeviceLists {\n    changed?: string[];\n    left?: string[];\n}\n\nexport interface ISyncResponse {\n    \"next_batch\": string;\n    \"rooms\": IRooms;\n    \"presence\"?: IPresence;\n    \"account_data\": IAccountData;\n    \"to_device\"?: IToDevice;\n    \"device_lists\"?: IDeviceLists;\n    \"device_one_time_keys_count\"?: Record<string, number>;\n\n    \"device_unused_fallback_key_types\"?: string[];\n    \"org.matrix.msc2732.device_unused_fallback_key_types\"?: string[];\n}\n/* eslint-enable camelcase */\n\nexport enum Category {\n    Invite = \"invite\",\n    Leave = \"leave\",\n    Join = \"join\",\n    Knock = \"knock\",\n}\n\ninterface IRoom {\n    _currentState: { [eventType: string]: { [stateKey: string]: IStateEvent } };\n    _timeline: {\n        event: IRoomEvent | IStateEvent;\n        token: string | null;\n    }[];\n    _summary: Partial<IRoomSummary>;\n    _accountData: { [eventType: string]: IMinimalEvent };\n    _unreadNotifications: Partial<UnreadNotificationCounts>;\n    _unreadThreadNotifications?: Record<string, Partial<UnreadNotificationCounts>>;\n    _receipts: ReceiptAccumulator;\n}\n\nexport interface ISyncData {\n    nextBatch: string;\n    accountData: IMinimalEvent[];\n    roomsData: IRooms;\n}\n\ntype TaggedEvent = IRoomEvent & { _localTs?: number };\n\nfunction isTaggedEvent(event: IRoomEvent): event is TaggedEvent {\n    return \"_localTs\" in event && event[\"_localTs\"] !== undefined;\n}\n\n/**\n * The purpose of this class is to accumulate /sync responses such that a\n * complete \"initial\" JSON response can be returned which accurately represents\n * the sum total of the /sync responses accumulated to date. It only handles\n * room data: that is, everything under the \"rooms\" top-level key.\n *\n * This class is used when persisting room data so a complete /sync response can\n * be loaded from disk and incremental syncs can be performed on the server,\n * rather than asking the server to do an initial sync on startup.\n */\nexport class SyncAccumulator {\n    private accountData: Record<string, IMinimalEvent> = {}; // $event_type: Object\n    private inviteRooms: Record<string, IInvitedRoom> = {}; // $roomId: { ... sync 'invite' json data ... }\n    private knockRooms: Record<string, IKnockedRoom> = {}; // $roomId: { ... sync 'knock' json data ... }\n    private joinRooms: { [roomId: string]: IRoom } = {};\n    // the /sync token which corresponds to the last time rooms were\n    // accumulated. We remember this so that any caller can obtain a\n    // coherent /sync response and know at what point they should be\n    // streaming from without losing events.\n    private nextBatch: string | null = null;\n\n    public constructor(private readonly opts: IOpts = {}) {\n        this.opts.maxTimelineEntries = this.opts.maxTimelineEntries || 50;\n    }\n\n    public accumulate(syncResponse: ISyncResponse, fromDatabase = false): void {\n        this.accumulateRooms(syncResponse, fromDatabase);\n        this.accumulateAccountData(syncResponse);\n        this.nextBatch = syncResponse.next_batch;\n    }\n\n    private accumulateAccountData(syncResponse: ISyncResponse): void {\n        if (!syncResponse.account_data || !syncResponse.account_data.events) {\n            return;\n        }\n        // Clobbers based on event type.\n        syncResponse.account_data.events.forEach((e) => {\n            this.accountData[e.type] = e;\n        });\n    }\n\n    /**\n     * Accumulate incremental /sync room data.\n     * @param syncResponse - the complete /sync JSON\n     * @param fromDatabase - True if the sync response is one saved to the database\n     */\n    private accumulateRooms(syncResponse: ISyncResponse, fromDatabase = false): void {\n        if (!syncResponse.rooms) {\n            return;\n        }\n        if (syncResponse.rooms.invite) {\n            Object.keys(syncResponse.rooms.invite).forEach((roomId) => {\n                this.accumulateRoom(roomId, Category.Invite, syncResponse.rooms.invite[roomId], fromDatabase);\n            });\n        }\n        if (syncResponse.rooms.join) {\n            Object.keys(syncResponse.rooms.join).forEach((roomId) => {\n                this.accumulateRoom(roomId, Category.Join, syncResponse.rooms.join[roomId], fromDatabase);\n            });\n        }\n        if (syncResponse.rooms.leave) {\n            Object.keys(syncResponse.rooms.leave).forEach((roomId) => {\n                this.accumulateRoom(roomId, Category.Leave, syncResponse.rooms.leave[roomId], fromDatabase);\n            });\n        }\n        if (syncResponse.rooms.knock) {\n            Object.keys(syncResponse.rooms.knock).forEach((roomId) => {\n                this.accumulateRoom(roomId, Category.Knock, syncResponse.rooms.knock[roomId], fromDatabase);\n            });\n        }\n    }\n\n    private accumulateRoom(roomId: string, category: Category.Invite, data: IInvitedRoom, fromDatabase: boolean): void;\n    private accumulateRoom(roomId: string, category: Category.Join, data: IJoinedRoom, fromDatabase: boolean): void;\n    private accumulateRoom(roomId: string, category: Category.Leave, data: ILeftRoom, fromDatabase: boolean): void;\n    private accumulateRoom(roomId: string, category: Category.Knock, data: IKnockedRoom, fromDatabase: boolean): void;\n    private accumulateRoom(roomId: string, category: Category, data: any, fromDatabase = false): void {\n        // Valid /sync state transitions\n        //       +--------+ <======+            1: Accept an invite\n        //   +== | INVITE |        | (5)        2: Leave a room\n        //   |   +--------+ =====+ |            3: Join a public room previously\n        //   |(1)            (4) | |               left (handle as if new room)\n        //   V         (2)       V |            4: Reject an invite\n        // +------+ ========> +--------+         5: Invite to a room previously\n        // | JOIN |    (3)    | LEAVE* |            left (handle as if new room)\n        // +------+ <======== +--------+\n        //\n        // * equivalent to \"no state\"\n        switch (category) {\n            case Category.Invite: // (5)\n                if (this.knockRooms[roomId]) {\n                    // was previously knock, now invite, need to delete knock state\n                    delete this.knockRooms[roomId];\n                }\n                this.accumulateInviteState(roomId, data as IInvitedRoom);\n                break;\n\n            case Category.Knock:\n                this.accumulateKnockState(roomId, data as IKnockedRoom);\n                break;\n\n            case Category.Join:\n                if (this.inviteRooms[roomId]) {\n                    // (1)\n                    // was previously invite, now join. We expect /sync to give\n                    // the entire state and timeline on 'join', so delete previous\n                    // invite state\n                    delete this.inviteRooms[roomId];\n                }\n                // (3)\n                this.accumulateJoinState(roomId, data as IJoinedRoom, fromDatabase);\n                break;\n\n            case Category.Leave:\n                if (this.knockRooms[roomId]) {\n                    // delete knock state on leave\n                    delete this.knockRooms[roomId];\n                } else if (this.inviteRooms[roomId]) {\n                    // (4)\n                    delete this.inviteRooms[roomId];\n                } else {\n                    // (2)\n                    delete this.joinRooms[roomId];\n                }\n                break;\n\n            default:\n                logger.error(\"Unknown cateogory: \", category);\n        }\n    }\n\n    private accumulateInviteState(roomId: string, data: IInvitedRoom): void {\n        if (!data.invite_state || !data.invite_state.events) {\n            // no new data\n            return;\n        }\n        if (!this.inviteRooms[roomId]) {\n            this.inviteRooms[roomId] = {\n                invite_state: data.invite_state,\n            };\n            return;\n        }\n        // accumulate extra keys for invite->invite transitions\n        // clobber based on event type / state key\n        // We expect invite_state to be small, so just loop over the events\n        const currentData = this.inviteRooms[roomId];\n        data.invite_state.events.forEach((e) => {\n            let hasAdded = false;\n            for (let i = 0; i < currentData.invite_state.events.length; i++) {\n                const current = currentData.invite_state.events[i];\n                if (current.type === e.type && current.state_key == e.state_key) {\n                    currentData.invite_state.events[i] = e; // update\n                    hasAdded = true;\n                }\n            }\n            if (!hasAdded) {\n                currentData.invite_state.events.push(e);\n            }\n        });\n    }\n\n    private accumulateKnockState(roomId: string, data: IKnockedRoom): void {\n        if (!data.knock_state || !data.knock_state.events) {\n            // no new data\n            return;\n        }\n        if (!this.knockRooms[roomId]) {\n            this.knockRooms[roomId] = {\n                knock_state: data.knock_state,\n            };\n            return;\n        }\n        // accumulate extra keys\n        // clobber based on event type / state key\n        // We expect knock_state to be small, so just loop over the events\n        const currentData = this.knockRooms[roomId];\n        data.knock_state.events.forEach((e) => {\n            let hasAdded = false;\n            for (let i = 0; i < currentData.knock_state.events.length; i++) {\n                const current = currentData.knock_state.events[i];\n                if (current.type === e.type && current.state_key == e.state_key) {\n                    currentData.knock_state.events[i] = e; // update\n                    hasAdded = true;\n                }\n            }\n            if (!hasAdded) {\n                currentData.knock_state.events.push(e);\n            }\n        });\n    }\n\n    // Accumulate timeline and state events in a room.\n    private accumulateJoinState(roomId: string, data: IJoinedRoom, fromDatabase = false): void {\n        // We expect this function to be called a lot (every /sync) so we want\n        // this to be fast. /sync stores events in an array but we often want\n        // to clobber based on type/state_key. Rather than convert arrays to\n        // maps all the time, just keep private maps which contain\n        // the actual current accumulated sync state, and array-ify it when\n        // getJSON() is called.\n\n        // State resolution:\n        // The 'state' key is the delta from the previous sync (or start of time\n        // if no token was supplied), to the START of the timeline. To obtain\n        // the current state, we need to \"roll forward\" state by reading the\n        // timeline. We want to store the current state so we can drop events\n        // out the end of the timeline based on opts.maxTimelineEntries.\n        //\n        //      'state'     'timeline'     current state\n        // |-------x<======================>x\n        //          T   I   M   E\n        //\n        // When getJSON() is called, we 'roll back' the current state by the\n        // number of entries in the timeline to work out what 'state' should be.\n\n        // Back-pagination:\n        // On an initial /sync, the server provides a back-pagination token for\n        // the start of the timeline. When /sync deltas come down, they also\n        // include back-pagination tokens for the start of the timeline. This\n        // means not all events in the timeline have back-pagination tokens, as\n        // it is only the ones at the START of the timeline which have them.\n        // In order for us to have a valid timeline (and back-pagination token\n        // to match), we need to make sure that when we remove old timeline\n        // events, that we roll forward to an event which has a back-pagination\n        // token. This means we can't keep a strict sliding-window based on\n        // opts.maxTimelineEntries, and we may have a few less. We should never\n        // have more though, provided that the /sync limit is less than or equal\n        // to opts.maxTimelineEntries.\n\n        if (!this.joinRooms[roomId]) {\n            // Create truly empty objects so event types of 'hasOwnProperty' and co\n            // don't cause this code to break.\n            this.joinRooms[roomId] = {\n                _currentState: Object.create(null),\n                _timeline: [],\n                _accountData: Object.create(null),\n                _unreadNotifications: {},\n                _unreadThreadNotifications: {},\n                _summary: {},\n                _receipts: new ReceiptAccumulator(),\n            };\n        }\n        const currentData = this.joinRooms[roomId];\n\n        if (data.account_data && data.account_data.events) {\n            // clobber based on type\n            data.account_data.events.forEach((e) => {\n                currentData._accountData[e.type] = e;\n            });\n        }\n\n        // these probably clobber, spec is unclear.\n        if (data.unread_notifications) {\n            currentData._unreadNotifications = data.unread_notifications;\n        }\n        currentData._unreadThreadNotifications =\n            data[UNREAD_THREAD_NOTIFICATIONS.stable!] ?? data[UNREAD_THREAD_NOTIFICATIONS.unstable!] ?? undefined;\n\n        if (data.summary) {\n            const HEROES_KEY = \"m.heroes\";\n            const INVITED_COUNT_KEY = \"m.invited_member_count\";\n            const JOINED_COUNT_KEY = \"m.joined_member_count\";\n\n            const acc = currentData._summary;\n            const sum = data.summary;\n            acc[HEROES_KEY] = sum[HEROES_KEY] ?? acc[HEROES_KEY];\n            acc[JOINED_COUNT_KEY] = sum[JOINED_COUNT_KEY] ?? acc[JOINED_COUNT_KEY];\n            acc[INVITED_COUNT_KEY] = sum[INVITED_COUNT_KEY] ?? acc[INVITED_COUNT_KEY];\n        }\n\n        // We purposefully do not persist m.typing events.\n        // Technically you could refresh a browser before the timer on a\n        // typing event is up, so it'll look like you aren't typing when\n        // you really still are. However, the alternative is worse. If\n        // we do persist typing events, it will look like people are\n        // typing forever until someone really does start typing (which\n        // will prompt Synapse to send down an actual m.typing event to\n        // clobber the one we persisted).\n\n        // Persist the receipts\n        currentData._receipts.consumeEphemeralEvents(data.ephemeral?.events);\n\n        // if we got a limited sync, we need to remove all timeline entries or else\n        // we will have gaps in the timeline.\n        if (data.timeline && data.timeline.limited) {\n            currentData._timeline = [];\n        }\n\n        // Work out the current state. The deltas need to be applied in the order:\n        // - existing state which didn't come down /sync.\n        // - State events under the 'state' key.\n        // - State events under the 'state_after' key OR state events in the 'timeline' if 'state_after' is not present.\n        data.state?.events?.forEach((e) => {\n            setState(currentData._currentState, e);\n        });\n        data[\"org.matrix.msc4222.state_after\"]?.events?.forEach((e) => {\n            setState(currentData._currentState, e);\n        });\n        data.timeline?.events?.forEach((e, index) => {\n            if (!data[\"org.matrix.msc4222.state_after\"]) {\n                // this nops if 'e' isn't a state event\n                setState(currentData._currentState, e);\n            }\n            // append the event to the timeline. The back-pagination token\n            // corresponds to the first event in the timeline\n            let transformedEvent: TaggedEvent;\n            if (!fromDatabase) {\n                transformedEvent = Object.assign({}, e);\n                if (transformedEvent.unsigned !== undefined) {\n                    transformedEvent.unsigned = Object.assign({}, transformedEvent.unsigned);\n                }\n                const age = e.unsigned?.age;\n                if (age !== undefined) transformedEvent._localTs = Date.now() - age;\n            } else {\n                transformedEvent = e;\n            }\n\n            currentData._timeline.push({\n                event: transformedEvent,\n                token: index === 0 ? (data.timeline.prev_batch ?? null) : null,\n            });\n        });\n\n        // attempt to prune the timeline by jumping between events which have\n        // pagination tokens.\n        if (currentData._timeline.length > this.opts.maxTimelineEntries!) {\n            const startIndex = currentData._timeline.length - this.opts.maxTimelineEntries!;\n            for (let i = startIndex; i < currentData._timeline.length; i++) {\n                if (currentData._timeline[i].token) {\n                    // keep all events after this, including this one\n                    currentData._timeline = currentData._timeline.slice(i, currentData._timeline.length);\n                    break;\n                }\n            }\n        }\n    }\n\n    /**\n     * Return everything under the 'rooms' key from a /sync response which\n     * represents all room data that should be stored. This should be paired\n     * with the sync token which represents the most recent /sync response\n     * provided to accumulate().\n     * @param forDatabase - True to generate a sync to be saved to storage\n     * @returns An object with a \"nextBatch\", \"roomsData\" and \"accountData\"\n     * keys.\n     * The \"nextBatch\" key is a string which represents at what point in the\n     * /sync stream the accumulator reached. This token should be used when\n     * restarting a /sync stream at startup. Failure to do so can lead to missing\n     * events. The \"roomsData\" key is an Object which represents the entire\n     * /sync response from the 'rooms' key onwards. The \"accountData\" key is\n     * a list of raw events which represent global account data.\n     */\n    public getJSON(forDatabase = false): ISyncData {\n        const data: IRooms = {\n            join: {},\n            invite: {},\n            knock: {},\n            // always empty. This is set by /sync when a room was previously\n            // in 'invite' or 'join'. On fresh startup, the client won't know\n            // about any previous room being in 'invite' or 'join' so we can\n            // just omit mentioning it at all, even if it has previously come\n            // down /sync.\n            // The notable exception is when a client is kicked or banned:\n            // we may want to hold onto that room so the client can clearly see\n            // why their room has disappeared. We don't persist it though because\n            // it is unclear *when* we can safely remove the room from the DB.\n            // Instead, we assume that if you're loading from the DB, you've\n            // refreshed the page, which means you've seen the kick/ban already.\n            leave: {},\n        };\n        Object.keys(this.inviteRooms).forEach((roomId) => {\n            data.invite[roomId] = this.inviteRooms[roomId];\n        });\n        Object.keys(this.knockRooms).forEach((roomId) => {\n            data.knock[roomId] = this.knockRooms[roomId];\n        });\n        Object.keys(this.joinRooms).forEach((roomId) => {\n            const roomData = this.joinRooms[roomId];\n            const roomJson: IJoinedRoom & {\n                // We track both `state` and `state_after` for downgrade compatibility\n                \"state\": IState;\n                \"org.matrix.msc4222.state_after\": IState;\n            } = {\n                \"ephemeral\": { events: [] },\n                \"account_data\": { events: [] },\n                \"state\": { events: [] },\n                \"org.matrix.msc4222.state_after\": { events: [] },\n                \"timeline\": {\n                    events: [],\n                    prev_batch: null,\n                },\n                \"unread_notifications\": roomData._unreadNotifications,\n                \"unread_thread_notifications\": roomData._unreadThreadNotifications,\n                \"summary\": roomData._summary as IRoomSummary,\n            };\n            // Add account data\n            Object.keys(roomData._accountData).forEach((evType) => {\n                roomJson.account_data.events.push(roomData._accountData[evType]);\n            });\n\n            const receiptEvent = roomData._receipts.buildAccumulatedReceiptEvent(roomId);\n\n            // add only if we have some receipt data\n            if (receiptEvent) {\n                roomJson.ephemeral.events.push(receiptEvent);\n            }\n\n            // Add timeline data\n            roomData._timeline.forEach((msgData) => {\n                if (!roomJson.timeline.prev_batch) {\n                    // the first event we add to the timeline MUST match up to\n                    // the prev_batch token.\n                    if (!msgData.token) {\n                        return; // this shouldn't happen as we prune constantly.\n                    }\n                    roomJson.timeline.prev_batch = msgData.token;\n                }\n\n                let transformedEvent: (IRoomEvent | IStateEvent) & { _localTs?: number };\n                if (!forDatabase && isTaggedEvent(msgData.event)) {\n                    // This means we have to copy each event, so we can fix it up to\n                    // set a correct 'age' parameter whilst keeping the local timestamp\n                    // on our stored event. If this turns out to be a bottleneck, it could\n                    // be optimised either by doing this in the main process after the data\n                    // has been structured-cloned to go between the worker & main process,\n                    // or special-casing data from saved syncs to read the local timestamp\n                    // directly rather than turning it into age to then immediately be\n                    // transformed back again into a local timestamp.\n                    transformedEvent = Object.assign({}, msgData.event);\n                    if (transformedEvent.unsigned !== undefined) {\n                        transformedEvent.unsigned = Object.assign({}, transformedEvent.unsigned);\n                    }\n                    delete transformedEvent._localTs;\n                    transformedEvent.unsigned = transformedEvent.unsigned || {};\n                    transformedEvent.unsigned.age = Date.now() - msgData.event._localTs!;\n                } else {\n                    transformedEvent = msgData.event;\n                }\n                roomJson.timeline.events.push(transformedEvent);\n            });\n\n            // Add state data: roll back current state to the start of timeline,\n            // by \"reverse clobbering\" from the end of the timeline to the start.\n            // Convert maps back into arrays.\n            const rollBackState = Object.create(null);\n            for (let i = roomJson.timeline.events.length - 1; i >= 0; i--) {\n                const timelineEvent = roomJson.timeline.events[i];\n                if (\n                    (timelineEvent as IStateEvent).state_key === null ||\n                    (timelineEvent as IStateEvent).state_key === undefined\n                ) {\n                    continue; // not a state event\n                }\n                // since we're going back in time, we need to use the previous\n                // state value else we'll break causality. We don't have the\n                // complete previous state event, so we need to create one.\n                const prevStateEvent = deepCopy(timelineEvent);\n                if (prevStateEvent.unsigned) {\n                    if (prevStateEvent.unsigned.prev_content) {\n                        prevStateEvent.content = prevStateEvent.unsigned.prev_content;\n                    }\n                    if (prevStateEvent.unsigned.prev_sender) {\n                        prevStateEvent.sender = prevStateEvent.unsigned.prev_sender;\n                    }\n                }\n                setState(rollBackState, prevStateEvent);\n            }\n            Object.keys(roomData._currentState).forEach((evType) => {\n                Object.keys(roomData._currentState[evType]).forEach((stateKey) => {\n                    let ev = roomData._currentState[evType][stateKey];\n                    // Push to both fields to provide downgrade compatibility in the sync accumulator db\n                    // the code will prefer `state_after` if it is present\n                    roomJson[\"org.matrix.msc4222.state_after\"].events.push(ev);\n                    // Roll the state back to the value at the start of the timeline if it was changed\n                    if (rollBackState[evType] && rollBackState[evType][stateKey]) {\n                        ev = rollBackState[evType][stateKey];\n                    }\n                    roomJson.state.events.push(ev);\n                });\n            });\n            data.join[roomId] = roomJson;\n        });\n\n        // Add account data\n        const accData: IMinimalEvent[] = [];\n        Object.keys(this.accountData).forEach((evType) => {\n            accData.push(this.accountData[evType]);\n        });\n\n        return {\n            nextBatch: this.nextBatch!,\n            roomsData: data,\n            accountData: accData,\n        };\n    }\n\n    public getNextBatchToken(): string {\n        return this.nextBatch!;\n    }\n}\n\nfunction setState(eventMap: Record<string, Record<string, IStateEvent>>, event: IRoomEvent | IStateEvent): void {\n    if ((event as IStateEvent).state_key === null || (event as IStateEvent).state_key === undefined || !event.type) {\n        return;\n    }\n    if (!eventMap[event.type]) {\n        eventMap[event.type] = Object.create(null);\n    }\n    eventMap[event.type][(event as IStateEvent).state_key] = event as IStateEvent;\n}\n","/*\nCopyright 2015 - 2023 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\n/*\n * TODO:\n * This class mainly serves to take all the syncing logic out of client.js and\n * into a separate file. It's all very fluid, and this class gut wrenches a lot\n * of MatrixClient props (e.g. http). Given we want to support WebSockets as\n * an alternative syncing API, we may want to have a proper syncing interface\n * for HTTP and WS at some point.\n */\n\nimport { type Optional } from \"matrix-events-sdk\";\n\nimport type { SyncCryptoCallbacks } from \"./common-crypto/CryptoBackend.ts\";\nimport { User } from \"./models/user.ts\";\nimport { NotificationCountType, Room, RoomEvent } from \"./models/room.ts\";\nimport { deepCopy, defer, type IDeferred, noUnsafeEventProps, promiseMapSeries, unsafeProp } from \"./utils.ts\";\nimport { Filter } from \"./filter.ts\";\nimport { EventTimeline } from \"./models/event-timeline.ts\";\nimport { logger } from \"./logger.ts\";\nimport {\n    ClientEvent,\n    type IStoredClientOpts,\n    type MatrixClient,\n    PendingEventOrdering,\n    type ResetTimelineCallback,\n} from \"./client.ts\";\nimport {\n    type IEphemeral,\n    type IInvitedRoom,\n    type IInviteState,\n    type IJoinedRoom,\n    type ILeftRoom,\n    type IKnockedRoom,\n    type IMinimalEvent,\n    type IRoomEvent,\n    type IStateEvent,\n    type IStrippedState,\n    type ISyncResponse,\n    type ITimeline,\n    type IToDeviceEvent,\n} from \"./sync-accumulator.ts\";\nimport { MatrixEvent, type IEvent } from \"./models/event.ts\";\nimport { type MatrixError, Method } from \"./http-api/index.ts\";\nimport { type ISavedSync } from \"./store/index.ts\";\nimport { EventType } from \"./@types/event.ts\";\nimport { type IPushRules } from \"./@types/PushRules.ts\";\nimport { RoomStateEvent, type IMarkerFoundOptions } from \"./models/room-state.ts\";\nimport { RoomMemberEvent } from \"./models/room-member.ts\";\nimport { BeaconEvent } from \"./models/beacon.ts\";\nimport { type IEventsResponse } from \"./@types/requests.ts\";\nimport { UNREAD_THREAD_NOTIFICATIONS } from \"./@types/sync.ts\";\nimport { Feature, ServerSupport } from \"./feature.ts\";\nimport { KnownMembership } from \"./@types/membership.ts\";\n\nconst DEBUG = true;\n\n// /sync requests allow you to set a timeout= but the request may continue\n// beyond that and wedge forever, so we need to track how long we are willing\n// to keep open the connection. This constant is *ADDED* to the timeout= value\n// to determine the max time we're willing to wait.\nconst BUFFER_PERIOD_MS = 80 * 1000;\n\n// Number of consecutive failed syncs that will lead to a syncState of ERROR as opposed\n// to RECONNECTING. This is needed to inform the client of server issues when the\n// keepAlive is successful but the server /sync fails.\nconst FAILED_SYNC_ERROR_THRESHOLD = 3;\n\nexport enum SyncState {\n    /** Emitted after we try to sync more than `FAILED_SYNC_ERROR_THRESHOLD`\n     * times and are still failing. Or when we enounter a hard error like the\n     * token being invalid. */\n    Error = \"ERROR\",\n    /** Emitted after the first sync events are ready (this could even be sync\n     * events from the cache) */\n    Prepared = \"PREPARED\",\n    /** Emitted when the sync loop is no longer running */\n    Stopped = \"STOPPED\",\n    /** Emitted after each sync request happens */\n    Syncing = \"SYNCING\",\n    /** Emitted after a connectivity error and we're ready to start syncing again */\n    Catchup = \"CATCHUP\",\n    /** Emitted for each time we try reconnecting. Will switch to `Error` after\n     * we reach the `FAILED_SYNC_ERROR_THRESHOLD`\n     */\n    Reconnecting = \"RECONNECTING\",\n}\n\n// Room versions where \"insertion\", \"batch\", and \"marker\" events are controlled\n// by power-levels. MSC2716 is supported in existing room versions but they\n// should only have special meaning when the room creator sends them.\nconst MSC2716_ROOM_VERSIONS = [\"org.matrix.msc2716v3\"];\n\nfunction getFilterName(userId: string, suffix?: string): string {\n    // scope this on the user ID because people may login on many accounts\n    // and they all need to be stored!\n    return `FILTER_SYNC_${userId}` + (suffix ? \"_\" + suffix : \"\");\n}\n\n/* istanbul ignore next */\nfunction debuglog(...params: any[]): void {\n    if (!DEBUG) return;\n    logger.log(...params);\n}\n\n/**\n * Options passed into the constructor of SyncApi by MatrixClient\n */\nexport interface SyncApiOptions {\n    /**\n     * If crypto is enabled on our client, callbacks into the crypto module\n     */\n    cryptoCallbacks?: SyncCryptoCallbacks;\n\n    /**\n     * A function which is called\n     * with a room ID and returns a boolean. It should return 'true' if the SDK can\n     * SAFELY remove events from this room. It may not be safe to remove events if\n     * there are other references to the timelines for this room.\n     */\n    canResetEntireTimeline?: ResetTimelineCallback;\n}\n\ninterface ISyncOptions {\n    filter?: string;\n    hasSyncedBefore?: boolean;\n}\n\nexport interface ISyncStateData {\n    /**\n     * The matrix error if `state=ERROR`.\n     */\n    error?: Error;\n    /**\n     * The 'since' token passed to /sync.\n     *    `null` for the first successful sync since this client was\n     *    started. Only present if `state=PREPARED` or\n     *    `state=SYNCING`.\n     */\n    oldSyncToken?: string;\n    /**\n     * The 'next_batch' result from /sync, which\n     *    will become the 'since' token for the next call to /sync. Only present if\n     *    `state=PREPARED</code> or <code>state=SYNCING`.\n     */\n    nextSyncToken?: string;\n    /**\n     * True if we are working our way through a\n     *    backlog of events after connecting. Only present if `state=SYNCING`.\n     */\n    catchingUp?: boolean;\n    fromCache?: boolean;\n}\n\nexport enum SetPresence {\n    Offline = \"offline\",\n    Online = \"online\",\n    Unavailable = \"unavailable\",\n}\n\ninterface ISyncParams {\n    \"filter\"?: string;\n    \"timeout\": number;\n    \"since\"?: string;\n    // eslint-disable-next-line camelcase\n    \"full_state\"?: boolean;\n    // eslint-disable-next-line camelcase\n    \"set_presence\"?: SetPresence;\n    \"_cacheBuster\"?: string | number; // not part of the API itself\n    \"org.matrix.msc4222.use_state_after\"?: boolean; // https://github.com/matrix-org/matrix-spec-proposals/pull/4222\n}\n\ntype WrappedRoom<T> = T & {\n    room: Room;\n    isBrandNewRoom: boolean;\n};\n\n/** add default settings to an IStoredClientOpts */\nexport function defaultClientOpts(opts?: IStoredClientOpts): IStoredClientOpts {\n    return {\n        initialSyncLimit: 8,\n        resolveInvitesToProfiles: false,\n        pollTimeout: 30 * 1000,\n        pendingEventOrdering: PendingEventOrdering.Chronological,\n        threadSupport: false,\n        ...opts,\n    };\n}\n\nexport function defaultSyncApiOpts(syncOpts?: SyncApiOptions): SyncApiOptions {\n    return {\n        canResetEntireTimeline: (_roomId): boolean => false,\n        ...syncOpts,\n    };\n}\n\nexport class SyncApi {\n    private readonly opts: IStoredClientOpts;\n    private readonly syncOpts: SyncApiOptions;\n\n    private _peekRoom: Optional<Room> = null;\n    private currentSyncRequest?: Promise<ISyncResponse>;\n    private abortController?: AbortController;\n    private syncState: SyncState | null = null;\n    private syncStateData?: ISyncStateData; // additional data (eg. error object for failed sync)\n    private catchingUp = false;\n    private running = false;\n    private keepAliveTimer?: ReturnType<typeof setTimeout>;\n    private connectionReturnedDefer?: IDeferred<boolean>;\n    private notifEvents: MatrixEvent[] = []; // accumulator of sync events in the current sync response\n    private failedSyncCount = 0; // Number of consecutive failed /sync requests\n    private storeIsInvalid = false; // flag set if the store needs to be cleared before we can start\n    private presence?: SetPresence;\n\n    /**\n     * Construct an entity which is able to sync with a homeserver.\n     * @param client - The matrix client instance to use.\n     * @param opts - client config options\n     * @param syncOpts - sync-specific options passed by the client\n     * @internal\n     */\n    public constructor(\n        private readonly client: MatrixClient,\n        opts?: IStoredClientOpts,\n        syncOpts?: SyncApiOptions,\n    ) {\n        this.opts = defaultClientOpts(opts);\n        this.syncOpts = defaultSyncApiOpts(syncOpts);\n\n        if (client.getNotifTimelineSet()) {\n            client.reEmitter.reEmit(client.getNotifTimelineSet()!, [RoomEvent.Timeline, RoomEvent.TimelineReset]);\n        }\n    }\n\n    public createRoom(roomId: string): Room {\n        const room = _createAndReEmitRoom(this.client, roomId, this.opts);\n\n        room.on(RoomStateEvent.Marker, (markerEvent, markerFoundOptions) => {\n            this.onMarkerStateEvent(room, markerEvent, markerFoundOptions);\n        });\n\n        return room;\n    }\n\n    /** When we see the marker state change in the room, we know there is some\n     * new historical messages imported by MSC2716 `/batch_send` somewhere in\n     * the room and we need to throw away the timeline to make sure the\n     * historical messages are shown when we paginate `/messages` again.\n     * @param room - The room where the marker event was sent\n     * @param markerEvent - The new marker event\n     * @param setStateOptions - When `timelineWasEmpty` is set\n     * as `true`, the given marker event will be ignored\n     */\n    private onMarkerStateEvent(\n        room: Room,\n        markerEvent: MatrixEvent,\n        { timelineWasEmpty }: IMarkerFoundOptions = {},\n    ): void {\n        // We don't need to refresh the timeline if it was empty before the\n        // marker arrived. This could be happen in a variety of cases:\n        //  1. From the initial sync\n        //  2. If it's from the first state we're seeing after joining the room\n        //  3. Or whether it's coming from `syncFromCache`\n        if (timelineWasEmpty) {\n            logger.debug(\n                `MarkerState: Ignoring markerEventId=${markerEvent.getId()} in roomId=${room.roomId} ` +\n                    `because the timeline was empty before the marker arrived which means there is nothing to refresh.`,\n            );\n            return;\n        }\n\n        const isValidMsc2716Event =\n            // Check whether the room version directly supports MSC2716, in\n            // which case, \"marker\" events are already auth'ed by\n            // power_levels\n            MSC2716_ROOM_VERSIONS.includes(room.getVersion()) ||\n            // MSC2716 is also supported in all existing room versions but\n            // special meaning should only be given to \"insertion\", \"batch\",\n            // and \"marker\" events when they come from the room creator\n            markerEvent.getSender() === room.getCreator();\n\n        // It would be nice if we could also specifically tell whether the\n        // historical messages actually affected the locally cached client\n        // timeline or not. The problem is we can't see the prev_events of\n        // the base insertion event that the marker was pointing to because\n        // prev_events aren't available in the client API's. In most cases,\n        // the history won't be in people's locally cached timelines in the\n        // client, so we don't need to bother everyone about refreshing\n        // their timeline. This works for a v1 though and there are use\n        // cases like initially bootstrapping your bridged room where people\n        // are likely to encounter the historical messages affecting their\n        // current timeline (think someone signing up for Beeper and\n        // importing their Whatsapp history).\n        if (isValidMsc2716Event) {\n            // Saw new marker event, let's let the clients know they should\n            // refresh the timeline.\n            logger.debug(\n                `MarkerState: Timeline needs to be refreshed because ` +\n                    `a new markerEventId=${markerEvent.getId()} was sent in roomId=${room.roomId}`,\n            );\n            room.setTimelineNeedsRefresh(true);\n            room.emit(RoomEvent.HistoryImportedWithinTimeline, markerEvent, room);\n        } else {\n            logger.debug(\n                `MarkerState: Ignoring markerEventId=${markerEvent.getId()} in roomId=${room.roomId} because ` +\n                    `MSC2716 is not supported in the room version or for any room version, the marker wasn't sent ` +\n                    `by the room creator.`,\n            );\n        }\n    }\n\n    /**\n     * Sync rooms the user has left.\n     * @returns Resolved when they've been added to the store.\n     */\n    public async syncLeftRooms(): Promise<Room[]> {\n        const client = this.client;\n\n        // grab a filter with limit=1 and include_leave=true\n        const filter = new Filter(this.client.credentials.userId);\n        filter.setTimelineLimit(1);\n        filter.setIncludeLeaveRooms(true);\n\n        const localTimeoutMs = this.opts.pollTimeout! + BUFFER_PERIOD_MS;\n\n        const filterId = await client.getOrCreateFilter(\n            getFilterName(client.credentials.userId!, \"LEFT_ROOMS\"),\n            filter,\n        );\n\n        const qps: ISyncParams = {\n            \"timeout\": 0, // don't want to block since this is a single isolated req\n            \"filter\": filterId,\n            \"org.matrix.msc4222.use_state_after\": true,\n        };\n\n        const data = await client.http.authedRequest<ISyncResponse>(Method.Get, \"/sync\", qps as any, undefined, {\n            localTimeoutMs,\n        });\n\n        let leaveRooms: WrappedRoom<ILeftRoom>[] = [];\n        if (data.rooms?.leave) {\n            leaveRooms = this.mapSyncResponseToRoomArray(data.rooms.leave);\n        }\n\n        const rooms = await Promise.all(\n            leaveRooms.map(async (leaveObj) => {\n                const room = leaveObj.room;\n                if (!leaveObj.isBrandNewRoom) {\n                    // the intention behind syncLeftRooms is to add in rooms which were\n                    // *omitted* from the initial /sync. Rooms the user were joined to\n                    // but then left whilst the app is running will appear in this list\n                    // and we do not want to bother with them since they will have the\n                    // current state already (and may get dupe messages if we add\n                    // yet more timeline events!), so skip them.\n                    // NB: When we persist rooms to localStorage this will be more\n                    //     complicated...\n                    return;\n                }\n                leaveObj.timeline = leaveObj.timeline || {\n                    prev_batch: null,\n                    events: [],\n                };\n\n                // set the back-pagination token. Do this *before* adding any\n                // events so that clients can start back-paginating.\n                room.getLiveTimeline().setPaginationToken(leaveObj.timeline.prev_batch, EventTimeline.BACKWARDS);\n\n                const { timelineEvents } = await this.mapAndInjectRoomEvents(leaveObj);\n\n                room.recalculate();\n                client.store.storeRoom(room);\n                client.emit(ClientEvent.Room, room);\n\n                this.processEventsForNotifs(room, timelineEvents);\n                return room;\n            }),\n        );\n\n        return rooms.filter(Boolean) as Room[];\n    }\n\n    /**\n     * Peek into a room. This will result in the room in question being synced so it\n     * is accessible via getRooms(). Live updates for the room will be provided.\n     * @param roomId - The room ID to peek into.\n     * @param limit - The number of timeline events to initially retrieve.\n     * @returns A promise which resolves once the room has been added to the\n     * store.\n     */\n    public peek(roomId: string, limit: number = 20): Promise<Room> {\n        if (this._peekRoom?.roomId === roomId) {\n            return Promise.resolve(this._peekRoom);\n        }\n\n        const client = this.client;\n        this._peekRoom = this.createRoom(roomId);\n        return this.client.roomInitialSync(roomId, limit).then((response) => {\n            if (this._peekRoom?.roomId !== roomId) {\n                throw new Error(\"Peeking aborted\");\n            }\n\n            // make sure things are init'd\n            response.messages = response.messages || { chunk: [] };\n            response.messages.chunk = response.messages.chunk || [];\n            response.state = response.state || [];\n\n            // FIXME: Mostly duplicated from injectRoomEvents but not entirely\n            // because \"state\" in this API is at the BEGINNING of the chunk\n            const oldStateEvents = deepCopy(response.state).map(client.getEventMapper());\n            const stateEvents = response.state.map(client.getEventMapper());\n            const messages = response.messages.chunk.map(client.getEventMapper());\n\n            // XXX: copypasted from /sync until we kill off this minging v1 API stuff)\n            // handle presence events (User objects)\n            if (Array.isArray(response.presence)) {\n                response.presence.map(client.getEventMapper()).forEach(function (presenceEvent) {\n                    let user = client.store.getUser(presenceEvent.getContent().user_id);\n                    if (user) {\n                        user.setPresenceEvent(presenceEvent);\n                    } else {\n                        user = User.createUser(presenceEvent.getContent().user_id, client);\n                        user.setPresenceEvent(presenceEvent);\n                        client.store.storeUser(user);\n                    }\n                    client.emit(ClientEvent.Event, presenceEvent);\n                });\n            }\n\n            // set the pagination token before adding the events in case people\n            // fire off pagination requests in response to the Room.timeline\n            // events.\n            if (response.messages.start) {\n                this._peekRoom.oldState.paginationToken = response.messages.start;\n            }\n\n            // set the state of the room to as it was after the timeline executes\n            this._peekRoom.oldState.setStateEvents(oldStateEvents);\n            this._peekRoom.currentState.setStateEvents(stateEvents);\n\n            this.resolveInvites(this._peekRoom);\n            this._peekRoom.recalculate();\n\n            // roll backwards to diverge old state. addEventsToTimeline\n            // will overwrite the pagination token, so make sure it overwrites\n            // it with the right thing.\n            this._peekRoom.addEventsToTimeline(\n                messages.reverse(),\n                true,\n                true,\n                this._peekRoom.getLiveTimeline(),\n                response.messages.start,\n            );\n\n            client.store.storeRoom(this._peekRoom);\n            client.emit(ClientEvent.Room, this._peekRoom);\n\n            this.peekPoll(this._peekRoom);\n            return this._peekRoom;\n        });\n    }\n\n    /**\n     * Stop polling for updates in the peeked room. NOPs if there is no room being\n     * peeked.\n     */\n    public stopPeeking(): void {\n        this._peekRoom = null;\n    }\n\n    /**\n     * Do a peek room poll.\n     * @param token - from= token\n     */\n    private peekPoll(peekRoom: Room, token?: string): void {\n        if (this._peekRoom !== peekRoom) {\n            debuglog(\"Stopped peeking in room %s\", peekRoom.roomId);\n            return;\n        }\n\n        // FIXME: gut wrenching; hard-coded timeout values\n        this.client.http\n            .authedRequest<IEventsResponse>(\n                Method.Get,\n                \"/events\",\n                {\n                    room_id: peekRoom.roomId,\n                    timeout: String(30 * 1000),\n                    from: token,\n                },\n                undefined,\n                {\n                    localTimeoutMs: 50 * 1000,\n                    abortSignal: this.abortController?.signal,\n                },\n            )\n            .then(\n                async (res) => {\n                    if (this._peekRoom !== peekRoom) {\n                        debuglog(\"Stopped peeking in room %s\", peekRoom.roomId);\n                        return;\n                    }\n                    // We have a problem that we get presence both from /events and /sync\n                    // however, /sync only returns presence for users in rooms\n                    // you're actually joined to.\n                    // in order to be sure to get presence for all of the users in the\n                    // peeked room, we handle presence explicitly here. This may result\n                    // in duplicate presence events firing for some users, which is a\n                    // performance drain, but such is life.\n                    // XXX: copypasted from /sync until we can kill this minging v1 stuff.\n\n                    res.chunk\n                        .filter(function (e) {\n                            return e.type === \"m.presence\";\n                        })\n                        .map(this.client.getEventMapper())\n                        .forEach((presenceEvent) => {\n                            let user = this.client.store.getUser(presenceEvent.getContent().user_id);\n                            if (user) {\n                                user.setPresenceEvent(presenceEvent);\n                            } else {\n                                user = User.createUser(presenceEvent.getContent().user_id, this.client);\n                                user.setPresenceEvent(presenceEvent);\n                                this.client.store.storeUser(user);\n                            }\n                            this.client.emit(ClientEvent.Event, presenceEvent);\n                        });\n\n                    // strip out events which aren't for the given room_id (e.g presence)\n                    // and also ephemeral events (which we're assuming is anything without\n                    // and event ID because the /events API doesn't separate them).\n                    const events = res.chunk\n                        .filter(function (e) {\n                            return e.room_id === peekRoom.roomId && e.event_id;\n                        })\n                        .map(this.client.getEventMapper());\n\n                    await peekRoom.addLiveEvents(events, { addToState: true });\n                    this.peekPoll(peekRoom, res.end);\n                },\n                (err) => {\n                    logger.error(\"[%s] Peek poll failed: %s\", peekRoom.roomId, err);\n                    setTimeout(() => {\n                        this.peekPoll(peekRoom, token);\n                    }, 30 * 1000);\n                },\n            );\n    }\n\n    /**\n     * Returns the current state of this sync object\n     * @see MatrixClient#event:\"sync\"\n     */\n    public getSyncState(): SyncState | null {\n        return this.syncState;\n    }\n\n    /**\n     * Returns the additional data object associated with\n     * the current sync state, or null if there is no\n     * such data.\n     * Sync errors, if available, are put in the 'error' key of\n     * this object.\n     */\n    public getSyncStateData(): ISyncStateData | null {\n        return this.syncStateData ?? null;\n    }\n\n    public async recoverFromSyncStartupError(savedSyncPromise: Promise<void> | undefined, error: Error): Promise<void> {\n        // Wait for the saved sync to complete - we send the pushrules and filter requests\n        // before the saved sync has finished so they can run in parallel, but only process\n        // the results after the saved sync is done. Equivalently, we wait for it to finish\n        // before reporting failures from these functions.\n        await savedSyncPromise;\n        const keepaliveProm = this.startKeepAlives();\n        this.updateSyncState(SyncState.Error, { error });\n        await keepaliveProm;\n    }\n\n    private shouldAbortSync(error: MatrixError): boolean {\n        if (error.errcode === \"M_UNKNOWN_TOKEN\") {\n            // The logout already happened, we just need to stop.\n            logger.warn(\"Token no longer valid - assuming logout\");\n            this.stop();\n            this.updateSyncState(SyncState.Error, { error });\n            return true;\n        }\n        return false;\n    }\n\n    private getPushRules = async (): Promise<void> => {\n        try {\n            debuglog(\"Getting push rules...\");\n            const result = await this.client.getPushRules();\n            debuglog(\"Got push rules\");\n\n            this.client.pushRules = result;\n        } catch (err) {\n            logger.error(\"Getting push rules failed\", err);\n            if (this.shouldAbortSync(<MatrixError>err)) return;\n            // wait for saved sync to complete before doing anything else,\n            // otherwise the sync state will end up being incorrect\n            debuglog(\"Waiting for saved sync before retrying push rules...\");\n            await this.recoverFromSyncStartupError(this.savedSyncPromise, <Error>err);\n            return this.getPushRules(); // try again\n        }\n    };\n\n    private buildDefaultFilter = (): Filter => {\n        const filter = new Filter(this.client.credentials.userId);\n        if (this.client.canSupport.get(Feature.ThreadUnreadNotifications) !== ServerSupport.Unsupported) {\n            filter.setUnreadThreadNotifications(true);\n        }\n        return filter;\n    };\n\n    private prepareLazyLoadingForSync = async (): Promise<void> => {\n        debuglog(\"Prepare lazy loading for sync...\");\n        if (this.client.isGuest()) {\n            this.opts.lazyLoadMembers = false;\n        }\n        if (this.opts.lazyLoadMembers) {\n            debuglog(\"Enabling lazy load on sync filter...\");\n            if (!this.opts.filter) {\n                this.opts.filter = this.buildDefaultFilter();\n            }\n            this.opts.filter.setLazyLoadMembers(true);\n        }\n    };\n\n    private storeClientOptions = async (): Promise<void> => {\n        try {\n            debuglog(\"Storing client options...\");\n            await this.client.storeClientOptions();\n            debuglog(\"Stored client options\");\n        } catch (err) {\n            logger.error(\"Storing client options failed\", err);\n            throw err;\n        }\n    };\n\n    private getFilter = async (): Promise<{\n        filterId?: string;\n        filter?: Filter;\n    }> => {\n        debuglog(\"Getting filter...\");\n        let filter: Filter;\n        if (this.opts.filter) {\n            filter = this.opts.filter;\n        } else {\n            filter = this.buildDefaultFilter();\n        }\n\n        let filterId: string;\n        try {\n            filterId = await this.client.getOrCreateFilter(getFilterName(this.client.credentials.userId!), filter);\n        } catch (err) {\n            logger.error(\"Getting filter failed\", err);\n            if (this.shouldAbortSync(<MatrixError>err)) return {};\n            // wait for saved sync to complete before doing anything else,\n            // otherwise the sync state will end up being incorrect\n            debuglog(\"Waiting for saved sync before retrying filter...\");\n            await this.recoverFromSyncStartupError(this.savedSyncPromise, <Error>err);\n            return this.getFilter(); // try again\n        }\n        return { filter, filterId };\n    };\n\n    private savedSyncPromise?: Promise<void>;\n\n    /**\n     * Main entry point\n     */\n    public async sync(): Promise<void> {\n        this.running = true;\n        this.abortController = new AbortController();\n\n        globalThis.window?.addEventListener?.(\"online\", this.onOnline, false);\n\n        if (this.client.isGuest()) {\n            // no push rules for guests, no access to POST filter for guests.\n            return this.doSync({});\n        }\n\n        // Pull the saved sync token out first, before the worker starts sending\n        // all the sync data which could take a while. This will let us send our\n        // first incremental sync request before we've processed our saved data.\n        debuglog(\"Getting saved sync token...\");\n        const savedSyncTokenPromise = this.client.store.getSavedSyncToken().then((tok) => {\n            debuglog(\"Got saved sync token\");\n            return tok;\n        });\n\n        this.savedSyncPromise = this.client.store\n            .getSavedSync()\n            .then((savedSync) => {\n                debuglog(`Got reply from saved sync, exists? ${!!savedSync}`);\n                if (savedSync) {\n                    return this.syncFromCache(savedSync);\n                }\n            })\n            .catch((err) => {\n                logger.error(\"Getting saved sync failed\", err);\n            });\n\n        // We need to do one-off checks before we can begin the /sync loop.\n        // These are:\n        //   1) We need to get push rules so we can check if events should bing as we get\n        //      them from /sync.\n        //   2) We need to get/create a filter which we can use for /sync.\n        //   3) We need to prepare lazy loading for sync\n        //   4) We need to store the client options\n\n        // Now start the first incremental sync request: this can also\n        // take a while so if we set it going now, we can wait for it\n        // to finish while we process our saved sync data.\n        await this.getPushRules();\n        await this.prepareLazyLoadingForSync();\n        await this.storeClientOptions();\n\n        const { filterId, filter } = await this.getFilter();\n        if (!filter) return; // bail, getFilter failed\n\n        // reset the notifications timeline to prepare it to paginate from\n        // the current point in time.\n        // The right solution would be to tie /sync pagination tokens into\n        // /notifications API somehow.\n        this.client.resetNotifTimelineSet();\n\n        if (!this.currentSyncRequest) {\n            let firstSyncFilter = filterId;\n            const savedSyncToken = await savedSyncTokenPromise;\n\n            if (savedSyncToken) {\n                debuglog(\"Sending first sync request...\");\n            } else {\n                debuglog(\"Sending initial sync request...\");\n                const initialFilter = this.buildDefaultFilter();\n                initialFilter.setDefinition(filter.getDefinition());\n                initialFilter.setTimelineLimit(this.opts.initialSyncLimit!);\n                // Use an inline filter, no point uploading it for a single usage\n                firstSyncFilter = JSON.stringify(initialFilter.getDefinition());\n            }\n\n            // Send this first sync request here so we can then wait for the saved\n            // sync data to finish processing before we process the results of this one.\n            this.currentSyncRequest = this.doSyncRequest({ filter: firstSyncFilter }, savedSyncToken);\n        }\n\n        // Now wait for the saved sync to finish...\n        debuglog(\"Waiting for saved sync before starting sync processing...\");\n        await this.savedSyncPromise;\n        // process the first sync request and continue syncing with the normal filterId\n        return this.doSync({ filter: filterId });\n    }\n\n    /**\n     * Stops the sync object from syncing.\n     */\n    public stop(): void {\n        debuglog(\"SyncApi.stop\");\n        // It is necessary to check for the existance of\n        // globalThis.window AND globalThis.window.removeEventListener.\n        // Some platforms (e.g. React Native) register globalThis.window,\n        // but do not have globalThis.window.removeEventListener.\n        globalThis.window?.removeEventListener?.(\"online\", this.onOnline, false);\n        this.running = false;\n        this.abortController?.abort();\n        if (this.keepAliveTimer) {\n            clearTimeout(this.keepAliveTimer);\n            this.keepAliveTimer = undefined;\n        }\n    }\n\n    /**\n     * Retry a backed off syncing request immediately. This should only be used when\n     * the user <b>explicitly</b> attempts to retry their lost connection.\n     * @returns True if this resulted in a request being retried.\n     */\n    public retryImmediately(): boolean {\n        if (!this.connectionReturnedDefer) {\n            return false;\n        }\n        this.startKeepAlives(0);\n        return true;\n    }\n    /**\n     * Process a single set of cached sync data.\n     * @param savedSync - a saved sync that was persisted by a store. This\n     * should have been acquired via client.store.getSavedSync().\n     */\n    private async syncFromCache(savedSync: ISavedSync): Promise<void> {\n        debuglog(\"sync(): not doing HTTP hit, instead returning stored /sync data\");\n\n        const nextSyncToken = savedSync.nextBatch;\n\n        // Set sync token for future incremental syncing\n        this.client.store.setSyncToken(nextSyncToken);\n\n        // No previous sync, set old token to null\n        const syncEventData: ISyncStateData = {\n            nextSyncToken,\n            catchingUp: false,\n            fromCache: true,\n        };\n\n        const data: ISyncResponse = {\n            next_batch: nextSyncToken,\n            rooms: savedSync.roomsData,\n            account_data: {\n                events: savedSync.accountData,\n            },\n        };\n\n        try {\n            await this.processSyncResponse(syncEventData, data);\n        } catch (e) {\n            logger.error(\"Error processing cached sync\", e);\n        }\n\n        // Don't emit a prepared if we've bailed because the store is invalid:\n        // in this case the client will not be usable until stopped & restarted\n        // so this would be useless and misleading.\n        if (!this.storeIsInvalid) {\n            this.updateSyncState(SyncState.Prepared, syncEventData);\n        }\n    }\n\n    /**\n     * Invoke me to do /sync calls\n     */\n    private async doSync(syncOptions: ISyncOptions): Promise<void> {\n        while (this.running) {\n            const syncToken = this.client.store.getSyncToken();\n\n            let data: ISyncResponse;\n            try {\n                if (!this.currentSyncRequest) {\n                    this.currentSyncRequest = this.doSyncRequest(syncOptions, syncToken);\n                }\n                data = await this.currentSyncRequest;\n            } catch (e) {\n                const abort = await this.onSyncError(<MatrixError>e);\n                if (abort) return;\n                continue;\n            } finally {\n                this.currentSyncRequest = undefined;\n            }\n\n            // set the sync token NOW *before* processing the events. We do this so\n            // if something barfs on an event we can skip it rather than constantly\n            // polling with the same token.\n            this.client.store.setSyncToken(data.next_batch);\n\n            // Reset after a successful sync\n            this.failedSyncCount = 0;\n\n            const syncEventData = {\n                oldSyncToken: syncToken ?? undefined,\n                nextSyncToken: data.next_batch,\n                catchingUp: this.catchingUp,\n            };\n\n            try {\n                await this.processSyncResponse(syncEventData, data);\n            } catch (e) {\n                // log the exception with stack if we have it, else fall back\n                // to the plain description\n                logger.error(\"Caught /sync error\", e);\n\n                // Emit the exception for client handling\n                this.client.emit(ClientEvent.SyncUnexpectedError, <Error>e);\n            }\n\n            // Persist after processing as `unsigned` may get mutated\n            // with an `org.matrix.msc4023.thread_id`\n            await this.client.store.setSyncData(data);\n\n            // update this as it may have changed\n            syncEventData.catchingUp = this.catchingUp;\n\n            // emit synced events\n            if (!syncOptions.hasSyncedBefore) {\n                this.updateSyncState(SyncState.Prepared, syncEventData);\n                syncOptions.hasSyncedBefore = true;\n            }\n\n            // tell the crypto module to do its processing. It may block (to do a\n            // /keys/changes request).\n            if (this.syncOpts.cryptoCallbacks) {\n                await this.syncOpts.cryptoCallbacks.onSyncCompleted(syncEventData);\n            }\n\n            // keep emitting SYNCING -> SYNCING for clients who want to do bulk updates\n            this.updateSyncState(SyncState.Syncing, syncEventData);\n\n            if (this.client.store.wantsSave()) {\n                // tell databases that everything is now in a consistent state and can be saved.\n                await this.client.store.save();\n            }\n        }\n\n        if (!this.running) {\n            debuglog(\"Sync no longer running: exiting.\");\n            if (this.connectionReturnedDefer) {\n                this.connectionReturnedDefer.reject();\n                this.connectionReturnedDefer = undefined;\n            }\n            this.updateSyncState(SyncState.Stopped);\n        }\n    }\n\n    private doSyncRequest(syncOptions: ISyncOptions, syncToken: string | null): Promise<ISyncResponse> {\n        const qps = this.getSyncParams(syncOptions, syncToken);\n        return this.client.http.authedRequest<ISyncResponse>(Method.Get, \"/sync\", qps as any, undefined, {\n            localTimeoutMs: qps.timeout + BUFFER_PERIOD_MS,\n            abortSignal: this.abortController?.signal,\n        });\n    }\n\n    private getSyncParams(syncOptions: ISyncOptions, syncToken: string | null): ISyncParams {\n        let timeout = this.opts.pollTimeout!;\n\n        if (this.getSyncState() !== SyncState.Syncing || this.catchingUp) {\n            // unless we are happily syncing already, we want the server to return\n            // as quickly as possible, even if there are no events queued. This\n            // serves two purposes:\n            //\n            // * When the connection dies, we want to know asap when it comes back,\n            //   so that we can hide the error from the user. (We don't want to\n            //   have to wait for an event or a timeout).\n            //\n            // * We want to know if the server has any to_device messages queued up\n            //   for us. We do that by calling it with a zero timeout until it\n            //   doesn't give us any more to_device messages.\n            this.catchingUp = true;\n            timeout = 0;\n        }\n\n        let filter = syncOptions.filter;\n        if (this.client.isGuest() && !filter) {\n            filter = this.getGuestFilter();\n        }\n\n        const qps: ISyncParams = {\n            filter,\n            timeout,\n            \"org.matrix.msc4222.use_state_after\": true,\n        };\n\n        if (this.opts.disablePresence) {\n            qps.set_presence = SetPresence.Offline;\n        } else if (this.presence !== undefined) {\n            qps.set_presence = this.presence;\n        }\n\n        if (syncToken) {\n            qps.since = syncToken;\n        } else {\n            // use a cachebuster for initialsyncs, to make sure that\n            // we don't get a stale sync\n            // (https://github.com/vector-im/vector-web/issues/1354)\n            qps._cacheBuster = Date.now();\n        }\n\n        if ([SyncState.Reconnecting, SyncState.Error].includes(this.getSyncState()!)) {\n            // we think the connection is dead. If it comes back up, we won't know\n            // about it till /sync returns. If the timeout= is high, this could\n            // be a long time. Set it to 0 when doing retries so we don't have to wait\n            // for an event or a timeout before emiting the SYNCING event.\n            qps.timeout = 0;\n        }\n\n        return qps;\n    }\n\n    /**\n     * Specify the set_presence value to be used for subsequent calls to the Sync API.\n     * @param presence - the presence to specify to set_presence of sync calls\n     */\n    public setPresence(presence?: SetPresence): void {\n        this.presence = presence;\n    }\n\n    private async onSyncError(err: MatrixError): Promise<boolean> {\n        if (!this.running) {\n            debuglog(\"Sync no longer running: exiting\");\n            if (this.connectionReturnedDefer) {\n                this.connectionReturnedDefer.reject();\n                this.connectionReturnedDefer = undefined;\n            }\n            this.updateSyncState(SyncState.Stopped);\n            return true; // abort\n        }\n\n        logger.error(\"/sync error %s\", err);\n\n        if (this.shouldAbortSync(err)) {\n            return true; // abort\n        }\n\n        this.failedSyncCount++;\n        logger.log(\"Number of consecutive failed sync requests:\", this.failedSyncCount);\n\n        debuglog(\"Starting keep-alive\");\n        // Note that we do *not* mark the sync connection as\n        // lost yet: we only do this if a keepalive poke\n        // fails, since long lived HTTP connections will\n        // go away sometimes and we shouldn't treat this as\n        // erroneous. We set the state to 'reconnecting'\n        // instead, so that clients can observe this state\n        // if they wish.\n        const keepAlivePromise = this.startKeepAlives();\n\n        this.currentSyncRequest = undefined;\n        // Transition from RECONNECTING to ERROR after a given number of failed syncs\n        this.updateSyncState(\n            this.failedSyncCount >= FAILED_SYNC_ERROR_THRESHOLD ? SyncState.Error : SyncState.Reconnecting,\n            { error: err },\n        );\n\n        const connDidFail = await keepAlivePromise;\n\n        // Only emit CATCHUP if we detected a connectivity error: if we didn't,\n        // it's quite likely the sync will fail again for the same reason and we\n        // want to stay in ERROR rather than keep flip-flopping between ERROR\n        // and CATCHUP.\n        if (connDidFail && this.getSyncState() === SyncState.Error) {\n            this.updateSyncState(SyncState.Catchup, {\n                catchingUp: true,\n            });\n        }\n        return false;\n    }\n\n    /**\n     * Process data returned from a sync response and propagate it\n     * into the model objects\n     *\n     * @param syncEventData - Object containing sync tokens associated with this sync\n     * @param data - The response from /sync\n     */\n    private async processSyncResponse(syncEventData: ISyncStateData, data: ISyncResponse): Promise<void> {\n        const client = this.client;\n\n        // data looks like:\n        // {\n        //    next_batch: $token,\n        //    presence: { events: [] },\n        //    account_data: { events: [] },\n        //    device_lists: { changed: [\"@user:server\", ... ]},\n        //    to_device: { events: [] },\n        //    device_one_time_keys_count: { signed_curve25519: 42 },\n        //    rooms: {\n        //      invite: {\n        //        $roomid: {\n        //          invite_state: { events: [] }\n        //        }\n        //      },\n        //      join: {\n        //        $roomid: {\n        //          state: { events: [] },\n        //          timeline: { events: [], prev_batch: $token, limited: true },\n        //          ephemeral: { events: [] },\n        //          summary: {\n        //             m.heroes: [ $user_id ],\n        //             m.joined_member_count: $count,\n        //             m.invited_member_count: $count\n        //          },\n        //          account_data: { events: [] },\n        //          unread_notifications: {\n        //              highlight_count: 0,\n        //              notification_count: 0,\n        //          }\n        //        }\n        //      },\n        //      leave: {\n        //        $roomid: {\n        //          state: { events: [] },\n        //          timeline: { events: [], prev_batch: $token }\n        //        }\n        //      }\n        //    }\n        // }\n\n        // TODO-arch:\n        // - Each event we pass through needs to be emitted via 'event', can we\n        //   do this in one place?\n        // - The isBrandNewRoom boilerplate is boilerplatey.\n\n        // handle presence events (User objects)\n        if (Array.isArray(data.presence?.events)) {\n            data.presence!.events.filter(noUnsafeEventProps)\n                .map(client.getEventMapper())\n                .forEach(function (presenceEvent) {\n                    let user = client.store.getUser(presenceEvent.getSender()!);\n                    if (user) {\n                        user.setPresenceEvent(presenceEvent);\n                    } else {\n                        user = User.createUser(presenceEvent.getSender()!, client);\n                        user.setPresenceEvent(presenceEvent);\n                        client.store.storeUser(user);\n                    }\n                    client.emit(ClientEvent.Event, presenceEvent);\n                });\n        }\n\n        // handle non-room account_data\n        if (Array.isArray(data.account_data?.events)) {\n            const events = data.account_data.events.filter(noUnsafeEventProps).map(client.getEventMapper());\n            const prevEventsMap = events.reduce<Record<string, MatrixEvent | undefined>>((m, c) => {\n                m[c.getType()!] = client.store.getAccountData(c.getType());\n                return m;\n            }, {});\n            client.store.storeAccountDataEvents(events);\n            events.forEach(function (accountDataEvent) {\n                // Honour push rules that come down the sync stream but also\n                // honour push rules that were previously cached. Base rules\n                // will be updated when we receive push rules via getPushRules\n                // (see sync) before syncing over the network.\n                if (accountDataEvent.getType() === EventType.PushRules) {\n                    const rules = accountDataEvent.getContent<IPushRules>();\n                    client.setPushRules(rules);\n                }\n                const prevEvent = prevEventsMap[accountDataEvent.getType()!];\n                client.emit(ClientEvent.AccountData, accountDataEvent, prevEvent);\n                return accountDataEvent;\n            });\n        }\n\n        // handle to-device events\n        if (data.to_device && Array.isArray(data.to_device.events) && data.to_device.events.length > 0) {\n            let toDeviceMessages: IToDeviceEvent[] = data.to_device.events.filter(noUnsafeEventProps);\n\n            if (this.syncOpts.cryptoCallbacks) {\n                toDeviceMessages = await this.syncOpts.cryptoCallbacks.preprocessToDeviceMessages(toDeviceMessages);\n            }\n\n            const cancelledKeyVerificationTxns: string[] = [];\n            toDeviceMessages\n                .map(mapToDeviceEvent)\n                .map((toDeviceEvent) => {\n                    // map is a cheap inline forEach\n                    // We want to flag m.key.verification.start events as cancelled\n                    // if there's an accompanying m.key.verification.cancel event, so\n                    // we pull out the transaction IDs from the cancellation events\n                    // so we can flag the verification events as cancelled in the loop\n                    // below.\n                    if (toDeviceEvent.getType() === \"m.key.verification.cancel\") {\n                        const txnId: string = toDeviceEvent.getContent()[\"transaction_id\"];\n                        if (txnId) {\n                            cancelledKeyVerificationTxns.push(txnId);\n                        }\n                    }\n\n                    // as mentioned above, .map is a cheap inline forEach, so return\n                    // the unmodified event.\n                    return toDeviceEvent;\n                })\n                .forEach(function (toDeviceEvent) {\n                    const content = toDeviceEvent.getContent();\n                    if (toDeviceEvent.getType() == \"m.room.message\" && content.msgtype == \"m.bad.encrypted\") {\n                        // the mapper already logged a warning.\n                        logger.log(\"Ignoring undecryptable to-device event from \" + toDeviceEvent.getSender());\n                        return;\n                    }\n\n                    if (\n                        toDeviceEvent.getType() === \"m.key.verification.start\" ||\n                        toDeviceEvent.getType() === \"m.key.verification.request\"\n                    ) {\n                        const txnId = content[\"transaction_id\"];\n                        if (cancelledKeyVerificationTxns.includes(txnId)) {\n                            toDeviceEvent.flagCancelled();\n                        }\n                    }\n\n                    client.emit(ClientEvent.ToDeviceEvent, toDeviceEvent);\n                });\n        } else {\n            // no more to-device events: we can stop polling with a short timeout.\n            this.catchingUp = false;\n        }\n\n        // the returned json structure is a bit crap, so make it into a\n        // nicer form (array) after applying sanity to make sure we don't fail\n        // on missing keys (on the off chance)\n        let inviteRooms: WrappedRoom<IInvitedRoom>[] = [];\n        let joinRooms: WrappedRoom<IJoinedRoom>[] = [];\n        let leaveRooms: WrappedRoom<ILeftRoom>[] = [];\n        let knockRooms: WrappedRoom<IKnockedRoom>[] = [];\n\n        if (data.rooms) {\n            if (data.rooms.invite) {\n                inviteRooms = this.mapSyncResponseToRoomArray(data.rooms.invite);\n            }\n            if (data.rooms.join) {\n                joinRooms = this.mapSyncResponseToRoomArray(data.rooms.join);\n            }\n            if (data.rooms.leave) {\n                leaveRooms = this.mapSyncResponseToRoomArray(data.rooms.leave);\n            }\n            if (data.rooms.knock) {\n                knockRooms = this.mapSyncResponseToRoomArray(data.rooms.knock);\n            }\n        }\n\n        this.notifEvents = [];\n\n        // Handle invites\n        await promiseMapSeries(inviteRooms, async (inviteObj) => {\n            const room = inviteObj.room;\n            const stateEvents = this.mapSyncEventsFormat(inviteObj.invite_state, room);\n\n            await this.injectRoomEvents(room, stateEvents, undefined);\n\n            if (inviteObj.isBrandNewRoom) {\n                room.recalculate();\n                client.store.storeRoom(room);\n                client.emit(ClientEvent.Room, room);\n            } else {\n                // Update room state for invite->reject->invite cycles\n                room.recalculate();\n            }\n            stateEvents.forEach(function (e) {\n                client.emit(ClientEvent.Event, e);\n            });\n        });\n\n        // Handle joins\n        await promiseMapSeries(joinRooms, async (joinObj) => {\n            const room = joinObj.room;\n            const stateEvents = this.mapSyncEventsFormat(joinObj.state, room);\n            const stateAfterEvents = this.mapSyncEventsFormat(joinObj[\"org.matrix.msc4222.state_after\"], room);\n            // Prevent events from being decrypted ahead of time\n            // this helps large account to speed up faster\n            // room::decryptCriticalEvent is in charge of decrypting all the events\n            // required for a client to function properly\n            const timelineEvents = this.mapSyncEventsFormat(joinObj.timeline, room, false);\n            const ephemeralEvents = this.mapSyncEventsFormat(joinObj.ephemeral);\n            const accountDataEvents = this.mapSyncEventsFormat(joinObj.account_data);\n\n            // If state_after is present, this is the events that form the state at the end of the timeline block and\n            // regular timeline events do *not* count towards state. If it's not present, then the state is formed by\n            // the state events plus the timeline events. Note mapSyncEventsFormat returns an empty array if the field\n            // is absent so we explicitly check the field on the original object.\n            const eventsFormingFinalState = joinObj[\"org.matrix.msc4222.state_after\"]\n                ? stateAfterEvents\n                : stateEvents.concat(timelineEvents);\n\n            const encrypted = this.isRoomEncrypted(room, eventsFormingFinalState);\n            // We store the server-provided value first so it's correct when any of the events fire.\n            if (joinObj.unread_notifications) {\n                /**\n                 * We track unread notifications ourselves in encrypted rooms, so don't\n                 * bother setting it here. We trust our calculations better than the\n                 * server's for this case, and therefore will assume that our non-zero\n                 * count is accurate.\n                 * XXX: this is known faulty as the push rule for `.m.room.encrypted` may be disabled so server\n                 * may issue notification counts of 0 which we wrongly trust.\n                 * https://github.com/matrix-org/matrix-spec-proposals/pull/2654 would fix this\n                 *\n                 * @see import(\"./client\").fixNotificationCountOnDecryption\n                 */\n                if (!encrypted || joinObj.unread_notifications.notification_count === 0) {\n                    // In an encrypted room, if the room has notifications enabled then it's typical for\n                    // the server to flag all new messages as notifying. However, some push rules calculate\n                    // events as ignored based on their event contents (e.g. ignoring msgtype=m.notice messages)\n                    // so we want to calculate this figure on the client in all cases.\n                    room.setUnreadNotificationCount(\n                        NotificationCountType.Total,\n                        joinObj.unread_notifications.notification_count ?? 0,\n                    );\n                }\n\n                if (!encrypted || room.getUnreadNotificationCount(NotificationCountType.Highlight) <= 0) {\n                    // If the locally stored highlight count is zero, use the server provided value.\n                    room.setUnreadNotificationCount(\n                        NotificationCountType.Highlight,\n                        joinObj.unread_notifications.highlight_count ?? 0,\n                    );\n                }\n            }\n\n            const unreadThreadNotifications =\n                joinObj[UNREAD_THREAD_NOTIFICATIONS.name] ?? joinObj[UNREAD_THREAD_NOTIFICATIONS.altName!];\n            if (unreadThreadNotifications) {\n                // This mirrors the logic above for rooms: take the *total* notification count from\n                // the server for unencrypted rooms or is it's zero. Any threads not present in this\n                // object implicitly have zero notifications, so start by clearing the total counts\n                // for all such threads.\n                room.resetThreadUnreadNotificationCountFromSync(Object.keys(unreadThreadNotifications));\n                for (const [threadId, unreadNotification] of Object.entries(unreadThreadNotifications)) {\n                    if (!encrypted || unreadNotification.notification_count === 0) {\n                        room.setThreadUnreadNotificationCount(\n                            threadId,\n                            NotificationCountType.Total,\n                            unreadNotification.notification_count ?? 0,\n                        );\n                    }\n\n                    const hasNoNotifications =\n                        room.getThreadUnreadNotificationCount(threadId, NotificationCountType.Highlight) <= 0;\n                    if (!encrypted || (encrypted && hasNoNotifications)) {\n                        room.setThreadUnreadNotificationCount(\n                            threadId,\n                            NotificationCountType.Highlight,\n                            unreadNotification.highlight_count ?? 0,\n                        );\n                    }\n                }\n            } else {\n                room.resetThreadUnreadNotificationCountFromSync();\n            }\n\n            joinObj.timeline = joinObj.timeline || ({} as ITimeline);\n\n            if (joinObj.isBrandNewRoom) {\n                // set the back-pagination token. Do this *before* adding any\n                // events so that clients can start back-paginating.\n                if (joinObj.timeline.prev_batch !== null) {\n                    room.getLiveTimeline().setPaginationToken(joinObj.timeline.prev_batch, EventTimeline.BACKWARDS);\n                }\n            } else if (joinObj.timeline.limited) {\n                let limited = true;\n\n                // we've got a limited sync, so we *probably* have a gap in the\n                // timeline, so should reset. But we might have been peeking or\n                // paginating and already have some of the events, in which\n                // case we just want to append any subsequent events to the end\n                // of the existing timeline.\n                //\n                // This is particularly important in the case that we already have\n                // *all* of the events in the timeline - in that case, if we reset\n                // the timeline, we'll end up with an entirely empty timeline,\n                // which we'll try to paginate but not get any new events (which\n                // will stop us linking the empty timeline into the chain).\n                //\n                for (let i = timelineEvents.length - 1; i >= 0; i--) {\n                    const eventId = timelineEvents[i].getId()!;\n                    if (room.getTimelineForEvent(eventId)) {\n                        debuglog(`Already have event ${eventId} in limited sync - not resetting`);\n                        limited = false;\n\n                        // we might still be missing some of the events before i;\n                        // we don't want to be adding them to the end of the\n                        // timeline because that would put them out of order.\n                        timelineEvents.splice(0, i);\n\n                        // XXX: there's a problem here if the skipped part of the\n                        // timeline modifies the state set in stateEvents, because\n                        // we'll end up using the state from stateEvents rather\n                        // than the later state from timelineEvents. We probably\n                        // need to wind stateEvents forward over the events we're\n                        // skipping.\n\n                        break;\n                    }\n                }\n\n                if (limited) {\n                    room.resetLiveTimeline(\n                        joinObj.timeline.prev_batch,\n                        this.syncOpts.canResetEntireTimeline!(room.roomId)\n                            ? null\n                            : (syncEventData.oldSyncToken ?? null),\n                    );\n\n                    // We have to assume any gap in any timeline is\n                    // reason to stop incrementally tracking notifications and\n                    // reset the timeline.\n                    client.resetNotifTimelineSet();\n                }\n            }\n\n            // process any crypto events *before* emitting the RoomStateEvent events. This\n            // avoids a race condition if the application tries to send a message after the\n            // state event is processed, but before crypto is enabled, which then causes the\n            // crypto layer to complain.\n\n            if (this.syncOpts.cryptoCallbacks) {\n                for (const e of eventsFormingFinalState) {\n                    if (e.isState() && e.getType() === EventType.RoomEncryption && e.getStateKey() === \"\") {\n                        await this.syncOpts.cryptoCallbacks.onCryptoEvent(room, e);\n                    }\n                }\n            }\n\n            try {\n                if (\"org.matrix.msc4222.state_after\" in joinObj) {\n                    await this.injectRoomEvents(\n                        room,\n                        undefined,\n                        stateAfterEvents,\n                        timelineEvents,\n                        syncEventData.fromCache,\n                    );\n                } else {\n                    await this.injectRoomEvents(room, stateEvents, undefined, timelineEvents, syncEventData.fromCache);\n                }\n            } catch (e) {\n                logger.error(`Failed to process events on room ${room.roomId}:`, e);\n            }\n\n            // set summary after processing events,\n            // because it will trigger a name calculation\n            // which needs the room state to be up to date\n            if (joinObj.summary) {\n                room.setSummary(joinObj.summary);\n            }\n\n            // we deliberately don't add ephemeral events to the timeline\n            room.addEphemeralEvents(ephemeralEvents);\n\n            // we deliberately don't add accountData to the timeline\n            room.addAccountData(accountDataEvents);\n\n            room.recalculate();\n            if (joinObj.isBrandNewRoom) {\n                client.store.storeRoom(room);\n                client.emit(ClientEvent.Room, room);\n            }\n\n            this.processEventsForNotifs(room, timelineEvents);\n\n            const emitEvent = (e: MatrixEvent): boolean => client.emit(ClientEvent.Event, e);\n            stateEvents.forEach(emitEvent);\n            timelineEvents.forEach(emitEvent);\n            ephemeralEvents.forEach(emitEvent);\n            accountDataEvents.forEach(emitEvent);\n\n            // Decrypt only the last message in all rooms to make sure we can generate a preview\n            // And decrypt all events after the recorded read receipt to ensure an accurate\n            // notification count\n            room.decryptCriticalEvents();\n        });\n\n        // Handle leaves (e.g. kicked rooms)\n        await promiseMapSeries(leaveRooms, async (leaveObj) => {\n            const room = leaveObj.room;\n            const { timelineEvents, stateEvents, stateAfterEvents } = await this.mapAndInjectRoomEvents(leaveObj);\n            const accountDataEvents = this.mapSyncEventsFormat(leaveObj.account_data);\n\n            room.addAccountData(accountDataEvents);\n\n            room.recalculate();\n            if (leaveObj.isBrandNewRoom) {\n                client.store.storeRoom(room);\n                client.emit(ClientEvent.Room, room);\n            }\n\n            this.processEventsForNotifs(room, timelineEvents);\n\n            stateEvents?.forEach(function (e) {\n                client.emit(ClientEvent.Event, e);\n            });\n            stateAfterEvents?.forEach(function (e) {\n                client.emit(ClientEvent.Event, e);\n            });\n            timelineEvents.forEach(function (e) {\n                client.emit(ClientEvent.Event, e);\n            });\n            accountDataEvents.forEach(function (e) {\n                client.emit(ClientEvent.Event, e);\n            });\n        });\n\n        // Handle knocks\n        await promiseMapSeries(knockRooms, async (knockObj) => {\n            const room = knockObj.room;\n            const stateEvents = this.mapSyncEventsFormat(knockObj.knock_state, room);\n\n            await this.injectRoomEvents(room, stateEvents, undefined);\n\n            if (knockObj.isBrandNewRoom) {\n                room.recalculate();\n                client.store.storeRoom(room);\n                client.emit(ClientEvent.Room, room);\n            } else {\n                // Update room state for knock->leave->knock cycles\n                room.recalculate();\n            }\n            stateEvents.forEach(function (e) {\n                client.emit(ClientEvent.Event, e);\n            });\n        });\n\n        // update the notification timeline, if appropriate.\n        // we only do this for live events, as otherwise we can't order them sanely\n        // in the timeline relative to ones paginated in by /notifications.\n        // XXX: we could fix this by making EventTimeline support chronological\n        // ordering... but it doesn't, right now.\n        if (syncEventData.oldSyncToken && this.notifEvents.length) {\n            this.notifEvents.sort(function (a, b) {\n                return a.getTs() - b.getTs();\n            });\n            this.notifEvents.forEach(function (event) {\n                client.getNotifTimelineSet()?.addLiveEvent(event, { addToState: true });\n            });\n        }\n\n        // Handle device list updates\n        if (data.device_lists) {\n            if (this.syncOpts.cryptoCallbacks) {\n                await this.syncOpts.cryptoCallbacks.processDeviceLists(data.device_lists);\n            } else {\n                // FIXME if we *don't* have a crypto module, we still need to\n                // invalidate the device lists. But that would require a\n                // substantial bit of rework :/.\n            }\n        }\n\n        // Handle one_time_keys_count and unused fallback keys\n        await this.syncOpts.cryptoCallbacks?.processKeyCounts(\n            data.device_one_time_keys_count,\n            data.device_unused_fallback_key_types ?? data[\"org.matrix.msc2732.device_unused_fallback_key_types\"],\n        );\n    }\n\n    /**\n     * Starts polling the connectivity check endpoint\n     * @param delay - How long to delay until the first poll.\n     *        defaults to a short, randomised interval (to prevent\n     *        tight-looping if /versions succeeds but /sync etc. fail).\n     * @returns which resolves once the connection returns\n     */\n    private startKeepAlives(delay?: number): Promise<boolean> {\n        if (delay === undefined) {\n            delay = 2000 + Math.floor(Math.random() * 5000);\n        }\n\n        if (this.keepAliveTimer !== null) {\n            clearTimeout(this.keepAliveTimer);\n        }\n        if (delay > 0) {\n            this.keepAliveTimer = setTimeout(this.pokeKeepAlive.bind(this), delay);\n        } else {\n            this.pokeKeepAlive();\n        }\n        if (!this.connectionReturnedDefer) {\n            this.connectionReturnedDefer = defer();\n        }\n        return this.connectionReturnedDefer.promise;\n    }\n\n    /**\n     * Make a dummy call to /_matrix/client/versions, to see if the HS is\n     * reachable.\n     *\n     * On failure, schedules a call back to itself. On success, resolves\n     * this.connectionReturnedDefer.\n     *\n     * @param connDidFail - True if a connectivity failure has been detected. Optional.\n     */\n    private pokeKeepAlive(connDidFail = false): void {\n        if (!this.running) {\n            // we are in a keepAlive, retrying to connect, but the syncronization\n            // was stopped, so we are stopping the retry.\n            clearTimeout(this.keepAliveTimer);\n            if (this.connectionReturnedDefer) {\n                this.connectionReturnedDefer.reject(\"SyncApi.stop() was called\");\n                this.connectionReturnedDefer = undefined;\n            }\n            return;\n        }\n\n        const success = (): void => {\n            clearTimeout(this.keepAliveTimer);\n            if (this.connectionReturnedDefer) {\n                this.connectionReturnedDefer.resolve(connDidFail);\n                this.connectionReturnedDefer = undefined;\n            }\n        };\n\n        this.client.http\n            .request(\n                Method.Get,\n                \"/_matrix/client/versions\",\n                undefined, // queryParams\n                undefined, // data\n                {\n                    prefix: \"\",\n                    localTimeoutMs: 15 * 1000,\n                    abortSignal: this.abortController?.signal,\n                },\n            )\n            .then(\n                () => {\n                    success();\n                },\n                (err) => {\n                    if (err.httpStatus == 400 || err.httpStatus == 404) {\n                        // treat this as a success because the server probably just doesn't\n                        // support /versions: point is, we're getting a response.\n                        // We wait a short time though, just in case somehow the server\n                        // is in a mode where it 400s /versions responses and sync etc.\n                        // responses fail, this will mean we don't hammer in a loop.\n                        this.keepAliveTimer = setTimeout(success, 2000);\n                    } else {\n                        connDidFail = true;\n                        this.keepAliveTimer = setTimeout(\n                            this.pokeKeepAlive.bind(this, connDidFail),\n                            5000 + Math.floor(Math.random() * 5000),\n                        );\n                        // A keepalive has failed, so we emit the\n                        // error state (whether or not this is the\n                        // first failure).\n                        // Note we do this after setting the timer:\n                        // this lets the unit tests advance the mock\n                        // clock when they get the error.\n                        this.updateSyncState(SyncState.Error, { error: err });\n                    }\n                },\n            );\n    }\n\n    private mapSyncResponseToRoomArray<T extends ILeftRoom | IJoinedRoom | IInvitedRoom | IKnockedRoom>(\n        obj: Record<string, T>,\n    ): Array<WrappedRoom<T>> {\n        // Maps { roomid: {stuff}, roomid: {stuff} }\n        // to\n        // [{stuff+Room+isBrandNewRoom}, {stuff+Room+isBrandNewRoom}]\n        const client = this.client;\n        return Object.keys(obj)\n            .filter((k) => !unsafeProp(k))\n            .map((roomId) => {\n                let room = client.store.getRoom(roomId);\n                let isBrandNewRoom = false;\n                if (!room) {\n                    room = this.createRoom(roomId);\n                    isBrandNewRoom = true;\n                }\n                return {\n                    ...obj[roomId],\n                    room,\n                    isBrandNewRoom,\n                };\n            });\n    }\n\n    private mapSyncEventsFormat(\n        obj: IInviteState | ITimeline | IEphemeral | undefined,\n        room?: Room,\n        decrypt = true,\n    ): MatrixEvent[] {\n        if (!obj || !Array.isArray(obj.events)) {\n            return [];\n        }\n        const mapper = this.client.getEventMapper({ decrypt });\n        type TaggedEvent = (IStrippedState | IRoomEvent | IStateEvent | IMinimalEvent) & { room_id?: string };\n        return (obj.events as TaggedEvent[]).filter(noUnsafeEventProps).map(function (e) {\n            if (room) {\n                e.room_id = room.roomId;\n            }\n            return mapper(e);\n        });\n    }\n\n    /**\n     */\n    private resolveInvites(room: Room): void {\n        if (!room || !this.opts.resolveInvitesToProfiles) {\n            return;\n        }\n        const client = this.client;\n        // For each invited room member we want to give them a displayname/avatar url\n        // if they have one (the m.room.member invites don't contain this).\n        room.getMembersWithMembership(KnownMembership.Invite).forEach(function (member) {\n            if (member.requestedProfileInfo) return;\n            member.requestedProfileInfo = true;\n            // try to get a cached copy first.\n            const user = client.getUser(member.userId);\n            let promise;\n            if (user) {\n                promise = Promise.resolve({\n                    avatar_url: user.avatarUrl,\n                    displayname: user.displayName,\n                });\n            } else {\n                promise = client.getProfileInfo(member.userId);\n            }\n            promise.then(\n                function (info) {\n                    // slightly naughty by doctoring the invite event but this means all\n                    // the code paths remain the same between invite/join display name stuff\n                    // which is a worthy trade-off for some minor pollution.\n                    const inviteEvent = member.events.member;\n                    if (inviteEvent?.getContent().membership !== KnownMembership.Invite) {\n                        // between resolving and now they have since joined, so don't clobber\n                        return;\n                    }\n                    inviteEvent.getContent().avatar_url = info.avatar_url;\n                    inviteEvent.getContent().displayname = info.displayname;\n                    // fire listeners\n                    member.setMembershipEvent(inviteEvent, room.currentState);\n                },\n                function (err) {\n                    // OH WELL.\n                },\n            );\n        });\n    }\n\n    private findEncryptionEvent(events?: MatrixEvent[]): MatrixEvent | undefined {\n        return events?.find((e) => e.getType() === EventType.RoomEncryption && e.getStateKey() === \"\");\n    }\n\n    // When processing the sync response we cannot rely on Room.hasEncryptionStateEvent we actually\n    // inject the events into the room object, so we have to inspect the events themselves.\n    private isRoomEncrypted(room: Room, eventsFormingFinalState: MatrixEvent[]): boolean {\n        return room.hasEncryptionStateEvent() || !!this.findEncryptionEvent(eventsFormingFinalState);\n    }\n\n    private async mapAndInjectRoomEvents(wrappedRoom: WrappedRoom<ILeftRoom>): Promise<{\n        timelineEvents: MatrixEvent[];\n        stateEvents?: MatrixEvent[];\n        stateAfterEvents?: MatrixEvent[];\n    }> {\n        const stateEvents = this.mapSyncEventsFormat(wrappedRoom.state, wrappedRoom.room);\n        const stateAfterEvents = this.mapSyncEventsFormat(\n            wrappedRoom[\"org.matrix.msc4222.state_after\"],\n            wrappedRoom.room,\n        );\n        const timelineEvents = this.mapSyncEventsFormat(wrappedRoom.timeline, wrappedRoom.room);\n\n        if (\"org.matrix.msc4222.state_after\" in wrappedRoom) {\n            await this.injectRoomEvents(wrappedRoom.room, undefined, stateAfterEvents, timelineEvents);\n        } else {\n            await this.injectRoomEvents(wrappedRoom.room, stateEvents, undefined, timelineEvents);\n        }\n\n        return { timelineEvents, stateEvents, stateAfterEvents };\n    }\n\n    /**\n     * Injects events into a room's model.\n     * @param stateEventList - A list of state events. This is the state\n     * at the *START* of the timeline list if it is supplied.\n     * @param stateAfterEventList - A list of state events. This is the state\n     * at the *END* of the timeline list if it is supplied.\n     * @param timelineEventList - A list of timeline events, including threaded. Lower index\n     * is earlier in time. Higher index is later.\n     * @param fromCache - whether the sync response came from cache\n     *\n     * No more than one of stateEventList and stateAfterEventList must be supplied. If\n     * stateEventList is supplied, the events in timelineEventList are added to the state\n     * after stateEventList. If stateAfterEventList is supplied, the events in timelineEventList\n     * are not added to the state.\n     */\n    public async injectRoomEvents(\n        room: Room,\n        stateEventList: MatrixEvent[],\n        stateAfterEventList: undefined,\n        timelineEventList?: MatrixEvent[],\n        fromCache?: boolean,\n    ): Promise<void>;\n    public async injectRoomEvents(\n        room: Room,\n        stateEventList: undefined,\n        stateAfterEventList: MatrixEvent[],\n        timelineEventList?: MatrixEvent[],\n        fromCache?: boolean,\n    ): Promise<void>;\n    public async injectRoomEvents(\n        room: Room,\n        stateEventList: MatrixEvent[] | undefined,\n        stateAfterEventList: MatrixEvent[] | undefined,\n        timelineEventList?: MatrixEvent[],\n        fromCache = false,\n    ): Promise<void> {\n        const eitherStateEventList = stateAfterEventList ?? stateEventList!;\n\n        // If there are no events in the timeline yet, initialise it with\n        // the given state events\n        const liveTimeline = room.getLiveTimeline();\n        const timelineWasEmpty = liveTimeline.getEvents().length == 0;\n        if (timelineWasEmpty) {\n            // Passing these events into initialiseState will freeze them, so we need\n            // to compute and cache the push actions for them now, otherwise sync dies\n            // with an attempt to assign to read only property.\n            // XXX: This is pretty horrible and is assuming all sorts of behaviour from\n            // these functions that it shouldn't be. We should probably either store the\n            // push actions cache elsewhere so we can freeze MatrixEvents, or otherwise\n            // find some solution where MatrixEvents are immutable but allow for a cache\n            // field.\n\n            for (const ev of eitherStateEventList) {\n                this.client.getPushActionsForEvent(ev);\n            }\n            liveTimeline.initialiseState(eitherStateEventList, {\n                timelineWasEmpty,\n            });\n        }\n\n        this.resolveInvites(room);\n\n        // recalculate the room name at this point as adding events to the timeline\n        // may make notifications appear which should have the right name.\n        // XXX: This looks suspect: we'll end up recalculating the room once here\n        // and then again after adding events (processSyncResponse calls it after\n        // calling us) even if no state events were added. It also means that if\n        // one of the room events in timelineEventList is something that needs\n        // a recalculation (like m.room.name) we won't recalculate until we've\n        // finished adding all the events, which will cause the notification to have\n        // the old room name rather than the new one.\n        room.recalculate();\n\n        // If the timeline wasn't empty, we process the state events here: they're\n        // defined as updates to the state before the start of the timeline, so this\n        // starts to roll the state forward.\n        // XXX: That's what we *should* do, but this can happen if we were previously\n        // peeking in a room, in which case we obviously do *not* want to add the\n        // state events here onto the end of the timeline. Historically, the js-sdk\n        // has just set these new state events on the old and new state. This seems\n        // very wrong because there could be events in the timeline that diverge the\n        // state, in which case this is going to leave things out of sync. However,\n        // for now I think it;s best to behave the same as the code has done previously.\n        if (!timelineWasEmpty) {\n            // XXX: As above, don't do this...\n            //room.addLiveEvents(stateEventList || []);\n            // Do this instead...\n            room.oldState.setStateEvents(eitherStateEventList);\n            room.currentState.setStateEvents(eitherStateEventList);\n        }\n\n        // Execute the timeline events. If addToState is true the timeline has any state\n        // events in it, this will continue to diverge the current state.\n        // This also needs to be done before running push rules on the events as they need\n        // to be decorated with sender etc.\n        await room.addLiveEvents(timelineEventList || [], {\n            fromCache,\n            timelineWasEmpty,\n            addToState: stateAfterEventList === undefined,\n        });\n        this.client.processBeaconEvents(room, timelineEventList);\n    }\n\n    /**\n     * Takes a list of timelineEvents and adds and adds to notifEvents\n     * as appropriate.\n     * This must be called after the room the events belong to has been stored.\n     *\n     * @param timelineEventList - A list of timeline events. Lower index\n     * is earlier in time. Higher index is later.\n     */\n    private processEventsForNotifs(room: Room, timelineEventList: MatrixEvent[]): void {\n        // gather our notifications into this.notifEvents\n        if (this.client.getNotifTimelineSet()) {\n            for (const event of timelineEventList) {\n                const pushActions = this.client.getPushActionsForEvent(event);\n                if (pushActions?.notify && pushActions.tweaks?.highlight) {\n                    this.notifEvents.push(event);\n                }\n            }\n        }\n    }\n\n    private getGuestFilter(): string {\n        // Dev note: This used to be conditional to return a filter of 20 events maximum, but\n        // the condition never went to the other branch. This is now hardcoded.\n        return \"{}\";\n    }\n\n    /**\n     * Sets the sync state and emits an event to say so\n     * @param newState - The new state string\n     * @param data - Object of additional data to emit in the event\n     */\n    private updateSyncState(newState: SyncState, data?: ISyncStateData): void {\n        const old = this.syncState;\n        this.syncState = newState;\n        this.syncStateData = data;\n        this.client.emit(ClientEvent.Sync, this.syncState, old, data);\n    }\n\n    /**\n     * Event handler for the 'online' event\n     * This event is generally unreliable and precise behaviour\n     * varies between browsers, so we poll for connectivity too,\n     * but this might help us reconnect a little faster.\n     */\n    private onOnline = (): void => {\n        debuglog(\"Browser thinks we are back online\");\n        this.startKeepAlives(0);\n    };\n}\n\n// /!\\ This function is not intended for public use! It's only exported from\n// here in order to share some common logic with sliding-sync-sdk.ts.\nexport function _createAndReEmitRoom(client: MatrixClient, roomId: string, opts: Partial<IStoredClientOpts>): Room {\n    const { timelineSupport } = client;\n\n    const room = new Room(roomId, client, client.getUserId()!, {\n        lazyLoadMembers: opts.lazyLoadMembers,\n        pendingEventOrdering: opts.pendingEventOrdering,\n        timelineSupport,\n    });\n\n    client.reEmitter.reEmit(room, [\n        RoomEvent.Name,\n        RoomEvent.Redaction,\n        RoomEvent.RedactionCancelled,\n        RoomEvent.Receipt,\n        RoomEvent.Tags,\n        RoomEvent.LocalEchoUpdated,\n        RoomEvent.AccountData,\n        RoomEvent.MyMembership,\n        RoomEvent.Timeline,\n        RoomEvent.TimelineReset,\n        RoomStateEvent.Events,\n        RoomStateEvent.Members,\n        RoomStateEvent.NewMember,\n        RoomStateEvent.Update,\n        BeaconEvent.New,\n        BeaconEvent.Update,\n        BeaconEvent.Destroy,\n        BeaconEvent.LivenessChange,\n    ]);\n\n    // We need to add a listener for RoomState.members in order to hook them\n    // correctly.\n    room.on(RoomStateEvent.NewMember, (event, state, member) => {\n        member.user = client.getUser(member.userId) ?? undefined;\n        client.reEmitter.reEmit(member, [\n            RoomMemberEvent.Name,\n            RoomMemberEvent.Typing,\n            RoomMemberEvent.PowerLevel,\n            RoomMemberEvent.Membership,\n        ]);\n    });\n\n    return room;\n}\n\nexport function mapToDeviceEvent(plainOldJsObject: Partial<IEvent>): MatrixEvent {\n    // to-device events should not have a `room_id` property, but let's be sure\n    delete plainOldJsObject.room_id;\n    return new MatrixEvent(plainOldJsObject);\n}\n","/*\nCopyright 2024 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\n/*\n * This file is a secondary entrypoint for the js-sdk library, for use by Typescript projects.\n * It exposes low-level types and interfaces reflecting structures defined in the Matrix specification.\n *\n * Remember to only export *public* types from this file.\n */\n\nexport type * from \"./@types/media.ts\";\nexport * from \"./@types/membership.ts\";\nexport type * from \"./@types/event.ts\";\nexport type * from \"./@types/events.ts\";\nexport type * from \"./@types/state_events.ts\";\nexport type * from \"./@types/AESEncryptedSecretStoragePayload.ts\";\n\n/** The different methods for device and user verification */\nexport enum VerificationMethod {\n    /** Short authentication string (emoji or decimals).\n     *\n     * @see https://spec.matrix.org/v1.9/client-server-api/#short-authentication-string-sas-verification\n     */\n    Sas = \"m.sas.v1\",\n\n    /**\n     * Verification by showing a QR code which is scanned by the other device.\n     *\n     * @see https://spec.matrix.org/v1.9/client-server-api/#qr-codes\n     */\n    ShowQrCode = \"m.qr_code.show.v1\",\n\n    /**\n     * Verification by scanning a QR code that is shown by the other device.\n     *\n     * @see https://spec.matrix.org/v1.9/client-server-api/#qr-codes\n     */\n    ScanQrCode = \"m.qr_code.scan.v1\",\n\n    /**\n     * Verification by confirming that we have scanned a QR code.\n     *\n     * @see https://spec.matrix.org/v1.9/client-server-api/#qr-codes\n     */\n    Reciprocate = \"m.reciprocate.v1\",\n}\n","/*\n * Copyright 2024 The Matrix.org Foundation C.I.C.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { decodeBase64 } from \"../base64.ts\";\nimport { deriveKeys } from \"./internal/deriveKeys.ts\";\nimport { type AESEncryptedSecretStoragePayload } from \"../@types/AESEncryptedSecretStoragePayload.ts\";\n\n/**\n * Decrypt an AES-encrypted Secret Storage item.\n *\n * @param data - the encrypted data, returned by {@link utils/encryptAESSecretStorageItem.default | encryptAESSecretStorageItem}.\n * @param key - the encryption key to use as an input to the HKDF function which is used to derive the AES key. Must\n *    be the same as provided to {@link utils/encryptAESSecretStorageItem.default | encryptAESSecretStorageItem}.\n * @param name - the name of the secret. Also used as an input to the HKDF operation which is used to derive the AES\n *    key, so again must be the same as provided to {@link utils/encryptAESSecretStorageItem.default | encryptAESSecretStorageItem}.\n */\nexport default async function decryptAESSecretStorageItem(\n    data: AESEncryptedSecretStoragePayload,\n    key: Uint8Array,\n    name: string,\n): Promise<string> {\n    const [aesKey, hmacKey] = await deriveKeys(key, name);\n\n    const ciphertext = decodeBase64(data.ciphertext);\n\n    if (!(await globalThis.crypto.subtle.verify({ name: \"HMAC\" }, hmacKey, decodeBase64(data.mac), ciphertext))) {\n        throw new Error(`Error decrypting secret ${name}: bad MAC`);\n    }\n\n    const plaintext = await globalThis.crypto.subtle.decrypt(\n        {\n            name: \"AES-CTR\",\n            counter: decodeBase64(data.iv),\n            length: 64,\n        },\n        aesKey,\n        ciphertext,\n    );\n\n    return new TextDecoder().decode(new Uint8Array(plaintext));\n}\n","/*\n * Copyright 2024 The Matrix.org Foundation C.I.C.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { decodeBase64, encodeBase64 } from \"../base64.ts\";\nimport { deriveKeys } from \"./internal/deriveKeys.ts\";\nimport { type AESEncryptedSecretStoragePayload } from \"../@types/AESEncryptedSecretStoragePayload.ts\";\n\n/**\n * Encrypt a string as a secret storage item, using AES-CTR.\n *\n * @param data - the plaintext to encrypt\n * @param key - the encryption key to use as an input to the HKDF function which is used to derive the AES key for\n *    encryption. Obviously, the same key must be provided when decrypting.\n * @param name - the name of the secret. Used as an input to the HKDF operation which is used to derive the AES key,\n *    so again the same value must be provided when decrypting.\n * @param ivStr - the base64-encoded initialization vector to use. If not supplied, a random one will be generated.\n *\n * @returns The encrypted result, including the ciphertext itself, the initialization vector (as supplied in `ivStr`,\n *   or generated), and an HMAC on the ciphertext — all base64-encoded.\n */\nexport default async function encryptAESSecretStorageItem(\n    data: string,\n    key: Uint8Array,\n    name: string,\n    ivStr?: string,\n): Promise<AESEncryptedSecretStoragePayload> {\n    let iv: Uint8Array;\n    if (ivStr) {\n        iv = decodeBase64(ivStr);\n    } else {\n        iv = new Uint8Array(16);\n        globalThis.crypto.getRandomValues(iv);\n\n        // clear bit 63 of the IV to stop us hitting the 64-bit counter boundary\n        // (which would mean we wouldn't be able to decrypt on Android). The loss\n        // of a single bit of iv is a price we have to pay.\n        iv[8] &= 0x7f;\n    }\n\n    const [aesKey, hmacKey] = await deriveKeys(key, name);\n    const encodedData = new TextEncoder().encode(data);\n\n    const ciphertext = await globalThis.crypto.subtle.encrypt(\n        {\n            name: \"AES-CTR\",\n            counter: iv,\n            length: 64,\n        },\n        aesKey,\n        encodedData,\n    );\n\n    const hmac = await globalThis.crypto.subtle.sign({ name: \"HMAC\" }, hmacKey, ciphertext);\n\n    return {\n        iv: encodeBase64(iv),\n        ciphertext: encodeBase64(new Uint8Array(ciphertext)),\n        mac: encodeBase64(new Uint8Array(hmac)),\n    };\n}\n","/*\n * Copyright 2024 The Matrix.org Foundation C.I.C.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n// salt for HKDF, with 8 bytes of zeros\nconst zeroSalt = new Uint8Array(8);\n\n/**\n * Derive AES and HMAC keys from a master key.\n *\n * This is used for deriving secret storage keys: see https://spec.matrix.org/v1.11/client-server-api/#msecret_storagev1aes-hmac-sha2 (step 1).\n *\n * @param key\n * @param name\n */\nexport async function deriveKeys(key: Uint8Array, name: string): Promise<[CryptoKey, CryptoKey]> {\n    const hkdfkey = await globalThis.crypto.subtle.importKey(\"raw\", key, { name: \"HKDF\" }, false, [\"deriveBits\"]);\n    const keybits = await globalThis.crypto.subtle.deriveBits(\n        {\n            name: \"HKDF\",\n            salt: zeroSalt,\n            // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n            // @ts-ignore: https://github.com/microsoft/TypeScript-DOM-lib-generator/pull/879\n            info: new TextEncoder().encode(name),\n            hash: \"SHA-256\",\n        },\n        hkdfkey,\n        512,\n    );\n\n    const aesKey = keybits.slice(0, 32);\n    const hmacKey = keybits.slice(32);\n\n    const aesProm = globalThis.crypto.subtle.importKey(\"raw\", aesKey, { name: \"AES-CTR\" }, false, [\n        \"encrypt\",\n        \"decrypt\",\n    ]);\n\n    const hmacProm = globalThis.crypto.subtle.importKey(\n        \"raw\",\n        hmacKey,\n        {\n            name: \"HMAC\",\n            hash: { name: \"SHA-256\" },\n        },\n        false,\n        [\"sign\", \"verify\"],\n    );\n\n    return Promise.all([aesProm, hmacProm]);\n}\n","/*\nCopyright 2022 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\n/**\n * A list of the spec versions which the js-sdk is compatible with.\n *\n * In practice, this means: when we connect to a server, it must declare support for one of the versions in this list.\n *\n * Note that it does not *necessarily* mean that the js-sdk has good support for all the features in the listed spec\n * versions; only that we should be able to provide a base level of functionality with a server that offers support for\n * any of the listed versions.\n */\nexport const SUPPORTED_MATRIX_VERSIONS = [\"v1.1\", \"v1.2\", \"v1.3\", \"v1.4\", \"v1.5\", \"v1.6\", \"v1.7\", \"v1.8\", \"v1.9\"];\n\n/**\n * The oldest Matrix specification version the js-sdk supports.\n */\nexport const MINIMUM_MATRIX_VERSION = SUPPORTED_MATRIX_VERSIONS[0];\n\n/**\n * The most recent Matrix specification version the js-sdk supports.\n */\nexport const MAXIMUM_MATRIX_VERSION = SUPPORTED_MATRIX_VERSIONS[SUPPORTED_MATRIX_VERSIONS.length - 1];\n","/*\nCopyright 2015, 2016 OpenMarket Ltd\nCopyright 2017 New Vector Ltd\nCopyright 2019, 2020 The Matrix.org Foundation C.I.C.\nCopyright 2021 - 2022 Šimon Brandner <simon.bra.ag@gmail.com>\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\n/**\n * This is an internal module. See {@link createNewMatrixCall} for the public API.\n */\n\nimport { v4 as uuidv4 } from \"uuid\";\nimport { parse as parseSdp, write as writeSdp } from \"sdp-transform\";\n\nimport { logger } from \"../logger.ts\";\nimport { checkObjectHasKeys, isNullOrUndefined, recursivelyAssign } from \"../utils.ts\";\nimport { type MatrixEvent } from \"../models/event.ts\";\nimport { EventType, type TimelineEvents, ToDeviceMessageId } from \"../@types/event.ts\";\nimport { type RoomMember } from \"../models/room-member.ts\";\nimport { secureRandomString } from \"../randomstring.ts\";\nimport {\n    type MCallReplacesEvent,\n    type MCallAnswer,\n    type MCallInviteNegotiate,\n    type CallCapabilities,\n    SDPStreamMetadataPurpose,\n    type SDPStreamMetadata,\n    SDPStreamMetadataKey,\n    type MCallSDPStreamMetadataChanged,\n    type MCallSelectAnswer,\n    type MCAllAssertedIdentity,\n    type MCallCandidates,\n    type MCallBase,\n    type MCallHangupReject,\n} from \"./callEventTypes.ts\";\nimport { CallFeed } from \"./callFeed.ts\";\nimport { type MatrixClient } from \"../client.ts\";\nimport { EventEmitterEvents, TypedEventEmitter } from \"../models/typed-event-emitter.ts\";\nimport { GroupCallUnknownDeviceError } from \"./groupCall.ts\";\nimport { type IScreensharingOpts } from \"./mediaHandler.ts\";\nimport { MatrixError } from \"../http-api/index.ts\";\nimport { type GroupCallStats } from \"./stats/groupCallStats.ts\";\n\ninterface CallOpts {\n    // The room ID for this call.\n    roomId: string;\n    invitee?: string;\n    // The Matrix Client instance to send events to.\n    client: MatrixClient;\n    /**\n     * Whether relay through TURN should be forced.\n     * @deprecated use opts.forceTURN when creating the matrix client\n     * since it's only possible to set this option on outbound calls.\n     */\n    forceTURN?: boolean;\n    // A list of TURN servers.\n    turnServers?: Array<TurnServer>;\n    opponentDeviceId?: string;\n    opponentSessionId?: string;\n    groupCallId?: string;\n}\n\ninterface TurnServer {\n    urls: Array<string>;\n    username?: string;\n    password?: string;\n    ttl?: number;\n}\n\ninterface AssertedIdentity {\n    id: string;\n    displayName: string;\n}\n\nenum MediaType {\n    AUDIO = \"audio\",\n    VIDEO = \"video\",\n}\n\nenum CodecName {\n    OPUS = \"opus\",\n    // add more as needed\n}\n\n// Used internally to specify modifications to codec parameters in SDP\ninterface CodecParamsMod {\n    mediaType: MediaType;\n    codec: CodecName;\n    enableDtx?: boolean; // true to enable discontinuous transmission, false to disable, undefined to leave as-is\n    maxAverageBitrate?: number; // sets the max average bitrate, or undefined to leave as-is\n}\n\nexport enum CallState {\n    Fledgling = \"fledgling\",\n    InviteSent = \"invite_sent\",\n    WaitLocalMedia = \"wait_local_media\",\n    CreateOffer = \"create_offer\",\n    CreateAnswer = \"create_answer\",\n    Connecting = \"connecting\",\n    Connected = \"connected\",\n    Ringing = \"ringing\",\n    Ended = \"ended\",\n}\n\nexport enum CallType {\n    Voice = \"voice\",\n    Video = \"video\",\n}\n\nexport enum CallDirection {\n    Inbound = \"inbound\",\n    Outbound = \"outbound\",\n}\n\nexport enum CallParty {\n    Local = \"local\",\n    Remote = \"remote\",\n}\n\nexport enum CallEvent {\n    Hangup = \"hangup\",\n    State = \"state\",\n    Error = \"error\",\n    Replaced = \"replaced\",\n\n    // The value of isLocalOnHold() has changed\n    LocalHoldUnhold = \"local_hold_unhold\",\n    // The value of isRemoteOnHold() has changed\n    RemoteHoldUnhold = \"remote_hold_unhold\",\n    // backwards compat alias for LocalHoldUnhold: remove in a major version bump\n    HoldUnhold = \"hold_unhold\",\n    // Feeds have changed\n    FeedsChanged = \"feeds_changed\",\n\n    AssertedIdentityChanged = \"asserted_identity_changed\",\n\n    LengthChanged = \"length_changed\",\n\n    DataChannel = \"datachannel\",\n\n    SendVoipEvent = \"send_voip_event\",\n\n    // When the call instantiates its peer connection\n    // For apps that want to access the underlying peer connection, eg for debugging\n    PeerConnectionCreated = \"peer_connection_created\",\n}\n\nexport enum CallErrorCode {\n    /** The user chose to end the call */\n    UserHangup = \"user_hangup\",\n\n    /** An error code when the local client failed to create an offer. */\n    LocalOfferFailed = \"local_offer_failed\",\n    /**\n     * An error code when there is no local mic/camera to use. This may be because\n     * the hardware isn't plugged in, or the user has explicitly denied access.\n     */\n    NoUserMedia = \"no_user_media\",\n\n    /**\n     * Error code used when a call event failed to send\n     * because unknown devices were present in the room\n     */\n    UnknownDevices = \"unknown_devices\",\n\n    /**\n     * Error code used when we fail to send the invite\n     * for some reason other than there being unknown devices\n     */\n    SendInvite = \"send_invite\",\n\n    /**\n     * An answer could not be created\n     */\n    CreateAnswer = \"create_answer\",\n\n    /**\n     * An offer could not be created\n     */\n    CreateOffer = \"create_offer\",\n\n    /**\n     * Error code used when we fail to send the answer\n     * for some reason other than there being unknown devices\n     */\n    SendAnswer = \"send_answer\",\n\n    /**\n     * The session description from the other side could not be set\n     */\n    SetRemoteDescription = \"set_remote_description\",\n\n    /**\n     * The session description from this side could not be set\n     */\n    SetLocalDescription = \"set_local_description\",\n\n    /**\n     * A different device answered the call\n     */\n    AnsweredElsewhere = \"answered_elsewhere\",\n\n    /**\n     * No media connection could be established to the other party\n     */\n    IceFailed = \"ice_failed\",\n\n    /**\n     * The invite timed out whilst waiting for an answer\n     */\n    InviteTimeout = \"invite_timeout\",\n\n    /**\n     * The call was replaced by another call\n     */\n    Replaced = \"replaced\",\n\n    /**\n     * Signalling for the call could not be sent (other than the initial invite)\n     */\n    SignallingFailed = \"signalling_timeout\",\n\n    /**\n     * The remote party is busy\n     */\n    UserBusy = \"user_busy\",\n\n    /**\n     * We transferred the call off to somewhere else\n     */\n    Transferred = \"transferred\",\n\n    /**\n     * A call from the same user was found with a new session id\n     */\n    NewSession = \"new_session\",\n}\n\n/**\n * The version field that we set in m.call.* events\n */\nconst VOIP_PROTO_VERSION = \"1\";\n\n/** The fallback ICE server to use for STUN or TURN protocols. */\nexport const FALLBACK_ICE_SERVER = \"stun:turn.matrix.org\";\n\n/** The length of time a call can be ringing for. */\nconst CALL_TIMEOUT_MS = 60 * 1000; // ms\n/** The time after which we increment callLength */\nconst CALL_LENGTH_INTERVAL = 1000; // ms\n/** The time after which we end the call, if ICE got disconnected */\nconst ICE_DISCONNECTED_TIMEOUT = 30 * 1000; // ms\n/** The time after which we try a ICE restart, if ICE got disconnected */\nconst ICE_RECONNECTING_TIMEOUT = 2 * 1000; // ms\nexport class CallError extends Error {\n    public readonly code: string;\n\n    public constructor(code: CallErrorCode, msg: string, err: Error) {\n        // Still don't think there's any way to have proper nested errors\n        super(msg + \": \" + err);\n\n        this.code = code;\n    }\n}\n\nexport function genCallID(): string {\n    return Date.now().toString() + secureRandomString(16);\n}\n\nfunction getCodecParamMods(isPtt: boolean): CodecParamsMod[] {\n    const mods = [\n        {\n            mediaType: \"audio\",\n            codec: \"opus\",\n            enableDtx: true,\n            maxAverageBitrate: isPtt ? 12000 : undefined,\n        },\n    ] as CodecParamsMod[];\n\n    return mods;\n}\n\ntype CallEventType =\n    | EventType.CallReplaces\n    | EventType.CallAnswer\n    | EventType.CallSelectAnswer\n    | EventType.CallNegotiate\n    | EventType.CallInvite\n    | EventType.CallCandidates\n    | EventType.CallHangup\n    | EventType.CallReject\n    | EventType.CallSDPStreamMetadataChangedPrefix;\n\nexport interface VoipEvent {\n    type: \"toDevice\" | \"sendEvent\";\n    eventType: string;\n    userId?: string;\n    opponentDeviceId?: string;\n    roomId?: string;\n    content: TimelineEvents[CallEventType];\n}\n\n/**\n * These now all have the call object as an argument. Why? Well, to know which call a given event is\n * about you have three options:\n *  1. Use a closure as the callback that remembers what call it's listening to. This can be\n *     a pain because you need to pass the listener function again when you remove the listener,\n *     which might be somewhere else.\n *  2. Use not-very-well-known fact that EventEmitter sets 'this' to the emitter object in the\n *     callback. This doesn't really play well with modern Typescript and eslint and doesn't work\n *     with our pattern of re-emitting events.\n *  3. Pass the object in question as an argument to the callback.\n *\n * Now that we have group calls which have to deal with multiple call objects, this will\n * become more important, and I think methods 1 and 2 are just going to cause issues.\n */\nexport type CallEventHandlerMap = {\n    [CallEvent.DataChannel]: (channel: RTCDataChannel, call: MatrixCall) => void;\n    [CallEvent.FeedsChanged]: (feeds: CallFeed[], call: MatrixCall) => void;\n    [CallEvent.Replaced]: (newCall: MatrixCall, oldCall: MatrixCall) => void;\n    [CallEvent.Error]: (error: CallError, call: MatrixCall) => void;\n    [CallEvent.RemoteHoldUnhold]: (onHold: boolean, call: MatrixCall) => void;\n    [CallEvent.LocalHoldUnhold]: (onHold: boolean, call: MatrixCall) => void;\n    [CallEvent.LengthChanged]: (length: number, call: MatrixCall) => void;\n    [CallEvent.State]: (state: CallState, oldState: CallState, call: MatrixCall) => void;\n    [CallEvent.Hangup]: (call: MatrixCall) => void;\n    [CallEvent.AssertedIdentityChanged]: (call: MatrixCall) => void;\n    /* @deprecated */\n    [CallEvent.HoldUnhold]: (onHold: boolean) => void;\n    [CallEvent.SendVoipEvent]: (event: VoipEvent, call: MatrixCall) => void;\n    [CallEvent.PeerConnectionCreated]: (peerConn: RTCPeerConnection, call: MatrixCall) => void;\n};\n\n// The key of the transceiver map (purpose + media type, separated by ':')\ntype TransceiverKey = string;\n\n// generates keys for the map of transceivers\n// kind is unfortunately a string rather than MediaType as this is the type of\n// track.kind\nfunction getTransceiverKey(purpose: SDPStreamMetadataPurpose, kind: TransceiverKey): string {\n    return purpose + \":\" + kind;\n}\n\nexport class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap> {\n    public roomId: string;\n    public callId: string;\n    public invitee?: string;\n    public hangupParty?: CallParty;\n    public hangupReason?: string;\n    public direction?: CallDirection;\n    public ourPartyId: string;\n    public peerConn?: RTCPeerConnection;\n    public toDeviceSeq = 0;\n\n    // whether this call should have push-to-talk semantics\n    // This should be set by the consumer on incoming & outgoing calls.\n    public isPtt = false;\n\n    private _state = CallState.Fledgling;\n    private readonly client: MatrixClient;\n    private readonly forceTURN?: boolean;\n    private readonly turnServers: Array<TurnServer>;\n    // A queue for candidates waiting to go out.\n    // We try to amalgamate candidates into a single candidate message where\n    // possible\n    private candidateSendQueue: Array<RTCIceCandidate> = [];\n    private candidateSendTries = 0;\n    private candidatesEnded = false;\n    private feeds: Array<CallFeed> = [];\n\n    // our transceivers for each purpose and type of media\n    private transceivers = new Map<TransceiverKey, RTCRtpTransceiver>();\n\n    private inviteOrAnswerSent = false;\n    private waitForLocalAVStream = false;\n    private successor?: MatrixCall;\n    private opponentMember?: RoomMember;\n    private opponentVersion?: number | string;\n    // The party ID of the other side: undefined if we haven't chosen a partner\n    // yet, null if we have but they didn't send a party ID.\n    private opponentPartyId: string | null | undefined;\n    private opponentCaps?: CallCapabilities;\n    private iceDisconnectedTimeout?: ReturnType<typeof setTimeout>;\n    private iceReconnectionTimeOut?: ReturnType<typeof setTimeout> | undefined;\n    private inviteTimeout?: ReturnType<typeof setTimeout>;\n    private readonly removeTrackListeners = new Map<MediaStream, () => void>();\n\n    // The logic of when & if a call is on hold is nontrivial and explained in is*OnHold\n    // This flag represents whether we want the other party to be on hold\n    private remoteOnHold = false;\n\n    // the stats for the call at the point it ended. We can't get these after we\n    // tear the call down, so we just grab a snapshot before we stop the call.\n    // The typescript definitions have this type as 'any' :(\n    private callStatsAtEnd?: any[];\n\n    // Perfect negotiation state: https://www.w3.org/TR/webrtc/#perfect-negotiation-example\n    private makingOffer = false;\n    private ignoreOffer = false;\n    private isSettingRemoteAnswerPending = false;\n\n    private responsePromiseChain?: Promise<void>;\n\n    // If candidates arrive before we've picked an opponent (which, in particular,\n    // will happen if the opponent sends candidates eagerly before the user answers\n    // the call) we buffer them up here so we can then add the ones from the party we pick\n    private remoteCandidateBuffer = new Map<string, MCallCandidates[\"candidates\"]>();\n\n    private remoteAssertedIdentity?: AssertedIdentity;\n    private remoteSDPStreamMetadata?: SDPStreamMetadata;\n\n    private callLengthInterval?: ReturnType<typeof setInterval>;\n    private callStartTime?: number;\n\n    private opponentDeviceId?: string;\n    private hasOpponentDeviceInfo?: boolean;\n    private opponentSessionId?: string;\n    public groupCallId?: string;\n\n    // Used to keep the timer for the delay before actually stopping our\n    // video track after muting (see setLocalVideoMuted)\n    private stopVideoTrackTimer?: ReturnType<typeof setTimeout>;\n    // Used to allow connection without Video and Audio. To establish a webrtc connection without media a Data channel is\n    // needed At the moment this property is true if we allow MatrixClient with isVoipWithNoMediaAllowed = true\n    private readonly isOnlyDataChannelAllowed: boolean;\n    private stats: GroupCallStats | undefined;\n\n    /**\n     * Construct a new Matrix Call.\n     * @param opts - Config options.\n     */\n    public constructor(opts: CallOpts) {\n        super();\n\n        this.roomId = opts.roomId;\n        this.invitee = opts.invitee;\n        this.client = opts.client;\n\n        if (!this.client.deviceId) throw new Error(\"Client must have a device ID to start calls\");\n\n        this.forceTURN = opts.forceTURN ?? false;\n        this.ourPartyId = this.client.deviceId;\n        this.opponentDeviceId = opts.opponentDeviceId;\n        this.opponentSessionId = opts.opponentSessionId;\n        this.groupCallId = opts.groupCallId;\n        // Array of Objects with urls, username, credential keys\n        this.turnServers = opts.turnServers || [];\n        if (this.turnServers.length === 0 && this.client.isFallbackICEServerAllowed()) {\n            this.turnServers.push({\n                urls: [FALLBACK_ICE_SERVER],\n            });\n        }\n        for (const server of this.turnServers) {\n            checkObjectHasKeys(server, [\"urls\"]);\n        }\n        this.callId = genCallID();\n        // If the Client provides calls without audio and video we need a datachannel for a webrtc connection\n        this.isOnlyDataChannelAllowed = this.client.isVoipWithNoMediaAllowed;\n    }\n\n    /**\n     * Place a voice call to this room.\n     * @throws If you have not specified a listener for 'error' events.\n     */\n    public async placeVoiceCall(): Promise<void> {\n        await this.placeCall(true, false);\n    }\n\n    /**\n     * Place a video call to this room.\n     * @throws If you have not specified a listener for 'error' events.\n     */\n    public async placeVideoCall(): Promise<void> {\n        await this.placeCall(true, true);\n    }\n\n    /**\n     * Create a datachannel using this call's peer connection.\n     * @param label - A human readable label for this datachannel\n     * @param options - An object providing configuration options for the data channel.\n     */\n    public createDataChannel(label: string, options: RTCDataChannelInit | undefined): RTCDataChannel {\n        const dataChannel = this.peerConn!.createDataChannel(label, options);\n        this.emit(CallEvent.DataChannel, dataChannel, this);\n        return dataChannel;\n    }\n\n    public getOpponentMember(): RoomMember | undefined {\n        return this.opponentMember;\n    }\n\n    public getOpponentDeviceId(): string | undefined {\n        return this.opponentDeviceId;\n    }\n\n    public getOpponentSessionId(): string | undefined {\n        return this.opponentSessionId;\n    }\n\n    public opponentCanBeTransferred(): boolean {\n        return Boolean(this.opponentCaps && this.opponentCaps[\"m.call.transferee\"]);\n    }\n\n    public opponentSupportsDTMF(): boolean {\n        return Boolean(this.opponentCaps && this.opponentCaps[\"m.call.dtmf\"]);\n    }\n\n    public getRemoteAssertedIdentity(): AssertedIdentity | undefined {\n        return this.remoteAssertedIdentity;\n    }\n\n    public get state(): CallState {\n        return this._state;\n    }\n\n    private set state(state: CallState) {\n        const oldState = this._state;\n        this._state = state;\n        this.emit(CallEvent.State, state, oldState, this);\n    }\n\n    public get type(): CallType {\n        // we may want to look for a video receiver here rather than a track to match the\n        // sender behaviour, although in practice they should be the same thing\n        return this.hasUserMediaVideoSender || this.hasRemoteUserMediaVideoTrack ? CallType.Video : CallType.Voice;\n    }\n\n    public get hasLocalUserMediaVideoTrack(): boolean {\n        return !!this.localUsermediaStream?.getVideoTracks().length;\n    }\n\n    public get hasRemoteUserMediaVideoTrack(): boolean {\n        return this.getRemoteFeeds().some((feed) => {\n            return feed.purpose === SDPStreamMetadataPurpose.Usermedia && feed.stream?.getVideoTracks().length;\n        });\n    }\n\n    public get hasLocalUserMediaAudioTrack(): boolean {\n        return !!this.localUsermediaStream?.getAudioTracks().length;\n    }\n\n    public get hasRemoteUserMediaAudioTrack(): boolean {\n        return this.getRemoteFeeds().some((feed) => {\n            return feed.purpose === SDPStreamMetadataPurpose.Usermedia && !!feed.stream?.getAudioTracks().length;\n        });\n    }\n\n    private get hasUserMediaAudioSender(): boolean {\n        return Boolean(this.transceivers.get(getTransceiverKey(SDPStreamMetadataPurpose.Usermedia, \"audio\"))?.sender);\n    }\n\n    private get hasUserMediaVideoSender(): boolean {\n        return Boolean(this.transceivers.get(getTransceiverKey(SDPStreamMetadataPurpose.Usermedia, \"video\"))?.sender);\n    }\n\n    public get localUsermediaFeed(): CallFeed | undefined {\n        return this.getLocalFeeds().find((feed) => feed.purpose === SDPStreamMetadataPurpose.Usermedia);\n    }\n\n    public get localScreensharingFeed(): CallFeed | undefined {\n        return this.getLocalFeeds().find((feed) => feed.purpose === SDPStreamMetadataPurpose.Screenshare);\n    }\n\n    public get localUsermediaStream(): MediaStream | undefined {\n        return this.localUsermediaFeed?.stream;\n    }\n\n    public get localScreensharingStream(): MediaStream | undefined {\n        return this.localScreensharingFeed?.stream;\n    }\n\n    public get remoteUsermediaFeed(): CallFeed | undefined {\n        return this.getRemoteFeeds().find((feed) => feed.purpose === SDPStreamMetadataPurpose.Usermedia);\n    }\n\n    public get remoteScreensharingFeed(): CallFeed | undefined {\n        return this.getRemoteFeeds().find((feed) => feed.purpose === SDPStreamMetadataPurpose.Screenshare);\n    }\n\n    public get remoteUsermediaStream(): MediaStream | undefined {\n        return this.remoteUsermediaFeed?.stream;\n    }\n\n    public get remoteScreensharingStream(): MediaStream | undefined {\n        return this.remoteScreensharingFeed?.stream;\n    }\n\n    private getFeedByStreamId(streamId: string): CallFeed | undefined {\n        return this.getFeeds().find((feed) => feed.stream.id === streamId);\n    }\n\n    /**\n     * Returns an array of all CallFeeds\n     * @returns CallFeeds\n     */\n    public getFeeds(): Array<CallFeed> {\n        return this.feeds;\n    }\n\n    /**\n     * Returns an array of all local CallFeeds\n     * @returns local CallFeeds\n     */\n    public getLocalFeeds(): Array<CallFeed> {\n        return this.feeds.filter((feed) => feed.isLocal());\n    }\n\n    /**\n     * Returns an array of all remote CallFeeds\n     * @returns remote CallFeeds\n     */\n    public getRemoteFeeds(): Array<CallFeed> {\n        return this.feeds.filter((feed) => !feed.isLocal());\n    }\n\n    private async initOpponentCrypto(): Promise<void> {\n        if (!this.opponentDeviceId) return;\n        if (!this.client.getUseE2eForGroupCall()) return;\n        // It's possible to want E2EE and yet not have the means to manage E2EE\n        // ourselves (for example if the client is a RoomWidgetClient)\n        if (!this.client.getCrypto()) {\n            // All we know is the device ID\n            this.hasOpponentDeviceInfo = true;\n            return;\n        }\n        const userId = this.invitee || this.getOpponentMember()?.userId;\n\n        if (!userId) throw new Error(\"Couldn't find opponent user ID to init crypto\");\n\n        // Here we were calling `MatrixClient.crypto.deviceList.downloadKeys` which is not supported by the rust cryptography.\n        this.hasOpponentDeviceInfo = false;\n        throw new GroupCallUnknownDeviceError(userId);\n    }\n\n    /**\n     * Generates and returns localSDPStreamMetadata\n     * @returns localSDPStreamMetadata\n     */\n    private getLocalSDPStreamMetadata(updateStreamIds = false): SDPStreamMetadata {\n        const metadata: SDPStreamMetadata = {};\n        for (const localFeed of this.getLocalFeeds()) {\n            if (updateStreamIds) {\n                localFeed.sdpMetadataStreamId = localFeed.stream.id;\n            }\n\n            metadata[localFeed.sdpMetadataStreamId] = {\n                purpose: localFeed.purpose,\n                audio_muted: localFeed.isAudioMuted(),\n                video_muted: localFeed.isVideoMuted(),\n            };\n        }\n        return metadata;\n    }\n\n    /**\n     * Returns true if there are no incoming feeds,\n     * otherwise returns false\n     * @returns no incoming feeds\n     */\n    public noIncomingFeeds(): boolean {\n        return !this.feeds.some((feed) => !feed.isLocal());\n    }\n\n    private pushRemoteFeed(stream: MediaStream): void {\n        // Fallback to old behavior if the other side doesn't support SDPStreamMetadata\n        if (!this.opponentSupportsSDPStreamMetadata()) {\n            this.pushRemoteFeedWithoutMetadata(stream);\n            return;\n        }\n\n        const userId = this.getOpponentMember()!.userId;\n        const purpose = this.remoteSDPStreamMetadata![stream.id].purpose;\n        const audioMuted = this.remoteSDPStreamMetadata![stream.id].audio_muted;\n        const videoMuted = this.remoteSDPStreamMetadata![stream.id].video_muted;\n\n        if (!purpose) {\n            logger.warn(\n                `Call ${this.callId} pushRemoteFeed() ignoring stream because we didn't get any metadata about it (streamId=${stream.id})`,\n            );\n            return;\n        }\n\n        if (this.getFeedByStreamId(stream.id)) {\n            logger.warn(\n                `Call ${this.callId} pushRemoteFeed() ignoring stream because we already have a feed for it (streamId=${stream.id})`,\n            );\n            return;\n        }\n\n        this.feeds.push(\n            new CallFeed({\n                client: this.client,\n                call: this,\n                roomId: this.roomId,\n                userId,\n                deviceId: this.getOpponentDeviceId(),\n                stream,\n                purpose,\n                audioMuted,\n                videoMuted,\n            }),\n        );\n\n        this.emit(CallEvent.FeedsChanged, this.feeds, this);\n\n        logger.info(\n            `Call ${this.callId} pushRemoteFeed() pushed stream (streamId=${stream.id}, active=${stream.active}, purpose=${purpose})`,\n        );\n    }\n\n    /**\n     * This method is used ONLY if the other client doesn't support sending SDPStreamMetadata\n     */\n    private pushRemoteFeedWithoutMetadata(stream: MediaStream): void {\n        const userId = this.getOpponentMember()!.userId;\n        // We can guess the purpose here since the other client can only send one stream\n        const purpose = SDPStreamMetadataPurpose.Usermedia;\n        const oldRemoteStream = this.feeds.find((feed) => !feed.isLocal())?.stream;\n\n        // Note that we check by ID and always set the remote stream: Chrome appears\n        // to make new stream objects when transceiver directionality is changed and the 'active'\n        // status of streams change - Dave\n        // If we already have a stream, check this stream has the same id\n        if (oldRemoteStream && stream.id !== oldRemoteStream.id) {\n            logger.warn(\n                `Call ${this.callId} pushRemoteFeedWithoutMetadata() ignoring new stream because we already have stream (streamId=${stream.id})`,\n            );\n            return;\n        }\n\n        if (this.getFeedByStreamId(stream.id)) {\n            logger.warn(\n                `Call ${this.callId} pushRemoteFeedWithoutMetadata() ignoring stream because we already have a feed for it (streamId=${stream.id})`,\n            );\n            return;\n        }\n\n        this.feeds.push(\n            new CallFeed({\n                client: this.client,\n                call: this,\n                roomId: this.roomId,\n                audioMuted: false,\n                videoMuted: false,\n                userId,\n                deviceId: this.getOpponentDeviceId(),\n                stream,\n                purpose,\n            }),\n        );\n\n        this.emit(CallEvent.FeedsChanged, this.feeds, this);\n\n        logger.info(\n            `Call ${this.callId} pushRemoteFeedWithoutMetadata() pushed stream (streamId=${stream.id}, active=${stream.active})`,\n        );\n    }\n\n    private pushNewLocalFeed(stream: MediaStream, purpose: SDPStreamMetadataPurpose, addToPeerConnection = true): void {\n        const userId = this.client.getUserId()!;\n\n        // Tracks don't always start off enabled, eg. chrome will give a disabled\n        // audio track if you ask for user media audio and already had one that\n        // you'd set to disabled (presumably because it clones them internally).\n        setTracksEnabled(stream.getAudioTracks(), true);\n        setTracksEnabled(stream.getVideoTracks(), true);\n\n        if (this.getFeedByStreamId(stream.id)) {\n            logger.warn(\n                `Call ${this.callId} pushNewLocalFeed() ignoring stream because we already have a feed for it (streamId=${stream.id})`,\n            );\n            return;\n        }\n\n        this.pushLocalFeed(\n            new CallFeed({\n                client: this.client,\n                roomId: this.roomId,\n                audioMuted: false,\n                videoMuted: false,\n                userId,\n                deviceId: this.getOpponentDeviceId(),\n                stream,\n                purpose,\n            }),\n            addToPeerConnection,\n        );\n    }\n\n    /**\n     * Pushes supplied feed to the call\n     * @param callFeed - to push\n     * @param addToPeerConnection - whether to add the tracks to the peer connection\n     */\n    public pushLocalFeed(callFeed: CallFeed, addToPeerConnection = true): void {\n        if (this.feeds.some((feed) => callFeed.stream.id === feed.stream.id)) {\n            logger.info(\n                `Call ${this.callId} pushLocalFeed() ignoring duplicate local stream (streamId=${callFeed.stream.id})`,\n            );\n            return;\n        }\n\n        this.feeds.push(callFeed);\n\n        if (addToPeerConnection) {\n            for (const track of callFeed.stream.getTracks()) {\n                logger.info(\n                    `Call ${this.callId} pushLocalFeed() adding track to peer connection (id=${track.id}, kind=${track.kind}, streamId=${callFeed.stream.id}, streamPurpose=${callFeed.purpose}, enabled=${track.enabled})`,\n                );\n\n                const tKey = getTransceiverKey(callFeed.purpose, track.kind);\n                if (this.transceivers.has(tKey)) {\n                    // we already have a sender, so we re-use it. We try to re-use transceivers as much\n                    // as possible because they can't be removed once added, so otherwise they just\n                    // accumulate which makes the SDP very large very quickly: in fact it only takes\n                    // about 6 video tracks to exceed the maximum size of an Olm-encrypted\n                    // Matrix event.\n                    const transceiver = this.transceivers.get(tKey)!;\n\n                    transceiver.sender.replaceTrack(track);\n                    // set the direction to indicate we're going to start sending again\n                    // (this will trigger the re-negotiation)\n                    transceiver.direction = transceiver.direction === \"inactive\" ? \"sendonly\" : \"sendrecv\";\n                } else {\n                    // create a new one. We need to use addTrack rather addTransceiver for this because firefox\n                    // doesn't yet implement RTCRTPSender.setStreams()\n                    // (https://bugzilla.mozilla.org/show_bug.cgi?id=1510802) so we'd have no way to group the\n                    // two tracks together into a stream.\n                    const newSender = this.peerConn!.addTrack(track, callFeed.stream);\n\n                    // now go & fish for the new transceiver\n                    const newTransceiver = this.peerConn!.getTransceivers().find((t) => t.sender === newSender);\n                    if (newTransceiver) {\n                        this.transceivers.set(tKey, newTransceiver);\n                    } else {\n                        logger.warn(\n                            `Call ${this.callId} pushLocalFeed() didn't find a matching transceiver after adding track!`,\n                        );\n                    }\n                }\n            }\n        }\n\n        logger.info(\n            `Call ${this.callId} pushLocalFeed() pushed stream (id=${callFeed.stream.id}, active=${callFeed.stream.active}, purpose=${callFeed.purpose})`,\n        );\n\n        this.emit(CallEvent.FeedsChanged, this.feeds, this);\n    }\n\n    /**\n     * Removes local call feed from the call and its tracks from the peer\n     * connection\n     * @param callFeed - to remove\n     */\n    public removeLocalFeed(callFeed: CallFeed): void {\n        const audioTransceiverKey = getTransceiverKey(callFeed.purpose, \"audio\");\n        const videoTransceiverKey = getTransceiverKey(callFeed.purpose, \"video\");\n\n        for (const transceiverKey of [audioTransceiverKey, videoTransceiverKey]) {\n            // this is slightly mixing the track and transceiver API but is basically just shorthand.\n            // There is no way to actually remove a transceiver, so this just sets it to inactive\n            // (or recvonly) and replaces the source with nothing.\n            if (this.transceivers.has(transceiverKey)) {\n                const transceiver = this.transceivers.get(transceiverKey)!;\n                if (transceiver.sender) this.peerConn!.removeTrack(transceiver.sender);\n            }\n        }\n\n        if (callFeed.purpose === SDPStreamMetadataPurpose.Screenshare) {\n            this.client.getMediaHandler().stopScreensharingStream(callFeed.stream);\n        }\n\n        this.deleteFeed(callFeed);\n    }\n\n    private deleteAllFeeds(): void {\n        for (const feed of this.feeds) {\n            if (!feed.isLocal() || !this.groupCallId) {\n                feed.dispose();\n            }\n        }\n\n        this.feeds = [];\n        this.emit(CallEvent.FeedsChanged, this.feeds, this);\n    }\n\n    private deleteFeedByStream(stream: MediaStream): void {\n        const feed = this.getFeedByStreamId(stream.id);\n        if (!feed) {\n            logger.warn(\n                `Call ${this.callId} deleteFeedByStream() didn't find the feed to delete (streamId=${stream.id})`,\n            );\n            return;\n        }\n        this.deleteFeed(feed);\n    }\n\n    private deleteFeed(feed: CallFeed): void {\n        feed.dispose();\n        this.feeds.splice(this.feeds.indexOf(feed), 1);\n        this.emit(CallEvent.FeedsChanged, this.feeds, this);\n    }\n\n    // The typescript definitions have this type as 'any' :(\n    public async getCurrentCallStats(): Promise<any[] | undefined> {\n        if (this.callHasEnded()) {\n            return this.callStatsAtEnd;\n        }\n\n        return this.collectCallStats();\n    }\n\n    private async collectCallStats(): Promise<any[] | undefined> {\n        // This happens when the call fails before it starts.\n        // For example when we fail to get capture sources\n        if (!this.peerConn) return;\n\n        const statsReport = await this.peerConn.getStats();\n        const stats: any[] = [];\n        statsReport.forEach((item) => {\n            stats.push(item);\n        });\n\n        return stats;\n    }\n\n    /**\n     * Configure this call from an invite event. Used by MatrixClient.\n     * @param event - The m.call.invite event\n     */\n    public async initWithInvite(event: MatrixEvent): Promise<void> {\n        const invite = event.getContent<MCallInviteNegotiate>();\n        this.direction = CallDirection.Inbound;\n\n        // make sure we have valid turn creds. Unless something's gone wrong, it should\n        // poll and keep the credentials valid so this should be instant.\n        const haveTurnCreds = await this.client.checkTurnServers();\n        if (!haveTurnCreds) {\n            logger.warn(\n                `Call ${this.callId} initWithInvite() failed to get TURN credentials! Proceeding with call anyway...`,\n            );\n        }\n\n        const sdpStreamMetadata = invite[SDPStreamMetadataKey];\n        if (sdpStreamMetadata) {\n            this.updateRemoteSDPStreamMetadata(sdpStreamMetadata);\n        } else {\n            logger.debug(\n                `Call ${this.callId} initWithInvite() did not get any SDPStreamMetadata! Can not send/receive multiple streams`,\n            );\n        }\n\n        this.peerConn = this.createPeerConnection();\n        this.emit(CallEvent.PeerConnectionCreated, this.peerConn, this);\n        // we must set the party ID before await-ing on anything: the call event\n        // handler will start giving us more call events (eg. candidates) so if\n        // we haven't set the party ID, we'll ignore them.\n        this.chooseOpponent(event);\n        await this.initOpponentCrypto();\n        try {\n            await this.peerConn.setRemoteDescription(invite.offer);\n            logger.debug(`Call ${this.callId} initWithInvite() set remote description: ${invite.offer.type}`);\n            await this.addBufferedIceCandidates();\n        } catch (e) {\n            logger.debug(`Call ${this.callId} initWithInvite() failed to set remote description`, e);\n            this.terminate(CallParty.Local, CallErrorCode.SetRemoteDescription, false);\n            return;\n        }\n\n        const remoteStream = this.feeds.find((feed) => !feed.isLocal())?.stream;\n\n        // According to previous comments in this file, firefox at some point did not\n        // add streams until media started arriving on them. Testing latest firefox\n        // (81 at time of writing), this is no longer a problem, so let's do it the correct way.\n        //\n        // For example in case of no media webrtc connections like screen share only call we have to allow webrtc\n        // connections without remote media. In this case we always use a data channel. At the moment we allow as well\n        // only data channel as media in the WebRTC connection with this setup here.\n        if (!this.isOnlyDataChannelAllowed && (!remoteStream || remoteStream.getTracks().length === 0)) {\n            logger.error(\n                `Call ${this.callId} initWithInvite() no remote stream or no tracks after setting remote description!`,\n            );\n            this.terminate(CallParty.Local, CallErrorCode.SetRemoteDescription, false);\n            return;\n        }\n\n        this.state = CallState.Ringing;\n\n        if (event.getLocalAge()) {\n            // Time out the call if it's ringing for too long\n            const ringingTimer = setTimeout(() => {\n                if (this.state == CallState.Ringing) {\n                    logger.debug(`Call ${this.callId} initWithInvite() invite has expired. Hanging up.`);\n                    this.hangupParty = CallParty.Remote; // effectively\n                    this.state = CallState.Ended;\n                    this.stopAllMedia();\n                    if (this.peerConn!.signalingState != \"closed\") {\n                        this.peerConn!.close();\n                    }\n                    this.stats?.removeStatsReportGatherer(this.callId);\n                    this.emit(CallEvent.Hangup, this);\n                }\n            }, invite.lifetime - event.getLocalAge());\n\n            const onState = (state: CallState): void => {\n                if (state !== CallState.Ringing) {\n                    clearTimeout(ringingTimer);\n                    this.off(CallEvent.State, onState);\n                }\n            };\n            this.on(CallEvent.State, onState);\n        }\n    }\n\n    /**\n     * Configure this call from a hangup or reject event. Used by MatrixClient.\n     * @param event - The m.call.hangup event\n     */\n    public initWithHangup(event: MatrixEvent): void {\n        // perverse as it may seem, sometimes we want to instantiate a call with a\n        // hangup message (because when getting the state of the room on load, events\n        // come in reverse order and we want to remember that a call has been hung up)\n        this.state = CallState.Ended;\n    }\n\n    private shouldAnswerWithMediaType(\n        wantedValue: boolean | undefined,\n        valueOfTheOtherSide: boolean,\n        type: \"audio\" | \"video\",\n    ): boolean {\n        if (wantedValue && !valueOfTheOtherSide) {\n            // TODO: Figure out how to do this\n            logger.warn(\n                `Call ${this.callId} shouldAnswerWithMediaType() unable to answer with ${type} because the other side isn't sending it either.`,\n            );\n            return false;\n        } else if (\n            !isNullOrUndefined(wantedValue) &&\n            wantedValue !== valueOfTheOtherSide &&\n            !this.opponentSupportsSDPStreamMetadata()\n        ) {\n            logger.warn(\n                `Call ${this.callId} shouldAnswerWithMediaType() unable to answer with ${type}=${wantedValue} because the other side doesn't support it. Answering with ${type}=${valueOfTheOtherSide}.`,\n            );\n            return valueOfTheOtherSide!;\n        }\n        return wantedValue ?? valueOfTheOtherSide!;\n    }\n\n    /**\n     * Answer a call.\n     */\n    public async answer(audio?: boolean, video?: boolean): Promise<void> {\n        if (this.inviteOrAnswerSent) return;\n        // TODO: Figure out how to do this\n        if (audio === false && video === false) throw new Error(\"You CANNOT answer a call without media\");\n\n        if (!this.localUsermediaStream && !this.waitForLocalAVStream) {\n            const prevState = this.state;\n            const answerWithAudio = this.shouldAnswerWithMediaType(audio, this.hasRemoteUserMediaAudioTrack, \"audio\");\n            const answerWithVideo = this.shouldAnswerWithMediaType(video, this.hasRemoteUserMediaVideoTrack, \"video\");\n\n            this.state = CallState.WaitLocalMedia;\n            this.waitForLocalAVStream = true;\n\n            try {\n                const stream = await this.client.getMediaHandler().getUserMediaStream(answerWithAudio, answerWithVideo);\n                this.waitForLocalAVStream = false;\n                const usermediaFeed = new CallFeed({\n                    client: this.client,\n                    roomId: this.roomId,\n                    userId: this.client.getUserId()!,\n                    deviceId: this.client.getDeviceId() ?? undefined,\n                    stream,\n                    purpose: SDPStreamMetadataPurpose.Usermedia,\n                    audioMuted: false,\n                    videoMuted: false,\n                });\n\n                const feeds = [usermediaFeed];\n\n                if (this.localScreensharingFeed) {\n                    feeds.push(this.localScreensharingFeed);\n                }\n\n                this.answerWithCallFeeds(feeds);\n            } catch (e) {\n                if (answerWithVideo) {\n                    // Try to answer without video\n                    logger.warn(\n                        `Call ${this.callId} answer() failed to getUserMedia(), trying to getUserMedia() without video`,\n                    );\n                    this.state = prevState;\n                    this.waitForLocalAVStream = false;\n                    await this.answer(answerWithAudio, false);\n                } else {\n                    this.getUserMediaFailed(<Error>e);\n                    return;\n                }\n            }\n        } else if (this.waitForLocalAVStream) {\n            this.state = CallState.WaitLocalMedia;\n        }\n    }\n\n    public answerWithCallFeeds(callFeeds: CallFeed[]): void {\n        if (this.inviteOrAnswerSent) return;\n\n        this.queueGotCallFeedsForAnswer(callFeeds);\n    }\n\n    /**\n     * Replace this call with a new call, e.g. for glare resolution. Used by\n     * MatrixClient.\n     * @param newCall - The new call.\n     */\n    public replacedBy(newCall: MatrixCall): void {\n        logger.debug(`Call ${this.callId} replacedBy() running (newCallId=${newCall.callId})`);\n        if (this.state === CallState.WaitLocalMedia) {\n            logger.debug(\n                `Call ${this.callId} replacedBy() telling new call to wait for local media (newCallId=${newCall.callId})`,\n            );\n            newCall.waitForLocalAVStream = true;\n        } else if ([CallState.CreateOffer, CallState.InviteSent].includes(this.state)) {\n            if (newCall.direction === CallDirection.Outbound) {\n                newCall.queueGotCallFeedsForAnswer([]);\n            } else {\n                logger.debug(\n                    `Call ${this.callId} replacedBy() handing local stream to new call(newCallId=${newCall.callId})`,\n                );\n                newCall.queueGotCallFeedsForAnswer(this.getLocalFeeds().map((feed) => feed.clone()));\n            }\n        }\n        this.successor = newCall;\n        this.emit(CallEvent.Replaced, newCall, this);\n        this.hangup(CallErrorCode.Replaced, true);\n    }\n\n    /**\n     * Hangup a call.\n     * @param reason - The reason why the call is being hung up.\n     * @param suppressEvent - True to suppress emitting an event.\n     */\n    public hangup(reason: CallErrorCode, suppressEvent: boolean): void {\n        if (this.callHasEnded()) return;\n\n        logger.debug(`Call ${this.callId} hangup() ending call (reason=${reason})`);\n        this.terminate(CallParty.Local, reason, !suppressEvent);\n        // We don't want to send hangup here if we didn't even get to sending an invite\n        if ([CallState.Fledgling, CallState.WaitLocalMedia].includes(this.state)) return;\n        const content: Omit<MCallHangupReject, \"version\" | \"call_id\" | \"party_id\" | \"conf_id\"> = {};\n        // Don't send UserHangup reason to older clients\n        if ((this.opponentVersion && this.opponentVersion !== 0) || reason !== CallErrorCode.UserHangup) {\n            content[\"reason\"] = reason;\n        }\n        this.sendVoipEvent(EventType.CallHangup, content);\n    }\n\n    /**\n     * Reject a call\n     * This used to be done by calling hangup, but is a separate method and protocol\n     * event as of MSC2746.\n     */\n    public reject(): void {\n        if (this.state !== CallState.Ringing) {\n            throw Error(\"Call must be in 'ringing' state to reject!\");\n        }\n\n        if (this.opponentVersion === 0) {\n            logger.info(\n                `Call ${this.callId} reject() opponent version is less than 1: sending hangup instead of reject (opponentVersion=${this.opponentVersion})`,\n            );\n            this.hangup(CallErrorCode.UserHangup, true);\n            return;\n        }\n\n        logger.debug(\"Rejecting call: \" + this.callId);\n        this.terminate(CallParty.Local, CallErrorCode.UserHangup, true);\n        this.sendVoipEvent(EventType.CallReject, {});\n    }\n\n    /**\n     * Adds an audio and/or video track - upgrades the call\n     * @param audio - should add an audio track\n     * @param video - should add an video track\n     */\n    private async upgradeCall(audio: boolean, video: boolean): Promise<void> {\n        // We don't do call downgrades\n        if (!audio && !video) return;\n        if (!this.opponentSupportsSDPStreamMetadata()) return;\n\n        try {\n            logger.debug(`Call ${this.callId} upgradeCall() upgrading call (audio=${audio}, video=${video})`);\n            const getAudio = audio || this.hasLocalUserMediaAudioTrack;\n            const getVideo = video || this.hasLocalUserMediaVideoTrack;\n\n            // updateLocalUsermediaStream() will take the tracks, use them as\n            // replacement and throw the stream away, so it isn't reusable\n            const stream = await this.client.getMediaHandler().getUserMediaStream(getAudio, getVideo, false);\n            await this.updateLocalUsermediaStream(stream, audio, video);\n        } catch (error) {\n            logger.error(`Call ${this.callId} upgradeCall() failed to upgrade the call`, error);\n            this.emit(\n                CallEvent.Error,\n                new CallError(CallErrorCode.NoUserMedia, \"Failed to get camera access: \", <Error>error),\n                this,\n            );\n        }\n    }\n\n    /**\n     * Returns true if this.remoteSDPStreamMetadata is defined, otherwise returns false\n     * @returns can screenshare\n     */\n    public opponentSupportsSDPStreamMetadata(): boolean {\n        return Boolean(this.remoteSDPStreamMetadata);\n    }\n\n    /**\n     * If there is a screensharing stream returns true, otherwise returns false\n     * @returns is screensharing\n     */\n    public isScreensharing(): boolean {\n        return Boolean(this.localScreensharingStream);\n    }\n\n    /**\n     * Starts/stops screensharing\n     * @param enabled - the desired screensharing state\n     * @param opts - screen sharing options\n     * @returns new screensharing state\n     */\n    public async setScreensharingEnabled(enabled: boolean, opts?: IScreensharingOpts): Promise<boolean> {\n        // Skip if there is nothing to do\n        if (enabled && this.isScreensharing()) {\n            logger.warn(\n                `Call ${this.callId} setScreensharingEnabled() there is already a screensharing stream - there is nothing to do!`,\n            );\n            return true;\n        } else if (!enabled && !this.isScreensharing()) {\n            logger.warn(\n                `Call ${this.callId} setScreensharingEnabled() there already isn't a screensharing stream - there is nothing to do!`,\n            );\n            return false;\n        }\n\n        // Fallback to replaceTrack()\n        if (!this.opponentSupportsSDPStreamMetadata()) {\n            return this.setScreensharingEnabledWithoutMetadataSupport(enabled, opts);\n        }\n\n        logger.debug(`Call ${this.callId} setScreensharingEnabled() running (enabled=${enabled})`);\n        if (enabled) {\n            try {\n                const stream = await this.client.getMediaHandler().getScreensharingStream(opts);\n                if (!stream) return false;\n                this.pushNewLocalFeed(stream, SDPStreamMetadataPurpose.Screenshare);\n                return true;\n            } catch (err) {\n                logger.error(`Call ${this.callId} setScreensharingEnabled() failed to get screen-sharing stream:`, err);\n                return false;\n            }\n        } else {\n            const audioTransceiver = this.transceivers.get(\n                getTransceiverKey(SDPStreamMetadataPurpose.Screenshare, \"audio\"),\n            );\n            const videoTransceiver = this.transceivers.get(\n                getTransceiverKey(SDPStreamMetadataPurpose.Screenshare, \"video\"),\n            );\n\n            for (const transceiver of [audioTransceiver, videoTransceiver]) {\n                // this is slightly mixing the track and transceiver API but is basically just shorthand\n                // for removing the sender.\n                if (transceiver && transceiver.sender) this.peerConn!.removeTrack(transceiver.sender);\n            }\n\n            this.client.getMediaHandler().stopScreensharingStream(this.localScreensharingStream!);\n            this.deleteFeedByStream(this.localScreensharingStream!);\n            return false;\n        }\n    }\n\n    /**\n     * Starts/stops screensharing\n     * Should be used ONLY if the opponent doesn't support SDPStreamMetadata\n     * @param enabled - the desired screensharing state\n     * @param opts - screen sharing options\n     * @returns new screensharing state\n     */\n    private async setScreensharingEnabledWithoutMetadataSupport(\n        enabled: boolean,\n        opts?: IScreensharingOpts,\n    ): Promise<boolean> {\n        logger.debug(\n            `Call ${this.callId} setScreensharingEnabledWithoutMetadataSupport() running (enabled=${enabled})`,\n        );\n        if (enabled) {\n            try {\n                const stream = await this.client.getMediaHandler().getScreensharingStream(opts);\n                if (!stream) return false;\n\n                const track = stream.getTracks().find((track) => track.kind === \"video\");\n\n                const sender = this.transceivers.get(\n                    getTransceiverKey(SDPStreamMetadataPurpose.Usermedia, \"video\"),\n                )?.sender;\n\n                sender?.replaceTrack(track ?? null);\n\n                this.pushNewLocalFeed(stream, SDPStreamMetadataPurpose.Screenshare, false);\n\n                return true;\n            } catch (err) {\n                logger.error(\n                    `Call ${this.callId} setScreensharingEnabledWithoutMetadataSupport() failed to get screen-sharing stream:`,\n                    err,\n                );\n                return false;\n            }\n        } else {\n            const track = this.localUsermediaStream?.getTracks().find((track) => track.kind === \"video\");\n            const sender = this.transceivers.get(\n                getTransceiverKey(SDPStreamMetadataPurpose.Usermedia, \"video\"),\n            )?.sender;\n            sender?.replaceTrack(track ?? null);\n\n            this.client.getMediaHandler().stopScreensharingStream(this.localScreensharingStream!);\n            this.deleteFeedByStream(this.localScreensharingStream!);\n\n            return false;\n        }\n    }\n\n    /**\n     * Replaces/adds the tracks from the passed stream to the localUsermediaStream\n     * @param stream - to use a replacement for the local usermedia stream\n     */\n    public async updateLocalUsermediaStream(\n        stream: MediaStream,\n        forceAudio = false,\n        forceVideo = false,\n    ): Promise<void> {\n        const callFeed = this.localUsermediaFeed!;\n        const audioEnabled = forceAudio || (!callFeed.isAudioMuted() && !this.remoteOnHold);\n        const videoEnabled = forceVideo || (!callFeed.isVideoMuted() && !this.remoteOnHold);\n        logger.log(\n            `Call ${this.callId} updateLocalUsermediaStream() running (streamId=${stream.id}, audio=${audioEnabled}, video=${videoEnabled})`,\n        );\n        setTracksEnabled(stream.getAudioTracks(), audioEnabled);\n        setTracksEnabled(stream.getVideoTracks(), videoEnabled);\n\n        // We want to keep the same stream id, so we replace the tracks rather\n        // than the whole stream.\n\n        // Firstly, we replace the tracks in our localUsermediaStream.\n        for (const track of this.localUsermediaStream!.getTracks()) {\n            this.localUsermediaStream!.removeTrack(track);\n            track.stop();\n        }\n        for (const track of stream.getTracks()) {\n            this.localUsermediaStream!.addTrack(track);\n        }\n\n        // Then replace the old tracks, if possible.\n        for (const track of stream.getTracks()) {\n            const tKey = getTransceiverKey(SDPStreamMetadataPurpose.Usermedia, track.kind);\n\n            const transceiver = this.transceivers.get(tKey);\n            const oldSender = transceiver?.sender;\n            let added = false;\n            if (oldSender) {\n                try {\n                    logger.info(\n                        `Call ${this.callId} updateLocalUsermediaStream() replacing track (id=${track.id}, kind=${track.kind}, streamId=${stream.id}, streamPurpose=${callFeed.purpose})`,\n                    );\n                    await oldSender.replaceTrack(track);\n                    // Set the direction to indicate we're going to be sending.\n                    // This is only necessary in the cases where we're upgrading\n                    // the call to video after downgrading it.\n                    transceiver.direction = transceiver.direction === \"inactive\" ? \"sendonly\" : \"sendrecv\";\n                    added = true;\n                } catch (error) {\n                    logger.warn(\n                        `Call ${this.callId} updateLocalUsermediaStream() replaceTrack failed: adding new transceiver instead`,\n                        error,\n                    );\n                }\n            }\n\n            if (!added) {\n                logger.info(\n                    `Call ${this.callId} updateLocalUsermediaStream() adding track to peer connection (id=${track.id}, kind=${track.kind}, streamId=${stream.id}, streamPurpose=${callFeed.purpose})`,\n                );\n\n                const newSender = this.peerConn!.addTrack(track, this.localUsermediaStream!);\n                const newTransceiver = this.peerConn!.getTransceivers().find((t) => t.sender === newSender);\n                if (newTransceiver) {\n                    this.transceivers.set(tKey, newTransceiver);\n                } else {\n                    logger.warn(\n                        `Call ${this.callId} updateLocalUsermediaStream() couldn't find matching transceiver for newly added track!`,\n                    );\n                }\n            }\n        }\n    }\n\n    /**\n     * Set whether our outbound video should be muted or not.\n     * @param muted - True to mute the outbound video.\n     * @returns the new mute state\n     */\n    public async setLocalVideoMuted(muted: boolean): Promise<boolean> {\n        logger.log(`Call ${this.callId} setLocalVideoMuted() running ${muted}`);\n\n        // if we were still thinking about stopping and removing the video\n        // track: don't, because we want it back.\n        if (!muted && this.stopVideoTrackTimer !== undefined) {\n            clearTimeout(this.stopVideoTrackTimer);\n            this.stopVideoTrackTimer = undefined;\n        }\n\n        if (!(await this.client.getMediaHandler().hasVideoDevice())) {\n            return this.isLocalVideoMuted();\n        }\n\n        if (!this.hasUserMediaVideoSender && !muted) {\n            this.localUsermediaFeed?.setAudioVideoMuted(null, muted);\n            await this.upgradeCall(false, true);\n            return this.isLocalVideoMuted();\n        }\n\n        // we may not have a video track - if not, re-request usermedia\n        if (!muted && this.localUsermediaStream!.getVideoTracks().length === 0) {\n            const stream = await this.client.getMediaHandler().getUserMediaStream(true, true);\n            await this.updateLocalUsermediaStream(stream);\n        }\n\n        this.localUsermediaFeed?.setAudioVideoMuted(null, muted);\n\n        this.updateMuteStatus();\n        await this.sendMetadataUpdate();\n\n        // if we're muting video, set a timeout to stop & remove the video track so we release\n        // the camera. We wait a short time to do this because when we disable a track, WebRTC\n        // will send black video for it. If we just stop and remove it straight away, the video\n        // will just freeze which means that when we unmute video, the other side will briefly\n        // get a static frame of us from before we muted. This way, the still frame is just black.\n        // A very small delay is not always enough so the theory here is that it needs to be long\n        // enough for WebRTC to encode a frame: 120ms should be long enough even if we're only\n        // doing 10fps.\n        if (muted) {\n            this.stopVideoTrackTimer = setTimeout(() => {\n                for (const t of this.localUsermediaStream!.getVideoTracks()) {\n                    t.stop();\n                    this.localUsermediaStream!.removeTrack(t);\n                }\n            }, 120);\n        }\n\n        return this.isLocalVideoMuted();\n    }\n\n    /**\n     * Check if local video is muted.\n     *\n     * If there are multiple video tracks, <i>all</i> of the tracks need to be muted\n     * for this to return true. This means if there are no video tracks, this will\n     * return true.\n     * @returns True if the local preview video is muted, else false\n     * (including if the call is not set up yet).\n     */\n    public isLocalVideoMuted(): boolean {\n        return this.localUsermediaFeed?.isVideoMuted() ?? false;\n    }\n\n    /**\n     * Set whether the microphone should be muted or not.\n     * @param muted - True to mute the mic.\n     * @returns the new mute state\n     */\n    public async setMicrophoneMuted(muted: boolean): Promise<boolean> {\n        logger.log(`Call ${this.callId} setMicrophoneMuted() running ${muted}`);\n        if (!(await this.client.getMediaHandler().hasAudioDevice())) {\n            return this.isMicrophoneMuted();\n        }\n\n        if (!muted && (!this.hasUserMediaAudioSender || !this.hasLocalUserMediaAudioTrack)) {\n            await this.upgradeCall(true, false);\n            return this.isMicrophoneMuted();\n        }\n        this.localUsermediaFeed?.setAudioVideoMuted(muted, null);\n        this.updateMuteStatus();\n        await this.sendMetadataUpdate();\n        return this.isMicrophoneMuted();\n    }\n\n    /**\n     * Check if the microphone is muted.\n     *\n     * If there are multiple audio tracks, <i>all</i> of the tracks need to be muted\n     * for this to return true. This means if there are no audio tracks, this will\n     * return true.\n     * @returns True if the mic is muted, else false (including if the call\n     * is not set up yet).\n     */\n    public isMicrophoneMuted(): boolean {\n        return this.localUsermediaFeed?.isAudioMuted() ?? false;\n    }\n\n    /**\n     * @returns true if we have put the party on the other side of the call on hold\n     * (that is, we are signalling to them that we are not listening)\n     */\n    public isRemoteOnHold(): boolean {\n        return this.remoteOnHold;\n    }\n\n    public setRemoteOnHold(onHold: boolean): void {\n        if (this.isRemoteOnHold() === onHold) return;\n        this.remoteOnHold = onHold;\n\n        for (const transceiver of this.peerConn!.getTransceivers()) {\n            // We don't send hold music or anything so we're not actually\n            // sending anything, but sendrecv is fairly standard for hold and\n            // it makes it a lot easier to figure out who's put who on hold.\n            transceiver.direction = onHold ? \"sendonly\" : \"sendrecv\";\n        }\n        this.updateMuteStatus();\n        this.sendMetadataUpdate();\n\n        this.emit(CallEvent.RemoteHoldUnhold, this.remoteOnHold, this);\n    }\n\n    /**\n     * Indicates whether we are 'on hold' to the remote party (ie. if true,\n     * they cannot hear us).\n     * @returns true if the other party has put us on hold\n     */\n    public isLocalOnHold(): boolean {\n        if (this.state !== CallState.Connected) return false;\n\n        let callOnHold = true;\n\n        // We consider a call to be on hold only if *all* the tracks are on hold\n        // (is this the right thing to do?)\n        for (const transceiver of this.peerConn!.getTransceivers()) {\n            const trackOnHold = [\"inactive\", \"recvonly\"].includes(transceiver.currentDirection!);\n\n            if (!trackOnHold) callOnHold = false;\n        }\n\n        return callOnHold;\n    }\n\n    /**\n     * Sends a DTMF digit to the other party\n     * @param digit - The digit (nb. string - '#' and '*' are dtmf too)\n     */\n    public sendDtmfDigit(digit: string): void {\n        for (const sender of this.peerConn!.getSenders()) {\n            if (sender.track?.kind === \"audio\" && sender.dtmf) {\n                sender.dtmf.insertDTMF(digit);\n                return;\n            }\n        }\n\n        throw new Error(\"Unable to find a track to send DTMF on\");\n    }\n\n    private updateMuteStatus(): void {\n        const micShouldBeMuted = this.isMicrophoneMuted() || this.remoteOnHold;\n        const vidShouldBeMuted = this.isLocalVideoMuted() || this.remoteOnHold;\n\n        logger.log(\n            `Call ${this.callId} updateMuteStatus stream ${\n                this.localUsermediaStream!.id\n            } micShouldBeMuted ${micShouldBeMuted} vidShouldBeMuted ${vidShouldBeMuted}`,\n        );\n\n        setTracksEnabled(this.localUsermediaStream!.getAudioTracks(), !micShouldBeMuted);\n        setTracksEnabled(this.localUsermediaStream!.getVideoTracks(), !vidShouldBeMuted);\n    }\n\n    public async sendMetadataUpdate(): Promise<void> {\n        await this.sendVoipEvent(EventType.CallSDPStreamMetadataChangedPrefix, {\n            [SDPStreamMetadataKey]: this.getLocalSDPStreamMetadata(),\n        });\n    }\n\n    private gotCallFeedsForInvite(callFeeds: CallFeed[], requestScreenshareFeed = false): void {\n        if (this.successor) {\n            this.successor.queueGotCallFeedsForAnswer(callFeeds);\n            return;\n        }\n        if (this.callHasEnded()) {\n            this.stopAllMedia();\n            return;\n        }\n\n        for (const feed of callFeeds) {\n            this.pushLocalFeed(feed);\n        }\n\n        if (requestScreenshareFeed) {\n            this.peerConn!.addTransceiver(\"video\", {\n                direction: \"recvonly\",\n            });\n        }\n\n        this.state = CallState.CreateOffer;\n\n        logger.debug(`Call ${this.callId} gotUserMediaForInvite() run`);\n        // Now we wait for the negotiationneeded event\n    }\n\n    private async sendAnswer(): Promise<void> {\n        const answerContent = {\n            answer: {\n                sdp: this.peerConn!.localDescription!.sdp,\n                // type is now deprecated as of Matrix VoIP v1, but\n                // required to still be sent for backwards compat\n                type: this.peerConn!.localDescription!.type,\n            },\n            [SDPStreamMetadataKey]: this.getLocalSDPStreamMetadata(true),\n        } as MCallAnswer;\n\n        answerContent.capabilities = {\n            \"m.call.transferee\": this.client.supportsCallTransfer,\n            \"m.call.dtmf\": false,\n        };\n\n        // We have just taken the local description from the peerConn which will\n        // contain all the local candidates added so far, so we can discard any candidates\n        // we had queued up because they'll be in the answer.\n        const discardCount = this.discardDuplicateCandidates();\n        logger.info(\n            `Call ${this.callId} sendAnswer() discarding ${discardCount} candidates that will be sent in answer`,\n        );\n\n        try {\n            await this.sendVoipEvent(EventType.CallAnswer, answerContent);\n            // If this isn't the first time we've tried to send the answer,\n            // we may have candidates queued up, so send them now.\n            this.inviteOrAnswerSent = true;\n        } catch (error) {\n            // We've failed to answer: back to the ringing state\n            this.state = CallState.Ringing;\n            if (error instanceof MatrixError && error.event) this.client.cancelPendingEvent(error.event);\n\n            let code = CallErrorCode.SendAnswer;\n            let message = \"Failed to send answer\";\n            if ((<Error>error).name == \"UnknownDeviceError\") {\n                code = CallErrorCode.UnknownDevices;\n                message = \"Unknown devices present in the room\";\n            }\n            this.emit(CallEvent.Error, new CallError(code, message, <Error>error), this);\n            throw error;\n        }\n\n        // error handler re-throws so this won't happen on error, but\n        // we don't want the same error handling on the candidate queue\n        this.sendCandidateQueue();\n    }\n\n    private queueGotCallFeedsForAnswer(callFeeds: CallFeed[]): void {\n        // Ensure only one negotiate/answer event is being processed at a time.\n        if (this.responsePromiseChain) {\n            this.responsePromiseChain = this.responsePromiseChain.then(() => this.gotCallFeedsForAnswer(callFeeds));\n        } else {\n            this.responsePromiseChain = this.gotCallFeedsForAnswer(callFeeds);\n        }\n    }\n\n    // Enables DTX (discontinuous transmission) on the given session to reduce\n    // bandwidth when transmitting silence\n    private mungeSdp(description: RTCSessionDescriptionInit, mods: CodecParamsMod[]): void {\n        // The only way to enable DTX at this time is through SDP munging\n        const sdp = parseSdp(description.sdp!);\n\n        sdp.media.forEach((media) => {\n            const payloadTypeToCodecMap = new Map<number, string>();\n            const codecToPayloadTypeMap = new Map<string, number>();\n            for (const rtp of media.rtp) {\n                payloadTypeToCodecMap.set(rtp.payload, rtp.codec);\n                codecToPayloadTypeMap.set(rtp.codec, rtp.payload);\n            }\n\n            for (const mod of mods) {\n                if (mod.mediaType !== media.type) continue;\n\n                if (!codecToPayloadTypeMap.has(mod.codec)) {\n                    logger.info(\n                        `Call ${this.callId} mungeSdp() ignoring SDP modifications for ${mod.codec} as it's not present.`,\n                    );\n                    continue;\n                }\n\n                const extraConfig: string[] = [];\n                if (mod.enableDtx !== undefined) {\n                    extraConfig.push(`usedtx=${mod.enableDtx ? \"1\" : \"0\"}`);\n                }\n                if (mod.maxAverageBitrate !== undefined) {\n                    extraConfig.push(`maxaveragebitrate=${mod.maxAverageBitrate}`);\n                }\n\n                let found = false;\n                for (const fmtp of media.fmtp) {\n                    if (payloadTypeToCodecMap.get(fmtp.payload) === mod.codec) {\n                        found = true;\n                        fmtp.config += \";\" + extraConfig.join(\";\");\n                    }\n                }\n                if (!found) {\n                    media.fmtp.push({\n                        payload: codecToPayloadTypeMap.get(mod.codec)!,\n                        config: extraConfig.join(\";\"),\n                    });\n                }\n            }\n        });\n        description.sdp = writeSdp(sdp);\n    }\n\n    private async createOffer(): Promise<RTCSessionDescriptionInit> {\n        const offer = await this.peerConn!.createOffer();\n        this.mungeSdp(offer, getCodecParamMods(this.isPtt));\n        return offer;\n    }\n\n    private async createAnswer(): Promise<RTCSessionDescriptionInit> {\n        const answer = await this.peerConn!.createAnswer();\n        this.mungeSdp(answer, getCodecParamMods(this.isPtt));\n        return answer;\n    }\n\n    private async gotCallFeedsForAnswer(callFeeds: CallFeed[]): Promise<void> {\n        if (this.callHasEnded()) return;\n\n        this.waitForLocalAVStream = false;\n\n        for (const feed of callFeeds) {\n            this.pushLocalFeed(feed);\n        }\n\n        this.state = CallState.CreateAnswer;\n\n        let answer: RTCSessionDescriptionInit;\n        try {\n            this.getRidOfRTXCodecs();\n            answer = await this.createAnswer();\n        } catch (err) {\n            logger.debug(`Call ${this.callId} gotCallFeedsForAnswer() failed to create answer: `, err);\n            this.terminate(CallParty.Local, CallErrorCode.CreateAnswer, true);\n            return;\n        }\n\n        try {\n            await this.peerConn!.setLocalDescription(answer);\n\n            // make sure we're still going\n            if (this.callHasEnded()) return;\n\n            this.state = CallState.Connecting;\n\n            // Allow a short time for initial candidates to be gathered\n            await new Promise((resolve) => {\n                setTimeout(resolve, 200);\n            });\n\n            // make sure the call hasn't ended before we continue\n            if (this.callHasEnded()) return;\n\n            this.sendAnswer();\n        } catch (err) {\n            logger.debug(`Call ${this.callId} gotCallFeedsForAnswer() error setting local description!`, err);\n            this.terminate(CallParty.Local, CallErrorCode.SetLocalDescription, true);\n            return;\n        }\n    }\n\n    /**\n     * Internal\n     */\n    private gotLocalIceCandidate = (event: RTCPeerConnectionIceEvent): void => {\n        if (event.candidate) {\n            if (this.candidatesEnded) {\n                logger.warn(`Call ${this.callId} gotLocalIceCandidate() got candidate after candidates have ended!`);\n            }\n\n            logger.debug(`Call ${this.callId} got local ICE ${event.candidate.sdpMid} ${event.candidate.candidate}`);\n\n            if (this.callHasEnded()) return;\n\n            // As with the offer, note we need to make a copy of this object, not\n            // pass the original: that broke in Chrome ~m43.\n            if (event.candidate.candidate === \"\") {\n                this.queueCandidate(null);\n            } else {\n                this.queueCandidate(event.candidate);\n            }\n        }\n    };\n\n    private onIceGatheringStateChange = (event: Event): void => {\n        logger.debug(\n            `Call ${this.callId} onIceGatheringStateChange() ice gathering state changed to ${\n                this.peerConn!.iceGatheringState\n            }`,\n        );\n        if (this.peerConn?.iceGatheringState === \"complete\") {\n            this.queueCandidate(null); // We should leave it to WebRTC to announce the end\n            logger.debug(\n                `Call ${this.callId} onIceGatheringStateChange() ice gathering state complete, set candidates have ended`,\n            );\n        }\n    };\n\n    public async onRemoteIceCandidatesReceived(ev: MatrixEvent): Promise<void> {\n        if (this.callHasEnded()) {\n            //debuglog(\"Ignoring remote ICE candidate because call has ended\");\n            return;\n        }\n\n        const content = ev.getContent<MCallCandidates>();\n        const candidates = content.candidates;\n        if (!candidates) {\n            logger.info(\n                `Call ${this.callId} onRemoteIceCandidatesReceived() ignoring candidates event with no candidates!`,\n            );\n            return;\n        }\n\n        const fromPartyId = content.version === 0 ? null : content.party_id || null;\n\n        if (this.opponentPartyId === undefined) {\n            // we haven't picked an opponent yet so save the candidates\n            if (fromPartyId) {\n                logger.info(\n                    `Call ${this.callId} onRemoteIceCandidatesReceived() buffering ${candidates.length} candidates until we pick an opponent`,\n                );\n                const bufferedCandidates = this.remoteCandidateBuffer.get(fromPartyId) || [];\n                bufferedCandidates.push(...candidates);\n                this.remoteCandidateBuffer.set(fromPartyId, bufferedCandidates);\n            }\n            return;\n        }\n\n        if (!this.partyIdMatches(content)) {\n            logger.info(\n                `Call ${this.callId} onRemoteIceCandidatesReceived() ignoring candidates from party ID ${content.party_id}: we have chosen party ID ${this.opponentPartyId}`,\n            );\n\n            return;\n        }\n\n        await this.addIceCandidates(candidates);\n    }\n\n    /**\n     * Used by MatrixClient.\n     */\n    public async onAnswerReceived(event: MatrixEvent): Promise<void> {\n        const content = event.getContent<MCallAnswer>();\n        logger.debug(`Call ${this.callId} onAnswerReceived() running (hangupParty=${content.party_id})`);\n\n        if (this.callHasEnded()) {\n            logger.debug(`Call ${this.callId} onAnswerReceived() ignoring answer because call has ended`);\n            return;\n        }\n\n        if (this.opponentPartyId !== undefined) {\n            logger.info(\n                `Call ${this.callId} onAnswerReceived() ignoring answer from party ID ${content.party_id}: we already have an answer/reject from ${this.opponentPartyId}`,\n            );\n            return;\n        }\n\n        this.chooseOpponent(event);\n        await this.addBufferedIceCandidates();\n\n        this.state = CallState.Connecting;\n\n        const sdpStreamMetadata = content[SDPStreamMetadataKey];\n        if (sdpStreamMetadata) {\n            this.updateRemoteSDPStreamMetadata(sdpStreamMetadata);\n        } else {\n            logger.warn(\n                `Call ${this.callId} onAnswerReceived() did not get any SDPStreamMetadata! Can not send/receive multiple streams`,\n            );\n        }\n\n        try {\n            this.isSettingRemoteAnswerPending = true;\n            await this.peerConn!.setRemoteDescription(content.answer);\n            this.isSettingRemoteAnswerPending = false;\n            logger.debug(`Call ${this.callId} onAnswerReceived() set remote description: ${content.answer.type}`);\n        } catch (e) {\n            this.isSettingRemoteAnswerPending = false;\n            logger.debug(`Call ${this.callId} onAnswerReceived() failed to set remote description`, e);\n            this.terminate(CallParty.Local, CallErrorCode.SetRemoteDescription, false);\n            return;\n        }\n\n        // If the answer we selected has a party_id, send a select_answer event\n        // We do this after setting the remote description since otherwise we'd block\n        // call setup on it\n        if (this.opponentPartyId !== null) {\n            try {\n                await this.sendVoipEvent(EventType.CallSelectAnswer, {\n                    selected_party_id: this.opponentPartyId!,\n                });\n            } catch (err) {\n                // This isn't fatal, and will just mean that if another party has raced to answer\n                // the call, they won't know they got rejected, so we carry on & don't retry.\n                logger.warn(`Call ${this.callId} onAnswerReceived() failed to send select_answer event`, err);\n            }\n        }\n    }\n\n    public async onSelectAnswerReceived(event: MatrixEvent): Promise<void> {\n        if (this.direction !== CallDirection.Inbound) {\n            logger.warn(\n                `Call ${this.callId} onSelectAnswerReceived() got select_answer for an outbound call: ignoring`,\n            );\n            return;\n        }\n\n        const selectedPartyId = event.getContent<MCallSelectAnswer>().selected_party_id;\n\n        if (selectedPartyId === undefined || selectedPartyId === null) {\n            logger.warn(\n                `Call ${this.callId} onSelectAnswerReceived() got nonsensical select_answer with null/undefined selected_party_id: ignoring`,\n            );\n            return;\n        }\n\n        if (selectedPartyId !== this.ourPartyId) {\n            logger.info(\n                `Call ${this.callId} onSelectAnswerReceived() got select_answer for party ID ${selectedPartyId}: we are party ID ${this.ourPartyId}.`,\n            );\n            // The other party has picked somebody else's answer\n            await this.terminate(CallParty.Remote, CallErrorCode.AnsweredElsewhere, true);\n        }\n    }\n\n    public async onNegotiateReceived(event: MatrixEvent): Promise<void> {\n        const content = event.getContent<MCallInviteNegotiate>();\n        const description = content.description;\n        if (!description || !description.sdp || !description.type) {\n            logger.info(`Call ${this.callId} onNegotiateReceived() ignoring invalid m.call.negotiate event`);\n            return;\n        }\n        // Politeness always follows the direction of the call: in a glare situation,\n        // we pick either the inbound or outbound call, so one side will always be\n        // inbound and one outbound\n        const polite = this.direction === CallDirection.Inbound;\n\n        // Here we follow the perfect negotiation logic from\n        // https://w3c.github.io/webrtc-pc/#perfect-negotiation-example\n        const readyForOffer =\n            !this.makingOffer && (this.peerConn!.signalingState === \"stable\" || this.isSettingRemoteAnswerPending);\n\n        const offerCollision = description.type === \"offer\" && !readyForOffer;\n\n        this.ignoreOffer = !polite && offerCollision;\n        if (this.ignoreOffer) {\n            logger.info(\n                `Call ${this.callId} onNegotiateReceived() ignoring colliding negotiate event because we're impolite`,\n            );\n            return;\n        }\n\n        const prevLocalOnHold = this.isLocalOnHold();\n\n        const sdpStreamMetadata = content[SDPStreamMetadataKey];\n        if (sdpStreamMetadata) {\n            this.updateRemoteSDPStreamMetadata(sdpStreamMetadata);\n        } else {\n            logger.warn(\n                `Call ${this.callId} onNegotiateReceived() received negotiation event without SDPStreamMetadata!`,\n            );\n        }\n\n        try {\n            this.isSettingRemoteAnswerPending = description.type == \"answer\";\n            await this.peerConn!.setRemoteDescription(description); // SRD rolls back as needed\n            this.isSettingRemoteAnswerPending = false;\n\n            logger.debug(`Call ${this.callId} onNegotiateReceived() set remote description: ${description.type}`);\n\n            if (description.type === \"offer\") {\n                let answer: RTCSessionDescriptionInit;\n                try {\n                    this.getRidOfRTXCodecs();\n                    answer = await this.createAnswer();\n                } catch (err) {\n                    logger.debug(`Call ${this.callId} onNegotiateReceived() failed to create answer: `, err);\n                    this.terminate(CallParty.Local, CallErrorCode.CreateAnswer, true);\n                    return;\n                }\n\n                await this.peerConn!.setLocalDescription(answer);\n                logger.debug(`Call ${this.callId} onNegotiateReceived() create an answer`);\n\n                this.sendVoipEvent(EventType.CallNegotiate, {\n                    lifetime: CALL_TIMEOUT_MS,\n                    description: this.peerConn!.localDescription?.toJSON() as RTCSessionDescription,\n                    [SDPStreamMetadataKey]: this.getLocalSDPStreamMetadata(true),\n                });\n            }\n        } catch (err) {\n            this.isSettingRemoteAnswerPending = false;\n            logger.warn(`Call ${this.callId} onNegotiateReceived() failed to complete negotiation`, err);\n        }\n\n        const newLocalOnHold = this.isLocalOnHold();\n        if (prevLocalOnHold !== newLocalOnHold) {\n            this.emit(CallEvent.LocalHoldUnhold, newLocalOnHold, this);\n            // also this one for backwards compat\n            this.emit(CallEvent.HoldUnhold, newLocalOnHold);\n        }\n    }\n\n    private updateRemoteSDPStreamMetadata(metadata: SDPStreamMetadata): void {\n        this.remoteSDPStreamMetadata = recursivelyAssign(this.remoteSDPStreamMetadata || {}, metadata, true);\n        for (const feed of this.getRemoteFeeds()) {\n            const streamId = feed.stream.id;\n            const metadata = this.remoteSDPStreamMetadata![streamId];\n\n            feed.setAudioVideoMuted(metadata?.audio_muted, metadata?.video_muted);\n            feed.purpose = this.remoteSDPStreamMetadata![streamId]?.purpose;\n        }\n    }\n\n    public onSDPStreamMetadataChangedReceived(event: MatrixEvent): void {\n        const content = event.getContent<MCallSDPStreamMetadataChanged>();\n        const metadata = content[SDPStreamMetadataKey];\n        this.updateRemoteSDPStreamMetadata(metadata);\n    }\n\n    public async onAssertedIdentityReceived(event: MatrixEvent): Promise<void> {\n        const content = event.getContent<MCAllAssertedIdentity>();\n        if (!content.asserted_identity) return;\n\n        this.remoteAssertedIdentity = {\n            id: content.asserted_identity.id,\n            displayName: content.asserted_identity.display_name,\n        };\n        this.emit(CallEvent.AssertedIdentityChanged, this);\n    }\n\n    public callHasEnded(): boolean {\n        // This exists as workaround to typescript trying to be clever and erroring\n        // when putting if (this.state === CallState.Ended) return; twice in the same\n        // function, even though that function is async.\n        return this.state === CallState.Ended;\n    }\n\n    private queueGotLocalOffer(): void {\n        // Ensure only one negotiate/answer event is being processed at a time.\n        if (this.responsePromiseChain) {\n            this.responsePromiseChain = this.responsePromiseChain.then(() => this.wrappedGotLocalOffer());\n        } else {\n            this.responsePromiseChain = this.wrappedGotLocalOffer();\n        }\n    }\n\n    private async wrappedGotLocalOffer(): Promise<void> {\n        this.makingOffer = true;\n        try {\n            // XXX: in what situations do we believe gotLocalOffer actually throws? It appears\n            // to handle most of its exceptions itself and terminate the call. I'm not entirely\n            // sure it would ever throw, so I can't add a test for these lines.\n            // Also the tense is different between \"gotLocalOffer\" and \"getLocalOfferFailed\" so\n            // it's not entirely clear whether getLocalOfferFailed is just misnamed or whether\n            // they've been cross-polinated somehow at some point.\n            await this.gotLocalOffer();\n        } catch (e) {\n            this.getLocalOfferFailed(e as Error);\n            return;\n        } finally {\n            this.makingOffer = false;\n        }\n    }\n\n    private async gotLocalOffer(): Promise<void> {\n        logger.debug(`Call ${this.callId} gotLocalOffer() running`);\n\n        if (this.callHasEnded()) {\n            logger.debug(\n                `Call ${this.callId} gotLocalOffer() ignoring newly created offer because the call has ended\"`,\n            );\n            return;\n        }\n\n        let offer: RTCSessionDescriptionInit;\n        try {\n            this.getRidOfRTXCodecs();\n            offer = await this.createOffer();\n        } catch (err) {\n            logger.debug(`Call ${this.callId} gotLocalOffer() failed to create offer: `, err);\n            this.terminate(CallParty.Local, CallErrorCode.CreateOffer, true);\n            return;\n        }\n\n        try {\n            await this.peerConn!.setLocalDescription(offer);\n        } catch (err) {\n            logger.debug(`Call ${this.callId} gotLocalOffer() error setting local description!`, err);\n            this.terminate(CallParty.Local, CallErrorCode.SetLocalDescription, true);\n            return;\n        }\n\n        if (this.peerConn!.iceGatheringState === \"gathering\") {\n            // Allow a short time for initial candidates to be gathered\n            await new Promise((resolve) => {\n                setTimeout(resolve, 200);\n            });\n        }\n\n        if (this.callHasEnded()) return;\n\n        const eventType = this.state === CallState.CreateOffer ? EventType.CallInvite : EventType.CallNegotiate;\n\n        const content = {\n            lifetime: CALL_TIMEOUT_MS,\n        } as MCallInviteNegotiate;\n\n        if (eventType === EventType.CallInvite && this.invitee) {\n            content.invitee = this.invitee;\n        }\n\n        // clunky because TypeScript can't follow the types through if we use an expression as the key\n        if (this.state === CallState.CreateOffer) {\n            content.offer = this.peerConn!.localDescription?.toJSON() as RTCSessionDescription;\n        } else {\n            content.description = this.peerConn!.localDescription?.toJSON() as RTCSessionDescription;\n        }\n\n        content.capabilities = {\n            \"m.call.transferee\": this.client.supportsCallTransfer,\n            \"m.call.dtmf\": false,\n        };\n\n        content[SDPStreamMetadataKey] = this.getLocalSDPStreamMetadata(true);\n\n        // Get rid of any candidates waiting to be sent: they'll be included in the local\n        // description we just got and will send in the offer.\n        const discardCount = this.discardDuplicateCandidates();\n        logger.info(\n            `Call ${this.callId} gotLocalOffer() discarding ${discardCount} candidates that will be sent in offer`,\n        );\n\n        try {\n            await this.sendVoipEvent(eventType, content);\n        } catch (error) {\n            logger.error(`Call ${this.callId} gotLocalOffer() failed to send invite`, error);\n            if (error instanceof MatrixError && error.event) this.client.cancelPendingEvent(error.event);\n\n            let code = CallErrorCode.SignallingFailed;\n            let message = \"Signalling failed\";\n            if (this.state === CallState.CreateOffer) {\n                code = CallErrorCode.SendInvite;\n                message = \"Failed to send invite\";\n            }\n            if ((<Error>error).name == \"UnknownDeviceError\") {\n                code = CallErrorCode.UnknownDevices;\n                message = \"Unknown devices present in the room\";\n            }\n\n            this.emit(CallEvent.Error, new CallError(code, message, <Error>error), this);\n            this.terminate(CallParty.Local, code, false);\n\n            // no need to carry on & send the candidate queue, but we also\n            // don't want to rethrow the error\n            return;\n        }\n\n        this.sendCandidateQueue();\n        if (this.state === CallState.CreateOffer) {\n            this.inviteOrAnswerSent = true;\n            this.state = CallState.InviteSent;\n            this.inviteTimeout = setTimeout(() => {\n                this.inviteTimeout = undefined;\n                if (this.state === CallState.InviteSent) {\n                    this.hangup(CallErrorCode.InviteTimeout, false);\n                }\n            }, CALL_TIMEOUT_MS);\n        }\n    }\n\n    private getLocalOfferFailed = (err: Error): void => {\n        logger.error(`Call ${this.callId} getLocalOfferFailed() running`, err);\n\n        this.emit(\n            CallEvent.Error,\n            new CallError(CallErrorCode.LocalOfferFailed, \"Failed to get local offer!\", err),\n            this,\n        );\n        this.terminate(CallParty.Local, CallErrorCode.LocalOfferFailed, false);\n    };\n\n    private getUserMediaFailed = (err: Error): void => {\n        if (this.successor) {\n            this.successor.getUserMediaFailed(err);\n            return;\n        }\n\n        logger.warn(`Call ${this.callId} getUserMediaFailed() failed to get user media - ending call`, err);\n\n        this.emit(\n            CallEvent.Error,\n            new CallError(\n                CallErrorCode.NoUserMedia,\n                \"Couldn't start capturing media! Is your microphone set up and does this app have permission?\",\n                err,\n            ),\n            this,\n        );\n        this.terminate(CallParty.Local, CallErrorCode.NoUserMedia, false);\n    };\n\n    private placeCallFailed = (err: Error): void => {\n        if (this.successor) {\n            this.successor.placeCallFailed(err);\n            return;\n        }\n\n        logger.warn(`Call ${this.callId} placeCallWithCallFeeds() failed - ending call`, err);\n\n        this.emit(\n            CallEvent.Error,\n            new CallError(CallErrorCode.IceFailed, \"Couldn't start call! Invalid ICE server configuration.\", err),\n            this,\n        );\n        this.terminate(CallParty.Local, CallErrorCode.IceFailed, false);\n    };\n\n    private onIceConnectionStateChanged = (): void => {\n        if (this.callHasEnded()) {\n            return; // because ICE can still complete as we're ending the call\n        }\n        logger.debug(\n            `Call ${this.callId} onIceConnectionStateChanged() running (state=${this.peerConn?.iceConnectionState}, conn=${this.peerConn?.connectionState})`,\n        );\n\n        // ideally we'd consider the call to be connected when we get media but\n        // chrome doesn't implement any of the 'onstarted' events yet\n        if ([\"connected\", \"completed\"].includes(this.peerConn?.iceConnectionState ?? \"\")) {\n            clearTimeout(this.iceDisconnectedTimeout);\n            this.iceDisconnectedTimeout = undefined;\n            if (this.iceReconnectionTimeOut) {\n                clearTimeout(this.iceReconnectionTimeOut);\n            }\n            this.state = CallState.Connected;\n\n            if (!this.callLengthInterval && !this.callStartTime) {\n                this.callStartTime = Date.now();\n\n                this.callLengthInterval = setInterval(() => {\n                    this.emit(CallEvent.LengthChanged, Math.round((Date.now() - this.callStartTime!) / 1000), this);\n                }, CALL_LENGTH_INTERVAL);\n            }\n        } else if (this.peerConn?.iceConnectionState == \"failed\") {\n            this.candidatesEnded = false;\n            // Firefox for Android does not yet have support for restartIce()\n            // (the types say it's always defined though, so we have to cast\n            // to prevent typescript from warning).\n            if (this.peerConn?.restartIce as (() => void) | null) {\n                this.candidatesEnded = false;\n                logger.debug(\n                    `Call ${this.callId} onIceConnectionStateChanged() ice restart (state=${this.peerConn?.iceConnectionState})`,\n                );\n                this.peerConn!.restartIce();\n            } else {\n                logger.info(\n                    `Call ${this.callId} onIceConnectionStateChanged() hanging up call (ICE failed and no ICE restart method)`,\n                );\n                this.hangup(CallErrorCode.IceFailed, false);\n            }\n        } else if (this.peerConn?.iceConnectionState == \"disconnected\") {\n            this.candidatesEnded = false;\n            this.iceReconnectionTimeOut = setTimeout((): void => {\n                logger.info(\n                    `Call ${this.callId} onIceConnectionStateChanged() ICE restarting because of ICE disconnected, (state=${this.peerConn?.iceConnectionState}, conn=${this.peerConn?.connectionState})`,\n                );\n                if (this.peerConn?.restartIce as (() => void) | null) {\n                    this.candidatesEnded = false;\n                    this.peerConn!.restartIce();\n                }\n                this.iceReconnectionTimeOut = undefined;\n            }, ICE_RECONNECTING_TIMEOUT);\n\n            this.iceDisconnectedTimeout = setTimeout((): void => {\n                logger.info(\n                    `Call ${this.callId} onIceConnectionStateChanged() hanging up call (ICE disconnected for too long)`,\n                );\n                this.hangup(CallErrorCode.IceFailed, false);\n            }, ICE_DISCONNECTED_TIMEOUT);\n            this.state = CallState.Connecting;\n        }\n\n        // In PTT mode, override feed status to muted when we lose connection to\n        // the peer, since we don't want to block the line if they're not saying anything.\n        // Experimenting in Chrome, this happens after 5 or 6 seconds, which is probably\n        // fast enough.\n        if (this.isPtt && [\"failed\", \"disconnected\"].includes(this.peerConn!.iceConnectionState)) {\n            for (const feed of this.getRemoteFeeds()) {\n                feed.setAudioVideoMuted(true, true);\n            }\n        }\n    };\n\n    private onSignallingStateChanged = (): void => {\n        logger.debug(`Call ${this.callId} onSignallingStateChanged() running (state=${this.peerConn?.signalingState})`);\n    };\n\n    private onTrack = (ev: RTCTrackEvent): void => {\n        if (ev.streams.length === 0) {\n            logger.warn(\n                `Call ${this.callId} onTrack() called with streamless track streamless (kind=${ev.track.kind})`,\n            );\n            return;\n        }\n\n        const stream = ev.streams[0];\n        this.pushRemoteFeed(stream);\n\n        if (!this.removeTrackListeners.has(stream)) {\n            const onRemoveTrack = (): void => {\n                if (stream.getTracks().length === 0) {\n                    logger.info(`Call ${this.callId} onTrack() removing track (streamId=${stream.id})`);\n                    this.deleteFeedByStream(stream);\n                    stream.removeEventListener(\"removetrack\", onRemoveTrack);\n                    this.removeTrackListeners.delete(stream);\n                }\n            };\n            stream.addEventListener(\"removetrack\", onRemoveTrack);\n            this.removeTrackListeners.set(stream, onRemoveTrack);\n        }\n    };\n\n    private onDataChannel = (ev: RTCDataChannelEvent): void => {\n        this.emit(CallEvent.DataChannel, ev.channel, this);\n    };\n\n    /**\n     * This method removes all video/rtx codecs from screensharing video\n     * transceivers. This is necessary since they can cause problems. Without\n     * this the following steps should produce an error:\n     *   Chromium calls Firefox\n     *   Firefox answers\n     *   Firefox starts screen-sharing\n     *   Chromium starts screen-sharing\n     *   Call crashes for Chromium with:\n     *       [96685:23:0518/162603.933321:ERROR:webrtc_video_engine.cc(3296)] RTX codec (PT=97) mapped to PT=96 which is not in the codec list.\n     *       [96685:23:0518/162603.933377:ERROR:webrtc_video_engine.cc(1171)] GetChangedRecvParameters called without any video codecs.\n     *       [96685:23:0518/162603.933430:ERROR:sdp_offer_answer.cc(4302)] Failed to set local video description recv parameters for m-section with mid='2'. (INVALID_PARAMETER)\n     */\n    private getRidOfRTXCodecs(): void {\n        // RTCRtpReceiver.getCapabilities and RTCRtpSender.getCapabilities don't seem to be supported on FF before v113\n        if (!RTCRtpReceiver.getCapabilities || !RTCRtpSender.getCapabilities) return;\n\n        const screenshareVideoTransceiver = this.transceivers.get(\n            getTransceiverKey(SDPStreamMetadataPurpose.Screenshare, \"video\"),\n        );\n\n        // setCodecPreferences isn't supported on FF (as of v113)\n        if (!screenshareVideoTransceiver || !screenshareVideoTransceiver.setCodecPreferences) return;\n\n        const recvCodecs = RTCRtpReceiver.getCapabilities(\"video\")!.codecs;\n        const sendCodecs = RTCRtpSender.getCapabilities(\"video\")!.codecs;\n        const codecs = [];\n\n        for (const codec of [...recvCodecs, ...sendCodecs]) {\n            if (codec.mimeType !== \"video/rtx\") {\n                codecs.push(codec);\n                try {\n                    screenshareVideoTransceiver.setCodecPreferences(codecs);\n                } catch (e) {\n                    // Specifically, Chrome around version 125 and Electron 30 (which is Chromium 124) return an H.264 codec in\n                    // the sender's capabilities but throw when you try to set it. Hence... this mess.\n                    // Specifically, that codec is:\n                    // {\n                    //   clockRate: 90000,\n                    //   mimeType: \"video/H264\",\n                    //   sdpFmtpLine: \"level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=640034\",\n                    // }\n                    logger.info(\n                        \"Working around buggy WebRTC impl: claimed to support codec but threw when setting codec preferences\",\n                        codec,\n                        e,\n                    );\n                    codecs.pop();\n                }\n            }\n        }\n    }\n\n    private onNegotiationNeeded = async (): Promise<void> => {\n        logger.info(`Call ${this.callId} onNegotiationNeeded() negotiation is needed!`);\n\n        if (this.state !== CallState.CreateOffer && this.opponentVersion === 0) {\n            logger.info(\n                `Call ${this.callId} onNegotiationNeeded() opponent does not support renegotiation: ignoring negotiationneeded event`,\n            );\n            return;\n        }\n\n        this.queueGotLocalOffer();\n    };\n\n    public onHangupReceived = (msg: MCallHangupReject): void => {\n        logger.debug(`Call ${this.callId} onHangupReceived() running`);\n\n        // party ID must match (our chosen partner hanging up the call) or be undefined (we haven't chosen\n        // a partner yet but we're treating the hangup as a reject as per VoIP v0)\n        if (this.partyIdMatches(msg) || this.state === CallState.Ringing) {\n            // default reason is user_hangup\n            this.terminate(CallParty.Remote, msg.reason || CallErrorCode.UserHangup, true);\n        } else {\n            logger.info(\n                `Call ${this.callId} onHangupReceived() ignoring message from party ID ${msg.party_id}: our partner is ${this.opponentPartyId}`,\n            );\n        }\n    };\n\n    public onRejectReceived = (msg: MCallHangupReject): void => {\n        logger.debug(`Call ${this.callId} onRejectReceived() running`);\n\n        // No need to check party_id for reject because if we'd received either\n        // an answer or reject, we wouldn't be in state InviteSent\n\n        const shouldTerminate =\n            // reject events also end the call if it's ringing: it's another of\n            // our devices rejecting the call.\n            [CallState.InviteSent, CallState.Ringing].includes(this.state) ||\n            // also if we're in the init state and it's an inbound call, since\n            // this means we just haven't entered the ringing state yet\n            (this.state === CallState.Fledgling && this.direction === CallDirection.Inbound);\n\n        if (shouldTerminate) {\n            this.terminate(CallParty.Remote, msg.reason || CallErrorCode.UserHangup, true);\n        } else {\n            logger.debug(`Call ${this.callId} onRejectReceived() called in wrong state (state=${this.state})`);\n        }\n    };\n\n    public onAnsweredElsewhere = (msg: MCallAnswer): void => {\n        logger.debug(`Call ${this.callId} onAnsweredElsewhere() running`);\n        this.terminate(CallParty.Remote, CallErrorCode.AnsweredElsewhere, true);\n    };\n\n    /**\n     * @internal\n     */\n    private async sendVoipEvent<K extends keyof Pick<TimelineEvents, CallEventType>>(\n        eventType: K,\n        content: Omit<TimelineEvents[K], \"version\" | \"call_id\" | \"party_id\" | \"conf_id\">,\n    ): Promise<void> {\n        const realContent = {\n            ...content,\n            version: VOIP_PROTO_VERSION,\n            call_id: this.callId,\n            party_id: this.ourPartyId,\n            conf_id: this.groupCallId,\n        } as TimelineEvents[K];\n\n        if (this.opponentDeviceId) {\n            const toDeviceSeq = this.toDeviceSeq++;\n            const content = {\n                ...realContent,\n                device_id: this.client.deviceId,\n                sender_session_id: this.client.getSessionId(),\n                dest_session_id: this.opponentSessionId,\n                seq: toDeviceSeq,\n                [ToDeviceMessageId]: uuidv4(),\n            };\n\n            this.emit(\n                CallEvent.SendVoipEvent,\n                {\n                    type: \"toDevice\",\n                    eventType,\n                    userId: this.invitee || this.getOpponentMember()?.userId,\n                    opponentDeviceId: this.opponentDeviceId,\n                    content,\n                },\n                this,\n            );\n\n            const userId = this.invitee || this.getOpponentMember()!.userId;\n            if (this.client.getUseE2eForGroupCall()) {\n                if (!this.hasOpponentDeviceInfo) {\n                    logger.warn(`Call ${this.callId} sendVoipEvent() failed: we do not have opponentDeviceInfo`);\n                    return;\n                }\n\n                // TODO: Here we were sending the event to the opponent's device as a to-device message with MatrixClient.encryptAndSendToDevices.\n                // However due to the switch to Rust cryptography we need to migrate to the new encryptToDeviceMessages API.\n                throw new Error(\"Unimplemented\");\n            } else {\n                await this.client.sendToDevice(\n                    eventType,\n                    new Map<string, any>([[userId, new Map([[this.opponentDeviceId, content]])]]),\n                );\n            }\n        } else {\n            this.emit(\n                CallEvent.SendVoipEvent,\n                {\n                    type: \"sendEvent\",\n                    eventType,\n                    roomId: this.roomId,\n                    content: realContent,\n                    userId: this.invitee || this.getOpponentMember()?.userId,\n                },\n                this,\n            );\n\n            await this.client.sendEvent(this.roomId!, eventType, realContent);\n        }\n    }\n\n    /**\n     * Queue a candidate to be sent\n     * @param content - The candidate to queue up, or null if candidates have finished being generated\n     *                and end-of-candidates should be signalled\n     */\n    private queueCandidate(content: RTCIceCandidate | null): void {\n        // We partially de-trickle candidates by waiting for `delay` before sending them\n        // amalgamated, in order to avoid sending too many m.call.candidates events and hitting\n        // rate limits in Matrix.\n        // In practice, it'd be better to remove rate limits for m.call.*\n\n        // N.B. this deliberately lets you queue and send blank candidates, which MSC2746\n        // currently proposes as the way to indicate that candidate gathering is complete.\n        // This will hopefully be changed to an explicit rather than implicit notification\n        // shortly.\n        if (content) {\n            this.candidateSendQueue.push(content);\n        } else {\n            this.candidatesEnded = true;\n        }\n\n        // Don't send the ICE candidates yet if the call is in the ringing state: this\n        // means we tried to pick (ie. started generating candidates) and then failed to\n        // send the answer and went back to the ringing state. Queue up the candidates\n        // to send if we successfully send the answer.\n        // Equally don't send if we haven't yet sent the answer because we can send the\n        // first batch of candidates along with the answer\n        if (this.state === CallState.Ringing || !this.inviteOrAnswerSent) return;\n\n        // MSC2746 recommends these values (can be quite long when calling because the\n        // callee will need a while to answer the call)\n        const delay = this.direction === CallDirection.Inbound ? 500 : 2000;\n\n        if (this.candidateSendTries === 0) {\n            setTimeout(() => {\n                this.sendCandidateQueue();\n            }, delay);\n        }\n    }\n\n    // Discard all non-end-of-candidates messages\n    // Return the number of candidate messages that were discarded.\n    // Call this method before sending an invite or answer message\n    private discardDuplicateCandidates(): number {\n        let discardCount = 0;\n        const newQueue: RTCIceCandidate[] = [];\n\n        for (let i = 0; i < this.candidateSendQueue.length; i++) {\n            const candidate = this.candidateSendQueue[i];\n            if (candidate.candidate === \"\") {\n                newQueue.push(candidate);\n            } else {\n                discardCount++;\n            }\n        }\n\n        this.candidateSendQueue = newQueue;\n\n        return discardCount;\n    }\n\n    /*\n     * Transfers this call to another user\n     */\n    public async transfer(targetUserId: string): Promise<void> {\n        // Fetch the target user's global profile info: their room avatar / displayname\n        // could be different in whatever room we share with them.\n        const profileInfo = await this.client.getProfileInfo(targetUserId);\n\n        const replacementId = genCallID();\n\n        const body = {\n            replacement_id: genCallID(),\n            target_user: {\n                id: targetUserId,\n                display_name: profileInfo.displayname,\n                avatar_url: profileInfo.avatar_url,\n            },\n            create_call: replacementId,\n        } as MCallReplacesEvent;\n\n        await this.sendVoipEvent(EventType.CallReplaces, body);\n\n        await this.terminate(CallParty.Local, CallErrorCode.Transferred, true);\n    }\n\n    /*\n     * Transfers this call to the target call, effectively 'joining' the\n     * two calls (so the remote parties on each call are connected together).\n     */\n    public async transferToCall(transferTargetCall: MatrixCall): Promise<void> {\n        const targetUserId = transferTargetCall.getOpponentMember()?.userId;\n        const targetProfileInfo = targetUserId ? await this.client.getProfileInfo(targetUserId) : undefined;\n        const opponentUserId = this.getOpponentMember()?.userId;\n        const transfereeProfileInfo = opponentUserId ? await this.client.getProfileInfo(opponentUserId) : undefined;\n\n        const newCallId = genCallID();\n\n        const bodyToTransferTarget = {\n            // the replacements on each side have their own ID, and it's distinct from the\n            // ID of the new call (but we can use the same function to generate it)\n            replacement_id: genCallID(),\n            target_user: {\n                id: opponentUserId,\n                display_name: transfereeProfileInfo?.displayname,\n                avatar_url: transfereeProfileInfo?.avatar_url,\n            },\n            await_call: newCallId,\n        } as MCallReplacesEvent;\n\n        await transferTargetCall.sendVoipEvent(EventType.CallReplaces, bodyToTransferTarget);\n\n        const bodyToTransferee = {\n            replacement_id: genCallID(),\n            target_user: {\n                id: targetUserId,\n                display_name: targetProfileInfo?.displayname,\n                avatar_url: targetProfileInfo?.avatar_url,\n            },\n            create_call: newCallId,\n        } as MCallReplacesEvent;\n\n        await this.sendVoipEvent(EventType.CallReplaces, bodyToTransferee);\n\n        await this.terminate(CallParty.Local, CallErrorCode.Transferred, true);\n        await transferTargetCall.terminate(CallParty.Local, CallErrorCode.Transferred, true);\n    }\n\n    private async terminate(hangupParty: CallParty, hangupReason: CallErrorCode, shouldEmit: boolean): Promise<void> {\n        if (this.callHasEnded()) return;\n\n        this.hangupParty = hangupParty;\n        this.hangupReason = hangupReason;\n        this.state = CallState.Ended;\n\n        if (this.inviteTimeout) {\n            clearTimeout(this.inviteTimeout);\n            this.inviteTimeout = undefined;\n        }\n        if (this.iceDisconnectedTimeout !== undefined) {\n            clearTimeout(this.iceDisconnectedTimeout);\n            this.iceDisconnectedTimeout = undefined;\n        }\n        if (this.callLengthInterval) {\n            clearInterval(this.callLengthInterval);\n            this.callLengthInterval = undefined;\n        }\n        if (this.stopVideoTrackTimer !== undefined) {\n            clearTimeout(this.stopVideoTrackTimer);\n            this.stopVideoTrackTimer = undefined;\n        }\n\n        for (const [stream, listener] of this.removeTrackListeners) {\n            stream.removeEventListener(\"removetrack\", listener);\n        }\n        this.removeTrackListeners.clear();\n\n        this.callStatsAtEnd = await this.collectCallStats();\n\n        // Order is important here: first we stopAllMedia() and only then we can deleteAllFeeds()\n        this.stopAllMedia();\n        this.deleteAllFeeds();\n\n        if (this.peerConn && this.peerConn.signalingState !== \"closed\") {\n            this.peerConn.close();\n        }\n        this.stats?.removeStatsReportGatherer(this.callId);\n\n        if (shouldEmit) {\n            this.emit(CallEvent.Hangup, this);\n        }\n\n        this.client.callEventHandler!.calls.delete(this.callId);\n    }\n\n    private stopAllMedia(): void {\n        logger.debug(`Call ${this.callId} stopAllMedia() running`);\n\n        for (const feed of this.feeds) {\n            // Slightly awkward as local feed need to go via the correct method on\n            // the MediaHandler so they get removed from MediaHandler (remote tracks\n            // don't)\n            // NB. We clone local streams when passing them to individual calls in a group\n            // call, so we can (and should) stop the clones once we no longer need them:\n            // the other clones will continue fine.\n            if (feed.isLocal() && feed.purpose === SDPStreamMetadataPurpose.Usermedia) {\n                this.client.getMediaHandler().stopUserMediaStream(feed.stream);\n            } else if (feed.isLocal() && feed.purpose === SDPStreamMetadataPurpose.Screenshare) {\n                this.client.getMediaHandler().stopScreensharingStream(feed.stream);\n            } else if (!feed.isLocal()) {\n                logger.debug(`Call ${this.callId} stopAllMedia() stopping stream (streamId=${feed.stream.id})`);\n                for (const track of feed.stream.getTracks()) {\n                    track.stop();\n                }\n            }\n        }\n    }\n\n    private checkForErrorListener(): void {\n        if (this.listeners(EventEmitterEvents.Error).length === 0) {\n            throw new Error(\"You MUST attach an error listener using call.on('error', function() {})\");\n        }\n    }\n\n    private async sendCandidateQueue(): Promise<void> {\n        if (this.candidateSendQueue.length === 0 || this.callHasEnded()) {\n            return;\n        }\n\n        const candidates = this.candidateSendQueue;\n        this.candidateSendQueue = [];\n        ++this.candidateSendTries;\n        const content: Pick<MCallCandidates, \"candidates\"> = {\n            candidates: candidates.map((candidate) => candidate.toJSON()),\n        };\n        if (this.candidatesEnded) {\n            // If there are no more candidates, signal this by adding an empty string candidate\n            content.candidates.push({\n                candidate: \"\",\n            });\n        }\n        logger.debug(`Call ${this.callId} sendCandidateQueue() attempting to send ${candidates.length} candidates`);\n        try {\n            await this.sendVoipEvent(EventType.CallCandidates, content);\n            // reset our retry count if we have successfully sent our candidates\n            // otherwise queueCandidate() will refuse to try to flush the queue\n            this.candidateSendTries = 0;\n\n            // Try to send candidates again just in case we received more candidates while sending.\n            this.sendCandidateQueue();\n        } catch (error) {\n            // don't retry this event: we'll send another one later as we might\n            // have more candidates by then.\n            if (error instanceof MatrixError && error.event) this.client.cancelPendingEvent(error.event);\n\n            // put all the candidates we failed to send back in the queue\n            this.candidateSendQueue.push(...candidates);\n\n            if (this.candidateSendTries > 5) {\n                logger.debug(\n                    `Call ${this.callId} sendCandidateQueue() failed to send candidates on attempt ${this.candidateSendTries}. Giving up on this call.`,\n                    error,\n                );\n\n                const code = CallErrorCode.SignallingFailed;\n                const message = \"Signalling failed\";\n\n                this.emit(CallEvent.Error, new CallError(code, message, <Error>error), this);\n                this.hangup(code, false);\n\n                return;\n            }\n\n            const delayMs = 500 * Math.pow(2, this.candidateSendTries);\n            ++this.candidateSendTries;\n            logger.debug(\n                `Call ${this.callId} sendCandidateQueue() failed to send candidates. Retrying in ${delayMs}ms`,\n                error,\n            );\n            setTimeout(() => {\n                this.sendCandidateQueue();\n            }, delayMs);\n        }\n    }\n\n    /**\n     * Place a call to this room.\n     * @throws if you have not specified a listener for 'error' events.\n     * @throws if have passed audio=false.\n     */\n    public async placeCall(audio: boolean, video: boolean): Promise<void> {\n        if (!audio) {\n            throw new Error(\"You CANNOT start a call without audio\");\n        }\n        this.state = CallState.WaitLocalMedia;\n\n        let callFeed: CallFeed;\n        try {\n            const stream = await this.client.getMediaHandler().getUserMediaStream(audio, video);\n\n            // make sure all the tracks are enabled (same as pushNewLocalFeed -\n            // we probably ought to just have one code path for adding streams)\n            setTracksEnabled(stream.getAudioTracks(), true);\n            setTracksEnabled(stream.getVideoTracks(), true);\n\n            callFeed = new CallFeed({\n                client: this.client,\n                roomId: this.roomId,\n                userId: this.client.getUserId()!,\n                deviceId: this.client.getDeviceId() ?? undefined,\n                stream,\n                purpose: SDPStreamMetadataPurpose.Usermedia,\n                audioMuted: false,\n                videoMuted: false,\n            });\n        } catch (e) {\n            this.getUserMediaFailed(<Error>e);\n            return;\n        }\n\n        try {\n            await this.placeCallWithCallFeeds([callFeed]);\n        } catch (e) {\n            this.placeCallFailed(<Error>e);\n            return;\n        }\n    }\n\n    /**\n     * Place a call to this room with call feed.\n     * @param callFeeds - to use\n     * @throws if you have not specified a listener for 'error' events.\n     * @throws if have passed audio=false.\n     */\n    public async placeCallWithCallFeeds(callFeeds: CallFeed[], requestScreenshareFeed = false): Promise<void> {\n        this.checkForErrorListener();\n        this.direction = CallDirection.Outbound;\n\n        await this.initOpponentCrypto();\n\n        // XXX Find a better way to do this\n        this.client.callEventHandler!.calls.set(this.callId, this);\n\n        // make sure we have valid turn creds. Unless something's gone wrong, it should\n        // poll and keep the credentials valid so this should be instant.\n        const haveTurnCreds = await this.client.checkTurnServers();\n        if (!haveTurnCreds) {\n            logger.warn(\n                `Call ${this.callId} placeCallWithCallFeeds() failed to get TURN credentials! Proceeding with call anyway...`,\n            );\n        }\n\n        // create the peer connection now so it can be gathering candidates while we get user\n        // media (assuming a candidate pool size is configured)\n        this.peerConn = this.createPeerConnection();\n        this.emit(CallEvent.PeerConnectionCreated, this.peerConn, this);\n        this.gotCallFeedsForInvite(callFeeds, requestScreenshareFeed);\n    }\n\n    private createPeerConnection(): RTCPeerConnection {\n        const pc = new window.RTCPeerConnection({\n            iceTransportPolicy: this.forceTURN ? \"relay\" : undefined,\n            iceServers: this.turnServers.length ? this.turnServers : undefined,\n            iceCandidatePoolSize: this.client.iceCandidatePoolSize,\n            bundlePolicy: \"max-bundle\",\n        });\n\n        // 'connectionstatechange' would be better, but firefox doesn't implement that.\n        pc.addEventListener(\"iceconnectionstatechange\", this.onIceConnectionStateChanged);\n        pc.addEventListener(\"signalingstatechange\", this.onSignallingStateChanged);\n        pc.addEventListener(\"icecandidate\", this.gotLocalIceCandidate);\n        pc.addEventListener(\"icegatheringstatechange\", this.onIceGatheringStateChange);\n        pc.addEventListener(\"track\", this.onTrack);\n        pc.addEventListener(\"negotiationneeded\", this.onNegotiationNeeded);\n        pc.addEventListener(\"datachannel\", this.onDataChannel);\n\n        const opponentMember: RoomMember | undefined = this.getOpponentMember();\n        const opponentMemberId = opponentMember ? opponentMember.userId : \"unknown\";\n        this.stats?.addStatsReportGatherer(this.callId, opponentMemberId, pc);\n        return pc;\n    }\n\n    private partyIdMatches(msg: MCallBase): boolean {\n        // They must either match or both be absent (in which case opponentPartyId will be null)\n        // Also we ignore party IDs on the invite/offer if the version is 0, so we must do the same\n        // here and use null if the version is 0 (woe betide any opponent sending messages in the\n        // same call with different versions)\n        const msgPartyId = msg.version === 0 ? null : msg.party_id || null;\n        return msgPartyId === this.opponentPartyId;\n    }\n\n    // Commits to an opponent for the call\n    // ev: An invite or answer event\n    private chooseOpponent(ev: MatrixEvent): void {\n        // I choo-choo-choose you\n        const msg = ev.getContent<MCallInviteNegotiate | MCallAnswer>();\n\n        logger.debug(`Call ${this.callId} chooseOpponent() running (partyId=${msg.party_id})`);\n\n        this.opponentVersion = msg.version;\n        if (this.opponentVersion === 0) {\n            // set to null to indicate that we've chosen an opponent, but because\n            // they're v0 they have no party ID (even if they sent one, we're ignoring it)\n            this.opponentPartyId = null;\n        } else {\n            // set to their party ID, or if they're naughty and didn't send one despite\n            // not being v0, set it to null to indicate we picked an opponent with no\n            // party ID\n            this.opponentPartyId = msg.party_id || null;\n        }\n        this.opponentCaps = msg.capabilities || ({} as CallCapabilities);\n        this.opponentMember = this.client.getRoom(this.roomId)!.getMember(ev.getSender()!) ?? undefined;\n        if (this.opponentMember) {\n            this.stats?.updateOpponentMember(this.callId, this.opponentMember.userId);\n        }\n    }\n\n    private async addBufferedIceCandidates(): Promise<void> {\n        const bufferedCandidates = this.remoteCandidateBuffer.get(this.opponentPartyId!);\n        if (bufferedCandidates) {\n            logger.info(\n                `Call ${this.callId} addBufferedIceCandidates() adding ${bufferedCandidates.length} buffered candidates for opponent ${this.opponentPartyId}`,\n            );\n            await this.addIceCandidates(bufferedCandidates);\n        }\n        this.remoteCandidateBuffer.clear();\n    }\n\n    private async addIceCandidates(candidates: RTCIceCandidate[] | MCallCandidates[\"candidates\"]): Promise<void> {\n        for (const candidate of candidates) {\n            if (\n                (candidate.sdpMid === null || candidate.sdpMid === undefined) &&\n                (candidate.sdpMLineIndex === null || candidate.sdpMLineIndex === undefined)\n            ) {\n                logger.debug(`Call ${this.callId} addIceCandidates() got remote ICE end-of-candidates`);\n            } else {\n                logger.debug(\n                    `Call ${this.callId} addIceCandidates() got remote ICE candidate (sdpMid=${candidate.sdpMid}, candidate=${candidate.candidate})`,\n                );\n            }\n\n            try {\n                await this.peerConn!.addIceCandidate(candidate);\n            } catch (err) {\n                if (!this.ignoreOffer) {\n                    logger.info(`Call ${this.callId} addIceCandidates() failed to add remote ICE candidate`, err);\n                } else {\n                    logger.debug(\n                        `Call ${this.callId} addIceCandidates() failed to add remote ICE candidate because ignoring offer`,\n                        err,\n                    );\n                }\n            }\n        }\n    }\n\n    public get hasPeerConnection(): boolean {\n        return Boolean(this.peerConn);\n    }\n\n    public initStats(stats: GroupCallStats, peerId = \"unknown\"): void {\n        this.stats = stats;\n        this.stats.start();\n    }\n}\n\nexport function setTracksEnabled(tracks: Array<MediaStreamTrack>, enabled: boolean): void {\n    for (const track of tracks) {\n        track.enabled = enabled;\n    }\n}\n\nexport function supportsMatrixCall(): boolean {\n    // typeof prevents Node from erroring on an undefined reference\n    if (typeof window === \"undefined\" || typeof document === \"undefined\") {\n        // NB. We don't log here as apps try to create a call object as a test for\n        // whether calls are supported, so we shouldn't fill the logs up.\n        return false;\n    }\n\n    // Firefox throws on so little as accessing the RTCPeerConnection when operating in a secure mode.\n    // There's some information at https://bugzilla.mozilla.org/show_bug.cgi?id=1542616 though the concern\n    // is that the browser throwing a SecurityError will brick the client creation process.\n    try {\n        const supported = Boolean(\n            window.RTCPeerConnection ??\n                window.RTCSessionDescription ??\n                window.RTCIceCandidate ??\n                navigator.mediaDevices,\n        );\n        if (!supported) {\n            /* istanbul ignore if */ // Adds a lot of noise to test runs, so disable logging there.\n            if (process.env.NODE_ENV !== \"test\") {\n                logger.error(\"WebRTC is not supported in this browser / environment\");\n            }\n            return false;\n        }\n    } catch (e) {\n        logger.error(\"Exception thrown when trying to access WebRTC\", e);\n        return false;\n    }\n\n    return true;\n}\n\n/**\n * DEPRECATED\n * Use client.createCall()\n *\n * Create a new Matrix call for the browser.\n * @param client - The client instance to use.\n * @param roomId - The room the call is in.\n * @param options - DEPRECATED optional options map.\n * @returns the call or null if the browser doesn't support calling.\n */\nexport function createNewMatrixCall(\n    client: MatrixClient,\n    roomId: string,\n    options?: Pick<CallOpts, \"forceTURN\" | \"invitee\" | \"opponentDeviceId\" | \"opponentSessionId\" | \"groupCallId\">,\n): MatrixCall | null {\n    if (!supportsMatrixCall()) return null;\n\n    const optionsForceTURN = options ? options.forceTURN : false;\n\n    const opts: CallOpts = {\n        client: client,\n        roomId: roomId,\n        invitee: options?.invitee,\n        turnServers: client.getTurnServers(),\n        // call level options\n        forceTURN: client.forceTURN || optionsForceTURN,\n        opponentDeviceId: options?.opponentDeviceId,\n        opponentSessionId: options?.opponentSessionId,\n        groupCallId: options?.groupCallId,\n    };\n    const call = new MatrixCall(opts);\n\n    client.reEmitter.reEmit(call, Object.values(CallEvent));\n\n    return call;\n}\n","/*\nCopyright 2020 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { type MatrixEvent } from \"../models/event.ts\";\nimport { logger } from \"../logger.ts\";\nimport { CallDirection, CallError, CallErrorCode, CallState, createNewMatrixCall, type MatrixCall } from \"./call.ts\";\nimport { EventType } from \"../@types/event.ts\";\nimport { ClientEvent, type MatrixClient } from \"../client.ts\";\nimport { type MCallAnswer, type MCallHangupReject } from \"./callEventTypes.ts\";\nimport { type GroupCall, GroupCallErrorCode, GroupCallEvent, GroupCallUnknownDeviceError } from \"./groupCall.ts\";\nimport { RoomEvent } from \"../models/room.ts\";\n\n// Don't ring unless we'd be ringing for at least 3 seconds: the user needs some\n// time to press the 'accept' button\nconst RING_GRACE_PERIOD = 3000;\n\nexport enum CallEventHandlerEvent {\n    Incoming = \"Call.incoming\",\n}\n\nexport type CallEventHandlerEventHandlerMap = {\n    /**\n     * Fires whenever an incoming call arrives.\n     * @param call - The incoming call.\n     * @example\n     * ```\n     * matrixClient.on(\"Call.incoming\", function(call){\n     *   call.answer(); // auto-answer\n     * });\n     * ```\n     */\n    [CallEventHandlerEvent.Incoming]: (call: MatrixCall) => void;\n};\n\nexport class CallEventHandler {\n    // XXX: Most of these are only public because of the tests\n    public calls: Map<string, MatrixCall>;\n    public callEventBuffer: MatrixEvent[];\n    public nextSeqByCall: Map<string, number> = new Map();\n    public toDeviceEventBuffers: Map<string, Array<MatrixEvent>> = new Map();\n\n    private client: MatrixClient;\n    private candidateEventsByCall: Map<string, Array<MatrixEvent>>;\n    private eventBufferPromiseChain?: Promise<void>;\n\n    public constructor(client: MatrixClient) {\n        this.client = client;\n        this.calls = new Map<string, MatrixCall>();\n        // The sync code always emits one event at a time, so it will patiently\n        // wait for us to finish processing a call invite before delivering the\n        // next event, even if that next event is a hangup. We therefore accumulate\n        // all our call events and then process them on the 'sync' event, ie.\n        // each time a sync has completed. This way, we can avoid emitting incoming\n        // call events if we get both the invite and answer/hangup in the same sync.\n        // This happens quite often, eg. replaying sync from storage, catchup sync\n        // after loading and after we've been offline for a bit.\n        this.callEventBuffer = [];\n        this.candidateEventsByCall = new Map<string, Array<MatrixEvent>>();\n    }\n\n    public start(): void {\n        this.client.on(ClientEvent.Sync, this.onSync);\n        this.client.on(RoomEvent.Timeline, this.onRoomTimeline);\n        this.client.on(ClientEvent.ToDeviceEvent, this.onToDeviceEvent);\n    }\n\n    public stop(): void {\n        this.client.removeListener(ClientEvent.Sync, this.onSync);\n        this.client.removeListener(RoomEvent.Timeline, this.onRoomTimeline);\n        this.client.removeListener(ClientEvent.ToDeviceEvent, this.onToDeviceEvent);\n    }\n\n    private onSync = (): void => {\n        // Process the current event buffer and start queuing into a new one.\n        const currentEventBuffer = this.callEventBuffer;\n        this.callEventBuffer = [];\n\n        // Ensure correct ordering by only processing this queue after the previous one has finished processing\n        if (this.eventBufferPromiseChain) {\n            this.eventBufferPromiseChain = this.eventBufferPromiseChain.then(() =>\n                this.evaluateEventBuffer(currentEventBuffer),\n            );\n        } else {\n            this.eventBufferPromiseChain = this.evaluateEventBuffer(currentEventBuffer);\n        }\n    };\n\n    private async evaluateEventBuffer(eventBuffer: MatrixEvent[]): Promise<void> {\n        await Promise.all(eventBuffer.map((event) => this.client.decryptEventIfNeeded(event)));\n\n        const callEvents = eventBuffer.filter((event) => {\n            const eventType = event.getType();\n            return eventType.startsWith(\"m.call.\") || eventType.startsWith(\"org.matrix.call.\");\n        });\n\n        const ignoreCallIds = new Set<string>();\n\n        // inspect the buffer and mark all calls which have been answered\n        // or hung up before passing them to the call event handler.\n        for (const event of callEvents) {\n            const eventType = event.getType();\n\n            if (eventType === EventType.CallAnswer || eventType === EventType.CallHangup) {\n                ignoreCallIds.add(event.getContent().call_id);\n            }\n        }\n\n        // Process call events in the order that they were received\n        for (const event of callEvents) {\n            const eventType = event.getType();\n            const callId = event.getContent().call_id;\n\n            if (eventType === EventType.CallInvite && ignoreCallIds.has(callId)) {\n                // This call has previously been answered or hung up: ignore it\n                continue;\n            }\n\n            try {\n                await this.handleCallEvent(event);\n            } catch (e) {\n                logger.error(\"CallEventHandler evaluateEventBuffer() caught exception handling call event\", e);\n            }\n        }\n    }\n\n    private onRoomTimeline = (event: MatrixEvent): void => {\n        this.callEventBuffer.push(event);\n    };\n\n    private onToDeviceEvent = (event: MatrixEvent): void => {\n        const content = event.getContent();\n\n        if (!content.call_id) {\n            this.callEventBuffer.push(event);\n            return;\n        }\n\n        if (!this.nextSeqByCall.has(content.call_id)) {\n            this.nextSeqByCall.set(content.call_id, 0);\n        }\n\n        if (content.seq === undefined) {\n            this.callEventBuffer.push(event);\n            return;\n        }\n\n        const nextSeq = this.nextSeqByCall.get(content.call_id) || 0;\n\n        if (content.seq !== nextSeq) {\n            if (!this.toDeviceEventBuffers.has(content.call_id)) {\n                this.toDeviceEventBuffers.set(content.call_id, []);\n            }\n\n            const buffer = this.toDeviceEventBuffers.get(content.call_id)!;\n            const index = buffer.findIndex((e) => e.getContent().seq > content.seq);\n\n            if (index === -1) {\n                buffer.push(event);\n            } else {\n                buffer.splice(index, 0, event);\n            }\n        } else {\n            const callId = content.call_id;\n            this.callEventBuffer.push(event);\n            this.nextSeqByCall.set(callId, content.seq + 1);\n\n            const buffer = this.toDeviceEventBuffers.get(callId);\n\n            let nextEvent = buffer && buffer.shift();\n\n            while (nextEvent && nextEvent.getContent().seq === this.nextSeqByCall.get(callId)) {\n                this.callEventBuffer.push(nextEvent);\n                this.nextSeqByCall.set(callId, nextEvent.getContent().seq + 1);\n                nextEvent = buffer!.shift();\n            }\n        }\n    };\n\n    private async handleCallEvent(event: MatrixEvent): Promise<void> {\n        this.client.emit(ClientEvent.ReceivedVoipEvent, event);\n\n        const content = event.getContent();\n        const callRoomId =\n            event.getRoomId() || this.client.groupCallEventHandler!.getGroupCallById(content.conf_id)?.room?.roomId;\n        const groupCallId = content.conf_id;\n        const type = event.getType() as EventType;\n        const senderId = event.getSender()!;\n        let call = content.call_id ? this.calls.get(content.call_id) : undefined;\n\n        let opponentDeviceId: string | undefined;\n\n        let groupCall: GroupCall | undefined;\n        if (groupCallId) {\n            groupCall = this.client.groupCallEventHandler!.getGroupCallById(groupCallId);\n\n            if (!groupCall) {\n                logger.warn(\n                    `CallEventHandler handleCallEvent() could not find a group call - ignoring event (groupCallId=${groupCallId}, type=${type})`,\n                );\n                return;\n            }\n\n            opponentDeviceId = content.device_id;\n\n            if (!opponentDeviceId) {\n                logger.warn(\n                    `CallEventHandler handleCallEvent() could not find a device id - ignoring event (senderId=${senderId})`,\n                );\n                groupCall.emit(GroupCallEvent.Error, new GroupCallUnknownDeviceError(senderId));\n                return;\n            }\n\n            if (content.dest_session_id !== this.client.getSessionId()) {\n                logger.warn(\n                    \"CallEventHandler handleCallEvent() call event does not match current session id - ignoring\",\n                );\n                return;\n            }\n        }\n\n        const weSentTheEvent =\n            senderId === this.client.credentials.userId &&\n            (opponentDeviceId === undefined || opponentDeviceId === this.client.getDeviceId()!);\n\n        if (!callRoomId) return;\n\n        if (type === EventType.CallInvite) {\n            // ignore invites you send\n            if (weSentTheEvent) return;\n            // expired call\n            if (event.getLocalAge() > content.lifetime - RING_GRACE_PERIOD) return;\n            // stale/old invite event\n            if (call && call.state === CallState.Ended) return;\n\n            if (call) {\n                logger.warn(\n                    `CallEventHandler handleCallEvent() already has a call but got an invite - clobbering (callId=${content.call_id})`,\n                );\n            }\n\n            if (content.invitee && content.invitee !== this.client.getUserId()) {\n                return; // This invite was meant for another user in the room\n            }\n\n            const timeUntilTurnCresExpire = (this.client.getTurnServersExpiry() ?? 0) - Date.now();\n            logger.info(\n                \"CallEventHandler handleCallEvent() current turn creds expire in \" + timeUntilTurnCresExpire + \" ms\",\n            );\n            call =\n                createNewMatrixCall(this.client, callRoomId, {\n                    forceTURN: this.client.forceTURN,\n                    opponentDeviceId,\n                    groupCallId,\n                    opponentSessionId: content.sender_session_id,\n                }) ?? undefined;\n            if (!call) {\n                logger.log(\n                    `CallEventHandler handleCallEvent() this client does not support WebRTC (callId=${content.call_id})`,\n                );\n                // don't hang up the call: there could be other clients\n                // connected that do support WebRTC and declining the\n                // the call on their behalf would be really annoying.\n                return;\n            }\n\n            call.callId = content.call_id;\n            const stats = groupCall?.getGroupCallStats();\n            if (stats) {\n                call.initStats(stats);\n            }\n\n            try {\n                await call.initWithInvite(event);\n            } catch (e) {\n                if (e instanceof CallError) {\n                    if (e.code === GroupCallErrorCode.UnknownDevice) {\n                        groupCall?.emit(GroupCallEvent.Error, e);\n                    } else {\n                        logger.error(e);\n                    }\n                }\n            }\n            this.calls.set(call.callId, call);\n\n            // if we stashed candidate events for that call ID, play them back now\n            if (this.candidateEventsByCall.get(call.callId)) {\n                for (const ev of this.candidateEventsByCall.get(call.callId)!) {\n                    call.onRemoteIceCandidatesReceived(ev);\n                }\n            }\n\n            // Were we trying to call that user (room)?\n            let existingCall: MatrixCall | undefined;\n            for (const thisCall of this.calls.values()) {\n                const isCalling = [CallState.WaitLocalMedia, CallState.CreateOffer, CallState.InviteSent].includes(\n                    thisCall.state,\n                );\n\n                if (\n                    call.roomId === thisCall.roomId &&\n                    thisCall.direction === CallDirection.Outbound &&\n                    call.getOpponentMember()?.userId === thisCall.invitee &&\n                    isCalling\n                ) {\n                    existingCall = thisCall;\n                    break;\n                }\n            }\n\n            if (existingCall) {\n                if (existingCall.callId > call.callId) {\n                    logger.log(\n                        `CallEventHandler handleCallEvent() detected glare - answering incoming call and canceling outgoing call (incomingId=${call.callId}, outgoingId=${existingCall.callId})`,\n                    );\n                    existingCall.replacedBy(call);\n                } else {\n                    logger.log(\n                        `CallEventHandler handleCallEvent() detected glare - hanging up incoming call (incomingId=${call.callId}, outgoingId=${existingCall.callId})`,\n                    );\n                    call.hangup(CallErrorCode.Replaced, true);\n                }\n            } else {\n                this.client.emit(CallEventHandlerEvent.Incoming, call);\n            }\n            return;\n        } else if (type === EventType.CallCandidates) {\n            if (weSentTheEvent) return;\n\n            if (!call) {\n                // store the candidates; we may get a call eventually.\n                if (!this.candidateEventsByCall.has(content.call_id)) {\n                    this.candidateEventsByCall.set(content.call_id, []);\n                }\n                this.candidateEventsByCall.get(content.call_id)!.push(event);\n            } else {\n                call.onRemoteIceCandidatesReceived(event);\n            }\n            return;\n        } else if ([EventType.CallHangup, EventType.CallReject].includes(type)) {\n            // Note that we also observe our own hangups here so we can see\n            // if we've already rejected a call that would otherwise be valid\n            if (!call) {\n                // if not live, store the fact that the call has ended because\n                // we're probably getting events backwards so\n                // the hangup will come before the invite\n                call =\n                    createNewMatrixCall(this.client, callRoomId, {\n                        opponentDeviceId,\n                        opponentSessionId: content.sender_session_id,\n                    }) ?? undefined;\n                if (call) {\n                    call.callId = content.call_id;\n                    call.initWithHangup(event);\n                    this.calls.set(content.call_id, call);\n                }\n            } else {\n                if (call.state !== CallState.Ended) {\n                    if (type === EventType.CallHangup) {\n                        call.onHangupReceived(content as MCallHangupReject);\n                    } else {\n                        call.onRejectReceived(content as MCallHangupReject);\n                    }\n\n                    // @ts-expect-error typescript thinks the state can't be 'ended' because we're\n                    // inside the if block where it wasn't, but it could have changed because\n                    // on[Hangup|Reject]Received are side-effecty.\n                    if (call.state === CallState.Ended) this.calls.delete(content.call_id);\n                }\n            }\n            return;\n        }\n\n        // The following events need a call and a peer connection\n        if (!call || !call.hasPeerConnection) {\n            logger.info(\n                `CallEventHandler handleCallEvent() discarding possible call event as we don't have a call (type=${type})`,\n            );\n            return;\n        }\n        // Ignore remote echo\n        if (event.getContent().party_id === call.ourPartyId) return;\n\n        switch (type) {\n            case EventType.CallAnswer:\n                if (weSentTheEvent) {\n                    if (call.state === CallState.Ringing) {\n                        call.onAnsweredElsewhere(content as MCallAnswer);\n                    }\n                } else {\n                    call.onAnswerReceived(event);\n                }\n                break;\n            case EventType.CallSelectAnswer:\n                call.onSelectAnswerReceived(event);\n                break;\n\n            case EventType.CallNegotiate:\n                call.onNegotiateReceived(event);\n                break;\n\n            case EventType.CallAssertedIdentity:\n            case EventType.CallAssertedIdentityPrefix:\n                call.onAssertedIdentityReceived(event);\n                break;\n\n            case EventType.CallSDPStreamMetadataChanged:\n            case EventType.CallSDPStreamMetadataChangedPrefix:\n                call.onSDPStreamMetadataChangedReceived(event);\n                break;\n        }\n    }\n}\n","// allow non-camelcase as these are events type that go onto the wire\n/* eslint-disable camelcase */\n\nimport { type CallErrorCode } from \"./call.ts\";\n\n// TODO: Change to \"sdp_stream_metadata\" when MSC3077 is merged\nexport const SDPStreamMetadataKey = \"org.matrix.msc3077.sdp_stream_metadata\";\n\nexport enum SDPStreamMetadataPurpose {\n    Usermedia = \"m.usermedia\",\n    Screenshare = \"m.screenshare\",\n}\n\nexport interface SDPStreamMetadataObject {\n    purpose: SDPStreamMetadataPurpose;\n    audio_muted: boolean;\n    video_muted: boolean;\n}\n\nexport interface SDPStreamMetadata {\n    [key: string]: SDPStreamMetadataObject;\n}\n\nexport interface CallCapabilities {\n    \"m.call.transferee\": boolean;\n    \"m.call.dtmf\": boolean;\n}\n\nexport interface CallReplacesTarget {\n    id: string;\n    display_name: string;\n    avatar_url: string;\n}\n\nexport interface MCallBase {\n    call_id: string;\n    conf_id?: string;\n    version: string | number;\n    party_id?: string;\n    sender_session_id?: string;\n    dest_session_id?: string;\n}\n\nexport interface MCallAnswer extends MCallBase {\n    answer: RTCSessionDescription;\n    capabilities?: CallCapabilities;\n    [SDPStreamMetadataKey]: SDPStreamMetadata;\n}\n\nexport interface MCallSelectAnswer extends MCallBase {\n    selected_party_id: string;\n}\n\nexport interface MCallInviteNegotiate extends MCallBase {\n    offer: RTCSessionDescription;\n    description: RTCSessionDescription;\n    lifetime: number;\n    capabilities?: CallCapabilities;\n    invitee?: string;\n    sender_session_id?: string;\n    dest_session_id?: string;\n    [SDPStreamMetadataKey]: SDPStreamMetadata;\n}\n\nexport interface MCallSDPStreamMetadataChanged extends MCallBase {\n    [SDPStreamMetadataKey]: SDPStreamMetadata;\n}\n\nexport interface MCallReplacesEvent extends MCallBase {\n    replacement_id: string;\n    target_user: CallReplacesTarget;\n    create_call: string;\n    await_call: string;\n    target_room: string;\n}\n\nexport interface MCAllAssertedIdentity extends MCallBase {\n    asserted_identity: {\n        id: string;\n        display_name: string;\n        avatar_url: string;\n    };\n}\n\nexport interface MCallCandidates extends MCallBase {\n    candidates: Omit<RTCIceCandidateInit, \"usernameFragment\">[];\n}\n\nexport interface MCallHangupReject extends MCallBase {\n    reason?: CallErrorCode;\n}\n\n/* eslint-enable camelcase */\n","/*\nCopyright 2022 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nlet audioContext: AudioContext | null = null;\nlet refCount = 0;\n\n/**\n * Acquires a reference to the shared AudioContext.\n * It's highly recommended to reuse this AudioContext rather than creating your\n * own, because multiple AudioContexts can be problematic in some browsers.\n * Make sure to call releaseContext when you're done using it.\n * @returns The shared AudioContext\n */\nexport const acquireContext = (): AudioContext => {\n    if (audioContext === null) audioContext = new AudioContext();\n    refCount++;\n    return audioContext;\n};\n\n/**\n * Signals that one of the references to the shared AudioContext has been\n * released, allowing the context and associated hardware resources to be\n * cleaned up if nothing else is using it.\n */\nexport const releaseContext = (): void => {\n    refCount--;\n    if (refCount === 0) {\n        audioContext?.close();\n        audioContext = null;\n    }\n};\n","/*\nCopyright 2021 Šimon Brandner <simon.bra.ag@gmail.com>\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { SDPStreamMetadataPurpose } from \"./callEventTypes.ts\";\nimport { acquireContext, releaseContext } from \"./audioContext.ts\";\nimport { type MatrixClient } from \"../client.ts\";\nimport { type RoomMember } from \"../models/room-member.ts\";\nimport { logger } from \"../logger.ts\";\nimport { TypedEventEmitter } from \"../models/typed-event-emitter.ts\";\nimport { CallEvent, CallState, type MatrixCall } from \"./call.ts\";\n\nconst POLLING_INTERVAL = 200; // ms\nexport const SPEAKING_THRESHOLD = -60; // dB\nconst SPEAKING_SAMPLE_COUNT = 8; // samples\n\nexport interface ICallFeedOpts {\n    client: MatrixClient;\n    roomId?: string;\n    userId: string;\n    deviceId: string | undefined;\n    stream: MediaStream;\n    purpose: SDPStreamMetadataPurpose;\n    /**\n     * Whether or not the remote SDPStreamMetadata says audio is muted\n     */\n    audioMuted: boolean;\n    /**\n     * Whether or not the remote SDPStreamMetadata says video is muted\n     */\n    videoMuted: boolean;\n    /**\n     * The MatrixCall which is the source of this CallFeed\n     */\n    call?: MatrixCall;\n}\n\nexport enum CallFeedEvent {\n    NewStream = \"new_stream\",\n    MuteStateChanged = \"mute_state_changed\",\n    LocalVolumeChanged = \"local_volume_changed\",\n    VolumeChanged = \"volume_changed\",\n    ConnectedChanged = \"connected_changed\",\n    Speaking = \"speaking\",\n    Disposed = \"disposed\",\n}\n\ntype EventHandlerMap = {\n    [CallFeedEvent.NewStream]: (stream: MediaStream) => void;\n    [CallFeedEvent.MuteStateChanged]: (audioMuted: boolean, videoMuted: boolean) => void;\n    [CallFeedEvent.LocalVolumeChanged]: (localVolume: number) => void;\n    [CallFeedEvent.VolumeChanged]: (volume: number) => void;\n    [CallFeedEvent.ConnectedChanged]: (connected: boolean) => void;\n    [CallFeedEvent.Speaking]: (speaking: boolean) => void;\n    [CallFeedEvent.Disposed]: () => void;\n};\n\nexport class CallFeed extends TypedEventEmitter<CallFeedEvent, EventHandlerMap> {\n    public stream: MediaStream;\n    public sdpMetadataStreamId: string;\n    public userId: string;\n    public readonly deviceId: string | undefined;\n    public purpose: SDPStreamMetadataPurpose;\n    public speakingVolumeSamples: number[];\n\n    private client: MatrixClient;\n    private call?: MatrixCall;\n    private roomId?: string;\n    private audioMuted: boolean;\n    private videoMuted: boolean;\n    private localVolume = 1;\n    private measuringVolumeActivity = false;\n    private audioContext?: AudioContext;\n    private analyser?: AnalyserNode;\n    private frequencyBinCount?: Float32Array;\n    private speakingThreshold = SPEAKING_THRESHOLD;\n    private speaking = false;\n    private volumeLooperTimeout?: ReturnType<typeof setTimeout>;\n    private _disposed = false;\n    private _connected = false;\n\n    public constructor(opts: ICallFeedOpts) {\n        super();\n\n        this.client = opts.client;\n        this.call = opts.call;\n        this.roomId = opts.roomId;\n        this.userId = opts.userId;\n        this.deviceId = opts.deviceId;\n        this.purpose = opts.purpose;\n        this.audioMuted = opts.audioMuted;\n        this.videoMuted = opts.videoMuted;\n        this.speakingVolumeSamples = new Array(SPEAKING_SAMPLE_COUNT).fill(-Infinity);\n        this.sdpMetadataStreamId = opts.stream.id;\n\n        this.updateStream(null, opts.stream);\n        this.stream = opts.stream; // updateStream does this, but this makes TS happier\n\n        if (this.hasAudioTrack) {\n            this.initVolumeMeasuring();\n        }\n\n        if (opts.call) {\n            opts.call.addListener(CallEvent.State, this.onCallState);\n            this.onCallState(opts.call.state);\n        }\n    }\n\n    public get connected(): boolean {\n        // Local feeds are always considered connected\n        return this.isLocal() || this._connected;\n    }\n\n    private set connected(connected: boolean) {\n        this._connected = connected;\n        this.emit(CallFeedEvent.ConnectedChanged, this.connected);\n    }\n\n    public get hasAudioTrack(): boolean {\n        return this.stream.getAudioTracks().length > 0;\n    }\n\n    private updateStream(oldStream: MediaStream | null, newStream: MediaStream): void {\n        if (newStream === oldStream) return;\n\n        const wasMeasuringVolumeActivity = this.measuringVolumeActivity;\n\n        if (oldStream) {\n            oldStream.removeEventListener(\"addtrack\", this.onAddTrack);\n            this.measureVolumeActivity(false);\n        }\n\n        this.stream = newStream;\n        newStream.addEventListener(\"addtrack\", this.onAddTrack);\n\n        if (this.hasAudioTrack) {\n            this.initVolumeMeasuring();\n            if (wasMeasuringVolumeActivity) this.measureVolumeActivity(true);\n        } else {\n            this.measureVolumeActivity(false);\n        }\n\n        this.emit(CallFeedEvent.NewStream, this.stream);\n    }\n\n    private initVolumeMeasuring(): void {\n        if (!this.hasAudioTrack) return;\n        if (!this.audioContext) this.audioContext = acquireContext();\n\n        this.analyser = this.audioContext.createAnalyser();\n        this.analyser.fftSize = 512;\n        this.analyser.smoothingTimeConstant = 0.1;\n\n        const mediaStreamAudioSourceNode = this.audioContext.createMediaStreamSource(this.stream);\n        mediaStreamAudioSourceNode.connect(this.analyser);\n\n        this.frequencyBinCount = new Float32Array(this.analyser.frequencyBinCount);\n    }\n\n    private onAddTrack = (): void => {\n        this.emit(CallFeedEvent.NewStream, this.stream);\n    };\n\n    private onCallState = (state: CallState): void => {\n        if (state === CallState.Connected) {\n            this.connected = true;\n        } else if (state === CallState.Connecting) {\n            this.connected = false;\n        }\n    };\n\n    /**\n     * Returns callRoom member\n     * @returns member of the callRoom\n     */\n    public getMember(): RoomMember | null {\n        const callRoom = this.client.getRoom(this.roomId);\n        return callRoom?.getMember(this.userId) ?? null;\n    }\n\n    /**\n     * Returns true if CallFeed is local, otherwise returns false\n     * @returns is local?\n     */\n    public isLocal(): boolean {\n        return (\n            this.userId === this.client.getUserId() &&\n            (this.deviceId === undefined || this.deviceId === this.client.getDeviceId())\n        );\n    }\n\n    /**\n     * Returns true if audio is muted or if there are no audio\n     * tracks, otherwise returns false\n     * @returns is audio muted?\n     */\n    public isAudioMuted(): boolean {\n        return this.stream.getAudioTracks().length === 0 || this.audioMuted;\n    }\n\n    /**\n     * Returns true video is muted or if there are no video\n     * tracks, otherwise returns false\n     * @returns is video muted?\n     */\n    public isVideoMuted(): boolean {\n        // We assume only one video track\n        return this.stream.getVideoTracks().length === 0 || this.videoMuted;\n    }\n\n    public isSpeaking(): boolean {\n        return this.speaking;\n    }\n\n    /**\n     * Replaces the current MediaStream with a new one.\n     * The stream will be different and new stream as remote parties are\n     * concerned, but this can be used for convenience locally to set up\n     * volume listeners automatically on the new stream etc.\n     * @param newStream - new stream with which to replace the current one\n     */\n    public setNewStream(newStream: MediaStream): void {\n        this.updateStream(this.stream, newStream);\n    }\n\n    /**\n     * Set one or both of feed's internal audio and video video mute state\n     * Either value may be null to leave it as-is\n     * @param audioMuted - is the feed's audio muted?\n     * @param videoMuted - is the feed's video muted?\n     */\n    public setAudioVideoMuted(audioMuted: boolean | null, videoMuted: boolean | null): void {\n        if (audioMuted !== null) {\n            if (this.audioMuted !== audioMuted) {\n                this.speakingVolumeSamples.fill(-Infinity);\n            }\n            this.audioMuted = audioMuted;\n        }\n        if (videoMuted !== null) this.videoMuted = videoMuted;\n        this.emit(CallFeedEvent.MuteStateChanged, this.audioMuted, this.videoMuted);\n    }\n\n    /**\n     * Starts emitting volume_changed events where the emitter value is in decibels\n     * @param enabled - emit volume changes\n     */\n    public measureVolumeActivity(enabled: boolean): void {\n        if (enabled) {\n            if (!this.analyser || !this.frequencyBinCount || !this.hasAudioTrack) return;\n\n            this.measuringVolumeActivity = true;\n            this.volumeLooper();\n        } else {\n            this.measuringVolumeActivity = false;\n            this.speakingVolumeSamples.fill(-Infinity);\n            this.emit(CallFeedEvent.VolumeChanged, -Infinity);\n        }\n    }\n\n    public setSpeakingThreshold(threshold: number): void {\n        this.speakingThreshold = threshold;\n    }\n\n    private volumeLooper = (): void => {\n        if (!this.analyser) return;\n\n        if (!this.measuringVolumeActivity) return;\n\n        this.analyser.getFloatFrequencyData(this.frequencyBinCount!);\n\n        let maxVolume = -Infinity;\n        for (const volume of this.frequencyBinCount!) {\n            if (volume > maxVolume) {\n                maxVolume = volume;\n            }\n        }\n\n        this.speakingVolumeSamples.shift();\n        this.speakingVolumeSamples.push(maxVolume);\n\n        this.emit(CallFeedEvent.VolumeChanged, maxVolume);\n\n        let newSpeaking = false;\n\n        for (const volume of this.speakingVolumeSamples) {\n            if (volume > this.speakingThreshold) {\n                newSpeaking = true;\n                break;\n            }\n        }\n\n        if (this.speaking !== newSpeaking) {\n            this.speaking = newSpeaking;\n            this.emit(CallFeedEvent.Speaking, this.speaking);\n        }\n\n        this.volumeLooperTimeout = setTimeout(this.volumeLooper, POLLING_INTERVAL);\n    };\n\n    public clone(): CallFeed {\n        const mediaHandler = this.client.getMediaHandler();\n        const stream = this.stream.clone();\n        logger.log(`CallFeed clone() cloning stream (originalStreamId=${this.stream.id}, newStreamId${stream.id})`);\n\n        if (this.purpose === SDPStreamMetadataPurpose.Usermedia) {\n            mediaHandler.userMediaStreams.push(stream);\n        } else {\n            mediaHandler.screensharingStreams.push(stream);\n        }\n\n        return new CallFeed({\n            client: this.client,\n            roomId: this.roomId,\n            userId: this.userId,\n            deviceId: this.deviceId,\n            stream,\n            purpose: this.purpose,\n            audioMuted: this.audioMuted,\n            videoMuted: this.videoMuted,\n        });\n    }\n\n    public dispose(): void {\n        clearTimeout(this.volumeLooperTimeout);\n        this.stream?.removeEventListener(\"addtrack\", this.onAddTrack);\n        this.call?.removeListener(CallEvent.State, this.onCallState);\n        if (this.audioContext) {\n            this.audioContext = undefined;\n            this.analyser = undefined;\n            releaseContext();\n        }\n        this._disposed = true;\n        this.emit(CallFeedEvent.Disposed);\n    }\n\n    public get disposed(): boolean {\n        return this._disposed;\n    }\n\n    private set disposed(value: boolean) {\n        this._disposed = value;\n    }\n\n    public getLocalVolume(): number {\n        return this.localVolume;\n    }\n\n    public setLocalVolume(localVolume: number): void {\n        this.localVolume = localVolume;\n        this.emit(CallFeedEvent.LocalVolumeChanged, localVolume);\n    }\n}\n","/*\nCopyright 2023 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { type TransportStats } from \"./transportStats.ts\";\nimport { type Bitrate } from \"./media/mediaTrackStats.ts\";\n\nexport interface ConnectionStatsBandwidth {\n    /**\n     * bytes per second\n     */\n    download: number;\n    /**\n     * bytes per second\n     */\n    upload: number;\n}\n\nexport interface ConnectionStatsBitrate extends Bitrate {\n    audio?: Bitrate;\n    video?: Bitrate;\n}\n\nexport interface PacketLoss {\n    total: number;\n    download: number;\n    upload: number;\n}\n\nexport class ConnectionStats {\n    public bandwidth: ConnectionStatsBitrate = {} as ConnectionStatsBitrate;\n    public bitrate: ConnectionStatsBitrate = {} as ConnectionStatsBitrate;\n    public packetLoss: PacketLoss = {} as PacketLoss;\n    public transport: TransportStats[] = [];\n}\n","/*\nCopyright 2023 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\nimport { type Bitrate } from \"./media/mediaTrackStats.ts\";\n\nexport class ConnectionStatsBuilder {\n    public static buildBandwidthReport(now: RTCIceCandidatePairStats): Bitrate {\n        const availableIncomingBitrate = now.availableIncomingBitrate;\n        const availableOutgoingBitrate = now.availableOutgoingBitrate;\n\n        return {\n            download: availableIncomingBitrate ? Math.round(availableIncomingBitrate / 1000) : 0,\n            upload: availableOutgoingBitrate ? Math.round(availableOutgoingBitrate / 1000) : 0,\n        };\n    }\n}\n","import { type TransportStats } from \"./transportStats.ts\";\n\nexport class TransportStatsBuilder {\n    public static buildReport(\n        report: RTCStatsReport | undefined,\n        now: RTCIceCandidatePairStats,\n        conferenceStatsTransport: TransportStats[],\n        isFocus: boolean,\n    ): TransportStats[] {\n        const localUsedCandidate = report?.get(now.localCandidateId);\n        const remoteUsedCandidate = report?.get(now.remoteCandidateId);\n\n        // RTCIceCandidateStats\n        // https://w3c.github.io/webrtc-stats/#icecandidate-dict*\n        if (remoteUsedCandidate && localUsedCandidate) {\n            const remoteIpAddress =\n                remoteUsedCandidate.ip !== undefined ? remoteUsedCandidate.ip : remoteUsedCandidate.address;\n            const remotePort = remoteUsedCandidate.port;\n            const ip = `${remoteIpAddress}:${remotePort}`;\n\n            const localIpAddress =\n                localUsedCandidate.ip !== undefined ? localUsedCandidate.ip : localUsedCandidate.address;\n            const localPort = localUsedCandidate.port;\n            const localIp = `${localIpAddress}:${localPort}`;\n\n            const type = remoteUsedCandidate.protocol;\n\n            // Save the address unless it has been saved already.\n            if (\n                !conferenceStatsTransport.some(\n                    (t: TransportStats) => t.ip === ip && t.type === type && t.localIp === localIp,\n                )\n            ) {\n                conferenceStatsTransport.push({\n                    ip,\n                    type,\n                    localIp,\n                    isFocus,\n                    localCandidateType: localUsedCandidate.candidateType,\n                    remoteCandidateType: remoteUsedCandidate.candidateType,\n                    networkType: localUsedCandidate.networkType,\n                    rtt: now.currentRoundTripTime ? now.currentRoundTripTime * 1000 : NaN,\n                } as TransportStats);\n            }\n        }\n        return conferenceStatsTransport;\n    }\n}\n","/*\nCopyright 2023 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { parse as parseSdp } from \"sdp-transform\";\n\nexport type Mid = string;\nexport type Ssrc = string;\nexport type MapType = \"local\" | \"remote\";\n\nexport class MediaSsrcHandler {\n    private readonly ssrcToMid = { local: new Map<Mid, Ssrc[]>(), remote: new Map<Mid, Ssrc[]>() };\n\n    public findMidBySsrc(ssrc: Ssrc, type: \"local\" | \"remote\"): Mid | undefined {\n        let mid: Mid | undefined;\n        this.ssrcToMid[type].forEach((ssrcs, m) => {\n            if (ssrcs.find((s) => s == ssrc)) {\n                mid = m;\n                return;\n            }\n        });\n        return mid;\n    }\n\n    public parse(description: string, type: MapType): void {\n        const sdp = parseSdp(description);\n        const ssrcToMid = new Map<Mid, Ssrc[]>();\n        sdp.media.forEach((m) => {\n            if ((!!m.mid && m.type === \"video\") || m.type === \"audio\") {\n                const ssrcs: Ssrc[] = [];\n                m.ssrcs?.forEach((ssrc) => {\n                    if (ssrc.attribute === \"cname\") {\n                        ssrcs.push(`${ssrc.id}`);\n                    }\n                });\n                ssrcToMid.set(`${m.mid}`, ssrcs);\n            }\n        });\n        this.ssrcToMid[type] = ssrcToMid;\n    }\n\n    public getSsrcToMidMap(type: MapType): Map<Mid, Ssrc[]> {\n        return this.ssrcToMid[type];\n    }\n}\n","/*\nCopyright 2023 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nexport type TrackId = string;\n\nexport class MediaTrackHandler {\n    public constructor(private readonly pc: RTCPeerConnection) {}\n\n    public getLocalTracks(kind: \"audio\" | \"video\"): MediaStreamTrack[] {\n        const isNotNullAndKind = (track: MediaStreamTrack | null): boolean => {\n            return track !== null && track.kind === kind;\n        };\n        return this.pc\n            .getTransceivers()\n            .filter((t) => t.currentDirection === \"sendonly\" || t.currentDirection === \"sendrecv\")\n            .filter((t) => t.sender !== null)\n            .map((t) => t.sender)\n            .map((s) => s.track)\n            .filter(isNotNullAndKind) as MediaStreamTrack[];\n    }\n\n    public getTackById(trackId: string): MediaStreamTrack | undefined {\n        return this.pc\n            .getTransceivers()\n            .map((t) => {\n                if (t?.sender.track !== null && t.sender.track.id === trackId) {\n                    return t.sender.track;\n                }\n                if (t?.receiver.track !== null && t.receiver.track.id === trackId) {\n                    return t.receiver.track;\n                }\n                return undefined;\n            })\n            .find((t) => t !== undefined);\n    }\n\n    public getLocalTrackIdByMid(mid: string): string | undefined {\n        const transceiver = this.pc.getTransceivers().find((t) => t.mid === mid);\n        return transceiver?.sender?.track?.id;\n    }\n\n    public getRemoteTrackIdByMid(mid: string): string | undefined {\n        const transceiver = this.pc.getTransceivers().find((t) => t.mid === mid);\n        return transceiver?.receiver?.track?.id;\n    }\n\n    public getActiveSimulcastStreams(): number {\n        //@TODO implement this right.. Check how many layer configured\n        return 3;\n    }\n\n    public getTransceiverByTrackId(trackId: TrackId): RTCRtpTransceiver | undefined {\n        return this.pc.getTransceivers().find((t) => {\n            return t.receiver.track.id === trackId || (t.sender.track !== null && t.sender.track.id === trackId);\n        });\n    }\n}\n","/*\nCopyright 2023 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { type AudioConcealment } from \"../statsReport.ts\";\nimport { type TrackId } from \"./mediaTrackHandler.ts\";\n\nexport interface PacketLoss {\n    packetsTotal: number;\n    packetsLost: number;\n    isDownloadStream: boolean;\n}\n\nexport interface Bitrate {\n    /**\n     * bytes per second\n     */\n    download: number;\n    /**\n     * bytes per second\n     */\n    upload: number;\n}\nexport interface ConcealedAudio {\n    /**\n     * duration in ms\n     */\n    duration: number;\n\n    ratio: number;\n}\nexport interface Resolution {\n    width: number;\n    height: number;\n}\n\nexport type TrackStatsType = \"local\" | \"remote\";\n\nexport class MediaTrackStats {\n    private loss: PacketLoss = { packetsTotal: 0, packetsLost: 0, isDownloadStream: false };\n    private bitrate: Bitrate = { download: 0, upload: 0 };\n    private resolution: Resolution = { width: -1, height: -1 };\n    private audioConcealment: AudioConcealment = { concealedAudio: 0, totalAudioDuration: 0 };\n    private framerate = 0;\n    private jitter = 0;\n    private codec = \"\";\n    private isAlive = true;\n    private isMuted = false;\n    private isEnabled = true;\n\n    public constructor(\n        public readonly trackId: TrackId,\n        public readonly type: TrackStatsType,\n        public readonly kind: \"audio\" | \"video\",\n    ) {}\n\n    public getType(): TrackStatsType {\n        return this.type;\n    }\n\n    public setLoss(loss: PacketLoss): void {\n        this.loss = loss;\n    }\n\n    public getLoss(): PacketLoss {\n        return this.loss;\n    }\n\n    public setResolution(resolution: Resolution): void {\n        this.resolution = resolution;\n    }\n\n    public getResolution(): Resolution {\n        return this.resolution;\n    }\n\n    public setFramerate(framerate: number): void {\n        this.framerate = framerate;\n    }\n\n    public getFramerate(): number {\n        return this.framerate;\n    }\n\n    public setBitrate(bitrate: Bitrate): void {\n        this.bitrate = bitrate;\n    }\n\n    public getBitrate(): Bitrate {\n        return this.bitrate;\n    }\n\n    public setCodec(codecShortType: string): boolean {\n        this.codec = codecShortType;\n        return true;\n    }\n\n    public getCodec(): string {\n        return this.codec;\n    }\n\n    public resetBitrate(): void {\n        this.bitrate = { download: 0, upload: 0 };\n    }\n\n    public set alive(isAlive: boolean) {\n        this.isAlive = isAlive;\n    }\n\n    /**\n     * A MediaTrackState is alive if the corresponding MediaStreamTrack track bound to a transceiver and the\n     * MediaStreamTrack is in state MediaStreamTrack.readyState === live\n     */\n    public get alive(): boolean {\n        return this.isAlive;\n    }\n\n    public set muted(isMuted: boolean) {\n        this.isMuted = isMuted;\n    }\n\n    /**\n     * A MediaTrackState.isMuted corresponding to MediaStreamTrack.muted.\n     * But these values only match if MediaTrackState.isAlive.\n     */\n    public get muted(): boolean {\n        return this.isMuted;\n    }\n\n    public set enabled(isEnabled: boolean) {\n        this.isEnabled = isEnabled;\n    }\n\n    /**\n     * A MediaTrackState.isEnabled corresponding to MediaStreamTrack.enabled.\n     * But these values only match if MediaTrackState.isAlive.\n     */\n    public get enabled(): boolean {\n        return this.isEnabled;\n    }\n\n    public setJitter(jitter: number): void {\n        this.jitter = jitter;\n    }\n\n    /**\n     * Jitter in milliseconds\n     */\n    public getJitter(): number {\n        return this.jitter;\n    }\n\n    /**\n     * Audio concealment ration (conceled duration / total duration)\n     */\n    public setAudioConcealment(concealedAudioDuration: number, totalAudioDuration: number): void {\n        this.audioConcealment.concealedAudio = concealedAudioDuration;\n        this.audioConcealment.totalAudioDuration = totalAudioDuration;\n    }\n\n    public getAudioConcealment(): AudioConcealment {\n        return this.audioConcealment;\n    }\n}\n","/*\nCopyright 2023 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\nimport { type TrackID } from \"../statsReport.ts\";\nimport { MediaTrackStats } from \"./mediaTrackStats.ts\";\nimport { type MediaTrackHandler, type TrackId } from \"./mediaTrackHandler.ts\";\nimport { type MediaSsrcHandler } from \"./mediaSsrcHandler.ts\";\n\nexport class MediaTrackStatsHandler {\n    private readonly track2stats = new Map<TrackID, MediaTrackStats>();\n\n    public constructor(\n        public readonly mediaSsrcHandler: MediaSsrcHandler,\n        public readonly mediaTrackHandler: MediaTrackHandler,\n    ) {}\n\n    /**\n     * Find tracks by rtc stats\n     * Argument report is any because the stats api is not consistent:\n     * For example `trackIdentifier`, `mid` not existing in every implementations\n     * https://www.w3.org/TR/webrtc-stats/#dom-rtcinboundrtpstreamstats\n     * https://developer.mozilla.org/en-US/docs/Web/API/RTCInboundRtpStreamStats\n     */\n    public findTrack2Stats(report: any, type: \"remote\" | \"local\"): MediaTrackStats | undefined {\n        let trackID;\n        if (report.trackIdentifier) {\n            trackID = report.trackIdentifier;\n        } else if (report.mid) {\n            trackID =\n                type === \"remote\"\n                    ? this.mediaTrackHandler.getRemoteTrackIdByMid(report.mid)\n                    : this.mediaTrackHandler.getLocalTrackIdByMid(report.mid);\n        } else if (report.ssrc) {\n            const mid = this.mediaSsrcHandler.findMidBySsrc(report.ssrc, type);\n            if (!mid) {\n                return undefined;\n            }\n            trackID =\n                type === \"remote\"\n                    ? this.mediaTrackHandler.getRemoteTrackIdByMid(report.mid)\n                    : this.mediaTrackHandler.getLocalTrackIdByMid(report.mid);\n        }\n\n        if (!trackID) {\n            return undefined;\n        }\n\n        let trackStats = this.track2stats.get(trackID);\n\n        if (!trackStats) {\n            const track = this.mediaTrackHandler.getTackById(trackID);\n            if (track !== undefined) {\n                const kind: \"audio\" | \"video\" = track.kind === \"audio\" ? track.kind : \"video\";\n                trackStats = new MediaTrackStats(trackID, type, kind);\n                this.track2stats.set(trackID, trackStats);\n            } else {\n                return undefined;\n            }\n        }\n        return trackStats;\n    }\n\n    public findLocalVideoTrackStats(report: any): MediaTrackStats | undefined {\n        const localVideoTracks = this.mediaTrackHandler.getLocalTracks(\"video\");\n        if (localVideoTracks.length === 0) {\n            return undefined;\n        }\n        return this.findTrack2Stats(report, \"local\");\n    }\n\n    public getTrack2stats(): Map<TrackID, MediaTrackStats> {\n        return this.track2stats;\n    }\n\n    public findTransceiverByTrackId(trackID: TrackId): undefined | RTCRtpTransceiver {\n        return this.mediaTrackHandler.getTransceiverByTrackId(trackID);\n    }\n}\n","/*\nCopyright 2023 The Matrix.org Foundation C.I.C.\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n    http://www.apache.org/licenses/LICENSE-2.0\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\nexport class ValueFormatter {\n    public static getNonNegativeValue(imput: any): number {\n        let value = imput;\n\n        if (typeof value !== \"number\") {\n            value = Number(value);\n        }\n\n        if (isNaN(value)) {\n            return 0;\n        }\n\n        return Math.max(0, value);\n    }\n}\n","import { type MediaTrackStats } from \"./media/mediaTrackStats.ts\";\nimport { ValueFormatter } from \"./valueFormatter.ts\";\nimport { type TrackSummary } from \"./callStatsReportSummary.ts\";\n\nexport class TrackStatsBuilder {\n    public static buildFramerateResolution(trackStats: MediaTrackStats, now: any): void {\n        const resolution = {\n            height: now.frameHeight,\n            width: now.frameWidth,\n        };\n        const frameRate = now.framesPerSecond;\n\n        if (resolution.height && resolution.width) {\n            trackStats.setResolution(resolution);\n        }\n        trackStats.setFramerate(Math.round(frameRate || 0));\n    }\n\n    public static calculateSimulcastFramerate(trackStats: MediaTrackStats, now: any, before: any, layer: number): void {\n        let frameRate = trackStats.getFramerate();\n        if (!frameRate) {\n            if (before) {\n                const timeMs = now.timestamp - before.timestamp;\n\n                if (timeMs > 0 && now.framesSent) {\n                    const numberOfFramesSinceBefore = now.framesSent - before.framesSent;\n\n                    frameRate = (numberOfFramesSinceBefore / timeMs) * 1000;\n                }\n            }\n\n            if (!frameRate) {\n                return;\n            }\n        }\n\n        // Reset frame rate to 0 when video is suspended as a result of endpoint falling out of last-n.\n        frameRate = layer ? Math.round(frameRate / layer) : 0;\n        trackStats.setFramerate(frameRate);\n    }\n\n    public static buildCodec(report: RTCStatsReport | undefined, trackStats: MediaTrackStats, now: any): void {\n        const codec = report?.get(now.codecId);\n\n        if (codec) {\n            /**\n             * The mime type has the following form: video/VP8 or audio/ISAC,\n             * so we what to keep just the type after the '/', audio and video\n             * keys will be added on the processing side.\n             */\n            const codecShortType = codec.mimeType.split(\"/\")[1];\n\n            if (codecShortType) trackStats.setCodec(codecShortType);\n        }\n    }\n\n    public static buildBitrateReceived(trackStats: MediaTrackStats, now: any, before: any): void {\n        trackStats.setBitrate({\n            download: TrackStatsBuilder.calculateBitrate(\n                now.bytesReceived,\n                before.bytesReceived,\n                now.timestamp,\n                before.timestamp,\n            ),\n            upload: 0,\n        });\n    }\n\n    public static buildBitrateSend(trackStats: MediaTrackStats, now: any, before: any): void {\n        trackStats.setBitrate({\n            download: 0,\n            upload: this.calculateBitrate(now.bytesSent, before.bytesSent, now.timestamp, before.timestamp),\n        });\n    }\n\n    public static buildPacketsLost(trackStats: MediaTrackStats, now: any, before: any): void {\n        const key = now.type === \"outbound-rtp\" ? \"packetsSent\" : \"packetsReceived\";\n\n        let packetsNow = now[key];\n        if (!packetsNow || packetsNow < 0) {\n            packetsNow = 0;\n        }\n\n        const packetsBefore = ValueFormatter.getNonNegativeValue(before[key]);\n        const packetsDiff = Math.max(0, packetsNow - packetsBefore);\n\n        const packetsLostNow = ValueFormatter.getNonNegativeValue(now.packetsLost);\n        const packetsLostBefore = ValueFormatter.getNonNegativeValue(before.packetsLost);\n        const packetsLostDiff = Math.max(0, packetsLostNow - packetsLostBefore);\n\n        trackStats.setLoss({\n            packetsTotal: packetsDiff + packetsLostDiff,\n            packetsLost: packetsLostDiff,\n            isDownloadStream: now.type !== \"outbound-rtp\",\n        });\n    }\n\n    private static calculateBitrate(\n        bytesNowAny: any,\n        bytesBeforeAny: any,\n        nowTimestamp: number,\n        beforeTimestamp: number,\n    ): number {\n        const bytesNow = ValueFormatter.getNonNegativeValue(bytesNowAny);\n        const bytesBefore = ValueFormatter.getNonNegativeValue(bytesBeforeAny);\n        const bytesProcessed = Math.max(0, bytesNow - bytesBefore);\n\n        const timeMs = nowTimestamp - beforeTimestamp;\n        let bitrateKbps = 0;\n\n        if (timeMs > 0) {\n            bitrateKbps = Math.round((bytesProcessed * 8) / timeMs);\n        }\n\n        return bitrateKbps;\n    }\n\n    public static setTrackStatsState(trackStats: MediaTrackStats, transceiver: RTCRtpTransceiver | undefined): void {\n        if (transceiver === undefined) {\n            trackStats.alive = false;\n            return;\n        }\n\n        const track = trackStats.getType() === \"remote\" ? transceiver.receiver.track : transceiver?.sender?.track;\n        if (track === undefined || track === null) {\n            trackStats.alive = false;\n            return;\n        }\n\n        if (track.readyState === \"ended\") {\n            trackStats.alive = false;\n            return;\n        }\n        trackStats.muted = track.muted;\n        trackStats.enabled = track.enabled;\n        trackStats.alive = true;\n    }\n\n    public static buildTrackSummary(trackStatsList: MediaTrackStats[]): {\n        audioTrackSummary: TrackSummary;\n        videoTrackSummary: TrackSummary;\n    } {\n        const videoTrackSummary: TrackSummary = {\n            count: 0,\n            muted: 0,\n            maxJitter: 0,\n            maxPacketLoss: 0,\n            concealedAudio: 0,\n            totalAudio: 0,\n        };\n        const audioTrackSummary: TrackSummary = {\n            count: 0,\n            muted: 0,\n            maxJitter: 0,\n            maxPacketLoss: 0,\n            concealedAudio: 0,\n            totalAudio: 0,\n        };\n\n        const remoteTrackList = trackStatsList.filter((t) => t.getType() === \"remote\");\n        const audioTrackList = remoteTrackList.filter((t) => t.kind === \"audio\");\n\n        remoteTrackList.forEach((stats) => {\n            const trackSummary = stats.kind === \"video\" ? videoTrackSummary : audioTrackSummary;\n            trackSummary.count++;\n            if (stats.alive && stats.muted) {\n                trackSummary.muted++;\n            }\n            if (trackSummary.maxJitter < stats.getJitter()) {\n                trackSummary.maxJitter = stats.getJitter();\n            }\n            if (trackSummary.maxPacketLoss < stats.getLoss().packetsLost) {\n                trackSummary.maxPacketLoss = stats.getLoss().packetsLost;\n            }\n            if (audioTrackList.length > 0) {\n                trackSummary.concealedAudio += stats.getAudioConcealment()?.concealedAudio;\n                trackSummary.totalAudio += stats.getAudioConcealment()?.totalAudioDuration;\n            }\n        });\n\n        return { audioTrackSummary, videoTrackSummary };\n    }\n\n    public static buildJitter(trackStats: MediaTrackStats, statsReport: any): void {\n        if (statsReport.type !== \"inbound-rtp\") {\n            return;\n        }\n\n        const jitterStr = statsReport?.jitter;\n        if (jitterStr !== undefined) {\n            const jitter = ValueFormatter.getNonNegativeValue(jitterStr);\n            trackStats.setJitter(Math.round(jitter * 1000));\n        } else {\n            trackStats.setJitter(-1);\n        }\n    }\n\n    public static buildAudioConcealment(trackStats: MediaTrackStats, statsReport: any): void {\n        if (statsReport.type !== \"inbound-rtp\") {\n            return;\n        }\n        const msPerSample = (1000 * statsReport?.totalSamplesDuration) / statsReport?.totalSamplesReceived;\n        const concealedAudioDuration = msPerSample * statsReport?.concealedSamples;\n        const totalAudioDuration = 1000 * statsReport?.totalSamplesDuration;\n        trackStats.setAudioConcealment(concealedAudioDuration, totalAudioDuration);\n    }\n}\n","/*\nCopyright 2023 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\nimport {\n    type AudioConcealment,\n    type CodecMap,\n    type ConnectionStatsReport,\n    type FramerateMap,\n    type ResolutionMap,\n    type TrackID,\n} from \"./statsReport.ts\";\nimport { type MediaTrackStats, type Resolution } from \"./media/mediaTrackStats.ts\";\n\nexport class ConnectionStatsReportBuilder {\n    public static build(stats: Map<TrackID, MediaTrackStats>): ConnectionStatsReport {\n        const report = {} as ConnectionStatsReport;\n\n        // process stats\n        const totalPackets = {\n            download: 0,\n            upload: 0,\n        };\n        const lostPackets = {\n            download: 0,\n            upload: 0,\n        };\n        let bitrateDownload = 0;\n        let bitrateUpload = 0;\n        const resolutions: ResolutionMap = {\n            local: new Map<TrackID, Resolution>(),\n            remote: new Map<TrackID, Resolution>(),\n        };\n        const framerates: FramerateMap = { local: new Map<TrackID, number>(), remote: new Map<TrackID, number>() };\n        const codecs: CodecMap = { local: new Map<TrackID, string>(), remote: new Map<TrackID, string>() };\n        const jitter = new Map<TrackID, number>();\n        const audioConcealment = new Map<TrackID, AudioConcealment>();\n\n        let audioBitrateDownload = 0;\n        let audioBitrateUpload = 0;\n        let videoBitrateDownload = 0;\n        let videoBitrateUpload = 0;\n\n        let totalConcealedAudio = 0;\n        let totalAudioDuration = 0;\n\n        for (const [trackId, trackStats] of stats) {\n            // process packet loss stats\n            const loss = trackStats.getLoss();\n            const type = loss.isDownloadStream ? \"download\" : \"upload\";\n\n            totalPackets[type] += loss.packetsTotal;\n            lostPackets[type] += loss.packetsLost;\n\n            // process bitrate stats\n            bitrateDownload += trackStats.getBitrate().download;\n            bitrateUpload += trackStats.getBitrate().upload;\n\n            // collect resolutions and framerates\n            if (trackStats.kind === \"audio\") {\n                // process audio quality stats\n                const audioConcealmentForTrack = trackStats.getAudioConcealment();\n                totalConcealedAudio += audioConcealmentForTrack.concealedAudio;\n                totalAudioDuration += audioConcealmentForTrack.totalAudioDuration;\n\n                audioBitrateDownload += trackStats.getBitrate().download;\n                audioBitrateUpload += trackStats.getBitrate().upload;\n            } else {\n                videoBitrateDownload += trackStats.getBitrate().download;\n                videoBitrateUpload += trackStats.getBitrate().upload;\n            }\n\n            resolutions[trackStats.getType()].set(trackId, trackStats.getResolution());\n            framerates[trackStats.getType()].set(trackId, trackStats.getFramerate());\n            codecs[trackStats.getType()].set(trackId, trackStats.getCodec());\n            if (trackStats.getType() === \"remote\") {\n                jitter.set(trackId, trackStats.getJitter());\n                if (trackStats.kind === \"audio\") {\n                    audioConcealment.set(trackId, trackStats.getAudioConcealment());\n                }\n            }\n\n            trackStats.resetBitrate();\n        }\n\n        report.bitrate = {\n            upload: bitrateUpload,\n            download: bitrateDownload,\n        };\n\n        report.bitrate.audio = {\n            upload: audioBitrateUpload,\n            download: audioBitrateDownload,\n        };\n\n        report.bitrate.video = {\n            upload: videoBitrateUpload,\n            download: videoBitrateDownload,\n        };\n\n        report.packetLoss = {\n            total: ConnectionStatsReportBuilder.calculatePacketLoss(\n                lostPackets.download + lostPackets.upload,\n                totalPackets.download + totalPackets.upload,\n            ),\n            download: ConnectionStatsReportBuilder.calculatePacketLoss(lostPackets.download, totalPackets.download),\n            upload: ConnectionStatsReportBuilder.calculatePacketLoss(lostPackets.upload, totalPackets.upload),\n        };\n        report.audioConcealment = audioConcealment;\n        report.totalAudioConcealment = {\n            concealedAudio: totalConcealedAudio,\n            totalAudioDuration,\n        };\n\n        report.framerate = framerates;\n        report.resolution = resolutions;\n        report.codec = codecs;\n        report.jitter = jitter;\n        return report;\n    }\n\n    private static calculatePacketLoss(lostPackets: number, totalPackets: number): number {\n        if (!totalPackets || totalPackets <= 0 || !lostPackets || lostPackets <= 0) {\n            return 0;\n        }\n\n        return Math.round((lostPackets / totalPackets) * 100);\n    }\n}\n","/*\nCopyright 2023 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\nimport { type CallFeedReport, type CallFeedStats, type TrackStats, type TransceiverStats } from \"./statsReport.ts\";\nimport { type CallFeed } from \"../callFeed.ts\";\n\nexport class CallFeedStatsReporter {\n    public static buildCallFeedReport(callId: string, opponentMemberId: string, pc: RTCPeerConnection): CallFeedReport {\n        const rtpTransceivers = pc.getTransceivers();\n        const transceiver: TransceiverStats[] = [];\n        const callFeeds: CallFeedStats[] = [];\n\n        rtpTransceivers.forEach((t) => {\n            const sender = t.sender?.track ? CallFeedStatsReporter.buildTrackStats(t.sender.track, \"sender\") : null;\n            const receiver = CallFeedStatsReporter.buildTrackStats(t.receiver.track, \"receiver\");\n            transceiver.push({\n                mid: t.mid == null ? \"null\" : t.mid,\n                direction: t.direction,\n                currentDirection: t.currentDirection == null ? \"null\" : t.currentDirection,\n                sender,\n                receiver,\n            });\n        });\n\n        return {\n            callId,\n            opponentMemberId,\n            transceiver,\n            callFeeds,\n        };\n    }\n\n    private static buildTrackStats(track: MediaStreamTrack, label = \"--\"): TrackStats {\n        const settingDeviceId = track.getSettings()?.deviceId;\n        const constrainDeviceId = track.getConstraints()?.deviceId;\n\n        return {\n            id: track.id,\n            kind: track.kind,\n            settingDeviceId: settingDeviceId ?? \"unknown\",\n            constrainDeviceId: constrainDeviceId ?? \"unknown\",\n            muted: track.muted,\n            enabled: track.enabled,\n            readyState: track.readyState,\n            label,\n        } as TrackStats;\n    }\n\n    public static expandCallFeedReport(\n        report: CallFeedReport,\n        callFeeds: CallFeed[],\n        prefix = \"unknown\",\n    ): CallFeedReport {\n        callFeeds.forEach((feed) => {\n            const audioTracks = feed.stream.getAudioTracks();\n            const videoTracks = feed.stream.getVideoTracks();\n            const audio =\n                audioTracks.length > 0\n                    ? CallFeedStatsReporter.buildTrackStats(feed.stream.getAudioTracks()[0], feed.purpose)\n                    : null;\n            const video =\n                videoTracks.length > 0\n                    ? CallFeedStatsReporter.buildTrackStats(feed.stream.getVideoTracks()[0], feed.purpose)\n                    : null;\n            const feedStats = {\n                stream: feed.stream.id,\n                type: feed.isLocal() ? \"local\" : \"remote\",\n                audio,\n                video,\n                purpose: feed.purpose,\n                prefix,\n                isVideoMuted: feed.isVideoMuted(),\n                isAudioMuted: feed.isAudioMuted(),\n            } as CallFeedStats;\n            report.callFeeds.push(feedStats);\n        });\n        return report;\n    }\n}\n","/*\nCopyright 2023 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { ConnectionStats } from \"./connectionStats.ts\";\nimport { type StatsReportEmitter } from \"./statsReportEmitter.ts\";\nimport { type ByteSend, type ByteSentStatsReport, type TrackID } from \"./statsReport.ts\";\nimport { ConnectionStatsBuilder } from \"./connectionStatsBuilder.ts\";\nimport { TransportStatsBuilder } from \"./transportStatsBuilder.ts\";\nimport { MediaSsrcHandler } from \"./media/mediaSsrcHandler.ts\";\nimport { MediaTrackHandler } from \"./media/mediaTrackHandler.ts\";\nimport { MediaTrackStatsHandler } from \"./media/mediaTrackStatsHandler.ts\";\nimport { TrackStatsBuilder } from \"./trackStatsBuilder.ts\";\nimport { ConnectionStatsReportBuilder } from \"./connectionStatsReportBuilder.ts\";\nimport { ValueFormatter } from \"./valueFormatter.ts\";\nimport { type CallStatsReportSummary } from \"./callStatsReportSummary.ts\";\nimport { logger } from \"../../logger.ts\";\nimport { CallFeedStatsReporter } from \"./callFeedStatsReporter.ts\";\n\nexport class CallStatsReportGatherer {\n    private isActive = true;\n    private previousStatsReport: RTCStatsReport | undefined;\n    private currentStatsReport: RTCStatsReport | undefined;\n    private readonly connectionStats = new ConnectionStats();\n\n    private readonly trackStats: MediaTrackStatsHandler;\n\n    public constructor(\n        public readonly callId: string,\n        private opponentMemberId: string,\n        private readonly pc: RTCPeerConnection,\n        private readonly emitter: StatsReportEmitter,\n        private readonly isFocus = true,\n    ) {\n        pc.addEventListener(\"signalingstatechange\", this.onSignalStateChange.bind(this));\n        this.trackStats = new MediaTrackStatsHandler(new MediaSsrcHandler(), new MediaTrackHandler(pc));\n    }\n\n    public async processStats(groupCallId: string, localUserId: string): Promise<CallStatsReportSummary> {\n        const summary = {\n            isFirstCollection: this.previousStatsReport === undefined,\n            receivedMedia: 0,\n            receivedAudioMedia: 0,\n            receivedVideoMedia: 0,\n            audioTrackSummary: { count: 0, muted: 0, maxPacketLoss: 0, maxJitter: 0, concealedAudio: 0, totalAudio: 0 },\n            videoTrackSummary: { count: 0, muted: 0, maxPacketLoss: 0, maxJitter: 0, concealedAudio: 0, totalAudio: 0 },\n        } as CallStatsReportSummary;\n        if (this.isActive) {\n            const statsPromise = this.pc.getStats();\n            if (typeof statsPromise?.then === \"function\") {\n                return statsPromise\n                    .then((report) => {\n                        // @ts-ignore\n                        this.currentStatsReport = typeof report?.result === \"function\" ? report.result() : report;\n\n                        try {\n                            this.processStatsReport(groupCallId, localUserId);\n                        } catch (error) {\n                            this.handleError(error);\n                            return summary;\n                        }\n\n                        this.previousStatsReport = this.currentStatsReport;\n                        summary.receivedMedia = this.connectionStats.bitrate.download;\n                        summary.receivedAudioMedia = this.connectionStats.bitrate.audio?.download || 0;\n                        summary.receivedVideoMedia = this.connectionStats.bitrate.video?.download || 0;\n                        const trackSummary = TrackStatsBuilder.buildTrackSummary(\n                            Array.from(this.trackStats.getTrack2stats().values()),\n                        );\n                        return {\n                            ...summary,\n                            audioTrackSummary: trackSummary.audioTrackSummary,\n                            videoTrackSummary: trackSummary.videoTrackSummary,\n                        };\n                    })\n                    .catch((error) => {\n                        this.handleError(error);\n                        return summary;\n                    });\n            }\n            this.isActive = false;\n        }\n        return Promise.resolve(summary);\n    }\n\n    private processStatsReport(groupCallId: string, localUserId: string): void {\n        const byteSentStatsReport: ByteSentStatsReport = new Map<TrackID, ByteSend>() as ByteSentStatsReport;\n        byteSentStatsReport.callId = this.callId;\n        byteSentStatsReport.opponentMemberId = this.opponentMemberId;\n\n        this.currentStatsReport?.forEach((now) => {\n            const before = this.previousStatsReport ? this.previousStatsReport.get(now.id) : null;\n            // RTCIceCandidatePairStats - https://w3c.github.io/webrtc-stats/#candidatepair-dict*\n            if (now.type === \"candidate-pair\" && now.nominated && now.state === \"succeeded\") {\n                this.connectionStats.bandwidth = ConnectionStatsBuilder.buildBandwidthReport(now);\n                this.connectionStats.transport = TransportStatsBuilder.buildReport(\n                    this.currentStatsReport,\n                    now,\n                    this.connectionStats.transport,\n                    this.isFocus,\n                );\n\n                // RTCReceivedRtpStreamStats\n                // https://w3c.github.io/webrtc-stats/#receivedrtpstats-dict*\n                // RTCSentRtpStreamStats\n                // https://w3c.github.io/webrtc-stats/#sentrtpstats-dict*\n            } else if (now.type === \"inbound-rtp\" || now.type === \"outbound-rtp\") {\n                const trackStats = this.trackStats.findTrack2Stats(\n                    now,\n                    now.type === \"inbound-rtp\" ? \"remote\" : \"local\",\n                );\n                if (!trackStats) {\n                    return;\n                }\n\n                if (before) {\n                    TrackStatsBuilder.buildPacketsLost(trackStats, now, before);\n                }\n\n                // Get the resolution and framerate for only remote video sources here. For the local video sources,\n                // 'track' stats will be used since they have the updated resolution based on the simulcast streams\n                // currently being sent. Promise based getStats reports three 'outbound-rtp' streams and there will be\n                // more calculations needed to determine what is the highest resolution stream sent by the client if the\n                // 'outbound-rtp' stats are used.\n                if (now.type === \"inbound-rtp\") {\n                    TrackStatsBuilder.buildFramerateResolution(trackStats, now);\n                    if (before) {\n                        TrackStatsBuilder.buildBitrateReceived(trackStats, now, before);\n                    }\n                    const ts = this.trackStats.findTransceiverByTrackId(trackStats.trackId);\n                    TrackStatsBuilder.setTrackStatsState(trackStats, ts);\n                    TrackStatsBuilder.buildJitter(trackStats, now);\n                    TrackStatsBuilder.buildAudioConcealment(trackStats, now);\n                } else if (before) {\n                    byteSentStatsReport.set(trackStats.trackId, ValueFormatter.getNonNegativeValue(now.bytesSent));\n                    TrackStatsBuilder.buildBitrateSend(trackStats, now, before);\n                }\n                TrackStatsBuilder.buildCodec(this.currentStatsReport, trackStats, now);\n            } else if (now.type === \"track\" && now.kind === \"video\" && !now.remoteSource) {\n                const trackStats = this.trackStats.findLocalVideoTrackStats(now);\n                if (!trackStats) {\n                    return;\n                }\n                TrackStatsBuilder.buildFramerateResolution(trackStats, now);\n                TrackStatsBuilder.calculateSimulcastFramerate(\n                    trackStats,\n                    now,\n                    before,\n                    this.trackStats.mediaTrackHandler.getActiveSimulcastStreams(),\n                );\n            }\n        });\n\n        this.emitter.emitByteSendReport(byteSentStatsReport);\n        this.emitter.emitCallFeedReport(\n            CallFeedStatsReporter.buildCallFeedReport(this.callId, this.opponentMemberId, this.pc),\n        );\n        this.processAndEmitConnectionStatsReport();\n    }\n\n    public setActive(isActive: boolean): void {\n        this.isActive = isActive;\n    }\n\n    public getActive(): boolean {\n        return this.isActive;\n    }\n\n    private handleError(error: any): void {\n        this.isActive = false;\n        logger.warn(`CallStatsReportGatherer ${this.callId} processStatsReport fails and set to inactive ${error}`);\n    }\n\n    private processAndEmitConnectionStatsReport(): void {\n        const report = ConnectionStatsReportBuilder.build(this.trackStats.getTrack2stats());\n        report.callId = this.callId;\n        report.opponentMemberId = this.opponentMemberId;\n\n        this.connectionStats.bandwidth = report.bandwidth;\n        this.connectionStats.bitrate = report.bitrate;\n        this.connectionStats.packetLoss = report.packetLoss;\n\n        this.emitter.emitConnectionStatsReport({\n            ...report,\n            transport: this.connectionStats.transport,\n        });\n\n        this.connectionStats.transport = [];\n    }\n\n    public stopProcessingStats(): void {}\n\n    private onSignalStateChange(): void {\n        if (this.pc.signalingState === \"stable\") {\n            if (this.pc.currentRemoteDescription) {\n                this.trackStats.mediaSsrcHandler.parse(this.pc.currentRemoteDescription.sdp, \"remote\");\n            }\n            if (this.pc.currentLocalDescription) {\n                this.trackStats.mediaSsrcHandler.parse(this.pc.currentLocalDescription.sdp, \"local\");\n            }\n        }\n    }\n\n    public setOpponentMemberId(id: string): void {\n        this.opponentMemberId = id;\n    }\n}\n","/*\nCopyright 2023 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { TypedEventEmitter } from \"../../models/typed-event-emitter.ts\";\nimport {\n    type ByteSentStatsReport,\n    type CallFeedReport,\n    type ConnectionStatsReport,\n    StatsReport,\n    type SummaryStatsReport,\n} from \"./statsReport.ts\";\n\nexport type StatsReportHandlerMap = {\n    [StatsReport.BYTE_SENT_STATS]: (report: ByteSentStatsReport) => void;\n    [StatsReport.CONNECTION_STATS]: (report: ConnectionStatsReport) => void;\n    [StatsReport.CALL_FEED_REPORT]: (report: CallFeedReport) => void;\n    [StatsReport.SUMMARY_STATS]: (report: SummaryStatsReport) => void;\n};\n\nexport class StatsReportEmitter extends TypedEventEmitter<StatsReport, StatsReportHandlerMap> {\n    public emitByteSendReport(byteSentStats: ByteSentStatsReport): void {\n        this.emit(StatsReport.BYTE_SENT_STATS, byteSentStats);\n    }\n\n    public emitConnectionStatsReport(report: ConnectionStatsReport): void {\n        this.emit(StatsReport.CONNECTION_STATS, report);\n    }\n\n    public emitCallFeedReport(report: CallFeedReport): void {\n        this.emit(StatsReport.CALL_FEED_REPORT, report);\n    }\n\n    public emitSummaryStatsReport(report: SummaryStatsReport): void {\n        this.emit(StatsReport.SUMMARY_STATS, report);\n    }\n}\n","/*\nCopyright 2023 The Matrix.org Foundation C.I.C.\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n    http://www.apache.org/licenses/LICENSE-2.0\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\nimport { type StatsReportEmitter } from \"./statsReportEmitter.ts\";\nimport { type CallStatsReportSummary } from \"./callStatsReportSummary.ts\";\nimport { type SummaryStatsReport } from \"./statsReport.ts\";\nimport { type ParticipantState } from \"../groupCall.ts\";\nimport { type RoomMember } from \"../../matrix.ts\";\n\ninterface CallStatsReportSummaryCounter {\n    receivedAudio: number;\n    receivedVideo: number;\n    receivedMedia: number;\n    concealedAudio: number;\n    totalAudio: number;\n}\n\nexport class SummaryStatsReportGatherer {\n    public constructor(private emitter: StatsReportEmitter) {}\n\n    public build(allSummary: CallStatsReportSummary[]): void {\n        // Filter all stats which collect the first time webrtc stats.\n        // Because stats based on time interval and the first collection of a summery stats has no previous\n        // webrtcStats as basement all the calculation are 0. We don't want track the 0 stats.\n        const summary = allSummary.filter((s) => !s.isFirstCollection);\n        const summaryTotalCount = summary.length;\n        // For counting the peer connections we also want to consider the ignored summaries\n        const peerConnectionsCount = allSummary.length;\n        if (summaryTotalCount === 0) {\n            return;\n        }\n\n        const summaryCounter: CallStatsReportSummaryCounter = {\n            receivedAudio: 0,\n            receivedVideo: 0,\n            receivedMedia: 0,\n            concealedAudio: 0,\n            totalAudio: 0,\n        };\n        let maxJitter = 0;\n        let maxPacketLoss = 0;\n        summary.forEach((stats) => {\n            this.countTrackListReceivedMedia(summaryCounter, stats);\n            this.countConcealedAudio(summaryCounter, stats);\n            maxJitter = this.buildMaxJitter(maxJitter, stats);\n            maxPacketLoss = this.buildMaxPacketLoss(maxPacketLoss, stats);\n        });\n        const decimalPlaces = 5;\n        const report = {\n            percentageReceivedMedia: Number((summaryCounter.receivedMedia / summaryTotalCount).toFixed(decimalPlaces)),\n            percentageReceivedVideoMedia: Number(\n                (summaryCounter.receivedVideo / summaryTotalCount).toFixed(decimalPlaces),\n            ),\n            percentageReceivedAudioMedia: Number(\n                (summaryCounter.receivedAudio / summaryTotalCount).toFixed(decimalPlaces),\n            ),\n            maxJitter,\n            maxPacketLoss,\n            percentageConcealedAudio: Number(\n                summaryCounter.totalAudio > 0\n                    ? (summaryCounter.concealedAudio / summaryCounter.totalAudio).toFixed(decimalPlaces)\n                    : 0,\n            ),\n            peerConnections: peerConnectionsCount,\n        } as SummaryStatsReport;\n        this.emitter.emitSummaryStatsReport(report);\n    }\n\n    public static extendSummaryReport(\n        report: SummaryStatsReport,\n        callParticipants: Map<RoomMember, Map<string, ParticipantState>>,\n    ): void {\n        // Calculate the actual number of devices based on the participants state event\n        // (this is used, to compare the expected participant count from the room state with the acutal peer connections)\n        // const devices = callParticipants.()\n        const devices: [string, ParticipantState][] = [];\n        const users: [RoomMember, Map<string, ParticipantState>][] = [];\n        for (const userEntry of callParticipants) {\n            users.push(userEntry);\n            for (const device of userEntry[1]) {\n                devices.push(device);\n            }\n        }\n        report.opponentDevicesInCall = Math.max(0, devices.length - 1);\n        report.opponentUsersInCall = Math.max(0, users.length - 1);\n        report.diffDevicesToPeerConnections = Math.max(0, devices.length - 1) - report.peerConnections;\n        report.ratioPeerConnectionToDevices =\n            Math.max(0, devices.length - 1) == 0 ? 0 : report.peerConnections / (devices.length - 1);\n    }\n\n    private countTrackListReceivedMedia(counter: CallStatsReportSummaryCounter, stats: CallStatsReportSummary): void {\n        let hasReceivedAudio = false;\n        let hasReceivedVideo = false;\n        if (stats.receivedAudioMedia > 0 || stats.audioTrackSummary.count === 0) {\n            counter.receivedAudio++;\n            hasReceivedAudio = true;\n        }\n        if (stats.receivedVideoMedia > 0 || stats.videoTrackSummary.count === 0) {\n            counter.receivedVideo++;\n            hasReceivedVideo = true;\n        } else {\n            if (stats.videoTrackSummary.muted > 0 && stats.videoTrackSummary.muted === stats.videoTrackSummary.count) {\n                counter.receivedVideo++;\n                hasReceivedVideo = true;\n            }\n        }\n\n        if (hasReceivedVideo && hasReceivedAudio) {\n            counter.receivedMedia++;\n        }\n    }\n\n    private buildMaxJitter(maxJitter: number, stats: CallStatsReportSummary): number {\n        if (maxJitter < stats.videoTrackSummary.maxJitter) {\n            maxJitter = stats.videoTrackSummary.maxJitter;\n        }\n\n        if (maxJitter < stats.audioTrackSummary.maxJitter) {\n            maxJitter = stats.audioTrackSummary.maxJitter;\n        }\n        return maxJitter;\n    }\n\n    private buildMaxPacketLoss(maxPacketLoss: number, stats: CallStatsReportSummary): number {\n        if (maxPacketLoss < stats.videoTrackSummary.maxPacketLoss) {\n            maxPacketLoss = stats.videoTrackSummary.maxPacketLoss;\n        }\n\n        if (maxPacketLoss < stats.audioTrackSummary.maxPacketLoss) {\n            maxPacketLoss = stats.audioTrackSummary.maxPacketLoss;\n        }\n        return maxPacketLoss;\n    }\n\n    private countConcealedAudio(summaryCounter: CallStatsReportSummaryCounter, stats: CallStatsReportSummary): void {\n        summaryCounter.concealedAudio += stats.audioTrackSummary.concealedAudio;\n        summaryCounter.totalAudio += stats.audioTrackSummary.totalAudio;\n    }\n}\n","/*\nCopyright 2023 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\nimport { CallStatsReportGatherer } from \"./callStatsReportGatherer.ts\";\nimport { StatsReportEmitter } from \"./statsReportEmitter.ts\";\nimport { type CallStatsReportSummary } from \"./callStatsReportSummary.ts\";\nimport { SummaryStatsReportGatherer } from \"./summaryStatsReportGatherer.ts\";\nimport { logger } from \"../../logger.ts\";\n\nexport class GroupCallStats {\n    private timer: undefined | ReturnType<typeof setTimeout>;\n    private readonly gatherers: Map<string, CallStatsReportGatherer> = new Map<string, CallStatsReportGatherer>();\n    public readonly reports = new StatsReportEmitter();\n    private readonly summaryStatsReportGatherer = new SummaryStatsReportGatherer(this.reports);\n\n    public constructor(\n        private groupCallId: string,\n        private userId: string,\n        private interval: number = 10000,\n    ) {}\n\n    public start(): void {\n        if (this.timer === undefined && this.interval > 0) {\n            this.timer = setInterval(() => {\n                this.processStats();\n            }, this.interval);\n        }\n    }\n\n    public stop(): void {\n        if (this.timer !== undefined) {\n            clearInterval(this.timer);\n            this.gatherers.forEach((c) => c.stopProcessingStats());\n        }\n    }\n\n    public hasStatsReportGatherer(callId: string): boolean {\n        return this.gatherers.has(callId);\n    }\n\n    public addStatsReportGatherer(\n        callId: string,\n        opponentMemberId: string,\n        peerConnection: RTCPeerConnection,\n    ): boolean {\n        if (this.hasStatsReportGatherer(callId)) {\n            return false;\n        }\n        this.gatherers.set(callId, new CallStatsReportGatherer(callId, opponentMemberId, peerConnection, this.reports));\n        return true;\n    }\n\n    public removeStatsReportGatherer(callId: string): boolean {\n        return this.gatherers.delete(callId);\n    }\n\n    public getStatsReportGatherer(callId: string): CallStatsReportGatherer | undefined {\n        return this.hasStatsReportGatherer(callId) ? this.gatherers.get(callId) : undefined;\n    }\n\n    public updateOpponentMember(callId: string, opponentMember: string): void {\n        this.getStatsReportGatherer(callId)?.setOpponentMemberId(opponentMember);\n    }\n\n    private processStats(): void {\n        const summary: Promise<CallStatsReportSummary>[] = [];\n        this.gatherers.forEach((c) => {\n            summary.push(c.processStats(this.groupCallId, this.userId));\n        });\n\n        Promise.all(summary)\n            .then((s: Awaited<CallStatsReportSummary>[]) => this.summaryStatsReportGatherer.build(s))\n            .catch((err) => {\n                logger.error(\"Could not build summary stats report\", err);\n            });\n    }\n\n    public setInterval(interval: number): void {\n        this.interval = interval;\n    }\n}\n","import { TypedEventEmitter } from \"../models/typed-event-emitter.ts\";\nimport { CallFeed, SPEAKING_THRESHOLD } from \"./callFeed.ts\";\nimport { type MatrixClient, type IMyDevice } from \"../client.ts\";\nimport {\n    CallErrorCode,\n    CallEvent,\n    type CallEventHandlerMap,\n    CallState,\n    genCallID,\n    type MatrixCall,\n    setTracksEnabled,\n    createNewMatrixCall,\n    CallError,\n} from \"./call.ts\";\nimport { type RoomMember } from \"../models/room-member.ts\";\nimport { type Room } from \"../models/room.ts\";\nimport { RoomStateEvent } from \"../models/room-state.ts\";\nimport { logger } from \"../logger.ts\";\nimport { ReEmitter } from \"../ReEmitter.ts\";\nimport { SDPStreamMetadataPurpose } from \"./callEventTypes.ts\";\nimport { type MatrixEvent } from \"../models/event.ts\";\nimport { EventType } from \"../@types/event.ts\";\nimport { CallEventHandlerEvent } from \"./callEventHandler.ts\";\nimport { GroupCallEventHandlerEvent } from \"./groupCallEventHandler.ts\";\nimport { type IScreensharingOpts } from \"./mediaHandler.ts\";\nimport { mapsEqual } from \"../utils.ts\";\nimport { GroupCallStats } from \"./stats/groupCallStats.ts\";\nimport {\n    type ByteSentStatsReport,\n    type CallFeedReport,\n    type ConnectionStatsReport,\n    StatsReport,\n    type SummaryStatsReport,\n} from \"./stats/statsReport.ts\";\nimport { SummaryStatsReportGatherer } from \"./stats/summaryStatsReportGatherer.ts\";\nimport { CallFeedStatsReporter } from \"./stats/callFeedStatsReporter.ts\";\nimport { KnownMembership } from \"../@types/membership.ts\";\n\nexport enum GroupCallIntent {\n    Ring = \"m.ring\",\n    Prompt = \"m.prompt\",\n    Room = \"m.room\",\n}\n\nexport enum GroupCallType {\n    Video = \"m.video\",\n    Voice = \"m.voice\",\n}\n\nexport enum GroupCallTerminationReason {\n    CallEnded = \"call_ended\",\n}\n\nexport type CallsByUserAndDevice = Map<string, Map<string, MatrixCall>>;\n\n/**\n * Because event names are just strings, they do need\n * to be unique over all event types of event emitter.\n * Some objects could emit more then one set of events.\n */\nexport enum GroupCallEvent {\n    GroupCallStateChanged = \"group_call_state_changed\",\n    ActiveSpeakerChanged = \"active_speaker_changed\",\n    CallsChanged = \"calls_changed\",\n    UserMediaFeedsChanged = \"user_media_feeds_changed\",\n    ScreenshareFeedsChanged = \"screenshare_feeds_changed\",\n    LocalScreenshareStateChanged = \"local_screenshare_state_changed\",\n    LocalMuteStateChanged = \"local_mute_state_changed\",\n    ParticipantsChanged = \"participants_changed\",\n    Error = \"group_call_error\",\n}\n\nexport type GroupCallEventHandlerMap = {\n    [GroupCallEvent.GroupCallStateChanged]: (newState: GroupCallState, oldState: GroupCallState) => void;\n    [GroupCallEvent.ActiveSpeakerChanged]: (activeSpeaker: CallFeed | undefined) => void;\n    [GroupCallEvent.CallsChanged]: (calls: CallsByUserAndDevice) => void;\n    [GroupCallEvent.UserMediaFeedsChanged]: (feeds: CallFeed[]) => void;\n    [GroupCallEvent.ScreenshareFeedsChanged]: (feeds: CallFeed[]) => void;\n    [GroupCallEvent.LocalScreenshareStateChanged]: (\n        isScreensharing: boolean,\n        feed?: CallFeed,\n        sourceId?: string,\n    ) => void;\n    [GroupCallEvent.LocalMuteStateChanged]: (audioMuted: boolean, videoMuted: boolean) => void;\n    [GroupCallEvent.ParticipantsChanged]: (participants: Map<RoomMember, Map<string, ParticipantState>>) => void;\n    /**\n     * Fires whenever an error occurs when call.js encounters an issue with setting up the call.\n     * <p>\n     * The error given will have a code equal to either `MatrixCall.ERR_LOCAL_OFFER_FAILED` or\n     * `MatrixCall.ERR_NO_USER_MEDIA`. `ERR_LOCAL_OFFER_FAILED` is emitted when the local client\n     * fails to create an offer. `ERR_NO_USER_MEDIA` is emitted when the user has denied access\n     * to their audio/video hardware.\n     * @param error - The error raised by MatrixCall.\n     * @example\n     * ```\n     * matrixCall.on(\"error\", function(err){\n     *   console.error(err.code, err);\n     * });\n     * ```\n     */\n    [GroupCallEvent.Error]: (error: GroupCallError) => void;\n};\n\nexport enum GroupCallStatsReportEvent {\n    ConnectionStats = \"GroupCall.connection_stats\",\n    ByteSentStats = \"GroupCall.byte_sent_stats\",\n    SummaryStats = \"GroupCall.summary_stats\",\n    CallFeedStats = \"GroupCall.call_feed_stats\",\n}\n\n/**\n * The final report-events that get consumed by client.\n */\nexport type GroupCallStatsReportEventHandlerMap = {\n    [GroupCallStatsReportEvent.ConnectionStats]: (report: GroupCallStatsReport<ConnectionStatsReport>) => void;\n    [GroupCallStatsReportEvent.ByteSentStats]: (report: GroupCallStatsReport<ByteSentStatsReport>) => void;\n    [GroupCallStatsReportEvent.SummaryStats]: (report: GroupCallStatsReport<SummaryStatsReport>) => void;\n    [GroupCallStatsReportEvent.CallFeedStats]: (report: GroupCallStatsReport<CallFeedReport>) => void;\n};\n\nexport enum GroupCallErrorCode {\n    NoUserMedia = \"no_user_media\",\n    UnknownDevice = \"unknown_device\",\n    PlaceCallFailed = \"place_call_failed\",\n}\n\nexport interface GroupCallStatsReport<\n    T extends ConnectionStatsReport | ByteSentStatsReport | SummaryStatsReport | CallFeedReport,\n> {\n    report: T;\n}\n\nexport class GroupCallError extends Error {\n    public code: string;\n\n    public constructor(code: GroupCallErrorCode, msg: string, err?: Error) {\n        // Still don't think there's any way to have proper nested errors\n        if (err) {\n            super(msg + \": \" + err);\n        } else {\n            super(msg);\n        }\n\n        this.code = code;\n    }\n}\n\nexport class GroupCallUnknownDeviceError extends GroupCallError {\n    public constructor(public userId: string) {\n        super(GroupCallErrorCode.UnknownDevice, \"No device found for \" + userId);\n    }\n}\n\nexport class OtherUserSpeakingError extends Error {\n    public constructor() {\n        super(\"Cannot unmute: another user is speaking\");\n    }\n}\n\nexport interface IGroupCallDataChannelOptions {\n    ordered: boolean;\n    maxPacketLifeTime: number;\n    maxRetransmits: number;\n    protocol: string;\n}\n\nexport interface IGroupCallRoomState {\n    \"m.intent\": GroupCallIntent;\n    \"m.type\": GroupCallType;\n    \"m.terminated\"?: GroupCallTerminationReason;\n    \"io.element.ptt\"?: boolean;\n    // TODO: Specify data-channels\n    \"dataChannelsEnabled\"?: boolean;\n    \"dataChannelOptions\"?: IGroupCallDataChannelOptions;\n\n    \"io.element.livekit_service_url\"?: string;\n}\n\nexport interface IGroupCallRoomMemberFeed {\n    purpose: SDPStreamMetadataPurpose;\n}\n\nexport interface IGroupCallRoomMemberDevice {\n    device_id: string;\n    session_id: string;\n    expires_ts: number;\n    feeds: IGroupCallRoomMemberFeed[];\n}\n\nexport interface IGroupCallRoomMemberCallState {\n    \"m.call_id\": string;\n    \"m.foci\"?: string[];\n    \"m.devices\": IGroupCallRoomMemberDevice[];\n}\n\nexport interface IGroupCallRoomMemberState {\n    \"m.calls\": IGroupCallRoomMemberCallState[];\n}\n\nexport enum GroupCallState {\n    LocalCallFeedUninitialized = \"local_call_feed_uninitialized\",\n    InitializingLocalCallFeed = \"initializing_local_call_feed\",\n    LocalCallFeedInitialized = \"local_call_feed_initialized\",\n    Entered = \"entered\",\n    Ended = \"ended\",\n}\n\nexport interface ParticipantState {\n    sessionId: string;\n    screensharing: boolean;\n}\n\ninterface ICallHandlers {\n    onCallFeedsChanged: (feeds: CallFeed[]) => void;\n    onCallStateChanged: (state: CallState, oldState: CallState | undefined) => void;\n    onCallHangup: (call: MatrixCall) => void;\n    onCallReplaced: (newCall: MatrixCall) => void;\n}\n\nconst DEVICE_TIMEOUT = 1000 * 60 * 60; // 1 hour\n\nfunction getCallUserId(call: MatrixCall): string | null {\n    return call.getOpponentMember()?.userId || call.invitee || null;\n}\n\nexport class GroupCall extends TypedEventEmitter<\n    GroupCallEvent | CallEvent | GroupCallStatsReportEvent,\n    GroupCallEventHandlerMap & CallEventHandlerMap & GroupCallStatsReportEventHandlerMap\n> {\n    // Config\n    public activeSpeakerInterval = 1000;\n    public retryCallInterval = 5000;\n    public participantTimeout = 1000 * 15;\n    public pttMaxTransmitTime = 1000 * 20;\n\n    public activeSpeaker?: CallFeed;\n    public localCallFeed?: CallFeed;\n    public localScreenshareFeed?: CallFeed;\n    public localDesktopCapturerSourceId?: string;\n    public readonly userMediaFeeds: CallFeed[] = [];\n    public readonly screenshareFeeds: CallFeed[] = [];\n    public groupCallId: string;\n    public readonly allowCallWithoutVideoAndAudio: boolean;\n\n    private readonly calls = new Map<string, Map<string, MatrixCall>>(); // user_id -> device_id -> MatrixCall\n    private callHandlers = new Map<string, Map<string, ICallHandlers>>(); // user_id -> device_id -> ICallHandlers\n    private activeSpeakerLoopInterval?: ReturnType<typeof setTimeout>;\n    private retryCallLoopInterval?: ReturnType<typeof setTimeout>;\n    private retryCallCounts: Map<string, Map<string, number>> = new Map(); // user_id -> device_id -> count\n    private reEmitter: ReEmitter;\n    private transmitTimer: ReturnType<typeof setTimeout> | null = null;\n    private participantsExpirationTimer: ReturnType<typeof setTimeout> | null = null;\n    private resendMemberStateTimer: ReturnType<typeof setInterval> | null = null;\n    private initWithAudioMuted = false;\n    private initWithVideoMuted = false;\n    private initCallFeedPromise?: Promise<void>;\n    private _livekitServiceURL?: string;\n\n    private stats: GroupCallStats | undefined;\n    /**\n     * Configure default webrtc stats collection interval in ms\n     * Disable collecting webrtc stats by setting interval to 0\n     */\n    private statsCollectIntervalTime = 0;\n\n    public constructor(\n        private client: MatrixClient,\n        public room: Room,\n        public type: GroupCallType,\n        public isPtt: boolean,\n        public intent: GroupCallIntent,\n        groupCallId?: string,\n        private dataChannelsEnabled?: boolean,\n        private dataChannelOptions?: IGroupCallDataChannelOptions,\n        isCallWithoutVideoAndAudio?: boolean,\n        // this tells the js-sdk not to actually establish any calls to exchange media and just to\n        // create the group call signaling events, with the intention that the actual media will be\n        // handled using livekit. The js-sdk doesn't contain any code to do the actual livekit call though.\n        private useLivekit = false,\n        livekitServiceURL?: string,\n    ) {\n        super();\n        this.reEmitter = new ReEmitter(this);\n        this.groupCallId = groupCallId ?? genCallID();\n        this._livekitServiceURL = livekitServiceURL;\n        this.creationTs =\n            room.currentState.getStateEvents(EventType.GroupCallPrefix, this.groupCallId)?.getTs() ?? null;\n        this.updateParticipants();\n\n        room.on(RoomStateEvent.Update, this.onRoomState);\n        this.on(GroupCallEvent.ParticipantsChanged, this.onParticipantsChanged);\n        this.on(GroupCallEvent.GroupCallStateChanged, this.onStateChanged);\n        this.on(GroupCallEvent.LocalScreenshareStateChanged, this.onLocalFeedsChanged);\n        this.allowCallWithoutVideoAndAudio = !!isCallWithoutVideoAndAudio;\n    }\n\n    private onConnectionStats = (report: ConnectionStatsReport): void => {\n        // Final emit of the summary event, to be consumed by the client\n        this.emit(GroupCallStatsReportEvent.ConnectionStats, { report });\n    };\n\n    private onByteSentStats = (report: ByteSentStatsReport): void => {\n        // Final emit of the summary event, to be consumed by the client\n        this.emit(GroupCallStatsReportEvent.ByteSentStats, { report });\n    };\n\n    private onSummaryStats = (report: SummaryStatsReport): void => {\n        SummaryStatsReportGatherer.extendSummaryReport(report, this.participants);\n        // Final emit of the summary event, to be consumed by the client\n        this.emit(GroupCallStatsReportEvent.SummaryStats, { report });\n    };\n\n    private onCallFeedReport = (report: CallFeedReport): void => {\n        if (this.localCallFeed) {\n            report = CallFeedStatsReporter.expandCallFeedReport(report, [this.localCallFeed], \"from-local-feed\");\n        }\n\n        const callFeeds: CallFeed[] = [];\n        this.forEachCall((call) => {\n            if (call.callId === report.callId) {\n                call.getFeeds().forEach((f) => callFeeds.push(f));\n            }\n        });\n\n        report = CallFeedStatsReporter.expandCallFeedReport(report, callFeeds, \"from-call-feed\");\n        this.emit(GroupCallStatsReportEvent.CallFeedStats, { report });\n    };\n\n    public async create(): Promise<GroupCall> {\n        this.creationTs = Date.now();\n        this.client.groupCallEventHandler!.groupCalls.set(this.room.roomId, this);\n        this.client.emit(GroupCallEventHandlerEvent.Outgoing, this);\n\n        await this.sendCallStateEvent();\n\n        return this;\n    }\n\n    private async sendCallStateEvent(): Promise<void> {\n        const groupCallState: IGroupCallRoomState = {\n            \"m.intent\": this.intent,\n            \"m.type\": this.type,\n            \"io.element.ptt\": this.isPtt,\n            // TODO: Specify data-channels better\n            \"dataChannelsEnabled\": this.dataChannelsEnabled,\n            \"dataChannelOptions\": this.dataChannelsEnabled ? this.dataChannelOptions : undefined,\n        };\n        if (this.livekitServiceURL) {\n            groupCallState[\"io.element.livekit_service_url\"] = this.livekitServiceURL;\n        }\n\n        await this.client.sendStateEvent(this.room.roomId, EventType.GroupCallPrefix, groupCallState, this.groupCallId);\n    }\n\n    public get livekitServiceURL(): string | undefined {\n        return this._livekitServiceURL;\n    }\n\n    public updateLivekitServiceURL(newURL: string): Promise<void> {\n        this._livekitServiceURL = newURL;\n        return this.sendCallStateEvent();\n    }\n\n    private _state = GroupCallState.LocalCallFeedUninitialized;\n\n    /**\n     * The group call's state.\n     */\n    public get state(): GroupCallState {\n        return this._state;\n    }\n\n    private set state(value: GroupCallState) {\n        const prevValue = this._state;\n        if (value !== prevValue) {\n            this._state = value;\n            this.emit(GroupCallEvent.GroupCallStateChanged, value, prevValue);\n        }\n    }\n\n    private _participants = new Map<RoomMember, Map<string, ParticipantState>>();\n\n    /**\n     * The current participants in the call, as a map from members to device IDs\n     * to participant info.\n     */\n    public get participants(): Map<RoomMember, Map<string, ParticipantState>> {\n        return this._participants;\n    }\n\n    private set participants(value: Map<RoomMember, Map<string, ParticipantState>>) {\n        const prevValue = this._participants;\n        const participantStateEqual = (x: ParticipantState, y: ParticipantState): boolean =>\n            x.sessionId === y.sessionId && x.screensharing === y.screensharing;\n        const deviceMapsEqual = (x: Map<string, ParticipantState>, y: Map<string, ParticipantState>): boolean =>\n            mapsEqual(x, y, participantStateEqual);\n\n        // Only update if the map actually changed\n        if (!mapsEqual(value, prevValue, deviceMapsEqual)) {\n            this._participants = value;\n            this.emit(GroupCallEvent.ParticipantsChanged, value);\n        }\n    }\n\n    private _creationTs: number | null = null;\n\n    /**\n     * The timestamp at which the call was created, or null if it has not yet\n     * been created.\n     */\n    public get creationTs(): number | null {\n        return this._creationTs;\n    }\n\n    private set creationTs(value: number | null) {\n        this._creationTs = value;\n    }\n\n    private _enteredViaAnotherSession = false;\n\n    /**\n     * Whether the local device has entered this call via another session, such\n     * as a widget.\n     */\n    public get enteredViaAnotherSession(): boolean {\n        return this._enteredViaAnotherSession;\n    }\n\n    public set enteredViaAnotherSession(value: boolean) {\n        this._enteredViaAnotherSession = value;\n        this.updateParticipants();\n    }\n\n    /**\n     * Executes the given callback on all calls in this group call.\n     * @param f - The callback.\n     */\n    public forEachCall(f: (call: MatrixCall) => void): void {\n        for (const deviceMap of this.calls.values()) {\n            for (const call of deviceMap.values()) f(call);\n        }\n    }\n\n    public getLocalFeeds(): CallFeed[] {\n        const feeds: CallFeed[] = [];\n\n        if (this.localCallFeed) feeds.push(this.localCallFeed);\n        if (this.localScreenshareFeed) feeds.push(this.localScreenshareFeed);\n\n        return feeds;\n    }\n\n    public hasLocalParticipant(): boolean {\n        return (\n            this.participants.get(this.room.getMember(this.client.getUserId()!)!)?.has(this.client.getDeviceId()!) ??\n            false\n        );\n    }\n\n    /**\n     * Determines whether the given call is one that we were expecting to exist\n     * given our knowledge of who is participating in the group call.\n     */\n    private callExpected(call: MatrixCall): boolean {\n        const userId = getCallUserId(call);\n        const member = userId === null ? null : this.room.getMember(userId);\n        const deviceId = call.getOpponentDeviceId();\n        return member !== null && deviceId !== undefined && this.participants.get(member)?.get(deviceId) !== undefined;\n    }\n\n    public async initLocalCallFeed(): Promise<void> {\n        if (this.useLivekit) {\n            logger.info(\"Livekit group call: not starting local call feed.\");\n            return;\n        }\n\n        if (this.state !== GroupCallState.LocalCallFeedUninitialized) {\n            throw new Error(`Cannot initialize local call feed in the \"${this.state}\" state.`);\n        }\n        this.state = GroupCallState.InitializingLocalCallFeed;\n\n        // wraps the real method to serialise calls, because we don't want to try starting\n        // multiple call feeds at once\n        if (this.initCallFeedPromise) return this.initCallFeedPromise;\n\n        try {\n            this.initCallFeedPromise = this.initLocalCallFeedInternal();\n            await this.initCallFeedPromise;\n        } finally {\n            this.initCallFeedPromise = undefined;\n        }\n    }\n\n    private async initLocalCallFeedInternal(): Promise<void> {\n        logger.log(`GroupCall ${this.groupCallId} initLocalCallFeedInternal() running`);\n\n        let stream: MediaStream;\n\n        try {\n            stream = await this.client.getMediaHandler().getUserMediaStream(true, this.type === GroupCallType.Video);\n        } catch (error) {\n            // If is allowed to join a call without a media stream, then we\n            // don't throw an error here. But we need an empty Local Feed to establish\n            // a connection later.\n            if (this.allowCallWithoutVideoAndAudio) {\n                stream = new MediaStream();\n            } else {\n                this.state = GroupCallState.LocalCallFeedUninitialized;\n                throw error;\n            }\n        }\n\n        // The call could've been disposed while we were waiting, and could\n        // also have been started back up again (hello, React 18) so if we're\n        // still in this 'initializing' state, carry on, otherwise bail.\n        if (this._state !== GroupCallState.InitializingLocalCallFeed) {\n            this.client.getMediaHandler().stopUserMediaStream(stream);\n            throw new Error(\"Group call disposed while gathering media stream\");\n        }\n\n        const callFeed = new CallFeed({\n            client: this.client,\n            roomId: this.room.roomId,\n            userId: this.client.getUserId()!,\n            deviceId: this.client.getDeviceId()!,\n            stream,\n            purpose: SDPStreamMetadataPurpose.Usermedia,\n            audioMuted: this.initWithAudioMuted || stream.getAudioTracks().length === 0 || this.isPtt,\n            videoMuted: this.initWithVideoMuted || stream.getVideoTracks().length === 0,\n        });\n\n        setTracksEnabled(stream.getAudioTracks(), !callFeed.isAudioMuted());\n        setTracksEnabled(stream.getVideoTracks(), !callFeed.isVideoMuted());\n\n        this.localCallFeed = callFeed;\n        this.addUserMediaFeed(callFeed);\n\n        this.state = GroupCallState.LocalCallFeedInitialized;\n    }\n\n    public async updateLocalUsermediaStream(stream: MediaStream): Promise<void> {\n        if (this.localCallFeed) {\n            const oldStream = this.localCallFeed.stream;\n            this.localCallFeed.setNewStream(stream);\n            const micShouldBeMuted = this.localCallFeed.isAudioMuted();\n            const vidShouldBeMuted = this.localCallFeed.isVideoMuted();\n            logger.log(\n                `GroupCall ${this.groupCallId} updateLocalUsermediaStream() (oldStreamId=${oldStream.id}, newStreamId=${stream.id}, micShouldBeMuted=${micShouldBeMuted}, vidShouldBeMuted=${vidShouldBeMuted})`,\n            );\n            setTracksEnabled(stream.getAudioTracks(), !micShouldBeMuted);\n            setTracksEnabled(stream.getVideoTracks(), !vidShouldBeMuted);\n            this.client.getMediaHandler().stopUserMediaStream(oldStream);\n        }\n    }\n\n    public async enter(): Promise<void> {\n        if (this.state === GroupCallState.LocalCallFeedUninitialized) {\n            await this.initLocalCallFeed();\n        } else if (this.state !== GroupCallState.LocalCallFeedInitialized) {\n            throw new Error(`Cannot enter call in the \"${this.state}\" state`);\n        }\n\n        logger.log(`GroupCall ${this.groupCallId} enter() running`);\n        this.state = GroupCallState.Entered;\n\n        this.client.on(CallEventHandlerEvent.Incoming, this.onIncomingCall);\n\n        for (const call of this.client.callEventHandler!.calls.values()) {\n            this.onIncomingCall(call);\n        }\n\n        if (!this.useLivekit) {\n            this.retryCallLoopInterval = setInterval(this.onRetryCallLoop, this.retryCallInterval);\n\n            this.activeSpeaker = undefined;\n            this.onActiveSpeakerLoop();\n            this.activeSpeakerLoopInterval = setInterval(this.onActiveSpeakerLoop, this.activeSpeakerInterval);\n        }\n    }\n\n    private dispose(): void {\n        if (this.localCallFeed) {\n            this.removeUserMediaFeed(this.localCallFeed);\n            this.localCallFeed = undefined;\n        }\n\n        if (this.localScreenshareFeed) {\n            this.client.getMediaHandler().stopScreensharingStream(this.localScreenshareFeed.stream);\n            this.removeScreenshareFeed(this.localScreenshareFeed);\n            this.localScreenshareFeed = undefined;\n            this.localDesktopCapturerSourceId = undefined;\n        }\n\n        this.client.getMediaHandler().stopAllStreams();\n\n        if (this.transmitTimer !== null) {\n            clearTimeout(this.transmitTimer);\n            this.transmitTimer = null;\n        }\n\n        if (this.retryCallLoopInterval !== undefined) {\n            clearInterval(this.retryCallLoopInterval);\n            this.retryCallLoopInterval = undefined;\n        }\n\n        if (this.participantsExpirationTimer !== null) {\n            clearTimeout(this.participantsExpirationTimer);\n            this.participantsExpirationTimer = null;\n        }\n\n        if (this.state !== GroupCallState.Entered) {\n            return;\n        }\n\n        this.forEachCall((call) => call.hangup(CallErrorCode.UserHangup, false));\n\n        this.activeSpeaker = undefined;\n        clearInterval(this.activeSpeakerLoopInterval);\n\n        this.retryCallCounts.clear();\n        clearInterval(this.retryCallLoopInterval);\n\n        this.client.removeListener(CallEventHandlerEvent.Incoming, this.onIncomingCall);\n        this.stats?.stop();\n    }\n\n    public leave(): void {\n        this.dispose();\n        this.state = GroupCallState.LocalCallFeedUninitialized;\n    }\n\n    public async terminate(emitStateEvent = true): Promise<void> {\n        this.dispose();\n\n        this.room.off(RoomStateEvent.Update, this.onRoomState);\n        this.client.groupCallEventHandler!.groupCalls.delete(this.room.roomId);\n        this.client.emit(GroupCallEventHandlerEvent.Ended, this);\n        this.state = GroupCallState.Ended;\n\n        if (emitStateEvent) {\n            const existingStateEvent = this.room.currentState.getStateEvents(\n                EventType.GroupCallPrefix,\n                this.groupCallId,\n            )!;\n\n            await this.client.sendStateEvent(\n                this.room.roomId,\n                EventType.GroupCallPrefix,\n                {\n                    ...existingStateEvent.getContent(),\n                    \"m.terminated\": GroupCallTerminationReason.CallEnded,\n                },\n                this.groupCallId,\n            );\n        }\n    }\n\n    /*\n     * Local Usermedia\n     */\n\n    public isLocalVideoMuted(): boolean {\n        if (this.localCallFeed) {\n            return this.localCallFeed.isVideoMuted();\n        }\n\n        return true;\n    }\n\n    public isMicrophoneMuted(): boolean {\n        if (this.localCallFeed) {\n            return this.localCallFeed.isAudioMuted();\n        }\n\n        return true;\n    }\n\n    /**\n     * Sets the mute state of the local participants's microphone.\n     * @param muted - Whether to mute the microphone\n     * @returns Whether muting/unmuting was successful\n     */\n    public async setMicrophoneMuted(muted: boolean): Promise<boolean> {\n        // hasAudioDevice can block indefinitely if the window has lost focus,\n        // and it doesn't make much sense to keep a device from being muted, so\n        // we always allow muted = true changes to go through\n        if (!muted && !(await this.client.getMediaHandler().hasAudioDevice())) {\n            return false;\n        }\n\n        const sendUpdatesBefore = !muted && this.isPtt;\n\n        // set a timer for the maximum transmit time on PTT calls\n        if (this.isPtt) {\n            // Set or clear the max transmit timer\n            if (!muted && this.isMicrophoneMuted()) {\n                this.transmitTimer = setTimeout(() => {\n                    this.setMicrophoneMuted(true);\n                }, this.pttMaxTransmitTime);\n            } else if (muted && !this.isMicrophoneMuted()) {\n                if (this.transmitTimer !== null) clearTimeout(this.transmitTimer);\n                this.transmitTimer = null;\n            }\n        }\n\n        this.forEachCall((call) => call.localUsermediaFeed?.setAudioVideoMuted(muted, null));\n\n        const sendUpdates = async (): Promise<void> => {\n            const updates: Promise<void>[] = [];\n            this.forEachCall((call) => updates.push(call.sendMetadataUpdate()));\n\n            await Promise.all(updates).catch((e) =>\n                logger.info(\n                    `GroupCall ${this.groupCallId} setMicrophoneMuted() failed to send some metadata updates`,\n                    e,\n                ),\n            );\n        };\n\n        if (sendUpdatesBefore) await sendUpdates();\n\n        if (this.localCallFeed) {\n            logger.log(\n                `GroupCall ${this.groupCallId} setMicrophoneMuted() (streamId=${this.localCallFeed.stream.id}, muted=${muted})`,\n            );\n\n            const hasPermission = await this.checkAudioPermissionIfNecessary(muted);\n\n            if (!hasPermission) {\n                return false;\n            }\n\n            this.localCallFeed.setAudioVideoMuted(muted, null);\n            // I don't believe its actually necessary to enable these tracks: they\n            // are the one on the GroupCall's own CallFeed and are cloned before being\n            // given to any of the actual calls, so these tracks don't actually go\n            // anywhere. Let's do it anyway to avoid confusion.\n            setTracksEnabled(this.localCallFeed.stream.getAudioTracks(), !muted);\n        } else {\n            logger.log(`GroupCall ${this.groupCallId} setMicrophoneMuted() no stream muted (muted=${muted})`);\n            this.initWithAudioMuted = muted;\n        }\n\n        this.forEachCall((call) =>\n            setTracksEnabled(call.localUsermediaFeed!.stream.getAudioTracks(), !muted && this.callExpected(call)),\n        );\n        this.emit(GroupCallEvent.LocalMuteStateChanged, muted, this.isLocalVideoMuted());\n\n        if (!sendUpdatesBefore) await sendUpdates();\n\n        return true;\n    }\n\n    /**\n     * If we allow entering a call without a camera and without video, it can happen that the access rights to the\n     * devices have not yet been queried. If a stream does not yet have an audio track, we assume that the rights have\n     * not yet been checked.\n     *\n     * `this.client.getMediaHandler().getUserMediaStream` clones the current stream, so it only wanted to be called when\n     * not Audio Track exists.\n     * As such, this is a compromise, because, the access rights should always be queried before the call.\n     */\n    private async checkAudioPermissionIfNecessary(muted: boolean): Promise<boolean> {\n        // We needed this here to avoid an error in case user join a call without a device.\n        try {\n            if (!muted && this.localCallFeed && !this.localCallFeed.hasAudioTrack) {\n                const stream = await this.client\n                    .getMediaHandler()\n                    .getUserMediaStream(true, !this.localCallFeed.isVideoMuted());\n                if (stream?.getTracks().length === 0) {\n                    // if case permission denied to get a stream stop this here\n                    /* istanbul ignore next */\n                    logger.log(\n                        `GroupCall ${this.groupCallId} setMicrophoneMuted() no device to receive local stream, muted=${muted}`,\n                    );\n                    return false;\n                }\n            }\n        } catch {\n            /* istanbul ignore next */\n            logger.log(\n                `GroupCall ${this.groupCallId} setMicrophoneMuted() no device or permission to receive local stream, muted=${muted}`,\n            );\n            return false;\n        }\n\n        return true;\n    }\n\n    /**\n     * Sets the mute state of the local participants's video.\n     * @param muted - Whether to mute the video\n     * @returns Whether muting/unmuting was successful\n     */\n    public async setLocalVideoMuted(muted: boolean): Promise<boolean> {\n        // hasAudioDevice can block indefinitely if the window has lost focus,\n        // and it doesn't make much sense to keep a device from being muted, so\n        // we always allow muted = true changes to go through\n        if (!muted && !(await this.client.getMediaHandler().hasVideoDevice())) {\n            return false;\n        }\n\n        if (this.localCallFeed) {\n            /* istanbul ignore next */\n            logger.log(\n                `GroupCall ${this.groupCallId} setLocalVideoMuted() (stream=${this.localCallFeed.stream.id}, muted=${muted})`,\n            );\n\n            try {\n                const stream = await this.client.getMediaHandler().getUserMediaStream(true, !muted);\n                await this.updateLocalUsermediaStream(stream);\n                this.localCallFeed.setAudioVideoMuted(null, muted);\n                setTracksEnabled(this.localCallFeed.stream.getVideoTracks(), !muted);\n            } catch {\n                // No permission to video device\n                /* istanbul ignore next */\n                logger.log(\n                    `GroupCall ${this.groupCallId} setLocalVideoMuted() no device or permission to receive local stream, muted=${muted}`,\n                );\n                return false;\n            }\n        } else {\n            logger.log(`GroupCall ${this.groupCallId} setLocalVideoMuted() no stream muted (muted=${muted})`);\n            this.initWithVideoMuted = muted;\n        }\n\n        const updates: Promise<unknown>[] = [];\n        this.forEachCall((call) => updates.push(call.setLocalVideoMuted(muted)));\n        await Promise.all(updates);\n\n        // We setTracksEnabled again, independently from the call doing it\n        // internally, since we might not be expecting the call\n        this.forEachCall((call) =>\n            setTracksEnabled(call.localUsermediaFeed!.stream.getVideoTracks(), !muted && this.callExpected(call)),\n        );\n\n        this.emit(GroupCallEvent.LocalMuteStateChanged, this.isMicrophoneMuted(), muted);\n\n        return true;\n    }\n\n    public async setScreensharingEnabled(enabled: boolean, opts: IScreensharingOpts = {}): Promise<boolean> {\n        if (enabled === this.isScreensharing()) {\n            return enabled;\n        }\n\n        if (enabled) {\n            try {\n                logger.log(\n                    `GroupCall ${this.groupCallId} setScreensharingEnabled() is asking for screensharing permissions`,\n                );\n                const stream = await this.client.getMediaHandler().getScreensharingStream(opts);\n\n                for (const track of stream.getTracks()) {\n                    const onTrackEnded = (): void => {\n                        this.setScreensharingEnabled(false);\n                        track.removeEventListener(\"ended\", onTrackEnded);\n                    };\n\n                    track.addEventListener(\"ended\", onTrackEnded);\n                }\n\n                logger.log(\n                    `GroupCall ${this.groupCallId} setScreensharingEnabled() granted screensharing permissions. Setting screensharing enabled on all calls`,\n                );\n\n                this.localDesktopCapturerSourceId = opts.desktopCapturerSourceId;\n                this.localScreenshareFeed = new CallFeed({\n                    client: this.client,\n                    roomId: this.room.roomId,\n                    userId: this.client.getUserId()!,\n                    deviceId: this.client.getDeviceId()!,\n                    stream,\n                    purpose: SDPStreamMetadataPurpose.Screenshare,\n                    audioMuted: false,\n                    videoMuted: false,\n                });\n                this.addScreenshareFeed(this.localScreenshareFeed);\n\n                this.emit(\n                    GroupCallEvent.LocalScreenshareStateChanged,\n                    true,\n                    this.localScreenshareFeed,\n                    this.localDesktopCapturerSourceId,\n                );\n\n                // TODO: handle errors\n                this.forEachCall((call) => call.pushLocalFeed(this.localScreenshareFeed!.clone()));\n\n                return true;\n            } catch (error) {\n                if (opts.throwOnFail) throw error;\n                logger.error(\n                    `GroupCall ${this.groupCallId} setScreensharingEnabled() enabling screensharing error`,\n                    error,\n                );\n                this.emit(\n                    GroupCallEvent.Error,\n                    new GroupCallError(\n                        GroupCallErrorCode.NoUserMedia,\n                        \"Failed to get screen-sharing stream: \",\n                        error as Error,\n                    ),\n                );\n                return false;\n            }\n        } else {\n            this.forEachCall((call) => {\n                if (call.localScreensharingFeed) call.removeLocalFeed(call.localScreensharingFeed);\n            });\n            this.client.getMediaHandler().stopScreensharingStream(this.localScreenshareFeed!.stream);\n            this.removeScreenshareFeed(this.localScreenshareFeed!);\n            this.localScreenshareFeed = undefined;\n            this.localDesktopCapturerSourceId = undefined;\n            this.emit(GroupCallEvent.LocalScreenshareStateChanged, false, undefined, undefined);\n            return false;\n        }\n    }\n\n    public isScreensharing(): boolean {\n        return !!this.localScreenshareFeed;\n    }\n\n    /*\n     * Call Setup\n     *\n     * There are two different paths for calls to be created:\n     * 1. Incoming calls triggered by the Call.incoming event.\n     * 2. Outgoing calls to the initial members of a room or new members\n     *    as they are observed by the RoomState.members event.\n     */\n\n    private onIncomingCall = (newCall: MatrixCall): void => {\n        // The incoming calls may be for another room, which we will ignore.\n        if (newCall.roomId !== this.room.roomId) {\n            return;\n        }\n\n        if (newCall.state !== CallState.Ringing) {\n            logger.warn(\n                `GroupCall ${this.groupCallId} onIncomingCall() incoming call no longer in ringing state - ignoring`,\n            );\n            return;\n        }\n\n        if (!newCall.groupCallId || newCall.groupCallId !== this.groupCallId) {\n            logger.log(\n                `GroupCall ${this.groupCallId} onIncomingCall() ignored because it doesn't match the current group call`,\n            );\n            newCall.reject();\n            return;\n        }\n\n        const opponentUserId = newCall.getOpponentMember()?.userId;\n        if (opponentUserId === undefined) {\n            logger.warn(`GroupCall ${this.groupCallId} onIncomingCall() incoming call with no member - ignoring`);\n            return;\n        }\n\n        if (this.useLivekit) {\n            logger.info(\"Received incoming call whilst in signaling-only mode! Ignoring.\");\n            return;\n        }\n\n        const deviceMap = this.calls.get(opponentUserId) ?? new Map<string, MatrixCall>();\n        const prevCall = deviceMap.get(newCall.getOpponentDeviceId()!);\n\n        if (prevCall?.callId === newCall.callId) return;\n\n        logger.log(\n            `GroupCall ${this.groupCallId} onIncomingCall() incoming call (userId=${opponentUserId}, callId=${newCall.callId})`,\n        );\n\n        if (prevCall) prevCall.hangup(CallErrorCode.Replaced, false);\n        // We must do this before we start initialising / answering the call as we\n        // need to know it is the active call for this user+deviceId and to not ignore\n        // events from it.\n        deviceMap.set(newCall.getOpponentDeviceId()!, newCall);\n        this.calls.set(opponentUserId, deviceMap);\n\n        this.initCall(newCall);\n\n        const feeds = this.getLocalFeeds().map((feed) => feed.clone());\n        if (!this.callExpected(newCall)) {\n            // Disable our tracks for users not explicitly participating in the\n            // call but trying to receive the feeds\n            for (const feed of feeds) {\n                setTracksEnabled(feed.stream.getAudioTracks(), false);\n                setTracksEnabled(feed.stream.getVideoTracks(), false);\n            }\n        }\n        newCall.answerWithCallFeeds(feeds);\n\n        this.emit(GroupCallEvent.CallsChanged, this.calls);\n    };\n\n    /**\n     * Determines whether a given participant expects us to call them (versus\n     * them calling us).\n     * @param userId - The participant's user ID.\n     * @param deviceId - The participant's device ID.\n     * @returns Whether we need to place an outgoing call to the participant.\n     */\n    private wantsOutgoingCall(userId: string, deviceId: string): boolean {\n        const localUserId = this.client.getUserId()!;\n        const localDeviceId = this.client.getDeviceId()!;\n        return (\n            // If a user's ID is less than our own, they'll call us\n            userId >= localUserId &&\n            // If this is another one of our devices, compare device IDs to tell whether it'll call us\n            (userId !== localUserId || deviceId > localDeviceId)\n        );\n    }\n\n    /**\n     * Places calls to all participants that we're responsible for calling.\n     */\n    private placeOutgoingCalls(): void {\n        let callsChanged = false;\n\n        for (const [{ userId }, participantMap] of this.participants) {\n            const callMap = this.calls.get(userId) ?? new Map<string, MatrixCall>();\n\n            for (const [deviceId, participant] of participantMap) {\n                const prevCall = callMap.get(deviceId);\n\n                if (\n                    prevCall?.getOpponentSessionId() !== participant.sessionId &&\n                    this.wantsOutgoingCall(userId, deviceId)\n                ) {\n                    callsChanged = true;\n\n                    if (prevCall !== undefined) {\n                        logger.debug(\n                            `GroupCall ${this.groupCallId} placeOutgoingCalls() replacing call (userId=${userId}, deviceId=${deviceId}, callId=${prevCall.callId})`,\n                        );\n                        prevCall.hangup(CallErrorCode.NewSession, false);\n                    }\n\n                    const newCall = createNewMatrixCall(this.client, this.room.roomId, {\n                        invitee: userId,\n                        opponentDeviceId: deviceId,\n                        opponentSessionId: participant.sessionId,\n                        groupCallId: this.groupCallId,\n                    });\n\n                    if (newCall === null) {\n                        logger.error(\n                            `GroupCall ${this.groupCallId} placeOutgoingCalls() failed to create call (userId=${userId}, device=${deviceId})`,\n                        );\n                        callMap.delete(deviceId);\n                    } else {\n                        this.initCall(newCall);\n                        callMap.set(deviceId, newCall);\n\n                        logger.debug(\n                            `GroupCall ${this.groupCallId} placeOutgoingCalls() placing call (userId=${userId}, deviceId=${deviceId}, sessionId=${participant.sessionId})`,\n                        );\n\n                        newCall\n                            .placeCallWithCallFeeds(\n                                this.getLocalFeeds().map((feed) => feed.clone()),\n                                participant.screensharing,\n                            )\n                            .then(() => {\n                                if (this.dataChannelsEnabled) {\n                                    newCall.createDataChannel(\"datachannel\", this.dataChannelOptions);\n                                }\n                            })\n                            .catch((e) => {\n                                logger.warn(\n                                    `GroupCall ${this.groupCallId} placeOutgoingCalls() failed to place call (userId=${userId})`,\n                                    e,\n                                );\n\n                                if (e instanceof CallError && e.code === GroupCallErrorCode.UnknownDevice) {\n                                    this.emit(GroupCallEvent.Error, e);\n                                } else {\n                                    this.emit(\n                                        GroupCallEvent.Error,\n                                        new GroupCallError(\n                                            GroupCallErrorCode.PlaceCallFailed,\n                                            `Failed to place call to ${userId}`,\n                                        ),\n                                    );\n                                }\n\n                                newCall.hangup(CallErrorCode.SignallingFailed, false);\n                                if (callMap.get(deviceId) === newCall) callMap.delete(deviceId);\n                            });\n                    }\n                }\n            }\n\n            if (callMap.size > 0) {\n                this.calls.set(userId, callMap);\n            } else {\n                this.calls.delete(userId);\n            }\n        }\n\n        if (callsChanged) this.emit(GroupCallEvent.CallsChanged, this.calls);\n    }\n\n    /*\n     * Room Member State\n     */\n\n    private getMemberStateEvents(): MatrixEvent[];\n    private getMemberStateEvents(userId: string): MatrixEvent | null;\n    private getMemberStateEvents(userId?: string): MatrixEvent[] | MatrixEvent | null {\n        return userId === undefined\n            ? this.room.currentState.getStateEvents(EventType.GroupCallMemberPrefix)\n            : this.room.currentState.getStateEvents(EventType.GroupCallMemberPrefix, userId);\n    }\n\n    private onRetryCallLoop = (): void => {\n        let needsRetry = false;\n\n        for (const [{ userId }, participantMap] of this.participants) {\n            const callMap = this.calls.get(userId);\n            let retriesMap = this.retryCallCounts.get(userId);\n\n            for (const [deviceId, participant] of participantMap) {\n                const call = callMap?.get(deviceId);\n                const retries = retriesMap?.get(deviceId) ?? 0;\n\n                if (\n                    call?.getOpponentSessionId() !== participant.sessionId &&\n                    this.wantsOutgoingCall(userId, deviceId) &&\n                    retries < 3\n                ) {\n                    if (retriesMap === undefined) {\n                        retriesMap = new Map();\n                        this.retryCallCounts.set(userId, retriesMap);\n                    }\n                    retriesMap.set(deviceId, retries + 1);\n                    needsRetry = true;\n                }\n            }\n        }\n\n        if (needsRetry) this.placeOutgoingCalls();\n    };\n\n    private initCall(call: MatrixCall): void {\n        const opponentMemberId = getCallUserId(call);\n\n        if (!opponentMemberId) {\n            throw new Error(\"Cannot init call without user id\");\n        }\n\n        const onCallFeedsChanged = (): void => this.onCallFeedsChanged(call);\n        const onCallStateChanged = (state: CallState, oldState?: CallState): void =>\n            this.onCallStateChanged(call, state, oldState);\n        const onCallHangup = this.onCallHangup;\n        const onCallReplaced = (newCall: MatrixCall): void => this.onCallReplaced(call, newCall);\n\n        let deviceMap = this.callHandlers.get(opponentMemberId);\n        if (deviceMap === undefined) {\n            deviceMap = new Map();\n            this.callHandlers.set(opponentMemberId, deviceMap);\n        }\n\n        deviceMap.set(call.getOpponentDeviceId()!, {\n            onCallFeedsChanged,\n            onCallStateChanged,\n            onCallHangup,\n            onCallReplaced,\n        });\n\n        call.on(CallEvent.FeedsChanged, onCallFeedsChanged);\n        call.on(CallEvent.State, onCallStateChanged);\n        call.on(CallEvent.Hangup, onCallHangup);\n        call.on(CallEvent.Replaced, onCallReplaced);\n\n        call.isPtt = this.isPtt;\n\n        this.reEmitter.reEmit(call, Object.values(CallEvent));\n\n        call.initStats(this.getGroupCallStats());\n\n        onCallFeedsChanged();\n    }\n\n    private disposeCall(call: MatrixCall, hangupReason: CallErrorCode): void {\n        const opponentMemberId = getCallUserId(call);\n        const opponentDeviceId = call.getOpponentDeviceId()!;\n\n        if (!opponentMemberId) {\n            throw new Error(\"Cannot dispose call without user id\");\n        }\n\n        const deviceMap = this.callHandlers.get(opponentMemberId)!;\n        const { onCallFeedsChanged, onCallStateChanged, onCallHangup, onCallReplaced } =\n            deviceMap.get(opponentDeviceId)!;\n\n        call.removeListener(CallEvent.FeedsChanged, onCallFeedsChanged);\n        call.removeListener(CallEvent.State, onCallStateChanged);\n        call.removeListener(CallEvent.Hangup, onCallHangup);\n        call.removeListener(CallEvent.Replaced, onCallReplaced);\n\n        deviceMap.delete(opponentMemberId);\n        if (deviceMap.size === 0) this.callHandlers.delete(opponentMemberId);\n\n        if (call.hangupReason === CallErrorCode.Replaced) {\n            return;\n        }\n\n        const usermediaFeed = this.getUserMediaFeed(opponentMemberId, opponentDeviceId);\n\n        if (usermediaFeed) {\n            this.removeUserMediaFeed(usermediaFeed);\n        }\n\n        const screenshareFeed = this.getScreenshareFeed(opponentMemberId, opponentDeviceId);\n\n        if (screenshareFeed) {\n            this.removeScreenshareFeed(screenshareFeed);\n        }\n    }\n\n    private onCallFeedsChanged = (call: MatrixCall): void => {\n        const opponentMemberId = getCallUserId(call);\n        const opponentDeviceId = call.getOpponentDeviceId()!;\n\n        if (!opponentMemberId) {\n            throw new Error(\"Cannot change call feeds without user id\");\n        }\n\n        const currentUserMediaFeed = this.getUserMediaFeed(opponentMemberId, opponentDeviceId);\n        const remoteUsermediaFeed = call.remoteUsermediaFeed;\n        const remoteFeedChanged = remoteUsermediaFeed !== currentUserMediaFeed;\n\n        const deviceMap = this.calls.get(opponentMemberId);\n        const currentCallForUserDevice = deviceMap?.get(opponentDeviceId);\n        if (currentCallForUserDevice?.callId !== call.callId) {\n            // the call in question is not the current call for this user/deviceId\n            // so ignore feed events from it otherwise we'll remove our real feeds\n            return;\n        }\n\n        if (remoteFeedChanged) {\n            if (!currentUserMediaFeed && remoteUsermediaFeed) {\n                this.addUserMediaFeed(remoteUsermediaFeed);\n            } else if (currentUserMediaFeed && remoteUsermediaFeed) {\n                this.replaceUserMediaFeed(currentUserMediaFeed, remoteUsermediaFeed);\n            } else if (currentUserMediaFeed && !remoteUsermediaFeed) {\n                this.removeUserMediaFeed(currentUserMediaFeed);\n            }\n        }\n\n        const currentScreenshareFeed = this.getScreenshareFeed(opponentMemberId, opponentDeviceId);\n        const remoteScreensharingFeed = call.remoteScreensharingFeed;\n        const remoteScreenshareFeedChanged = remoteScreensharingFeed !== currentScreenshareFeed;\n\n        if (remoteScreenshareFeedChanged) {\n            if (!currentScreenshareFeed && remoteScreensharingFeed) {\n                this.addScreenshareFeed(remoteScreensharingFeed);\n            } else if (currentScreenshareFeed && remoteScreensharingFeed) {\n                this.replaceScreenshareFeed(currentScreenshareFeed, remoteScreensharingFeed);\n            } else if (currentScreenshareFeed && !remoteScreensharingFeed) {\n                this.removeScreenshareFeed(currentScreenshareFeed);\n            }\n        }\n    };\n\n    private onCallStateChanged = (call: MatrixCall, state: CallState, _oldState: CallState | undefined): void => {\n        if (state === CallState.Ended) return;\n\n        const audioMuted = this.localCallFeed!.isAudioMuted();\n\n        if (call.localUsermediaStream && call.isMicrophoneMuted() !== audioMuted) {\n            call.setMicrophoneMuted(audioMuted);\n        }\n\n        const videoMuted = this.localCallFeed!.isVideoMuted();\n\n        if (call.localUsermediaStream && call.isLocalVideoMuted() !== videoMuted) {\n            call.setLocalVideoMuted(videoMuted);\n        }\n\n        const opponentUserId = call.getOpponentMember()?.userId;\n        if (state === CallState.Connected && opponentUserId) {\n            const retriesMap = this.retryCallCounts.get(opponentUserId);\n            retriesMap?.delete(call.getOpponentDeviceId()!);\n            if (retriesMap?.size === 0) this.retryCallCounts.delete(opponentUserId);\n        }\n    };\n\n    private onCallHangup = (call: MatrixCall): void => {\n        if (call.hangupReason === CallErrorCode.Replaced) return;\n\n        const opponentUserId = call.getOpponentMember()?.userId ?? this.room.getMember(call.invitee!)!.userId;\n        const deviceMap = this.calls.get(opponentUserId);\n\n        // Sanity check that this call is in fact in the map\n        if (deviceMap?.get(call.getOpponentDeviceId()!) === call) {\n            this.disposeCall(call, call.hangupReason as CallErrorCode);\n            deviceMap.delete(call.getOpponentDeviceId()!);\n            if (deviceMap.size === 0) this.calls.delete(opponentUserId);\n            this.emit(GroupCallEvent.CallsChanged, this.calls);\n        }\n    };\n\n    private onCallReplaced = (prevCall: MatrixCall, newCall: MatrixCall): void => {\n        const opponentUserId = prevCall.getOpponentMember()!.userId;\n\n        let deviceMap = this.calls.get(opponentUserId);\n        if (deviceMap === undefined) {\n            deviceMap = new Map();\n            this.calls.set(opponentUserId, deviceMap);\n        }\n\n        prevCall.hangup(CallErrorCode.Replaced, false);\n        this.initCall(newCall);\n        deviceMap.set(prevCall.getOpponentDeviceId()!, newCall);\n        this.emit(GroupCallEvent.CallsChanged, this.calls);\n    };\n\n    /*\n     * UserMedia CallFeed Event Handlers\n     */\n\n    public getUserMediaFeed(userId: string, deviceId: string): CallFeed | undefined {\n        return this.userMediaFeeds.find((f) => f.userId === userId && f.deviceId! === deviceId);\n    }\n\n    private addUserMediaFeed(callFeed: CallFeed): void {\n        this.userMediaFeeds.push(callFeed);\n        callFeed.measureVolumeActivity(true);\n        this.emit(GroupCallEvent.UserMediaFeedsChanged, this.userMediaFeeds);\n    }\n\n    private replaceUserMediaFeed(existingFeed: CallFeed, replacementFeed: CallFeed): void {\n        const feedIndex = this.userMediaFeeds.findIndex(\n            (f) => f.userId === existingFeed.userId && f.deviceId! === existingFeed.deviceId,\n        );\n\n        if (feedIndex === -1) {\n            throw new Error(\"Couldn't find user media feed to replace\");\n        }\n\n        this.userMediaFeeds.splice(feedIndex, 1, replacementFeed);\n\n        existingFeed.dispose();\n        replacementFeed.measureVolumeActivity(true);\n        this.emit(GroupCallEvent.UserMediaFeedsChanged, this.userMediaFeeds);\n    }\n\n    private removeUserMediaFeed(callFeed: CallFeed): void {\n        const feedIndex = this.userMediaFeeds.findIndex(\n            (f) => f.userId === callFeed.userId && f.deviceId! === callFeed.deviceId,\n        );\n\n        if (feedIndex === -1) {\n            throw new Error(\"Couldn't find user media feed to remove\");\n        }\n\n        this.userMediaFeeds.splice(feedIndex, 1);\n\n        callFeed.dispose();\n        this.emit(GroupCallEvent.UserMediaFeedsChanged, this.userMediaFeeds);\n\n        if (this.activeSpeaker === callFeed) {\n            this.activeSpeaker = this.userMediaFeeds[0];\n            this.emit(GroupCallEvent.ActiveSpeakerChanged, this.activeSpeaker);\n        }\n    }\n\n    private onActiveSpeakerLoop = (): void => {\n        let topAvg: number | undefined = undefined;\n        let nextActiveSpeaker: CallFeed | undefined = undefined;\n\n        for (const callFeed of this.userMediaFeeds) {\n            if (callFeed.isLocal() && this.userMediaFeeds.length > 1) continue;\n\n            const total = callFeed.speakingVolumeSamples.reduce(\n                (acc, volume) => acc + Math.max(volume, SPEAKING_THRESHOLD),\n            );\n            const avg = total / callFeed.speakingVolumeSamples.length;\n\n            if (!topAvg || avg > topAvg) {\n                topAvg = avg;\n                nextActiveSpeaker = callFeed;\n            }\n        }\n\n        if (nextActiveSpeaker && this.activeSpeaker !== nextActiveSpeaker && topAvg && topAvg > SPEAKING_THRESHOLD) {\n            this.activeSpeaker = nextActiveSpeaker;\n            this.emit(GroupCallEvent.ActiveSpeakerChanged, this.activeSpeaker);\n        }\n    };\n\n    /*\n     * Screenshare Call Feed Event Handlers\n     */\n\n    public getScreenshareFeed(userId: string, deviceId: string): CallFeed | undefined {\n        return this.screenshareFeeds.find((f) => f.userId === userId && f.deviceId! === deviceId);\n    }\n\n    private addScreenshareFeed(callFeed: CallFeed): void {\n        this.screenshareFeeds.push(callFeed);\n        this.emit(GroupCallEvent.ScreenshareFeedsChanged, this.screenshareFeeds);\n    }\n\n    private replaceScreenshareFeed(existingFeed: CallFeed, replacementFeed: CallFeed): void {\n        const feedIndex = this.screenshareFeeds.findIndex(\n            (f) => f.userId === existingFeed.userId && f.deviceId! === existingFeed.deviceId,\n        );\n\n        if (feedIndex === -1) {\n            throw new Error(\"Couldn't find screenshare feed to replace\");\n        }\n\n        this.screenshareFeeds.splice(feedIndex, 1, replacementFeed);\n\n        existingFeed.dispose();\n        this.emit(GroupCallEvent.ScreenshareFeedsChanged, this.screenshareFeeds);\n    }\n\n    private removeScreenshareFeed(callFeed: CallFeed): void {\n        const feedIndex = this.screenshareFeeds.findIndex(\n            (f) => f.userId === callFeed.userId && f.deviceId! === callFeed.deviceId,\n        );\n\n        if (feedIndex === -1) {\n            throw new Error(\"Couldn't find screenshare feed to remove\");\n        }\n\n        this.screenshareFeeds.splice(feedIndex, 1);\n\n        callFeed.dispose();\n        this.emit(GroupCallEvent.ScreenshareFeedsChanged, this.screenshareFeeds);\n    }\n\n    /**\n     * Recalculates and updates the participant map to match the room state.\n     */\n    private updateParticipants(): void {\n        const localMember = this.room.getMember(this.client.getSafeUserId());\n        if (!localMember) {\n            // The client hasn't fetched enough of the room state to get our own member\n            // event. This probably shouldn't happen, but sanity check & exit for now.\n            logger.warn(\n                `GroupCall ${this.groupCallId} updateParticipants() tried to update participants before local room member is available`,\n            );\n            return;\n        }\n\n        if (this.participantsExpirationTimer !== null) {\n            clearTimeout(this.participantsExpirationTimer);\n            this.participantsExpirationTimer = null;\n        }\n\n        if (this.state === GroupCallState.Ended) {\n            this.participants = new Map();\n            return;\n        }\n\n        const participants = new Map<RoomMember, Map<string, ParticipantState>>();\n        const now = Date.now();\n        const entered = this.state === GroupCallState.Entered || this.enteredViaAnotherSession;\n        let nextExpiration = Infinity;\n\n        for (const e of this.getMemberStateEvents()) {\n            const member = this.room.getMember(e.getStateKey()!);\n            const content = e.getContent<Record<any, unknown>>();\n            const calls: Record<any, unknown>[] = Array.isArray(content[\"m.calls\"]) ? content[\"m.calls\"] : [];\n            const call = calls.find((call) => call[\"m.call_id\"] === this.groupCallId);\n            const devices: Record<any, unknown>[] = Array.isArray(call?.[\"m.devices\"]) ? call![\"m.devices\"] : [];\n\n            // Filter out invalid and expired devices\n            let validDevices = devices.filter(\n                (d) =>\n                    typeof d.device_id === \"string\" &&\n                    typeof d.session_id === \"string\" &&\n                    typeof d.expires_ts === \"number\" &&\n                    d.expires_ts > now &&\n                    Array.isArray(d.feeds),\n            ) as unknown as IGroupCallRoomMemberDevice[];\n\n            // Apply local echo for the unentered case\n            if (!entered && member?.userId === this.client.getUserId()!) {\n                validDevices = validDevices.filter((d) => d.device_id !== this.client.getDeviceId()!);\n            }\n\n            // Must have a connected device and be joined to the room\n            if (validDevices.length > 0 && member?.membership === KnownMembership.Join) {\n                const deviceMap = new Map<string, ParticipantState>();\n                participants.set(member, deviceMap);\n\n                for (const d of validDevices) {\n                    deviceMap.set(d.device_id, {\n                        sessionId: d.session_id,\n                        screensharing: d.feeds.some((f) => f.purpose === SDPStreamMetadataPurpose.Screenshare),\n                    });\n                    if (d.expires_ts < nextExpiration) nextExpiration = d.expires_ts;\n                }\n            }\n        }\n\n        // Apply local echo for the entered case\n        if (entered) {\n            let deviceMap = participants.get(localMember);\n            if (deviceMap === undefined) {\n                deviceMap = new Map();\n                participants.set(localMember, deviceMap);\n            }\n\n            if (!deviceMap.has(this.client.getDeviceId()!)) {\n                deviceMap.set(this.client.getDeviceId()!, {\n                    sessionId: this.client.getSessionId(),\n                    screensharing: this.getLocalFeeds().some((f) => f.purpose === SDPStreamMetadataPurpose.Screenshare),\n                });\n            }\n        }\n\n        this.participants = participants;\n        if (nextExpiration < Infinity) {\n            this.participantsExpirationTimer = setTimeout(() => this.updateParticipants(), nextExpiration - now);\n        }\n    }\n\n    /**\n     * Updates the local user's member state with the devices returned by the given function.\n     * @param fn - A function from the current devices to the new devices. If it\n     *   returns null, the update will be skipped.\n     * @param keepAlive - Whether the request should outlive the window.\n     */\n    private async updateDevices(\n        fn: (devices: IGroupCallRoomMemberDevice[]) => IGroupCallRoomMemberDevice[] | null,\n        keepAlive = false,\n    ): Promise<void> {\n        const now = Date.now();\n        const localUserId = this.client.getUserId()!;\n\n        const event = this.getMemberStateEvents(localUserId);\n        const content = event?.getContent<Record<any, unknown>>() ?? {};\n        const calls: Record<any, unknown>[] = Array.isArray(content[\"m.calls\"]) ? content[\"m.calls\"] : [];\n\n        let call: Record<any, unknown> | null = null;\n        const otherCalls: Record<any, unknown>[] = [];\n        for (const c of calls) {\n            if (c[\"m.call_id\"] === this.groupCallId) {\n                call = c;\n            } else {\n                otherCalls.push(c);\n            }\n        }\n        if (call === null) call = {};\n\n        const devices: Record<any, unknown>[] = Array.isArray(call[\"m.devices\"]) ? call[\"m.devices\"] : [];\n\n        // Filter out invalid and expired devices\n        const validDevices = devices.filter(\n            (d) =>\n                typeof d.device_id === \"string\" &&\n                typeof d.session_id === \"string\" &&\n                typeof d.expires_ts === \"number\" &&\n                d.expires_ts > now &&\n                Array.isArray(d.feeds),\n        ) as unknown as IGroupCallRoomMemberDevice[];\n\n        const newDevices = fn(validDevices);\n        if (newDevices === null) return;\n\n        const newCalls = [...(otherCalls as unknown as IGroupCallRoomMemberCallState[])];\n        if (newDevices.length > 0) {\n            newCalls.push({\n                ...call,\n                \"m.call_id\": this.groupCallId,\n                \"m.devices\": newDevices,\n            });\n        }\n\n        const newContent: IGroupCallRoomMemberState = { \"m.calls\": newCalls };\n\n        await this.client.sendStateEvent(this.room.roomId, EventType.GroupCallMemberPrefix, newContent, localUserId, {\n            keepAlive,\n        });\n    }\n\n    private async addDeviceToMemberState(): Promise<void> {\n        await this.updateDevices((devices) => [\n            ...devices.filter((d) => d.device_id !== this.client.getDeviceId()!),\n            {\n                device_id: this.client.getDeviceId()!,\n                session_id: this.client.getSessionId(),\n                expires_ts: Date.now() + DEVICE_TIMEOUT,\n                feeds: this.getLocalFeeds().map((feed) => ({ purpose: feed.purpose })),\n                // TODO: Add data channels\n            },\n        ]);\n    }\n\n    private async updateMemberState(): Promise<void> {\n        // Clear the old update interval before proceeding\n        if (this.resendMemberStateTimer !== null) {\n            clearInterval(this.resendMemberStateTimer);\n            this.resendMemberStateTimer = null;\n        }\n\n        if (this.state === GroupCallState.Entered) {\n            // Add the local device\n            await this.addDeviceToMemberState();\n\n            // Resend the state event every so often so it doesn't become stale\n            this.resendMemberStateTimer = setInterval(\n                async () => {\n                    logger.log(`GroupCall ${this.groupCallId} updateMemberState() resending call member state\"`);\n                    try {\n                        await this.addDeviceToMemberState();\n                    } catch (e) {\n                        logger.error(\n                            `GroupCall ${this.groupCallId} updateMemberState() failed to resend call member state`,\n                            e,\n                        );\n                    }\n                },\n                (DEVICE_TIMEOUT * 3) / 4,\n            );\n        } else {\n            // Remove the local device\n            await this.updateDevices(\n                (devices) => devices.filter((d) => d.device_id !== this.client.getDeviceId()!),\n                true,\n            );\n        }\n    }\n\n    /**\n     * Cleans up our member state by filtering out logged out devices, inactive\n     * devices, and our own device (if we know we haven't entered).\n     */\n    public async cleanMemberState(): Promise<void> {\n        const { devices: myDevices } = await this.client.getDevices();\n        const deviceMap = new Map<string, IMyDevice>(myDevices.map((d) => [d.device_id, d]));\n\n        // updateDevices takes care of filtering out inactive devices for us\n        await this.updateDevices((devices) => {\n            const newDevices = devices.filter((d) => {\n                const device = deviceMap.get(d.device_id);\n                return (\n                    device?.last_seen_ts !== undefined &&\n                    !(\n                        d.device_id === this.client.getDeviceId()! &&\n                        this.state !== GroupCallState.Entered &&\n                        !this.enteredViaAnotherSession\n                    )\n                );\n            });\n\n            // Skip the update if the devices are unchanged\n            return newDevices.length === devices.length ? null : newDevices;\n        });\n    }\n\n    private onRoomState = (): void => this.updateParticipants();\n\n    private onParticipantsChanged = (): void => {\n        // Re-run setTracksEnabled on all calls, so that participants that just\n        // left get denied access to our media, and participants that just\n        // joined get granted access\n        this.forEachCall((call) => {\n            const expected = this.callExpected(call);\n            for (const feed of call.getLocalFeeds()) {\n                setTracksEnabled(feed.stream.getAudioTracks(), !feed.isAudioMuted() && expected);\n                setTracksEnabled(feed.stream.getVideoTracks(), !feed.isVideoMuted() && expected);\n            }\n        });\n\n        if (this.state === GroupCallState.Entered && !this.useLivekit) this.placeOutgoingCalls();\n\n        // Update the participants stored in the stats object\n    };\n\n    private onStateChanged = (newState: GroupCallState, oldState: GroupCallState): void => {\n        if (\n            newState === GroupCallState.Entered ||\n            oldState === GroupCallState.Entered ||\n            newState === GroupCallState.Ended\n        ) {\n            // We either entered, left, or ended the call\n            this.updateParticipants();\n            this.updateMemberState().catch((e) =>\n                logger.error(\n                    `GroupCall ${this.groupCallId} onStateChanged() failed to update member state devices\"`,\n                    e,\n                ),\n            );\n        }\n    };\n\n    private onLocalFeedsChanged = (): void => {\n        if (this.state === GroupCallState.Entered) {\n            this.updateMemberState().catch((e) =>\n                logger.error(\n                    `GroupCall ${this.groupCallId} onLocalFeedsChanged() failed to update member state feeds`,\n                    e,\n                ),\n            );\n        }\n    };\n\n    public getGroupCallStats(): GroupCallStats {\n        if (this.stats === undefined) {\n            const userID = this.client.getUserId() || \"unknown\";\n            this.stats = new GroupCallStats(this.groupCallId, userID, this.statsCollectIntervalTime);\n            this.stats.reports.on(StatsReport.CONNECTION_STATS, this.onConnectionStats);\n            this.stats.reports.on(StatsReport.BYTE_SENT_STATS, this.onByteSentStats);\n            this.stats.reports.on(StatsReport.SUMMARY_STATS, this.onSummaryStats);\n            this.stats.reports.on(StatsReport.CALL_FEED_REPORT, this.onCallFeedReport);\n        }\n        return this.stats;\n    }\n\n    public setGroupCallStatsInterval(interval: number): void {\n        this.statsCollectIntervalTime = interval;\n        if (this.stats !== undefined) {\n            this.stats.stop();\n            this.stats.setInterval(interval);\n            if (interval > 0) {\n                this.stats.start();\n            }\n        }\n    }\n}\n","/*\nCopyright 2021 Šimon Brandner <simon.bra.ag@gmail.com>\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { type MatrixEvent } from \"../models/event.ts\";\nimport { type MatrixClient, ClientEvent } from \"../client.ts\";\nimport { GroupCall, GroupCallIntent, GroupCallType, type IGroupCallDataChannelOptions } from \"./groupCall.ts\";\nimport { type Room } from \"../models/room.ts\";\nimport { type RoomState, RoomStateEvent } from \"../models/room-state.ts\";\nimport { type RoomMember } from \"../models/room-member.ts\";\nimport { logger } from \"../logger.ts\";\nimport { EventType } from \"../@types/event.ts\";\nimport { SyncState } from \"../sync.ts\";\n\nexport enum GroupCallEventHandlerEvent {\n    Incoming = \"GroupCall.incoming\",\n    Outgoing = \"GroupCall.outgoing\",\n    Ended = \"GroupCall.ended\",\n    Participants = \"GroupCall.participants\",\n}\n\nexport type GroupCallEventHandlerEventHandlerMap = {\n    [GroupCallEventHandlerEvent.Incoming]: (call: GroupCall) => void;\n    [GroupCallEventHandlerEvent.Outgoing]: (call: GroupCall) => void;\n    [GroupCallEventHandlerEvent.Ended]: (call: GroupCall) => void;\n    [GroupCallEventHandlerEvent.Participants]: (participants: RoomMember[], call: GroupCall) => void;\n};\n\ninterface RoomDeferred {\n    prom: Promise<void>;\n    resolve?: () => void;\n}\n\nexport class GroupCallEventHandler {\n    public groupCalls = new Map<string, GroupCall>(); // roomId -> GroupCall\n\n    // All rooms we know about and whether we've seen a 'Room' event\n    // for them. The promise will be fulfilled once we've processed that\n    // event which means we're \"up to date\" on what calls are in a room\n    // and get\n    private roomDeferreds = new Map<string, RoomDeferred>();\n\n    public constructor(private client: MatrixClient) {}\n\n    public async start(): Promise<void> {\n        // We wait until the client has started syncing for real.\n        // This is because we only support one call at a time, and want\n        // the latest. We therefore want the latest state of the room before\n        // we create a group call for the room so we can be fairly sure that\n        // the group call we create is really the latest one.\n        if (this.client.getSyncState() !== SyncState.Syncing) {\n            logger.debug(\"GroupCallEventHandler start() waiting for client to start syncing\");\n            await new Promise<void>((resolve) => {\n                const onSync = (): void => {\n                    if (this.client.getSyncState() === SyncState.Syncing) {\n                        this.client.off(ClientEvent.Sync, onSync);\n                        return resolve();\n                    }\n                };\n                this.client.on(ClientEvent.Sync, onSync);\n            });\n        }\n\n        const rooms = this.client.getRooms();\n\n        for (const room of rooms) {\n            this.createGroupCallForRoom(room);\n        }\n\n        this.client.on(ClientEvent.Room, this.onRoomsChanged);\n        this.client.on(RoomStateEvent.Events, this.onRoomStateChanged);\n    }\n\n    public stop(): void {\n        this.client.removeListener(ClientEvent.Room, this.onRoomsChanged);\n        this.client.removeListener(RoomStateEvent.Events, this.onRoomStateChanged);\n    }\n\n    private getRoomDeferred(roomId: string): RoomDeferred {\n        let deferred = this.roomDeferreds.get(roomId);\n        if (deferred === undefined) {\n            let resolveFunc: () => void;\n            deferred = {\n                prom: new Promise<void>((resolve) => {\n                    resolveFunc = resolve;\n                }),\n            };\n            deferred.resolve = resolveFunc!;\n            this.roomDeferreds.set(roomId, deferred);\n        }\n\n        return deferred;\n    }\n\n    public waitUntilRoomReadyForGroupCalls(roomId: string): Promise<void> {\n        return this.getRoomDeferred(roomId).prom;\n    }\n\n    public getGroupCallById(groupCallId: string): GroupCall | undefined {\n        return [...this.groupCalls.values()].find((groupCall) => groupCall.groupCallId === groupCallId);\n    }\n\n    private createGroupCallForRoom(room: Room): void {\n        const callEvents = room.currentState.getStateEvents(EventType.GroupCallPrefix);\n        const sortedCallEvents = callEvents.sort((a, b) => b.getTs() - a.getTs());\n\n        for (const callEvent of sortedCallEvents) {\n            const content = callEvent.getContent();\n\n            if (content[\"m.terminated\"] || callEvent.isRedacted()) {\n                continue;\n            }\n\n            logger.debug(\n                `GroupCallEventHandler createGroupCallForRoom() choosing group call from possible calls (stateKey=${callEvent.getStateKey()}, ts=${callEvent.getTs()}, roomId=${\n                    room.roomId\n                }, numOfPossibleCalls=${callEvents.length})`,\n            );\n\n            this.createGroupCallFromRoomStateEvent(callEvent);\n            break;\n        }\n\n        this.getRoomDeferred(room.roomId).resolve!();\n    }\n\n    private createGroupCallFromRoomStateEvent(event: MatrixEvent): GroupCall | undefined {\n        const roomId = event.getRoomId();\n        const content = event.getContent();\n\n        const room = this.client.getRoom(roomId);\n\n        if (!room) {\n            logger.warn(\n                `GroupCallEventHandler createGroupCallFromRoomStateEvent() couldn't find room for call (roomId=${roomId})`,\n            );\n            return;\n        }\n\n        const groupCallId = event.getStateKey();\n\n        const callType = content[\"m.type\"];\n\n        if (!Object.values(GroupCallType).includes(callType)) {\n            logger.warn(\n                `GroupCallEventHandler createGroupCallFromRoomStateEvent() received invalid call type (type=${callType}, roomId=${roomId})`,\n            );\n            return;\n        }\n\n        const callIntent = content[\"m.intent\"];\n\n        if (!Object.values(GroupCallIntent).includes(callIntent)) {\n            logger.warn(`Received invalid group call intent (type=${callType}, roomId=${roomId})`);\n            return;\n        }\n\n        const isPtt = Boolean(content[\"io.element.ptt\"]);\n\n        let dataChannelOptions: IGroupCallDataChannelOptions | undefined;\n\n        if (content?.dataChannelsEnabled && content?.dataChannelOptions) {\n            // Pull out just the dataChannelOptions we want to support.\n            const { ordered, maxPacketLifeTime, maxRetransmits, protocol } = content.dataChannelOptions;\n            dataChannelOptions = { ordered, maxPacketLifeTime, maxRetransmits, protocol };\n        }\n\n        const groupCall = new GroupCall(\n            this.client,\n            room,\n            callType,\n            isPtt,\n            callIntent,\n            groupCallId,\n            // Because without Media section a WebRTC connection is not possible, so need a RTCDataChannel to set up a\n            // no media WebRTC connection anyway.\n            content?.dataChannelsEnabled || this.client.isVoipWithNoMediaAllowed,\n            dataChannelOptions,\n            this.client.isVoipWithNoMediaAllowed,\n            this.client.useLivekitForGroupCalls,\n            content[\"io.element.livekit_service_url\"],\n        );\n\n        this.groupCalls.set(room.roomId, groupCall);\n        this.client.emit(GroupCallEventHandlerEvent.Incoming, groupCall);\n\n        return groupCall;\n    }\n\n    private onRoomsChanged = (room: Room): void => {\n        this.createGroupCallForRoom(room);\n    };\n\n    private onRoomStateChanged = (event: MatrixEvent, state: RoomState): void => {\n        const eventType = event.getType();\n\n        if (eventType === EventType.GroupCallPrefix) {\n            const groupCallId = event.getStateKey();\n            const content = event.getContent();\n\n            const currentGroupCall = this.groupCalls.get(state.roomId);\n\n            if (!currentGroupCall && !content[\"m.terminated\"] && !event.isRedacted()) {\n                this.createGroupCallFromRoomStateEvent(event);\n            } else if (currentGroupCall && currentGroupCall.groupCallId === groupCallId) {\n                if (content[\"m.terminated\"] || event.isRedacted()) {\n                    currentGroupCall.terminate(false);\n                } else if (content[\"m.type\"] !== currentGroupCall.type) {\n                    // TODO: Handle the callType changing when the room state changes\n                    logger.warn(\n                        `GroupCallEventHandler onRoomStateChanged() currently does not support changing type (roomId=${state.roomId})`,\n                    );\n                }\n            } else if (currentGroupCall && currentGroupCall.groupCallId !== groupCallId) {\n                // TODO: Handle new group calls and multiple group calls\n                logger.warn(\n                    `GroupCallEventHandler onRoomStateChanged() currently does not support multiple calls (roomId=${state.roomId})`,\n                );\n            }\n        }\n    };\n}\n","/*\nCopyright 2015, 2016 OpenMarket Ltd\nCopyright 2017 New Vector Ltd\nCopyright 2019, 2020 The Matrix.org Foundation C.I.C.\nCopyright 2021 - 2022 Šimon Brandner <simon.bra.ag@gmail.com>\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { TypedEventEmitter } from \"../models/typed-event-emitter.ts\";\nimport { GroupCallType, GroupCallState } from \"../webrtc/groupCall.ts\";\nimport { logger } from \"../logger.ts\";\nimport { type MatrixClient } from \"../client.ts\";\n\nexport enum MediaHandlerEvent {\n    LocalStreamsChanged = \"local_streams_changed\",\n}\n\nexport type MediaHandlerEventHandlerMap = {\n    [MediaHandlerEvent.LocalStreamsChanged]: () => void;\n};\n\nexport interface IScreensharingOpts {\n    /**\n     * sourceId for Electron DesktopCapturer\n     */\n    desktopCapturerSourceId?: string;\n    audio?: boolean;\n    // For electron screen capture, there are very few options for detecting electron\n    // apart from inspecting the user agent or just trying getDisplayMedia() and\n    // catching the failure, so we do the latter - this flag tells the function to just\n    // throw an error so we can catch it in this case, rather than logging and emitting.\n    throwOnFail?: boolean;\n}\n\nexport interface AudioSettings {\n    autoGainControl: boolean;\n    echoCancellation: boolean;\n    noiseSuppression: boolean;\n}\n\nexport class MediaHandler extends TypedEventEmitter<\n    MediaHandlerEvent.LocalStreamsChanged,\n    MediaHandlerEventHandlerMap\n> {\n    private audioInput?: string;\n    private audioSettings?: AudioSettings;\n    private videoInput?: string;\n    private localUserMediaStream?: MediaStream;\n    public userMediaStreams: MediaStream[] = [];\n    public screensharingStreams: MediaStream[] = [];\n\n    // Promise chain to serialise calls to getMediaStream\n    private getMediaStreamPromise?: Promise<MediaStream>;\n\n    public constructor(private client: MatrixClient) {\n        super();\n    }\n\n    public restoreMediaSettings(audioInput: string, videoInput: string): void {\n        this.audioInput = audioInput;\n        this.videoInput = videoInput;\n    }\n\n    /**\n     * Set an audio input device to use for MatrixCalls\n     * @param deviceId - the identifier for the device\n     * undefined treated as unset\n     */\n    public async setAudioInput(deviceId: string): Promise<void> {\n        logger.info(`MediaHandler setAudioInput() running (deviceId=${deviceId})`);\n\n        if (this.audioInput === deviceId) return;\n\n        this.audioInput = deviceId;\n        await this.updateLocalUsermediaStreams();\n    }\n\n    /**\n     * Set audio settings for MatrixCalls\n     * @param opts - audio options to set\n     */\n    public async setAudioSettings(opts: AudioSettings): Promise<void> {\n        logger.info(`MediaHandler setAudioSettings() running (opts=${JSON.stringify(opts)})`);\n\n        this.audioSettings = Object.assign({}, opts) as AudioSettings;\n        await this.updateLocalUsermediaStreams();\n    }\n\n    /**\n     * Set a video input device to use for MatrixCalls\n     * @param deviceId - the identifier for the device\n     * undefined treated as unset\n     */\n    public async setVideoInput(deviceId: string): Promise<void> {\n        logger.info(`MediaHandler setVideoInput() running (deviceId=${deviceId})`);\n\n        if (this.videoInput === deviceId) return;\n\n        this.videoInput = deviceId;\n        await this.updateLocalUsermediaStreams();\n    }\n\n    /**\n     * Set media input devices to use for MatrixCalls\n     * @param audioInput - the identifier for the audio device\n     * @param videoInput - the identifier for the video device\n     * undefined treated as unset\n     */\n    public async setMediaInputs(audioInput: string, videoInput: string): Promise<void> {\n        logger.log(`MediaHandler setMediaInputs() running (audioInput: ${audioInput} videoInput: ${videoInput})`);\n        this.audioInput = audioInput;\n        this.videoInput = videoInput;\n        await this.updateLocalUsermediaStreams();\n    }\n\n    /*\n     * Requests new usermedia streams and replace the old ones\n     */\n    public async updateLocalUsermediaStreams(): Promise<void> {\n        if (this.userMediaStreams.length === 0) return;\n\n        const callMediaStreamParams: Map<string, { audio: boolean; video: boolean }> = new Map();\n        for (const call of this.client.callEventHandler!.calls.values()) {\n            callMediaStreamParams.set(call.callId, {\n                audio: call.hasLocalUserMediaAudioTrack,\n                video: call.hasLocalUserMediaVideoTrack,\n            });\n        }\n\n        for (const stream of this.userMediaStreams) {\n            logger.log(`MediaHandler updateLocalUsermediaStreams() stopping all tracks (streamId=${stream.id})`);\n            for (const track of stream.getTracks()) {\n                track.stop();\n            }\n        }\n\n        this.userMediaStreams = [];\n        this.localUserMediaStream = undefined;\n\n        for (const call of this.client.callEventHandler!.calls.values()) {\n            if (call.callHasEnded() || !callMediaStreamParams.has(call.callId)) {\n                continue;\n            }\n\n            const { audio, video } = callMediaStreamParams.get(call.callId)!;\n\n            logger.log(\n                `MediaHandler updateLocalUsermediaStreams() calling getUserMediaStream() (callId=${call.callId})`,\n            );\n            const stream = await this.getUserMediaStream(audio, video);\n\n            if (call.callHasEnded()) {\n                continue;\n            }\n\n            await call.updateLocalUsermediaStream(stream);\n        }\n\n        for (const groupCall of this.client.groupCallEventHandler!.groupCalls.values()) {\n            if (!groupCall.localCallFeed) {\n                continue;\n            }\n\n            logger.log(\n                `MediaHandler updateLocalUsermediaStreams() calling getUserMediaStream() (groupCallId=${groupCall.groupCallId})`,\n            );\n            const stream = await this.getUserMediaStream(true, groupCall.type === GroupCallType.Video);\n\n            if (groupCall.state === GroupCallState.Ended) {\n                continue;\n            }\n\n            await groupCall.updateLocalUsermediaStream(stream);\n        }\n\n        this.emit(MediaHandlerEvent.LocalStreamsChanged);\n    }\n\n    public async hasAudioDevice(): Promise<boolean> {\n        try {\n            const devices = await navigator.mediaDevices.enumerateDevices();\n            return devices.filter((device) => device.kind === \"audioinput\").length > 0;\n        } catch (err) {\n            logger.log(`MediaHandler hasAudioDevice() calling navigator.mediaDevices.enumerateDevices with error`, err);\n            return false;\n        }\n    }\n\n    public async hasVideoDevice(): Promise<boolean> {\n        try {\n            const devices = await navigator.mediaDevices.enumerateDevices();\n            return devices.filter((device) => device.kind === \"videoinput\").length > 0;\n        } catch (err) {\n            logger.log(`MediaHandler hasVideoDevice() calling navigator.mediaDevices.enumerateDevices with error`, err);\n            return false;\n        }\n    }\n\n    /**\n     * @param audio - should have an audio track\n     * @param video - should have a video track\n     * @param reusable - is allowed to be reused by the MediaHandler\n     * @returns based on passed parameters\n     */\n    public async getUserMediaStream(audio: boolean, video: boolean, reusable = true): Promise<MediaStream> {\n        // Serialise calls, othertwise we can't sensibly re-use the stream\n        if (this.getMediaStreamPromise) {\n            this.getMediaStreamPromise = this.getMediaStreamPromise.then(() => {\n                return this.getUserMediaStreamInternal(audio, video, reusable);\n            });\n        } else {\n            this.getMediaStreamPromise = this.getUserMediaStreamInternal(audio, video, reusable);\n        }\n\n        return this.getMediaStreamPromise;\n    }\n\n    private async getUserMediaStreamInternal(audio: boolean, video: boolean, reusable: boolean): Promise<MediaStream> {\n        const shouldRequestAudio = audio && (await this.hasAudioDevice());\n        const shouldRequestVideo = video && (await this.hasVideoDevice());\n\n        let stream: MediaStream;\n\n        let canReuseStream = true;\n        if (this.localUserMediaStream) {\n            // This figures out if we can reuse the current localUsermediaStream\n            // based on whether or not the \"mute state\" (presence of tracks of a\n            // given kind) matches what is being requested\n            if (shouldRequestAudio !== this.localUserMediaStream.getAudioTracks().length > 0) {\n                canReuseStream = false;\n            }\n            if (shouldRequestVideo !== this.localUserMediaStream.getVideoTracks().length > 0) {\n                canReuseStream = false;\n            }\n\n            // This code checks that the device ID is the same as the localUserMediaStream stream, but we update\n            // the localUserMediaStream whenever the device ID changes (apart from when restoring) so it's not\n            // clear why this would ever be different, unless there's a race.\n            if (\n                shouldRequestAudio &&\n                this.localUserMediaStream.getAudioTracks()[0]?.getSettings()?.deviceId !== this.audioInput\n            ) {\n                canReuseStream = false;\n            }\n            if (\n                shouldRequestVideo &&\n                this.localUserMediaStream.getVideoTracks()[0]?.getSettings()?.deviceId !== this.videoInput\n            ) {\n                canReuseStream = false;\n            }\n        } else {\n            canReuseStream = false;\n        }\n\n        if (!canReuseStream) {\n            const constraints = this.getUserMediaContraints(shouldRequestAudio, shouldRequestVideo);\n            stream = await navigator.mediaDevices.getUserMedia(constraints);\n            logger.log(\n                `MediaHandler getUserMediaStreamInternal() calling getUserMediaStream (streamId=${\n                    stream.id\n                }, shouldRequestAudio=${shouldRequestAudio}, shouldRequestVideo=${shouldRequestVideo}, constraints=${JSON.stringify(\n                    constraints,\n                )})`,\n            );\n\n            for (const track of stream.getTracks()) {\n                const settings = track.getSettings();\n\n                if (track.kind === \"audio\") {\n                    this.audioInput = settings.deviceId!;\n                } else if (track.kind === \"video\") {\n                    this.videoInput = settings.deviceId!;\n                }\n            }\n\n            if (reusable) {\n                this.localUserMediaStream = stream;\n            }\n        } else {\n            stream = this.localUserMediaStream!.clone();\n            logger.log(\n                `MediaHandler getUserMediaStreamInternal() cloning (oldStreamId=${this.localUserMediaStream?.id} newStreamId=${stream.id} shouldRequestAudio=${shouldRequestAudio} shouldRequestVideo=${shouldRequestVideo})`,\n            );\n\n            if (!shouldRequestAudio) {\n                for (const track of stream.getAudioTracks()) {\n                    stream.removeTrack(track);\n                }\n            }\n\n            if (!shouldRequestVideo) {\n                for (const track of stream.getVideoTracks()) {\n                    stream.removeTrack(track);\n                }\n            }\n        }\n\n        if (reusable) {\n            this.userMediaStreams.push(stream);\n        }\n\n        this.emit(MediaHandlerEvent.LocalStreamsChanged);\n\n        return stream;\n    }\n\n    /**\n     * Stops all tracks on the provided usermedia stream\n     */\n    public stopUserMediaStream(mediaStream: MediaStream): void {\n        logger.log(`MediaHandler stopUserMediaStream() stopping (streamId=${mediaStream.id})`);\n        for (const track of mediaStream.getTracks()) {\n            track.stop();\n        }\n\n        const index = this.userMediaStreams.indexOf(mediaStream);\n\n        if (index !== -1) {\n            logger.debug(\n                `MediaHandler stopUserMediaStream() splicing usermedia stream out stream array (streamId=${mediaStream.id})`,\n                mediaStream.id,\n            );\n            this.userMediaStreams.splice(index, 1);\n        }\n\n        this.emit(MediaHandlerEvent.LocalStreamsChanged);\n\n        if (this.localUserMediaStream === mediaStream) {\n            // if we have this stream cahced, remove it, because we've stopped it\n            this.localUserMediaStream = undefined;\n        } else {\n            // If it's not the same stream. remove any tracks from the cached stream that\n            // we have just stopped, and if we do stop any, call the same method on the\n            // cached stream too in order to stop all its tracks (in case they are different)\n            // and un-cache it.\n            for (const track of mediaStream.getTracks()) {\n                if (this.localUserMediaStream?.getTrackById(track.id)) {\n                    this.stopUserMediaStream(this.localUserMediaStream);\n                    break;\n                }\n            }\n        }\n    }\n\n    /**\n     * @param opts - screensharing stream options\n     * @param reusable - is allowed to be reused by the MediaHandler\n     * @returns based on passed parameters\n     */\n    public async getScreensharingStream(opts: IScreensharingOpts = {}, reusable = true): Promise<MediaStream> {\n        let stream: MediaStream;\n\n        if (this.screensharingStreams.length === 0) {\n            const screenshareConstraints = this.getScreenshareContraints(opts);\n\n            if (opts.desktopCapturerSourceId) {\n                // We are using Electron\n                logger.debug(\n                    `MediaHandler getScreensharingStream() calling getUserMedia() (opts=${JSON.stringify(opts)})`,\n                );\n                stream = await navigator.mediaDevices.getUserMedia(screenshareConstraints);\n            } else {\n                // We are not using Electron\n                logger.debug(\n                    `MediaHandler getScreensharingStream() calling getDisplayMedia() (opts=${JSON.stringify(opts)})`,\n                );\n                stream = await navigator.mediaDevices.getDisplayMedia(screenshareConstraints);\n            }\n        } else {\n            const matchingStream = this.screensharingStreams[this.screensharingStreams.length - 1];\n            logger.log(`MediaHandler getScreensharingStream() cloning (streamId=${matchingStream.id})`);\n            stream = matchingStream.clone();\n        }\n\n        if (reusable) {\n            this.screensharingStreams.push(stream);\n        }\n\n        this.emit(MediaHandlerEvent.LocalStreamsChanged);\n\n        return stream;\n    }\n\n    /**\n     * Stops all tracks on the provided screensharing stream\n     */\n    public stopScreensharingStream(mediaStream: MediaStream): void {\n        logger.debug(`MediaHandler stopScreensharingStream() stopping stream (streamId=${mediaStream.id})`);\n        for (const track of mediaStream.getTracks()) {\n            track.stop();\n        }\n\n        const index = this.screensharingStreams.indexOf(mediaStream);\n\n        if (index !== -1) {\n            logger.debug(`MediaHandler stopScreensharingStream() splicing stream out (streamId=${mediaStream.id})`);\n            this.screensharingStreams.splice(index, 1);\n        }\n\n        this.emit(MediaHandlerEvent.LocalStreamsChanged);\n    }\n\n    /**\n     * Stops all local media tracks\n     */\n    public stopAllStreams(): void {\n        for (const stream of this.userMediaStreams) {\n            logger.log(`MediaHandler stopAllStreams() stopping (streamId=${stream.id})`);\n            for (const track of stream.getTracks()) {\n                track.stop();\n            }\n        }\n\n        for (const stream of this.screensharingStreams) {\n            for (const track of stream.getTracks()) {\n                track.stop();\n            }\n        }\n\n        this.userMediaStreams = [];\n        this.screensharingStreams = [];\n        this.localUserMediaStream = undefined;\n\n        this.emit(MediaHandlerEvent.LocalStreamsChanged);\n    }\n\n    private getUserMediaContraints(audio: boolean, video: boolean): MediaStreamConstraints {\n        const isWebkit = !!navigator.webkitGetUserMedia;\n\n        return {\n            audio: audio\n                ? {\n                      deviceId: this.audioInput ? { ideal: this.audioInput } : undefined,\n                      autoGainControl: this.audioSettings ? { ideal: this.audioSettings.autoGainControl } : undefined,\n                      echoCancellation: this.audioSettings ? { ideal: this.audioSettings.echoCancellation } : undefined,\n                      noiseSuppression: this.audioSettings ? { ideal: this.audioSettings.noiseSuppression } : undefined,\n                  }\n                : false,\n            video: video\n                ? {\n                      deviceId: this.videoInput ? { ideal: this.videoInput } : undefined,\n                      /* We want 640x360.  Chrome will give it only if we ask exactly,\n                   FF refuses entirely if we ask exactly, so have to ask for ideal\n                   instead\n                   XXX: Is this still true?\n                 */\n                      width: isWebkit ? { exact: 640 } : { ideal: 640 },\n                      height: isWebkit ? { exact: 360 } : { ideal: 360 },\n                  }\n                : false,\n        };\n    }\n\n    private getScreenshareContraints(opts: IScreensharingOpts): DesktopCapturerConstraints {\n        const { desktopCapturerSourceId, audio } = opts;\n        if (desktopCapturerSourceId) {\n            return {\n                audio: audio ?? false,\n                video: {\n                    mandatory: {\n                        chromeMediaSource: \"desktop\",\n                        chromeMediaSourceId: desktopCapturerSourceId,\n                    },\n                },\n            };\n        } else {\n            return {\n                audio: audio ?? false,\n                video: true,\n            };\n        }\n    }\n}\n","/*\nCopyright 2023 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { type ConnectionStatsBandwidth, type ConnectionStatsBitrate, type PacketLoss } from \"./connectionStats.ts\";\nimport { type TransportStats } from \"./transportStats.ts\";\nimport { type Resolution } from \"./media/mediaTrackStats.ts\";\n\nexport enum StatsReport {\n    CONNECTION_STATS = \"StatsReport.connection_stats\",\n    CALL_FEED_REPORT = \"StatsReport.call_feed_report\",\n    BYTE_SENT_STATS = \"StatsReport.byte_sent_stats\",\n    SUMMARY_STATS = \"StatsReport.summary_stats\",\n}\n\n/// ByteSentStatsReport ################################################################################################\nexport interface ByteSentStatsReport extends Map<TrackID, ByteSend> {\n    callId?: string;\n    opponentMemberId?: string;\n    // is a map: `local trackID` => byte send\n}\n\nexport type TrackID = string;\nexport type ByteSend = number;\n\n/// ConnectionStatsReport ##############################################################################################\nexport interface ConnectionStatsReport {\n    callId?: string;\n    opponentMemberId?: string;\n    bandwidth: ConnectionStatsBandwidth;\n    bitrate: ConnectionStatsBitrate;\n    packetLoss: PacketLoss;\n    audioConcealment: Map<TrackID, AudioConcealment>;\n    totalAudioConcealment: AudioConcealment;\n    resolution: ResolutionMap;\n    framerate: FramerateMap;\n    codec: CodecMap;\n    jitter: Map<TrackID, number>;\n    transport: TransportStats[];\n}\n\nexport interface AudioConcealment {\n    concealedAudio: number;\n    totalAudioDuration: number;\n}\n\nexport interface ResolutionMap {\n    local: Map<TrackID, Resolution>;\n    remote: Map<TrackID, Resolution>;\n}\n\nexport interface FramerateMap {\n    local: Map<TrackID, number>;\n    remote: Map<TrackID, number>;\n}\n\nexport interface CodecMap {\n    local: Map<TrackID, string>;\n    remote: Map<TrackID, string>;\n}\n\n/// SummaryStatsReport #################################################################################################\nexport interface SummaryStatsReport {\n    /**\n     * Aggregated the information for percentage of received media\n     *\n     * This measure whether the current user receive data from a call participants.\n     * As soon as a participant sends at least a byte media to this user, this counts as one measurement unit.\n     * The units of measure divided by the total number of participants is a value between 0 and 1.\n     */\n    percentageReceivedMedia: number;\n    percentageReceivedAudioMedia: number;\n    percentageReceivedVideoMedia: number;\n    maxJitter: number;\n    maxPacketLoss: number;\n    percentageConcealedAudio: number;\n    peerConnections: number;\n    opponentUsersInCall?: number;\n    opponentDevicesInCall?: number;\n    diffDevicesToPeerConnections?: number;\n    ratioPeerConnectionToDevices?: number;\n    // Todo: Decide if we want an index (or a timestamp) of this report in relation to the group call, to help differenciate when issues occur and ignore/track initial connection delays.\n}\n\n/// CallFeedReport #####################################################################################################\nexport interface CallFeedReport {\n    callId: string;\n    opponentMemberId: string;\n    transceiver: TransceiverStats[];\n    callFeeds: CallFeedStats[];\n}\n\nexport interface CallFeedStats {\n    stream: string;\n    type: \"remote\" | \"local\";\n    audio: TrackStats | null;\n    video: TrackStats | null;\n    purpose: string;\n    prefix: string;\n    isVideoMuted: boolean;\n    isAudioMuted: boolean;\n}\n\nexport interface TransceiverStats {\n    readonly mid: string;\n    readonly sender: TrackStats | null;\n    readonly receiver: TrackStats | null;\n    readonly direction: string;\n    readonly currentDirection: string;\n}\n\nexport interface TrackStats {\n    readonly id: string;\n    readonly kind: \"audio\" | \"video\";\n    readonly settingDeviceId: string;\n    readonly constrainDeviceId: string;\n    readonly muted: boolean;\n    readonly enabled: boolean;\n    readonly readyState: \"ended\" | \"live\";\n    readonly label: string;\n}\n","\"use strict\";\n/*\nCopyright 2023 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __exportStar = (this && this.__exportStar) || function(m, exports) {\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.KEY_SEPARATOR = void 0;\nexports.KEY_SEPARATOR = \"|\";\n__exportStar(require(\"./utils\"), exports);\n__exportStar(require(\"./types\"), exports);\n","\"use strict\";\n/*\nCopyright 2023 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\nObject.defineProperty(exports, \"__esModule\", { value: true });\n","\"use strict\";\n/*\nCopyright 2017 MTRNord and Cooperative EITA\nCopyright 2017 Vector Creations Ltd.\nCopyright 2019 Michael Telatynski <7t3chguy@gmail.com>\nCopyright 2019 - 2022 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.getNormalizedLanguageKeys = exports.normalizeLanguageKey = void 0;\n/**\n * Returns a language string with underscores replaced with\n * hyphens, and lower-cased.\n *\n * @param {string} language The language string to be normalized\n * @returns {string} The normalized language string\n */\nfunction normalizeLanguageKey(language) {\n    return language.toLowerCase().replace(\"_\", \"-\");\n}\nexports.normalizeLanguageKey = normalizeLanguageKey;\n/**\n * Turns a language string, normalises it,\n * (see normalizeLanguageKey) into an array of language strings\n * with fallback to generic languages\n * (e.g. 'pt-BR' => ['pt-br', 'pt'])\n *\n * @param language The input language string\n * @return a list of normalised languages\n */\nfunction getNormalizedLanguageKeys(language) {\n    const languageKeys = [];\n    const normalizedLanguage = normalizeLanguageKey(language);\n    const languageParts = normalizedLanguage.split(\"-\");\n    if (languageParts.length === 2 && languageParts[0] === languageParts[1]) {\n        languageKeys.push(languageParts[0]);\n    }\n    else {\n        languageKeys.push(normalizedLanguage);\n        if (languageParts.length === 2) {\n            languageKeys.push(languageParts[0]);\n        }\n    }\n    return languageKeys;\n}\nexports.getNormalizedLanguageKeys = getNormalizedLanguageKeys;\n","/*\n * Copyright 2020 - 2024 The Matrix.org Foundation C.I.C.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *         http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { EventEmitter } from \"events\";\n\nimport { ITransport } from \"./transport/ITransport\";\nimport { Widget } from \"./models/Widget\";\nimport { PostmessageTransport } from \"./transport/PostmessageTransport\";\nimport { WidgetApiDirection } from \"./interfaces/WidgetApiDirection\";\nimport { IWidgetApiRequest, IWidgetApiRequestEmptyData } from \"./interfaces/IWidgetApiRequest\";\nimport { IContentLoadedActionRequest } from \"./interfaces/ContentLoadedAction\";\nimport { WidgetApiFromWidgetAction, WidgetApiToWidgetAction } from \"./interfaces/WidgetApiAction\";\nimport { IWidgetApiErrorResponseData } from \"./interfaces/IWidgetApiErrorResponse\";\nimport {\n    Capability,\n    MatrixCapabilities,\n    getTimelineRoomIDFromCapability,\n    isTimelineCapability,\n} from \"./interfaces/Capabilities\";\nimport { IOpenIDUpdate, ISendEventDetails, ISendDelayedEventDetails, WidgetDriver } from \"./driver/WidgetDriver\";\nimport {\n    ICapabilitiesActionResponseData,\n    INotifyCapabilitiesActionRequestData,\n    IRenegotiateCapabilitiesActionRequest,\n} from \"./interfaces/CapabilitiesAction\";\nimport {\n    ISupportedVersionsActionRequest,\n    ISupportedVersionsActionResponseData,\n} from \"./interfaces/SupportedVersionsAction\";\nimport { ApiVersion, CurrentApiVersions, UnstableApiVersion } from \"./interfaces/ApiVersion\";\nimport { IScreenshotActionResponseData } from \"./interfaces/ScreenshotAction\";\nimport { IVisibilityActionRequestData } from \"./interfaces/VisibilityAction\";\nimport { IWidgetApiAcknowledgeResponseData, IWidgetApiResponseData } from \"./interfaces/IWidgetApiResponse\";\nimport {\n    IModalWidgetButtonClickedRequestData,\n    IModalWidgetOpenRequestData,\n    IModalWidgetOpenRequestDataButton,\n    IModalWidgetReturnData,\n} from \"./interfaces/ModalWidgetActions\";\nimport {\n    ISendEventFromWidgetActionRequest,\n    ISendEventFromWidgetResponseData,\n    ISendEventToWidgetRequestData,\n} from \"./interfaces/SendEventAction\";\nimport {\n    ISendToDeviceFromWidgetActionRequest,\n    ISendToDeviceFromWidgetResponseData,\n    ISendToDeviceToWidgetRequestData,\n} from \"./interfaces/SendToDeviceAction\";\nimport { EventDirection, EventKind, WidgetEventCapability } from \"./models/WidgetEventCapability\";\nimport { IRoomEvent } from \"./interfaces/IRoomEvent\";\nimport { IRoomAccountData } from \"./interfaces/IRoomAccountData\";\nimport {\n    IGetOpenIDActionRequest,\n    IGetOpenIDActionResponseData,\n    IOpenIDCredentials,\n    OpenIDRequestState,\n} from \"./interfaces/GetOpenIDAction\";\nimport { SimpleObservable } from \"./util/SimpleObservable\";\nimport { IOpenIDCredentialsActionRequestData } from \"./interfaces/OpenIDCredentialsAction\";\nimport { INavigateActionRequest } from \"./interfaces/NavigateAction\";\nimport { IReadEventFromWidgetActionRequest, IReadEventFromWidgetResponseData } from \"./interfaces/ReadEventAction\";\nimport {\n    ITurnServer,\n    IWatchTurnServersRequest,\n    IUnwatchTurnServersRequest,\n    IUpdateTurnServersRequestData,\n} from \"./interfaces/TurnServerActions\";\nimport { Symbols } from \"./Symbols\";\nimport {\n    IReadRelationsFromWidgetActionRequest,\n    IReadRelationsFromWidgetResponseData,\n} from \"./interfaces/ReadRelationsAction\";\nimport {\n    IUserDirectorySearchFromWidgetActionRequest,\n    IUserDirectorySearchFromWidgetResponseData,\n} from \"./interfaces/UserDirectorySearchAction\";\nimport {\n    IReadRoomAccountDataFromWidgetActionRequest,\n    IReadRoomAccountDataFromWidgetResponseData,\n} from \"./interfaces/ReadRoomAccountDataAction\";\nimport {\n    IGetMediaConfigActionFromWidgetActionRequest,\n    IGetMediaConfigActionFromWidgetResponseData,\n} from \"./interfaces/GetMediaConfigAction\";\nimport {\n    IUpdateDelayedEventFromWidgetActionRequest,\n    UpdateDelayedEventAction,\n} from \"./interfaces/UpdateDelayedEventAction\";\nimport {\n    IUploadFileActionFromWidgetActionRequest,\n    IUploadFileActionFromWidgetResponseData,\n} from \"./interfaces/UploadFileAction\";\nimport {\n    IDownloadFileActionFromWidgetActionRequest,\n    IDownloadFileActionFromWidgetResponseData,\n} from \"./interfaces/DownloadFileAction\";\nimport { IThemeChangeActionRequestData } from \"./interfaces/ThemeChangeAction\";\nimport { IUpdateStateToWidgetRequestData } from \"./interfaces/UpdateStateAction\";\n\n/**\n * API handler for the client side of widgets. This raises events\n * for each action received as `action:${action}` (eg: \"action:screenshot\").\n * Default handling can be prevented by using preventDefault() on the\n * raised event. The default handling varies for each action: ones\n * which the SDK can handle safely are acknowledged appropriately and\n * ones which are unhandled (custom or require the client to do something)\n * are rejected with an error.\n *\n * Events which are preventDefault()ed must reply using the transport.\n * The events raised will have a default of an IWidgetApiRequest\n * interface.\n *\n * When the ClientWidgetApi is ready to start sending requests, it will\n * raise a \"ready\" CustomEvent. After the ready event fires, actions can\n * be sent and the transport will be ready.\n *\n * When the widget has indicated it has loaded, this class raises a\n * \"preparing\" CustomEvent. The preparing event does not indicate that\n * the widget is ready to receive communications - that is signified by\n * the ready event exclusively.\n *\n * This class only handles one widget at a time.\n */\nexport class ClientWidgetApi extends EventEmitter {\n    public readonly transport: ITransport;\n\n    private cachedWidgetVersions: ApiVersion[] | null = null;\n    // contentLoadedActionSent is used to check that only one ContentLoaded request is send.\n    private contentLoadedActionSent = false;\n    private allowedCapabilities = new Set<Capability>();\n    private allowedEvents: WidgetEventCapability[] = [];\n    private isStopped = false;\n    private turnServers: AsyncGenerator<ITurnServer> | null = null;\n    private contentLoadedWaitTimer?: ReturnType<typeof setTimeout>;\n    // Stores pending requests to push a room's state to the widget\n    private pushRoomStateTasks = new Set<Promise<void>>();\n    // Room ID → event type → state key → events to be pushed\n    private pushRoomStateResult = new Map<string, Map<string, Map<string, IRoomEvent>>>();\n    private flushRoomStateTask: Promise<void> | null = null;\n\n    /**\n     * Creates a new client widget API. This will instantiate the transport\n     * and start everything. When the iframe is loaded under the widget's\n     * conditions, a \"ready\" event will be raised.\n     * @param {Widget} widget The widget to communicate with.\n     * @param {HTMLIFrameElement} iframe The iframe the widget is in.\n     * @param {WidgetDriver} driver The driver for this widget/client.\n     */\n    public constructor(\n        public readonly widget: Widget,\n        private iframe: HTMLIFrameElement,\n        private driver: WidgetDriver,\n    ) {\n        super();\n        if (!iframe?.contentWindow) {\n            throw new Error(\"No iframe supplied\");\n        }\n        if (!widget) {\n            throw new Error(\"Invalid widget\");\n        }\n        if (!driver) {\n            throw new Error(\"Invalid driver\");\n        }\n        this.transport = new PostmessageTransport(WidgetApiDirection.ToWidget, widget.id, iframe.contentWindow, window);\n        this.transport.targetOrigin = widget.origin;\n        this.transport.on(\"message\", this.handleMessage.bind(this));\n\n        iframe.addEventListener(\"load\", this.onIframeLoad.bind(this));\n\n        this.transport.start();\n    }\n\n    public hasCapability(capability: Capability): boolean {\n        return this.allowedCapabilities.has(capability);\n    }\n\n    public canUseRoomTimeline(roomId: string | Symbols.AnyRoom): boolean {\n        return (\n            this.hasCapability(`org.matrix.msc2762.timeline:${Symbols.AnyRoom}`) ||\n            this.hasCapability(`org.matrix.msc2762.timeline:${roomId}`)\n        );\n    }\n\n    public canSendRoomEvent(eventType: string, msgtype: string | null = null): boolean {\n        return this.allowedEvents.some((e) => e.matchesAsRoomEvent(EventDirection.Send, eventType, msgtype));\n    }\n\n    public canSendStateEvent(eventType: string, stateKey: string): boolean {\n        return this.allowedEvents.some((e) => e.matchesAsStateEvent(EventDirection.Send, eventType, stateKey));\n    }\n\n    public canSendToDeviceEvent(eventType: string): boolean {\n        return this.allowedEvents.some((e) => e.matchesAsToDeviceEvent(EventDirection.Send, eventType));\n    }\n\n    public canReceiveRoomEvent(eventType: string, msgtype: string | null = null): boolean {\n        return this.allowedEvents.some((e) => e.matchesAsRoomEvent(EventDirection.Receive, eventType, msgtype));\n    }\n\n    public canReceiveStateEvent(eventType: string, stateKey: string | null): boolean {\n        return this.allowedEvents.some((e) => e.matchesAsStateEvent(EventDirection.Receive, eventType, stateKey));\n    }\n\n    public canReceiveToDeviceEvent(eventType: string): boolean {\n        return this.allowedEvents.some((e) => e.matchesAsToDeviceEvent(EventDirection.Receive, eventType));\n    }\n\n    public canReceiveRoomAccountData(eventType: string): boolean {\n        return this.allowedEvents.some((e) => e.matchesAsRoomAccountData(EventDirection.Receive, eventType));\n    }\n\n    public stop(): void {\n        this.isStopped = true;\n        this.transport.stop();\n    }\n\n    public async getWidgetVersions(): Promise<ApiVersion[]> {\n        if (Array.isArray(this.cachedWidgetVersions)) {\n            return Promise.resolve(this.cachedWidgetVersions);\n        }\n\n        try {\n            const r = await this.transport.send<IWidgetApiRequestEmptyData, ISupportedVersionsActionResponseData>(\n                WidgetApiToWidgetAction.SupportedApiVersions,\n                {},\n            );\n            this.cachedWidgetVersions = r.supported_versions;\n            return r.supported_versions;\n        } catch (e) {\n            console.warn(\"non-fatal error getting supported widget versions: \", e);\n            return [];\n        }\n    }\n\n    private beginCapabilities(): void {\n        // widget has loaded - tell all the listeners that\n        this.emit(\"preparing\");\n\n        let requestedCaps: Capability[];\n        this.transport\n            .send<IWidgetApiRequestEmptyData, ICapabilitiesActionResponseData>(WidgetApiToWidgetAction.Capabilities, {})\n            .then((caps) => {\n                requestedCaps = caps.capabilities;\n                return this.driver.validateCapabilities(new Set(caps.capabilities));\n            })\n            .then((allowedCaps) => {\n                this.allowCapabilities([...allowedCaps], requestedCaps);\n                this.emit(\"ready\");\n            })\n            .catch((e) => {\n                this.emit(\"error:preparing\", e);\n            });\n    }\n\n    private allowCapabilities(allowed: string[], requested: string[]): void {\n        console.log(`Widget ${this.widget.id} is allowed capabilities:`, allowed);\n\n        for (const c of allowed) this.allowedCapabilities.add(c);\n        const allowedEvents = WidgetEventCapability.findEventCapabilities(allowed);\n        this.allowedEvents.push(...allowedEvents);\n\n        this.transport\n            .send(WidgetApiToWidgetAction.NotifyCapabilities, <INotifyCapabilitiesActionRequestData>{\n                requested,\n                approved: Array.from(this.allowedCapabilities),\n            })\n            .catch((e) => {\n                console.warn(\"non-fatal error notifying widget of approved capabilities:\", e);\n            })\n            .then(() => {\n                this.emit(\"capabilitiesNotified\");\n            });\n\n        // Push the initial room state for all rooms with a timeline capability\n        for (const c of allowed) {\n            if (isTimelineCapability(c)) {\n                const roomId = getTimelineRoomIDFromCapability(c);\n                if (roomId === Symbols.AnyRoom) {\n                    for (const roomId of this.driver.getKnownRooms()) this.pushRoomState(roomId);\n                } else {\n                    this.pushRoomState(roomId);\n                }\n            }\n        }\n        // If new events are allowed and the currently viewed room isn't covered\n        // by a timeline capability, then we know that there could be some state\n        // in the viewed room that the widget hasn't learned about yet- push it.\n        if (allowedEvents.length > 0 && this.viewedRoomId !== null && !this.canUseRoomTimeline(this.viewedRoomId)) {\n            this.pushRoomState(this.viewedRoomId);\n        }\n    }\n\n    private onIframeLoad(ev: Event): void {\n        if (this.widget.waitForIframeLoad) {\n            // If the widget is set to waitForIframeLoad the capabilities immediately get setup after load.\n            // The client does not wait for the ContentLoaded action.\n            this.beginCapabilities();\n        } else {\n            // Reaching this means, that the Iframe got reloaded/loaded and\n            // the clientApi is awaiting the FIRST ContentLoaded action.\n            console.log(\"waitForIframeLoad is false: waiting for widget to send contentLoaded\");\n            this.contentLoadedWaitTimer = setTimeout(() => {\n                console.error(\n                    \"Widget specified waitForIframeLoad=false but timed out waiting for contentLoaded event!\",\n                );\n            }, 10000);\n            this.contentLoadedActionSent = false;\n        }\n    }\n\n    private handleContentLoadedAction(action: IContentLoadedActionRequest): void {\n        if (this.contentLoadedWaitTimer !== undefined) {\n            clearTimeout(this.contentLoadedWaitTimer);\n            this.contentLoadedWaitTimer = undefined;\n        }\n        if (this.contentLoadedActionSent) {\n            throw new Error(\n                \"Improper sequence: ContentLoaded Action can only be sent once after the widget loaded \" +\n                    \"and should only be used if waitForIframeLoad is false (default=true)\",\n            );\n        }\n        if (this.widget.waitForIframeLoad) {\n            this.transport.reply(action, <IWidgetApiErrorResponseData>{\n                error: {\n                    message:\n                        \"Improper sequence: not expecting ContentLoaded event if \" +\n                        \"waitForIframeLoad is true (default=true)\",\n                },\n            });\n        } else {\n            this.transport.reply(action, <IWidgetApiRequestEmptyData>{});\n            this.beginCapabilities();\n        }\n        this.contentLoadedActionSent = true;\n    }\n\n    private replyVersions(request: ISupportedVersionsActionRequest): void {\n        this.transport.reply<ISupportedVersionsActionResponseData>(request, {\n            supported_versions: CurrentApiVersions,\n        });\n    }\n\n    private async supportsUpdateState(): Promise<boolean> {\n        return (await this.getWidgetVersions()).includes(UnstableApiVersion.MSC2762_UPDATE_STATE);\n    }\n\n    private handleCapabilitiesRenegotiate(request: IRenegotiateCapabilitiesActionRequest): void {\n        // acknowledge first\n        this.transport.reply<IWidgetApiAcknowledgeResponseData>(request, {});\n\n        const requested = request.data?.capabilities || [];\n        const newlyRequested = new Set(requested.filter((r) => !this.hasCapability(r)));\n        if (newlyRequested.size === 0) {\n            // Nothing to do - skip validation\n            this.allowCapabilities([], []);\n        }\n\n        this.driver\n            .validateCapabilities(newlyRequested)\n            .then((allowed) => this.allowCapabilities([...allowed], [...newlyRequested]));\n    }\n\n    private handleNavigate(request: INavigateActionRequest): void {\n        if (!this.hasCapability(MatrixCapabilities.MSC2931Navigate)) {\n            return this.transport.reply<IWidgetApiErrorResponseData>(request, {\n                error: { message: \"Missing capability\" },\n            });\n        }\n\n        if (!request.data?.uri || !request.data?.uri.toString().startsWith(\"https://matrix.to/#\")) {\n            return this.transport.reply<IWidgetApiErrorResponseData>(request, {\n                error: { message: \"Invalid matrix.to URI\" },\n            });\n        }\n\n        const onErr = (e: unknown): void => {\n            console.error(\"[ClientWidgetApi] Failed to handle navigation: \", e);\n            this.handleDriverError(e, request, \"Error handling navigation\");\n        };\n\n        try {\n            this.driver\n                .navigate(request.data.uri.toString())\n                .catch((e: unknown) => onErr(e))\n                .then(() => {\n                    return this.transport.reply<IWidgetApiAcknowledgeResponseData>(request, {});\n                });\n        } catch (e) {\n            return onErr(e);\n        }\n    }\n\n    private handleOIDC(request: IGetOpenIDActionRequest): void {\n        let phase = 1; // 1 = initial request, 2 = after user manual confirmation\n\n        const replyState = (\n            state: OpenIDRequestState,\n            credential?: IOpenIDCredentials,\n        ): void | Promise<IWidgetApiAcknowledgeResponseData> => {\n            credential = credential || {};\n            if (phase > 1) {\n                return this.transport.send<IOpenIDCredentialsActionRequestData>(\n                    WidgetApiToWidgetAction.OpenIDCredentials,\n                    {\n                        state: state,\n                        original_request_id: request.requestId,\n                        ...credential,\n                    },\n                );\n            } else {\n                return this.transport.reply<IGetOpenIDActionResponseData>(request, {\n                    state: state,\n                    ...credential,\n                });\n            }\n        };\n\n        const replyError = (msg: string): void | Promise<IWidgetApiAcknowledgeResponseData> => {\n            console.error(\"[ClientWidgetApi] Failed to handle OIDC: \", msg);\n            if (phase > 1) {\n                // We don't have a way to indicate that a random error happened in this flow, so\n                // just block the attempt.\n                return replyState(OpenIDRequestState.Blocked);\n            } else {\n                return this.transport.reply<IWidgetApiErrorResponseData>(request, {\n                    error: { message: msg },\n                });\n            }\n        };\n\n        const observer = new SimpleObservable<IOpenIDUpdate>((update) => {\n            if (update.state === OpenIDRequestState.PendingUserConfirmation && phase > 1) {\n                observer.close();\n                return replyError(\"client provided out-of-phase response to OIDC flow\");\n            }\n\n            if (update.state === OpenIDRequestState.PendingUserConfirmation) {\n                replyState(update.state);\n                phase++;\n                return;\n            }\n\n            if (update.state === OpenIDRequestState.Allowed && !update.token) {\n                return replyError(\"client provided invalid OIDC token for an allowed request\");\n            }\n            if (update.state === OpenIDRequestState.Blocked) {\n                update.token = undefined; // just in case the client did something weird\n            }\n\n            observer.close();\n            return replyState(update.state, update.token);\n        });\n\n        this.driver.askOpenID(observer);\n    }\n    private handleReadRoomAccountData(request: IReadRoomAccountDataFromWidgetActionRequest): void | Promise<void> {\n        let events: Promise<IRoomAccountData[]> = Promise.resolve([]);\n        events = this.driver.readRoomAccountData(request.data.type);\n\n        if (!this.canReceiveRoomAccountData(request.data.type)) {\n            return this.transport.reply<IWidgetApiErrorResponseData>(request, {\n                error: { message: \"Cannot read room account data of this type\" },\n            });\n        }\n\n        return events.then((evs) => {\n            this.transport.reply<IReadRoomAccountDataFromWidgetResponseData>(request, { events: evs });\n        });\n    }\n\n    private async handleReadEvents(request: IReadEventFromWidgetActionRequest): Promise<void> {\n        if (!request.data.type) {\n            return this.transport.reply<IWidgetApiErrorResponseData>(request, {\n                error: { message: \"Invalid request - missing event type\" },\n            });\n        }\n        if (request.data.limit !== undefined && (!request.data.limit || request.data.limit < 0)) {\n            return this.transport.reply<IWidgetApiErrorResponseData>(request, {\n                error: { message: \"Invalid request - limit out of range\" },\n            });\n        }\n\n        let askRoomIds: string[];\n        if (request.data.room_ids === undefined) {\n            askRoomIds = this.viewedRoomId === null ? [] : [this.viewedRoomId];\n        } else if (request.data.room_ids === Symbols.AnyRoom) {\n            askRoomIds = this.driver.getKnownRooms().filter((roomId) => this.canUseRoomTimeline(roomId));\n        } else {\n            askRoomIds = request.data.room_ids;\n            for (const roomId of askRoomIds) {\n                if (!this.canUseRoomTimeline(roomId)) {\n                    return this.transport.reply<IWidgetApiErrorResponseData>(request, {\n                        error: { message: `Unable to access room timeline: ${roomId}` },\n                    });\n                }\n            }\n        }\n\n        const limit = request.data.limit || 0;\n        const since = request.data.since;\n\n        let stateKey: string | undefined = undefined;\n        let msgtype: string | undefined = undefined;\n        if (request.data.state_key !== undefined) {\n            stateKey = request.data.state_key === true ? undefined : request.data.state_key.toString();\n            if (!this.canReceiveStateEvent(request.data.type, stateKey ?? null)) {\n                return this.transport.reply<IWidgetApiErrorResponseData>(request, {\n                    error: { message: \"Cannot read state events of this type\" },\n                });\n            }\n        } else {\n            msgtype = request.data.msgtype;\n            if (!this.canReceiveRoomEvent(request.data.type, msgtype)) {\n                return this.transport.reply<IWidgetApiErrorResponseData>(request, {\n                    error: { message: \"Cannot read room events of this type\" },\n                });\n            }\n        }\n\n        let events: IRoomEvent[];\n\n        if (request.data.room_ids === undefined && askRoomIds.length === 0) {\n            // For backwards compatibility we still call the deprecated\n            // readRoomEvents and readStateEvents methods in case the client isn't\n            // letting us know the currently viewed room via setViewedRoomId\n            //\n            // This can be considered as a deprecated implementation.\n            // A driver should call `setViewedRoomId` on the widget messaging and implement the new readRoomState and readRoomTimeline\n            // Methods.\n            // This block makes sure that it is also possible to not use setViewedRoomId.\n            // readRoomTimeline and readRoomState are required however! Otherwise widget requests that include\n            // `room_ids` will fail.\n            console.warn(\n                \"The widgetDriver uses deprecated behaviour:\\n It does not set the viewedRoomId using `setViewedRoomId`\",\n            );\n            events = await // This returns [] with the current driver of Element Web.\n            // Add default implementations of the `readRoomEvents` and `readStateEvents`\n            // methods to use `readRoomTimeline` and `readRoomState` if they are not overwritten.\n            (request.data.state_key === undefined\n                ? this.driver.readRoomEvents(request.data.type, msgtype, limit, null, since)\n                : this.driver.readStateEvents(request.data.type, stateKey, limit, null));\n        } else if (await this.supportsUpdateState()) {\n            // Calling read_events with a stateKey still reads from the rooms timeline (not the room state).\n            events = (\n                await Promise.all(\n                    askRoomIds.map((roomId) =>\n                        this.driver.readRoomTimeline(roomId, request.data.type, msgtype, stateKey, limit, since),\n                    ),\n                )\n            ).flat(1);\n        } else {\n            // TODO: remove this once `UnstableApiVersion.MSC2762_UPDATE_STATE` becomes stable.\n            // Before version `MSC2762_UPDATE_STATE` we used readRoomState for read_events actions.\n            events = (\n                request.data.state_key === undefined\n                    ? await Promise.all(\n                          askRoomIds.map((roomId) =>\n                              this.driver.readRoomTimeline(roomId, request.data.type, msgtype, stateKey, limit, since),\n                          ),\n                      )\n                    : await Promise.all(\n                          askRoomIds.map((roomId) => this.driver.readRoomState(roomId, request.data.type, stateKey)),\n                      )\n            ).flat(1);\n        }\n\n        this.transport.reply<IReadEventFromWidgetResponseData>(request, { events });\n    }\n\n    private handleSendEvent(request: ISendEventFromWidgetActionRequest): void {\n        if (!request.data.type) {\n            return this.transport.reply<IWidgetApiErrorResponseData>(request, {\n                error: { message: \"Invalid request - missing event type\" },\n            });\n        }\n\n        if (!!request.data.room_id && !this.canUseRoomTimeline(request.data.room_id)) {\n            return this.transport.reply<IWidgetApiErrorResponseData>(request, {\n                error: { message: `Unable to access room timeline: ${request.data.room_id}` },\n            });\n        }\n\n        const isDelayedEvent = request.data.delay !== undefined || request.data.parent_delay_id !== undefined;\n        if (isDelayedEvent && !this.hasCapability(MatrixCapabilities.MSC4157SendDelayedEvent)) {\n            return this.transport.reply<IWidgetApiErrorResponseData>(request, {\n                error: { message: \"Missing capability\" },\n            });\n        }\n\n        let sendEventPromise: Promise<ISendEventDetails | ISendDelayedEventDetails>;\n        if (request.data.state_key !== undefined) {\n            if (!this.canSendStateEvent(request.data.type, request.data.state_key)) {\n                return this.transport.reply<IWidgetApiErrorResponseData>(request, {\n                    error: { message: \"Cannot send state events of this type\" },\n                });\n            }\n\n            if (!isDelayedEvent) {\n                sendEventPromise = this.driver.sendEvent(\n                    request.data.type,\n                    request.data.content || {},\n                    request.data.state_key,\n                    request.data.room_id,\n                );\n            } else {\n                sendEventPromise = this.driver.sendDelayedEvent(\n                    request.data.delay ?? null,\n                    request.data.parent_delay_id ?? null,\n                    request.data.type,\n                    request.data.content || {},\n                    request.data.state_key,\n                    request.data.room_id,\n                );\n            }\n        } else {\n            const content = (request.data.content as { msgtype?: string }) || {};\n            const msgtype = content[\"msgtype\"];\n            if (!this.canSendRoomEvent(request.data.type, msgtype)) {\n                return this.transport.reply<IWidgetApiErrorResponseData>(request, {\n                    error: { message: \"Cannot send room events of this type\" },\n                });\n            }\n\n            if (!isDelayedEvent) {\n                sendEventPromise = this.driver.sendEvent(\n                    request.data.type,\n                    content,\n                    null, // not sending a state event\n                    request.data.room_id,\n                );\n            } else {\n                sendEventPromise = this.driver.sendDelayedEvent(\n                    request.data.delay ?? null,\n                    request.data.parent_delay_id ?? null,\n                    request.data.type,\n                    content,\n                    null, // not sending a state event\n                    request.data.room_id,\n                );\n            }\n        }\n\n        sendEventPromise\n            .then((sentEvent) => {\n                return this.transport.reply<ISendEventFromWidgetResponseData>(request, {\n                    room_id: sentEvent.roomId,\n                    ...(\"eventId\" in sentEvent\n                        ? {\n                              event_id: sentEvent.eventId,\n                          }\n                        : {\n                              delay_id: sentEvent.delayId,\n                          }),\n                });\n            })\n            .catch((e: unknown) => {\n                console.error(\"error sending event: \", e);\n                this.handleDriverError(e, request, \"Error sending event\");\n            });\n    }\n\n    private handleUpdateDelayedEvent(request: IUpdateDelayedEventFromWidgetActionRequest): void {\n        if (!request.data.delay_id) {\n            return this.transport.reply<IWidgetApiErrorResponseData>(request, {\n                error: { message: \"Invalid request - missing delay_id\" },\n            });\n        }\n\n        if (!this.hasCapability(MatrixCapabilities.MSC4157UpdateDelayedEvent)) {\n            return this.transport.reply<IWidgetApiErrorResponseData>(request, {\n                error: { message: \"Missing capability\" },\n            });\n        }\n\n        switch (request.data.action) {\n            case UpdateDelayedEventAction.Cancel:\n            case UpdateDelayedEventAction.Restart:\n            case UpdateDelayedEventAction.Send:\n                this.driver\n                    .updateDelayedEvent(request.data.delay_id, request.data.action)\n                    .then(() => {\n                        return this.transport.reply<IWidgetApiAcknowledgeResponseData>(request, {});\n                    })\n                    .catch((e: unknown) => {\n                        console.error(\"error updating delayed event: \", e);\n                        this.handleDriverError(e, request, \"Error updating delayed event\");\n                    });\n                break;\n            default:\n                return this.transport.reply<IWidgetApiErrorResponseData>(request, {\n                    error: { message: \"Invalid request - unsupported action\" },\n                });\n        }\n    }\n\n    private async handleSendToDevice(request: ISendToDeviceFromWidgetActionRequest): Promise<void> {\n        if (!request.data.type) {\n            await this.transport.reply<IWidgetApiErrorResponseData>(request, {\n                error: { message: \"Invalid request - missing event type\" },\n            });\n        } else if (!request.data.messages) {\n            await this.transport.reply<IWidgetApiErrorResponseData>(request, {\n                error: { message: \"Invalid request - missing event contents\" },\n            });\n        } else if (typeof request.data.encrypted !== \"boolean\") {\n            await this.transport.reply<IWidgetApiErrorResponseData>(request, {\n                error: { message: \"Invalid request - missing encryption flag\" },\n            });\n        } else if (!this.canSendToDeviceEvent(request.data.type)) {\n            await this.transport.reply<IWidgetApiErrorResponseData>(request, {\n                error: { message: \"Cannot send to-device events of this type\" },\n            });\n        } else {\n            try {\n                await this.driver.sendToDevice(request.data.type, request.data.encrypted, request.data.messages);\n                await this.transport.reply<ISendToDeviceFromWidgetResponseData>(request, {});\n            } catch (e) {\n                console.error(\"error sending to-device event\", e);\n                this.handleDriverError(e, request, \"Error sending event\");\n            }\n        }\n    }\n\n    private async pollTurnServers(turnServers: AsyncGenerator<ITurnServer>, initialServer: ITurnServer): Promise<void> {\n        try {\n            await this.transport.send<IUpdateTurnServersRequestData>(\n                WidgetApiToWidgetAction.UpdateTurnServers,\n                initialServer as IUpdateTurnServersRequestData, // it's compatible, but missing the index signature\n            );\n\n            // Pick the generator up where we left off\n            for await (const server of turnServers) {\n                await this.transport.send<IUpdateTurnServersRequestData>(\n                    WidgetApiToWidgetAction.UpdateTurnServers,\n                    server as IUpdateTurnServersRequestData, // it's compatible, but missing the index signature\n                );\n            }\n        } catch (e) {\n            console.error(\"error polling for TURN servers\", e);\n        }\n    }\n\n    private async handleWatchTurnServers(request: IWatchTurnServersRequest): Promise<void> {\n        if (!this.hasCapability(MatrixCapabilities.MSC3846TurnServers)) {\n            await this.transport.reply<IWidgetApiErrorResponseData>(request, {\n                error: { message: \"Missing capability\" },\n            });\n        } else if (this.turnServers) {\n            // We're already polling, so this is a no-op\n            await this.transport.reply<IWidgetApiAcknowledgeResponseData>(request, {});\n        } else {\n            try {\n                const turnServers = this.driver.getTurnServers();\n\n                // Peek at the first result, so we can at least verify that the\n                // client isn't banned from getting TURN servers entirely\n                const { done, value } = await turnServers.next();\n                if (done) throw new Error(\"Client refuses to provide any TURN servers\");\n                await this.transport.reply<IWidgetApiAcknowledgeResponseData>(request, {});\n\n                // Start the poll loop, sending the widget the initial result\n                this.pollTurnServers(turnServers, value);\n                this.turnServers = turnServers;\n            } catch (e) {\n                console.error(\"error getting first TURN server results\", e);\n                await this.transport.reply<IWidgetApiErrorResponseData>(request, {\n                    error: { message: \"TURN servers not available\" },\n                });\n            }\n        }\n    }\n\n    private async handleUnwatchTurnServers(request: IUnwatchTurnServersRequest): Promise<void> {\n        if (!this.hasCapability(MatrixCapabilities.MSC3846TurnServers)) {\n            await this.transport.reply<IWidgetApiErrorResponseData>(request, {\n                error: { message: \"Missing capability\" },\n            });\n        } else if (!this.turnServers) {\n            // We weren't polling anyways, so this is a no-op\n            await this.transport.reply<IWidgetApiAcknowledgeResponseData>(request, {});\n        } else {\n            // Stop the generator, allowing it to clean up\n            await this.turnServers.return(undefined);\n            this.turnServers = null;\n            await this.transport.reply<IWidgetApiAcknowledgeResponseData>(request, {});\n        }\n    }\n\n    private async handleReadRelations(request: IReadRelationsFromWidgetActionRequest): Promise<void> {\n        if (!request.data.event_id) {\n            return this.transport.reply<IWidgetApiErrorResponseData>(request, {\n                error: { message: \"Invalid request - missing event ID\" },\n            });\n        }\n\n        if (request.data.limit !== undefined && request.data.limit < 0) {\n            return this.transport.reply<IWidgetApiErrorResponseData>(request, {\n                error: { message: \"Invalid request - limit out of range\" },\n            });\n        }\n\n        if (request.data.room_id !== undefined && !this.canUseRoomTimeline(request.data.room_id)) {\n            return this.transport.reply<IWidgetApiErrorResponseData>(request, {\n                error: { message: `Unable to access room timeline: ${request.data.room_id}` },\n            });\n        }\n\n        try {\n            const result = await this.driver.readEventRelations(\n                request.data.event_id,\n                request.data.room_id,\n                request.data.rel_type,\n                request.data.event_type,\n                request.data.from,\n                request.data.to,\n                request.data.limit,\n                request.data.direction,\n            );\n\n            // only return events that the user has the permission to receive\n            const chunk = result.chunk.filter((e) => {\n                if (e.state_key !== undefined) {\n                    return this.canReceiveStateEvent(e.type, e.state_key);\n                } else {\n                    return this.canReceiveRoomEvent(e.type, (e.content as { msgtype?: string })[\"msgtype\"]);\n                }\n            });\n\n            return this.transport.reply<IReadRelationsFromWidgetResponseData>(request, {\n                chunk,\n                prev_batch: result.prevBatch,\n                next_batch: result.nextBatch,\n            });\n        } catch (e) {\n            console.error(\"error getting the relations\", e);\n            this.handleDriverError(e, request, \"Unexpected error while reading relations\");\n        }\n    }\n\n    private async handleUserDirectorySearch(request: IUserDirectorySearchFromWidgetActionRequest): Promise<void> {\n        if (!this.hasCapability(MatrixCapabilities.MSC3973UserDirectorySearch)) {\n            return this.transport.reply<IWidgetApiErrorResponseData>(request, {\n                error: { message: \"Missing capability\" },\n            });\n        }\n\n        if (typeof request.data.search_term !== \"string\") {\n            return this.transport.reply<IWidgetApiErrorResponseData>(request, {\n                error: { message: \"Invalid request - missing search term\" },\n            });\n        }\n\n        if (request.data.limit !== undefined && request.data.limit < 0) {\n            return this.transport.reply<IWidgetApiErrorResponseData>(request, {\n                error: { message: \"Invalid request - limit out of range\" },\n            });\n        }\n\n        try {\n            const result = await this.driver.searchUserDirectory(request.data.search_term, request.data.limit);\n\n            return this.transport.reply<IUserDirectorySearchFromWidgetResponseData>(request, {\n                limited: result.limited,\n                results: result.results.map((r) => ({\n                    user_id: r.userId,\n                    display_name: r.displayName,\n                    avatar_url: r.avatarUrl,\n                })),\n            });\n        } catch (e) {\n            console.error(\"error searching in the user directory\", e);\n            this.handleDriverError(e, request, \"Unexpected error while searching in the user directory\");\n        }\n    }\n\n    private async handleGetMediaConfig(request: IGetMediaConfigActionFromWidgetActionRequest): Promise<void> {\n        if (!this.hasCapability(MatrixCapabilities.MSC4039UploadFile)) {\n            return this.transport.reply<IWidgetApiErrorResponseData>(request, {\n                error: { message: \"Missing capability\" },\n            });\n        }\n\n        try {\n            const result = await this.driver.getMediaConfig();\n\n            return this.transport.reply<IGetMediaConfigActionFromWidgetResponseData>(request, result);\n        } catch (e) {\n            console.error(\"error while getting the media configuration\", e);\n            this.handleDriverError(e, request, \"Unexpected error while getting the media configuration\");\n        }\n    }\n\n    private async handleUploadFile(request: IUploadFileActionFromWidgetActionRequest): Promise<void> {\n        if (!this.hasCapability(MatrixCapabilities.MSC4039UploadFile)) {\n            return this.transport.reply<IWidgetApiErrorResponseData>(request, {\n                error: { message: \"Missing capability\" },\n            });\n        }\n\n        try {\n            const result = await this.driver.uploadFile(request.data.file);\n\n            return this.transport.reply<IUploadFileActionFromWidgetResponseData>(request, {\n                content_uri: result.contentUri,\n            });\n        } catch (e) {\n            console.error(\"error while uploading a file\", e);\n            this.handleDriverError(e, request, \"Unexpected error while uploading a file\");\n        }\n    }\n\n    private async handleDownloadFile(request: IDownloadFileActionFromWidgetActionRequest): Promise<void> {\n        if (!this.hasCapability(MatrixCapabilities.MSC4039DownloadFile)) {\n            return this.transport.reply<IWidgetApiErrorResponseData>(request, {\n                error: { message: \"Missing capability\" },\n            });\n        }\n\n        try {\n            const result = await this.driver.downloadFile(request.data.content_uri);\n\n            return this.transport.reply<IDownloadFileActionFromWidgetResponseData>(request, { file: result.file });\n        } catch (e) {\n            console.error(\"error while downloading a file\", e);\n            this.handleDriverError(e, request, \"Unexpected error while downloading a file\");\n        }\n    }\n\n    private handleDriverError(e: unknown, request: IWidgetApiRequest, message: string): void {\n        const data = this.driver.processError(e);\n        this.transport.reply<IWidgetApiErrorResponseData>(request, {\n            error: {\n                message,\n                ...data,\n            },\n        });\n    }\n\n    private handleMessage(ev: CustomEvent<IWidgetApiRequest>): void | Promise<void> {\n        if (this.isStopped) return;\n        const actionEv = new CustomEvent(`action:${ev.detail.action}`, {\n            detail: ev.detail,\n            cancelable: true,\n        });\n        this.emit(`action:${ev.detail.action}`, actionEv);\n        if (!actionEv.defaultPrevented) {\n            switch (ev.detail.action) {\n                case WidgetApiFromWidgetAction.ContentLoaded:\n                    return this.handleContentLoadedAction(<IContentLoadedActionRequest>ev.detail);\n                case WidgetApiFromWidgetAction.SupportedApiVersions:\n                    return this.replyVersions(<ISupportedVersionsActionRequest>ev.detail);\n                case WidgetApiFromWidgetAction.SendEvent:\n                    return this.handleSendEvent(<ISendEventFromWidgetActionRequest>ev.detail);\n                case WidgetApiFromWidgetAction.SendToDevice:\n                    return this.handleSendToDevice(<ISendToDeviceFromWidgetActionRequest>ev.detail);\n                case WidgetApiFromWidgetAction.GetOpenIDCredentials:\n                    return this.handleOIDC(<IGetOpenIDActionRequest>ev.detail);\n                case WidgetApiFromWidgetAction.MSC2931Navigate:\n                    return this.handleNavigate(<INavigateActionRequest>ev.detail);\n                case WidgetApiFromWidgetAction.MSC2974RenegotiateCapabilities:\n                    return this.handleCapabilitiesRenegotiate(<IRenegotiateCapabilitiesActionRequest>ev.detail);\n                case WidgetApiFromWidgetAction.MSC2876ReadEvents:\n                    return this.handleReadEvents(<IReadEventFromWidgetActionRequest>ev.detail);\n                case WidgetApiFromWidgetAction.WatchTurnServers:\n                    return this.handleWatchTurnServers(<IWatchTurnServersRequest>ev.detail);\n                case WidgetApiFromWidgetAction.UnwatchTurnServers:\n                    return this.handleUnwatchTurnServers(<IUnwatchTurnServersRequest>ev.detail);\n                case WidgetApiFromWidgetAction.MSC3869ReadRelations:\n                    return this.handleReadRelations(<IReadRelationsFromWidgetActionRequest>ev.detail);\n                case WidgetApiFromWidgetAction.MSC3973UserDirectorySearch:\n                    return this.handleUserDirectorySearch(<IUserDirectorySearchFromWidgetActionRequest>ev.detail);\n                case WidgetApiFromWidgetAction.BeeperReadRoomAccountData:\n                    return this.handleReadRoomAccountData(<IReadRoomAccountDataFromWidgetActionRequest>ev.detail);\n                case WidgetApiFromWidgetAction.MSC4039GetMediaConfigAction:\n                    return this.handleGetMediaConfig(<IGetMediaConfigActionFromWidgetActionRequest>ev.detail);\n                case WidgetApiFromWidgetAction.MSC4039UploadFileAction:\n                    return this.handleUploadFile(<IUploadFileActionFromWidgetActionRequest>ev.detail);\n                case WidgetApiFromWidgetAction.MSC4039DownloadFileAction:\n                    return this.handleDownloadFile(<IDownloadFileActionFromWidgetActionRequest>ev.detail);\n                case WidgetApiFromWidgetAction.MSC4157UpdateDelayedEvent:\n                    return this.handleUpdateDelayedEvent(<IUpdateDelayedEventFromWidgetActionRequest>ev.detail);\n\n                default:\n                    return this.transport.reply(ev.detail, <IWidgetApiErrorResponseData>{\n                        error: {\n                            message: \"Unknown or unsupported action: \" + ev.detail.action,\n                        },\n                    });\n            }\n        }\n    }\n\n    /**\n     * Informs the widget that the client's theme has changed.\n     * @param theme The theme data, as an object with arbitrary contents.\n     */\n    public updateTheme(theme: IThemeChangeActionRequestData): Promise<IWidgetApiResponseData> {\n        return this.transport.send(WidgetApiToWidgetAction.ThemeChange, theme);\n    }\n\n    /**\n     * Informs the widget that the client's language has changed.\n     * @param lang The BCP 47 identifier representing the client's current language.\n     */\n    public updateLanguage(lang: string): Promise<IWidgetApiResponseData> {\n        return this.transport.send(WidgetApiToWidgetAction.LanguageChange, { lang });\n    }\n\n    /**\n     * Takes a screenshot of the widget.\n     * @returns Resolves to the widget's screenshot.\n     * @throws Throws if there is a problem.\n     */\n    public takeScreenshot(): Promise<IScreenshotActionResponseData> {\n        return this.transport.send(WidgetApiToWidgetAction.TakeScreenshot, <IWidgetApiRequestEmptyData>{});\n    }\n\n    /**\n     * Alerts the widget to whether or not it is currently visible.\n     * @param {boolean} isVisible Whether the widget is visible or not.\n     * @returns {Promise<IWidgetApiResponseData>} Resolves when the widget acknowledges the update.\n     */\n    public updateVisibility(isVisible: boolean): Promise<IWidgetApiResponseData> {\n        return this.transport.send(WidgetApiToWidgetAction.UpdateVisibility, <IVisibilityActionRequestData>{\n            visible: isVisible,\n        });\n    }\n\n    public sendWidgetConfig(data: IModalWidgetOpenRequestData): Promise<void> {\n        return this.transport.send<IModalWidgetOpenRequestData>(WidgetApiToWidgetAction.WidgetConfig, data).then();\n    }\n\n    public notifyModalWidgetButtonClicked(id: IModalWidgetOpenRequestDataButton[\"id\"]): Promise<void> {\n        return this.transport\n            .send<IModalWidgetButtonClickedRequestData>(WidgetApiToWidgetAction.ButtonClicked, { id })\n            .then();\n    }\n\n    public notifyModalWidgetClose(data: IModalWidgetReturnData): Promise<void> {\n        return this.transport.send<IModalWidgetReturnData>(WidgetApiToWidgetAction.CloseModalWidget, data).then();\n    }\n\n    /**\n     * Feeds an event to the widget. As a client you are expected to call this\n     * for every new event in every room to which you are joined or invited.\n     * @param {IRoomEvent} rawEvent The event to (try to) send to the widget.\n     * @param {string} currentViewedRoomId The room ID the user is currently\n     *   interacting with. Not the room ID of the event.\n     * @returns {Promise<void>} Resolves when delivered or if the widget is not\n     *   able to read the event due to permissions, rejects if the widget failed\n     *   to handle the event.\n     * @deprecated It is recommended to communicate the viewed room ID by calling\n     *   {@link ClientWidgetApi.setViewedRoomId} rather than passing it to this\n     *   method.\n     */\n    public async feedEvent(rawEvent: IRoomEvent, currentViewedRoomId: string): Promise<void>;\n    /**\n     * Feeds an event to the widget. As a client you are expected to call this\n     * for every new event (including state events) in every room to which you are joined or invited.\n     * @param {IRoomEvent} rawEvent The event to (try to) send to the widget.\n     * @returns {Promise<void>} Resolves when delivered or if the widget is not\n     *   able to read the event due to permissions, rejects if the widget failed\n     *   to handle the event.\n     */\n    public async feedEvent(rawEvent: IRoomEvent): Promise<void>;\n    public async feedEvent(rawEvent: IRoomEvent, currentViewedRoomId?: string): Promise<void> {\n        if (currentViewedRoomId !== undefined) this.setViewedRoomId(currentViewedRoomId);\n        if (rawEvent.room_id !== this.viewedRoomId && !this.canUseRoomTimeline(rawEvent.room_id)) {\n            return; // no-op\n        }\n\n        if (rawEvent.state_key !== undefined && rawEvent.state_key !== null) {\n            // state event\n            if (!this.canReceiveStateEvent(rawEvent.type, rawEvent.state_key)) {\n                return; // no-op\n            }\n        } else {\n            // message event\n            if (!this.canReceiveRoomEvent(rawEvent.type, (rawEvent.content as { msgtype?: string })?.[\"msgtype\"])) {\n                return; // no-op\n            }\n        }\n\n        // Feed the event into the widget\n        await this.transport.send<ISendEventToWidgetRequestData>(\n            WidgetApiToWidgetAction.SendEvent,\n            // it's compatible, but missing the index signature\n            rawEvent as ISendEventToWidgetRequestData,\n        );\n    }\n\n    /**\n     * Feeds a to-device event to the widget. As a client you are expected to\n     * call this for every to-device event you receive.\n     * @param {IRoomEvent} rawEvent The event to (try to) send to the widget.\n     * @param {boolean} encrypted Whether the event contents were encrypted.\n     * @returns {Promise<void>} Resolves when delivered or if the widget is not\n     *   able to receive the event due to permissions, rejects if the widget\n     *   failed to handle the event.\n     */\n    public async feedToDevice(rawEvent: IRoomEvent, encrypted: boolean): Promise<void> {\n        if (this.canReceiveToDeviceEvent(rawEvent.type)) {\n            await this.transport.send<ISendToDeviceToWidgetRequestData>(\n                WidgetApiToWidgetAction.SendToDevice,\n                // it's compatible, but missing the index signature\n                { ...rawEvent, encrypted } as ISendToDeviceToWidgetRequestData,\n            );\n        }\n    }\n\n    private viewedRoomId: string | null = null;\n\n    /**\n     * Indicate that a room is being viewed (making it possible for the widget\n     * to interact with it).\n     */\n    public setViewedRoomId(roomId: string | null): void {\n        this.viewedRoomId = roomId;\n        // If the widget doesn't have timeline permissions for the room then\n        // this is its opportunity to learn the room state. We push the entire\n        // room state, which could be redundant if this room had been viewed\n        // once before, but it's easier than selectively pushing just the bits\n        // of state that changed while the room was in the background.\n        if (roomId !== null && !this.canUseRoomTimeline(roomId)) this.pushRoomState(roomId);\n    }\n\n    private async flushRoomState(): Promise<void> {\n        try {\n            // Only send a single action once all concurrent tasks have completed\n            do await Promise.all([...this.pushRoomStateTasks]);\n            while (this.pushRoomStateTasks.size > 0);\n\n            const events: IRoomEvent[] = [];\n            for (const eventTypeMap of this.pushRoomStateResult.values()) {\n                for (const stateKeyMap of eventTypeMap.values()) {\n                    events.push(...stateKeyMap.values());\n                }\n            }\n            if ((await this.getWidgetVersions()).includes(UnstableApiVersion.MSC2762_UPDATE_STATE)) {\n                // Only send state updates when using UpdateState. Otherwise the SendEvent action will be responsible for state updates.\n                await this.transport.send<IUpdateStateToWidgetRequestData>(WidgetApiToWidgetAction.UpdateState, {\n                    state: events,\n                });\n            }\n        } finally {\n            this.flushRoomStateTask = null;\n        }\n    }\n\n    /**\n     * Read the room's state and push all entries that the widget is allowed to\n     * read through to the widget.\n     */\n    private pushRoomState(roomId: string): void {\n        for (const cap of this.allowedEvents) {\n            if (cap.kind === EventKind.State && cap.direction === EventDirection.Receive) {\n                // Initiate the task\n                const events = this.driver.readRoomState(roomId, cap.eventType, cap.keyStr ?? undefined);\n                const task = events\n                    .then(\n                        (events) => {\n                            // When complete, queue the resulting events to be\n                            // pushed to the widget\n                            for (const event of events) {\n                                let eventTypeMap = this.pushRoomStateResult.get(roomId);\n                                if (eventTypeMap === undefined) {\n                                    eventTypeMap = new Map();\n                                    this.pushRoomStateResult.set(roomId, eventTypeMap);\n                                }\n                                let stateKeyMap = eventTypeMap.get(cap.eventType);\n                                if (stateKeyMap === undefined) {\n                                    stateKeyMap = new Map();\n                                    eventTypeMap.set(cap.eventType, stateKeyMap);\n                                }\n                                if (!stateKeyMap.has(event.state_key!)) stateKeyMap.set(event.state_key!, event);\n                            }\n                        },\n                        (e) =>\n                            console.error(\n                                `Failed to read room state for ${roomId} (${cap.eventType}, ${cap.keyStr})`,\n                                e,\n                            ),\n                    )\n                    .then(() => {\n                        // Mark request as no longer pending\n                        this.pushRoomStateTasks.delete(task);\n                    });\n\n                // Mark task as pending\n                this.pushRoomStateTasks.add(task);\n                // Assuming no other tasks are already happening concurrently,\n                // schedule the widget action that actually pushes the events\n                this.flushRoomStateTask ??= this.flushRoomState();\n                this.flushRoomStateTask.catch((e) => console.error(\"Failed to push room state\", e));\n            }\n        }\n    }\n\n    /**\n     * Feeds a room state update to the widget. As a client you are expected to\n     * call this for every state update in every room to which you are joined or\n     * invited.\n     * @param {IRoomEvent} rawEvent The state event corresponding to the updated\n     *   room state entry.\n     * @returns {Promise<void>} Resolves when delivered or if the widget is not\n     *   able to receive the room state due to permissions, rejects if the\n     *   widget failed to handle the update.\n     */\n    public async feedStateUpdate(rawEvent: IRoomEvent): Promise<void> {\n        if (rawEvent.state_key === undefined) throw new Error(\"Not a state event\");\n        if (\n            (rawEvent.room_id === this.viewedRoomId || this.canUseRoomTimeline(rawEvent.room_id)) &&\n            this.canReceiveStateEvent(rawEvent.type, rawEvent.state_key)\n        ) {\n            // Updates could race with the initial push of the room's state\n            if (this.pushRoomStateTasks.size === 0) {\n                // No initial push tasks are pending; safe to send immediately\n                if ((await this.getWidgetVersions()).includes(UnstableApiVersion.MSC2762_UPDATE_STATE)) {\n                    // Only send state updates when using UpdateState. Otherwise the SendEvent action will be responsible for state updates.\n                    await this.transport.send<IUpdateStateToWidgetRequestData>(WidgetApiToWidgetAction.UpdateState, {\n                        state: [rawEvent],\n                    });\n                }\n            } else {\n                // Lump the update in with whatever data will be sent in the\n                // initial push later. Even if we set it to an \"outdated\" entry\n                // here, we can count on any newer entries being passed to this\n                // same method eventually; this won't cause stuck state.\n                let eventTypeMap = this.pushRoomStateResult.get(rawEvent.room_id);\n                if (eventTypeMap === undefined) {\n                    eventTypeMap = new Map();\n                    this.pushRoomStateResult.set(rawEvent.room_id, eventTypeMap);\n                }\n                let stateKeyMap = eventTypeMap.get(rawEvent.type);\n                if (stateKeyMap === undefined) {\n                    stateKeyMap = new Map();\n                    eventTypeMap.set(rawEvent.type, stateKeyMap);\n                }\n                if (!stateKeyMap.has(rawEvent.type)) stateKeyMap.set(rawEvent.state_key, rawEvent);\n                do await Promise.all([...this.pushRoomStateTasks]);\n                while (this.pushRoomStateTasks.size > 0);\n                await this.flushRoomStateTask;\n            }\n        }\n    }\n}\n","/*\n * Copyright 2021 The Matrix.org Foundation C.I.C.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *         http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nexport enum Symbols {\n    AnyRoom = \"*\",\n}\n","/*\n * Copyright 2020 - 2024 The Matrix.org Foundation C.I.C.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *         http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { EventEmitter } from \"events\";\n\nimport { Capability } from \"./interfaces/Capabilities\";\nimport { IWidgetApiRequest, IWidgetApiRequestEmptyData } from \"./interfaces/IWidgetApiRequest\";\nimport { IWidgetApiAcknowledgeResponseData } from \"./interfaces/IWidgetApiResponse\";\nimport { WidgetApiDirection } from \"./interfaces/WidgetApiDirection\";\nimport {\n    ISupportedVersionsActionRequest,\n    ISupportedVersionsActionResponseData,\n} from \"./interfaces/SupportedVersionsAction\";\nimport { ApiVersion, CurrentApiVersions, UnstableApiVersion } from \"./interfaces/ApiVersion\";\nimport {\n    ICapabilitiesActionRequest,\n    ICapabilitiesActionResponseData,\n    INotifyCapabilitiesActionRequest,\n    IRenegotiateCapabilitiesRequestData,\n} from \"./interfaces/CapabilitiesAction\";\nimport { ITransport } from \"./transport/ITransport\";\nimport { PostmessageTransport } from \"./transport/PostmessageTransport\";\nimport { WidgetApiFromWidgetAction, WidgetApiToWidgetAction } from \"./interfaces/WidgetApiAction\";\nimport { IWidgetApiErrorResponseData, IWidgetApiErrorResponseDataDetails } from \"./interfaces/IWidgetApiErrorResponse\";\nimport { IStickerActionRequestData } from \"./interfaces/StickerAction\";\nimport { IStickyActionRequestData, IStickyActionResponseData } from \"./interfaces/StickyAction\";\nimport {\n    IGetOpenIDActionRequestData,\n    IGetOpenIDActionResponse,\n    IOpenIDCredentials,\n    OpenIDRequestState,\n} from \"./interfaces/GetOpenIDAction\";\nimport { IOpenIDCredentialsActionRequest } from \"./interfaces/OpenIDCredentialsAction\";\nimport { MatrixWidgetType, WidgetType } from \"./interfaces/WidgetType\";\nimport {\n    BuiltInModalButtonID,\n    IModalWidgetCreateData,\n    IModalWidgetOpenRequestData,\n    IModalWidgetOpenRequestDataButton,\n    IModalWidgetReturnData,\n    ModalButtonID,\n} from \"./interfaces/ModalWidgetActions\";\nimport { ISetModalButtonEnabledActionRequestData } from \"./interfaces/SetModalButtonEnabledAction\";\nimport { ISendEventFromWidgetRequestData, ISendEventFromWidgetResponseData } from \"./interfaces/SendEventAction\";\nimport {\n    ISendToDeviceFromWidgetRequestData,\n    ISendToDeviceFromWidgetResponseData,\n} from \"./interfaces/SendToDeviceAction\";\nimport { EventDirection, WidgetEventCapability } from \"./models/WidgetEventCapability\";\nimport { INavigateActionRequestData } from \"./interfaces/NavigateAction\";\nimport { IReadEventFromWidgetRequestData, IReadEventFromWidgetResponseData } from \"./interfaces/ReadEventAction\";\nimport {\n    IReadRoomAccountDataFromWidgetRequestData,\n    IReadRoomAccountDataFromWidgetResponseData,\n} from \"./interfaces/ReadRoomAccountDataAction\";\nimport { IRoomEvent } from \"./interfaces/IRoomEvent\";\nimport { IRoomAccountData } from \"./interfaces/IRoomAccountData\";\nimport { ITurnServer, IUpdateTurnServersRequest } from \"./interfaces/TurnServerActions\";\nimport { Symbols } from \"./Symbols\";\nimport {\n    IReadRelationsFromWidgetRequestData,\n    IReadRelationsFromWidgetResponseData,\n} from \"./interfaces/ReadRelationsAction\";\nimport {\n    IUserDirectorySearchFromWidgetRequestData,\n    IUserDirectorySearchFromWidgetResponseData,\n} from \"./interfaces/UserDirectorySearchAction\";\nimport {\n    IGetMediaConfigActionFromWidgetRequestData,\n    IGetMediaConfigActionFromWidgetResponseData,\n} from \"./interfaces/GetMediaConfigAction\";\nimport {\n    IUploadFileActionFromWidgetRequestData,\n    IUploadFileActionFromWidgetResponseData,\n} from \"./interfaces/UploadFileAction\";\nimport {\n    IDownloadFileActionFromWidgetRequestData,\n    IDownloadFileActionFromWidgetResponseData,\n} from \"./interfaces/DownloadFileAction\";\nimport {\n    IUpdateDelayedEventFromWidgetRequestData,\n    IUpdateDelayedEventFromWidgetResponseData,\n    UpdateDelayedEventAction,\n} from \"./interfaces/UpdateDelayedEventAction\";\n\nexport class WidgetApiResponseError extends Error {\n    static {\n        this.prototype.name = this.name;\n    }\n\n    public constructor(\n        message: string,\n        public readonly data: IWidgetApiErrorResponseDataDetails,\n    ) {\n        super(message);\n    }\n}\n\n/**\n * API handler for widgets. This raises events for each action\n * received as `action:${action}` (eg: \"action:screenshot\").\n * Default handling can be prevented by using preventDefault()\n * on the raised event. The default handling varies for each\n * action: ones which the SDK can handle safely are acknowledged\n * appropriately and ones which are unhandled (custom or require\n * the widget to do something) are rejected with an error.\n *\n * Events which are preventDefault()ed must reply using the\n * transport. The events raised will have a detail of an\n * IWidgetApiRequest interface.\n *\n * When the WidgetApi is ready to start sending requests, it will\n * raise a \"ready\" CustomEvent. After the ready event fires, actions\n * can be sent and the transport will be ready.\n */\nexport class WidgetApi extends EventEmitter {\n    public readonly transport: ITransport;\n\n    private capabilitiesFinished = false;\n    private supportsMSC2974Renegotiate = false;\n    private requestedCapabilities: Capability[] = [];\n    private approvedCapabilities?: Capability[];\n    private cachedClientVersions?: ApiVersion[];\n    private turnServerWatchers = 0;\n\n    /**\n     * Creates a new API handler for the given widget.\n     * @param {string} widgetId The widget ID to listen for. If not supplied then\n     * the API will use the widget ID from the first valid request it receives.\n     * @param {string} clientOrigin The origin of the client, or null if not known.\n     */\n    public constructor(\n        widgetId: string | null = null,\n        private clientOrigin: string | null = null,\n    ) {\n        super();\n        if (!window.parent) {\n            throw new Error(\"No parent window. This widget doesn't appear to be embedded properly.\");\n        }\n        this.transport = new PostmessageTransport(WidgetApiDirection.FromWidget, widgetId, window.parent, window);\n        this.transport.targetOrigin = clientOrigin;\n        this.transport.on(\"message\", this.handleMessage.bind(this));\n    }\n\n    /**\n     * Determines if the widget was granted a particular capability. Note that on\n     * clients where the capabilities are not fed back to the widget this function\n     * will rely on requested capabilities instead.\n     * @param {Capability} capability The capability to check for approval of.\n     * @returns {boolean} True if the widget has approval for the given capability.\n     */\n    public hasCapability(capability: Capability): boolean {\n        if (Array.isArray(this.approvedCapabilities)) {\n            return this.approvedCapabilities.includes(capability);\n        }\n        return this.requestedCapabilities.includes(capability);\n    }\n\n    /**\n     * Request a capability from the client. It is not guaranteed to be allowed,\n     * but will be asked for.\n     * @param {Capability} capability The capability to request.\n     * @throws Throws if the capabilities negotiation has already started and the\n     * widget is unable to request additional capabilities.\n     */\n    public requestCapability(capability: Capability): void {\n        if (this.capabilitiesFinished && !this.supportsMSC2974Renegotiate) {\n            throw new Error(\"Capabilities have already been negotiated\");\n        }\n\n        this.requestedCapabilities.push(capability);\n    }\n\n    /**\n     * Request capabilities from the client. They are not guaranteed to be allowed,\n     * but will be asked for if the negotiation has not already happened.\n     * @param {Capability[]} capabilities The capabilities to request.\n     * @throws Throws if the capabilities negotiation has already started.\n     */\n    public requestCapabilities(capabilities: Capability[]): void {\n        capabilities.forEach((cap) => this.requestCapability(cap));\n    }\n\n    /**\n     * Requests the capability to interact with rooms other than the user's currently\n     * viewed room. Applies to event receiving and sending.\n     * @param {string | Symbols.AnyRoom} roomId The room ID, or `Symbols.AnyRoom` to\n     * denote all known rooms.\n     */\n    public requestCapabilityForRoomTimeline(roomId: string | Symbols.AnyRoom): void {\n        this.requestCapability(`org.matrix.msc2762.timeline:${roomId}`);\n    }\n\n    /**\n     * Requests the capability to send a given state event with optional explicit\n     * state key. It is not guaranteed to be allowed, but will be asked for if the\n     * negotiation has not already happened.\n     * @param {string} eventType The state event type to ask for.\n     * @param {string} stateKey If specified, the specific state key to request.\n     * Otherwise all state keys will be requested.\n     */\n    public requestCapabilityToSendState(eventType: string, stateKey?: string): void {\n        this.requestCapability(WidgetEventCapability.forStateEvent(EventDirection.Send, eventType, stateKey).raw);\n    }\n\n    /**\n     * Requests the capability to receive a given state event with optional explicit\n     * state key. It is not guaranteed to be allowed, but will be asked for if the\n     * negotiation has not already happened.\n     * @param {string} eventType The state event type to ask for.\n     * @param {string} stateKey If specified, the specific state key to request.\n     * Otherwise all state keys will be requested.\n     */\n    public requestCapabilityToReceiveState(eventType: string, stateKey?: string): void {\n        this.requestCapability(WidgetEventCapability.forStateEvent(EventDirection.Receive, eventType, stateKey).raw);\n    }\n\n    /**\n     * Requests the capability to send a given to-device event. It is not\n     * guaranteed to be allowed, but will be asked for if the negotiation has\n     * not already happened.\n     * @param {string} eventType The room event type to ask for.\n     */\n    public requestCapabilityToSendToDevice(eventType: string): void {\n        this.requestCapability(WidgetEventCapability.forToDeviceEvent(EventDirection.Send, eventType).raw);\n    }\n\n    /**\n     * Requests the capability to receive a given to-device event. It is not\n     * guaranteed to be allowed, but will be asked for if the negotiation has\n     * not already happened.\n     * @param {string} eventType The room event type to ask for.\n     */\n    public requestCapabilityToReceiveToDevice(eventType: string): void {\n        this.requestCapability(WidgetEventCapability.forToDeviceEvent(EventDirection.Receive, eventType).raw);\n    }\n\n    /**\n     * Requests the capability to send a given room event. It is not guaranteed to be\n     * allowed, but will be asked for if the negotiation has not already happened.\n     * @param {string} eventType The room event type to ask for.\n     */\n    public requestCapabilityToSendEvent(eventType: string): void {\n        this.requestCapability(WidgetEventCapability.forRoomEvent(EventDirection.Send, eventType).raw);\n    }\n\n    /**\n     * Requests the capability to receive a given room event. It is not guaranteed to be\n     * allowed, but will be asked for if the negotiation has not already happened.\n     * @param {string} eventType The room event type to ask for.\n     */\n    public requestCapabilityToReceiveEvent(eventType: string): void {\n        this.requestCapability(WidgetEventCapability.forRoomEvent(EventDirection.Receive, eventType).raw);\n    }\n\n    /**\n     * Requests the capability to send a given message event with optional explicit\n     * `msgtype`. It is not guaranteed to be allowed, but will be asked for if the\n     * negotiation has not already happened.\n     * @param {string} msgtype If specified, the specific msgtype to request.\n     * Otherwise all message types will be requested.\n     */\n    public requestCapabilityToSendMessage(msgtype?: string): void {\n        this.requestCapability(WidgetEventCapability.forRoomMessageEvent(EventDirection.Send, msgtype).raw);\n    }\n\n    /**\n     * Requests the capability to receive a given message event with optional explicit\n     * `msgtype`. It is not guaranteed to be allowed, but will be asked for if the\n     * negotiation has not already happened.\n     * @param {string} msgtype If specified, the specific msgtype to request.\n     * Otherwise all message types will be requested.\n     */\n    public requestCapabilityToReceiveMessage(msgtype?: string): void {\n        this.requestCapability(WidgetEventCapability.forRoomMessageEvent(EventDirection.Receive, msgtype).raw);\n    }\n\n    /**\n     * Requests the capability to receive a given item in room account data. It is not guaranteed to be\n     * allowed, but will be asked for if the negotiation has not already happened.\n     * @param {string} eventType The state event type to ask for.\n     */\n    public requestCapabilityToReceiveRoomAccountData(eventType: string): void {\n        this.requestCapability(WidgetEventCapability.forRoomAccountData(EventDirection.Receive, eventType).raw);\n    }\n\n    /**\n     * Requests an OpenID Connect token from the client for the currently logged in\n     * user. This token can be validated server-side with the federation API. Note\n     * that the widget is responsible for validating the token and caching any results\n     * it needs.\n     * @returns {Promise<IOpenIDCredentials>} Resolves to a token for verification.\n     * @throws Throws if the user rejected the request or the request failed.\n     */\n    public requestOpenIDConnectToken(): Promise<IOpenIDCredentials> {\n        return new Promise<IOpenIDCredentials>((resolve, reject) => {\n            this.transport\n                .sendComplete<IGetOpenIDActionRequestData, IGetOpenIDActionResponse>(\n                    WidgetApiFromWidgetAction.GetOpenIDCredentials,\n                    {},\n                )\n                .then((response) => {\n                    const rdata = response.response;\n                    if (rdata.state === OpenIDRequestState.Allowed) {\n                        resolve(rdata);\n                    } else if (rdata.state === OpenIDRequestState.Blocked) {\n                        reject(new Error(\"User declined to verify their identity\"));\n                    } else if (rdata.state === OpenIDRequestState.PendingUserConfirmation) {\n                        const handlerFn = (ev: CustomEvent<IOpenIDCredentialsActionRequest>): void => {\n                            ev.preventDefault();\n                            const request = ev.detail;\n                            if (request.data.original_request_id !== response.requestId) return;\n                            if (request.data.state === OpenIDRequestState.Allowed) {\n                                resolve(request.data);\n                                this.transport.reply(request, <IWidgetApiRequestEmptyData>{}); // ack\n                            } else if (request.data.state === OpenIDRequestState.Blocked) {\n                                reject(new Error(\"User declined to verify their identity\"));\n                                this.transport.reply(request, <IWidgetApiRequestEmptyData>{}); // ack\n                            } else {\n                                reject(new Error(\"Invalid state on reply: \" + rdata.state));\n                                this.transport.reply(request, <IWidgetApiErrorResponseData>{\n                                    error: {\n                                        message: \"Invalid state\",\n                                    },\n                                });\n                            }\n                            this.off(`action:${WidgetApiToWidgetAction.OpenIDCredentials}`, handlerFn);\n                        };\n                        this.on(`action:${WidgetApiToWidgetAction.OpenIDCredentials}`, handlerFn);\n                    } else {\n                        reject(new Error(\"Invalid state: \" + rdata.state));\n                    }\n                })\n                .catch(reject);\n        });\n    }\n\n    /**\n     * Asks the client for additional capabilities. Capabilities can be queued for this\n     * request with the requestCapability() functions.\n     * @returns {Promise<void>} Resolves when complete. Note that the promise resolves when\n     * the capabilities request has gone through, not when the capabilities are approved/denied.\n     * Use the WidgetApiToWidgetAction.NotifyCapabilities action to detect changes.\n     */\n    public updateRequestedCapabilities(): Promise<void> {\n        return this.transport\n            .send(WidgetApiFromWidgetAction.MSC2974RenegotiateCapabilities, <IRenegotiateCapabilitiesRequestData>{\n                capabilities: this.requestedCapabilities,\n            })\n            .then();\n    }\n\n    /**\n     * Tell the client that the content has been loaded.\n     * @returns {Promise} Resolves when the client acknowledges the request.\n     */\n    public sendContentLoaded(): Promise<void> {\n        return this.transport.send(WidgetApiFromWidgetAction.ContentLoaded, <IWidgetApiRequestEmptyData>{}).then();\n    }\n\n    /**\n     * Sends a sticker to the client.\n     * @param {IStickerActionRequestData} sticker The sticker to send.\n     * @returns {Promise} Resolves when the client acknowledges the request.\n     */\n    public sendSticker(sticker: IStickerActionRequestData): Promise<void> {\n        return this.transport.send(WidgetApiFromWidgetAction.SendSticker, sticker).then();\n    }\n\n    /**\n     * Asks the client to set the always-on-screen status for this widget.\n     * @param {boolean} value The new state to request.\n     * @returns {Promise<boolean>} Resolve with true if the client was able to fulfill\n     * the request, resolves to false otherwise. Rejects if an error occurred.\n     */\n    public setAlwaysOnScreen(value: boolean): Promise<boolean> {\n        return this.transport\n            .send<\n                IStickyActionRequestData,\n                IStickyActionResponseData\n            >(WidgetApiFromWidgetAction.UpdateAlwaysOnScreen, { value })\n            .then((res) => res.success);\n    }\n\n    /**\n     * Opens a modal widget.\n     * @param {string} url The URL to the modal widget.\n     * @param {string} name The name of the widget.\n     * @param {IModalWidgetOpenRequestDataButton[]} buttons The buttons to have on the widget.\n     * @param {IModalWidgetCreateData} data Data to supply to the modal widget.\n     * @param {WidgetType} type The type of modal widget.\n     * @returns {Promise<void>} Resolves when the modal widget has been opened.\n     */\n    public openModalWidget(\n        url: string,\n        name: string,\n        buttons: IModalWidgetOpenRequestDataButton[] = [],\n        data: IModalWidgetCreateData = {},\n        type: WidgetType = MatrixWidgetType.Custom,\n    ): Promise<void> {\n        return this.transport\n            .send<IModalWidgetOpenRequestData>(WidgetApiFromWidgetAction.OpenModalWidget, {\n                type,\n                url,\n                name,\n                buttons,\n                data,\n            })\n            .then();\n    }\n\n    /**\n     * Closes the modal widget. The widget's session will be terminated shortly after.\n     * @param {IModalWidgetReturnData} data Optional data to close the modal widget with.\n     * @returns {Promise<void>} Resolves when complete.\n     */\n    public closeModalWidget(data: IModalWidgetReturnData = {}): Promise<void> {\n        return this.transport.send<IModalWidgetReturnData>(WidgetApiFromWidgetAction.CloseModalWidget, data).then();\n    }\n\n    public sendRoomEvent(\n        eventType: string,\n        content: unknown,\n        roomId?: string,\n        delay?: number,\n        parentDelayId?: string,\n    ): Promise<ISendEventFromWidgetResponseData> {\n        return this.sendEvent(eventType, undefined, content, roomId, delay, parentDelayId);\n    }\n\n    public sendStateEvent(\n        eventType: string,\n        stateKey: string,\n        content: unknown,\n        roomId?: string,\n        delay?: number,\n        parentDelayId?: string,\n    ): Promise<ISendEventFromWidgetResponseData> {\n        return this.sendEvent(eventType, stateKey, content, roomId, delay, parentDelayId);\n    }\n\n    private sendEvent(\n        eventType: string,\n        stateKey: string | undefined,\n        content: unknown,\n        roomId?: string,\n        delay?: number,\n        parentDelayId?: string,\n    ): Promise<ISendEventFromWidgetResponseData> {\n        return this.transport.send<ISendEventFromWidgetRequestData, ISendEventFromWidgetResponseData>(\n            WidgetApiFromWidgetAction.SendEvent,\n            {\n                type: eventType,\n                content,\n                ...(stateKey !== undefined && { state_key: stateKey }),\n                ...(roomId !== undefined && { room_id: roomId }),\n                ...(delay !== undefined && { delay }),\n                ...(parentDelayId !== undefined && { parent_delay_id: parentDelayId }),\n            },\n        );\n    }\n\n    /**\n     * @deprecated This currently relies on an unstable MSC (MSC4157).\n     */\n    public updateDelayedEvent(\n        delayId: string,\n        action: UpdateDelayedEventAction,\n    ): Promise<IUpdateDelayedEventFromWidgetResponseData> {\n        return this.transport.send<IUpdateDelayedEventFromWidgetRequestData, IUpdateDelayedEventFromWidgetResponseData>(\n            WidgetApiFromWidgetAction.MSC4157UpdateDelayedEvent,\n            {\n                delay_id: delayId,\n                action,\n            },\n        );\n    }\n\n    /**\n     * Sends a to-device event.\n     * @param {string} eventType The type of events being sent.\n     * @param {boolean} encrypted Whether to encrypt the message contents.\n     * @param {Object} contentMap A map from user IDs to device IDs to message contents.\n     * @returns {Promise<ISendToDeviceFromWidgetResponseData>} Resolves when complete.\n     */\n    public sendToDevice(\n        eventType: string,\n        encrypted: boolean,\n        contentMap: { [userId: string]: { [deviceId: string]: object } },\n    ): Promise<ISendToDeviceFromWidgetResponseData> {\n        return this.transport.send<ISendToDeviceFromWidgetRequestData, ISendToDeviceFromWidgetResponseData>(\n            WidgetApiFromWidgetAction.SendToDevice,\n            { type: eventType, encrypted, messages: contentMap },\n        );\n    }\n\n    public readRoomAccountData(eventType: string, roomIds?: (string | Symbols.AnyRoom)[]): Promise<IRoomAccountData[]> {\n        const data: IReadEventFromWidgetRequestData = { type: eventType };\n\n        if (roomIds) {\n            if (roomIds.includes(Symbols.AnyRoom)) {\n                data.room_ids = Symbols.AnyRoom;\n            } else {\n                data.room_ids = roomIds;\n            }\n        }\n        return this.transport\n            .send<\n                IReadRoomAccountDataFromWidgetRequestData,\n                IReadRoomAccountDataFromWidgetResponseData\n            >(WidgetApiFromWidgetAction.BeeperReadRoomAccountData, data)\n            .then((r) => r.events);\n    }\n\n    public readRoomEvents(\n        eventType: string,\n        limit?: number,\n        msgtype?: string,\n        roomIds?: (string | Symbols.AnyRoom)[],\n        since?: string | undefined,\n    ): Promise<IRoomEvent[]> {\n        const data: IReadEventFromWidgetRequestData = { type: eventType, msgtype: msgtype };\n        if (limit !== undefined) {\n            data.limit = limit;\n        }\n        if (roomIds) {\n            if (roomIds.includes(Symbols.AnyRoom)) {\n                data.room_ids = Symbols.AnyRoom;\n            } else {\n                data.room_ids = roomIds;\n            }\n        }\n        if (since) {\n            data.since = since;\n        }\n        return this.transport\n            .send<\n                IReadEventFromWidgetRequestData,\n                IReadEventFromWidgetResponseData\n            >(WidgetApiFromWidgetAction.MSC2876ReadEvents, data)\n            .then((r) => r.events);\n    }\n\n    /**\n     * Reads all related events given a known eventId.\n     * @param eventId The id of the parent event to be read.\n     * @param roomId The room to look within. When undefined, the user's currently\n     * viewed room.\n     * @param relationType The relationship type of child events to search for.\n     * When undefined, all relations are returned.\n     * @param eventType The event type of child events to search for. When undefined,\n     * all related events are returned.\n     * @param limit The maximum number of events to retrieve per room. If not\n     * supplied, the server will apply a default limit.\n     * @param from The pagination token to start returning results from, as\n     * received from a previous call. If not supplied, results start at the most\n     * recent topological event known to the server.\n     * @param to The pagination token to stop returning results at. If not\n     * supplied, results continue up to limit or until there are no more events.\n     * @param direction The direction to search for according to MSC3715.\n     * @returns Resolves to the room relations.\n     */\n    public async readEventRelations(\n        eventId: string,\n        roomId?: string,\n        relationType?: string,\n        eventType?: string,\n        limit?: number,\n        from?: string,\n        to?: string,\n        direction?: \"f\" | \"b\",\n    ): Promise<IReadRelationsFromWidgetResponseData> {\n        const versions = await this.getClientVersions();\n        if (!versions.includes(UnstableApiVersion.MSC3869)) {\n            throw new Error(\"The read_relations action is not supported by the client.\");\n        }\n\n        const data: IReadRelationsFromWidgetRequestData = {\n            event_id: eventId,\n            rel_type: relationType,\n            event_type: eventType,\n            room_id: roomId,\n            to,\n            from,\n            limit,\n            direction,\n        };\n\n        return this.transport.send<IReadRelationsFromWidgetRequestData, IReadRelationsFromWidgetResponseData>(\n            WidgetApiFromWidgetAction.MSC3869ReadRelations,\n            data,\n        );\n    }\n\n    public readStateEvents(\n        eventType: string,\n        limit?: number,\n        stateKey?: string,\n        roomIds?: (string | Symbols.AnyRoom)[],\n    ): Promise<IRoomEvent[]> {\n        const data: IReadEventFromWidgetRequestData = {\n            type: eventType,\n            state_key: stateKey === undefined ? true : stateKey,\n        };\n        if (limit !== undefined) {\n            data.limit = limit;\n        }\n        if (roomIds) {\n            if (roomIds.includes(Symbols.AnyRoom)) {\n                data.room_ids = Symbols.AnyRoom;\n            } else {\n                data.room_ids = roomIds;\n            }\n        }\n        return this.transport\n            .send<\n                IReadEventFromWidgetRequestData,\n                IReadEventFromWidgetResponseData\n            >(WidgetApiFromWidgetAction.MSC2876ReadEvents, data)\n            .then((r) => r.events);\n    }\n\n    /**\n     * Sets a button as disabled or enabled on the modal widget. Buttons are enabled by default.\n     * @param {ModalButtonID} buttonId The button ID to enable/disable.\n     * @param {boolean} isEnabled Whether or not the button is enabled.\n     * @returns {Promise<void>} Resolves when complete.\n     * @throws Throws if the button cannot be disabled, or the client refuses to disable the button.\n     */\n    public setModalButtonEnabled(buttonId: ModalButtonID, isEnabled: boolean): Promise<void> {\n        if (buttonId === BuiltInModalButtonID.Close) {\n            throw new Error(\"The close button cannot be disabled\");\n        }\n        return this.transport\n            .send<ISetModalButtonEnabledActionRequestData>(WidgetApiFromWidgetAction.SetModalButtonEnabled, {\n                button: buttonId,\n                enabled: isEnabled,\n            })\n            .then();\n    }\n\n    /**\n     * Attempts to navigate the client to the given URI. This can only be called with Matrix URIs\n     * (currently only matrix.to, but in future a Matrix URI scheme will be defined).\n     * @param {string} uri The URI to navigate to.\n     * @returns {Promise<void>} Resolves when complete.\n     * @throws Throws if the URI is invalid or cannot be processed.\n     * @deprecated This currently relies on an unstable MSC (MSC2931).\n     */\n    public navigateTo(uri: string): Promise<void> {\n        if (!uri || !uri.startsWith(\"https://matrix.to/#\")) {\n            throw new Error(\"Invalid matrix.to URI\");\n        }\n\n        return this.transport\n            .send<INavigateActionRequestData>(WidgetApiFromWidgetAction.MSC2931Navigate, { uri })\n            .then();\n    }\n\n    /**\n     * Starts watching for TURN servers, yielding an initial set of credentials as soon as possible,\n     * and thereafter yielding new credentials whenever the previous ones expire.\n     * @yields {ITurnServer} The TURN server URIs and credentials currently available to the widget.\n     */\n    public async *getTurnServers(): AsyncGenerator<ITurnServer> {\n        let setTurnServer: (server: ITurnServer) => void;\n\n        const onUpdateTurnServers = async (ev: CustomEvent<IUpdateTurnServersRequest>): Promise<void> => {\n            ev.preventDefault();\n            setTurnServer(ev.detail.data);\n            await this.transport.reply<IWidgetApiAcknowledgeResponseData>(ev.detail, {});\n        };\n\n        // Start listening for updates before we even start watching, to catch\n        // TURN data that is sent immediately\n        this.on(`action:${WidgetApiToWidgetAction.UpdateTurnServers}`, onUpdateTurnServers);\n\n        // Only send the 'watch' action if we aren't already watching\n        if (this.turnServerWatchers === 0) {\n            try {\n                await this.transport.send<IWidgetApiRequestEmptyData>(WidgetApiFromWidgetAction.WatchTurnServers, {});\n            } catch (e) {\n                this.off(`action:${WidgetApiToWidgetAction.UpdateTurnServers}`, onUpdateTurnServers);\n                throw e;\n            }\n        }\n        this.turnServerWatchers++;\n\n        try {\n            // Watch for new data indefinitely (until this generator's return method is called)\n            while (true) {\n                yield await new Promise<ITurnServer>((resolve) => (setTurnServer = resolve));\n            }\n        } finally {\n            // The loop was broken by the caller - clean up\n            this.off(`action:${WidgetApiToWidgetAction.UpdateTurnServers}`, onUpdateTurnServers);\n\n            // Since sending the 'unwatch' action will end updates for all other\n            // consumers, only send it if we're the only consumer remaining\n            this.turnServerWatchers--;\n            if (this.turnServerWatchers === 0) {\n                await this.transport.send<IWidgetApiRequestEmptyData>(WidgetApiFromWidgetAction.UnwatchTurnServers, {});\n            }\n        }\n    }\n\n    /**\n     * Search for users in the user directory.\n     * @param searchTerm The term to search for.\n     * @param limit The maximum number of results to return. If not supplied, the\n     * @returns Resolves to the search results.\n     */\n    public async searchUserDirectory(\n        searchTerm: string,\n        limit?: number,\n    ): Promise<IUserDirectorySearchFromWidgetResponseData> {\n        const versions = await this.getClientVersions();\n        if (!versions.includes(UnstableApiVersion.MSC3973)) {\n            throw new Error(\"The user_directory_search action is not supported by the client.\");\n        }\n\n        const data: IUserDirectorySearchFromWidgetRequestData = {\n            search_term: searchTerm,\n            limit,\n        };\n\n        return this.transport.send<\n            IUserDirectorySearchFromWidgetRequestData,\n            IUserDirectorySearchFromWidgetResponseData\n        >(WidgetApiFromWidgetAction.MSC3973UserDirectorySearch, data);\n    }\n\n    /**\n     * Get the config for the media repository.\n     * @returns Promise which resolves with an object containing the config.\n     */\n    public async getMediaConfig(): Promise<IGetMediaConfigActionFromWidgetResponseData> {\n        const versions = await this.getClientVersions();\n        if (!versions.includes(UnstableApiVersion.MSC4039)) {\n            throw new Error(\"The get_media_config action is not supported by the client.\");\n        }\n\n        const data: IGetMediaConfigActionFromWidgetRequestData = {};\n\n        return this.transport.send<\n            IGetMediaConfigActionFromWidgetRequestData,\n            IGetMediaConfigActionFromWidgetResponseData\n        >(WidgetApiFromWidgetAction.MSC4039GetMediaConfigAction, data);\n    }\n\n    /**\n     * Upload a file to the media repository on the homeserver.\n     * @param file - The object to upload. Something that can be sent to\n     *               XMLHttpRequest.send (typically a File).\n     * @returns Resolves to the location of the uploaded file.\n     */\n    public async uploadFile(file: XMLHttpRequestBodyInit): Promise<IUploadFileActionFromWidgetResponseData> {\n        const versions = await this.getClientVersions();\n        if (!versions.includes(UnstableApiVersion.MSC4039)) {\n            throw new Error(\"The upload_file action is not supported by the client.\");\n        }\n\n        const data: IUploadFileActionFromWidgetRequestData = {\n            file,\n        };\n\n        return this.transport.send<IUploadFileActionFromWidgetRequestData, IUploadFileActionFromWidgetResponseData>(\n            WidgetApiFromWidgetAction.MSC4039UploadFileAction,\n            data,\n        );\n    }\n\n    /**\n     * Download a file from the media repository on the homeserver.\n     * @param contentUri - MXC URI of the file to download.\n     * @returns Resolves to the contents of the file.\n     */\n    public async downloadFile(contentUri: string): Promise<IDownloadFileActionFromWidgetResponseData> {\n        const versions = await this.getClientVersions();\n        if (!versions.includes(UnstableApiVersion.MSC4039)) {\n            throw new Error(\"The download_file action is not supported by the client.\");\n        }\n\n        const data: IDownloadFileActionFromWidgetRequestData = {\n            content_uri: contentUri,\n        };\n\n        return this.transport.send<IDownloadFileActionFromWidgetRequestData, IDownloadFileActionFromWidgetResponseData>(\n            WidgetApiFromWidgetAction.MSC4039DownloadFileAction,\n            data,\n        );\n    }\n\n    /**\n     * Starts the communication channel. This should be done early to ensure\n     * that messages are not missed. Communication can only be stopped by the client.\n     */\n    public start(): void {\n        this.transport.start();\n        this.getClientVersions().then((v) => {\n            if (v.includes(UnstableApiVersion.MSC2974)) {\n                this.supportsMSC2974Renegotiate = true;\n            }\n        });\n    }\n\n    private handleMessage(ev: CustomEvent<IWidgetApiRequest>): void | Promise<void> {\n        const actionEv = new CustomEvent(`action:${ev.detail.action}`, {\n            detail: ev.detail,\n            cancelable: true,\n        });\n        this.emit(`action:${ev.detail.action}`, actionEv);\n        if (!actionEv.defaultPrevented) {\n            switch (ev.detail.action) {\n                case WidgetApiToWidgetAction.SupportedApiVersions:\n                    return this.replyVersions(<ISupportedVersionsActionRequest>ev.detail);\n                case WidgetApiToWidgetAction.Capabilities:\n                    return this.handleCapabilities(<ICapabilitiesActionRequest>ev.detail);\n                case WidgetApiToWidgetAction.UpdateVisibility:\n                    return this.transport.reply(ev.detail, <IWidgetApiRequestEmptyData>{}); // ack to avoid error spam\n                case WidgetApiToWidgetAction.NotifyCapabilities:\n                    return this.transport.reply(ev.detail, <IWidgetApiRequestEmptyData>{}); // ack to avoid error spam\n                default:\n                    return this.transport.reply(ev.detail, <IWidgetApiErrorResponseData>{\n                        error: {\n                            message: \"Unknown or unsupported action: \" + ev.detail.action,\n                        },\n                    });\n            }\n        }\n    }\n\n    private replyVersions(request: ISupportedVersionsActionRequest): void {\n        this.transport.reply<ISupportedVersionsActionResponseData>(request, {\n            supported_versions: CurrentApiVersions,\n        });\n    }\n\n    public getClientVersions(): Promise<ApiVersion[]> {\n        if (Array.isArray(this.cachedClientVersions)) {\n            return Promise.resolve(this.cachedClientVersions);\n        }\n\n        return this.transport\n            .send<IWidgetApiRequestEmptyData, ISupportedVersionsActionResponseData>(\n                WidgetApiFromWidgetAction.SupportedApiVersions,\n                {},\n            )\n            .then((r) => {\n                this.cachedClientVersions = r.supported_versions;\n                return r.supported_versions;\n            })\n            .catch((e) => {\n                console.warn(\"non-fatal error getting supported client versions: \", e);\n                return [];\n            });\n    }\n\n    private handleCapabilities(request: ICapabilitiesActionRequest): void | Promise<void> {\n        if (this.capabilitiesFinished) {\n            return this.transport.reply<IWidgetApiErrorResponseData>(request, {\n                error: {\n                    message: \"Capability negotiation already completed\",\n                },\n            });\n        }\n\n        // See if we can expect a capabilities notification or not\n        return this.getClientVersions().then((v) => {\n            if (v.includes(UnstableApiVersion.MSC2871)) {\n                this.once(\n                    `action:${WidgetApiToWidgetAction.NotifyCapabilities}`,\n                    (ev: CustomEvent<INotifyCapabilitiesActionRequest>) => {\n                        this.approvedCapabilities = ev.detail.data.approved;\n                        this.emit(\"ready\");\n                    },\n                );\n            } else {\n                // if we can't expect notification, we're as done as we can be\n                this.emit(\"ready\");\n            }\n\n            // in either case, reply to that capabilities request\n            this.capabilitiesFinished = true;\n            return this.transport.reply<ICapabilitiesActionResponseData>(request, {\n                capabilities: this.requestedCapabilities,\n            });\n        });\n    }\n}\n","/*\n * Copyright 2020 - 2024 The Matrix.org Foundation C.I.C.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *         http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n    Capability,\n    IOpenIDCredentials,\n    OpenIDRequestState,\n    SimpleObservable,\n    IRoomEvent,\n    IRoomAccountData,\n    ITurnServer,\n    IWidgetApiErrorResponseDataDetails,\n    UpdateDelayedEventAction,\n} from \"..\";\n\nexport interface ISendEventDetails {\n    roomId: string;\n    eventId: string;\n}\n\nexport interface ISendDelayedEventDetails {\n    roomId: string;\n    delayId: string;\n}\n\nexport interface IOpenIDUpdate {\n    state: OpenIDRequestState;\n    token?: IOpenIDCredentials;\n}\n\nexport interface IReadEventRelationsResult {\n    chunk: IRoomEvent[];\n    nextBatch?: string;\n    prevBatch?: string;\n}\n\nexport interface ISearchUserDirectoryResult {\n    limited: boolean;\n    results: Array<{\n        userId: string;\n        displayName?: string;\n        avatarUrl?: string;\n    }>;\n}\n\nexport interface IGetMediaConfigResult {\n    [key: string]: unknown;\n    \"m.upload.size\"?: number;\n}\n\n/**\n * Represents the functions and behaviour the widget-api is unable to\n * do, such as prompting the user for information or interacting with\n * the UI. Clients are expected to implement this class and override\n * any functions they need/want to support.\n *\n * This class assumes the client will have a context of a Widget\n * instance already.\n */\nexport abstract class WidgetDriver {\n    /**\n     * Verifies the widget's requested capabilities, returning the ones\n     * it is approved to use. Mutating the requested capabilities will\n     * have no effect.\n     *\n     * This SHOULD result in the user being prompted to approve/deny\n     * capabilities.\n     *\n     * By default this rejects all capabilities (returns an empty set).\n     * @param {Set<Capability>} requested The set of requested capabilities.\n     * @returns {Promise<Set<Capability>>} Resolves to the allowed capabilities.\n     */\n    public validateCapabilities(requested: Set<Capability>): Promise<Set<Capability>> {\n        return Promise.resolve(new Set());\n    }\n\n    /**\n     * Sends an event into a room. If `roomId` is falsy, the client should send the event\n     * into the room the user is currently looking at. The widget API will have already\n     * verified that the widget is capable of sending the event to that room.\n     * @param {string} eventType The event type to be sent.\n     * @param {*} content The content for the event.\n     * @param {string|null} stateKey The state key if this is a state event, otherwise null.\n     * May be an empty string.\n     * @param {string|null} roomId The room ID to send the event to. If falsy, the room the\n     * user is currently looking at.\n     * @returns {Promise<ISendEventDetails>} Resolves when the event has been sent with\n     * details of that event.\n     * @throws Rejected when the event could not be sent.\n     */\n    public sendEvent(\n        eventType: string,\n        content: unknown,\n        stateKey: string | null = null,\n        roomId: string | null = null,\n    ): Promise<ISendEventDetails> {\n        return Promise.reject(new Error(\"Failed to override function\"));\n    }\n\n    /**\n     * @experimental Part of MSC4140 & MSC4157\n     * Sends a delayed event into a room. If `roomId` is falsy, the client should send it\n     * into the room the user is currently looking at. The widget API will have already\n     * verified that the widget is capable of sending the event to that room.\n     * @param {number|null} delay How much later to send the event, or null to not send the\n     * event automatically. May not be null if {@link parentDelayId} is null.\n     * @param {string|null} parentDelayId The ID of the delayed event this one is grouped with,\n     * or null if it will be put in a new group. May not be null if {@link delay} is null.\n     * @param {string} eventType The event type of the event to be sent.\n     * @param {*} content The content for the event to be sent.\n     * @param {string|null} stateKey The state key if the event to be sent a state event,\n     * otherwise null. May be an empty string.\n     * @param {string|null} roomId The room ID to send the event to. If falsy, the room the\n     * user is currently looking at.\n     * @returns {Promise<ISendDelayedEventDetails>} Resolves when the delayed event has been\n     * prepared with details of how to refer to it for updating/sending/canceling it later.\n     * @throws Rejected when the delayed event could not be sent.\n     */\n    public sendDelayedEvent(\n        delay: number | null,\n        parentDelayId: string | null,\n        eventType: string,\n        content: unknown,\n        stateKey: string | null = null,\n        roomId: string | null = null,\n    ): Promise<ISendDelayedEventDetails> {\n        return Promise.reject(new Error(\"Failed to override function\"));\n    }\n\n    /**\n     * @experimental Part of MSC4140 & MSC4157\n     * Run the specified {@link action} for the delayed event matching the provided {@link delayId}.\n     * @throws Rejected when there is no matching delayed event, or when the action failed to run.\n     */\n    public updateDelayedEvent(delayId: string, action: UpdateDelayedEventAction): Promise<void> {\n        return Promise.reject(new Error(\"Failed to override function\"));\n    }\n\n    /**\n     * Sends a to-device event. The widget API will have already verified that the widget\n     * is capable of sending the event.\n     * @param {string} eventType The event type to be sent.\n     * @param {boolean} encrypted Whether to encrypt the message contents.\n     * @param {Object} contentMap A map from user ID and device ID to event content.\n     * @returns {Promise<void>} Resolves when the event has been sent.\n     * @throws Rejected when the event could not be sent.\n     */\n    public sendToDevice(\n        eventType: string,\n        encrypted: boolean,\n        contentMap: { [userId: string]: { [deviceId: string]: object } },\n    ): Promise<void> {\n        return Promise.reject(new Error(\"Failed to override function\"));\n    }\n    /**\n     * Reads an element of room account data. The widget API will have already verified that the widget is\n     * capable of receiving the `eventType` of the requested information. If `roomIds` is supplied, it may\n     * contain `Symbols.AnyRoom` to denote that the piece of room account data in each of the client's known\n     * rooms should be returned. When `null`, only the room the user is currently looking at should be considered.\n     * @param eventType The event type to be read.\n     * @param roomIds When null, the user's currently viewed room. Otherwise, the list of room IDs\n     * to look within, possibly containing Symbols.AnyRoom to denote all known rooms.\n     * @returns {Promise<IRoomAccountData[]>} Resolves to the element of room account data, or an empty array.\n     */\n    public readRoomAccountData(eventType: string, roomIds: string[] | null = null): Promise<IRoomAccountData[]> {\n        return Promise.resolve([]);\n    }\n\n    /**\n     * Reads all events of the given type, and optionally `msgtype` (if applicable/defined),\n     * the user has access to. The widget API will have already verified that the widget is\n     * capable of receiving the events. Less events than the limit are allowed to be returned,\n     * but not more. If `roomIds` is supplied, it may contain `Symbols.AnyRoom` to denote that\n     * `limit` in each of the client's known rooms should be returned. When `null`, only the\n     * room the user is currently looking at should be considered. If `since` is specified but\n     * the event ID isn't present in the number of events fetched by the client due to `limit`,\n     * the client will return all the events.\n     * @param eventType The event type to be read.\n     * @param msgtype The msgtype of the events to be read, if applicable/defined.\n     * @param stateKey The state key of the events to be read, if applicable/defined.\n     * @param limit The maximum number of events to retrieve per room. Will be zero to denote \"as many\n     * as possible\".\n     * @param roomIds When null, the user's currently viewed room. Otherwise, the list of room IDs\n     * to look within, possibly containing Symbols.AnyRoom to denote all known rooms.\n     * @param since When null, retrieves the number of events specified by the \"limit\" parameter.\n     * Otherwise, the event ID at which only subsequent events will be returned, as many as specified\n     * in \"limit\".\n     * @returns {Promise<IRoomEvent[]>} Resolves to the room events, or an empty array.\n     * @deprecated Clients are advised to implement {@link WidgetDriver.readRoomTimeline} instead.\n     */\n    public readRoomEvents(\n        eventType: string,\n        msgtype: string | undefined,\n        limit: number,\n        roomIds: string[] | null = null,\n        since?: string,\n    ): Promise<IRoomEvent[]> {\n        return Promise.resolve([]);\n    }\n\n    /**\n     * Reads all events of the given type, and optionally state key (if applicable/defined),\n     * the user has access to. The widget API will have already verified that the widget is\n     * capable of receiving the events. Less events than the limit are allowed to be returned,\n     * but not more. If `roomIds` is supplied, it may contain `Symbols.AnyRoom` to denote that\n     * `limit` in each of the client's known rooms should be returned. When `null`, only the\n     * room the user is currently looking at should be considered.\n     * @param eventType The event type to be read.\n     * @param stateKey The state key of the events to be read, if applicable/defined.\n     * @param limit The maximum number of events to retrieve. Will be zero to denote \"as many\n     * as possible\".\n     * @param roomIds When null, the user's currently viewed room. Otherwise, the list of room IDs\n     * to look within, possibly containing Symbols.AnyRoom to denote all known rooms.\n     * @returns {Promise<IRoomEvent[]>} Resolves to the state events, or an empty array.\n     * @deprecated Clients are advised to implement {@link WidgetDriver.readRoomTimeline} instead.\n     */\n    public readStateEvents(\n        eventType: string,\n        stateKey: string | undefined,\n        limit: number,\n        roomIds: string[] | null = null,\n    ): Promise<IRoomEvent[]> {\n        return Promise.resolve([]);\n    }\n\n    /**\n     * Reads all events of the given type, and optionally `msgtype` (if applicable/defined),\n     * the user has access to. The widget API will have already verified that the widget is\n     * capable of receiving the events. Less events than the limit are allowed to be returned,\n     * but not more.\n     * @param roomId The ID of the room to look within.\n     * @param eventType The event type to be read.\n     * @param msgtype The msgtype of the events to be read, if applicable/defined.\n     * @param stateKey The state key of the events to be read, if applicable/defined.\n     * @param limit The maximum number of events to retrieve. Will be zero to denote \"as many as\n     * possible\".\n     * @param since When null, retrieves the number of events specified by the \"limit\" parameter.\n     * Otherwise, the event ID at which only subsequent events will be returned, as many as specified\n     * in \"limit\".\n     * @returns {Promise<IRoomEvent[]>} Resolves to the room events, or an empty array.\n     */\n    public readRoomTimeline(\n        roomId: string,\n        eventType: string,\n        msgtype: string | undefined,\n        stateKey: string | undefined,\n        limit: number,\n        since: string | undefined,\n    ): Promise<IRoomEvent[]> {\n        // For backward compatibility we try the deprecated methods, in case\n        // they're implemented\n        if (stateKey === undefined) return this.readRoomEvents(eventType, msgtype, limit, [roomId], since);\n        else return this.readStateEvents(eventType, stateKey, limit, [roomId]);\n    }\n\n    /**\n     * Reads the current values of all matching room state entries.\n     * @param roomId The ID of the room.\n     * @param eventType The event type of the entries to be read.\n     * @param stateKey The state key of the entry to be read. If undefined,\n     * all room state entries with a matching event type should be returned.\n     * @returns {Promise<IRoomEvent[]>} Resolves to the events representing the\n     * current values of the room state entries.\n     */\n    public readRoomState(roomId: string, eventType: string, stateKey: string | undefined): Promise<IRoomEvent[]> {\n        return this.readStateEvents(eventType, stateKey, Number.MAX_SAFE_INTEGER, [roomId]);\n    }\n\n    /**\n     * Reads all events that are related to a given event. The widget API will\n     * have already verified that the widget is capable of receiving the event,\n     * or will make sure to reject access to events which are returned from this\n     * function, but are not capable of receiving. If `relationType` or `eventType`\n     * are set, the returned events should already be filtered. Less events than\n     * the limit are allowed to be returned, but not more.\n     * @param eventId The id of the parent event to be read.\n     * @param roomId The room to look within. When undefined, the user's\n     * currently viewed room.\n     * @param relationType The relationship type of child events to search for.\n     * When undefined, all relations are returned.\n     * @param eventType The event type of child events to search for. When undefined,\n     * all related events are returned.\n     * @param from The pagination token to start returning results from, as\n     * received from a previous call. If not supplied, results start at the most\n     * recent topological event known to the server.\n     * @param to The pagination token to stop returning results at. If not\n     * supplied, results continue up to limit or until there are no more events.\n     * @param limit The maximum number of events to retrieve per room. If not\n     * supplied, the server will apply a default limit.\n     * @param direction The direction to search for according to MSC3715\n     * @returns Resolves to the room relations.\n     */\n    public readEventRelations(\n        eventId: string,\n        roomId?: string,\n        relationType?: string,\n        eventType?: string,\n        from?: string,\n        to?: string,\n        limit?: number,\n        direction?: \"f\" | \"b\",\n    ): Promise<IReadEventRelationsResult> {\n        return Promise.resolve({ chunk: [] });\n    }\n\n    /**\n     * Asks the user for permission to validate their identity through OpenID Connect. The\n     * interface for this function is an observable which accepts the state machine of the\n     * OIDC exchange flow. For example, if the client/user blocks the request then it would\n     * feed back a `{state: Blocked}` into the observable. Similarly, if the user already\n     * approved the widget then a `{state: Allowed}` would be fed into the observable alongside\n     * the token itself. If the client is asking for permission, it should feed in a\n     * `{state: PendingUserConfirmation}` followed by the relevant Allowed or Blocked state.\n     *\n     * The widget API will reject the widget's request with an error if this contract is not\n     * met properly. By default, the widget driver will block all OIDC requests.\n     * @param {SimpleObservable<IOpenIDUpdate>} observer The observable to feed updates into.\n     */\n    public askOpenID(observer: SimpleObservable<IOpenIDUpdate>): void {\n        observer.update({ state: OpenIDRequestState.Blocked });\n    }\n\n    /**\n     * Navigates the client with a matrix.to URI. In future this function will also be provided\n     * with the Matrix URIs once matrix.to is replaced. The given URI will have already been\n     * lightly checked to ensure it looks like a valid URI, though the implementation is recommended\n     * to do further checks on the URI.\n     * @param {string} uri The URI to navigate to.\n     * @returns {Promise<void>} Resolves when complete.\n     * @throws Throws if there's a problem with the navigation, such as invalid format.\n     */\n    public navigate(uri: string): Promise<void> {\n        throw new Error(\"Navigation is not implemented\");\n    }\n\n    /**\n     * Polls for TURN server data, yielding an initial set of credentials as soon as possible, and\n     * thereafter yielding new credentials whenever the previous ones expire. The widget API will\n     * have already verified that the widget has permission to access TURN servers.\n     * @yields {ITurnServer} The TURN server URIs and credentials currently available to the client.\n     */\n    public getTurnServers(): AsyncGenerator<ITurnServer> {\n        throw new Error(\"TURN server support is not implemented\");\n    }\n\n    /**\n     * Search for users in the user directory.\n     * @param searchTerm The term to search for.\n     * @param limit The maximum number of results to return. If not supplied, the\n     * @returns Resolves to the search results.\n     */\n    public searchUserDirectory(searchTerm: string, limit?: number): Promise<ISearchUserDirectoryResult> {\n        return Promise.resolve({ limited: false, results: [] });\n    }\n\n    /**\n     * Get the config for the media repository.\n     * @returns Promise which resolves with an object containing the config.\n     */\n    public getMediaConfig(): Promise<IGetMediaConfigResult> {\n        throw new Error(\"Get media config is not implemented\");\n    }\n\n    /**\n     * Upload a file to the media repository on the homeserver.\n     * @param file - The object to upload. Something that can be sent to\n     *               XMLHttpRequest.send (typically a File).\n     * @returns Resolves to the location of the uploaded file.\n     */\n    public uploadFile(file: XMLHttpRequestBodyInit): Promise<{ contentUri: string }> {\n        throw new Error(\"Upload file is not implemented\");\n    }\n\n    /**\n     * Download a file from the media repository on the homeserver.\n     * @param contentUri - MXC URI of the file to download.\n     * @returns Resolves to the contents of the file.\n     */\n    public downloadFile(contentUri: string): Promise<{ file: XMLHttpRequestBodyInit }> {\n        throw new Error(\"Download file is not implemented\");\n    }\n\n    /**\n     * Gets the IDs of all joined or invited rooms currently known to the\n     * client.\n     * @returns The room IDs.\n     */\n    public getKnownRooms(): string[] {\n        throw new Error(\"Querying known rooms is not implemented\");\n    }\n\n    /**\n     * Expresses an error thrown by this driver in a format compatible with the Widget API.\n     * @param error The error to handle.\n     * @returns The error expressed as a {@link IWidgetApiErrorResponseDataDetails},\n     * or undefined if it cannot be expressed as one.\n     */\n    public processError(error: unknown): IWidgetApiErrorResponseDataDetails | undefined {\n        return undefined;\n    }\n}\n","/*\nCopyright 2020 - 2021 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n        http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\n// Primary structures\nexport * from \"./WidgetApi\";\nexport * from \"./ClientWidgetApi\";\nexport * from \"./Symbols\";\n\n// Transports (not sure why you'd use these directly, but might as well export all the things)\nexport type * from \"./transport/ITransport\";\nexport * from \"./transport/PostmessageTransport\";\n\n// Interfaces and simple models\nexport type * from \"./interfaces/ICustomWidgetData\";\nexport type * from \"./interfaces/IJitsiWidgetData\";\nexport type * from \"./interfaces/IStickerpickerWidgetData\";\nexport type * from \"./interfaces/IWidget\";\nexport * from \"./interfaces/WidgetType\";\nexport * from \"./interfaces/IWidgetApiErrorResponse\";\nexport type * from \"./interfaces/IWidgetApiRequest\";\nexport type * from \"./interfaces/IWidgetApiResponse\";\nexport * from \"./interfaces/WidgetApiAction\";\nexport * from \"./interfaces/WidgetApiDirection\";\nexport * from \"./interfaces/ApiVersion\";\nexport * from \"./interfaces/Capabilities\";\nexport type * from \"./interfaces/CapabilitiesAction\";\nexport type * from \"./interfaces/ContentLoadedAction\";\nexport type * from \"./interfaces/ScreenshotAction\";\nexport type * from \"./interfaces/StickerAction\";\nexport type * from \"./interfaces/StickyAction\";\nexport type * from \"./interfaces/SupportedVersionsAction\";\nexport type * from \"./interfaces/VisibilityAction\";\nexport * from \"./interfaces/GetOpenIDAction\";\nexport type * from \"./interfaces/OpenIDCredentialsAction\";\nexport * from \"./interfaces/WidgetKind\";\nexport * from \"./interfaces/ModalButtonKind\";\nexport * from \"./interfaces/ModalWidgetActions\";\nexport type * from \"./interfaces/SetModalButtonEnabledAction\";\nexport type * from \"./interfaces/WidgetConfigAction\";\nexport type * from \"./interfaces/SendEventAction\";\nexport type * from \"./interfaces/SendToDeviceAction\";\nexport type * from \"./interfaces/ReadEventAction\";\nexport type * from \"./interfaces/IRoomEvent\";\nexport type * from \"./interfaces/IRoomAccountData\";\nexport type * from \"./interfaces/NavigateAction\";\nexport type * from \"./interfaces/TurnServerActions\";\nexport type * from \"./interfaces/ReadRelationsAction\";\nexport type * from \"./interfaces/GetMediaConfigAction\";\nexport * from \"./interfaces/UpdateDelayedEventAction\";\nexport type * from \"./interfaces/UpdateStateAction\";\nexport type * from \"./interfaces/UploadFileAction\";\nexport type * from \"./interfaces/DownloadFileAction\";\nexport type * from \"./interfaces/ThemeChangeAction\";\nexport type * from \"./interfaces/LanguageChangeAction\";\n\n// Complex models\nexport * from \"./models/WidgetEventCapability\";\nexport * from \"./models/validation/url\";\nexport * from \"./models/validation/utils\";\nexport * from \"./models/Widget\";\nexport * from \"./models/WidgetParser\";\n\n// Utilities\nexport * from \"./templating/url-template\";\nexport * from \"./util/SimpleObservable\";\n\n// Drivers\nexport * from \"./driver/WidgetDriver\";\n","/*\n * Copyright 2020 The Matrix.org Foundation C.I.C.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *         http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nexport enum MatrixApiVersion {\n    Prerelease1 = \"0.0.1\",\n    Prerelease2 = \"0.0.2\",\n    //V010 = \"0.1.0\", // first release\n}\n\nexport enum UnstableApiVersion {\n    MSC2762 = \"org.matrix.msc2762\",\n    MSC2762_UPDATE_STATE = \"org.matrix.msc2762_update_state\",\n    MSC2871 = \"org.matrix.msc2871\",\n    MSC2873 = \"org.matrix.msc2873\",\n    MSC2931 = \"org.matrix.msc2931\",\n    MSC2974 = \"org.matrix.msc2974\",\n    MSC2876 = \"org.matrix.msc2876\",\n    MSC3819 = \"org.matrix.msc3819\",\n    MSC3846 = \"town.robin.msc3846\",\n    MSC3869 = \"org.matrix.msc3869\",\n    MSC3973 = \"org.matrix.msc3973\",\n    MSC4039 = \"org.matrix.msc4039\",\n}\n\nexport type ApiVersion = MatrixApiVersion | UnstableApiVersion | string;\n\nexport const CurrentApiVersions: ApiVersion[] = [\n    MatrixApiVersion.Prerelease1,\n    MatrixApiVersion.Prerelease2,\n    //MatrixApiVersion.V010,\n    UnstableApiVersion.MSC2762,\n    UnstableApiVersion.MSC2762_UPDATE_STATE,\n    UnstableApiVersion.MSC2871,\n    UnstableApiVersion.MSC2873,\n    UnstableApiVersion.MSC2931,\n    UnstableApiVersion.MSC2974,\n    UnstableApiVersion.MSC2876,\n    UnstableApiVersion.MSC3819,\n    UnstableApiVersion.MSC3846,\n    UnstableApiVersion.MSC3869,\n    UnstableApiVersion.MSC3973,\n    UnstableApiVersion.MSC4039,\n];\n","/*\n * Copyright 2020 - 2021 The Matrix.org Foundation C.I.C.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *         http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Symbols } from \"../Symbols\";\n\nexport enum MatrixCapabilities {\n    Screenshots = \"m.capability.screenshot\",\n    StickerSending = \"m.sticker\",\n    AlwaysOnScreen = \"m.always_on_screen\",\n    /**\n     * @deprecated It is not recommended to rely on this existing - it can be removed without notice.\n     * Ask Element to not give the option to move the widget into a separate tab.\n     */\n    RequiresClient = \"io.element.requires_client\",\n    /**\n     * @deprecated It is not recommended to rely on this existing - it can be removed without notice.\n     */\n    MSC2931Navigate = \"org.matrix.msc2931.navigate\",\n    MSC3846TurnServers = \"town.robin.msc3846.turn_servers\",\n    /**\n     * @deprecated It is not recommended to rely on this existing - it can be removed without notice.\n     */\n    MSC3973UserDirectorySearch = \"org.matrix.msc3973.user_directory_search\",\n    /**\n     * @deprecated It is not recommended to rely on this existing - it can be removed without notice.\n     */\n    MSC4039UploadFile = \"org.matrix.msc4039.upload_file\",\n    /**\n     * @deprecated It is not recommended to rely on this existing - it can be removed without notice.\n     */\n    MSC4039DownloadFile = \"org.matrix.msc4039.download_file\",\n    /**\n     * @deprecated It is not recommended to rely on this existing - it can be removed without notice.\n     */\n    MSC4157SendDelayedEvent = \"org.matrix.msc4157.send.delayed_event\",\n    /**\n     * @deprecated It is not recommended to rely on this existing - it can be removed without notice.\n     */\n    MSC4157UpdateDelayedEvent = \"org.matrix.msc4157.update_delayed_event\",\n}\n\nexport type Capability = MatrixCapabilities | string;\n\nexport const StickerpickerCapabilities: Capability[] = [MatrixCapabilities.StickerSending];\nexport const VideoConferenceCapabilities: Capability[] = [MatrixCapabilities.AlwaysOnScreen];\n\n/**\n * Determines if a capability is a capability for a timeline.\n * @param {Capability} capability The capability to test.\n * @returns {boolean} True if a timeline capability, false otherwise.\n */\nexport function isTimelineCapability(capability: Capability): boolean {\n    // TODO: Change when MSC2762 becomes stable.\n    return capability?.startsWith(\"org.matrix.msc2762.timeline:\");\n}\n\n/**\n * Determines if a capability is a timeline capability for the given room.\n * @param {Capability} capability The capability to test.\n * @param {string | Symbols.AnyRoom} roomId The room ID, or `Symbols.AnyRoom` for that designation.\n * @returns {boolean} True if a matching capability, false otherwise.\n */\nexport function isTimelineCapabilityFor(capability: Capability, roomId: string | Symbols.AnyRoom): boolean {\n    return capability === `org.matrix.msc2762.timeline:${roomId}`;\n}\n\n/**\n * Gets the room ID described by a timeline capability.\n * @param {string} capability The capability to parse.\n * @returns {string} The room ID.\n */\nexport function getTimelineRoomIDFromCapability(capability: Capability): string {\n    return capability.substring(capability.indexOf(\":\") + 1);\n}\n","/*\n * Copyright 2020 The Matrix.org Foundation C.I.C.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *         http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { IWidgetApiRequest, IWidgetApiRequestData } from \"./IWidgetApiRequest\";\nimport { WidgetApiFromWidgetAction } from \"./WidgetApiAction\";\nimport { IWidgetApiResponseData } from \"./IWidgetApiResponse\";\n\nexport enum OpenIDRequestState {\n    Allowed = \"allowed\",\n    Blocked = \"blocked\",\n    PendingUserConfirmation = \"request\",\n}\n\nexport interface IOpenIDCredentials {\n    access_token?: string; // eslint-disable-line camelcase\n    expires_in?: number; // eslint-disable-line camelcase\n    matrix_server_name?: string; // eslint-disable-line camelcase\n    token_type?: \"Bearer\" | string; // eslint-disable-line camelcase\n}\n\nexport interface IGetOpenIDActionRequestData extends IWidgetApiRequestData {\n    // nothing\n}\n\nexport interface IGetOpenIDActionRequest extends IWidgetApiRequest {\n    action: WidgetApiFromWidgetAction.GetOpenIDCredentials;\n    data: IGetOpenIDActionRequestData;\n}\n\nexport interface IGetOpenIDActionResponseData extends IWidgetApiResponseData, IOpenIDCredentials {\n    state: OpenIDRequestState;\n}\n\nexport interface IGetOpenIDActionResponse extends IGetOpenIDActionRequest {\n    response: IGetOpenIDActionResponseData;\n}\n","/*\n * Copyright 2020 - 2024 The Matrix.org Foundation C.I.C.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *         http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { IWidgetApiResponse, IWidgetApiResponseData } from \"./IWidgetApiResponse\";\n\n/**\n * The format of errors returned by Matrix API requests\n * made by a WidgetDriver.\n */\nexport interface IMatrixApiError {\n    /** The HTTP status code of the associated request. */\n    http_status: number; // eslint-disable-line camelcase\n    /** Any HTTP response headers that are relevant to the error. */\n    http_headers: { [name: string]: string }; // eslint-disable-line camelcase\n    /** The URL of the failed request. */\n    url: string;\n    /** @see {@link https://spec.matrix.org/latest/client-server-api/#standard-error-response} */\n    response: {\n        errcode: string;\n        error: string;\n    } & IWidgetApiResponseData; // extensible\n}\n\nexport interface IWidgetApiErrorResponseDataDetails {\n    /** Set if the error came from a Matrix API request made by a widget driver */\n    matrix_api_error?: IMatrixApiError; // eslint-disable-line camelcase\n}\n\nexport interface IWidgetApiErrorResponseData extends IWidgetApiResponseData {\n    error: {\n        /** A user-friendly string describing the error */\n        message: string;\n    } & IWidgetApiErrorResponseDataDetails;\n}\n\nexport interface IWidgetApiErrorResponse extends IWidgetApiResponse {\n    response: IWidgetApiErrorResponseData;\n}\n\nexport function isErrorResponse(responseData: IWidgetApiResponseData): responseData is IWidgetApiErrorResponseData {\n    const error = responseData.error;\n    return typeof error === \"object\" && error !== null && \"message\" in error && typeof error.message === \"string\";\n}\n","/*\n * Copyright 2020 The Matrix.org Foundation C.I.C.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *         http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nexport enum ModalButtonKind {\n    Primary = \"m.primary\",\n    Secondary = \"m.secondary\",\n    Warning = \"m.warning\",\n    Danger = \"m.danger\",\n    Link = \"m.link\",\n}\n","/*\n * Copyright 2020 The Matrix.org Foundation C.I.C.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *         http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { IWidgetApiRequest, IWidgetApiRequestData } from \"./IWidgetApiRequest\";\nimport { WidgetApiFromWidgetAction, WidgetApiToWidgetAction } from \"./WidgetApiAction\";\nimport { IWidgetApiAcknowledgeResponseData, IWidgetApiResponse } from \"./IWidgetApiResponse\";\nimport { IWidget } from \"./IWidget\";\nimport { ModalButtonKind } from \"./ModalButtonKind\";\n\nexport enum BuiltInModalButtonID {\n    Close = \"m.close\",\n}\nexport type ModalButtonID = BuiltInModalButtonID | string;\n\nexport interface IModalWidgetCreateData extends IWidgetApiRequestData {\n    [key: string]: unknown;\n}\n\nexport interface IModalWidgetReturnData {\n    [key: string]: unknown;\n}\n\n// Types for a normal modal requesting the opening a modal widget\nexport interface IModalWidgetOpenRequestDataButton {\n    id: ModalButtonID;\n    label: string;\n    kind: ModalButtonKind | string;\n    disabled?: boolean;\n}\n\nexport interface IModalWidgetOpenRequestData extends IModalWidgetCreateData, Omit<IWidget, \"id\" | \"creatorUserId\"> {\n    buttons?: IModalWidgetOpenRequestDataButton[];\n}\n\nexport interface IModalWidgetOpenRequest extends IWidgetApiRequest {\n    action: WidgetApiFromWidgetAction.OpenModalWidget;\n    data: IModalWidgetOpenRequestData;\n}\n\nexport interface IModalWidgetOpenResponse extends IWidgetApiResponse {\n    response: IWidgetApiAcknowledgeResponseData;\n}\n\n// Types for a modal widget receiving notifications that its buttons have been pressed\nexport interface IModalWidgetButtonClickedRequestData extends IWidgetApiRequestData {\n    id: IModalWidgetOpenRequestDataButton[\"id\"];\n}\n\nexport interface IModalWidgetButtonClickedRequest extends IWidgetApiRequest {\n    action: WidgetApiToWidgetAction.ButtonClicked;\n    data: IModalWidgetButtonClickedRequestData;\n}\n\nexport interface IModalWidgetButtonClickedResponse extends IWidgetApiResponse {\n    response: IWidgetApiAcknowledgeResponseData;\n}\n\n// Types for a modal widget requesting close\nexport interface IModalWidgetCloseRequest extends IWidgetApiRequest {\n    action: WidgetApiFromWidgetAction.CloseModalWidget;\n    data: IModalWidgetReturnData;\n}\n\nexport interface IModalWidgetCloseResponse extends IWidgetApiResponse {\n    response: IWidgetApiAcknowledgeResponseData;\n}\n\n// Types for a normal widget being notified that the modal widget it opened has been closed\nexport interface IModalWidgetCloseNotificationRequest extends IWidgetApiRequest {\n    action: WidgetApiToWidgetAction.CloseModalWidget;\n    data: IModalWidgetReturnData;\n}\n\nexport interface IModalWidgetCloseNotificationResponse extends IWidgetApiResponse {\n    response: IWidgetApiAcknowledgeResponseData;\n}\n","/*\n * Copyright 2020 - 2024 The Matrix.org Foundation C.I.C.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *         http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { IWidgetApiRequest, IWidgetApiRequestData } from \"./IWidgetApiRequest\";\nimport { WidgetApiFromWidgetAction } from \"./WidgetApiAction\";\nimport { IWidgetApiResponseData } from \"./IWidgetApiResponse\";\n\nexport enum UpdateDelayedEventAction {\n    Cancel = \"cancel\",\n    Restart = \"restart\",\n    Send = \"send\",\n}\n\nexport interface IUpdateDelayedEventFromWidgetRequestData extends IWidgetApiRequestData {\n    delay_id: string; // eslint-disable-line camelcase\n    action: UpdateDelayedEventAction;\n}\n\nexport interface IUpdateDelayedEventFromWidgetActionRequest extends IWidgetApiRequest {\n    action: WidgetApiFromWidgetAction.MSC4157UpdateDelayedEvent;\n    data: IUpdateDelayedEventFromWidgetRequestData;\n}\n\nexport interface IUpdateDelayedEventFromWidgetResponseData extends IWidgetApiResponseData {\n    // nothing\n}\n\nexport interface IUpdateDelayedEventFromWidgetActionResponse extends IUpdateDelayedEventFromWidgetActionRequest {\n    response: IUpdateDelayedEventFromWidgetResponseData;\n}\n","/*\n * Copyright 2020 The Matrix.org Foundation C.I.C.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *         http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nexport enum WidgetApiToWidgetAction {\n    SupportedApiVersions = \"supported_api_versions\",\n    Capabilities = \"capabilities\",\n    NotifyCapabilities = \"notify_capabilities\",\n    ThemeChange = \"theme_change\",\n    LanguageChange = \"language_change\",\n    TakeScreenshot = \"screenshot\",\n    UpdateVisibility = \"visibility\",\n    OpenIDCredentials = \"openid_credentials\",\n    WidgetConfig = \"widget_config\",\n    CloseModalWidget = \"close_modal\",\n    ButtonClicked = \"button_clicked\",\n    SendEvent = \"send_event\",\n    SendToDevice = \"send_to_device\",\n    UpdateState = \"update_state\",\n    UpdateTurnServers = \"update_turn_servers\",\n}\n\nexport enum WidgetApiFromWidgetAction {\n    SupportedApiVersions = \"supported_api_versions\",\n    ContentLoaded = \"content_loaded\",\n    SendSticker = \"m.sticker\",\n    UpdateAlwaysOnScreen = \"set_always_on_screen\",\n    GetOpenIDCredentials = \"get_openid\",\n    CloseModalWidget = \"close_modal\",\n    OpenModalWidget = \"open_modal\",\n    SetModalButtonEnabled = \"set_button_enabled\",\n    SendEvent = \"send_event\",\n    SendToDevice = \"send_to_device\",\n    WatchTurnServers = \"watch_turn_servers\",\n    UnwatchTurnServers = \"unwatch_turn_servers\",\n\n    BeeperReadRoomAccountData = \"com.beeper.read_room_account_data\",\n\n    /**\n     * @deprecated It is not recommended to rely on this existing - it can be removed without notice.\n     */\n    MSC2876ReadEvents = \"org.matrix.msc2876.read_events\",\n\n    /**\n     * @deprecated It is not recommended to rely on this existing - it can be removed without notice.\n     */\n    MSC2931Navigate = \"org.matrix.msc2931.navigate\",\n\n    /**\n     * @deprecated It is not recommended to rely on this existing - it can be removed without notice.\n     */\n    MSC2974RenegotiateCapabilities = \"org.matrix.msc2974.request_capabilities\",\n\n    /**\n     * @deprecated It is not recommended to rely on this existing - it can be removed without notice.\n     */\n    MSC3869ReadRelations = \"org.matrix.msc3869.read_relations\",\n\n    /**\n     * @deprecated It is not recommended to rely on this existing - it can be removed without notice.\n     */\n    MSC3973UserDirectorySearch = \"org.matrix.msc3973.user_directory_search\",\n\n    /**\n     * @deprecated It is not recommended to rely on this existing - it can be removed without notice.\n     */\n    MSC4039GetMediaConfigAction = \"org.matrix.msc4039.get_media_config\",\n\n    /**\n     * @deprecated It is not recommended to rely on this existing - it can be removed without notice.\n     */\n    MSC4039UploadFileAction = \"org.matrix.msc4039.upload_file\",\n\n    /**\n     * @deprecated It is not recommended to rely on this existing - it can be removed without notice.\n     */\n    MSC4039DownloadFileAction = \"org.matrix.msc4039.download_file\",\n\n    /**\n     * @deprecated It is not recommended to rely on this existing - it can be removed without notice.\n     */\n    MSC4157UpdateDelayedEvent = \"org.matrix.msc4157.update_delayed_event\",\n}\n\nexport type WidgetApiAction = WidgetApiToWidgetAction | WidgetApiFromWidgetAction | string;\n","/*\n * Copyright 2020 The Matrix.org Foundation C.I.C.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *         http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nexport enum WidgetApiDirection {\n    ToWidget = \"toWidget\",\n    FromWidget = \"fromWidget\",\n}\n\nexport function invertedDirection(dir: WidgetApiDirection): WidgetApiDirection {\n    if (dir === WidgetApiDirection.ToWidget) {\n        return WidgetApiDirection.FromWidget;\n    } else if (dir === WidgetApiDirection.FromWidget) {\n        return WidgetApiDirection.ToWidget;\n    } else {\n        throw new Error(\"Invalid direction\");\n    }\n}\n","/*\n * Copyright 2020 The Matrix.org Foundation C.I.C.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *         http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nexport enum WidgetKind {\n    Room = \"room\",\n    Account = \"account\",\n    Modal = \"modal\",\n}\n","/*\n * Copyright 2020 The Matrix.org Foundation C.I.C.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *         http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nexport enum MatrixWidgetType {\n    Custom = \"m.custom\",\n    JitsiMeet = \"m.jitsi\",\n    Stickerpicker = \"m.stickerpicker\",\n}\n\nexport type WidgetType = MatrixWidgetType | string;\n","/*\n * Copyright 2020 The Matrix.org Foundation C.I.C.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *         http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { IWidget, IWidgetData, WidgetType } from \"..\";\nimport { assertPresent } from \"./validation/utils\";\nimport { ITemplateParams, runTemplate } from \"..\";\n\n/**\n * Represents the barest form of widget.\n */\nexport class Widget {\n    public constructor(private definition: IWidget) {\n        if (!this.definition) throw new Error(\"Definition is required\");\n\n        assertPresent(definition, \"id\");\n        assertPresent(definition, \"creatorUserId\");\n        assertPresent(definition, \"type\");\n        assertPresent(definition, \"url\");\n    }\n\n    /**\n     * The user ID who created the widget.\n     */\n    public get creatorUserId(): string {\n        return this.definition.creatorUserId;\n    }\n\n    /**\n     * The type of widget.\n     */\n    public get type(): WidgetType {\n        return this.definition.type;\n    }\n\n    /**\n     * The ID of the widget.\n     */\n    public get id(): string {\n        return this.definition.id;\n    }\n\n    /**\n     * The name of the widget, or null if not set.\n     */\n    public get name(): string | null {\n        return this.definition.name || null;\n    }\n\n    /**\n     * The title for the widget, or null if not set.\n     */\n    public get title(): string | null {\n        return this.rawData.title || null;\n    }\n\n    /**\n     * The templated URL for the widget.\n     */\n    public get templateUrl(): string {\n        return this.definition.url;\n    }\n\n    /**\n     * The origin for this widget.\n     */\n    public get origin(): string {\n        return new URL(this.templateUrl).origin;\n    }\n\n    /**\n     * Whether or not the client should wait for the iframe to load. Defaults\n     * to true.\n     */\n    public get waitForIframeLoad(): boolean {\n        if (this.definition.waitForIframeLoad === false) return false;\n        if (this.definition.waitForIframeLoad === true) return true;\n        return true; // default true\n    }\n\n    /**\n     * The raw data for the widget. This will always be defined, though\n     * may be empty.\n     */\n    public get rawData(): IWidgetData {\n        return this.definition.data || {};\n    }\n\n    /**\n     * Gets a complete widget URL for the client to render.\n     * @param {ITemplateParams} params The template parameters.\n     * @returns {string} A templated URL.\n     */\n    public getCompleteUrl(params: ITemplateParams): string {\n        return runTemplate(this.templateUrl, this.definition, params);\n    }\n}\n","/*\n * Copyright 2020 The Matrix.org Foundation C.I.C.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *         http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Capability } from \"..\";\n\nexport enum EventKind {\n    Event = \"event\",\n    State = \"state_event\",\n    ToDevice = \"to_device\",\n    RoomAccount = \"room_account\",\n}\n\nexport enum EventDirection {\n    Send = \"send\",\n    Receive = \"receive\",\n}\n\nexport class WidgetEventCapability {\n    private constructor(\n        public readonly direction: EventDirection,\n        public readonly eventType: string,\n        public readonly kind: EventKind,\n        public readonly keyStr: string | null,\n        public readonly raw: string,\n    ) {}\n\n    public matchesAsStateEvent(direction: EventDirection, eventType: string, stateKey: string | null): boolean {\n        if (this.kind !== EventKind.State) return false; // not a state event\n        if (this.direction !== direction) return false; // direction mismatch\n        if (this.eventType !== eventType) return false; // event type mismatch\n        if (this.keyStr === null) return true; // all state keys are allowed\n        if (this.keyStr === stateKey) return true; // this state key is allowed\n\n        // Default not allowed\n        return false;\n    }\n\n    public matchesAsToDeviceEvent(direction: EventDirection, eventType: string): boolean {\n        if (this.kind !== EventKind.ToDevice) return false; // not a to-device event\n        if (this.direction !== direction) return false; // direction mismatch\n        if (this.eventType !== eventType) return false; // event type mismatch\n\n        // Checks passed, the event is allowed\n        return true;\n    }\n\n    public matchesAsRoomEvent(direction: EventDirection, eventType: string, msgtype: string | null = null): boolean {\n        if (this.kind !== EventKind.Event) return false; // not a room event\n        if (this.direction !== direction) return false; // direction mismatch\n        if (this.eventType !== eventType) return false; // event type mismatch\n\n        if (this.eventType === \"m.room.message\") {\n            if (this.keyStr === null) return true; // all message types are allowed\n            if (this.keyStr === msgtype) return true; // this message type is allowed\n        } else {\n            return true; // already passed the check for if the event is allowed\n        }\n\n        // Default not allowed\n        return false;\n    }\n\n    public matchesAsRoomAccountData(direction: EventDirection, eventType: string): boolean {\n        if (this.kind !== EventKind.RoomAccount) return false; // not room account data\n        if (this.direction !== direction) return false; // direction mismatch\n        if (this.eventType !== eventType) return false; // event type mismatch\n\n        // Checks passed, the event is allowed\n        return true;\n    }\n\n    public static forStateEvent(\n        direction: EventDirection,\n        eventType: string,\n        stateKey?: string,\n    ): WidgetEventCapability {\n        // TODO: Enable support for m.* namespace once the MSC lands.\n        // https://github.com/matrix-org/matrix-widget-api/issues/22\n        eventType = eventType.replace(/#/g, \"\\\\#\");\n        stateKey = stateKey !== null && stateKey !== undefined ? `#${stateKey}` : \"\";\n        const str = `org.matrix.msc2762.${direction}.state_event:${eventType}${stateKey}`;\n\n        // cheat by sending it through the processor\n        return WidgetEventCapability.findEventCapabilities([str])[0];\n    }\n\n    public static forToDeviceEvent(direction: EventDirection, eventType: string): WidgetEventCapability {\n        // TODO: Enable support for m.* namespace once the MSC lands.\n        // https://github.com/matrix-org/matrix-widget-api/issues/56\n        const str = `org.matrix.msc3819.${direction}.to_device:${eventType}`;\n\n        // cheat by sending it through the processor\n        return WidgetEventCapability.findEventCapabilities([str])[0];\n    }\n\n    public static forRoomEvent(direction: EventDirection, eventType: string): WidgetEventCapability {\n        // TODO: Enable support for m.* namespace once the MSC lands.\n        // https://github.com/matrix-org/matrix-widget-api/issues/22\n        const str = `org.matrix.msc2762.${direction}.event:${eventType}`;\n\n        // cheat by sending it through the processor\n        return WidgetEventCapability.findEventCapabilities([str])[0];\n    }\n\n    public static forRoomMessageEvent(direction: EventDirection, msgtype?: string): WidgetEventCapability {\n        // TODO: Enable support for m.* namespace once the MSC lands.\n        // https://github.com/matrix-org/matrix-widget-api/issues/22\n        msgtype = msgtype === null || msgtype === undefined ? \"\" : msgtype;\n        const str = `org.matrix.msc2762.${direction}.event:m.room.message#${msgtype}`;\n\n        // cheat by sending it through the processor\n        return WidgetEventCapability.findEventCapabilities([str])[0];\n    }\n\n    public static forRoomAccountData(direction: EventDirection, eventType: string): WidgetEventCapability {\n        const str = `com.beeper.capabilities.${direction}.room_account_data:${eventType}`;\n\n        return WidgetEventCapability.findEventCapabilities([str])[0];\n    }\n\n    /**\n     * Parses a capabilities request to find all the event capability requests.\n     * @param {Iterable<Capability>} capabilities The capabilities requested/to parse.\n     * @returns {WidgetEventCapability[]} An array of event capability requests. May be empty, but never null.\n     */\n    public static findEventCapabilities(capabilities: Iterable<Capability>): WidgetEventCapability[] {\n        const parsed: WidgetEventCapability[] = [];\n        for (const cap of capabilities) {\n            let direction: EventDirection | null = null;\n            let eventSegment: string | undefined;\n            let kind: EventKind | null = null;\n\n            // TODO: Enable support for m.* namespace once the MSCs land.\n            // https://github.com/matrix-org/matrix-widget-api/issues/22\n            // https://github.com/matrix-org/matrix-widget-api/issues/56\n\n            if (cap.startsWith(\"org.matrix.msc2762.send.event:\")) {\n                direction = EventDirection.Send;\n                kind = EventKind.Event;\n                eventSegment = cap.substring(\"org.matrix.msc2762.send.event:\".length);\n            } else if (cap.startsWith(\"org.matrix.msc2762.send.state_event:\")) {\n                direction = EventDirection.Send;\n                kind = EventKind.State;\n                eventSegment = cap.substring(\"org.matrix.msc2762.send.state_event:\".length);\n            } else if (cap.startsWith(\"org.matrix.msc3819.send.to_device:\")) {\n                direction = EventDirection.Send;\n                kind = EventKind.ToDevice;\n                eventSegment = cap.substring(\"org.matrix.msc3819.send.to_device:\".length);\n            } else if (cap.startsWith(\"org.matrix.msc2762.receive.event:\")) {\n                direction = EventDirection.Receive;\n                kind = EventKind.Event;\n                eventSegment = cap.substring(\"org.matrix.msc2762.receive.event:\".length);\n            } else if (cap.startsWith(\"org.matrix.msc2762.receive.state_event:\")) {\n                direction = EventDirection.Receive;\n                kind = EventKind.State;\n                eventSegment = cap.substring(\"org.matrix.msc2762.receive.state_event:\".length);\n            } else if (cap.startsWith(\"org.matrix.msc3819.receive.to_device:\")) {\n                direction = EventDirection.Receive;\n                kind = EventKind.ToDevice;\n                eventSegment = cap.substring(\"org.matrix.msc3819.receive.to_device:\".length);\n            } else if (cap.startsWith(\"com.beeper.capabilities.receive.room_account_data:\")) {\n                direction = EventDirection.Receive;\n                kind = EventKind.RoomAccount;\n                eventSegment = cap.substring(\"com.beeper.capabilities.receive.room_account_data:\".length);\n            }\n\n            if (direction === null || kind === null || eventSegment === undefined) continue;\n\n            // The capability uses `#` as a separator between event type and state key/msgtype,\n            // so we split on that. However, a # is also valid in either one of those so we\n            // join accordingly.\n            // Eg: `m.room.message##m.text` is \"m.room.message\" event with msgtype \"#m.text\".\n            const expectingKeyStr = eventSegment.startsWith(\"m.room.message#\") || kind === EventKind.State;\n            let keyStr: string | null = null;\n            if (eventSegment.includes(\"#\") && expectingKeyStr) {\n                // Dev note: regex is difficult to write, so instead the rules are manually written\n                // out. This is probably just as understandable as a boring regex though, so win-win?\n\n                // Test cases:\n                // str                      eventSegment        keyStr\n                // -------------------------------------------------------------\n                // m.room.message#          m.room.message      <empty string>\n                // m.room.message#test      m.room.message      test\n                // m.room.message\\#         m.room.message#     test\n                // m.room.message##test     m.room.message      #test\n                // m.room.message\\##test    m.room.message#     test\n                // m.room.message\\\\##test   m.room.message\\#    test\n                // m.room.message\\\\###test  m.room.message\\#    #test\n\n                // First step: explode the string\n                const parts = eventSegment.split(\"#\");\n\n                // To form the eventSegment, we'll keep finding parts of the exploded string until\n                // there's one that doesn't end with the escape character (\\). We'll then join those\n                // segments together with the exploding character. We have to remember to consume the\n                // escape character as well.\n                const idx = parts.findIndex((p) => !p.endsWith(\"\\\\\"));\n                eventSegment = parts\n                    .slice(0, idx + 1)\n                    .map((p) => (p.endsWith(\"\\\\\") ? p.substring(0, p.length - 1) : p))\n                    .join(\"#\");\n\n                // The keyStr is whatever is left over.\n                keyStr = parts.slice(idx + 1).join(\"#\");\n            }\n\n            parsed.push(new WidgetEventCapability(direction, eventSegment, kind, keyStr, cap));\n        }\n        return parsed;\n    }\n}\n","/*\n * Copyright 2020 The Matrix.org Foundation C.I.C.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *         http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Widget } from \"./Widget\";\nimport { IWidget } from \"..\";\nimport { isValidUrl } from \"./validation/url\";\n\nexport interface IStateEvent {\n    event_id: string; // eslint-disable-line camelcase\n    room_id: string; // eslint-disable-line camelcase\n    type: string;\n    sender: string;\n    origin_server_ts: number; // eslint-disable-line camelcase\n    unsigned?: unknown;\n    content: unknown;\n    state_key: string; // eslint-disable-line camelcase\n}\n\nexport interface IAccountDataWidgets {\n    [widgetId: string]: {\n        type: \"m.widget\";\n        // the state_key is also the widget's ID\n        state_key: string; // eslint-disable-line camelcase\n        sender: string; // current user's ID\n        content: IWidget;\n        id?: string; // off-spec, but possible\n    };\n}\n\nexport class WidgetParser {\n    private constructor() {\n        // private constructor because this is a util class\n    }\n\n    /**\n     * Parses widgets from the \"m.widgets\" account data event. This will always\n     * return an array, though may be empty if no valid widgets were found.\n     * @param {IAccountDataWidgets} content The content of the \"m.widgets\" account data.\n     * @returns {Widget[]} The widgets in account data, or an empty array.\n     */\n    public static parseAccountData(content: IAccountDataWidgets): Widget[] {\n        if (!content) return [];\n\n        const result: Widget[] = [];\n        for (const widgetId of Object.keys(content)) {\n            const roughWidget = content[widgetId];\n            if (!roughWidget) continue;\n            if (roughWidget.type !== \"m.widget\" && roughWidget.type !== \"im.vector.modular.widgets\") continue;\n            if (!roughWidget.sender) continue;\n\n            const probableWidgetId = roughWidget.state_key || roughWidget.id;\n            if (probableWidgetId !== widgetId) continue;\n\n            const asStateEvent: IStateEvent = {\n                content: roughWidget.content,\n                sender: roughWidget.sender,\n                type: \"m.widget\",\n                state_key: widgetId,\n                event_id: \"$example\",\n                room_id: \"!example\",\n                origin_server_ts: 1,\n            };\n\n            const widget = WidgetParser.parseRoomWidget(asStateEvent);\n            if (widget) result.push(widget);\n        }\n\n        return result;\n    }\n\n    /**\n     * Parses all the widgets possible in the given array. This will always return\n     * an array, though may be empty if no widgets could be parsed.\n     * @param {IStateEvent[]} currentState The room state to parse.\n     * @returns {Widget[]} The widgets in the state, or an empty array.\n     */\n    public static parseWidgetsFromRoomState(currentState: IStateEvent[]): Widget[] {\n        if (!currentState) return [];\n        const result: Widget[] = [];\n        for (const state of currentState) {\n            const widget = WidgetParser.parseRoomWidget(state);\n            if (widget) result.push(widget);\n        }\n        return result;\n    }\n\n    /**\n     * Parses a state event into a widget. If the state event does not represent\n     * a widget (wrong event type, invalid widget, etc) then null is returned.\n     * @param {IStateEvent} stateEvent The state event.\n     * @returns {Widget|null} The widget, or null if invalid\n     */\n    public static parseRoomWidget(stateEvent: IStateEvent): Widget | null {\n        if (!stateEvent) return null;\n\n        // TODO: [Legacy] Remove legacy support\n        if (stateEvent.type !== \"m.widget\" && stateEvent.type !== \"im.vector.modular.widgets\") {\n            return null;\n        }\n\n        // Dev note: Throughout this function we have null safety to ensure that\n        // if the caller did not supply something useful that we don't error. This\n        // is done against the requirements of the interface because not everyone\n        // will have an interface to validate against.\n\n        const content = (stateEvent.content as IWidget) || {};\n\n        // Form our best approximation of a widget with the information we have\n        const estimatedWidget: IWidget = {\n            id: stateEvent.state_key,\n            creatorUserId: content[\"creatorUserId\"] || stateEvent.sender,\n            name: content[\"name\"],\n            type: content[\"type\"],\n            url: content[\"url\"],\n            waitForIframeLoad: content[\"waitForIframeLoad\"],\n            data: content[\"data\"],\n        };\n\n        // Finally, process that widget\n        return WidgetParser.processEstimatedWidget(estimatedWidget);\n    }\n\n    private static processEstimatedWidget(widget: IWidget): Widget | null {\n        // Validate that the widget has the best chance of passing as a widget\n        if (!widget.id || !widget.creatorUserId || !widget.type) {\n            return null;\n        }\n        if (!isValidUrl(widget.url)) {\n            return null;\n        }\n        // TODO: Validate data for known widget types\n        return new Widget(widget);\n    }\n}\n","/*\n * Copyright 2020 The Matrix.org Foundation C.I.C.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *         http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nexport function isValidUrl(val: string): boolean {\n    if (!val) return false; // easy: not valid if not present\n\n    try {\n        const parsed = new URL(val);\n        if (parsed.protocol !== \"http\" && parsed.protocol !== \"https\") {\n            return false;\n        }\n        return true;\n    } catch (e) {\n        if (e instanceof TypeError) {\n            return false;\n        }\n        throw e;\n    }\n}\n","/*\n * Copyright 2020 The Matrix.org Foundation C.I.C.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *         http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function assertPresent<O extends Record<any, any>>(obj: O, key: keyof O): void {\n    if (!obj[key]) {\n        throw new Error(`${String(key)} is required`);\n    }\n}\n","/*\n * Copyright 2020, 2021 The Matrix.org Foundation C.I.C.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *         http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { IWidget } from \"..\";\n\nexport interface ITemplateParams {\n    widgetRoomId?: string;\n    currentUserId: string;\n    userDisplayName?: string;\n    userHttpAvatarUrl?: string;\n    clientId?: string;\n    clientTheme?: string;\n    clientLanguage?: string;\n    deviceId?: string;\n    baseUrl?: string;\n}\n\nexport function runTemplate(url: string, widget: IWidget, params: ITemplateParams): string {\n    // Always apply the supplied params over top of data to ensure the data can't lie about them.\n    const variables = Object.assign({}, widget.data, {\n        \"matrix_room_id\": params.widgetRoomId || \"\",\n        \"matrix_user_id\": params.currentUserId,\n        \"matrix_display_name\": params.userDisplayName || params.currentUserId,\n        \"matrix_avatar_url\": params.userHttpAvatarUrl || \"\",\n        \"matrix_widget_id\": widget.id,\n\n        // TODO: Convert to stable (https://github.com/matrix-org/matrix-doc/pull/2873)\n        \"org.matrix.msc2873.client_id\": params.clientId || \"\",\n        \"org.matrix.msc2873.client_theme\": params.clientTheme || \"\",\n        \"org.matrix.msc2873.client_language\": params.clientLanguage || \"\",\n\n        // TODO: Convert to stable (https://github.com/matrix-org/matrix-spec-proposals/pull/3819)\n        \"org.matrix.msc3819.matrix_device_id\": params.deviceId || \"\",\n\n        // TODO: Convert to stable (https://github.com/matrix-org/matrix-spec-proposals/pull/4039)\n        \"org.matrix.msc4039.matrix_base_url\": params.baseUrl || \"\",\n    });\n    let result = url;\n    for (const key of Object.keys(variables)) {\n        // Regex escape from https://stackoverflow.com/a/6969486/7037379\n        const pattern = `$${key}`.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\"); // $& means the whole matched string\n        const rexp = new RegExp(pattern, \"g\");\n\n        // This is technically not what we're supposed to do for a couple of reasons:\n        // 1. We are assuming that there won't later be a $key match after we replace a variable.\n        // 2. We are assuming that the variable is in a place where it can be escaped (eg: path or query string).\n        result = result.replace(rexp, encodeURIComponent(toString(variables[key])));\n    }\n    return result;\n}\n\nexport function toString(a: unknown): string {\n    if (a === null || a === undefined) {\n        return `${a}`;\n    }\n    // eslint-disable-next-line @typescript-eslint/no-base-to-string\n    return String(a);\n}\n","/*\n * Copyright 2020 - 2024 The Matrix.org Foundation C.I.C.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *         http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { EventEmitter } from \"events\";\n\nimport { ITransport } from \"./ITransport\";\nimport {\n    invertedDirection,\n    isErrorResponse,\n    IWidgetApiRequest,\n    IWidgetApiRequestData,\n    IWidgetApiResponse,\n    IWidgetApiResponseData,\n    WidgetApiResponseError,\n    WidgetApiAction,\n    WidgetApiDirection,\n    WidgetApiToWidgetAction,\n} from \"..\";\n\ninterface IOutboundRequest {\n    request: IWidgetApiRequest;\n    resolve: (response: IWidgetApiResponse) => void;\n    reject: (err: Error) => void;\n}\n\n/**\n * Transport for the Widget API over postMessage.\n */\nexport class PostmessageTransport extends EventEmitter implements ITransport {\n    public strictOriginCheck = false;\n    public targetOrigin = \"*\";\n    public timeoutSeconds = 10;\n\n    private _ready = false;\n    private _widgetId: string | null = null;\n    private outboundRequests = new Map<string, IOutboundRequest | null>();\n    private stopController = new AbortController();\n\n    public get ready(): boolean {\n        return this._ready;\n    }\n\n    public get widgetId(): string | null {\n        return this._widgetId || null;\n    }\n\n    public constructor(\n        private sendDirection: WidgetApiDirection,\n        private initialWidgetId: string | null,\n        private transportWindow: Window,\n        private inboundWindow: Window,\n    ) {\n        super();\n        this._widgetId = initialWidgetId;\n    }\n\n    private get nextRequestId(): string {\n        const idBase = `widgetapi-${Date.now()}`;\n        let index = 0;\n        let id = idBase;\n        while (this.outboundRequests.has(id)) {\n            id = `${idBase}-${index++}`;\n        }\n\n        // reserve the ID\n        this.outboundRequests.set(id, null);\n\n        return id;\n    }\n\n    private sendInternal(message: IWidgetApiRequest | IWidgetApiResponse): void {\n        console.log(`[PostmessageTransport] Sending object to ${this.targetOrigin}: `, message);\n        this.transportWindow.postMessage(message, this.targetOrigin);\n    }\n\n    public reply<T extends IWidgetApiResponseData>(request: IWidgetApiRequest, responseData: T): void {\n        return this.sendInternal(<IWidgetApiResponse>{\n            ...request,\n            response: responseData,\n        });\n    }\n\n    public send<T extends IWidgetApiRequestData, R extends IWidgetApiResponseData>(\n        action: WidgetApiAction,\n        data: T,\n    ): Promise<R> {\n        return this.sendComplete(action, data).then((r) => <R>r.response);\n    }\n\n    public sendComplete<T extends IWidgetApiRequestData, R extends IWidgetApiResponse>(\n        action: WidgetApiAction,\n        data: T,\n    ): Promise<R> {\n        if (!this.ready || !this.widgetId) {\n            return Promise.reject(new Error(\"Not ready or unknown widget ID\"));\n        }\n        const request: IWidgetApiRequest = {\n            api: this.sendDirection,\n            widgetId: this.widgetId,\n            requestId: this.nextRequestId,\n            action: action,\n            data: data,\n        };\n        if (action === WidgetApiToWidgetAction.UpdateVisibility) {\n            request[\"visible\"] = data[\"visible\"];\n        }\n        return new Promise<R>((prResolve, prReject) => {\n            const resolve = (response: IWidgetApiResponse): void => {\n                cleanUp();\n                prResolve(<R>response);\n            };\n            const reject = (err: Error): void => {\n                cleanUp();\n                prReject(err);\n            };\n\n            const timerId = setTimeout(() => reject(new Error(\"Request timed out\")), (this.timeoutSeconds || 1) * 1000);\n\n            const onStop = (): void => reject(new Error(\"Transport stopped\"));\n            this.stopController.signal.addEventListener(\"abort\", onStop);\n\n            const cleanUp = (): void => {\n                this.outboundRequests.delete(request.requestId);\n                clearTimeout(timerId);\n                this.stopController.signal.removeEventListener(\"abort\", onStop);\n            };\n\n            this.outboundRequests.set(request.requestId, { request, resolve, reject });\n            this.sendInternal(request);\n        });\n    }\n\n    public start(): void {\n        this.inboundWindow.addEventListener(\"message\", (ev: MessageEvent) => {\n            this.handleMessage(ev);\n        });\n        this._ready = true;\n    }\n\n    public stop(): void {\n        this._ready = false;\n        this.stopController.abort();\n    }\n\n    private handleMessage(ev: MessageEvent): void {\n        if (this.stopController.signal.aborted) return;\n        if (!ev.data) return; // invalid event\n\n        if (this.strictOriginCheck && ev.origin !== window.origin) return; // bad origin\n\n        // treat the message as a response first, then downgrade to a request\n        const response = <IWidgetApiResponse>ev.data;\n        if (!response.action || !response.requestId || !response.widgetId) return; // invalid request/response\n\n        if (!response.response) {\n            // it's a request\n            const request = <IWidgetApiRequest>response;\n            if (request.api !== invertedDirection(this.sendDirection)) return; // wrong direction\n            this.handleRequest(request);\n        } else {\n            // it's a response\n            if (response.api !== this.sendDirection) return; // wrong direction\n            this.handleResponse(response);\n        }\n    }\n\n    private handleRequest(request: IWidgetApiRequest): void {\n        if (this.widgetId) {\n            if (this.widgetId !== request.widgetId) return; // wrong widget\n        } else {\n            this._widgetId = request.widgetId;\n        }\n\n        this.emit(\"message\", new CustomEvent(\"message\", { detail: request }));\n    }\n\n    private handleResponse(response: IWidgetApiResponse): void {\n        if (response.widgetId !== this.widgetId) return; // wrong widget\n\n        const req = this.outboundRequests.get(response.requestId);\n        if (!req) return; // response to an unknown request\n\n        if (isErrorResponse(response.response)) {\n            const { message, ...data } = response.response.error;\n            req.reject(new WidgetApiResponseError(message, data));\n        } else {\n            req.resolve(response);\n        }\n    }\n}\n","/*\n * Copyright 2020 The Matrix.org Foundation C.I.C.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *         http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nexport type ObservableFunction<T> = (val: T) => void;\n\nexport class SimpleObservable<T> {\n    private listeners: ObservableFunction<T>[] = [];\n\n    public constructor(initialFn?: ObservableFunction<T>) {\n        if (initialFn) this.listeners.push(initialFn);\n    }\n\n    public onUpdate(fn: ObservableFunction<T>): void {\n        this.listeners.push(fn);\n    }\n\n    public update(val: T): void {\n        for (const listener of this.listeners) {\n            listener(val);\n        }\n    }\n\n    public close(): void {\n        this.listeners = []; // reset\n    }\n}\n","\n'use strict';\n\n\nvar encodeCache = {};\n\n\n// Create a lookup array where anything but characters in `chars` string\n// and alphanumeric chars is percent-encoded.\n//\nfunction getEncodeCache(exclude) {\n  var i, ch, cache = encodeCache[exclude];\n  if (cache) { return cache; }\n\n  cache = encodeCache[exclude] = [];\n\n  for (i = 0; i < 128; i++) {\n    ch = String.fromCharCode(i);\n\n    if (/^[0-9a-z]$/i.test(ch)) {\n      // always allow unencoded alphanumeric characters\n      cache.push(ch);\n    } else {\n      cache.push('%' + ('0' + i.toString(16).toUpperCase()).slice(-2));\n    }\n  }\n\n  for (i = 0; i < exclude.length; i++) {\n    cache[exclude.charCodeAt(i)] = exclude[i];\n  }\n\n  return cache;\n}\n\n\n// Encode unsafe characters with percent-encoding, skipping already\n// encoded sequences.\n//\n//  - string       - string to encode\n//  - exclude      - list of characters to ignore (in addition to a-zA-Z0-9)\n//  - keepEscaped  - don't encode '%' in a correct escape sequence (default: true)\n//\nfunction encode(string, exclude, keepEscaped) {\n  var i, l, code, nextCode, cache,\n      result = '';\n\n  if (typeof exclude !== 'string') {\n    // encode(string, keepEscaped)\n    keepEscaped  = exclude;\n    exclude = encode.defaultChars;\n  }\n\n  if (typeof keepEscaped === 'undefined') {\n    keepEscaped = true;\n  }\n\n  cache = getEncodeCache(exclude);\n\n  for (i = 0, l = string.length; i < l; i++) {\n    code = string.charCodeAt(i);\n\n    if (keepEscaped && code === 0x25 /* % */ && i + 2 < l) {\n      if (/^[0-9a-f]{2}$/i.test(string.slice(i + 1, i + 3))) {\n        result += string.slice(i, i + 3);\n        i += 2;\n        continue;\n      }\n    }\n\n    if (code < 128) {\n      result += cache[code];\n      continue;\n    }\n\n    if (code >= 0xD800 && code <= 0xDFFF) {\n      if (code >= 0xD800 && code <= 0xDBFF && i + 1 < l) {\n        nextCode = string.charCodeAt(i + 1);\n        if (nextCode >= 0xDC00 && nextCode <= 0xDFFF) {\n          result += encodeURIComponent(string[i] + string[i + 1]);\n          i++;\n          continue;\n        }\n      }\n      result += '%EF%BF%BD';\n      continue;\n    }\n\n    result += encodeURIComponent(string[i]);\n  }\n\n  return result;\n}\n\nencode.defaultChars   = \";/?:@&=+$,-_.!~*'()#\";\nencode.componentChars = \"-_.!~*'()\";\n\n\nmodule.exports = encode;\n","var safeIsNaN = Number.isNaN ||\n    function ponyfill(value) {\n        return typeof value === 'number' && value !== value;\n    };\nfunction isEqual(first, second) {\n    if (first === second) {\n        return true;\n    }\n    if (safeIsNaN(first) && safeIsNaN(second)) {\n        return true;\n    }\n    return false;\n}\nfunction areInputsEqual(newInputs, lastInputs) {\n    if (newInputs.length !== lastInputs.length) {\n        return false;\n    }\n    for (var i = 0; i < newInputs.length; i++) {\n        if (!isEqual(newInputs[i], lastInputs[i])) {\n            return false;\n        }\n    }\n    return true;\n}\n\nfunction memoizeOne(resultFn, isEqual) {\n    if (isEqual === void 0) { isEqual = areInputsEqual; }\n    var cache = null;\n    function memoized() {\n        var newArgs = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            newArgs[_i] = arguments[_i];\n        }\n        if (cache && cache.lastThis === this && isEqual(newArgs, cache.lastArgs)) {\n            return cache.lastResult;\n        }\n        var lastResult = resultFn.apply(this, newArgs);\n        cache = {\n            lastResult: lastResult,\n            lastArgs: newArgs,\n            lastThis: this,\n        };\n        return lastResult;\n    }\n    memoized.clear = function clear() {\n        cache = null;\n    };\n    return memoized;\n}\n\nexport { memoizeOne as default };\n","const types = {\n    'application/prs.cww': ['cww'],\n    'application/prs.xsf+xml': ['xsf'],\n    'application/vnd.1000minds.decision-model+xml': ['1km'],\n    'application/vnd.3gpp.pic-bw-large': ['plb'],\n    'application/vnd.3gpp.pic-bw-small': ['psb'],\n    'application/vnd.3gpp.pic-bw-var': ['pvb'],\n    'application/vnd.3gpp2.tcap': ['tcap'],\n    'application/vnd.3m.post-it-notes': ['pwn'],\n    'application/vnd.accpac.simply.aso': ['aso'],\n    'application/vnd.accpac.simply.imp': ['imp'],\n    'application/vnd.acucobol': ['acu'],\n    'application/vnd.acucorp': ['atc', 'acutc'],\n    'application/vnd.adobe.air-application-installer-package+zip': ['air'],\n    'application/vnd.adobe.formscentral.fcdt': ['fcdt'],\n    'application/vnd.adobe.fxp': ['fxp', 'fxpl'],\n    'application/vnd.adobe.xdp+xml': ['xdp'],\n    'application/vnd.adobe.xfdf': ['*xfdf'],\n    'application/vnd.age': ['age'],\n    'application/vnd.ahead.space': ['ahead'],\n    'application/vnd.airzip.filesecure.azf': ['azf'],\n    'application/vnd.airzip.filesecure.azs': ['azs'],\n    'application/vnd.amazon.ebook': ['azw'],\n    'application/vnd.americandynamics.acc': ['acc'],\n    'application/vnd.amiga.ami': ['ami'],\n    'application/vnd.android.package-archive': ['apk'],\n    'application/vnd.anser-web-certificate-issue-initiation': ['cii'],\n    'application/vnd.anser-web-funds-transfer-initiation': ['fti'],\n    'application/vnd.antix.game-component': ['atx'],\n    'application/vnd.apple.installer+xml': ['mpkg'],\n    'application/vnd.apple.keynote': ['key'],\n    'application/vnd.apple.mpegurl': ['m3u8'],\n    'application/vnd.apple.numbers': ['numbers'],\n    'application/vnd.apple.pages': ['pages'],\n    'application/vnd.apple.pkpass': ['pkpass'],\n    'application/vnd.aristanetworks.swi': ['swi'],\n    'application/vnd.astraea-software.iota': ['iota'],\n    'application/vnd.audiograph': ['aep'],\n    'application/vnd.balsamiq.bmml+xml': ['bmml'],\n    'application/vnd.blueice.multipass': ['mpm'],\n    'application/vnd.bmi': ['bmi'],\n    'application/vnd.businessobjects': ['rep'],\n    'application/vnd.chemdraw+xml': ['cdxml'],\n    'application/vnd.chipnuts.karaoke-mmd': ['mmd'],\n    'application/vnd.cinderella': ['cdy'],\n    'application/vnd.citationstyles.style+xml': ['csl'],\n    'application/vnd.claymore': ['cla'],\n    'application/vnd.cloanto.rp9': ['rp9'],\n    'application/vnd.clonk.c4group': ['c4g', 'c4d', 'c4f', 'c4p', 'c4u'],\n    'application/vnd.cluetrust.cartomobile-config': ['c11amc'],\n    'application/vnd.cluetrust.cartomobile-config-pkg': ['c11amz'],\n    'application/vnd.commonspace': ['csp'],\n    'application/vnd.contact.cmsg': ['cdbcmsg'],\n    'application/vnd.cosmocaller': ['cmc'],\n    'application/vnd.crick.clicker': ['clkx'],\n    'application/vnd.crick.clicker.keyboard': ['clkk'],\n    'application/vnd.crick.clicker.palette': ['clkp'],\n    'application/vnd.crick.clicker.template': ['clkt'],\n    'application/vnd.crick.clicker.wordbank': ['clkw'],\n    'application/vnd.criticaltools.wbs+xml': ['wbs'],\n    'application/vnd.ctc-posml': ['pml'],\n    'application/vnd.cups-ppd': ['ppd'],\n    'application/vnd.curl.car': ['car'],\n    'application/vnd.curl.pcurl': ['pcurl'],\n    'application/vnd.dart': ['dart'],\n    'application/vnd.data-vision.rdz': ['rdz'],\n    'application/vnd.dbf': ['dbf'],\n    'application/vnd.dece.data': ['uvf', 'uvvf', 'uvd', 'uvvd'],\n    'application/vnd.dece.ttml+xml': ['uvt', 'uvvt'],\n    'application/vnd.dece.unspecified': ['uvx', 'uvvx'],\n    'application/vnd.dece.zip': ['uvz', 'uvvz'],\n    'application/vnd.denovo.fcselayout-link': ['fe_launch'],\n    'application/vnd.dna': ['dna'],\n    'application/vnd.dolby.mlp': ['mlp'],\n    'application/vnd.dpgraph': ['dpg'],\n    'application/vnd.dreamfactory': ['dfac'],\n    'application/vnd.ds-keypoint': ['kpxx'],\n    'application/vnd.dvb.ait': ['ait'],\n    'application/vnd.dvb.service': ['svc'],\n    'application/vnd.dynageo': ['geo'],\n    'application/vnd.ecowin.chart': ['mag'],\n    'application/vnd.enliven': ['nml'],\n    'application/vnd.epson.esf': ['esf'],\n    'application/vnd.epson.msf': ['msf'],\n    'application/vnd.epson.quickanime': ['qam'],\n    'application/vnd.epson.salt': ['slt'],\n    'application/vnd.epson.ssf': ['ssf'],\n    'application/vnd.eszigno3+xml': ['es3', 'et3'],\n    'application/vnd.ezpix-album': ['ez2'],\n    'application/vnd.ezpix-package': ['ez3'],\n    'application/vnd.fdf': ['*fdf'],\n    'application/vnd.fdsn.mseed': ['mseed'],\n    'application/vnd.fdsn.seed': ['seed', 'dataless'],\n    'application/vnd.flographit': ['gph'],\n    'application/vnd.fluxtime.clip': ['ftc'],\n    'application/vnd.framemaker': ['fm', 'frame', 'maker', 'book'],\n    'application/vnd.frogans.fnc': ['fnc'],\n    'application/vnd.frogans.ltf': ['ltf'],\n    'application/vnd.fsc.weblaunch': ['fsc'],\n    'application/vnd.fujitsu.oasys': ['oas'],\n    'application/vnd.fujitsu.oasys2': ['oa2'],\n    'application/vnd.fujitsu.oasys3': ['oa3'],\n    'application/vnd.fujitsu.oasysgp': ['fg5'],\n    'application/vnd.fujitsu.oasysprs': ['bh2'],\n    'application/vnd.fujixerox.ddd': ['ddd'],\n    'application/vnd.fujixerox.docuworks': ['xdw'],\n    'application/vnd.fujixerox.docuworks.binder': ['xbd'],\n    'application/vnd.fuzzysheet': ['fzs'],\n    'application/vnd.genomatix.tuxedo': ['txd'],\n    'application/vnd.geogebra.file': ['ggb'],\n    'application/vnd.geogebra.slides': ['ggs'],\n    'application/vnd.geogebra.tool': ['ggt'],\n    'application/vnd.geometry-explorer': ['gex', 'gre'],\n    'application/vnd.geonext': ['gxt'],\n    'application/vnd.geoplan': ['g2w'],\n    'application/vnd.geospace': ['g3w'],\n    'application/vnd.gmx': ['gmx'],\n    'application/vnd.google-apps.document': ['gdoc'],\n    'application/vnd.google-apps.presentation': ['gslides'],\n    'application/vnd.google-apps.spreadsheet': ['gsheet'],\n    'application/vnd.google-earth.kml+xml': ['kml'],\n    'application/vnd.google-earth.kmz': ['kmz'],\n    'application/vnd.gov.sk.xmldatacontainer+xml': ['xdcf'],\n    'application/vnd.grafeq': ['gqf', 'gqs'],\n    'application/vnd.groove-account': ['gac'],\n    'application/vnd.groove-help': ['ghf'],\n    'application/vnd.groove-identity-message': ['gim'],\n    'application/vnd.groove-injector': ['grv'],\n    'application/vnd.groove-tool-message': ['gtm'],\n    'application/vnd.groove-tool-template': ['tpl'],\n    'application/vnd.groove-vcard': ['vcg'],\n    'application/vnd.hal+xml': ['hal'],\n    'application/vnd.handheld-entertainment+xml': ['zmm'],\n    'application/vnd.hbci': ['hbci'],\n    'application/vnd.hhe.lesson-player': ['les'],\n    'application/vnd.hp-hpgl': ['hpgl'],\n    'application/vnd.hp-hpid': ['hpid'],\n    'application/vnd.hp-hps': ['hps'],\n    'application/vnd.hp-jlyt': ['jlt'],\n    'application/vnd.hp-pcl': ['pcl'],\n    'application/vnd.hp-pclxl': ['pclxl'],\n    'application/vnd.hydrostatix.sof-data': ['sfd-hdstx'],\n    'application/vnd.ibm.minipay': ['mpy'],\n    'application/vnd.ibm.modcap': ['afp', 'listafp', 'list3820'],\n    'application/vnd.ibm.rights-management': ['irm'],\n    'application/vnd.ibm.secure-container': ['sc'],\n    'application/vnd.iccprofile': ['icc', 'icm'],\n    'application/vnd.igloader': ['igl'],\n    'application/vnd.immervision-ivp': ['ivp'],\n    'application/vnd.immervision-ivu': ['ivu'],\n    'application/vnd.insors.igm': ['igm'],\n    'application/vnd.intercon.formnet': ['xpw', 'xpx'],\n    'application/vnd.intergeo': ['i2g'],\n    'application/vnd.intu.qbo': ['qbo'],\n    'application/vnd.intu.qfx': ['qfx'],\n    'application/vnd.ipunplugged.rcprofile': ['rcprofile'],\n    'application/vnd.irepository.package+xml': ['irp'],\n    'application/vnd.is-xpr': ['xpr'],\n    'application/vnd.isac.fcs': ['fcs'],\n    'application/vnd.jam': ['jam'],\n    'application/vnd.jcp.javame.midlet-rms': ['rms'],\n    'application/vnd.jisp': ['jisp'],\n    'application/vnd.joost.joda-archive': ['joda'],\n    'application/vnd.kahootz': ['ktz', 'ktr'],\n    'application/vnd.kde.karbon': ['karbon'],\n    'application/vnd.kde.kchart': ['chrt'],\n    'application/vnd.kde.kformula': ['kfo'],\n    'application/vnd.kde.kivio': ['flw'],\n    'application/vnd.kde.kontour': ['kon'],\n    'application/vnd.kde.kpresenter': ['kpr', 'kpt'],\n    'application/vnd.kde.kspread': ['ksp'],\n    'application/vnd.kde.kword': ['kwd', 'kwt'],\n    'application/vnd.kenameaapp': ['htke'],\n    'application/vnd.kidspiration': ['kia'],\n    'application/vnd.kinar': ['kne', 'knp'],\n    'application/vnd.koan': ['skp', 'skd', 'skt', 'skm'],\n    'application/vnd.kodak-descriptor': ['sse'],\n    'application/vnd.las.las+xml': ['lasxml'],\n    'application/vnd.llamagraphics.life-balance.desktop': ['lbd'],\n    'application/vnd.llamagraphics.life-balance.exchange+xml': ['lbe'],\n    'application/vnd.lotus-1-2-3': ['123'],\n    'application/vnd.lotus-approach': ['apr'],\n    'application/vnd.lotus-freelance': ['pre'],\n    'application/vnd.lotus-notes': ['nsf'],\n    'application/vnd.lotus-organizer': ['org'],\n    'application/vnd.lotus-screencam': ['scm'],\n    'application/vnd.lotus-wordpro': ['lwp'],\n    'application/vnd.macports.portpkg': ['portpkg'],\n    'application/vnd.mapbox-vector-tile': ['mvt'],\n    'application/vnd.mcd': ['mcd'],\n    'application/vnd.medcalcdata': ['mc1'],\n    'application/vnd.mediastation.cdkey': ['cdkey'],\n    'application/vnd.mfer': ['mwf'],\n    'application/vnd.mfmp': ['mfm'],\n    'application/vnd.micrografx.flo': ['flo'],\n    'application/vnd.micrografx.igx': ['igx'],\n    'application/vnd.mif': ['mif'],\n    'application/vnd.mobius.daf': ['daf'],\n    'application/vnd.mobius.dis': ['dis'],\n    'application/vnd.mobius.mbk': ['mbk'],\n    'application/vnd.mobius.mqy': ['mqy'],\n    'application/vnd.mobius.msl': ['msl'],\n    'application/vnd.mobius.plc': ['plc'],\n    'application/vnd.mobius.txf': ['txf'],\n    'application/vnd.mophun.application': ['mpn'],\n    'application/vnd.mophun.certificate': ['mpc'],\n    'application/vnd.mozilla.xul+xml': ['xul'],\n    'application/vnd.ms-artgalry': ['cil'],\n    'application/vnd.ms-cab-compressed': ['cab'],\n    'application/vnd.ms-excel': ['xls', 'xlm', 'xla', 'xlc', 'xlt', 'xlw'],\n    'application/vnd.ms-excel.addin.macroenabled.12': ['xlam'],\n    'application/vnd.ms-excel.sheet.binary.macroenabled.12': ['xlsb'],\n    'application/vnd.ms-excel.sheet.macroenabled.12': ['xlsm'],\n    'application/vnd.ms-excel.template.macroenabled.12': ['xltm'],\n    'application/vnd.ms-fontobject': ['eot'],\n    'application/vnd.ms-htmlhelp': ['chm'],\n    'application/vnd.ms-ims': ['ims'],\n    'application/vnd.ms-lrm': ['lrm'],\n    'application/vnd.ms-officetheme': ['thmx'],\n    'application/vnd.ms-outlook': ['msg'],\n    'application/vnd.ms-pki.seccat': ['cat'],\n    'application/vnd.ms-pki.stl': ['*stl'],\n    'application/vnd.ms-powerpoint': ['ppt', 'pps', 'pot'],\n    'application/vnd.ms-powerpoint.addin.macroenabled.12': ['ppam'],\n    'application/vnd.ms-powerpoint.presentation.macroenabled.12': ['pptm'],\n    'application/vnd.ms-powerpoint.slide.macroenabled.12': ['sldm'],\n    'application/vnd.ms-powerpoint.slideshow.macroenabled.12': ['ppsm'],\n    'application/vnd.ms-powerpoint.template.macroenabled.12': ['potm'],\n    'application/vnd.ms-project': ['*mpp', 'mpt'],\n    'application/vnd.ms-word.document.macroenabled.12': ['docm'],\n    'application/vnd.ms-word.template.macroenabled.12': ['dotm'],\n    'application/vnd.ms-works': ['wps', 'wks', 'wcm', 'wdb'],\n    'application/vnd.ms-wpl': ['wpl'],\n    'application/vnd.ms-xpsdocument': ['xps'],\n    'application/vnd.mseq': ['mseq'],\n    'application/vnd.musician': ['mus'],\n    'application/vnd.muvee.style': ['msty'],\n    'application/vnd.mynfc': ['taglet'],\n    'application/vnd.nato.bindingdataobject+xml': ['bdo'],\n    'application/vnd.neurolanguage.nlu': ['nlu'],\n    'application/vnd.nitf': ['ntf', 'nitf'],\n    'application/vnd.noblenet-directory': ['nnd'],\n    'application/vnd.noblenet-sealer': ['nns'],\n    'application/vnd.noblenet-web': ['nnw'],\n    'application/vnd.nokia.n-gage.ac+xml': ['*ac'],\n    'application/vnd.nokia.n-gage.data': ['ngdat'],\n    'application/vnd.nokia.n-gage.symbian.install': ['n-gage'],\n    'application/vnd.nokia.radio-preset': ['rpst'],\n    'application/vnd.nokia.radio-presets': ['rpss'],\n    'application/vnd.novadigm.edm': ['edm'],\n    'application/vnd.novadigm.edx': ['edx'],\n    'application/vnd.novadigm.ext': ['ext'],\n    'application/vnd.oasis.opendocument.chart': ['odc'],\n    'application/vnd.oasis.opendocument.chart-template': ['otc'],\n    'application/vnd.oasis.opendocument.database': ['odb'],\n    'application/vnd.oasis.opendocument.formula': ['odf'],\n    'application/vnd.oasis.opendocument.formula-template': ['odft'],\n    'application/vnd.oasis.opendocument.graphics': ['odg'],\n    'application/vnd.oasis.opendocument.graphics-template': ['otg'],\n    'application/vnd.oasis.opendocument.image': ['odi'],\n    'application/vnd.oasis.opendocument.image-template': ['oti'],\n    'application/vnd.oasis.opendocument.presentation': ['odp'],\n    'application/vnd.oasis.opendocument.presentation-template': ['otp'],\n    'application/vnd.oasis.opendocument.spreadsheet': ['ods'],\n    'application/vnd.oasis.opendocument.spreadsheet-template': ['ots'],\n    'application/vnd.oasis.opendocument.text': ['odt'],\n    'application/vnd.oasis.opendocument.text-master': ['odm'],\n    'application/vnd.oasis.opendocument.text-template': ['ott'],\n    'application/vnd.oasis.opendocument.text-web': ['oth'],\n    'application/vnd.olpc-sugar': ['xo'],\n    'application/vnd.oma.dd2+xml': ['dd2'],\n    'application/vnd.openblox.game+xml': ['obgx'],\n    'application/vnd.openofficeorg.extension': ['oxt'],\n    'application/vnd.openstreetmap.data+xml': ['osm'],\n    'application/vnd.openxmlformats-officedocument.presentationml.presentation': [\n        'pptx',\n    ],\n    'application/vnd.openxmlformats-officedocument.presentationml.slide': [\n        'sldx',\n    ],\n    'application/vnd.openxmlformats-officedocument.presentationml.slideshow': [\n        'ppsx',\n    ],\n    'application/vnd.openxmlformats-officedocument.presentationml.template': [\n        'potx',\n    ],\n    'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet': ['xlsx'],\n    'application/vnd.openxmlformats-officedocument.spreadsheetml.template': [\n        'xltx',\n    ],\n    'application/vnd.openxmlformats-officedocument.wordprocessingml.document': [\n        'docx',\n    ],\n    'application/vnd.openxmlformats-officedocument.wordprocessingml.template': [\n        'dotx',\n    ],\n    'application/vnd.osgeo.mapguide.package': ['mgp'],\n    'application/vnd.osgi.dp': ['dp'],\n    'application/vnd.osgi.subsystem': ['esa'],\n    'application/vnd.palm': ['pdb', 'pqa', 'oprc'],\n    'application/vnd.pawaafile': ['paw'],\n    'application/vnd.pg.format': ['str'],\n    'application/vnd.pg.osasli': ['ei6'],\n    'application/vnd.picsel': ['efif'],\n    'application/vnd.pmi.widget': ['wg'],\n    'application/vnd.pocketlearn': ['plf'],\n    'application/vnd.powerbuilder6': ['pbd'],\n    'application/vnd.previewsystems.box': ['box'],\n    'application/vnd.proteus.magazine': ['mgz'],\n    'application/vnd.publishare-delta-tree': ['qps'],\n    'application/vnd.pvi.ptid1': ['ptid'],\n    'application/vnd.pwg-xhtml-print+xml': ['xhtm'],\n    'application/vnd.quark.quarkxpress': [\n        'qxd',\n        'qxt',\n        'qwd',\n        'qwt',\n        'qxl',\n        'qxb',\n    ],\n    'application/vnd.rar': ['rar'],\n    'application/vnd.realvnc.bed': ['bed'],\n    'application/vnd.recordare.musicxml': ['mxl'],\n    'application/vnd.recordare.musicxml+xml': ['musicxml'],\n    'application/vnd.rig.cryptonote': ['cryptonote'],\n    'application/vnd.rim.cod': ['cod'],\n    'application/vnd.rn-realmedia': ['rm'],\n    'application/vnd.rn-realmedia-vbr': ['rmvb'],\n    'application/vnd.route66.link66+xml': ['link66'],\n    'application/vnd.sailingtracker.track': ['st'],\n    'application/vnd.seemail': ['see'],\n    'application/vnd.sema': ['sema'],\n    'application/vnd.semd': ['semd'],\n    'application/vnd.semf': ['semf'],\n    'application/vnd.shana.informed.formdata': ['ifm'],\n    'application/vnd.shana.informed.formtemplate': ['itp'],\n    'application/vnd.shana.informed.interchange': ['iif'],\n    'application/vnd.shana.informed.package': ['ipk'],\n    'application/vnd.simtech-mindmapper': ['twd', 'twds'],\n    'application/vnd.smaf': ['mmf'],\n    'application/vnd.smart.teacher': ['teacher'],\n    'application/vnd.software602.filler.form+xml': ['fo'],\n    'application/vnd.solent.sdkm+xml': ['sdkm', 'sdkd'],\n    'application/vnd.spotfire.dxp': ['dxp'],\n    'application/vnd.spotfire.sfs': ['sfs'],\n    'application/vnd.stardivision.calc': ['sdc'],\n    'application/vnd.stardivision.draw': ['sda'],\n    'application/vnd.stardivision.impress': ['sdd'],\n    'application/vnd.stardivision.math': ['smf'],\n    'application/vnd.stardivision.writer': ['sdw', 'vor'],\n    'application/vnd.stardivision.writer-global': ['sgl'],\n    'application/vnd.stepmania.package': ['smzip'],\n    'application/vnd.stepmania.stepchart': ['sm'],\n    'application/vnd.sun.wadl+xml': ['wadl'],\n    'application/vnd.sun.xml.calc': ['sxc'],\n    'application/vnd.sun.xml.calc.template': ['stc'],\n    'application/vnd.sun.xml.draw': ['sxd'],\n    'application/vnd.sun.xml.draw.template': ['std'],\n    'application/vnd.sun.xml.impress': ['sxi'],\n    'application/vnd.sun.xml.impress.template': ['sti'],\n    'application/vnd.sun.xml.math': ['sxm'],\n    'application/vnd.sun.xml.writer': ['sxw'],\n    'application/vnd.sun.xml.writer.global': ['sxg'],\n    'application/vnd.sun.xml.writer.template': ['stw'],\n    'application/vnd.sus-calendar': ['sus', 'susp'],\n    'application/vnd.svd': ['svd'],\n    'application/vnd.symbian.install': ['sis', 'sisx'],\n    'application/vnd.syncml+xml': ['xsm'],\n    'application/vnd.syncml.dm+wbxml': ['bdm'],\n    'application/vnd.syncml.dm+xml': ['xdm'],\n    'application/vnd.syncml.dmddf+xml': ['ddf'],\n    'application/vnd.tao.intent-module-archive': ['tao'],\n    'application/vnd.tcpdump.pcap': ['pcap', 'cap', 'dmp'],\n    'application/vnd.tmobile-livetv': ['tmo'],\n    'application/vnd.trid.tpt': ['tpt'],\n    'application/vnd.triscape.mxs': ['mxs'],\n    'application/vnd.trueapp': ['tra'],\n    'application/vnd.ufdl': ['ufd', 'ufdl'],\n    'application/vnd.uiq.theme': ['utz'],\n    'application/vnd.umajin': ['umj'],\n    'application/vnd.unity': ['unityweb'],\n    'application/vnd.uoml+xml': ['uoml', 'uo'],\n    'application/vnd.vcx': ['vcx'],\n    'application/vnd.visio': ['vsd', 'vst', 'vss', 'vsw'],\n    'application/vnd.visionary': ['vis'],\n    'application/vnd.vsf': ['vsf'],\n    'application/vnd.wap.wbxml': ['wbxml'],\n    'application/vnd.wap.wmlc': ['wmlc'],\n    'application/vnd.wap.wmlscriptc': ['wmlsc'],\n    'application/vnd.webturbo': ['wtb'],\n    'application/vnd.wolfram.player': ['nbp'],\n    'application/vnd.wordperfect': ['wpd'],\n    'application/vnd.wqd': ['wqd'],\n    'application/vnd.wt.stf': ['stf'],\n    'application/vnd.xara': ['xar'],\n    'application/vnd.xfdl': ['xfdl'],\n    'application/vnd.yamaha.hv-dic': ['hvd'],\n    'application/vnd.yamaha.hv-script': ['hvs'],\n    'application/vnd.yamaha.hv-voice': ['hvp'],\n    'application/vnd.yamaha.openscoreformat': ['osf'],\n    'application/vnd.yamaha.openscoreformat.osfpvg+xml': ['osfpvg'],\n    'application/vnd.yamaha.smaf-audio': ['saf'],\n    'application/vnd.yamaha.smaf-phrase': ['spf'],\n    'application/vnd.yellowriver-custom-menu': ['cmp'],\n    'application/vnd.zul': ['zir', 'zirz'],\n    'application/vnd.zzazz.deck+xml': ['zaz'],\n    'application/x-7z-compressed': ['7z'],\n    'application/x-abiword': ['abw'],\n    'application/x-ace-compressed': ['ace'],\n    'application/x-apple-diskimage': ['*dmg'],\n    'application/x-arj': ['arj'],\n    'application/x-authorware-bin': ['aab', 'x32', 'u32', 'vox'],\n    'application/x-authorware-map': ['aam'],\n    'application/x-authorware-seg': ['aas'],\n    'application/x-bcpio': ['bcpio'],\n    'application/x-bdoc': ['*bdoc'],\n    'application/x-bittorrent': ['torrent'],\n    'application/x-blorb': ['blb', 'blorb'],\n    'application/x-bzip': ['bz'],\n    'application/x-bzip2': ['bz2', 'boz'],\n    'application/x-cbr': ['cbr', 'cba', 'cbt', 'cbz', 'cb7'],\n    'application/x-cdlink': ['vcd'],\n    'application/x-cfs-compressed': ['cfs'],\n    'application/x-chat': ['chat'],\n    'application/x-chess-pgn': ['pgn'],\n    'application/x-chrome-extension': ['crx'],\n    'application/x-cocoa': ['cco'],\n    'application/x-conference': ['nsc'],\n    'application/x-cpio': ['cpio'],\n    'application/x-csh': ['csh'],\n    'application/x-debian-package': ['*deb', 'udeb'],\n    'application/x-dgc-compressed': ['dgc'],\n    'application/x-director': [\n        'dir',\n        'dcr',\n        'dxr',\n        'cst',\n        'cct',\n        'cxt',\n        'w3d',\n        'fgd',\n        'swa',\n    ],\n    'application/x-doom': ['wad'],\n    'application/x-dtbncx+xml': ['ncx'],\n    'application/x-dtbook+xml': ['dtb'],\n    'application/x-dtbresource+xml': ['res'],\n    'application/x-dvi': ['dvi'],\n    'application/x-envoy': ['evy'],\n    'application/x-eva': ['eva'],\n    'application/x-font-bdf': ['bdf'],\n    'application/x-font-ghostscript': ['gsf'],\n    'application/x-font-linux-psf': ['psf'],\n    'application/x-font-pcf': ['pcf'],\n    'application/x-font-snf': ['snf'],\n    'application/x-font-type1': ['pfa', 'pfb', 'pfm', 'afm'],\n    'application/x-freearc': ['arc'],\n    'application/x-futuresplash': ['spl'],\n    'application/x-gca-compressed': ['gca'],\n    'application/x-glulx': ['ulx'],\n    'application/x-gnumeric': ['gnumeric'],\n    'application/x-gramps-xml': ['gramps'],\n    'application/x-gtar': ['gtar'],\n    'application/x-hdf': ['hdf'],\n    'application/x-httpd-php': ['php'],\n    'application/x-install-instructions': ['install'],\n    'application/x-iso9660-image': ['*iso'],\n    'application/x-iwork-keynote-sffkey': ['*key'],\n    'application/x-iwork-numbers-sffnumbers': ['*numbers'],\n    'application/x-iwork-pages-sffpages': ['*pages'],\n    'application/x-java-archive-diff': ['jardiff'],\n    'application/x-java-jnlp-file': ['jnlp'],\n    'application/x-keepass2': ['kdbx'],\n    'application/x-latex': ['latex'],\n    'application/x-lua-bytecode': ['luac'],\n    'application/x-lzh-compressed': ['lzh', 'lha'],\n    'application/x-makeself': ['run'],\n    'application/x-mie': ['mie'],\n    'application/x-mobipocket-ebook': ['*prc', 'mobi'],\n    'application/x-ms-application': ['application'],\n    'application/x-ms-shortcut': ['lnk'],\n    'application/x-ms-wmd': ['wmd'],\n    'application/x-ms-wmz': ['wmz'],\n    'application/x-ms-xbap': ['xbap'],\n    'application/x-msaccess': ['mdb'],\n    'application/x-msbinder': ['obd'],\n    'application/x-mscardfile': ['crd'],\n    'application/x-msclip': ['clp'],\n    'application/x-msdos-program': ['*exe'],\n    'application/x-msdownload': ['*exe', '*dll', 'com', 'bat', '*msi'],\n    'application/x-msmediaview': ['mvb', 'm13', 'm14'],\n    'application/x-msmetafile': ['*wmf', '*wmz', '*emf', 'emz'],\n    'application/x-msmoney': ['mny'],\n    'application/x-mspublisher': ['pub'],\n    'application/x-msschedule': ['scd'],\n    'application/x-msterminal': ['trm'],\n    'application/x-mswrite': ['wri'],\n    'application/x-netcdf': ['nc', 'cdf'],\n    'application/x-ns-proxy-autoconfig': ['pac'],\n    'application/x-nzb': ['nzb'],\n    'application/x-perl': ['pl', 'pm'],\n    'application/x-pilot': ['*prc', '*pdb'],\n    'application/x-pkcs12': ['p12', 'pfx'],\n    'application/x-pkcs7-certificates': ['p7b', 'spc'],\n    'application/x-pkcs7-certreqresp': ['p7r'],\n    'application/x-rar-compressed': ['*rar'],\n    'application/x-redhat-package-manager': ['rpm'],\n    'application/x-research-info-systems': ['ris'],\n    'application/x-sea': ['sea'],\n    'application/x-sh': ['sh'],\n    'application/x-shar': ['shar'],\n    'application/x-shockwave-flash': ['swf'],\n    'application/x-silverlight-app': ['xap'],\n    'application/x-sql': ['*sql'],\n    'application/x-stuffit': ['sit'],\n    'application/x-stuffitx': ['sitx'],\n    'application/x-subrip': ['srt'],\n    'application/x-sv4cpio': ['sv4cpio'],\n    'application/x-sv4crc': ['sv4crc'],\n    'application/x-t3vm-image': ['t3'],\n    'application/x-tads': ['gam'],\n    'application/x-tar': ['tar'],\n    'application/x-tcl': ['tcl', 'tk'],\n    'application/x-tex': ['tex'],\n    'application/x-tex-tfm': ['tfm'],\n    'application/x-texinfo': ['texinfo', 'texi'],\n    'application/x-tgif': ['*obj'],\n    'application/x-ustar': ['ustar'],\n    'application/x-virtualbox-hdd': ['hdd'],\n    'application/x-virtualbox-ova': ['ova'],\n    'application/x-virtualbox-ovf': ['ovf'],\n    'application/x-virtualbox-vbox': ['vbox'],\n    'application/x-virtualbox-vbox-extpack': ['vbox-extpack'],\n    'application/x-virtualbox-vdi': ['vdi'],\n    'application/x-virtualbox-vhd': ['vhd'],\n    'application/x-virtualbox-vmdk': ['vmdk'],\n    'application/x-wais-source': ['src'],\n    'application/x-web-app-manifest+json': ['webapp'],\n    'application/x-x509-ca-cert': ['der', 'crt', 'pem'],\n    'application/x-xfig': ['fig'],\n    'application/x-xliff+xml': ['*xlf'],\n    'application/x-xpinstall': ['xpi'],\n    'application/x-xz': ['xz'],\n    'application/x-zmachine': ['z1', 'z2', 'z3', 'z4', 'z5', 'z6', 'z7', 'z8'],\n    'audio/vnd.dece.audio': ['uva', 'uvva'],\n    'audio/vnd.digital-winds': ['eol'],\n    'audio/vnd.dra': ['dra'],\n    'audio/vnd.dts': ['dts'],\n    'audio/vnd.dts.hd': ['dtshd'],\n    'audio/vnd.lucent.voice': ['lvp'],\n    'audio/vnd.ms-playready.media.pya': ['pya'],\n    'audio/vnd.nuera.ecelp4800': ['ecelp4800'],\n    'audio/vnd.nuera.ecelp7470': ['ecelp7470'],\n    'audio/vnd.nuera.ecelp9600': ['ecelp9600'],\n    'audio/vnd.rip': ['rip'],\n    'audio/x-aac': ['*aac'],\n    'audio/x-aiff': ['aif', 'aiff', 'aifc'],\n    'audio/x-caf': ['caf'],\n    'audio/x-flac': ['flac'],\n    'audio/x-m4a': ['*m4a'],\n    'audio/x-matroska': ['mka'],\n    'audio/x-mpegurl': ['m3u'],\n    'audio/x-ms-wax': ['wax'],\n    'audio/x-ms-wma': ['wma'],\n    'audio/x-pn-realaudio': ['ram', 'ra'],\n    'audio/x-pn-realaudio-plugin': ['rmp'],\n    'audio/x-realaudio': ['*ra'],\n    'audio/x-wav': ['*wav'],\n    'chemical/x-cdx': ['cdx'],\n    'chemical/x-cif': ['cif'],\n    'chemical/x-cmdf': ['cmdf'],\n    'chemical/x-cml': ['cml'],\n    'chemical/x-csml': ['csml'],\n    'chemical/x-xyz': ['xyz'],\n    'image/prs.btif': ['btif', 'btf'],\n    'image/prs.pti': ['pti'],\n    'image/vnd.adobe.photoshop': ['psd'],\n    'image/vnd.airzip.accelerator.azv': ['azv'],\n    'image/vnd.dece.graphic': ['uvi', 'uvvi', 'uvg', 'uvvg'],\n    'image/vnd.djvu': ['djvu', 'djv'],\n    'image/vnd.dvb.subtitle': ['*sub'],\n    'image/vnd.dwg': ['dwg'],\n    'image/vnd.dxf': ['dxf'],\n    'image/vnd.fastbidsheet': ['fbs'],\n    'image/vnd.fpx': ['fpx'],\n    'image/vnd.fst': ['fst'],\n    'image/vnd.fujixerox.edmics-mmr': ['mmr'],\n    'image/vnd.fujixerox.edmics-rlc': ['rlc'],\n    'image/vnd.microsoft.icon': ['ico'],\n    'image/vnd.ms-dds': ['dds'],\n    'image/vnd.ms-modi': ['mdi'],\n    'image/vnd.ms-photo': ['wdp'],\n    'image/vnd.net-fpx': ['npx'],\n    'image/vnd.pco.b16': ['b16'],\n    'image/vnd.tencent.tap': ['tap'],\n    'image/vnd.valve.source.texture': ['vtf'],\n    'image/vnd.wap.wbmp': ['wbmp'],\n    'image/vnd.xiff': ['xif'],\n    'image/vnd.zbrush.pcx': ['pcx'],\n    'image/x-3ds': ['3ds'],\n    'image/x-cmu-raster': ['ras'],\n    'image/x-cmx': ['cmx'],\n    'image/x-freehand': ['fh', 'fhc', 'fh4', 'fh5', 'fh7'],\n    'image/x-icon': ['*ico'],\n    'image/x-jng': ['jng'],\n    'image/x-mrsid-image': ['sid'],\n    'image/x-ms-bmp': ['*bmp'],\n    'image/x-pcx': ['*pcx'],\n    'image/x-pict': ['pic', 'pct'],\n    'image/x-portable-anymap': ['pnm'],\n    'image/x-portable-bitmap': ['pbm'],\n    'image/x-portable-graymap': ['pgm'],\n    'image/x-portable-pixmap': ['ppm'],\n    'image/x-rgb': ['rgb'],\n    'image/x-tga': ['tga'],\n    'image/x-xbitmap': ['xbm'],\n    'image/x-xpixmap': ['xpm'],\n    'image/x-xwindowdump': ['xwd'],\n    'message/vnd.wfa.wsc': ['wsc'],\n    'model/vnd.bary': ['bary'],\n    'model/vnd.cld': ['cld'],\n    'model/vnd.collada+xml': ['dae'],\n    'model/vnd.dwf': ['dwf'],\n    'model/vnd.gdl': ['gdl'],\n    'model/vnd.gtw': ['gtw'],\n    'model/vnd.mts': ['*mts'],\n    'model/vnd.opengex': ['ogex'],\n    'model/vnd.parasolid.transmit.binary': ['x_b'],\n    'model/vnd.parasolid.transmit.text': ['x_t'],\n    'model/vnd.pytha.pyox': ['pyo', 'pyox'],\n    'model/vnd.sap.vds': ['vds'],\n    'model/vnd.usda': ['usda'],\n    'model/vnd.usdz+zip': ['usdz'],\n    'model/vnd.valve.source.compiled-map': ['bsp'],\n    'model/vnd.vtu': ['vtu'],\n    'text/prs.lines.tag': ['dsc'],\n    'text/vnd.curl': ['curl'],\n    'text/vnd.curl.dcurl': ['dcurl'],\n    'text/vnd.curl.mcurl': ['mcurl'],\n    'text/vnd.curl.scurl': ['scurl'],\n    'text/vnd.dvb.subtitle': ['sub'],\n    'text/vnd.familysearch.gedcom': ['ged'],\n    'text/vnd.fly': ['fly'],\n    'text/vnd.fmi.flexstor': ['flx'],\n    'text/vnd.graphviz': ['gv'],\n    'text/vnd.in3d.3dml': ['3dml'],\n    'text/vnd.in3d.spot': ['spot'],\n    'text/vnd.sun.j2me.app-descriptor': ['jad'],\n    'text/vnd.wap.wml': ['wml'],\n    'text/vnd.wap.wmlscript': ['wmls'],\n    'text/x-asm': ['s', 'asm'],\n    'text/x-c': ['c', 'cc', 'cxx', 'cpp', 'h', 'hh', 'dic'],\n    'text/x-component': ['htc'],\n    'text/x-fortran': ['f', 'for', 'f77', 'f90'],\n    'text/x-handlebars-template': ['hbs'],\n    'text/x-java-source': ['java'],\n    'text/x-lua': ['lua'],\n    'text/x-markdown': ['mkd'],\n    'text/x-nfo': ['nfo'],\n    'text/x-opml': ['opml'],\n    'text/x-org': ['*org'],\n    'text/x-pascal': ['p', 'pas'],\n    'text/x-processing': ['pde'],\n    'text/x-sass': ['sass'],\n    'text/x-scss': ['scss'],\n    'text/x-setext': ['etx'],\n    'text/x-sfv': ['sfv'],\n    'text/x-suse-ymp': ['ymp'],\n    'text/x-uuencode': ['uu'],\n    'text/x-vcalendar': ['vcs'],\n    'text/x-vcard': ['vcf'],\n    'video/vnd.dece.hd': ['uvh', 'uvvh'],\n    'video/vnd.dece.mobile': ['uvm', 'uvvm'],\n    'video/vnd.dece.pd': ['uvp', 'uvvp'],\n    'video/vnd.dece.sd': ['uvs', 'uvvs'],\n    'video/vnd.dece.video': ['uvv', 'uvvv'],\n    'video/vnd.dvb.file': ['dvb'],\n    'video/vnd.fvt': ['fvt'],\n    'video/vnd.mpegurl': ['mxu', 'm4u'],\n    'video/vnd.ms-playready.media.pyv': ['pyv'],\n    'video/vnd.uvvu.mp4': ['uvu', 'uvvu'],\n    'video/vnd.vivo': ['viv'],\n    'video/x-f4v': ['f4v'],\n    'video/x-fli': ['fli'],\n    'video/x-flv': ['flv'],\n    'video/x-m4v': ['m4v'],\n    'video/x-matroska': ['mkv', 'mk3d', 'mks'],\n    'video/x-mng': ['mng'],\n    'video/x-ms-asf': ['asf', 'asx'],\n    'video/x-ms-vob': ['vob'],\n    'video/x-ms-wm': ['wm'],\n    'video/x-ms-wmv': ['wmv'],\n    'video/x-ms-wmx': ['wmx'],\n    'video/x-ms-wvx': ['wvx'],\n    'video/x-msvideo': ['avi'],\n    'video/x-sgi-movie': ['movie'],\n    'video/x-smv': ['smv'],\n    'x-conference/x-cooltalk': ['ice'],\n};\nObject.freeze(types);\nexport default types;\n","const types = {\n    'application/andrew-inset': ['ez'],\n    'application/appinstaller': ['appinstaller'],\n    'application/applixware': ['aw'],\n    'application/appx': ['appx'],\n    'application/appxbundle': ['appxbundle'],\n    'application/atom+xml': ['atom'],\n    'application/atomcat+xml': ['atomcat'],\n    'application/atomdeleted+xml': ['atomdeleted'],\n    'application/atomsvc+xml': ['atomsvc'],\n    'application/atsc-dwd+xml': ['dwd'],\n    'application/atsc-held+xml': ['held'],\n    'application/atsc-rsat+xml': ['rsat'],\n    'application/automationml-aml+xml': ['aml'],\n    'application/automationml-amlx+zip': ['amlx'],\n    'application/bdoc': ['bdoc'],\n    'application/calendar+xml': ['xcs'],\n    'application/ccxml+xml': ['ccxml'],\n    'application/cdfx+xml': ['cdfx'],\n    'application/cdmi-capability': ['cdmia'],\n    'application/cdmi-container': ['cdmic'],\n    'application/cdmi-domain': ['cdmid'],\n    'application/cdmi-object': ['cdmio'],\n    'application/cdmi-queue': ['cdmiq'],\n    'application/cpl+xml': ['cpl'],\n    'application/cu-seeme': ['cu'],\n    'application/cwl': ['cwl'],\n    'application/dash+xml': ['mpd'],\n    'application/dash-patch+xml': ['mpp'],\n    'application/davmount+xml': ['davmount'],\n    'application/docbook+xml': ['dbk'],\n    'application/dssc+der': ['dssc'],\n    'application/dssc+xml': ['xdssc'],\n    'application/ecmascript': ['ecma'],\n    'application/emma+xml': ['emma'],\n    'application/emotionml+xml': ['emotionml'],\n    'application/epub+zip': ['epub'],\n    'application/exi': ['exi'],\n    'application/express': ['exp'],\n    'application/fdf': ['fdf'],\n    'application/fdt+xml': ['fdt'],\n    'application/font-tdpfr': ['pfr'],\n    'application/geo+json': ['geojson'],\n    'application/gml+xml': ['gml'],\n    'application/gpx+xml': ['gpx'],\n    'application/gxf': ['gxf'],\n    'application/gzip': ['gz'],\n    'application/hjson': ['hjson'],\n    'application/hyperstudio': ['stk'],\n    'application/inkml+xml': ['ink', 'inkml'],\n    'application/ipfix': ['ipfix'],\n    'application/its+xml': ['its'],\n    'application/java-archive': ['jar', 'war', 'ear'],\n    'application/java-serialized-object': ['ser'],\n    'application/java-vm': ['class'],\n    'application/javascript': ['*js'],\n    'application/json': ['json', 'map'],\n    'application/json5': ['json5'],\n    'application/jsonml+json': ['jsonml'],\n    'application/ld+json': ['jsonld'],\n    'application/lgr+xml': ['lgr'],\n    'application/lost+xml': ['lostxml'],\n    'application/mac-binhex40': ['hqx'],\n    'application/mac-compactpro': ['cpt'],\n    'application/mads+xml': ['mads'],\n    'application/manifest+json': ['webmanifest'],\n    'application/marc': ['mrc'],\n    'application/marcxml+xml': ['mrcx'],\n    'application/mathematica': ['ma', 'nb', 'mb'],\n    'application/mathml+xml': ['mathml'],\n    'application/mbox': ['mbox'],\n    'application/media-policy-dataset+xml': ['mpf'],\n    'application/mediaservercontrol+xml': ['mscml'],\n    'application/metalink+xml': ['metalink'],\n    'application/metalink4+xml': ['meta4'],\n    'application/mets+xml': ['mets'],\n    'application/mmt-aei+xml': ['maei'],\n    'application/mmt-usd+xml': ['musd'],\n    'application/mods+xml': ['mods'],\n    'application/mp21': ['m21', 'mp21'],\n    'application/mp4': ['*mp4', '*mpg4', 'mp4s', 'm4p'],\n    'application/msix': ['msix'],\n    'application/msixbundle': ['msixbundle'],\n    'application/msword': ['doc', 'dot'],\n    'application/mxf': ['mxf'],\n    'application/n-quads': ['nq'],\n    'application/n-triples': ['nt'],\n    'application/node': ['cjs'],\n    'application/octet-stream': [\n        'bin',\n        'dms',\n        'lrf',\n        'mar',\n        'so',\n        'dist',\n        'distz',\n        'pkg',\n        'bpk',\n        'dump',\n        'elc',\n        'deploy',\n        'exe',\n        'dll',\n        'deb',\n        'dmg',\n        'iso',\n        'img',\n        'msi',\n        'msp',\n        'msm',\n        'buffer',\n    ],\n    'application/oda': ['oda'],\n    'application/oebps-package+xml': ['opf'],\n    'application/ogg': ['ogx'],\n    'application/omdoc+xml': ['omdoc'],\n    'application/onenote': ['onetoc', 'onetoc2', 'onetmp', 'onepkg'],\n    'application/oxps': ['oxps'],\n    'application/p2p-overlay+xml': ['relo'],\n    'application/patch-ops-error+xml': ['xer'],\n    'application/pdf': ['pdf'],\n    'application/pgp-encrypted': ['pgp'],\n    'application/pgp-keys': ['asc'],\n    'application/pgp-signature': ['sig', '*asc'],\n    'application/pics-rules': ['prf'],\n    'application/pkcs10': ['p10'],\n    'application/pkcs7-mime': ['p7m', 'p7c'],\n    'application/pkcs7-signature': ['p7s'],\n    'application/pkcs8': ['p8'],\n    'application/pkix-attr-cert': ['ac'],\n    'application/pkix-cert': ['cer'],\n    'application/pkix-crl': ['crl'],\n    'application/pkix-pkipath': ['pkipath'],\n    'application/pkixcmp': ['pki'],\n    'application/pls+xml': ['pls'],\n    'application/postscript': ['ai', 'eps', 'ps'],\n    'application/provenance+xml': ['provx'],\n    'application/pskc+xml': ['pskcxml'],\n    'application/raml+yaml': ['raml'],\n    'application/rdf+xml': ['rdf', 'owl'],\n    'application/reginfo+xml': ['rif'],\n    'application/relax-ng-compact-syntax': ['rnc'],\n    'application/resource-lists+xml': ['rl'],\n    'application/resource-lists-diff+xml': ['rld'],\n    'application/rls-services+xml': ['rs'],\n    'application/route-apd+xml': ['rapd'],\n    'application/route-s-tsid+xml': ['sls'],\n    'application/route-usd+xml': ['rusd'],\n    'application/rpki-ghostbusters': ['gbr'],\n    'application/rpki-manifest': ['mft'],\n    'application/rpki-roa': ['roa'],\n    'application/rsd+xml': ['rsd'],\n    'application/rss+xml': ['rss'],\n    'application/rtf': ['rtf'],\n    'application/sbml+xml': ['sbml'],\n    'application/scvp-cv-request': ['scq'],\n    'application/scvp-cv-response': ['scs'],\n    'application/scvp-vp-request': ['spq'],\n    'application/scvp-vp-response': ['spp'],\n    'application/sdp': ['sdp'],\n    'application/senml+xml': ['senmlx'],\n    'application/sensml+xml': ['sensmlx'],\n    'application/set-payment-initiation': ['setpay'],\n    'application/set-registration-initiation': ['setreg'],\n    'application/shf+xml': ['shf'],\n    'application/sieve': ['siv', 'sieve'],\n    'application/smil+xml': ['smi', 'smil'],\n    'application/sparql-query': ['rq'],\n    'application/sparql-results+xml': ['srx'],\n    'application/sql': ['sql'],\n    'application/srgs': ['gram'],\n    'application/srgs+xml': ['grxml'],\n    'application/sru+xml': ['sru'],\n    'application/ssdl+xml': ['ssdl'],\n    'application/ssml+xml': ['ssml'],\n    'application/swid+xml': ['swidtag'],\n    'application/tei+xml': ['tei', 'teicorpus'],\n    'application/thraud+xml': ['tfi'],\n    'application/timestamped-data': ['tsd'],\n    'application/toml': ['toml'],\n    'application/trig': ['trig'],\n    'application/ttml+xml': ['ttml'],\n    'application/ubjson': ['ubj'],\n    'application/urc-ressheet+xml': ['rsheet'],\n    'application/urc-targetdesc+xml': ['td'],\n    'application/voicexml+xml': ['vxml'],\n    'application/wasm': ['wasm'],\n    'application/watcherinfo+xml': ['wif'],\n    'application/widget': ['wgt'],\n    'application/winhlp': ['hlp'],\n    'application/wsdl+xml': ['wsdl'],\n    'application/wspolicy+xml': ['wspolicy'],\n    'application/xaml+xml': ['xaml'],\n    'application/xcap-att+xml': ['xav'],\n    'application/xcap-caps+xml': ['xca'],\n    'application/xcap-diff+xml': ['xdf'],\n    'application/xcap-el+xml': ['xel'],\n    'application/xcap-ns+xml': ['xns'],\n    'application/xenc+xml': ['xenc'],\n    'application/xfdf': ['xfdf'],\n    'application/xhtml+xml': ['xhtml', 'xht'],\n    'application/xliff+xml': ['xlf'],\n    'application/xml': ['xml', 'xsl', 'xsd', 'rng'],\n    'application/xml-dtd': ['dtd'],\n    'application/xop+xml': ['xop'],\n    'application/xproc+xml': ['xpl'],\n    'application/xslt+xml': ['*xsl', 'xslt'],\n    'application/xspf+xml': ['xspf'],\n    'application/xv+xml': ['mxml', 'xhvml', 'xvml', 'xvm'],\n    'application/yang': ['yang'],\n    'application/yin+xml': ['yin'],\n    'application/zip': ['zip'],\n    'audio/3gpp': ['*3gpp'],\n    'audio/aac': ['adts', 'aac'],\n    'audio/adpcm': ['adp'],\n    'audio/amr': ['amr'],\n    'audio/basic': ['au', 'snd'],\n    'audio/midi': ['mid', 'midi', 'kar', 'rmi'],\n    'audio/mobile-xmf': ['mxmf'],\n    'audio/mp3': ['*mp3'],\n    'audio/mp4': ['m4a', 'mp4a'],\n    'audio/mpeg': ['mpga', 'mp2', 'mp2a', 'mp3', 'm2a', 'm3a'],\n    'audio/ogg': ['oga', 'ogg', 'spx', 'opus'],\n    'audio/s3m': ['s3m'],\n    'audio/silk': ['sil'],\n    'audio/wav': ['wav'],\n    'audio/wave': ['*wav'],\n    'audio/webm': ['weba'],\n    'audio/xm': ['xm'],\n    'font/collection': ['ttc'],\n    'font/otf': ['otf'],\n    'font/ttf': ['ttf'],\n    'font/woff': ['woff'],\n    'font/woff2': ['woff2'],\n    'image/aces': ['exr'],\n    'image/apng': ['apng'],\n    'image/avci': ['avci'],\n    'image/avcs': ['avcs'],\n    'image/avif': ['avif'],\n    'image/bmp': ['bmp', 'dib'],\n    'image/cgm': ['cgm'],\n    'image/dicom-rle': ['drle'],\n    'image/dpx': ['dpx'],\n    'image/emf': ['emf'],\n    'image/fits': ['fits'],\n    'image/g3fax': ['g3'],\n    'image/gif': ['gif'],\n    'image/heic': ['heic'],\n    'image/heic-sequence': ['heics'],\n    'image/heif': ['heif'],\n    'image/heif-sequence': ['heifs'],\n    'image/hej2k': ['hej2'],\n    'image/hsj2': ['hsj2'],\n    'image/ief': ['ief'],\n    'image/jls': ['jls'],\n    'image/jp2': ['jp2', 'jpg2'],\n    'image/jpeg': ['jpeg', 'jpg', 'jpe'],\n    'image/jph': ['jph'],\n    'image/jphc': ['jhc'],\n    'image/jpm': ['jpm', 'jpgm'],\n    'image/jpx': ['jpx', 'jpf'],\n    'image/jxl': ['jxl'],\n    'image/jxr': ['jxr'],\n    'image/jxra': ['jxra'],\n    'image/jxrs': ['jxrs'],\n    'image/jxs': ['jxs'],\n    'image/jxsc': ['jxsc'],\n    'image/jxsi': ['jxsi'],\n    'image/jxss': ['jxss'],\n    'image/ktx': ['ktx'],\n    'image/ktx2': ['ktx2'],\n    'image/png': ['png'],\n    'image/sgi': ['sgi'],\n    'image/svg+xml': ['svg', 'svgz'],\n    'image/t38': ['t38'],\n    'image/tiff': ['tif', 'tiff'],\n    'image/tiff-fx': ['tfx'],\n    'image/webp': ['webp'],\n    'image/wmf': ['wmf'],\n    'message/disposition-notification': ['disposition-notification'],\n    'message/global': ['u8msg'],\n    'message/global-delivery-status': ['u8dsn'],\n    'message/global-disposition-notification': ['u8mdn'],\n    'message/global-headers': ['u8hdr'],\n    'message/rfc822': ['eml', 'mime'],\n    'model/3mf': ['3mf'],\n    'model/gltf+json': ['gltf'],\n    'model/gltf-binary': ['glb'],\n    'model/iges': ['igs', 'iges'],\n    'model/jt': ['jt'],\n    'model/mesh': ['msh', 'mesh', 'silo'],\n    'model/mtl': ['mtl'],\n    'model/obj': ['obj'],\n    'model/prc': ['prc'],\n    'model/step+xml': ['stpx'],\n    'model/step+zip': ['stpz'],\n    'model/step-xml+zip': ['stpxz'],\n    'model/stl': ['stl'],\n    'model/u3d': ['u3d'],\n    'model/vrml': ['wrl', 'vrml'],\n    'model/x3d+binary': ['*x3db', 'x3dbz'],\n    'model/x3d+fastinfoset': ['x3db'],\n    'model/x3d+vrml': ['*x3dv', 'x3dvz'],\n    'model/x3d+xml': ['x3d', 'x3dz'],\n    'model/x3d-vrml': ['x3dv'],\n    'text/cache-manifest': ['appcache', 'manifest'],\n    'text/calendar': ['ics', 'ifb'],\n    'text/coffeescript': ['coffee', 'litcoffee'],\n    'text/css': ['css'],\n    'text/csv': ['csv'],\n    'text/html': ['html', 'htm', 'shtml'],\n    'text/jade': ['jade'],\n    'text/javascript': ['js', 'mjs'],\n    'text/jsx': ['jsx'],\n    'text/less': ['less'],\n    'text/markdown': ['md', 'markdown'],\n    'text/mathml': ['mml'],\n    'text/mdx': ['mdx'],\n    'text/n3': ['n3'],\n    'text/plain': ['txt', 'text', 'conf', 'def', 'list', 'log', 'in', 'ini'],\n    'text/richtext': ['rtx'],\n    'text/rtf': ['*rtf'],\n    'text/sgml': ['sgml', 'sgm'],\n    'text/shex': ['shex'],\n    'text/slim': ['slim', 'slm'],\n    'text/spdx': ['spdx'],\n    'text/stylus': ['stylus', 'styl'],\n    'text/tab-separated-values': ['tsv'],\n    'text/troff': ['t', 'tr', 'roff', 'man', 'me', 'ms'],\n    'text/turtle': ['ttl'],\n    'text/uri-list': ['uri', 'uris', 'urls'],\n    'text/vcard': ['vcard'],\n    'text/vtt': ['vtt'],\n    'text/wgsl': ['wgsl'],\n    'text/xml': ['*xml'],\n    'text/yaml': ['yaml', 'yml'],\n    'video/3gpp': ['3gp', '3gpp'],\n    'video/3gpp2': ['3g2'],\n    'video/h261': ['h261'],\n    'video/h263': ['h263'],\n    'video/h264': ['h264'],\n    'video/iso.segment': ['m4s'],\n    'video/jpeg': ['jpgv'],\n    'video/jpm': ['*jpm', '*jpgm'],\n    'video/mj2': ['mj2', 'mjp2'],\n    'video/mp2t': ['ts', 'm2t', 'm2ts', 'mts'],\n    'video/mp4': ['mp4', 'mp4v', 'mpg4'],\n    'video/mpeg': ['mpeg', 'mpg', 'mpe', 'm1v', 'm2v'],\n    'video/ogg': ['ogv'],\n    'video/quicktime': ['qt', 'mov'],\n    'video/webm': ['webm'],\n};\nObject.freeze(types);\nexport default types;\n","var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n};\nvar _Mime_extensionToType, _Mime_typeToExtension, _Mime_typeToExtensions;\nclass Mime {\n    constructor(...args) {\n        _Mime_extensionToType.set(this, new Map());\n        _Mime_typeToExtension.set(this, new Map());\n        _Mime_typeToExtensions.set(this, new Map());\n        for (const arg of args) {\n            this.define(arg);\n        }\n    }\n    define(typeMap, force = false) {\n        for (let [type, extensions] of Object.entries(typeMap)) {\n            type = type.toLowerCase();\n            extensions = extensions.map((ext) => ext.toLowerCase());\n            if (!__classPrivateFieldGet(this, _Mime_typeToExtensions, \"f\").has(type)) {\n                __classPrivateFieldGet(this, _Mime_typeToExtensions, \"f\").set(type, new Set());\n            }\n            const allExtensions = __classPrivateFieldGet(this, _Mime_typeToExtensions, \"f\").get(type);\n            let first = true;\n            for (let extension of extensions) {\n                const starred = extension.startsWith('*');\n                extension = starred ? extension.slice(1) : extension;\n                allExtensions?.add(extension);\n                if (first) {\n                    __classPrivateFieldGet(this, _Mime_typeToExtension, \"f\").set(type, extension);\n                }\n                first = false;\n                if (starred)\n                    continue;\n                const currentType = __classPrivateFieldGet(this, _Mime_extensionToType, \"f\").get(extension);\n                if (currentType && currentType != type && !force) {\n                    throw new Error(`\"${type} -> ${extension}\" conflicts with \"${currentType} -> ${extension}\". Pass \\`force=true\\` to override this definition.`);\n                }\n                __classPrivateFieldGet(this, _Mime_extensionToType, \"f\").set(extension, type);\n            }\n        }\n        return this;\n    }\n    getType(path) {\n        if (typeof path !== 'string')\n            return null;\n        const last = path.replace(/^.*[/\\\\]/, '').toLowerCase();\n        const ext = last.replace(/^.*\\./, '').toLowerCase();\n        const hasPath = last.length < path.length;\n        const hasDot = ext.length < last.length - 1;\n        if (!hasDot && hasPath)\n            return null;\n        return __classPrivateFieldGet(this, _Mime_extensionToType, \"f\").get(ext) ?? null;\n    }\n    getExtension(type) {\n        if (typeof type !== 'string')\n            return null;\n        type = type?.split?.(';')[0];\n        return ((type && __classPrivateFieldGet(this, _Mime_typeToExtension, \"f\").get(type.trim().toLowerCase())) ?? null);\n    }\n    getAllExtensions(type) {\n        if (typeof type !== 'string')\n            return null;\n        return __classPrivateFieldGet(this, _Mime_typeToExtensions, \"f\").get(type.toLowerCase()) ?? null;\n    }\n    _freeze() {\n        this.define = () => {\n            throw new Error('define() not allowed for built-in Mime objects. See https://github.com/broofa/mime/blob/main/README.md#custom-mime-instances');\n        };\n        Object.freeze(this);\n        for (const extensions of __classPrivateFieldGet(this, _Mime_typeToExtensions, \"f\").values()) {\n            Object.freeze(extensions);\n        }\n        return this;\n    }\n    _getTestState() {\n        return {\n            types: __classPrivateFieldGet(this, _Mime_extensionToType, \"f\"),\n            extensions: __classPrivateFieldGet(this, _Mime_typeToExtension, \"f\"),\n        };\n    }\n}\n_Mime_extensionToType = new WeakMap(), _Mime_typeToExtension = new WeakMap(), _Mime_typeToExtensions = new WeakMap();\nexport default Mime;\n","import otherTypes from '../types/other.js';\nimport standardTypes from '../types/standard.js';\nimport Mime from './Mime.js';\nexport { default as Mime } from './Mime.js';\nexport default new Mime(standardTypes, otherTypes)._freeze();\n","// This alphabet uses `A-Za-z0-9_-` symbols.\n// The order of characters is optimized for better gzip and brotli compression.\n// References to the same file (works both for gzip and brotli):\n// `'use`, `andom`, and `rict'`\n// References to the brotli default dictionary:\n// `-26T`, `1983`, `40px`, `75px`, `bush`, `jack`, `mind`, `very`, and `wolf`\nlet urlAlphabet =\n  'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict'\n\nlet customAlphabet = (alphabet, defaultSize = 21) => {\n  return (size = defaultSize) => {\n    let id = ''\n    // A compact alternative for `for (var i = 0; i < step; i++)`.\n    let i = size | 0\n    while (i--) {\n      // `| 0` is more compact and faster than `Math.floor()`.\n      id += alphabet[(Math.random() * alphabet.length) | 0]\n    }\n    return id\n  }\n}\n\nlet nanoid = (size = 21) => {\n  let id = ''\n  // A compact alternative for `for (var i = 0; i < step; i++)`.\n  let i = size | 0\n  while (i--) {\n    // `| 0` is more compact and faster than `Math.floor()`.\n    id += urlAlphabet[(Math.random() * 64) | 0]\n  }\n  return id\n}\n\nmodule.exports = { nanoid, customAlphabet }\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\n\nexport { ErrorResponse, ErrorTimeout } from \"./errors\";\nexport type { INavigator, IFrameWindowParams, IWindow, NavigateParams, NavigateResponse, PopupWindowParams, RedirectParams } from \"./navigators\";\nexport { Log, Logger } from \"./utils\";\nexport type { ILogger, PopupWindowFeatures } from \"./utils\";\nexport type { OidcAddressClaim, OidcStandardClaims, IdTokenClaims, JwtClaims } from \"./Claims\";\n\nexport { AccessTokenEvents } from \"./AccessTokenEvents\";\nexport type { AccessTokenCallback } from \"./AccessTokenEvents\";\nexport { CheckSessionIFrame } from \"./CheckSessionIFrame\";\nexport { InMemoryWebStorage } from \"./InMemoryWebStorage\";\nexport type { AsyncStorage } from \"./AsyncStorage\";\nexport { MetadataService } from \"./MetadataService\";\nexport * from \"./OidcClient\";\nexport { OidcClientSettingsStore } from \"./OidcClientSettings\";\nexport type { OidcClientSettings, SigningKey, ExtraHeader } from \"./OidcClientSettings\";\nexport type { OidcMetadata } from \"./OidcMetadata\";\nexport { SessionMonitor } from \"./SessionMonitor\";\nexport type { SessionStatus } from \"./SessionStatus\";\nexport type { SigninRequest, SigninRequestCreateArgs } from \"./SigninRequest\";\nexport type { RefreshState } from \"./RefreshState\";\nexport { SigninResponse } from \"./SigninResponse\";\nexport { SigninState } from \"./SigninState\";\nexport type { SigninStateArgs, SigninStateCreateArgs } from \"./SigninState\";\nexport type { SignoutRequest, SignoutRequestArgs } from \"./SignoutRequest\";\nexport { SignoutResponse } from \"./SignoutResponse\";\nexport { State } from \"./State\";\nexport type { StateStore } from \"./StateStore\";\nexport { User } from \"./User\";\nexport type { UserProfile } from \"./User\";\nexport * from \"./UserManager\";\nexport type {\n    UserManagerEvents,\n    SilentRenewErrorCallback,\n    UserLoadedCallback,\n    UserSessionChangedCallback,\n    UserSignedInCallback,\n    UserSignedOutCallback,\n    UserUnloadedCallback,\n} from \"./UserManagerEvents\";\nexport { UserManagerSettingsStore } from \"./UserManagerSettings\";\nexport type { UserManagerSettings } from \"./UserManagerSettings\";\nexport { Version } from \"./Version\";\nexport { WebStorageStateStore } from \"./WebStorageStateStore\";\nexport { IndexedDbDPoPStore } from \"./IndexedDbDPoPStore\";\nexport { DPoPState } from \"./DPoPStore\";\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\n\n/**\n * Native interface\n *\n * @public\n */\nexport interface ILogger {\n    debug(...args: unknown[]): void;\n    info(...args: unknown[]): void;\n    warn(...args: unknown[]): void;\n    error(...args: unknown[]): void;\n}\n\nconst nopLogger: ILogger = {\n    debug: () => undefined,\n    info: () => undefined,\n    warn: () => undefined,\n    error: () => undefined,\n};\n\nlet level: number;\nlet logger: ILogger;\n\n/**\n * Log levels\n *\n * @public\n */\nexport enum Log {\n    NONE,\n    ERROR,\n    WARN,\n    INFO,\n    DEBUG\n}\n\n/**\n * Log manager\n *\n * @public\n */\nexport namespace Log { // eslint-disable-line @typescript-eslint/no-namespace\n    export function reset(): void {\n        level = Log.INFO;\n        logger = nopLogger;\n    }\n\n    export function setLevel(value: Log): void {\n        if (!(Log.NONE <= value && value <= Log.DEBUG)) {\n            throw new Error(\"Invalid log level\");\n        }\n        level = value;\n    }\n\n    export function setLogger(value: ILogger): void {\n        logger = value;\n    }\n}\n\n/**\n * Internal logger instance\n *\n * @public\n */\nexport class Logger {\n    private _method?: string;\n    public constructor(private _name: string) {}\n\n    /* eslint-disable @typescript-eslint/no-unsafe-enum-comparison */\n    public debug(...args: unknown[]): void {\n        if (level >= Log.DEBUG) {\n            logger.debug(Logger._format(this._name, this._method), ...args);\n        }\n    }\n    public info(...args: unknown[]): void {\n        if (level >= Log.INFO) {\n            logger.info(Logger._format(this._name, this._method), ...args);\n        }\n    }\n    public warn(...args: unknown[]): void {\n        if (level >= Log.WARN) {\n            logger.warn(Logger._format(this._name, this._method), ...args);\n        }\n    }\n    public error(...args: unknown[]): void {\n        if (level >= Log.ERROR) {\n            logger.error(Logger._format(this._name, this._method), ...args);\n        }\n    }\n    /* eslint-enable @typescript-eslint/no-unsafe-enum-comparison */\n\n    public throw(err: Error): never {\n        this.error(err);\n        throw err;\n    }\n\n    public create(method: string): Logger {\n        const methodLogger: Logger = Object.create(this);\n        methodLogger._method = method;\n        methodLogger.debug(\"begin\");\n        return methodLogger;\n    }\n\n    public static createStatic(name: string, staticMethod: string): Logger {\n        const staticLogger = new Logger(`${name}.${staticMethod}`);\n        staticLogger.debug(\"begin\");\n        return staticLogger;\n    }\n\n    private static _format(name: string, method?: string) {\n        const prefix = `[${name}]`;\n        return method ? `${prefix} ${method}:` : prefix;\n    }\n\n    /* eslint-disable @typescript-eslint/no-unsafe-enum-comparison */\n    // helpers for static class methods\n    public static debug(name: string, ...args: unknown[]): void {\n        if (level >= Log.DEBUG) {\n            logger.debug(Logger._format(name), ...args);\n        }\n    }\n    public static info(name: string, ...args: unknown[]): void {\n        if (level >= Log.INFO) {\n            logger.info(Logger._format(name), ...args);\n        }\n    }\n    public static warn(name: string, ...args: unknown[]): void {\n        if (level >= Log.WARN) {\n            logger.warn(Logger._format(name), ...args);\n        }\n    }\n    public static error(name: string, ...args: unknown[]): void {\n        if (level >= Log.ERROR) {\n            logger.error(Logger._format(name), ...args);\n        }\n    }\n    /* eslint-enable @typescript-eslint/no-unsafe-enum-comparison */\n}\n\nLog.reset();\n","import { jwtDecode } from \"jwt-decode\";\n\nimport { Logger } from \"./Logger\";\nimport type { JwtClaims } from \"../Claims\";\nimport { CryptoUtils } from \"./CryptoUtils\";\n\n/**\n * @internal\n */\nexport class JwtUtils {\n    // IMPORTANT: doesn't validate the token\n    public static decode(token: string): JwtClaims {\n        try {\n            return jwtDecode<JwtClaims>(token);\n        }\n        catch (err) {\n            Logger.error(\"JwtUtils.decode\", err);\n            throw err;\n        }\n    }\n\n    public static async generateSignedJwt(header: object, payload: object, privateKey: CryptoKey) : Promise<string> {\n        const encodedHeader = CryptoUtils.encodeBase64Url(new TextEncoder().encode(JSON.stringify(header)));\n        const encodedPayload = CryptoUtils.encodeBase64Url(new TextEncoder().encode(JSON.stringify(payload)));\n        const encodedToken = `${encodedHeader}.${encodedPayload}`;\n\n        const signature = await window.crypto.subtle.sign(\n            {\n                name: \"ECDSA\",\n                hash: { name: \"SHA-256\" },\n            },\n            privateKey,\n            new TextEncoder().encode(encodedToken),\n        );\n\n        const encodedSignature = CryptoUtils.encodeBase64Url(new Uint8Array(signature));\n        return `${encodedToken}.${encodedSignature}`;\n    }\n}\n","import { Logger } from \"./Logger\";\nimport { JwtUtils } from \"./JwtUtils\";\n\nexport interface GenerateDPoPProofOpts {\n    url: string;\n    accessToken?: string;\n    httpMethod?: string;\n    keyPair: CryptoKeyPair;\n    nonce?: string;\n}\n\nconst UUID_V4_TEMPLATE = \"10000000-1000-4000-8000-100000000000\";\n\nconst toBase64 = (val: ArrayBuffer): string =>\n    btoa([...new Uint8Array(val)]\n        .map((chr) => String.fromCharCode(chr))\n        .join(\"\"));\n\n/**\n * @internal\n */\nexport class CryptoUtils {\n    private static _randomWord(): number {\n        const arr = new Uint32Array(1);\n        crypto.getRandomValues(arr);\n        return arr[0];\n    }\n\n    /**\n     * Generates RFC4122 version 4 guid\n     */\n    public static generateUUIDv4(): string {\n        const uuid = UUID_V4_TEMPLATE.replace(/[018]/g, c =>\n            (+c ^ CryptoUtils._randomWord() & 15 >> +c / 4).toString(16),\n        );\n        return uuid.replace(/-/g, \"\");\n    }\n\n    /**\n     * PKCE: Generate a code verifier\n     */\n    public static generateCodeVerifier(): string {\n        return CryptoUtils.generateUUIDv4() + CryptoUtils.generateUUIDv4() + CryptoUtils.generateUUIDv4();\n    }\n\n    /**\n     * PKCE: Generate a code challenge\n     */\n    public static async generateCodeChallenge(code_verifier: string): Promise<string> {\n        if (!crypto.subtle) {\n            throw new Error(\"Crypto.subtle is available only in secure contexts (HTTPS).\");\n        }\n\n        try {\n            const encoder = new TextEncoder();\n            const data = encoder.encode(code_verifier);\n            const hashed = await crypto.subtle.digest(\"SHA-256\", data);\n            return toBase64(hashed).replace(/\\+/g, \"-\").replace(/\\//g, \"_\").replace(/=+$/, \"\");\n        }\n        catch (err) {\n            Logger.error(\"CryptoUtils.generateCodeChallenge\", err);\n            throw err;\n        }\n    }\n\n    /**\n     * Generates a base64-encoded string for a basic auth header\n     */\n    public static generateBasicAuth(client_id: string, client_secret: string): string {\n        const encoder = new TextEncoder();\n        const data = encoder.encode([client_id, client_secret].join(\":\"));\n        return toBase64(data);\n    }\n\n    /**\n     * Generates a hash of a string using a given algorithm\n     * @param alg\n     * @param message\n     */\n    public static async hash(alg: string, message: string) : Promise<Uint8Array> {\n        const msgUint8 = new TextEncoder().encode(message);\n        const hashBuffer = await crypto.subtle.digest(alg, msgUint8);\n        return new Uint8Array(hashBuffer);\n    }\n\n    /**\n     * Generates a base64url encoded string\n     */\n    public static encodeBase64Url = (input: Uint8Array) => {\n        return toBase64(input).replace(/=/g, \"\").replace(/\\+/g, \"-\").replace(/\\//g, \"_\");\n    };\n\n    /**\n     * Generates a rfc7638 compliant jwk thumbprint\n     * @param jwk\n     */\n    public static async customCalculateJwkThumbprint(jwk: JsonWebKey): Promise<string> {\n        let jsonObject: object;\n        switch (jwk.kty) {\n            case \"RSA\":\n                jsonObject = {\n                    \"e\": jwk.e,\n                    \"kty\": jwk.kty,\n                    \"n\": jwk.n,\n                };\n                break;\n            case \"EC\":\n                jsonObject = {\n                    \"crv\": jwk.crv,\n                    \"kty\": jwk.kty,\n                    \"x\": jwk.x,\n                    \"y\": jwk.y,\n                };\n                break;\n            case \"OKP\":\n                jsonObject = {\n                    \"crv\": jwk.crv,\n                    \"kty\": jwk.kty,\n                    \"x\": jwk.x,\n                };\n                break;\n            case \"oct\":\n                jsonObject = {\n                    \"crv\": jwk.k,\n                    \"kty\": jwk.kty,\n                };\n                break;\n            default:\n                throw new Error(\"Unknown jwk type\");\n        }\n        const utf8encodedAndHashed = await CryptoUtils.hash(\"SHA-256\", JSON.stringify(jsonObject));\n        return CryptoUtils.encodeBase64Url(utf8encodedAndHashed);\n    }\n\n    public static async generateDPoPProof({\n        url,\n        accessToken,\n        httpMethod,\n        keyPair,\n        nonce,\n    }: GenerateDPoPProofOpts): Promise<string> {\n        let hashedToken: Uint8Array;\n        let encodedHash: string;\n\n        const payload: Record<string, string | number> = {\n            \"jti\": window.crypto.randomUUID(),\n            \"htm\": httpMethod ?? \"GET\",\n            \"htu\": url,\n            \"iat\": Math.floor(Date.now() / 1000),\n        };\n\n        if (accessToken) {\n            hashedToken = await CryptoUtils.hash(\"SHA-256\", accessToken);\n            encodedHash = CryptoUtils.encodeBase64Url(hashedToken);\n            payload.ath = encodedHash;\n        }\n\n        if (nonce) {\n            payload.nonce = nonce;\n        }\n\n        try {\n            const publicJwk = await crypto.subtle.exportKey(\"jwk\", keyPair.publicKey);\n            const header = {\n                \"alg\": \"ES256\",\n                \"typ\": \"dpop+jwt\",\n                \"jwk\": {\n                    \"crv\": publicJwk.crv,\n                    \"kty\": publicJwk.kty,\n                    \"x\": publicJwk.x,\n                    \"y\": publicJwk.y,\n                },\n            };\n            return await JwtUtils.generateSignedJwt(header, payload, keyPair.privateKey);\n        } catch (err) {\n            if (err instanceof TypeError) {\n                throw new Error(`Error exporting dpop public key: ${err.message}`);\n            } else {\n                throw err;\n            }\n        }\n    }\n\n    public static async generateDPoPJkt(keyPair: CryptoKeyPair) : Promise<string> {\n        try {\n            const publicJwk = await crypto.subtle.exportKey(\"jwk\", keyPair.publicKey);\n            return await CryptoUtils.customCalculateJwkThumbprint(publicJwk);\n        } catch (err) {\n            if (err instanceof TypeError) {\n                throw new Error(`Could not retrieve dpop keys from storage: ${err.message}`);\n            } else {\n                throw err;\n            }\n        }\n    }\n\n    public static async generateDPoPKeys() : Promise<CryptoKeyPair> {\n        return await window.crypto.subtle.generateKey(\n            {\n                name: \"ECDSA\",\n                namedCurve: \"P-256\",\n            },\n            false,\n            [\"sign\", \"verify\"],\n        );\n    }\n}\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\n\nimport { Logger } from \"./Logger\";\n\n/**\n * @internal\n */\nexport type Callback<EventType extends unknown[]> = (...ev: EventType) => (Promise<void> | void);\n\n/**\n * @internal\n */\nexport class Event<EventType extends unknown[]> {\n    protected readonly _logger: Logger;\n\n    private readonly _callbacks: Array<Callback<EventType>> = [];\n\n    public constructor(protected readonly _name: string) {\n        this._logger = new Logger(`Event('${this._name}')`);\n    }\n\n    public addHandler(cb: Callback<EventType>): () => void {\n        this._callbacks.push(cb);\n        return () => this.removeHandler(cb);\n    }\n\n    public removeHandler(cb: Callback<EventType>): void {\n        const idx = this._callbacks.lastIndexOf(cb);\n        if (idx >= 0) {\n            this._callbacks.splice(idx, 1);\n        }\n    }\n\n    public async raise(...ev: EventType): Promise<void> {\n        this._logger.debug(\"raise:\", ...ev);\n        for (const cb of this._callbacks) {\n            await cb(...ev);\n        }\n    }\n}\n","/**\n *\n * @public\n * @see https://developer.mozilla.org/en-US/docs/Web/API/Window/open#window_features\n */\nexport interface PopupWindowFeatures {\n    left?: number;\n    top?: number;\n    width?: number;\n    height?: number;\n    menubar?: boolean | string;\n    toolbar?: boolean | string;\n    location?: boolean | string;\n    status?: boolean | string;\n    resizable?: boolean | string;\n    scrollbars?: boolean | string;\n    /** Close popup window after time in seconds, by default it is -1. To enable this feature, set value greater than 0. */\n    closePopupWindowAfterInSeconds?: number;\n\n    [k: string]: boolean | string | number | undefined;\n}\n\nexport class PopupUtils {\n    /**\n     * Populates a map of window features with a placement centered in front of\n     * the current window. If no explicit width is given, a default value is\n     * binned into [800, 720, 600, 480, 360] based on the current window's width.\n     */\n    static center({ ...features }: PopupWindowFeatures): PopupWindowFeatures {\n        if (features.width == null)\n            features.width = [800, 720, 600, 480].find(width => width <= window.outerWidth / 1.618) ?? 360;\n        features.left ??= Math.max(0, Math.round(window.screenX + (window.outerWidth - features.width) / 2));\n        if (features.height != null)\n            features.top ??= Math.max(0, Math.round(window.screenY + (window.outerHeight - features.height) / 2));\n        return features;\n    }\n\n    static serialize(features: PopupWindowFeatures): string {\n        return Object.entries(features)\n            .filter(([, value]) => value != null)\n            .map(([key, value]) => `${key}=${typeof value !== \"boolean\" ? value as string : value ? \"yes\" : \"no\"}`)\n            .join(\",\");\n    }\n}\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\n\nimport { Event } from \"./Event\";\nimport { Logger } from \"./Logger\";\n\n/**\n * @internal\n */\nexport class Timer extends Event<[void]> {\n    protected readonly _logger = new Logger(`Timer('${this._name}')`);\n    private _timerHandle: ReturnType<typeof setInterval> | null = null;\n    private _expiration = 0;\n\n    // get the time\n    public static getEpochTime(): number {\n        return Math.floor(Date.now() / 1000);\n    }\n\n    public init(durationInSeconds: number): void {\n        const logger = this._logger.create(\"init\");\n        durationInSeconds = Math.max(Math.floor(durationInSeconds), 1);\n        const expiration = Timer.getEpochTime() + durationInSeconds;\n        if (this.expiration === expiration && this._timerHandle) {\n            // no need to reinitialize to same expiration, so bail out\n            logger.debug(\"skipping since already initialized for expiration at\", this.expiration);\n            return;\n        }\n\n        this.cancel();\n\n        logger.debug(\"using duration\", durationInSeconds);\n        this._expiration = expiration;\n\n        // we're using a fairly short timer and then checking the expiration in the\n        // callback to handle scenarios where the browser device sleeps, and then\n        // the timers end up getting delayed.\n        const timerDurationInSeconds = Math.min(durationInSeconds, 5);\n        this._timerHandle = setInterval(this._callback, timerDurationInSeconds * 1000);\n    }\n\n    public get expiration(): number {\n        return this._expiration;\n    }\n\n    public cancel(): void {\n        this._logger.create(\"cancel\");\n        if (this._timerHandle) {\n            clearInterval(this._timerHandle);\n            this._timerHandle = null;\n        }\n    }\n\n    protected _callback = (): void => {\n        const diff = this._expiration - Timer.getEpochTime();\n        this._logger.debug(\"timer completes in\", diff);\n\n        if (this._expiration <= Timer.getEpochTime()) {\n            this.cancel();\n            void super.raise();\n        }\n    };\n}\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\n\n/**\n * @internal\n */\nexport class UrlUtils {\n    public static readParams(url: string, responseMode: \"query\" | \"fragment\" = \"query\"): URLSearchParams {\n        if (!url) throw new TypeError(\"Invalid URL\");\n        // the base URL is irrelevant, it's just here to support relative url arguments\n        const parsedUrl = new URL(url, \"http://127.0.0.1\");\n        const params = parsedUrl[responseMode === \"fragment\" ? \"hash\" : \"search\"];\n        return new URLSearchParams(params.slice(1));\n    }\n}\n\n/**\n * @internal\n */\nexport const URL_STATE_DELIMITER = \";\";","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\n\nimport { Logger } from \"../utils\";\n\n/**\n * Error class thrown in case of an authentication error.\n *\n * @public\n * @see https://openid.net/specs/openid-connect-core-1_0.html#AuthError\n */\nexport class ErrorResponse extends Error {\n    /** Marker to detect class: \"ErrorResponse\" */\n    public readonly name: string = \"ErrorResponse\";\n\n    /** An error code string that can be used to classify the types of errors that occur and to respond to errors. */\n    public readonly error: string | null;\n    /** additional information that can help a developer identify the cause of the error.*/\n    public readonly error_description: string | null;\n    /**\n     * URI identifying a human-readable web page with information about the error, used to provide the client\n       developer with additional information about the error.\n    */\n    public readonly error_uri: string | null;\n\n    /** custom state data set during the initial signin request */\n    public state?: unknown;\n\n    public readonly session_state: string | null;\n\n    public url_state?: string;\n\n    public constructor(\n        args: {\n            error?: string | null; error_description?: string | null; error_uri?: string | null;\n            userState?: unknown; session_state?: string | null; url_state?: string;\n        },\n        /** The x-www-form-urlencoded request body sent to the authority server */\n        public readonly form?: URLSearchParams,\n    ) {\n        super(args.error_description || args.error || \"\");\n\n        if (!args.error) {\n            Logger.error(\"ErrorResponse\", \"No error passed\");\n            throw new Error(\"No error passed\");\n        }\n\n        this.error = args.error;\n        this.error_description = args.error_description ?? null;\n        this.error_uri = args.error_uri ?? null;\n\n        this.state = args.userState;\n        this.session_state = args.session_state ?? null;\n        this.url_state = args.url_state;\n    }\n}\n","// Copyright (C) 2021 AuthTS Contributors\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\n\n/**\n * Error class thrown in case of network timeouts (e.g IFrame time out).\n *\n * @public\n */\nexport class ErrorTimeout extends Error {\n    /** Marker to detect class: \"ErrorTimeout\" */\n    public readonly name: string = \"ErrorTimeout\";\n\n    public constructor(message?: string) {\n        super(message);\n    }\n}\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\n\nimport { Logger, Timer } from \"./utils\";\nimport type { User } from \"./User\";\n\n/**\n * @public\n */\nexport type AccessTokenCallback = (...ev: unknown[]) => (Promise<void> | void);\n\n/**\n * @public\n */\nexport class AccessTokenEvents {\n    protected readonly _logger = new Logger(\"AccessTokenEvents\");\n\n    private readonly _expiringTimer = new Timer(\"Access token expiring\");\n    private readonly _expiredTimer = new Timer(\"Access token expired\");\n    private readonly _expiringNotificationTimeInSeconds: number;\n\n    public constructor(args: { expiringNotificationTimeInSeconds: number }) {\n        this._expiringNotificationTimeInSeconds = args.expiringNotificationTimeInSeconds;\n    }\n\n    public load(container: User): void {\n        const logger = this._logger.create(\"load\");\n        // only register events if there's an access token and it has an expiration\n        if (container.access_token && container.expires_in !== undefined) {\n            const duration = container.expires_in;\n            logger.debug(\"access token present, remaining duration:\", duration);\n\n            if (duration > 0) {\n                // only register expiring if we still have time\n                let expiring = duration - this._expiringNotificationTimeInSeconds;\n                if (expiring <= 0) {\n                    expiring = 1;\n                }\n\n                logger.debug(\"registering expiring timer, raising in\", expiring, \"seconds\");\n                this._expiringTimer.init(expiring);\n            }\n            else {\n                logger.debug(\"canceling existing expiring timer because we're past expiration.\");\n                this._expiringTimer.cancel();\n            }\n\n            // if it's negative, it will still fire\n            const expired = duration + 1;\n            logger.debug(\"registering expired timer, raising in\", expired, \"seconds\");\n            this._expiredTimer.init(expired);\n        }\n        else {\n            this._expiringTimer.cancel();\n            this._expiredTimer.cancel();\n        }\n    }\n\n    public unload(): void {\n        this._logger.debug(\"unload: canceling existing access token timers\");\n        this._expiringTimer.cancel();\n        this._expiredTimer.cancel();\n    }\n\n    /**\n     * Add callback: Raised prior to the access token expiring.\n     */\n    public addAccessTokenExpiring(cb: AccessTokenCallback): () => void {\n        return this._expiringTimer.addHandler(cb);\n    }\n    /**\n     * Remove callback: Raised prior to the access token expiring.\n     */\n    public removeAccessTokenExpiring(cb: AccessTokenCallback): void {\n        this._expiringTimer.removeHandler(cb);\n    }\n\n    /**\n     * Add callback: Raised after the access token has expired.\n     */\n    public addAccessTokenExpired(cb: AccessTokenCallback): () => void {\n        return this._expiredTimer.addHandler(cb);\n    }\n    /**\n     * Remove callback: Raised after the access token has expired.\n     */\n    public removeAccessTokenExpired(cb: AccessTokenCallback): void {\n        this._expiredTimer.removeHandler(cb);\n    }\n}\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\n\nimport { Logger } from \"./utils\";\n\n/**\n * @internal\n */\nexport class CheckSessionIFrame {\n    private readonly _logger = new Logger(\"CheckSessionIFrame\");\n    private _frame_origin: string;\n    private _frame: HTMLIFrameElement;\n    private _timer: ReturnType<typeof setInterval> | null = null;\n    private _session_state: string | null = null;\n\n    public constructor(\n        private _callback: () => Promise<void>,\n        private _client_id: string,\n        url: string,\n        private _intervalInSeconds: number,\n        private _stopOnError: boolean,\n    ) {\n        const parsedUrl = new URL(url);\n        this._frame_origin = parsedUrl.origin;\n\n        this._frame = window.document.createElement(\"iframe\");\n\n        // shotgun approach\n        this._frame.style.visibility = \"hidden\";\n        this._frame.style.position = \"fixed\";\n        this._frame.style.left = \"-1000px\";\n        this._frame.style.top = \"0\";\n        this._frame.width = \"0\";\n        this._frame.height = \"0\";\n        this._frame.src = parsedUrl.href;\n    }\n\n    public load(): Promise<void> {\n        return new Promise<void>((resolve) => {\n            this._frame.onload = () => {\n                resolve();\n            };\n\n            window.document.body.appendChild(this._frame);\n            window.addEventListener(\"message\", this._message, false);\n        });\n    }\n\n    private _message = (e: MessageEvent<string>): void => {\n        if (e.origin === this._frame_origin &&\n            e.source === this._frame.contentWindow\n        ) {\n            if (e.data === \"error\") {\n                this._logger.error(\"error message from check session op iframe\");\n                if (this._stopOnError) {\n                    this.stop();\n                }\n            }\n            else if (e.data === \"changed\") {\n                this._logger.debug(\"changed message from check session op iframe\");\n                this.stop();\n                void this._callback();\n            }\n            else {\n                this._logger.debug(e.data + \" message from check session op iframe\");\n            }\n        }\n    };\n\n    public start(session_state: string): void {\n        if (this._session_state === session_state) {\n            return;\n        }\n\n        this._logger.create(\"start\");\n\n        this.stop();\n\n        this._session_state = session_state;\n\n        const send = () => {\n            if (!this._frame.contentWindow || !this._session_state) {\n                return;\n            }\n\n            this._frame.contentWindow.postMessage(this._client_id + \" \" + this._session_state, this._frame_origin);\n        };\n\n        // trigger now\n        send();\n\n        // and setup timer\n        this._timer = setInterval(send, this._intervalInSeconds * 1000);\n    }\n\n    public stop(): void {\n        this._logger.create(\"stop\");\n        this._session_state = null;\n\n        if (this._timer) {\n\n            clearInterval(this._timer);\n            this._timer = null;\n        }\n    }\n}\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\n\nimport { Logger } from \"./utils\";\n\n/**\n * @public\n */\nexport class InMemoryWebStorage implements Storage {\n    private readonly _logger = new Logger(\"InMemoryWebStorage\");\n    private _data: Record<string, string> = {};\n\n    public clear(): void {\n        this._logger.create(\"clear\");\n        this._data = {};\n    }\n\n    public getItem(key: string): string {\n        this._logger.create(`getItem('${key}')`);\n        return this._data[key];\n    }\n\n    public setItem(key: string, value: string): void {\n        this._logger.create(`setItem('${key}')`);\n        this._data[key] = value;\n    }\n\n    public removeItem(key: string): void {\n        this._logger.create(`removeItem('${key}')`);\n        delete this._data[key];\n    }\n\n    public get length(): number {\n        return Object.getOwnPropertyNames(this._data).length;\n    }\n\n    public key(index: number): string {\n        return Object.getOwnPropertyNames(this._data)[index];\n    }\n}\n","export class ErrorDPoPNonce extends Error {\n    /** Marker to detect class: \"ErrorDPoPNonce\" */\n    public readonly name: string = \"ErrorDPoPNonce\";\n    public readonly nonce: string;\n\n    public constructor(nonce: string, message?: string) {\n        super(message);\n        this.nonce = nonce;\n    }\n}\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\n\nimport { ErrorResponse, ErrorTimeout } from \"./errors\";\nimport type { ExtraHeader } from \"./OidcClientSettings\";\nimport { Logger } from \"./utils\";\nimport { ErrorDPoPNonce } from \"./errors/ErrorDPoPNonce\";\n\n/**\n * @internal\n */\nexport type JwtHandler = (text: string) => Promise<Record<string, unknown>>;\n\n/**\n * @internal\n */\nexport interface GetJsonOpts {\n    token?: string;\n    credentials?: RequestCredentials;\n    timeoutInSeconds?: number;\n}\n\n/**\n * @internal\n */\nexport interface PostFormOpts {\n    body: URLSearchParams;\n    basicAuth?: string;\n    timeoutInSeconds?: number;\n    initCredentials?: \"same-origin\" | \"include\" | \"omit\";\n    extraHeaders?: Record<string, ExtraHeader>;\n}\n\n/**\n * @internal\n */\nexport class JsonService {\n    private readonly _logger = new Logger(\"JsonService\");\n\n    private _contentTypes: string[] = [];\n\n    public constructor(\n        additionalContentTypes: string[] = [],\n        private _jwtHandler: JwtHandler | null = null,\n        private _extraHeaders: Record<string, ExtraHeader> = {},\n    ) {\n        this._contentTypes.push(...additionalContentTypes, \"application/json\");\n        if (_jwtHandler) {\n            this._contentTypes.push(\"application/jwt\");\n        }\n    }\n\n    protected async fetchWithTimeout(input: RequestInfo, init: RequestInit & { timeoutInSeconds?: number } = {}) {\n        const { timeoutInSeconds, ...initFetch } = init;\n        if (!timeoutInSeconds) {\n            return await fetch(input, initFetch);\n        }\n\n        const controller = new AbortController();\n        const timeoutId = setTimeout(() => controller.abort(), timeoutInSeconds * 1000);\n\n        try {\n            const response = await fetch(input, {\n                ...init,\n                signal: controller.signal,\n            });\n            return response;\n        }\n        catch (err) {\n            if (err instanceof DOMException && err.name === \"AbortError\") {\n                throw new ErrorTimeout(\"Network timed out\");\n            }\n            throw err;\n        }\n        finally {\n            clearTimeout(timeoutId);\n        }\n    }\n\n    public async getJson(url: string, {\n        token,\n        credentials,\n        timeoutInSeconds,\n    }: GetJsonOpts = {}): Promise<Record<string, unknown>> {\n        const logger = this._logger.create(\"getJson\");\n        const headers: HeadersInit = {\n            \"Accept\": this._contentTypes.join(\", \"),\n        };\n        if (token) {\n            logger.debug(\"token passed, setting Authorization header\");\n            headers[\"Authorization\"] = \"Bearer \" + token;\n        }\n\n        this.appendExtraHeaders(headers);\n\n        let response: Response;\n        try {\n            logger.debug(\"url:\", url);\n            response = await this.fetchWithTimeout(url, { method: \"GET\", headers, timeoutInSeconds, credentials });\n        }\n        catch (err) {\n            logger.error(\"Network Error\");\n            throw err;\n        }\n\n        logger.debug(\"HTTP response received, status\", response.status);\n        const contentType = response.headers.get(\"Content-Type\");\n        if (contentType && !this._contentTypes.find(item => contentType.startsWith(item))) {\n            logger.throw(new Error(`Invalid response Content-Type: ${(contentType ?? \"undefined\")}, from URL: ${url}`));\n        }\n        if (response.ok && this._jwtHandler && contentType?.startsWith(\"application/jwt\")) {\n            return await this._jwtHandler(await response.text());\n        }\n        let json: Record<string, unknown>;\n        try {\n            json = await response.json();\n        }\n        catch (err) {\n            logger.error(\"Error parsing JSON response\", err);\n            if (response.ok) throw err;\n            throw new Error(`${response.statusText} (${response.status})`);\n        }\n        if (!response.ok) {\n            logger.error(\"Error from server:\", json);\n            if (json.error) {\n                throw new ErrorResponse(json);\n            }\n            throw new Error(`${response.statusText} (${response.status}): ${JSON.stringify(json)}`);\n        }\n        return json;\n    }\n\n    public async postForm(url: string, {\n        body,\n        basicAuth,\n        timeoutInSeconds,\n        initCredentials,\n        extraHeaders,\n    }: PostFormOpts): Promise<Record<string, unknown>> {\n        const logger = this._logger.create(\"postForm\");\n        const headers: HeadersInit = {\n            \"Accept\": this._contentTypes.join(\", \"),\n            \"Content-Type\": \"application/x-www-form-urlencoded\",\n            ...extraHeaders,\n        };\n        if (basicAuth !== undefined) {\n            headers[\"Authorization\"] = \"Basic \" + basicAuth;\n        }\n\n        this.appendExtraHeaders(headers);\n\n        let response: Response;\n        try {\n            logger.debug(\"url:\", url);\n            response = await this.fetchWithTimeout(url, { method: \"POST\", headers, body, timeoutInSeconds, credentials: initCredentials });\n        }\n        catch (err) {\n            logger.error(\"Network error\");\n            throw err;\n        }\n\n        logger.debug(\"HTTP response received, status\", response.status);\n        const contentType = response.headers.get(\"Content-Type\");\n        if (contentType && !this._contentTypes.find(item => contentType.startsWith(item))) {\n            throw new Error(`Invalid response Content-Type: ${(contentType ?? \"undefined\")}, from URL: ${url}`);\n        }\n\n        const responseText = await response.text();\n\n        let json: Record<string, unknown> = {};\n        if (responseText) {\n            try {\n                json = JSON.parse(responseText);\n            }\n            catch (err) {\n                logger.error(\"Error parsing JSON response\", err);\n                if (response.ok) throw err;\n                throw new Error(`${response.statusText} (${response.status})`);\n            }\n        }\n\n        if (!response.ok) {\n            logger.error(\"Error from server:\", json);\n            if (response.headers.has(\"dpop-nonce\")) {\n                const nonce = response.headers.get(\"dpop-nonce\") as string;\n                throw new ErrorDPoPNonce(nonce, `${JSON.stringify(json)}`);\n            }\n            if (json.error) {\n                throw new ErrorResponse(json, body);\n            }\n            throw new Error(`${response.statusText} (${response.status}): ${JSON.stringify(json)}`);\n        }\n\n        return json;\n    }\n\n    private appendExtraHeaders(\n        headers: Record<string, string>,\n    ): void {\n        const logger = this._logger.create(\"appendExtraHeaders\");\n        const customKeys = Object.keys(this._extraHeaders);\n        const protectedHeaders = [\n            \"authorization\",\n            \"accept\",\n            \"content-type\",\n        ];\n        if (customKeys.length === 0) {\n            return;\n        }\n        customKeys.forEach((headerName) => {\n            if (protectedHeaders.includes(headerName.toLocaleLowerCase())) {\n                logger.warn(\"Protected header could not be overridden\", headerName, protectedHeaders);\n                return;\n            }\n            const content = (typeof this._extraHeaders[headerName] === \"function\") ?\n                (this._extraHeaders[headerName] as ()=>string)() :\n                this._extraHeaders[headerName];\n            if (content && content !== \"\") {\n                headers[headerName] = content as string;\n            }\n        });\n    }\n}\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\n\nimport { Logger } from \"./utils\";\nimport { JsonService } from \"./JsonService\";\nimport type { OidcClientSettingsStore, SigningKey } from \"./OidcClientSettings\";\nimport type { OidcMetadata } from \"./OidcMetadata\";\n\n/**\n * @public\n * @see https://openid.net/specs/openid-connect-discovery-1_0.html#ProviderMetadata\n */\nexport class MetadataService {\n    private readonly _logger = new Logger(\"MetadataService\");\n    private readonly _jsonService;\n\n    // cache\n    private _metadataUrl: string;\n    private _signingKeys: SigningKey[] | null = null;\n    private _metadata: Partial<OidcMetadata> | null = null;\n    private _fetchRequestCredentials: RequestCredentials | undefined;\n\n    public constructor(private readonly _settings: OidcClientSettingsStore) {\n        this._metadataUrl = this._settings.metadataUrl;\n        this._jsonService = new JsonService(\n            [\"application/jwk-set+json\"],\n            null,\n            this._settings.extraHeaders,\n        );\n        if (this._settings.signingKeys) {\n            this._logger.debug(\"using signingKeys from settings\");\n            this._signingKeys = this._settings.signingKeys;\n        }\n\n        if (this._settings.metadata) {\n            this._logger.debug(\"using metadata from settings\");\n            this._metadata = this._settings.metadata;\n        }\n\n        if (this._settings.fetchRequestCredentials) {\n            this._logger.debug(\"using fetchRequestCredentials from settings\");\n            this._fetchRequestCredentials = this._settings.fetchRequestCredentials;\n        }\n    }\n\n    public resetSigningKeys(): void {\n        this._signingKeys = null;\n    }\n\n    public async getMetadata(): Promise<Partial<OidcMetadata>> {\n        const logger = this._logger.create(\"getMetadata\");\n        if (this._metadata) {\n            logger.debug(\"using cached values\");\n            return this._metadata;\n        }\n\n        if (!this._metadataUrl) {\n            logger.throw(new Error(\"No authority or metadataUrl configured on settings\"));\n            throw null;\n        }\n\n        logger.debug(\"getting metadata from\", this._metadataUrl);\n        const metadata = await this._jsonService.getJson(this._metadataUrl, { credentials: this._fetchRequestCredentials, timeoutInSeconds: this._settings.requestTimeoutInSeconds });\n\n        logger.debug(\"merging remote JSON with seed metadata\");\n        this._metadata = Object.assign({}, this._settings.metadataSeed, metadata);\n        return this._metadata;\n    }\n\n    public getIssuer(): Promise<string> {\n        return this._getMetadataProperty(\"issuer\") as Promise<string>;\n    }\n\n    public getAuthorizationEndpoint(): Promise<string> {\n        return this._getMetadataProperty(\"authorization_endpoint\") as Promise<string>;\n    }\n\n    public getUserInfoEndpoint(): Promise<string> {\n        return this._getMetadataProperty(\"userinfo_endpoint\") as Promise<string>;\n    }\n\n    public getTokenEndpoint(optional: false): Promise<string>;\n    public getTokenEndpoint(optional?: true): Promise<string | undefined>;\n    public getTokenEndpoint(optional = true): Promise<string | undefined> {\n        return this._getMetadataProperty(\"token_endpoint\", optional) as Promise<string | undefined>;\n    }\n\n    public getCheckSessionIframe(): Promise<string | undefined> {\n        return this._getMetadataProperty(\"check_session_iframe\", true) as Promise<string | undefined>;\n    }\n\n    public getEndSessionEndpoint(): Promise<string | undefined> {\n        return this._getMetadataProperty(\"end_session_endpoint\", true) as Promise<string | undefined>;\n    }\n\n    public getRevocationEndpoint(optional: false): Promise<string>;\n    public getRevocationEndpoint(optional?: true): Promise<string | undefined>;\n    public getRevocationEndpoint(optional = true): Promise<string | undefined> {\n        return this._getMetadataProperty(\"revocation_endpoint\", optional) as Promise<string | undefined>;\n    }\n\n    public getKeysEndpoint(optional: false): Promise<string>;\n    public getKeysEndpoint(optional?: true): Promise<string | undefined>;\n    public getKeysEndpoint(optional = true): Promise<string | undefined> {\n        return this._getMetadataProperty(\"jwks_uri\", optional) as Promise<string | undefined>;\n    }\n\n    protected async _getMetadataProperty(name: keyof OidcMetadata, optional=false): Promise<string | boolean | string[] | undefined> {\n        const logger = this._logger.create(`_getMetadataProperty('${name}')`);\n\n        const metadata = await this.getMetadata();\n        logger.debug(\"resolved\");\n\n        if (metadata[name] === undefined) {\n            if (optional === true) {\n                logger.warn(\"Metadata does not contain optional property\");\n                return undefined;\n            }\n\n            logger.throw(new Error(\"Metadata does not contain property \" + name));\n        }\n\n        return metadata[name];\n    }\n\n    public async getSigningKeys(): Promise<SigningKey[] | null> {\n        const logger = this._logger.create(\"getSigningKeys\");\n        if (this._signingKeys) {\n            logger.debug(\"returning signingKeys from cache\");\n            return this._signingKeys;\n        }\n\n        const jwks_uri = await this.getKeysEndpoint(false);\n        logger.debug(\"got jwks_uri\", jwks_uri);\n\n        const keySet = await this._jsonService.getJson(jwks_uri, { timeoutInSeconds: this._settings.requestTimeoutInSeconds });\n        logger.debug(\"got key set\", keySet);\n\n        if (!Array.isArray(keySet.keys)) {\n            logger.throw(new Error(\"Missing keys on keyset\"));\n            throw null; // https://github.com/microsoft/TypeScript/issues/46972\n        }\n\n        this._signingKeys = keySet.keys;\n        return this._signingKeys;\n    }\n}\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\n\nimport { Logger } from \"./utils\";\nimport type { StateStore } from \"./StateStore\";\nimport type { AsyncStorage } from \"./AsyncStorage\";\n\n/**\n * @public\n */\nexport class WebStorageStateStore implements StateStore {\n    private readonly _logger = new Logger(\"WebStorageStateStore\");\n\n    private readonly _store: AsyncStorage | Storage;\n    private readonly _prefix: string;\n\n    public constructor({\n        prefix = \"oidc.\",\n        store = localStorage,\n    }: { prefix?: string; store?: AsyncStorage | Storage } = {}) {\n        this._store = store;\n        this._prefix = prefix;\n    }\n\n    public async set(key: string, value: string): Promise<void> {\n        this._logger.create(`set('${key}')`);\n\n        key = this._prefix + key;\n        await this._store.setItem(key, value);\n    }\n\n    public async get(key: string): Promise<string | null> {\n        this._logger.create(`get('${key}')`);\n\n        key = this._prefix + key;\n        const item = await this._store.getItem(key);\n        return item;\n    }\n\n    public async remove(key: string): Promise<string | null> {\n        this._logger.create(`remove('${key}')`);\n\n        key = this._prefix + key;\n        const item = await this._store.getItem(key);\n        await this._store.removeItem(key);\n        return item;\n    }\n\n    public async getAllKeys(): Promise<string[]> {\n        this._logger.create(\"getAllKeys\");\n        const len = await this._store.length;\n\n        const keys = [];\n        for (let index = 0; index < len; index++) {\n            const key = await this._store.key(index);\n            if (key && key.indexOf(this._prefix) === 0) {\n                keys.push(key.substr(this._prefix.length));\n            }\n        }\n        return keys;\n    }\n}\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\n\nimport { WebStorageStateStore } from \"./WebStorageStateStore\";\nimport type { OidcMetadata } from \"./OidcMetadata\";\nimport type { StateStore } from \"./StateStore\";\nimport { InMemoryWebStorage } from \"./InMemoryWebStorage\";\nimport type { DPoPStore } from \"./DPoPStore\";\n\nconst DefaultResponseType = \"code\";\nconst DefaultScope = \"openid\";\nconst DefaultClientAuthentication = \"client_secret_post\";\nconst DefaultStaleStateAgeInSeconds = 60 * 15;\n\n/**\n * @public\n */\nexport type SigningKey = Record<string, string | string[]>;\n\n/**\n * @public\n */\nexport type ExtraHeader = string | (() => string);\n\n/**\n * Optional DPoP settings\n * @public\n */\nexport interface DPoPSettings {\n    bind_authorization_code?: boolean;\n    store: DPoPStore;\n}\n\n/**\n * The settings used to configure the {@link OidcClient}.\n *\n * @public\n */\nexport interface OidcClientSettings {\n    /** The URL of the OIDC/OAuth2 provider */\n    authority: string;\n    metadataUrl?: string;\n    /** Provide metadata when authority server does not allow CORS on the metadata endpoint */\n    metadata?: Partial<OidcMetadata>;\n    /** Can be used to seed or add additional values to the results of the discovery request */\n    metadataSeed?: Partial<OidcMetadata>;\n    /** Provide signingKeys when authority server does not allow CORS on the jwks uri */\n    signingKeys?: SigningKey[];\n\n    /** Your client application's identifier as registered with the OIDC/OAuth2 */\n    client_id: string;\n    client_secret?: string;\n    /** The type of response desired from the OIDC/OAuth2 provider (default: \"code\") */\n    response_type?: string;\n    /** The scope being requested from the OIDC/OAuth2 provider (default: \"openid\") */\n    scope?: string;\n    /** The redirect URI of your client application to receive a response from the OIDC/OAuth2 provider */\n    redirect_uri: string;\n    /** The OIDC/OAuth2 post-logout redirect URI */\n    post_logout_redirect_uri?: string;\n\n    /**\n     * Client authentication method that is used to authenticate when using the token endpoint (default: \"client_secret_post\")\n     * - \"client_secret_basic\": using the HTTP Basic authentication scheme\n     * - \"client_secret_post\": including the client credentials in the request body\n     *\n     * See https://openid.net/specs/openid-connect-core-1_0.html#ClientAuthentication\n     */\n    client_authentication?: \"client_secret_basic\" | \"client_secret_post\";\n\n    /** optional protocol param */\n    prompt?: string;\n    /** optional protocol param */\n    display?: string;\n    /** optional protocol param */\n    max_age?: number;\n    /** optional protocol param */\n    ui_locales?: string;\n    /** optional protocol param */\n    acr_values?: string;\n    /** optional protocol param */\n    resource?: string | string[];\n\n    /**\n     * Optional protocol param\n     * The response mode used by the authority server is defined by the response_type unless explicitly specified:\n     * - Response mode for the OAuth 2.0 response type \"code\" is the \"query\" encoding\n     * - Response mode for the OAuth 2.0 response type \"token\" is the \"fragment\" encoding\n     *\n     * @see https://openid.net/specs/oauth-v2-multiple-response-types-1_0.html#ResponseModes\n     */\n    response_mode?: \"query\" | \"fragment\";\n\n    /**\n     * Should optional OIDC protocol claims be removed from profile or specify the ones to be removed (default: true)\n     * When true, the following claims are removed by default: [\"nbf\", \"jti\", \"auth_time\", \"nonce\", \"acr\", \"amr\", \"azp\", \"at_hash\"]\n     * When specifying claims, the following claims are not allowed: [\"sub\", \"iss\", \"aud\", \"exp\", \"iat\"]\n    */\n    filterProtocolClaims?: boolean | string[];\n    /** Flag to control if additional identity data is loaded from the user info endpoint in order to populate the user's profile (default: false) */\n    loadUserInfo?: boolean;\n    /** Number (in seconds) indicating the age of state entries in storage for authorize requests that are considered abandoned and thus can be cleaned up (default: 900) */\n    staleStateAgeInSeconds?: number;\n\n    /**\n     * Indicates how objects returned from the user info endpoint as claims (e.g. `address`) are merged into the claims from the\n     * id token as a single object.  (default: `{ array: \"replace\" }`)\n     * - array: \"replace\": natives (string, int, float) and arrays are replaced, objects are merged as distinct objects\n     * - array: \"merge\": natives (string, int, float) are replaced, arrays and objects are merged as distinct objects\n     */\n    mergeClaimsStrategy?: { array: \"replace\" | \"merge\" };\n\n    /**\n     * Storage object used to persist interaction state (default: window.localStorage, InMemoryWebStorage iff no window).\n     * E.g. `stateStore: new WebStorageStateStore({ store: window.localStorage })`\n     */\n    stateStore?: StateStore;\n\n    /**\n     * An object containing additional query string parameters to be including in the authorization request.\n     * E.g, when using Azure AD to obtain an access token an additional resource parameter is required. extraQueryParams: `{resource:\"some_identifier\"}`\n     */\n    extraQueryParams?: Record<string, string | number | boolean>;\n\n    extraTokenParams?: Record<string, unknown>;\n\n    /**\n     * An object containing additional header to be including in request.\n     */\n    extraHeaders?: Record<string, ExtraHeader>;\n\n    /**\n     * DPoP enabled or disabled\n     */\n    dpop?: DPoPSettings | undefined;\n\n    /**\n     * Will check the content type header of the response of the revocation endpoint to match these passed values (default: [])\n     */\n    revokeTokenAdditionalContentTypes?: string[];\n    /**\n     * Will disable PKCE validation, changing to true will not append to sign in request code_challenge and code_challenge_method. (default: false)\n     */\n    disablePKCE?: boolean;\n    /**\n     * Sets the credentials for fetch requests. (default: \"same-origin\")\n     * Use this if you need to send cookies to the OIDC/OAuth2 provider or if you are using a proxy that requires cookies\n     */\n    fetchRequestCredentials?: RequestCredentials;\n\n    /**\n     * Only scopes in this list will be passed in the token refresh request.\n     */\n    refreshTokenAllowedScope?: string | undefined;\n\n    /**\n     * Defines request timeouts globally across all requests made to the authorisation server\n     */\n    requestTimeoutInSeconds?: number | undefined;\n\n    /**\n     * https://datatracker.ietf.org/doc/html/rfc6749#section-3.3 describes behavior when omitting scopes from sign in requests\n     * If the IDP supports default scopes, this setting will ignore the scopes property passed to the config. (Default: false)\n     */\n    omitScopeWhenRequesting?: boolean;\n}\n\n/**\n * The settings with defaults applied of the {@link OidcClient}.\n *\n * @public\n * @see {@link OidcClientSettings}\n */\nexport class OidcClientSettingsStore {\n    // metadata\n    public readonly authority: string;\n    public readonly metadataUrl: string;\n    public readonly metadata: Partial<OidcMetadata> | undefined;\n    public readonly metadataSeed: Partial<OidcMetadata> | undefined;\n    public readonly signingKeys: SigningKey[] | undefined;\n\n    // client config\n    public readonly client_id: string;\n    public readonly client_secret: string | undefined;\n    public readonly response_type: string;\n    public readonly scope: string;\n    public readonly redirect_uri: string;\n    public readonly post_logout_redirect_uri: string | undefined;\n    public readonly client_authentication: \"client_secret_basic\" | \"client_secret_post\";\n\n    // optional protocol params\n    public readonly prompt: string | undefined;\n    public readonly display: string | undefined;\n    public readonly max_age: number | undefined;\n    public readonly ui_locales: string | undefined;\n    public readonly acr_values: string | undefined;\n    public readonly resource: string | string[] | undefined;\n    public readonly response_mode: \"query\" | \"fragment\" | undefined;\n\n    // behavior flags\n    public readonly filterProtocolClaims: boolean | string[];\n    public readonly loadUserInfo: boolean;\n    public readonly staleStateAgeInSeconds: number;\n    public readonly mergeClaimsStrategy: { array: \"replace\" | \"merge\" };\n    public readonly omitScopeWhenRequesting: boolean;\n\n    public readonly stateStore: StateStore;\n\n    // extra\n    public readonly extraQueryParams: Record<string, string | number | boolean>;\n    public readonly extraTokenParams: Record<string, unknown>;\n    public readonly dpop: DPoPSettings | undefined;\n    public readonly extraHeaders: Record<string, ExtraHeader>;\n\n    public readonly revokeTokenAdditionalContentTypes?: string[];\n    public readonly fetchRequestCredentials: RequestCredentials;\n    public readonly refreshTokenAllowedScope: string | undefined;\n    public readonly disablePKCE: boolean;\n    public readonly requestTimeoutInSeconds: number | undefined;\n\n    public constructor({\n        // metadata related\n        authority, metadataUrl, metadata, signingKeys, metadataSeed,\n        // client related\n        client_id, client_secret, response_type = DefaultResponseType, scope = DefaultScope,\n        redirect_uri, post_logout_redirect_uri,\n        client_authentication = DefaultClientAuthentication,\n        // optional protocol\n        prompt, display, max_age, ui_locales, acr_values, resource, response_mode,\n        // behavior flags\n        filterProtocolClaims = true,\n        loadUserInfo = false,\n        requestTimeoutInSeconds,\n        staleStateAgeInSeconds = DefaultStaleStateAgeInSeconds,\n        mergeClaimsStrategy = { array: \"replace\" },\n        disablePKCE = false,\n        // other behavior\n        stateStore,\n        revokeTokenAdditionalContentTypes,\n        fetchRequestCredentials,\n        refreshTokenAllowedScope,\n        // extra\n        extraQueryParams = {},\n        extraTokenParams = {},\n        extraHeaders = {},\n        dpop,\n        omitScopeWhenRequesting = false,\n    }: OidcClientSettings) {\n\n        this.authority = authority;\n\n        if (metadataUrl) {\n            this.metadataUrl = metadataUrl;\n        } else {\n            this.metadataUrl = authority;\n            if (authority) {\n                if (!this.metadataUrl.endsWith(\"/\")) {\n                    this.metadataUrl += \"/\";\n                }\n                this.metadataUrl += \".well-known/openid-configuration\";\n            }\n        }\n\n        this.metadata = metadata;\n        this.metadataSeed = metadataSeed;\n        this.signingKeys = signingKeys;\n\n        this.client_id = client_id;\n        this.client_secret = client_secret;\n        this.response_type = response_type;\n        this.scope = scope;\n        this.redirect_uri = redirect_uri;\n        this.post_logout_redirect_uri = post_logout_redirect_uri;\n        this.client_authentication = client_authentication;\n\n        this.prompt = prompt;\n        this.display = display;\n        this.max_age = max_age;\n        this.ui_locales = ui_locales;\n        this.acr_values = acr_values;\n        this.resource = resource;\n        this.response_mode = response_mode;\n\n        this.filterProtocolClaims = filterProtocolClaims ?? true;\n        this.loadUserInfo = !!loadUserInfo;\n        this.staleStateAgeInSeconds = staleStateAgeInSeconds;\n        this.mergeClaimsStrategy = mergeClaimsStrategy;\n        this.omitScopeWhenRequesting = omitScopeWhenRequesting;\n        this.disablePKCE = !!disablePKCE;\n        this.revokeTokenAdditionalContentTypes = revokeTokenAdditionalContentTypes;\n\n        this.fetchRequestCredentials = fetchRequestCredentials ? fetchRequestCredentials : \"same-origin\";\n        this.requestTimeoutInSeconds = requestTimeoutInSeconds;\n\n        if (stateStore) {\n            this.stateStore = stateStore;\n        }\n        else {\n            const store = typeof window !== \"undefined\" ? window.localStorage : new InMemoryWebStorage();\n            this.stateStore = new WebStorageStateStore({ store });\n        }\n\n        this.refreshTokenAllowedScope = refreshTokenAllowedScope;\n\n        this.extraQueryParams = extraQueryParams;\n        this.extraTokenParams = extraTokenParams;\n        this.extraHeaders = extraHeaders;\n\n        this.dpop = dpop;\n        if (this.dpop && !this.dpop?.store) {\n            throw new Error(\"A DPoPStore is required when dpop is enabled\");\n        }\n    }\n}\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\n\nimport { Logger, JwtUtils } from \"./utils\";\nimport { JsonService } from \"./JsonService\";\nimport type { MetadataService } from \"./MetadataService\";\nimport type { JwtClaims } from \"./Claims\";\nimport type { OidcClientSettingsStore } from \"./OidcClientSettings\";\n\n/**\n * @internal\n */\nexport class UserInfoService {\n    protected readonly _logger = new Logger(\"UserInfoService\");\n    private readonly _jsonService: JsonService;\n\n    public constructor(private readonly _settings: OidcClientSettingsStore,\n        private readonly _metadataService: MetadataService,\n    ) {\n        this._jsonService = new JsonService(\n            undefined,\n            this._getClaimsFromJwt,\n            this._settings.extraHeaders,\n        );\n    }\n\n    public async getClaims(token: string): Promise<JwtClaims> {\n        const logger = this._logger.create(\"getClaims\");\n        if (!token) {\n            this._logger.throw(new Error(\"No token passed\"));\n        }\n\n        const url = await this._metadataService.getUserInfoEndpoint();\n        logger.debug(\"got userinfo url\", url);\n\n        const claims = await this._jsonService.getJson(url, {\n            token,\n            credentials: this._settings.fetchRequestCredentials,\n            timeoutInSeconds: this._settings.requestTimeoutInSeconds,\n        });\n        logger.debug(\"got claims\", claims);\n\n        return claims;\n    }\n\n    protected _getClaimsFromJwt = async (responseText: string): Promise<JwtClaims> => {\n        const logger = this._logger.create(\"_getClaimsFromJwt\");\n        try {\n            const payload = JwtUtils.decode(responseText);\n            logger.debug(\"JWT decoding successful\");\n\n            return payload;\n        } catch (err) {\n            logger.error(\"Error parsing JWT response\");\n            throw err;\n        }\n    };\n}\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\n\nimport { CryptoUtils, Logger } from \"./utils\";\nimport { JsonService } from \"./JsonService\";\nimport type { MetadataService } from \"./MetadataService\";\nimport type { ExtraHeader, OidcClientSettingsStore } from \"./OidcClientSettings\";\n\n/**\n * @internal\n */\nexport interface ExchangeCodeArgs {\n    client_id?: string;\n    client_secret?: string;\n    redirect_uri?: string;\n\n    grant_type?: string;\n    code: string;\n    code_verifier?: string;\n\n    extraHeaders?: Record<string, ExtraHeader>;\n}\n\n/**\n * @internal\n */\nexport interface ExchangeCredentialsArgs {\n    client_id?: string;\n    client_secret?: string;\n\n    grant_type?: string;\n    scope?: string;\n\n    username: string;\n    password: string;\n}\n\n/**\n * @internal\n */\nexport interface ExchangeRefreshTokenArgs {\n    client_id?: string;\n    client_secret?: string;\n    redirect_uri?: string;\n\n    grant_type?: string;\n    refresh_token: string;\n    scope?: string;\n    resource?: string | string[];\n\n    timeoutInSeconds?: number;\n\n    extraHeaders?: Record<string, ExtraHeader>;\n}\n\n/**\n * @internal\n */\nexport interface RevokeArgs {\n    token: string;\n    token_type_hint?: \"access_token\" | \"refresh_token\";\n}\n\n/**\n * @internal\n */\nexport class TokenClient {\n    private readonly _logger = new Logger(\"TokenClient\");\n    private readonly _jsonService;\n\n    public constructor(\n        private readonly _settings: OidcClientSettingsStore,\n        private readonly _metadataService: MetadataService,\n    ) {\n        this._jsonService = new JsonService(\n            this._settings.revokeTokenAdditionalContentTypes,\n            null,\n            this._settings.extraHeaders,\n        );\n    }\n\n    /**\n     * Exchange code.\n     *\n     * @see https://www.rfc-editor.org/rfc/rfc6749#section-4.1.3\n     */\n    public async exchangeCode({\n        grant_type = \"authorization_code\",\n        redirect_uri = this._settings.redirect_uri,\n        client_id = this._settings.client_id,\n        client_secret = this._settings.client_secret,\n        extraHeaders,\n        ...args\n    }: ExchangeCodeArgs): Promise<Record<string, unknown>> {\n        const logger = this._logger.create(\"exchangeCode\");\n        if (!client_id) {\n            logger.throw(new Error(\"A client_id is required\"));\n        }\n        if (!redirect_uri) {\n            logger.throw(new Error(\"A redirect_uri is required\"));\n        }\n        if (!args.code) {\n            logger.throw(new Error(\"A code is required\"));\n        }\n\n        const params = new URLSearchParams({ grant_type, redirect_uri });\n        for (const [key, value] of Object.entries(args)) {\n            if (value != null) {\n                params.set(key, value);\n            }\n        }\n        let basicAuth: string | undefined;\n        switch (this._settings.client_authentication) {\n            case \"client_secret_basic\":\n                if (!client_secret) {\n                    logger.throw(new Error(\"A client_secret is required\"));\n                    throw null; // https://github.com/microsoft/TypeScript/issues/46972\n                }\n                basicAuth = CryptoUtils.generateBasicAuth(client_id, client_secret);\n                break;\n            case \"client_secret_post\":\n                params.append(\"client_id\", client_id);\n                if (client_secret) {\n                    params.append(\"client_secret\", client_secret);\n                }\n                break;\n        }\n\n        const url = await this._metadataService.getTokenEndpoint(false);\n        logger.debug(\"got token endpoint\");\n\n        const response = await this._jsonService.postForm(url, {\n            body: params,\n            basicAuth,\n            timeoutInSeconds: this._settings.requestTimeoutInSeconds,\n            initCredentials: this._settings.fetchRequestCredentials,\n            extraHeaders,\n        });\n\n        logger.debug(\"got response\");\n\n        return response;\n    }\n\n    /**\n     * Exchange credentials.\n     *\n     * @see https://www.rfc-editor.org/rfc/rfc6749#section-4.3.2\n     */\n    public async exchangeCredentials({\n        grant_type = \"password\",\n        client_id = this._settings.client_id,\n        client_secret = this._settings.client_secret,\n        scope = this._settings.scope,\n        ...args\n    }: ExchangeCredentialsArgs): Promise<Record<string, unknown>> {\n        const logger = this._logger.create(\"exchangeCredentials\");\n\n        if (!client_id) {\n            logger.throw(new Error(\"A client_id is required\"));\n        }\n\n        const params = new URLSearchParams({ grant_type });\n        if (!this._settings.omitScopeWhenRequesting) {\n            params.set(\"scope\", scope);\n        }\n        for (const [key, value] of Object.entries(args)) {\n            if (value != null) {\n                params.set(key, value);\n            }\n        }\n\n        let basicAuth: string | undefined;\n        switch (this._settings.client_authentication) {\n            case \"client_secret_basic\":\n                if (!client_secret) {\n                    logger.throw(new Error(\"A client_secret is required\"));\n                    throw null; // https://github.com/microsoft/TypeScript/issues/46972\n                }\n                basicAuth = CryptoUtils.generateBasicAuth(client_id, client_secret);\n                break;\n            case \"client_secret_post\":\n                params.append(\"client_id\", client_id);\n                if (client_secret) {\n                    params.append(\"client_secret\", client_secret);\n                }\n                break;\n        }\n\n        const url = await this._metadataService.getTokenEndpoint(false);\n        logger.debug(\"got token endpoint\");\n\n        const response = await this._jsonService.postForm(url, { body: params, basicAuth, timeoutInSeconds: this._settings.requestTimeoutInSeconds, initCredentials: this._settings.fetchRequestCredentials });\n        logger.debug(\"got response\");\n\n        return response;\n    }\n\n    /**\n     * Exchange a refresh token.\n     *\n     * @see https://www.rfc-editor.org/rfc/rfc6749#section-6\n     */\n    public async exchangeRefreshToken({\n        grant_type = \"refresh_token\",\n        client_id = this._settings.client_id,\n        client_secret = this._settings.client_secret,\n        timeoutInSeconds,\n        extraHeaders,\n        ...args\n    }: ExchangeRefreshTokenArgs): Promise<Record<string, unknown>> {\n        const logger = this._logger.create(\"exchangeRefreshToken\");\n        if (!client_id) {\n            logger.throw(new Error(\"A client_id is required\"));\n        }\n        if (!args.refresh_token) {\n            logger.throw(new Error(\"A refresh_token is required\"));\n        }\n\n        const params = new URLSearchParams({ grant_type });\n        for (const [key, value] of Object.entries(args)) {\n            if (Array.isArray(value)) {\n                value.forEach(param => params.append(key, param));\n            }\n            else if (value != null) {\n                params.set(key, value);\n            }\n        }\n        let basicAuth: string | undefined;\n        switch (this._settings.client_authentication) {\n            case \"client_secret_basic\":\n                if (!client_secret) {\n                    logger.throw(new Error(\"A client_secret is required\"));\n                    throw null; // https://github.com/microsoft/TypeScript/issues/46972\n                }\n                basicAuth = CryptoUtils.generateBasicAuth(client_id, client_secret);\n                break;\n            case \"client_secret_post\":\n                params.append(\"client_id\", client_id);\n                if (client_secret) {\n                    params.append(\"client_secret\", client_secret);\n                }\n                break;\n        }\n\n        const url = await this._metadataService.getTokenEndpoint(false);\n        logger.debug(\"got token endpoint\");\n\n        const response = await this._jsonService.postForm(url, { body: params, basicAuth, timeoutInSeconds, initCredentials: this._settings.fetchRequestCredentials, extraHeaders });\n        logger.debug(\"got response\");\n\n        return response;\n    }\n\n    /**\n     * Revoke an access or refresh token.\n     *\n     * @see https://datatracker.ietf.org/doc/html/rfc7009#section-2.1\n     */\n    public async revoke(args: RevokeArgs): Promise<void> {\n        const logger = this._logger.create(\"revoke\");\n        if (!args.token) {\n            logger.throw(new Error(\"A token is required\"));\n        }\n\n        const url = await this._metadataService.getRevocationEndpoint(false);\n\n        logger.debug(`got revocation endpoint, revoking ${args.token_type_hint ?? \"default token type\"}`);\n\n        const params = new URLSearchParams();\n        for (const [key, value] of Object.entries(args)) {\n            if (value != null) {\n                params.set(key, value);\n            }\n        }\n        params.set(\"client_id\", this._settings.client_id);\n        if (this._settings.client_secret) {\n            params.set(\"client_secret\", this._settings.client_secret);\n        }\n\n        await this._jsonService.postForm(url, { body: params, timeoutInSeconds: this._settings.requestTimeoutInSeconds });\n        logger.debug(\"got response\");\n    }\n}\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\n\nimport { Logger, JwtUtils } from \"./utils\";\nimport { ErrorResponse } from \"./errors\";\nimport type { MetadataService } from \"./MetadataService\";\nimport { UserInfoService } from \"./UserInfoService\";\nimport { TokenClient } from \"./TokenClient\";\nimport type { ExtraHeader, OidcClientSettingsStore } from \"./OidcClientSettings\";\nimport type { SigninState } from \"./SigninState\";\nimport type { SigninResponse } from \"./SigninResponse\";\nimport type { State } from \"./State\";\nimport type { SignoutResponse } from \"./SignoutResponse\";\nimport type { UserProfile } from \"./User\";\nimport type { RefreshState } from \"./RefreshState\";\nimport type { IdTokenClaims } from \"./Claims\";\nimport type { ClaimsService } from \"./ClaimsService\";\n\n/**\n * @internal\n */\nexport class ResponseValidator {\n    protected readonly _logger = new Logger(\"ResponseValidator\");\n    protected readonly _userInfoService: UserInfoService;\n    protected readonly _tokenClient: TokenClient;\n\n    public constructor(\n        protected readonly _settings: OidcClientSettingsStore,\n        protected readonly _metadataService: MetadataService,\n        protected readonly _claimsService: ClaimsService,\n    ) {\n        this._userInfoService = new UserInfoService(this._settings, this._metadataService);\n        this._tokenClient = new TokenClient(this._settings, this._metadataService);\n    }\n\n    public async validateSigninResponse(response: SigninResponse, state: SigninState, extraHeaders?: Record<string, ExtraHeader>): Promise<void> {\n        const logger = this._logger.create(\"validateSigninResponse\");\n\n        this._processSigninState(response, state);\n        logger.debug(\"state processed\");\n\n        await this._processCode(response, state, extraHeaders);\n        logger.debug(\"code processed\");\n\n        if (response.isOpenId) {\n            this._validateIdTokenAttributes(response);\n        }\n        logger.debug(\"tokens validated\");\n\n        await this._processClaims(response, state?.skipUserInfo, response.isOpenId);\n        logger.debug(\"claims processed\");\n    }\n\n    public async validateCredentialsResponse(response: SigninResponse, skipUserInfo: boolean): Promise<void> {\n        const logger = this._logger.create(\"validateCredentialsResponse\");\n\n        if (response.isOpenId && !!response.id_token) {\n            this._validateIdTokenAttributes(response);\n        }\n        logger.debug(\"tokens validated\");\n\n        await this._processClaims(response, skipUserInfo, response.isOpenId);\n        logger.debug(\"claims processed\");\n    }\n\n    public async validateRefreshResponse(response: SigninResponse, state: RefreshState): Promise<void> {\n        const logger = this._logger.create(\"validateRefreshResponse\");\n\n        response.userState = state.data;\n        // if there's no session_state on the response, copy over session_state from original request\n        response.session_state ??= state.session_state;\n        // if there's no scope on the response, then assume all scopes granted (per-spec) and copy over scopes from original request\n        response.scope ??= state.scope;\n\n        // OpenID Connect Core 1.0 says that id_token is optional in refresh response:\n        // https://openid.net/specs/openid-connect-core-1_0.html#RefreshTokenResponse\n        if (response.isOpenId && !!response.id_token) {\n            this._validateIdTokenAttributes(response, state.id_token);\n            logger.debug(\"ID Token validated\");\n        }\n\n        if (!response.id_token) {\n            // if there's no id_token on the response, copy over id_token from original request\n            response.id_token = state.id_token;\n            // and decoded part too\n            response.profile = state.profile;\n        }\n\n        const hasIdToken = response.isOpenId && !!response.id_token;\n        await this._processClaims(response, false, hasIdToken);\n        logger.debug(\"claims processed\");\n    }\n\n    public validateSignoutResponse(response: SignoutResponse, state: State): void {\n        const logger = this._logger.create(\"validateSignoutResponse\");\n        if (state.id !== response.state) {\n            logger.throw(new Error(\"State does not match\"));\n        }\n\n        // now that we know the state matches, take the stored data\n        // and set it into the response so callers can get their state\n        // this is important for both success & error outcomes\n        logger.debug(\"state validated\");\n        response.userState = state.data;\n\n        if (response.error) {\n            logger.warn(\"Response was error\", response.error);\n            throw new ErrorResponse(response);\n        }\n    }\n\n    protected _processSigninState(response: SigninResponse, state: SigninState): void {\n        const logger = this._logger.create(\"_processSigninState\");\n        if (state.id !== response.state) {\n            logger.throw(new Error(\"State does not match\"));\n        }\n\n        if (!state.client_id) {\n            logger.throw(new Error(\"No client_id on state\"));\n        }\n\n        if (!state.authority) {\n            logger.throw(new Error(\"No authority on state\"));\n        }\n\n        // ensure we're using the correct authority\n        if (this._settings.authority !== state.authority) {\n            logger.throw(new Error(\"authority mismatch on settings vs. signin state\"));\n        }\n        if (this._settings.client_id && this._settings.client_id !== state.client_id) {\n            logger.throw(new Error(\"client_id mismatch on settings vs. signin state\"));\n        }\n\n        // now that we know the state matches, take the stored data\n        // and set it into the response so callers can get their state\n        // this is important for both success & error outcomes\n        logger.debug(\"state validated\");\n        response.userState = state.data;\n        response.url_state = state.url_state;\n        // if there's no scope on the response, then assume all scopes granted (per-spec) and copy over scopes from original request\n        response.scope ??= state.scope;\n\n        if (response.error) {\n            logger.warn(\"Response was error\", response.error);\n            throw new ErrorResponse(response);\n        }\n\n        if (state.code_verifier && !response.code) {\n            logger.throw(new Error(\"Expected code in response\"));\n        }\n\n    }\n\n    protected async _processClaims(response: SigninResponse, skipUserInfo = false, validateSub = true): Promise<void> {\n        const logger = this._logger.create(\"_processClaims\");\n        response.profile = this._claimsService.filterProtocolClaims(response.profile);\n\n        if (skipUserInfo || !this._settings.loadUserInfo || !response.access_token) {\n            logger.debug(\"not loading user info\");\n            return;\n        }\n\n        logger.debug(\"loading user info\");\n        const claims = await this._userInfoService.getClaims(response.access_token);\n        logger.debug(\"user info claims received from user info endpoint\");\n\n        if (validateSub && claims.sub !== response.profile.sub) {\n            logger.throw(new Error(\"subject from UserInfo response does not match subject in ID Token\"));\n        }\n\n        response.profile = this._claimsService.mergeClaims(response.profile, this._claimsService.filterProtocolClaims(claims as IdTokenClaims));\n        logger.debug(\"user info claims received, updated profile:\", response.profile);\n    }\n\n    protected async _processCode(response: SigninResponse, state: SigninState, extraHeaders?: Record<string, ExtraHeader>): Promise<void> {\n        const logger = this._logger.create(\"_processCode\");\n        if (response.code) {\n            logger.debug(\"Validating code\");\n            const tokenResponse = await this._tokenClient.exchangeCode({\n                client_id: state.client_id,\n                client_secret: state.client_secret,\n                code: response.code,\n                redirect_uri: state.redirect_uri,\n                code_verifier: state.code_verifier,\n                extraHeaders: extraHeaders,\n                ...state.extraTokenParams,\n            });\n            Object.assign(response, tokenResponse);\n        } else {\n            logger.debug(\"No code to process\");\n        }\n    }\n\n    protected _validateIdTokenAttributes(response: SigninResponse, existingToken?: string): void {\n        const logger = this._logger.create(\"_validateIdTokenAttributes\");\n\n        logger.debug(\"decoding ID Token JWT\");\n        const incoming = JwtUtils.decode(response.id_token ?? \"\");\n\n        if (!incoming.sub) {\n            logger.throw(new Error(\"ID Token is missing a subject claim\"));\n        }\n\n        if (existingToken) {\n            const existing = JwtUtils.decode(existingToken);\n            if (incoming.sub !== existing.sub) {\n                logger.throw(new Error(\"sub in id_token does not match current sub\"));\n            }\n            if (incoming.auth_time && incoming.auth_time !== existing.auth_time) {\n                logger.throw(new Error(\"auth_time in id_token does not match original auth_time\"));\n            }\n            if (incoming.azp && incoming.azp !== existing.azp) {\n                logger.throw(new Error(\"azp in id_token does not match original azp\"));\n            }\n            if (!incoming.azp && existing.azp) {\n                logger.throw(new Error(\"azp not in id_token, but present in original id_token\"));\n            }\n        }\n\n        response.profile = incoming as UserProfile;\n    }\n}\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\n\nimport { Logger, CryptoUtils, Timer } from \"./utils\";\nimport type { StateStore } from \"./StateStore\";\n\n/**\n * @public\n */\nexport class State {\n    public readonly id: string;\n    public readonly created: number;\n    public readonly request_type: string | undefined;\n    public readonly url_state: string | undefined;\n\n    /** custom \"state\", which can be used by a caller to have \"data\" round tripped */\n    public readonly data?: unknown;\n\n    public constructor(args: {\n        id?: string;\n        data?: unknown;\n        created?: number;\n        request_type?: string;\n        url_state?: string;\n    }) {\n        this.id = args.id || CryptoUtils.generateUUIDv4();\n        this.data = args.data;\n\n        if (args.created && args.created > 0) {\n            this.created = args.created;\n        }\n        else {\n            this.created = Timer.getEpochTime();\n        }\n        this.request_type = args.request_type;\n        this.url_state = args.url_state;\n    }\n\n    public toStorageString(): string {\n        new Logger(\"State\").create(\"toStorageString\");\n        return JSON.stringify({\n            id: this.id,\n            data: this.data,\n            created: this.created,\n            request_type: this.request_type,\n            url_state: this.url_state,\n        });\n    }\n\n    public static fromStorageString(storageString: string): Promise<State> {\n        Logger.createStatic(\"State\", \"fromStorageString\");\n        return Promise.resolve(new State(JSON.parse(storageString)));\n    }\n\n    public static async clearStaleState(storage: StateStore, age: number): Promise<void> {\n        const logger = Logger.createStatic(\"State\", \"clearStaleState\");\n        const cutoff = Timer.getEpochTime() - age;\n\n        const keys = await storage.getAllKeys();\n        logger.debug(\"got keys\", keys);\n\n        for (let i = 0; i < keys.length; i++) {\n            const key = keys[i];\n            const item = await storage.get(key);\n            let remove = false;\n\n            if (item) {\n                try {\n                    const state = await State.fromStorageString(item);\n\n                    logger.debug(\"got item from key:\", key, state.created);\n                    if (state.created <= cutoff) {\n                        remove = true;\n                    }\n                }\n                catch (err) {\n                    logger.error(\"Error parsing state for key:\", key, err);\n                    remove = true;\n                }\n            }\n            else {\n                logger.debug(\"no item in storage for key:\", key);\n                remove = true;\n            }\n\n            if (remove) {\n                logger.debug(\"removed item for key:\", key);\n                void storage.remove(key);\n            }\n        }\n    }\n}\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\n\nimport { Logger, CryptoUtils } from \"./utils\";\nimport { State } from \"./State\";\n\n/** @public */\nexport interface SigninStateArgs {\n    id?: string;\n    data?: unknown;\n    created?: number;\n    request_type?: string;\n\n    code_verifier?: string;\n    code_challenge?: string;\n    authority: string;\n    client_id: string;\n    redirect_uri: string;\n    scope: string;\n    client_secret?: string;\n    extraTokenParams?: Record<string, unknown>;\n    response_mode?: \"query\" | \"fragment\";\n    skipUserInfo?: boolean;\n    url_state?: string;\n}\n\n/** @public */\nexport type SigninStateCreateArgs = Omit<SigninStateArgs, \"code_verifier\"> & {\n    code_verifier?: string | boolean;\n};\n\n/**\n * @public\n */\nexport class SigninState extends State {\n    // isCode\n    /** The same code_verifier that was used to obtain the authorization_code via PKCE. */\n    public readonly code_verifier: string | undefined;\n    /** Used to secure authorization code grants via Proof Key for Code Exchange (PKCE). */\n    public readonly code_challenge: string | undefined;\n\n    // to ensure state still matches settings\n    /** @see {@link OidcClientSettings.authority} */\n    public readonly authority: string;\n    /** @see {@link OidcClientSettings.client_id} */\n    public readonly client_id: string;\n    /** @see {@link OidcClientSettings.redirect_uri} */\n    public readonly redirect_uri: string;\n    /** @see {@link OidcClientSettings.scope} */\n    public readonly scope: string;\n    /** @see {@link OidcClientSettings.client_secret} */\n    public readonly client_secret: string | undefined;\n    /** @see {@link OidcClientSettings.extraTokenParams} */\n    public readonly extraTokenParams: Record<string, unknown> | undefined;\n    /** @see {@link OidcClientSettings.response_mode} */\n    public readonly response_mode: \"query\" | \"fragment\" | undefined;\n\n    public readonly skipUserInfo: boolean | undefined;\n\n    private constructor(args: SigninStateArgs) {\n        super(args);\n\n        this.code_verifier = args.code_verifier;\n        this.code_challenge = args.code_challenge;\n        this.authority = args.authority;\n        this.client_id = args.client_id;\n        this.redirect_uri = args.redirect_uri;\n        this.scope = args.scope;\n        this.client_secret = args.client_secret;\n        this.extraTokenParams = args.extraTokenParams;\n\n        this.response_mode = args.response_mode;\n        this.skipUserInfo = args.skipUserInfo;\n    }\n\n    public static async create(args: SigninStateCreateArgs): Promise<SigninState> {\n        const code_verifier = args.code_verifier === true ? CryptoUtils.generateCodeVerifier() : (args.code_verifier || undefined);\n        const code_challenge = code_verifier ? (await CryptoUtils.generateCodeChallenge(code_verifier)) : undefined;\n\n        return new SigninState({\n            ...args,\n            code_verifier,\n            code_challenge,\n        });\n    }\n\n    public toStorageString(): string {\n        new Logger(\"SigninState\").create(\"toStorageString\");\n        return JSON.stringify({\n            id: this.id,\n            data: this.data,\n            created: this.created,\n            request_type: this.request_type,\n            url_state: this.url_state,\n\n            code_verifier: this.code_verifier,\n            authority: this.authority,\n            client_id: this.client_id,\n            redirect_uri: this.redirect_uri,\n            scope: this.scope,\n            client_secret: this.client_secret,\n            extraTokenParams : this.extraTokenParams,\n            response_mode: this.response_mode,\n            skipUserInfo: this.skipUserInfo,\n        });\n    }\n\n    public static fromStorageString(storageString: string): Promise<SigninState> {\n        Logger.createStatic(\"SigninState\", \"fromStorageString\");\n        const data = JSON.parse(storageString);\n        return SigninState.create(data);\n    }\n}\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\n\nimport { Logger, URL_STATE_DELIMITER } from \"./utils\";\nimport { SigninState } from \"./SigninState\";\n\n/**\n * @public\n * @see https://openid.net/specs/openid-connect-core-1_0.html#AuthRequest\n */\nexport interface SigninRequestCreateArgs {\n    // mandatory\n    url: string;\n    authority: string;\n    client_id: string;\n    redirect_uri: string;\n    response_type: string;\n    scope: string;\n\n    // optional\n    response_mode?: \"query\" | \"fragment\";\n    nonce?: string;\n    display?: string;\n    dpopJkt?: string;\n    prompt?: string;\n    max_age?: number;\n    ui_locales?: string;\n    id_token_hint?: string;\n    login_hint?: string;\n    acr_values?: string;\n\n    // other\n    resource?: string | string[];\n    request?: string;\n    request_uri?: string;\n    request_type?: string;\n    extraQueryParams?: Record<string, string | number | boolean>;\n\n    // special\n    extraTokenParams?: Record<string, unknown>;\n    client_secret?: string;\n    skipUserInfo?: boolean;\n    disablePKCE?: boolean;\n    /** custom \"state\", which can be used by a caller to have \"data\" round tripped */\n    state_data?: unknown;\n    url_state?: string;\n    omitScopeWhenRequesting?: boolean;\n}\n\n/**\n * @public\n */\nexport class SigninRequest {\n    private static readonly _logger = new Logger(\"SigninRequest\");\n\n    public readonly url: string;\n    public readonly state: SigninState;\n\n    private constructor(args: {\n        url: string;\n        state: SigninState;\n    }) {\n        this.url = args.url;\n        this.state = args.state;\n    }\n\n    public static async create({\n        // mandatory\n        url, authority, client_id, redirect_uri, response_type, scope,\n        // optional\n        state_data, response_mode, request_type, client_secret, nonce, url_state,\n        resource,\n        skipUserInfo,\n        extraQueryParams,\n        extraTokenParams,\n        disablePKCE,\n        dpopJkt,\n        omitScopeWhenRequesting,\n        ...optionalParams\n    }: SigninRequestCreateArgs): Promise<SigninRequest> {\n        if (!url) {\n            this._logger.error(\"create: No url passed\");\n            throw new Error(\"url\");\n        }\n        if (!client_id) {\n            this._logger.error(\"create: No client_id passed\");\n            throw new Error(\"client_id\");\n        }\n        if (!redirect_uri) {\n            this._logger.error(\"create: No redirect_uri passed\");\n            throw new Error(\"redirect_uri\");\n        }\n        if (!response_type) {\n            this._logger.error(\"create: No response_type passed\");\n            throw new Error(\"response_type\");\n        }\n        if (!scope) {\n            this._logger.error(\"create: No scope passed\");\n            throw new Error(\"scope\");\n        }\n        if (!authority) {\n            this._logger.error(\"create: No authority passed\");\n            throw new Error(\"authority\");\n        }\n\n        const state = await SigninState.create({\n            data: state_data,\n            request_type,\n            url_state,\n            code_verifier: !disablePKCE,\n            client_id, authority, redirect_uri,\n            response_mode,\n            client_secret, scope, extraTokenParams,\n            skipUserInfo,\n        });\n\n        const parsedUrl = new URL(url);\n        parsedUrl.searchParams.append(\"client_id\", client_id);\n        parsedUrl.searchParams.append(\"redirect_uri\", redirect_uri);\n        parsedUrl.searchParams.append(\"response_type\", response_type);\n        if (!omitScopeWhenRequesting) {\n            parsedUrl.searchParams.append(\"scope\", scope);\n        }\n        if (nonce) {\n            parsedUrl.searchParams.append(\"nonce\", nonce);\n        }\n\n        if (dpopJkt) {\n            parsedUrl.searchParams.append(\"dpop_jkt\", dpopJkt);\n        }\n\n        let stateParam = state.id;\n        if (url_state) {\n            stateParam = `${stateParam}${URL_STATE_DELIMITER}${url_state}`;\n        }\n        parsedUrl.searchParams.append(\"state\", stateParam);\n        if (state.code_challenge) {\n            parsedUrl.searchParams.append(\"code_challenge\", state.code_challenge);\n            parsedUrl.searchParams.append(\"code_challenge_method\", \"S256\");\n        }\n\n        if (resource) {\n            // https://datatracker.ietf.org/doc/html/rfc8707\n            const resources = Array.isArray(resource) ? resource : [resource];\n            resources\n                .forEach(r => parsedUrl.searchParams.append(\"resource\", r));\n        }\n\n        for (const [key, value] of Object.entries({ response_mode, ...optionalParams, ...extraQueryParams })) {\n            if (value != null) {\n                parsedUrl.searchParams.append(key, value.toString());\n            }\n        }\n\n        return new SigninRequest({\n            url: parsedUrl.href,\n            state,\n        });\n    }\n}\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\n\nimport { Timer, URL_STATE_DELIMITER } from \"./utils\";\nimport type { UserProfile } from \"./User\";\n\nconst OidcScope = \"openid\";\n\n/**\n * @public\n * @see https://openid.net/specs/openid-connect-core-1_0.html#AuthResponse\n * @see https://openid.net/specs/openid-connect-core-1_0.html#AuthError\n */\nexport class SigninResponse {\n    // props present in the initial callback response regardless of success\n    public readonly state: string | null;\n    /** @see {@link User.session_state} */\n    public session_state: string | null;\n\n    // error props\n    /** @see {@link ErrorResponse.error} */\n    public readonly error: string | null;\n    /** @see {@link ErrorResponse.error_description} */\n    public readonly error_description: string | null;\n    /** @see {@link ErrorResponse.error_uri} */\n    public readonly error_uri: string | null;\n\n    // success props\n    public readonly code: string | null;\n\n    // props set after validation\n    /** @see {@link User.id_token} */\n    public id_token?: string;\n    /** @see {@link User.access_token} */\n    public access_token = \"\";\n    /** @see {@link User.token_type} */\n    public token_type = \"\";\n    /** @see {@link User.refresh_token} */\n    public refresh_token?: string;\n    /** @see {@link User.scope} */\n    public scope?: string;\n    /** @see {@link User.expires_at} */\n    public expires_at?: number;\n\n    /** custom state data set during the initial signin request */\n    public userState: unknown;\n    public url_state?: string;\n\n    /** @see {@link User.profile} */\n    public profile: UserProfile = {} as UserProfile;\n\n    public constructor(params: URLSearchParams) {\n        this.state = params.get(\"state\");\n        this.session_state = params.get(\"session_state\");\n        if (this.state) {\n            const splitState = decodeURIComponent(this.state).split(URL_STATE_DELIMITER);\n            this.state = splitState[0];\n            if (splitState.length > 1) {\n                this.url_state = splitState.slice(1).join(URL_STATE_DELIMITER);\n            }\n        }\n\n        this.error = params.get(\"error\");\n        this.error_description = params.get(\"error_description\");\n        this.error_uri = params.get(\"error_uri\");\n\n        this.code = params.get(\"code\");\n    }\n\n    public get expires_in(): number | undefined {\n        if (this.expires_at === undefined) {\n            return undefined;\n        }\n        return this.expires_at - Timer.getEpochTime();\n    }\n    public set expires_in(value: number | undefined) {\n        // spec expects a number, but normalize here just in case\n        if (typeof value === \"string\") value = Number(value);\n        if (value !== undefined && value >= 0) {\n            this.expires_at = Math.floor(value) + Timer.getEpochTime();\n        }\n    }\n\n    public get isOpenId(): boolean {\n        return this.scope?.split(\" \").includes(OidcScope) || !!this.id_token;\n    }\n}\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\n\nimport { Logger } from \"./utils\";\nimport { State } from \"./State\";\n\n/**\n * @public\n * @see https://openid.net/specs/openid-connect-rpinitiated-1_0.html#RPLogout\n */\nexport interface SignoutRequestArgs {\n    // mandatory\n    url: string;\n\n    // optional\n    id_token_hint?: string;\n    client_id?: string;\n    post_logout_redirect_uri?: string;\n    extraQueryParams?: Record<string, string | number | boolean>;\n\n    // special\n    request_type?: string;\n    /** custom \"state\", which can be used by a caller to have \"data\" round tripped */\n    state_data?: unknown;\n}\n\n/**\n * @public\n */\nexport class SignoutRequest {\n    private readonly _logger = new Logger(\"SignoutRequest\");\n\n    public readonly url: string;\n    public readonly state?: State;\n\n    public constructor({\n        url,\n        state_data, id_token_hint, post_logout_redirect_uri, extraQueryParams, request_type, client_id,\n    }: SignoutRequestArgs) {\n        if (!url) {\n            this._logger.error(\"ctor: No url passed\");\n            throw new Error(\"url\");\n        }\n\n        const parsedUrl = new URL(url);\n        if (id_token_hint) {\n            parsedUrl.searchParams.append(\"id_token_hint\", id_token_hint);\n        }\n        if (client_id) {\n            parsedUrl.searchParams.append(\"client_id\", client_id);\n        }\n\n        if (post_logout_redirect_uri) {\n            parsedUrl.searchParams.append(\"post_logout_redirect_uri\", post_logout_redirect_uri);\n\n            if (state_data) {\n                this.state = new State({ data: state_data, request_type });\n\n                parsedUrl.searchParams.append(\"state\", this.state.id);\n            }\n        }\n\n        for (const [key, value] of Object.entries({ ...extraQueryParams })) {\n            if (value != null) {\n                parsedUrl.searchParams.append(key, value.toString());\n            }\n        }\n\n        this.url = parsedUrl.href;\n    }\n}\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\n\n/**\n * @public\n * @see https://openid.net/specs/openid-connect-core-1_0.html#AuthError\n */\nexport class SignoutResponse {\n    public readonly state: string | null;\n\n    // error props\n    /** @see {@link ErrorResponse.error} */\n    public error: string | null;\n    /** @see {@link ErrorResponse.error_description} */\n    public error_description: string | null;\n    /** @see {@link ErrorResponse.error_uri} */\n    public error_uri: string | null;\n\n    /** custom state data set during the initial signin request */\n    public userState: unknown;\n\n    public constructor(params: URLSearchParams) {\n        this.state = params.get(\"state\");\n\n        this.error = params.get(\"error\");\n        this.error_description = params.get(\"error_description\");\n        this.error_uri = params.get(\"error_uri\");\n    }\n}\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\n\nimport type { JwtClaims } from \"./Claims\";\nimport type { OidcClientSettingsStore } from \"./OidcClientSettings\";\nimport type { UserProfile } from \"./User\";\nimport { Logger } from \"./utils\";\n\n/**\n * Protocol claims that could be removed by default from profile.\n * Derived from the following sets of claims:\n * - {@link https://datatracker.ietf.org/doc/html/rfc7519.html#section-4.1}\n * - {@link https://openid.net/specs/openid-connect-core-1_0.html#IDToken}\n * - {@link https://openid.net/specs/openid-connect-core-1_0.html#CodeIDToken}\n *\n * @internal\n */\nconst DefaultProtocolClaims = [\n    \"nbf\",\n    \"jti\",\n    \"auth_time\",\n    \"nonce\",\n    \"acr\",\n    \"amr\",\n    \"azp\",\n    \"at_hash\", // https://openid.net/specs/openid-connect-core-1_0.html#CodeIDToken\n] as const;\n\n/**\n * Protocol claims that should never be removed from profile.\n * \"sub\" is needed internally and others should remain required as per the OIDC specs.\n *\n * @internal\n */\nconst InternalRequiredProtocolClaims = [\"sub\", \"iss\", \"aud\", \"exp\", \"iat\"];\n\n/**\n * @internal\n */\nexport class ClaimsService {\n    protected readonly _logger = new Logger(\"ClaimsService\");\n    public constructor(\n        protected readonly _settings: OidcClientSettingsStore,\n    ) {}\n\n    public filterProtocolClaims(claims: UserProfile): UserProfile {\n        const result = { ...claims };\n\n        if (this._settings.filterProtocolClaims) {\n            let protocolClaims;\n            if (Array.isArray(this._settings.filterProtocolClaims)) {\n                protocolClaims = this._settings.filterProtocolClaims;\n            } else {\n                protocolClaims = DefaultProtocolClaims;\n            }\n\n            for (const claim of protocolClaims) {\n                if (!InternalRequiredProtocolClaims.includes(claim)) {\n                    delete result[claim];\n                }\n            }\n        }\n\n        return result;\n    }\n\n    public mergeClaims(claims1: JwtClaims, claims2: JwtClaims): UserProfile;\n    public mergeClaims(claims1: UserProfile, claims2: JwtClaims): UserProfile {\n        const result = { ...claims1 };\n        for (const [claim, values] of Object.entries(claims2)) {\n            if (result[claim] !== values) {\n                if (Array.isArray(result[claim]) || Array.isArray(values)) {\n                    if (this._settings.mergeClaimsStrategy.array == \"replace\") {\n                        result[claim] = values;\n                    } else {\n                        const mergedValues = Array.isArray(result[claim]) ? result[claim] as unknown[] : [result[claim]];\n                        for (const value of Array.isArray(values) ? values : [values]) {\n                            if (!mergedValues.includes(value)) {\n                                mergedValues.push(value);\n                            }\n                        }\n                        result[claim] = mergedValues;\n                    }\n                } else if (typeof result[claim] === \"object\" && typeof values === \"object\") {\n                    result[claim] = this.mergeClaims(result[claim] as JwtClaims, values as JwtClaims);\n                } else {\n                    result[claim] = values;\n                }\n            }\n        }\n\n        return result;\n    }\n}\n","/**\n * @public\n */\nexport interface DPoPStore {\n    set(key: string, value: DPoPState): Promise<void>;\n    get(key: string): Promise<DPoPState>;\n    remove(key: string): Promise<DPoPState>;\n    getAllKeys(): Promise<string[]>;\n}\n\n/**\n * @public\n */\nexport class DPoPState {\n    public constructor(\n        public readonly keys: CryptoKeyPair,\n        public nonce?: string,\n    ) { }\n}\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\n\nimport { CryptoUtils, Logger, UrlUtils } from \"./utils\";\nimport { ErrorResponse } from \"./errors\";\nimport { type ExtraHeader, type OidcClientSettings, OidcClientSettingsStore } from \"./OidcClientSettings\";\nimport { ResponseValidator } from \"./ResponseValidator\";\nimport { MetadataService } from \"./MetadataService\";\nimport type { RefreshState } from \"./RefreshState\";\nimport { SigninRequest, type SigninRequestCreateArgs } from \"./SigninRequest\";\nimport { SigninResponse } from \"./SigninResponse\";\nimport { SignoutRequest, type SignoutRequestArgs } from \"./SignoutRequest\";\nimport { SignoutResponse } from \"./SignoutResponse\";\nimport { SigninState } from \"./SigninState\";\nimport { State } from \"./State\";\nimport { TokenClient } from \"./TokenClient\";\nimport { ClaimsService } from \"./ClaimsService\";\nimport { DPoPState, type DPoPStore } from \"./DPoPStore\";\nimport { ErrorDPoPNonce } from \"./errors/ErrorDPoPNonce\";\n\n/**\n * @public\n */\nexport interface CreateSigninRequestArgs\n    extends Omit<SigninRequestCreateArgs, \"url\" | \"authority\" | \"client_id\" | \"redirect_uri\" | \"response_type\" | \"scope\" | \"state_data\"> {\n    redirect_uri?: string;\n    response_type?: string;\n    scope?: string;\n    dpopJkt?: string;\n\n    /** custom \"state\", which can be used by a caller to have \"data\" round tripped */\n    state?: unknown;\n}\n\n/**\n * @public\n */\nexport interface UseRefreshTokenArgs {\n    redirect_uri?: string;\n    resource?: string | string[];\n    extraTokenParams?: Record<string, unknown>;\n    timeoutInSeconds?: number;\n\n    state: RefreshState;\n\n    extraHeaders?: Record<string, ExtraHeader>;\n}\n\n/**\n * @public\n */\nexport type CreateSignoutRequestArgs = Omit<SignoutRequestArgs, \"url\" | \"state_data\"> & {\n    /** custom \"state\", which can be used by a caller to have \"data\" round tripped */\n    state?: unknown;\n};\n\n/**\n * @public\n */\nexport type ProcessResourceOwnerPasswordCredentialsArgs = {\n    username: string;\n    password: string;\n    skipUserInfo?: boolean;\n    extraTokenParams?: Record<string, unknown>;\n};\n\n/**\n * Provides the raw OIDC/OAuth2 protocol support for the authorization endpoint and the end session endpoint in the\n * authorization server. It provides a bare-bones protocol implementation and is used by the UserManager class.\n * Only use this class if you simply want protocol support without the additional management features of the\n * UserManager class.\n *\n * @public\n */\nexport class OidcClient {\n    public readonly settings: OidcClientSettingsStore;\n    protected readonly _logger = new Logger(\"OidcClient\");\n\n    public readonly metadataService: MetadataService;\n    protected readonly _claimsService: ClaimsService;\n    protected readonly _validator: ResponseValidator;\n    protected readonly _tokenClient: TokenClient;\n\n    public constructor(settings: OidcClientSettings);\n    public constructor(settings: OidcClientSettingsStore, metadataService: MetadataService);\n    public constructor(settings: OidcClientSettings | OidcClientSettingsStore, metadataService?: MetadataService) {\n        this.settings = settings instanceof OidcClientSettingsStore ? settings : new OidcClientSettingsStore(settings);\n\n        this.metadataService = metadataService ?? new MetadataService(this.settings);\n        this._claimsService = new ClaimsService(this.settings);\n        this._validator = new ResponseValidator(this.settings, this.metadataService, this._claimsService);\n        this._tokenClient = new TokenClient(this.settings, this.metadataService);\n    }\n\n    public async createSigninRequest({\n        state,\n        request,\n        request_uri,\n        request_type,\n        id_token_hint,\n        login_hint,\n        skipUserInfo,\n        nonce,\n        url_state,\n        response_type = this.settings.response_type,\n        scope = this.settings.scope,\n        redirect_uri = this.settings.redirect_uri,\n        prompt = this.settings.prompt,\n        display = this.settings.display,\n        max_age = this.settings.max_age,\n        ui_locales = this.settings.ui_locales,\n        acr_values = this.settings.acr_values,\n        resource = this.settings.resource,\n        response_mode = this.settings.response_mode,\n        extraQueryParams = this.settings.extraQueryParams,\n        extraTokenParams = this.settings.extraTokenParams,\n        dpopJkt,\n        omitScopeWhenRequesting = this.settings.omitScopeWhenRequesting,\n    }: CreateSigninRequestArgs): Promise<SigninRequest> {\n        const logger = this._logger.create(\"createSigninRequest\");\n\n        if (response_type !== \"code\") {\n            throw new Error(\"Only the Authorization Code flow (with PKCE) is supported\");\n        }\n\n        const url = await this.metadataService.getAuthorizationEndpoint();\n        logger.debug(\"Received authorization endpoint\", url);\n\n        const signinRequest = await SigninRequest.create({\n            url,\n            authority: this.settings.authority,\n            client_id: this.settings.client_id,\n            redirect_uri,\n            response_type,\n            scope,\n            state_data: state,\n            url_state,\n            prompt, display, max_age, ui_locales, id_token_hint, login_hint, acr_values, dpopJkt,\n            resource, request, request_uri, extraQueryParams, extraTokenParams, request_type, response_mode,\n            client_secret: this.settings.client_secret,\n            skipUserInfo,\n            nonce,\n            disablePKCE: this.settings.disablePKCE,\n            omitScopeWhenRequesting,\n        });\n\n        // house cleaning\n        await this.clearStaleState();\n\n        const signinState = signinRequest.state;\n        await this.settings.stateStore.set(signinState.id, signinState.toStorageString());\n        return signinRequest;\n    }\n\n    public async readSigninResponseState(url: string, removeState = false): Promise<{ state: SigninState; response: SigninResponse }> {\n        const logger = this._logger.create(\"readSigninResponseState\");\n\n        const response = new SigninResponse(UrlUtils.readParams(url, this.settings.response_mode));\n        if (!response.state) {\n            logger.throw(new Error(\"No state in response\"));\n            // need to throw within this function's body for type narrowing to work\n            throw null; // https://github.com/microsoft/TypeScript/issues/46972\n        }\n\n        const storedStateString = await this.settings.stateStore[removeState ? \"remove\" : \"get\"](response.state);\n        if (!storedStateString) {\n            logger.throw(new Error(\"No matching state found in storage\"));\n            throw null; // https://github.com/microsoft/TypeScript/issues/46972\n        }\n\n        const state = await SigninState.fromStorageString(storedStateString);\n        return { state, response };\n    }\n\n    public async processSigninResponse(url: string, extraHeaders?: Record<string, ExtraHeader>): Promise<SigninResponse> {\n        const logger = this._logger.create(\"processSigninResponse\");\n\n        const { state, response } = await this.readSigninResponseState(url, true);\n        logger.debug(\"received state from storage; validating response\");\n\n        if (this.settings.dpop && this.settings.dpop.store) {\n            const dpopProof = await this.getDpopProof(this.settings.dpop.store);\n            extraHeaders = { ...extraHeaders, \"DPoP\": dpopProof };\n        }\n\n        /**\n         * The DPoP spec describes a method for Authorization Servers to supply a nonce value\n         * in order to limit the lifetime of a given DPoP proof.\n         * See https://datatracker.ietf.org/doc/html/rfc9449#name-authorization-server-provid\n         * This involves the AS returning a 400 bad request with a DPoP-Nonce header containing\n         * the nonce value. The client must then retry the request with a recomputed DPoP proof\n         * containing the supplied nonce value.\n         */\n        try {\n            await this._validator.validateSigninResponse(response, state, extraHeaders);\n        }\n        catch (err) {\n            if (err instanceof ErrorDPoPNonce && this.settings.dpop) {\n                const dpopProof = await this.getDpopProof(this.settings.dpop.store, err.nonce);\n                extraHeaders![\"DPoP\"] = dpopProof;\n                await this._validator.validateSigninResponse(response, state, extraHeaders);\n            } else {\n                throw err;\n            }\n        }\n\n        return response;\n    }\n\n    async getDpopProof(dpopStore: DPoPStore, nonce?: string): Promise<string> {\n        let keyPair: CryptoKeyPair;\n        let dpopState: DPoPState;\n\n        if (!(await dpopStore.getAllKeys()).includes(this.settings.client_id)) {\n            keyPair = await CryptoUtils.generateDPoPKeys();\n            dpopState = new DPoPState(keyPair, nonce);\n            await dpopStore.set(this.settings.client_id, dpopState);\n        } else {\n            dpopState = await dpopStore.get(this.settings.client_id);\n\n            // if the server supplied nonce has changed since the last request, update the nonce\n            if (dpopState.nonce !== nonce && nonce) {\n                dpopState.nonce = nonce;\n                await dpopStore.set(this.settings.client_id, dpopState);\n            }\n        }\n\n        return await CryptoUtils.generateDPoPProof({\n            url: await this.metadataService.getTokenEndpoint(false),\n            httpMethod: \"POST\",\n            keyPair: dpopState.keys,\n            nonce: dpopState.nonce,\n        });\n    }\n\n    public async processResourceOwnerPasswordCredentials({\n        username,\n        password,\n        skipUserInfo = false,\n        extraTokenParams = {},\n    }: ProcessResourceOwnerPasswordCredentialsArgs): Promise<SigninResponse> {\n        const tokenResponse: Record<string, unknown> = await this._tokenClient.exchangeCredentials({ username, password, ...extraTokenParams });\n        const signinResponse: SigninResponse = new SigninResponse(new URLSearchParams());\n        Object.assign(signinResponse, tokenResponse);\n        await this._validator.validateCredentialsResponse(signinResponse, skipUserInfo);\n        return signinResponse;\n    }\n\n    public async useRefreshToken({\n        state,\n        redirect_uri,\n        resource,\n        timeoutInSeconds,\n        extraHeaders,\n        extraTokenParams,\n    }: UseRefreshTokenArgs): Promise<SigninResponse> {\n        const logger = this._logger.create(\"useRefreshToken\");\n\n        // https://github.com/authts/oidc-client-ts/issues/695\n        // In some cases (e.g. AzureAD), not all granted scopes are allowed on token refresh requests.\n        // Therefore, we filter all granted scopes by a list of allowable scopes.\n        let scope;\n        if (this.settings.refreshTokenAllowedScope === undefined) {\n            scope = state.scope;\n        } else {\n            const allowableScopes = this.settings.refreshTokenAllowedScope.split(\" \");\n            const providedScopes = state.scope?.split(\" \") || [];\n\n            scope = providedScopes.filter(s => allowableScopes.includes(s)).join(\" \");\n        }\n\n        if (this.settings.dpop && this.settings.dpop.store) {\n            const dpopProof = await this.getDpopProof(this.settings.dpop.store);\n            extraHeaders = { ...extraHeaders, \"DPoP\": dpopProof };\n        }\n\n        /**\n         * The DPoP spec describes a method for Authorization Servers to supply a nonce value\n         * in order to limit the lifetime of a given DPoP proof.\n         * See https://datatracker.ietf.org/doc/html/rfc9449#name-authorization-server-provid\n         * This involves the AS returning a 400 bad request with a DPoP-Nonce header containing\n         * the nonce value. The client must then retry the request with a recomputed DPoP proof\n         * containing the supplied nonce value.\n         */\n        let result;\n        try {\n            result = await this._tokenClient.exchangeRefreshToken({\n                refresh_token: state.refresh_token,\n                // provide the (possible filtered) scope list\n                scope,\n                redirect_uri,\n                resource,\n                timeoutInSeconds,\n                extraHeaders,\n                ...extraTokenParams,\n            });\n        } catch (err) {\n            if (err instanceof ErrorDPoPNonce && this.settings.dpop) {\n                extraHeaders![\"DPoP\"] = await this.getDpopProof(this.settings.dpop.store, err.nonce);\n                result = await this._tokenClient.exchangeRefreshToken({\n                    refresh_token: state.refresh_token,\n                    // provide the (possible filtered) scope list\n                    scope,\n                    redirect_uri,\n                    resource,\n                    timeoutInSeconds,\n                    extraHeaders,\n                    ...extraTokenParams,\n                });\n            } else {\n                throw err;\n            }\n        }\n\n        const response = new SigninResponse(new URLSearchParams());\n        Object.assign(response, result);\n        logger.debug(\"validating response\", response);\n        await this._validator.validateRefreshResponse(response, {\n            ...state,\n            // override the scope in the state handed over to the validator\n            // so it can set the granted scope to the requested scope in case none is included in the response\n            scope,\n        });\n        return response;\n    }\n\n    public async createSignoutRequest({\n        state,\n        id_token_hint,\n        client_id,\n        request_type,\n        post_logout_redirect_uri = this.settings.post_logout_redirect_uri,\n        extraQueryParams = this.settings.extraQueryParams,\n    }: CreateSignoutRequestArgs = {}): Promise<SignoutRequest> {\n        const logger = this._logger.create(\"createSignoutRequest\");\n\n        const url = await this.metadataService.getEndSessionEndpoint();\n        if (!url) {\n            logger.throw(new Error(\"No end session endpoint\"));\n            throw null; // https://github.com/microsoft/TypeScript/issues/46972\n        }\n\n        logger.debug(\"Received end session endpoint\", url);\n\n        // specify the client identifier when post_logout_redirect_uri is used but id_token_hint is not\n        if (!client_id && post_logout_redirect_uri && !id_token_hint) {\n            client_id = this.settings.client_id;\n        }\n\n        const request = new SignoutRequest({\n            url,\n            id_token_hint,\n            client_id,\n            post_logout_redirect_uri,\n            state_data: state,\n            extraQueryParams,\n            request_type,\n        });\n\n        // house cleaning\n        await this.clearStaleState();\n\n        const signoutState = request.state;\n        if (signoutState) {\n            logger.debug(\"Signout request has state to persist\");\n            await this.settings.stateStore.set(signoutState.id, signoutState.toStorageString());\n        }\n\n        return request;\n    }\n\n    public async readSignoutResponseState(url: string, removeState = false): Promise<{ state: State | undefined; response: SignoutResponse }> {\n        const logger = this._logger.create(\"readSignoutResponseState\");\n\n        const response = new SignoutResponse(UrlUtils.readParams(url, this.settings.response_mode));\n        if (!response.state) {\n            logger.debug(\"No state in response\");\n\n            if (response.error) {\n                logger.warn(\"Response was error:\", response.error);\n                throw new ErrorResponse(response);\n            }\n\n            return { state: undefined, response };\n        }\n\n        const storedStateString = await this.settings.stateStore[removeState ? \"remove\" : \"get\"](response.state);\n        if (!storedStateString) {\n            logger.throw(new Error(\"No matching state found in storage\"));\n            throw null; // https://github.com/microsoft/TypeScript/issues/46972\n        }\n\n        const state = await State.fromStorageString(storedStateString);\n        return { state, response };\n    }\n\n    public async processSignoutResponse(url: string): Promise<SignoutResponse> {\n        const logger = this._logger.create(\"processSignoutResponse\");\n\n        const { state, response } = await this.readSignoutResponseState(url, true);\n        if (state) {\n            logger.debug(\"Received state from storage; validating response\");\n            this._validator.validateSignoutResponse(response, state);\n        } else {\n            logger.debug(\"No state from storage; skipping response validation\");\n        }\n\n        return response;\n    }\n\n    public clearStaleState(): Promise<void> {\n        this._logger.create(\"clearStaleState\");\n        return State.clearStaleState(this.settings.stateStore, this.settings.staleStateAgeInSeconds);\n    }\n\n    public async revokeToken(token: string, type?: \"access_token\" | \"refresh_token\"): Promise<void> {\n        this._logger.create(\"revokeToken\");\n        return await this._tokenClient.revoke({\n            token,\n            token_type_hint: type,\n        });\n    }\n}\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\n\nimport { Logger } from \"./utils\";\nimport { CheckSessionIFrame } from \"./CheckSessionIFrame\";\nimport type { UserManager } from \"./UserManager\";\nimport type { User } from \"./User\";\n\n/**\n * @public\n */\nexport class SessionMonitor {\n    private readonly _logger = new Logger(\"SessionMonitor\");\n\n    private _sub: string | undefined;\n    private _checkSessionIFrame?: CheckSessionIFrame;\n\n    public constructor(private readonly _userManager: UserManager) {\n        if (!_userManager) {\n            this._logger.throw(new Error(\"No user manager passed\"));\n        }\n\n        this._userManager.events.addUserLoaded(this._start);\n        this._userManager.events.addUserUnloaded(this._stop);\n\n        this._init().catch((err: unknown) => {\n            // catch to suppress errors since we're in a ctor\n            this._logger.error(err);\n        });\n    }\n\n    protected async _init(): Promise<void> {\n        this._logger.create(\"_init\");\n        const user = await this._userManager.getUser();\n        // doing this manually here since calling getUser\n        // doesn't trigger load event.\n        if (user) {\n            void this._start(user);\n        }\n        else if (this._userManager.settings.monitorAnonymousSession) {\n            const session = await this._userManager.querySessionStatus();\n            if (session) {\n                const tmpUser = {\n                    session_state: session.session_state,\n                    profile: session.sub ? {\n                        sub: session.sub,\n                    } : null,\n                };\n                void this._start(tmpUser);\n            }\n        }\n    }\n\n    protected _start = async (\n        user: User | {\n            session_state: string;\n            profile: { sub: string } | null;\n        },\n    ): Promise<void> => {\n        const session_state = user.session_state;\n        if (!session_state) {\n            return;\n        }\n        const logger = this._logger.create(\"_start\");\n\n        if (user.profile) {\n            this._sub = user.profile.sub;\n            logger.debug(\"session_state\", session_state, \", sub\", this._sub);\n        }\n        else {\n            this._sub = undefined;\n            logger.debug(\"session_state\", session_state, \", anonymous user\");\n        }\n\n        if (this._checkSessionIFrame) {\n            this._checkSessionIFrame.start(session_state);\n            return;\n        }\n\n        try {\n            const url = await this._userManager.metadataService.getCheckSessionIframe();\n            if (url) {\n                logger.debug(\"initializing check session iframe\");\n\n                const client_id = this._userManager.settings.client_id;\n                const intervalInSeconds = this._userManager.settings.checkSessionIntervalInSeconds;\n                const stopOnError = this._userManager.settings.stopCheckSessionOnError;\n\n                const checkSessionIFrame = new CheckSessionIFrame(this._callback, client_id, url, intervalInSeconds, stopOnError);\n                await checkSessionIFrame.load();\n                this._checkSessionIFrame = checkSessionIFrame;\n                checkSessionIFrame.start(session_state);\n            }\n            else {\n                logger.warn(\"no check session iframe found in the metadata\");\n            }\n        }\n        catch (err) {\n            // catch to suppress errors since we're in non-promise callback\n            logger.error(\"Error from getCheckSessionIframe:\", err instanceof Error ? err.message : err);\n        }\n    };\n\n    protected _stop = (): void => {\n        const logger = this._logger.create(\"_stop\");\n        this._sub = undefined;\n\n        if (this._checkSessionIFrame) {\n            this._checkSessionIFrame.stop();\n        }\n\n        if (this._userManager.settings.monitorAnonymousSession) {\n            // using a timer to delay re-initialization to avoid race conditions during signout\n            // TODO rewrite to use promise correctly\n            // eslint-disable-next-line @typescript-eslint/no-misused-promises\n            const timerHandle = setInterval(async () => {\n                clearInterval(timerHandle);\n\n                try {\n                    const session = await this._userManager.querySessionStatus();\n                    if (session) {\n                        const tmpUser = {\n                            session_state: session.session_state,\n                            profile: session.sub ? {\n                                sub: session.sub,\n                            } : null,\n                        };\n                        void this._start(tmpUser);\n                    }\n                }\n                catch (err) {\n                    // catch to suppress errors since we're in a callback\n                    logger.error(\"error from querySessionStatus\", err instanceof Error ? err.message : err);\n                }\n            }, 1000);\n        }\n    };\n\n    protected _callback = async (): Promise<void> => {\n        const logger = this._logger.create(\"_callback\");\n        try {\n            const session = await this._userManager.querySessionStatus();\n            let raiseEvent = true;\n\n            if (session && this._checkSessionIFrame) {\n                if (session.sub === this._sub) {\n                    raiseEvent = false;\n                    this._checkSessionIFrame.start(session.session_state);\n\n                    logger.debug(\"same sub still logged in at OP, session state has changed, restarting check session iframe; session_state\", session.session_state);\n                    await this._userManager.events._raiseUserSessionChanged();\n                }\n                else {\n                    logger.debug(\"different subject signed into OP\", session.sub);\n                }\n            }\n            else {\n                logger.debug(\"subject no longer signed into OP\");\n            }\n\n            if (raiseEvent) {\n                if (this._sub) {\n                    await this._userManager.events._raiseUserSignedOut();\n                }\n                else {\n                    await this._userManager.events._raiseUserSignedIn();\n                }\n            } else {\n                logger.debug(\"no change in session detected, no event to raise\");\n            }\n        }\n        catch (err) {\n            if (this._sub) {\n                logger.debug(\"Error calling queryCurrentSigninSession; raising signed out event\", err);\n                await this._userManager.events._raiseUserSignedOut();\n            }\n        }\n    };\n}\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\n\nimport { Logger, Timer } from \"./utils\";\nimport type { IdTokenClaims } from \"./Claims\";\n\n/**\n * Holds claims represented by a combination of the `id_token` and the user info endpoint.\n *\n * @public\n */\nexport type UserProfile = IdTokenClaims;\n\n/**\n * @public\n */\nexport class User {\n    /**\n     * A JSON Web Token (JWT). Only provided if `openid` scope was requested.\n     * The application can access the data decoded by using the `profile` property.\n     */\n    public id_token?: string;\n\n    /** The session state value returned from the OIDC provider. */\n    public session_state: string | null;\n\n    /**\n     * The requested access token returned from the OIDC provider. The application can use this token to\n     * authenticate itself to the secured resource.\n     */\n    public access_token: string;\n\n    /**\n     * An OAuth 2.0 refresh token. The app can use this token to acquire additional access tokens after the\n     * current access token expires. Refresh tokens are long-lived and can be used to maintain access to resources\n     * for extended periods of time.\n     */\n    public refresh_token?: string;\n\n    /** Typically \"Bearer\" */\n    public token_type: string;\n\n    /** The scopes that the requested access token is valid for. */\n    public scope?: string;\n\n    /** The claims represented by a combination of the `id_token` and the user info endpoint. */\n    public profile: UserProfile;\n\n    /** The expires at returned from the OIDC provider. */\n    public expires_at?: number;\n\n    /** custom state data set during the initial signin request */\n    public readonly state: unknown;\n    public readonly url_state?: string;\n\n    public constructor(args: {\n        id_token?: string;\n        session_state?: string | null;\n        access_token: string;\n        refresh_token?: string;\n        token_type: string;\n        scope?: string;\n        profile: UserProfile;\n        expires_at?: number;\n        userState?: unknown;\n        url_state?: string;\n    }) {\n        this.id_token = args.id_token;\n        this.session_state = args.session_state ?? null;\n        this.access_token = args.access_token;\n        this.refresh_token = args.refresh_token;\n\n        this.token_type = args.token_type;\n        this.scope = args.scope;\n        this.profile = args.profile;\n        this.expires_at = args.expires_at;\n        this.state = args.userState;\n        this.url_state = args.url_state;\n    }\n\n    /** Computed number of seconds the access token has remaining. */\n    public get expires_in(): number | undefined {\n        if (this.expires_at === undefined) {\n            return undefined;\n        }\n        return this.expires_at - Timer.getEpochTime();\n    }\n\n    public set expires_in(value: number | undefined) {\n        if (value !== undefined) {\n            this.expires_at = Math.floor(value) + Timer.getEpochTime();\n        }\n    }\n\n    /** Computed value indicating if the access token is expired. */\n    public get expired(): boolean | undefined {\n        const expires_in = this.expires_in;\n        if (expires_in === undefined) {\n            return undefined;\n        }\n        return expires_in <= 0;\n    }\n\n    /** Array representing the parsed values from the `scope`. */\n    public get scopes(): string[] {\n        return this.scope?.split(\" \") ?? [];\n    }\n\n    public toStorageString(): string {\n        new Logger(\"User\").create(\"toStorageString\");\n        return JSON.stringify({\n            id_token: this.id_token,\n            session_state: this.session_state,\n            access_token: this.access_token,\n            refresh_token: this.refresh_token,\n            token_type: this.token_type,\n            scope: this.scope,\n            profile: this.profile,\n            expires_at: this.expires_at,\n        });\n    }\n\n    public static fromStorageString(storageString: string): User {\n        Logger.createStatic(\"User\", \"fromStorageString\");\n        return new User(JSON.parse(storageString));\n    }\n}\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\n\nimport { Event, Logger, UrlUtils } from \"../utils\";\nimport type { IWindow, NavigateParams, NavigateResponse } from \"./IWindow\";\n\nconst messageSource = \"oidc-client\";\n\ninterface MessageData {\n    source: string;\n    url: string;\n    keepOpen: boolean;\n}\n\n/**\n * Window implementation which resolves via communication from a child window\n * via the `Window.postMessage()` interface.\n *\n * @internal\n */\nexport abstract class AbstractChildWindow implements IWindow {\n    protected abstract readonly _logger: Logger;\n    protected readonly _abort = new Event<[reason: Error]>(\"Window navigation aborted\");\n    protected readonly _disposeHandlers = new Set<() => void>();\n\n    protected _window: WindowProxy | null = null;\n\n    public async navigate(params: NavigateParams): Promise<NavigateResponse> {\n        const logger = this._logger.create(\"navigate\");\n        if (!this._window) {\n            throw new Error(\"Attempted to navigate on a disposed window\");\n        }\n\n        logger.debug(\"setting URL in window\");\n        this._window.location.replace(params.url);\n\n        const { url, keepOpen } = await new Promise<MessageData>((resolve, reject) => {\n            const listener = (e: MessageEvent) => {\n                const data: MessageData | undefined = e.data;\n                const origin = params.scriptOrigin ?? window.location.origin;\n                if (e.origin !== origin || data?.source !== messageSource) {\n                    // silently discard events not intended for us\n                    return;\n                }\n                try {\n                    const state = UrlUtils.readParams(data.url, params.response_mode).get(\"state\");\n                    if (!state) {\n                        logger.warn(\"no state found in response url\");\n                    }\n                    if (e.source !== this._window && state !== params.state) {\n                        // MessageEvent source is a relatively modern feature, we can't rely on it\n                        // so we also inspect the payload for a matching state key as an alternative\n                        return;\n                    }\n                }\n                catch (err) {\n                    this._dispose();\n                    reject(new Error(\"Invalid response from window\"));\n                }\n                resolve(data);\n            };\n            window.addEventListener(\"message\", listener, false);\n            this._disposeHandlers.add(() => window.removeEventListener(\"message\", listener, false));\n            this._disposeHandlers.add(this._abort.addHandler((reason) => {\n                this._dispose();\n                reject(reason);\n            }));\n        });\n        logger.debug(\"got response from window\");\n        this._dispose();\n\n        if (!keepOpen) {\n            this.close();\n        }\n\n        return { url };\n    }\n\n    public abstract close(): void;\n\n    private _dispose(): void {\n        this._logger.create(\"_dispose\");\n\n        for (const dispose of this._disposeHandlers) {\n            dispose();\n        }\n        this._disposeHandlers.clear();\n    }\n\n    protected static _notifyParent(parent: Window, url: string, keepOpen = false, targetOrigin = window.location.origin): void {\n        parent.postMessage({\n            source: messageSource,\n            url,\n            keepOpen,\n        } as MessageData, targetOrigin);\n    }\n}\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\n\nimport { type OidcClientSettings, OidcClientSettingsStore } from \"./OidcClientSettings\";\nimport type { PopupWindowFeatures } from \"./utils/PopupUtils\";\nimport { WebStorageStateStore } from \"./WebStorageStateStore\";\nimport { InMemoryWebStorage } from \"./InMemoryWebStorage\";\n\nexport const DefaultPopupWindowFeatures: PopupWindowFeatures = {\n    location: false,\n    toolbar: false,\n    height: 640,\n    closePopupWindowAfterInSeconds: -1,\n};\nexport const DefaultPopupTarget = \"_blank\";\nconst DefaultAccessTokenExpiringNotificationTimeInSeconds = 60;\nconst DefaultCheckSessionIntervalInSeconds = 2;\nexport const DefaultSilentRequestTimeoutInSeconds = 10;\n\n/**\n * The settings used to configure the {@link UserManager}.\n *\n * @public\n */\nexport interface UserManagerSettings extends OidcClientSettings {\n    /** The URL for the page containing the call to signinPopupCallback to handle the callback from the OIDC/OAuth2 */\n    popup_redirect_uri?: string;\n    popup_post_logout_redirect_uri?: string;\n    /**\n     * The features parameter to window.open for the popup signin window. By default, the popup is\n     * placed centered in front of the window opener.\n     * (default: \\{ location: false, menubar: false, height: 640, closePopupWindowAfterInSeconds: -1 \\})\n     */\n    popupWindowFeatures?: PopupWindowFeatures;\n    /** The target parameter to window.open for the popup signin window (default: \"_blank\") */\n    popupWindowTarget?: string;\n    /** The methods window.location method used to redirect (default: \"assign\") */\n    redirectMethod?: \"replace\" | \"assign\";\n    /** The methods target window being redirected (default: \"self\") */\n    redirectTarget?: \"top\" | \"self\";\n\n    /** The target to pass while calling postMessage inside iframe for callback (default: window.location.origin) */\n    iframeNotifyParentOrigin?: string;\n\n    /** The script origin to check during 'message' callback execution while performing silent auth via iframe (default: window.location.origin) */\n    iframeScriptOrigin?: string;\n\n    /** The URL for the page containing the code handling the silent renew */\n    silent_redirect_uri?: string;\n    /** Number of seconds to wait for the silent renew to return before assuming it has failed or timed out (default: 10) */\n    silentRequestTimeoutInSeconds?: number;\n    /** Flag to indicate if there should be an automatic attempt to renew the access token prior to its expiration. The automatic renew attempt starts 1 minute before the access token expires (default: true) */\n    automaticSilentRenew?: boolean;\n    /** Flag to validate user.profile.sub in silent renew calls (default: true) */\n    validateSubOnSilentRenew?: boolean;\n    /** Flag to control if id_token is included as id_token_hint in silent renew calls (default: false) */\n    includeIdTokenInSilentRenew?: boolean;\n\n    /** Will raise events for when user has performed a signout at the OP (default: false) */\n    monitorSession?: boolean;\n    monitorAnonymousSession?: boolean;\n    /** Interval in seconds to check the user's session (default: 2) */\n    checkSessionIntervalInSeconds?: number;\n    query_status_response_type?: string;\n    stopCheckSessionOnError?: boolean;\n\n    /**\n     * The `token_type_hint`s to pass to the authority server by default (default: [\"access_token\", \"refresh_token\"])\n     *\n     * Token types will be revoked in the same order as they are given here.\n     */\n    revokeTokenTypes?: (\"access_token\" | \"refresh_token\")[];\n    /** Will invoke the revocation endpoint on signout if there is an access token for the user (default: false) */\n    revokeTokensOnSignout?: boolean;\n    /** Flag to control if id_token is included as id_token_hint in silent signout calls (default: false) */\n    includeIdTokenInSilentSignout?: boolean;\n\n    /** The number of seconds before an access token is to expire to raise the accessTokenExpiring event (default: 60) */\n    accessTokenExpiringNotificationTimeInSeconds?: number;\n\n    /**\n     * Storage object used to persist User for currently authenticated user (default: window.sessionStorage, InMemoryWebStorage iff no window).\n     *  E.g. `userStore: new WebStorageStateStore({ store: window.localStorage })`\n     */\n    userStore?: WebStorageStateStore;\n}\n\n/**\n * The settings with defaults applied of the {@link UserManager}.\n * @see {@link UserManagerSettings}\n *\n * @public\n */\nexport class UserManagerSettingsStore extends OidcClientSettingsStore {\n    public readonly popup_redirect_uri: string;\n    public readonly popup_post_logout_redirect_uri: string | undefined;\n    public readonly popupWindowFeatures: PopupWindowFeatures;\n    public readonly popupWindowTarget: string;\n    public readonly redirectMethod: \"replace\" | \"assign\";\n    public readonly redirectTarget: \"top\" | \"self\";\n\n    public readonly iframeNotifyParentOrigin: string | undefined;\n    public readonly iframeScriptOrigin: string | undefined;\n\n    public readonly silent_redirect_uri: string;\n    public readonly silentRequestTimeoutInSeconds: number;\n    public readonly automaticSilentRenew: boolean;\n    public readonly validateSubOnSilentRenew: boolean;\n    public readonly includeIdTokenInSilentRenew: boolean;\n\n    public readonly monitorSession: boolean;\n    public readonly monitorAnonymousSession: boolean;\n    public readonly checkSessionIntervalInSeconds: number;\n    public readonly query_status_response_type: string;\n    public readonly stopCheckSessionOnError: boolean;\n\n    public readonly revokeTokenTypes: (\"access_token\" | \"refresh_token\")[];\n    public readonly revokeTokensOnSignout: boolean;\n    public readonly includeIdTokenInSilentSignout: boolean;\n\n    public readonly accessTokenExpiringNotificationTimeInSeconds: number;\n\n    public readonly userStore: WebStorageStateStore;\n\n    public constructor(args: UserManagerSettings) {\n        const {\n            popup_redirect_uri = args.redirect_uri,\n            popup_post_logout_redirect_uri = args.post_logout_redirect_uri,\n            popupWindowFeatures = DefaultPopupWindowFeatures,\n            popupWindowTarget = DefaultPopupTarget,\n            redirectMethod = \"assign\",\n            redirectTarget = \"self\",\n\n            iframeNotifyParentOrigin = args.iframeNotifyParentOrigin,\n            iframeScriptOrigin = args.iframeScriptOrigin,\n\n            requestTimeoutInSeconds,\n            silent_redirect_uri = args.redirect_uri,\n            silentRequestTimeoutInSeconds,\n            automaticSilentRenew = true,\n            validateSubOnSilentRenew = true,\n            includeIdTokenInSilentRenew = false,\n\n            monitorSession = false,\n            monitorAnonymousSession = false,\n            checkSessionIntervalInSeconds = DefaultCheckSessionIntervalInSeconds,\n            query_status_response_type = \"code\",\n            stopCheckSessionOnError = true,\n\n            revokeTokenTypes = [\"access_token\", \"refresh_token\"],\n            revokeTokensOnSignout = false,\n            includeIdTokenInSilentSignout = false,\n\n            accessTokenExpiringNotificationTimeInSeconds = DefaultAccessTokenExpiringNotificationTimeInSeconds,\n\n            userStore,\n        } = args;\n\n        super(args);\n\n        this.popup_redirect_uri = popup_redirect_uri;\n        this.popup_post_logout_redirect_uri = popup_post_logout_redirect_uri;\n        this.popupWindowFeatures = popupWindowFeatures;\n        this.popupWindowTarget = popupWindowTarget;\n        this.redirectMethod = redirectMethod;\n        this.redirectTarget = redirectTarget;\n\n        this.iframeNotifyParentOrigin = iframeNotifyParentOrigin;\n        this.iframeScriptOrigin = iframeScriptOrigin;\n\n        this.silent_redirect_uri = silent_redirect_uri;\n        this.silentRequestTimeoutInSeconds = silentRequestTimeoutInSeconds || requestTimeoutInSeconds || DefaultSilentRequestTimeoutInSeconds;\n        this.automaticSilentRenew = automaticSilentRenew;\n        this.validateSubOnSilentRenew = validateSubOnSilentRenew;\n        this.includeIdTokenInSilentRenew = includeIdTokenInSilentRenew;\n\n        this.monitorSession = monitorSession;\n        this.monitorAnonymousSession = monitorAnonymousSession;\n        this.checkSessionIntervalInSeconds = checkSessionIntervalInSeconds;\n        this.stopCheckSessionOnError = stopCheckSessionOnError;\n        this.query_status_response_type = query_status_response_type;\n\n        this.revokeTokenTypes = revokeTokenTypes;\n        this.revokeTokensOnSignout = revokeTokensOnSignout;\n        this.includeIdTokenInSilentSignout = includeIdTokenInSilentSignout;\n\n        this.accessTokenExpiringNotificationTimeInSeconds = accessTokenExpiringNotificationTimeInSeconds;\n\n        if (userStore) {\n            this.userStore = userStore;\n        }\n        else {\n            const store = typeof window !== \"undefined\" ? window.sessionStorage : new InMemoryWebStorage();\n            this.userStore = new WebStorageStateStore({ store });\n        }\n    }\n}\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\n\nimport { Logger } from \"../utils\";\nimport { ErrorTimeout } from \"../errors\";\nimport type { NavigateParams, NavigateResponse } from \"./IWindow\";\nimport { AbstractChildWindow } from \"./AbstractChildWindow\";\nimport { DefaultSilentRequestTimeoutInSeconds } from \"../UserManagerSettings\";\n\n/**\n * @public\n */\nexport interface IFrameWindowParams {\n    silentRequestTimeoutInSeconds?: number;\n}\n\n/**\n * @internal\n */\nexport class IFrameWindow extends AbstractChildWindow {\n    protected readonly _logger = new Logger(\"IFrameWindow\");\n    private _frame: HTMLIFrameElement | null;\n    private _timeoutInSeconds: number;\n\n    public constructor({\n        silentRequestTimeoutInSeconds = DefaultSilentRequestTimeoutInSeconds,\n    }: IFrameWindowParams) {\n        super();\n        this._timeoutInSeconds = silentRequestTimeoutInSeconds;\n\n        this._frame = IFrameWindow.createHiddenIframe();\n        this._window = this._frame.contentWindow;\n    }\n\n    private static createHiddenIframe(): HTMLIFrameElement {\n        const iframe = window.document.createElement(\"iframe\");\n\n        // shotgun approach\n        iframe.style.visibility = \"hidden\";\n        iframe.style.position = \"fixed\";\n        iframe.style.left = \"-1000px\";\n        iframe.style.top = \"0\";\n        iframe.width = \"0\";\n        iframe.height = \"0\";\n\n        window.document.body.appendChild(iframe);\n        return iframe;\n    }\n\n    public async navigate(params: NavigateParams): Promise<NavigateResponse> {\n        this._logger.debug(\"navigate: Using timeout of:\", this._timeoutInSeconds);\n        const timer = setTimeout(() => void this._abort.raise(new ErrorTimeout(\"IFrame timed out without a response\")), this._timeoutInSeconds * 1000);\n        this._disposeHandlers.add(() => clearTimeout(timer));\n\n        return await super.navigate(params);\n    }\n\n    public close(): void {\n        if (this._frame) {\n            if (this._frame.parentNode) {\n                this._frame.addEventListener(\"load\", (ev) => {\n                    const frame = ev.target as HTMLIFrameElement;\n                    frame.parentNode?.removeChild(frame);\n                    void this._abort.raise(new Error(\"IFrame removed from DOM\"));\n                }, true);\n                this._frame.contentWindow?.location.replace(\"about:blank\");\n            }\n            this._frame = null;\n        }\n        this._window = null;\n    }\n\n    public static notifyParent(url: string, targetOrigin?: string): void {\n        return super._notifyParent(window.parent, url, false, targetOrigin);\n    }\n}\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\n\nimport { Logger } from \"../utils\";\nimport type { UserManagerSettingsStore } from \"../UserManagerSettings\";\nimport { IFrameWindow, type IFrameWindowParams } from \"./IFrameWindow\";\nimport type { INavigator } from \"./INavigator\";\n\n/**\n * @internal\n */\nexport class IFrameNavigator implements INavigator {\n    private readonly _logger = new Logger(\"IFrameNavigator\");\n\n    constructor(private _settings: UserManagerSettingsStore) {}\n\n    public async prepare({\n        silentRequestTimeoutInSeconds = this._settings.silentRequestTimeoutInSeconds,\n    }: IFrameWindowParams): Promise<IFrameWindow> {\n        return new IFrameWindow({ silentRequestTimeoutInSeconds });\n    }\n\n    public async callback(url: string): Promise<void> {\n        this._logger.create(\"callback\");\n        IFrameWindow.notifyParent(url, this._settings.iframeNotifyParentOrigin);\n    }\n}\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\n\nimport { Logger, PopupUtils, type PopupWindowFeatures } from \"../utils\";\nimport { DefaultPopupWindowFeatures, DefaultPopupTarget } from \"../UserManagerSettings\";\nimport { AbstractChildWindow } from \"./AbstractChildWindow\";\nimport type { NavigateParams, NavigateResponse } from \"./IWindow\";\n\nconst checkForPopupClosedInterval = 500;\nconst second = 1000;\n\n/**\n * @public\n */\nexport interface PopupWindowParams {\n    popupWindowFeatures?: PopupWindowFeatures;\n    popupWindowTarget?: string;\n    /** An AbortSignal to set request's signal. */\n    popupSignal?: AbortSignal | null;\n}\n\n/**\n * @internal\n */\nexport class PopupWindow extends AbstractChildWindow {\n    protected readonly _logger = new Logger(\"PopupWindow\");\n\n    protected _window: WindowProxy | null;\n\n    public constructor({\n        popupWindowTarget = DefaultPopupTarget,\n        popupWindowFeatures = {},\n        popupSignal,\n    }: PopupWindowParams) {\n        super();\n        const centeredPopup = PopupUtils.center({ ...DefaultPopupWindowFeatures, ...popupWindowFeatures });\n        this._window = window.open(undefined, popupWindowTarget, PopupUtils.serialize(centeredPopup));\n\n        if (popupSignal) {\n            popupSignal.addEventListener(\"abort\", () => {\n                void this._abort.raise(new Error(popupSignal.reason ?? \"Popup aborted\"));\n            });\n        }\n\n        if (popupWindowFeatures.closePopupWindowAfterInSeconds && popupWindowFeatures.closePopupWindowAfterInSeconds > 0) {\n            setTimeout(() => {\n                if (!this._window || typeof this._window.closed !== \"boolean\" || this._window.closed) {\n                    void this._abort.raise(new Error(\"Popup blocked by user\"));\n                    return;\n                }\n\n                this.close();\n            }, popupWindowFeatures.closePopupWindowAfterInSeconds * second);\n        }\n    }\n\n    public async navigate(params: NavigateParams): Promise<NavigateResponse> {\n        this._window?.focus();\n\n        const popupClosedInterval = setInterval(() => {\n            if (!this._window || this._window.closed) {\n                void this._abort.raise(new Error(\"Popup closed by user\"));\n            }\n        }, checkForPopupClosedInterval);\n        this._disposeHandlers.add(() => clearInterval(popupClosedInterval));\n\n        return await super.navigate(params);\n    }\n\n    public close(): void {\n        if (this._window) {\n            if (!this._window.closed) {\n                this._window.close();\n                void this._abort.raise(new Error(\"Popup closed\"));\n            }\n        }\n        this._window = null;\n    }\n\n    public static notifyOpener(url: string, keepOpen: boolean): void {\n        if (!window.opener) {\n            throw new Error(\"No window.opener. Can't complete notification.\");\n        }\n        return super._notifyParent(window.opener, url, keepOpen);\n    }\n}\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\n\nimport { Logger } from \"../utils\";\nimport { PopupWindow, type PopupWindowParams } from \"./PopupWindow\";\nimport type { INavigator } from \"./INavigator\";\nimport type { UserManagerSettingsStore } from \"../UserManagerSettings\";\n\n/**\n * @internal\n */\nexport class PopupNavigator implements INavigator {\n    private readonly _logger = new Logger(\"PopupNavigator\");\n\n    constructor(private _settings: UserManagerSettingsStore) { }\n\n    public async prepare({\n        popupWindowFeatures = this._settings.popupWindowFeatures,\n        popupWindowTarget = this._settings.popupWindowTarget,\n        popupSignal,\n    }: PopupWindowParams): Promise<PopupWindow> {\n        return new PopupWindow({ popupWindowFeatures, popupWindowTarget, popupSignal });\n    }\n\n    public async callback(url: string, { keepOpen = false }): Promise<void> {\n        this._logger.create(\"callback\");\n\n        PopupWindow.notifyOpener(url, keepOpen);\n    }\n}\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\n\nimport { Logger } from \"../utils\";\nimport type { UserManagerSettingsStore } from \"../UserManagerSettings\";\nimport type { INavigator } from \"./INavigator\";\nimport type { IWindow } from \"./IWindow\";\n\n/**\n * @public\n */\nexport interface RedirectParams {\n    redirectMethod?: \"replace\" | \"assign\";\n    redirectTarget?: \"top\" | \"self\";\n}\n\n/**\n * @internal\n */\nexport class RedirectNavigator implements INavigator {\n    private readonly _logger = new Logger(\"RedirectNavigator\");\n\n    constructor(private _settings: UserManagerSettingsStore) {}\n\n    public async prepare({\n        redirectMethod = this._settings.redirectMethod,\n        redirectTarget = this._settings.redirectTarget,\n    }: RedirectParams): Promise<IWindow> {\n        this._logger.create(\"prepare\");\n        let targetWindow = window.self as Window;\n\n        if (redirectTarget === \"top\") {\n            targetWindow = window.top ?? window.self;\n        }\n    \n        const redirect = targetWindow.location[redirectMethod].bind(targetWindow.location) as (url: string) => never;\n        let abort: (reason: Error) => void;\n        return {\n            navigate: async (params): Promise<never> => {\n                this._logger.create(\"navigate\");\n                // We use a promise that never resolves to block the caller\n                const promise = new Promise((resolve, reject) => {\n                    abort = reject;\n                });\n                redirect(params.url);\n                return await (promise as Promise<never>);\n            },\n            close: () => {\n                this._logger.create(\"close\");\n                abort?.(new Error(\"Redirect aborted\"));\n                targetWindow.stop();\n            },\n        };\n    }\n\n    public async callback(): Promise<void> {\n        return;\n    }\n}\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\n\nimport { Logger, Event } from \"./utils\";\nimport { AccessTokenEvents } from \"./AccessTokenEvents\";\nimport type { UserManagerSettingsStore } from \"./UserManagerSettings\";\nimport type { User } from \"./User\";\n\n/**\n * @public\n */\nexport type UserLoadedCallback = (user: User) => Promise<void> | void;\n/**\n * @public\n */\nexport type UserUnloadedCallback = () => Promise<void> | void;\n/**\n * @public\n */\nexport type SilentRenewErrorCallback = (error: Error) => Promise<void> | void;\n/**\n * @public\n */\nexport type UserSignedInCallback = () => Promise<void> | void;\n/**\n * @public\n */\nexport type UserSignedOutCallback = () => Promise<void> | void;\n/**\n * @public\n */\nexport type UserSessionChangedCallback = () => Promise<void> | void;\n\n/**\n * @public\n */\nexport class UserManagerEvents extends AccessTokenEvents {\n    protected readonly _logger = new Logger(\"UserManagerEvents\");\n\n    private readonly _userLoaded = new Event<[User]>(\"User loaded\");\n    private readonly _userUnloaded = new Event<[]>(\"User unloaded\");\n    private readonly _silentRenewError = new Event<[Error]>(\"Silent renew error\");\n    private readonly _userSignedIn = new Event<[]>(\"User signed in\");\n    private readonly _userSignedOut = new Event<[]>(\"User signed out\");\n    private readonly _userSessionChanged = new Event<[]>(\"User session changed\");\n\n    public constructor(settings: UserManagerSettingsStore) {\n        super({ expiringNotificationTimeInSeconds: settings.accessTokenExpiringNotificationTimeInSeconds });\n    }\n\n    public async load(user: User, raiseEvent=true): Promise<void> {\n        super.load(user);\n        if (raiseEvent) {\n            await this._userLoaded.raise(user);\n        }\n    }\n    public async unload(): Promise<void> {\n        super.unload();\n        await this._userUnloaded.raise();\n    }\n\n    /**\n     * Add callback: Raised when a user session has been established (or re-established).\n     */\n    public addUserLoaded(cb: UserLoadedCallback): () => void {\n        return this._userLoaded.addHandler(cb);\n    }\n    /**\n     * Remove callback: Raised when a user session has been established (or re-established).\n     */\n    public removeUserLoaded(cb: UserLoadedCallback): void {\n        return this._userLoaded.removeHandler(cb);\n    }\n\n    /**\n     * Add callback: Raised when a user session has been terminated.\n     */\n    public addUserUnloaded(cb: UserUnloadedCallback): () => void {\n        return this._userUnloaded.addHandler(cb);\n    }\n    /**\n     * Remove callback: Raised when a user session has been terminated.\n     */\n    public removeUserUnloaded(cb: UserUnloadedCallback): void {\n        return this._userUnloaded.removeHandler(cb);\n    }\n\n    /**\n     * Add callback: Raised when the automatic silent renew has failed.\n     */\n    public addSilentRenewError(cb: SilentRenewErrorCallback): () => void {\n        return this._silentRenewError.addHandler(cb);\n    }\n    /**\n     * Remove callback: Raised when the automatic silent renew has failed.\n     */\n    public removeSilentRenewError(cb: SilentRenewErrorCallback): void {\n        return this._silentRenewError.removeHandler(cb);\n    }\n    /**\n     * @internal\n     */\n    public async _raiseSilentRenewError(e: Error): Promise<void> {\n        await this._silentRenewError.raise(e);\n    }\n\n    /**\n     * Add callback: Raised when the user is signed in (when `monitorSession` is set).\n     * @see {@link UserManagerSettings.monitorSession}\n     */\n    public addUserSignedIn(cb: UserSignedInCallback): () => void {\n        return this._userSignedIn.addHandler(cb);\n    }\n    /**\n     * Remove callback: Raised when the user is signed in (when `monitorSession` is set).\n     */\n    public removeUserSignedIn(cb: UserSignedInCallback): void {\n        this._userSignedIn.removeHandler(cb);\n    }\n    /**\n     * @internal\n     */\n    public async _raiseUserSignedIn(): Promise<void> {\n        await this._userSignedIn.raise();\n    }\n\n    /**\n     * Add callback: Raised when the user's sign-in status at the OP has changed (when `monitorSession` is set).\n     * @see {@link UserManagerSettings.monitorSession}\n     */\n    public addUserSignedOut(cb: UserSignedOutCallback): () => void {\n        return this._userSignedOut.addHandler(cb);\n    }\n    /**\n     * Remove callback: Raised when the user's sign-in status at the OP has changed (when `monitorSession` is set).\n     */\n    public removeUserSignedOut(cb: UserSignedOutCallback): void {\n        this._userSignedOut.removeHandler(cb);\n    }\n    /**\n     * @internal\n     */\n    public async _raiseUserSignedOut(): Promise<void> {\n        await this._userSignedOut.raise();\n    }\n\n    /**\n     * Add callback: Raised when the user session changed (when `monitorSession` is set).\n     * @see {@link UserManagerSettings.monitorSession}\n     */\n    public addUserSessionChanged(cb: UserSessionChangedCallback): () => void {\n        return this._userSessionChanged.addHandler(cb);\n    }\n    /**\n     * Remove callback: Raised when the user session changed (when `monitorSession` is set).\n     */\n    public removeUserSessionChanged(cb: UserSessionChangedCallback): void {\n        this._userSessionChanged.removeHandler(cb);\n    }\n    /**\n     * @internal\n     */\n    public async _raiseUserSessionChanged(): Promise<void> {\n        await this._userSessionChanged.raise();\n    }\n}\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\n\nimport { Logger, Timer } from \"./utils\";\nimport { ErrorTimeout } from \"./errors\";\nimport type { UserManager } from \"./UserManager\";\nimport type { AccessTokenCallback } from \"./AccessTokenEvents\";\n\n/**\n * @internal\n */\nexport class SilentRenewService {\n    protected _logger = new Logger(\"SilentRenewService\");\n    private _isStarted = false;\n    private readonly _retryTimer = new Timer(\"Retry Silent Renew\");\n\n    public constructor(private _userManager: UserManager) {}\n\n    public async start(): Promise<void> {\n        const logger = this._logger.create(\"start\");\n        if (!this._isStarted) {\n            this._isStarted = true;\n            this._userManager.events.addAccessTokenExpiring(this._tokenExpiring);\n            this._retryTimer.addHandler(this._tokenExpiring);\n\n            // this will trigger loading of the user so the expiring events can be initialized\n            try {\n                await this._userManager.getUser();\n                // deliberate nop\n            }\n            catch (err) {\n                // catch to suppress errors since we're in a ctor\n                logger.error(\"getUser error\", err);\n            }\n        }\n    }\n\n    public stop(): void {\n        if (this._isStarted) {\n            this._retryTimer.cancel();\n            this._retryTimer.removeHandler(this._tokenExpiring);\n            this._userManager.events.removeAccessTokenExpiring(this._tokenExpiring);\n            this._isStarted = false;\n        }\n    }\n\n    protected _tokenExpiring: AccessTokenCallback = async () => {\n        const logger = this._logger.create(\"_tokenExpiring\");\n        try {\n            await this._userManager.signinSilent();\n            logger.debug(\"silent token renewal successful\");\n        }\n        catch (err) {\n            if (err instanceof ErrorTimeout) {\n                // no response from authority server, e.g. IFrame timeout, ...\n                logger.warn(\"ErrorTimeout from signinSilent:\", err, \"retry in 5s\");\n                this._retryTimer.init(5);\n                return;\n            }\n\n            logger.error(\"Error from signinSilent:\", err);\n            await this._userManager.events._raiseSilentRenewError(err as Error);\n        }\n    };\n}\n","// Copyright (C) AuthTS Contributors\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\n\nimport type { UserProfile } from \"./User\";\n\n/**\n * Fake state store implementation necessary for validating refresh token requests.\n *\n * @public\n */\nexport class RefreshState {\n    /** custom \"state\", which can be used by a caller to have \"data\" round tripped */\n    public readonly data?: unknown;\n\n    public readonly refresh_token: string;\n    public readonly id_token?: string;\n    public readonly session_state: string | null;\n    public readonly scope?: string;\n    public readonly profile: UserProfile;\n\n    constructor(args: {\n        refresh_token: string;\n        id_token?: string;\n        session_state: string | null;\n        scope?: string;\n        profile: UserProfile;\n\n        state?: unknown;\n    }) {\n        this.refresh_token = args.refresh_token;\n        this.id_token = args.id_token;\n        this.session_state = args.session_state;\n        this.scope = args.scope;\n        this.profile = args.profile;\n\n        this.data = args.state;\n\n    }\n}\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\n\nimport { CryptoUtils, Logger } from \"./utils\";\nimport { ErrorResponse } from \"./errors\";\nimport { type NavigateResponse, type PopupWindowParams, type IWindow, type IFrameWindowParams, type RedirectParams, RedirectNavigator, PopupNavigator, IFrameNavigator, type INavigator } from \"./navigators\";\nimport { OidcClient, type CreateSigninRequestArgs, type CreateSignoutRequestArgs, type ProcessResourceOwnerPasswordCredentialsArgs, type UseRefreshTokenArgs } from \"./OidcClient\";\nimport { type UserManagerSettings, UserManagerSettingsStore } from \"./UserManagerSettings\";\nimport { User } from \"./User\";\nimport { UserManagerEvents } from \"./UserManagerEvents\";\nimport { SilentRenewService } from \"./SilentRenewService\";\nimport { SessionMonitor } from \"./SessionMonitor\";\nimport type { SessionStatus } from \"./SessionStatus\";\nimport type { SignoutResponse } from \"./SignoutResponse\";\nimport type { MetadataService } from \"./MetadataService\";\nimport { RefreshState } from \"./RefreshState\";\nimport type { SigninResponse } from \"./SigninResponse\";\nimport type { ExtraHeader, DPoPSettings } from \"./OidcClientSettings\";\nimport { DPoPState } from \"./DPoPStore\";\n\n/**\n * @public\n */\nexport type ExtraSigninRequestArgs = Pick<CreateSigninRequestArgs, \"nonce\" | \"extraQueryParams\" | \"extraTokenParams\" | \"state\" | \"redirect_uri\" | \"prompt\" | \"acr_values\" | \"login_hint\" | \"scope\" | \"max_age\" | \"ui_locales\" | \"resource\" | \"url_state\">;\n/**\n * @public\n */\nexport type ExtraSignoutRequestArgs = Pick<CreateSignoutRequestArgs, \"extraQueryParams\" | \"state\" | \"id_token_hint\" | \"post_logout_redirect_uri\">;\n\n/**\n * @public\n */\nexport type RevokeTokensTypes = UserManagerSettings[\"revokeTokenTypes\"];\n\n/**\n * @public\n */\nexport type SigninRedirectArgs = RedirectParams & ExtraSigninRequestArgs;\n\n/**\n * @public\n */\nexport type SigninPopupArgs = PopupWindowParams & ExtraSigninRequestArgs;\n\n/**\n * @public\n */\nexport type SigninSilentArgs = IFrameWindowParams & ExtraSigninRequestArgs;\n\n/**\n * @public\n */\nexport type SigninResourceOwnerCredentialsArgs = ProcessResourceOwnerPasswordCredentialsArgs;\n\n/**\n * @public\n */\nexport type QuerySessionStatusArgs = IFrameWindowParams & ExtraSigninRequestArgs;\n\n/**\n * @public\n */\nexport type SignoutRedirectArgs = RedirectParams & ExtraSignoutRequestArgs;\n\n/**\n * @public\n */\nexport type SignoutPopupArgs = PopupWindowParams & ExtraSignoutRequestArgs;\n\n/**\n * @public\n */\nexport type SignoutSilentArgs = IFrameWindowParams & ExtraSignoutRequestArgs;\n\n/**\n * Provides a higher level API for signing a user in, signing out, managing the user's claims returned from the identity provider,\n * and managing an access token returned from the identity provider (OAuth2/OIDC).\n *\n * @public\n */\nexport class UserManager {\n    /** Get the settings used to configure the `UserManager`. */\n    public readonly settings: UserManagerSettingsStore;\n    protected readonly _logger = new Logger(\"UserManager\");\n\n    protected readonly _client: OidcClient;\n    protected readonly _redirectNavigator: INavigator;\n    protected readonly _popupNavigator: INavigator;\n    protected readonly _iframeNavigator: INavigator;\n    protected readonly _events: UserManagerEvents;\n    protected readonly _silentRenewService: SilentRenewService;\n    protected readonly _sessionMonitor: SessionMonitor | null;\n\n    public constructor(settings: UserManagerSettings, redirectNavigator?: INavigator, popupNavigator?: INavigator, iframeNavigator?: INavigator) {\n        this.settings = new UserManagerSettingsStore(settings);\n\n        this._client = new OidcClient(settings);\n\n        this._redirectNavigator = redirectNavigator ?? new RedirectNavigator(this.settings);\n        this._popupNavigator = popupNavigator ?? new PopupNavigator(this.settings);\n        this._iframeNavigator = iframeNavigator ?? new IFrameNavigator(this.settings);\n\n        this._events = new UserManagerEvents(this.settings);\n        this._silentRenewService = new SilentRenewService(this);\n\n        // order is important for the following properties; these services depend upon the events.\n        if (this.settings.automaticSilentRenew) {\n            this.startSilentRenew();\n        }\n\n        this._sessionMonitor = null;\n        if (this.settings.monitorSession) {\n            this._sessionMonitor = new SessionMonitor(this);\n        }\n    }\n\n    /**\n     * Get object used to register for events raised by the `UserManager`.\n     */\n    public get events(): UserManagerEvents {\n        return this._events;\n    }\n\n    /**\n     * Get object used to access the metadata configuration of the identity provider.\n     */\n    public get metadataService(): MetadataService {\n        return this._client.metadataService;\n    }\n\n    /**\n     * Load the `User` object for the currently authenticated user.\n     *\n     * @returns A promise\n     */\n    public async getUser(): Promise<User | null> {\n        const logger = this._logger.create(\"getUser\");\n        const user = await this._loadUser();\n        if (user) {\n            logger.info(\"user loaded\");\n            await this._events.load(user, false);\n            return user;\n        }\n\n        logger.info(\"user not found in storage\");\n        return null;\n    }\n\n    /**\n     * Remove from any storage the currently authenticated user.\n     *\n     * @returns A promise\n     */\n    public async removeUser(): Promise<void> {\n        const logger = this._logger.create(\"removeUser\");\n        await this.storeUser(null);\n        logger.info(\"user removed from storage\");\n        await this._events.unload();\n    }\n\n    /**\n     * Trigger a redirect of the current window to the authorization endpoint.\n     *\n     * @returns A promise\n     *\n     * @throws `Error` In cases of wrong authentication.\n     */\n    public async signinRedirect(args: SigninRedirectArgs = {}): Promise<void> {\n        this._logger.create(\"signinRedirect\");\n        const {\n            redirectMethod,\n            ...requestArgs\n        } = args;\n\n        let dpopJkt: string | undefined;\n        if (this.settings.dpop?.bind_authorization_code) {\n            dpopJkt = await this.generateDPoPJkt(this.settings.dpop);\n        }\n\n        const handle = await this._redirectNavigator.prepare({ redirectMethod });\n        await this._signinStart({\n            request_type: \"si:r\",\n            dpopJkt,\n            ...requestArgs,\n        }, handle);\n    }\n\n    /**\n     * Process the response (callback) from the authorization endpoint.\n     * It is recommended to use {@link UserManager.signinCallback} instead.\n     *\n     * @returns A promise containing the authenticated `User`.\n     *\n     * @see {@link UserManager.signinCallback}\n     */\n    public async signinRedirectCallback(url = window.location.href): Promise<User> {\n        const logger = this._logger.create(\"signinRedirectCallback\");\n        const user = await this._signinEnd(url);\n        if (user.profile && user.profile.sub) {\n            logger.info(\"success, signed in subject\", user.profile.sub);\n        }\n        else {\n            logger.info(\"no subject\");\n        }\n\n        return user;\n    }\n\n    /**\n     * Trigger the signin with user/password.\n     *\n     * @returns A promise containing the authenticated `User`.\n     * @throws {@link ErrorResponse} In cases of wrong authentication.\n     */\n    public async signinResourceOwnerCredentials({\n        username,\n        password,\n        skipUserInfo = false,\n    }: SigninResourceOwnerCredentialsArgs): Promise<User> {\n        const logger = this._logger.create(\"signinResourceOwnerCredential\");\n\n        const signinResponse = await this._client.processResourceOwnerPasswordCredentials({\n            username,\n            password,\n            skipUserInfo,\n            extraTokenParams: this.settings.extraTokenParams,\n        });\n        logger.debug(\"got signin response\");\n\n        const user = await this._buildUser(signinResponse);\n        if (user.profile && user.profile.sub) {\n            logger.info(\"success, signed in subject\", user.profile.sub);\n        } else {\n            logger.info(\"no subject\");\n        }\n        return user;\n    }\n\n    /**\n     * Trigger a request (via a popup window) to the authorization endpoint.\n     *\n     * @returns A promise containing the authenticated `User`.\n     * @throws `Error` In cases of wrong authentication.\n     */\n    public async signinPopup(args: SigninPopupArgs = {}): Promise<User> {\n        const logger = this._logger.create(\"signinPopup\");\n\n        let dpopJkt: string | undefined;\n        if (this.settings.dpop?.bind_authorization_code) {\n            dpopJkt = await this.generateDPoPJkt(this.settings.dpop);\n        }\n\n        const {\n            popupWindowFeatures,\n            popupWindowTarget,\n            popupSignal,\n            ...requestArgs\n        } = args;\n        const url = this.settings.popup_redirect_uri;\n        if (!url) {\n            logger.throw(new Error(\"No popup_redirect_uri configured\"));\n        }\n\n        const handle = await this._popupNavigator.prepare({ popupWindowFeatures, popupWindowTarget, popupSignal });\n        const user = await this._signin({\n            request_type: \"si:p\",\n            redirect_uri: url,\n            display: \"popup\",\n            dpopJkt,\n            ...requestArgs,\n        }, handle);\n        if (user) {\n            if (user.profile && user.profile.sub) {\n                logger.info(\"success, signed in subject\", user.profile.sub);\n            } else {\n                logger.info(\"no subject\");\n            }\n        }\n\n        return user;\n    }\n\n    /**\n     * Notify the opening window of response (callback) from the authorization endpoint.\n     * It is recommended to use {@link UserManager.signinCallback} instead.\n     *\n     * @returns A promise\n     *\n     * @see {@link UserManager.signinCallback}\n     */\n    public async signinPopupCallback(url = window.location.href, keepOpen = false): Promise<void> {\n        const logger = this._logger.create(\"signinPopupCallback\");\n        await this._popupNavigator.callback(url, { keepOpen });\n        logger.info(\"success\");\n    }\n\n    /**\n     * Trigger a silent request (via refresh token or an iframe) to the authorization endpoint.\n     *\n     * @returns A promise that contains the authenticated `User`.\n     */\n    public async signinSilent(args: SigninSilentArgs = {}): Promise<User | null> {\n        const logger = this._logger.create(\"signinSilent\");\n        const {\n            silentRequestTimeoutInSeconds,\n            ...requestArgs\n        } = args;\n        // first determine if we have a refresh token, or need to use iframe\n        let user = await this._loadUser();\n        if (user?.refresh_token) {\n            logger.debug(\"using refresh token\");\n            const state = new RefreshState(user as Required<User>);\n            return await this._useRefreshToken({\n                state,\n                redirect_uri: requestArgs.redirect_uri,\n                resource: requestArgs.resource,\n                extraTokenParams: requestArgs.extraTokenParams,\n                timeoutInSeconds: silentRequestTimeoutInSeconds,\n            });\n        }\n\n        let dpopJkt: string | undefined;\n        if (this.settings.dpop?.bind_authorization_code) {\n            dpopJkt = await this.generateDPoPJkt(this.settings.dpop);\n        }\n\n        const url = this.settings.silent_redirect_uri;\n        if (!url) {\n            logger.throw(new Error(\"No silent_redirect_uri configured\"));\n        }\n\n        let verifySub: string | undefined;\n        if (user && this.settings.validateSubOnSilentRenew) {\n            logger.debug(\"subject prior to silent renew:\", user.profile.sub);\n            verifySub = user.profile.sub;\n        }\n\n        const handle = await this._iframeNavigator.prepare({ silentRequestTimeoutInSeconds });\n        user = await this._signin({\n            request_type: \"si:s\",\n            redirect_uri: url,\n            prompt: \"none\",\n            id_token_hint: this.settings.includeIdTokenInSilentRenew ? user?.id_token : undefined,\n            dpopJkt,\n            ...requestArgs,\n        }, handle, verifySub);\n        if (user) {\n            if (user.profile?.sub) {\n                logger.info(\"success, signed in subject\", user.profile.sub);\n            }\n            else {\n                logger.info(\"no subject\");\n            }\n        }\n\n        return user;\n    }\n\n    protected async _useRefreshToken(args: UseRefreshTokenArgs): Promise<User> {\n        const response = await this._client.useRefreshToken({\n            timeoutInSeconds: this.settings.silentRequestTimeoutInSeconds,\n            ...args,\n        });\n        const user = new User({ ...args.state, ...response });\n\n        await this.storeUser(user);\n        await this._events.load(user);\n        return user;\n    }\n\n    /**\n     *\n     * Notify the parent window of response (callback) from the authorization endpoint.\n     * It is recommended to use {@link UserManager.signinCallback} instead.\n     *\n     * @returns A promise\n     *\n     * @see {@link UserManager.signinCallback}\n     */\n    public async signinSilentCallback(url = window.location.href): Promise<void> {\n        const logger = this._logger.create(\"signinSilentCallback\");\n        await this._iframeNavigator.callback(url);\n        logger.info(\"success\");\n    }\n\n    /**\n     * Process any response (callback) from the authorization endpoint, by dispatching the request_type\n     * and executing one of the following functions:\n     * - {@link UserManager.signinRedirectCallback}\n     * - {@link UserManager.signinPopupCallback}\n     * - {@link UserManager.signinSilentCallback}\n     *\n     * @throws `Error` If request_type is unknown or signin cannot be processed.\n     */\n    public async signinCallback(url = window.location.href): Promise<User | undefined> {\n        const { state } = await this._client.readSigninResponseState(url);\n        switch (state.request_type) {\n            case \"si:r\":\n                return await this.signinRedirectCallback(url);\n            case \"si:p\":\n                await this.signinPopupCallback(url);\n                break;\n            case \"si:s\":\n                await this.signinSilentCallback(url);\n                break;\n            default:\n                throw new Error(\"invalid response_type in state\");\n        }\n        return undefined;\n    }\n\n    /**\n     * Process any response (callback) from the end session endpoint, by dispatching the request_type\n     * and executing one of the following functions:\n     * - {@link UserManager.signoutRedirectCallback}\n     * - {@link UserManager.signoutPopupCallback}\n     * - {@link UserManager.signoutSilentCallback}\n     *\n     * @throws `Error` If request_type is unknown or signout cannot be processed.\n     */\n    public async signoutCallback(url = window.location.href, keepOpen = false): Promise<SignoutResponse | undefined> {\n        const { state } = await this._client.readSignoutResponseState(url);\n        if (!state) {\n            return undefined;\n        }\n\n        switch (state.request_type) {\n            case \"so:r\":\n                return await this.signoutRedirectCallback(url);\n            case \"so:p\":\n                await this.signoutPopupCallback(url, keepOpen);\n                break;\n            case \"so:s\":\n                await this.signoutSilentCallback(url);\n                break;\n            default:\n                throw new Error(\"invalid response_type in state\");\n        }\n        return undefined;\n    }\n\n    /**\n     * Query OP for user's current signin status.\n     *\n     * @returns A promise object with session_state and subject identifier.\n     */\n    public async querySessionStatus(args: QuerySessionStatusArgs = {}): Promise<SessionStatus | null> {\n        const logger = this._logger.create(\"querySessionStatus\");\n        const {\n            silentRequestTimeoutInSeconds,\n            ...requestArgs\n        } = args;\n        const url = this.settings.silent_redirect_uri;\n        if (!url) {\n            logger.throw(new Error(\"No silent_redirect_uri configured\"));\n        }\n\n        const user = await this._loadUser();\n        const handle = await this._iframeNavigator.prepare({ silentRequestTimeoutInSeconds });\n        const navResponse = await this._signinStart({\n            request_type: \"si:s\", // this acts like a signin silent\n            redirect_uri: url,\n            prompt: \"none\",\n            id_token_hint: this.settings.includeIdTokenInSilentRenew ? user?.id_token : undefined,\n            response_type: this.settings.query_status_response_type,\n            scope: \"openid\",\n            skipUserInfo: true,\n            ...requestArgs,\n        }, handle);\n        try {\n            const extraHeaders: Record<string, ExtraHeader> = {};\n            const signinResponse = await this._client.processSigninResponse(navResponse.url, extraHeaders);\n            logger.debug(\"got signin response\");\n\n            if (signinResponse.session_state && signinResponse.profile.sub) {\n                logger.info(\"success for subject\", signinResponse.profile.sub);\n                return {\n                    session_state: signinResponse.session_state,\n                    sub: signinResponse.profile.sub,\n                };\n            }\n\n            logger.info(\"success, user not authenticated\");\n            return null;\n        } catch (err) {\n            if (this.settings.monitorAnonymousSession && err instanceof ErrorResponse) {\n                switch (err.error) {\n                    case \"login_required\":\n                    case \"consent_required\":\n                    case \"interaction_required\":\n                    case \"account_selection_required\":\n                        logger.info(\"success for anonymous user\");\n                        return {\n                            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n                            session_state: err.session_state!,\n                        };\n                }\n            }\n            throw err;\n        }\n    }\n\n    protected async _signin(args: CreateSigninRequestArgs, handle: IWindow, verifySub?: string): Promise<User> {\n        const navResponse = await this._signinStart(args, handle);\n        return await this._signinEnd(navResponse.url, verifySub);\n    }\n\n    protected async _signinStart(args: CreateSigninRequestArgs, handle: IWindow): Promise<NavigateResponse> {\n        const logger = this._logger.create(\"_signinStart\");\n\n        try {\n            const signinRequest = await this._client.createSigninRequest(args);\n            logger.debug(\"got signin request\");\n\n            return await handle.navigate({\n                url: signinRequest.url,\n                state: signinRequest.state.id,\n                response_mode: signinRequest.state.response_mode,\n                scriptOrigin: this.settings.iframeScriptOrigin,\n            });\n        } catch (err) {\n            logger.debug(\"error after preparing navigator, closing navigator window\");\n            handle.close();\n            throw err;\n        }\n    }\n\n    protected async _signinEnd(url: string, verifySub?: string): Promise<User> {\n        const logger = this._logger.create(\"_signinEnd\");\n        const extraHeaders: Record<string, ExtraHeader> = {};\n        const signinResponse = await this._client.processSigninResponse(url, extraHeaders);\n        logger.debug(\"got signin response\");\n\n        const user = await this._buildUser(signinResponse, verifySub);\n        return user;\n    }\n\n    protected async _buildUser(signinResponse: SigninResponse, verifySub?: string) {\n        const logger = this._logger.create(\"_buildUser\");\n        const user = new User(signinResponse);\n        if (verifySub) {\n            if (verifySub !== user.profile.sub) {\n                logger.debug(\"current user does not match user returned from signin. sub from signin:\", user.profile.sub);\n                throw new ErrorResponse({ ...signinResponse, error: \"login_required\" });\n            }\n            logger.debug(\"current user matches user returned from signin\");\n        }\n\n        await this.storeUser(user);\n        logger.debug(\"user stored\");\n        await this._events.load(user);\n\n        return user;\n    }\n\n    /**\n     * Trigger a redirect of the current window to the end session endpoint.\n     *\n     * @returns A promise\n     */\n    public async signoutRedirect(args: SignoutRedirectArgs = {}): Promise<void> {\n        const logger = this._logger.create(\"signoutRedirect\");\n        const {\n            redirectMethod,\n            ...requestArgs\n        } = args;\n        const handle = await this._redirectNavigator.prepare({ redirectMethod });\n        await this._signoutStart({\n            request_type: \"so:r\",\n            post_logout_redirect_uri: this.settings.post_logout_redirect_uri,\n            ...requestArgs,\n        }, handle);\n        logger.info(\"success\");\n    }\n\n    /**\n     * Process response (callback) from the end session endpoint.\n     * It is recommended to use {@link UserManager.signoutCallback} instead.\n     *\n     * @returns A promise containing signout response\n     *\n     * @see {@link UserManager.signoutCallback}\n     */\n    public async signoutRedirectCallback(url = window.location.href): Promise<SignoutResponse> {\n        const logger = this._logger.create(\"signoutRedirectCallback\");\n        const response = await this._signoutEnd(url);\n        logger.info(\"success\");\n        return response;\n    }\n\n    /**\n     * Trigger a redirect of a popup window to the end session endpoint.\n     *\n     * @returns A promise\n     */\n    public async signoutPopup(args: SignoutPopupArgs = {}): Promise<void> {\n        const logger = this._logger.create(\"signoutPopup\");\n        const {\n            popupWindowFeatures,\n            popupWindowTarget,\n            popupSignal,\n            ...requestArgs\n        } = args;\n        const url = this.settings.popup_post_logout_redirect_uri;\n\n        const handle = await this._popupNavigator.prepare({ popupWindowFeatures, popupWindowTarget, popupSignal });\n        await this._signout({\n            request_type: \"so:p\",\n            post_logout_redirect_uri: url,\n            // we're putting a dummy entry in here because we\n            // need a unique id from the state for notification\n            // to the parent window, which is necessary if we\n            // plan to return back to the client after signout\n            // and so we can close the popup after signout\n            state: url == null ? undefined : {},\n            ...requestArgs,\n        }, handle);\n        logger.info(\"success\");\n    }\n\n    /**\n     * Process response (callback) from the end session endpoint from a popup window.\n     * It is recommended to use {@link UserManager.signoutCallback} instead.\n     *\n     * @returns A promise\n     *\n     * @see {@link UserManager.signoutCallback}\n     */\n    public async signoutPopupCallback(url = window.location.href, keepOpen = false): Promise<void> {\n        const logger = this._logger.create(\"signoutPopupCallback\");\n        await this._popupNavigator.callback(url, { keepOpen });\n        logger.info(\"success\");\n    }\n\n    protected async _signout(args: CreateSignoutRequestArgs, handle: IWindow): Promise<SignoutResponse> {\n        const navResponse = await this._signoutStart(args, handle);\n        return await this._signoutEnd(navResponse.url);\n    }\n\n    protected async _signoutStart(args: CreateSignoutRequestArgs = {}, handle: IWindow): Promise<NavigateResponse> {\n        const logger = this._logger.create(\"_signoutStart\");\n\n        try {\n            const user = await this._loadUser();\n            logger.debug(\"loaded current user from storage\");\n\n            if (this.settings.revokeTokensOnSignout) {\n                await this._revokeInternal(user);\n            }\n\n            const id_token = args.id_token_hint || user && user.id_token;\n            if (id_token) {\n                logger.debug(\"setting id_token_hint in signout request\");\n                args.id_token_hint = id_token;\n            }\n\n            await this.removeUser();\n            logger.debug(\"user removed, creating signout request\");\n\n            const signoutRequest = await this._client.createSignoutRequest(args);\n            logger.debug(\"got signout request\");\n\n            return await handle.navigate({\n                url: signoutRequest.url,\n                state: signoutRequest.state?.id,\n                scriptOrigin: this.settings.iframeScriptOrigin,\n            });\n        } catch (err) {\n            logger.debug(\"error after preparing navigator, closing navigator window\");\n            handle.close();\n            throw err;\n        }\n    }\n\n    protected async _signoutEnd(url: string): Promise<SignoutResponse> {\n        const logger = this._logger.create(\"_signoutEnd\");\n        const signoutResponse = await this._client.processSignoutResponse(url);\n        logger.debug(\"got signout response\");\n\n        return signoutResponse;\n    }\n\n    /**\n     * Trigger a silent request (via an iframe) to the end session endpoint.\n     *\n     * @returns A promise\n     */\n    public async signoutSilent(args: SignoutSilentArgs = {}): Promise<void> {\n        const logger = this._logger.create(\"signoutSilent\");\n        const {\n            silentRequestTimeoutInSeconds,\n            ...requestArgs\n        } = args;\n\n        const id_token_hint = this.settings.includeIdTokenInSilentSignout\n            ? (await this._loadUser())?.id_token\n            : undefined;\n\n        const url = this.settings.popup_post_logout_redirect_uri;\n        const handle = await this._iframeNavigator.prepare({ silentRequestTimeoutInSeconds });\n        await this._signout({\n            request_type: \"so:s\",\n            post_logout_redirect_uri: url,\n            id_token_hint: id_token_hint,\n            ...requestArgs,\n        }, handle);\n\n        logger.info(\"success\");\n    }\n\n    /**\n     * Notify the parent window of response (callback) from the end session endpoint.\n     * It is recommended to use {@link UserManager.signoutCallback} instead.\n     *\n     * @returns A promise\n     *\n     * @see {@link UserManager.signoutCallback}\n     */\n    public async signoutSilentCallback(url = window.location.href): Promise<void> {\n        const logger = this._logger.create(\"signoutSilentCallback\");\n        await this._iframeNavigator.callback(url);\n        logger.info(\"success\");\n    }\n\n    public async revokeTokens(types?: RevokeTokensTypes): Promise<void> {\n        const user = await this._loadUser();\n        await this._revokeInternal(user, types);\n    }\n\n    protected async _revokeInternal(user: User | null, types = this.settings.revokeTokenTypes): Promise<void> {\n        const logger = this._logger.create(\"_revokeInternal\");\n        if (!user) return;\n\n        const typesPresent = types.filter(type => typeof user[type] === \"string\");\n\n        if (!typesPresent.length) {\n            logger.debug(\"no need to revoke due to no token(s)\");\n            return;\n        }\n\n        // don't Promise.all, order matters\n        for (const type of typesPresent) {\n            await this._client.revokeToken(\n                user[type]!, // eslint-disable-line @typescript-eslint/no-non-null-assertion\n                type,\n            );\n            logger.info(`${type} revoked successfully`);\n            if (type !== \"access_token\") {\n                user[type] = null as never;\n            }\n        }\n\n        await this.storeUser(user);\n        logger.debug(\"user stored\");\n        await this._events.load(user);\n    }\n\n    /**\n     * Enables silent renew for the `UserManager`.\n     */\n    public startSilentRenew(): void {\n        this._logger.create(\"startSilentRenew\");\n        void this._silentRenewService.start();\n    }\n\n    /**\n     * Disables silent renew for the `UserManager`.\n     */\n    public stopSilentRenew(): void {\n        this._silentRenewService.stop();\n    }\n\n    protected get _userStoreKey(): string {\n        return `user:${this.settings.authority}:${this.settings.client_id}`;\n    }\n\n    protected async _loadUser(): Promise<User | null> {\n        const logger = this._logger.create(\"_loadUser\");\n        const storageString = await this.settings.userStore.get(this._userStoreKey);\n        if (storageString) {\n            logger.debug(\"user storageString loaded\");\n            return User.fromStorageString(storageString);\n        }\n\n        logger.debug(\"no user storageString\");\n        return null;\n    }\n\n    public async storeUser(user: User | null): Promise<void> {\n        const logger = this._logger.create(\"storeUser\");\n        if (user) {\n            logger.debug(\"storing user\");\n            const storageString = user.toStorageString();\n            await this.settings.userStore.set(this._userStoreKey, storageString);\n        } else {\n            this._logger.debug(\"removing user\");\n            await this.settings.userStore.remove(this._userStoreKey);\n            if (this.settings.dpop) {\n                await this.settings.dpop.store.remove(this.settings.client_id);\n            }\n        }\n    }\n\n    /**\n     * Removes stale state entries in storage for incomplete authorize requests.\n     */\n    public async clearStaleState(): Promise<void> {\n        await this._client.clearStaleState();\n    }\n\n    /**\n     * Dynamically generates a DPoP proof for a given user, URL and optional Http method.\n     * This method is useful when you need to make a request to a resource server\n     * with fetch or similar, and you need to include a DPoP proof in a DPoP header.\n     * @param url - The URL to generate the DPoP proof for\n     * @param user - The user to generate the DPoP proof for\n     * @param httpMethod - Optional, defaults to \"GET\"\n     * @param nonce - Optional nonce provided by the resource server\n     *\n     * @returns A promise containing the DPoP proof or undefined if DPoP is not enabled/no user is found.\n     */\n    public async dpopProof(url: string, user: User, httpMethod?: string, nonce?: string): Promise<string | undefined> {\n        const dpopState = await this.settings.dpop?.store?.get(this.settings.client_id);\n        if (dpopState) {\n            return await CryptoUtils.generateDPoPProof({\n                url,\n                accessToken: user?.access_token,\n                httpMethod: httpMethod,\n                keyPair: dpopState.keys,\n                nonce,\n            });\n        }\n        return undefined;\n    }\n\n    async generateDPoPJkt(dpopSettings: DPoPSettings): Promise<string | undefined> {\n        let dpopState = await dpopSettings.store.get(this.settings.client_id);\n        if (!dpopState) {\n            const dpopKeys = await CryptoUtils.generateDPoPKeys();\n            dpopState = new DPoPState(dpopKeys);\n            await dpopSettings.store.set(this.settings.client_id, dpopState);\n        }\n        return await CryptoUtils.generateDPoPJkt(dpopState.keys);\n    }\n}\n","// @ts-expect-error avoid enabling resolveJsonModule to keep build process simple\nimport { version } from \"../package.json\";\n\n/**\n * @public\n */\nexport const Version: string = version;\n","{\n  \"name\": \"oidc-client-ts\",\n  \"version\": \"3.1.0\",\n  \"description\": \"OpenID Connect (OIDC) & OAuth2 client library\",\n  \"repository\": {\n    \"type\": \"git\",\n    \"url\": \"git+https://github.com/authts/oidc-client-ts.git\"\n  },\n  \"homepage\": \"https://github.com/authts/oidc-client-ts#readme\",\n  \"license\": \"Apache-2.0\",\n  \"main\": \"dist/umd/oidc-client-ts.js\",\n  \"types\": \"dist/types/oidc-client-ts.d.ts\",\n  \"exports\": {\n    \".\": {\n      \"types\": \"./dist/types/oidc-client-ts.d.ts\",\n      \"import\": \"./dist/esm/oidc-client-ts.js\",\n      \"require\": \"./dist/umd/oidc-client-ts.js\"\n    },\n    \"./package.json\": \"./package.json\"\n  },\n  \"files\": [\n    \"dist\"\n  ],\n  \"keywords\": [\n    \"authentication\",\n    \"oauth2\",\n    \"oidc\",\n    \"openid\",\n    \"OpenID Connect\"\n  ],\n  \"scripts\": {\n    \"build\": \"node scripts/build.js && npm run build-types\",\n    \"build-types\": \"tsc -p tsconfig.build.json && api-extractor run\",\n    \"clean\": \"git clean -fdX dist lib *.tsbuildinfo\",\n    \"prepack\": \"npm run build\",\n    \"test\": \"tsc && jest\",\n    \"typedoc\": \"typedoc\",\n    \"lint\": \"eslint --max-warnings=0 --cache .\",\n    \"prepare\": \"husky\"\n  },\n  \"dependencies\": {\n    \"jwt-decode\": \"^4.0.0\"\n  },\n  \"devDependencies\": {\n    \"@microsoft/api-extractor\": \"^7.47.2\",\n    \"@testing-library/jest-dom\": \"^6.4.6\",\n    \"@types/jest\": \"^29.5.12\",\n    \"@types/node\": \"^22.4.1\",\n    \"@typescript-eslint/eslint-plugin\": \"^7.16.1\",\n    \"@typescript-eslint/parser\": \"^7.16.1\",\n    \"esbuild\": \"^0.24.0\",\n    \"eslint\": \"^8.57.0\",\n    \"eslint-plugin-testing-library\": \"^6.2.2\",\n    \"http-proxy-middleware\": \"^3.0.0\",\n    \"fake-indexeddb\": \"^6.0.0\",\n    \"husky\": \"^9.0.11\",\n    \"jest\": \"^29.7.0\",\n    \"jest-environment-jsdom\": \"^29.7.0\",\n    \"jest-mock\": \"^29.7.0\",\n    \"jose\": \"^5.6.3\",\n    \"lint-staged\": \"^15.2.7\",\n    \"ts-jest\": \"^29.2.2\",\n    \"typedoc\": \"^0.26.4\",\n    \"typescript\": \"~5.4.2\",\n    \"yn\": \"^5.0.0\"\n  },\n  \"engines\": {\n    \"node\": \">=18\"\n  },\n  \"lint-staged\": {\n    \"*.{js,jsx,ts,tsx}\": \"eslint --cache --fix\"\n  }\n}\n","import { DPoPState, type DPoPStore } from \"./DPoPStore\";\n\n/**\n * Provides a default implementation of the DPoP store using IndexedDB.\n *\n * @public\n */\nexport class IndexedDbDPoPStore implements DPoPStore {\n    readonly _dbName: string = \"oidc\";\n    readonly _storeName: string = \"dpop\";\n\n    public async set(key: string, value: DPoPState): Promise<void> {\n        const store = await this.createStore(this._dbName, this._storeName);\n        await store(\"readwrite\", (str: IDBObjectStore) => {\n            str.put(value, key);\n            return this.promisifyRequest(str.transaction);\n        });\n    }\n\n    public async get(key: string): Promise<DPoPState> {\n        const store = await this.createStore(this._dbName, this._storeName);\n        return await store(\"readonly\", (str) => {\n            return this.promisifyRequest(str.get(key));\n        }) as DPoPState;\n    }\n\n    public async remove(key: string): Promise<DPoPState> {\n        const item = await this.get(key);\n        const store = await this.createStore(this._dbName, this._storeName);\n        await store(\"readwrite\", (str) => {\n            return this.promisifyRequest(str.delete(key));\n        });\n        return item;\n    }\n\n    public async getAllKeys(): Promise<string[]> {\n        const store = await this.createStore(this._dbName, this._storeName);\n        return await store(\"readonly\", (str) => {\n            return this.promisifyRequest(str.getAllKeys());\n        }) as string[];\n    }\n\n    promisifyRequest<T = undefined>(\n        request: IDBRequest<T> | IDBTransaction): Promise<T> {\n        return new Promise<T>((resolve, reject) => {\n            (request as IDBTransaction).oncomplete = (request as IDBRequest<T>).onsuccess = () => resolve((request as IDBRequest<T>).result);\n            (request as IDBTransaction).onabort = (request as IDBRequest<T>).onerror = () => reject((request as IDBRequest<T>).error);\n        });\n    }\n\n    async createStore<T>(\n        dbName: string,\n        storeName: string,\n    ): Promise<(txMode: IDBTransactionMode, callback: (store: IDBObjectStore) => T | PromiseLike<T>) => Promise<T>> {\n        const request = indexedDB.open(dbName);\n        request.onupgradeneeded = () => request.result.createObjectStore(storeName);\n        const db = await this.promisifyRequest<IDBDatabase>(request);\n\n        return async (\n            txMode: IDBTransactionMode,\n            callback: (store: IDBObjectStore) => T | PromiseLike<T>,\n        ) => {\n            const tx = db.transaction(storeName, txMode);\n            const store = tx.objectStore(storeName);\n            return await callback(store);\n        };\n    }\n}\n","export default __webpack_public_path__ + \"opus-decoderWorker.min.f69d392.js\";","export default __webpack_public_path__ + \"decoderWorker.min.wasm\";","export default __webpack_public_path__ + \"opus-encoderWorker.min.8bd8ff5.js\";","!function(e,t){\"object\"==typeof exports&&\"object\"==typeof module?module.exports=t():\"function\"==typeof define&&define.amd?define([],t):\"object\"==typeof exports?exports.Recorder=t():e.Recorder=t()}(\"undefined\"!=typeof self?self:this,(function(){return function(e){var t={};function o(n){if(t[n])return t[n].exports;var i=t[n]={i:n,l:!1,exports:{}};return e[n].call(i.exports,i,i.exports,o),i.l=!0,i.exports}return o.m=e,o.c=t,o.d=function(e,t,n){o.o(e,t)||Object.defineProperty(e,t,{enumerable:!0,get:n})},o.r=function(e){\"undefined\"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:\"Module\"}),Object.defineProperty(e,\"__esModule\",{value:!0})},o.t=function(e,t){if(1&t&&(e=o(e)),8&t)return e;if(4&t&&\"object\"==typeof e&&e&&e.__esModule)return e;var n=Object.create(null);if(o.r(n),Object.defineProperty(n,\"default\",{enumerable:!0,value:e}),2&t&&\"string\"!=typeof e)for(var i in e)o.d(n,i,function(t){return e[t]}.bind(null,i));return n},o.n=function(e){var t=e&&e.__esModule?function(){return e.default}:function(){return e};return o.d(t,\"a\",t),t},o.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},o.p=\"\",o(o.s=0)}([function(e,t,o){\"use strict\";(function(t){function o(e,t){if(null==e)return{};var o,n,i=function(e,t){if(null==e)return{};var o,n,i={},r=Object.keys(e);for(n=0;n<r.length;n++)o=r[n],t.indexOf(o)>=0||(i[o]=e[o]);return i}(e,t);if(Object.getOwnPropertySymbols){var r=Object.getOwnPropertySymbols(e);for(n=0;n<r.length;n++)o=r[n],t.indexOf(o)>=0||Object.prototype.propertyIsEnumerable.call(e,o)&&(i[o]=e[o])}return i}var n=t.AudioContext||t.webkitAudioContext,i=function e(){var t=this,o=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};if(!e.isRecordingSupported())throw new Error(\"Recording is not supported in this browser\");this.state=\"inactive\",this.config=Object.assign({bufferLength:4096,encoderApplication:2049,encoderFrameSize:20,encoderPath:\"encoderWorker.min.js\",encoderSampleRate:48e3,maxFramesPerPage:40,mediaTrackConstraints:!0,monitorGain:0,numberOfChannels:1,recordingGain:1,resampleQuality:3,streamPages:!1,wavBitDepth:16,sourceNode:{context:null}},o),this.encodedSamplePosition=0,this.initAudioContext(),this.initialize=this.initWorklet().then((function(){return t.initEncoder()}))};i.isRecordingSupported=function(){var e=t.navigator&&t.navigator.mediaDevices&&t.navigator.mediaDevices.getUserMedia;return n&&e&&t.WebAssembly},i.version=\"8.0.5\",i.prototype.clearStream=function(){this.stream&&(this.stream.getTracks?this.stream.getTracks().forEach((function(e){return e.stop()})):this.stream.stop())},i.prototype.close=function(){return this.monitorGainNode.disconnect(),this.recordingGainNode.disconnect(),this.sourceNode&&this.sourceNode.disconnect(),this.clearStream(),this.encoder&&(this.encoderNode.disconnect(),this.encoder.postMessage({command:\"close\"})),this.config.sourceNode.context?Promise.resolve():this.audioContext.close()},i.prototype.encodeBuffers=function(e){if(\"recording\"===this.state){for(var t=[],o=0;o<e.numberOfChannels;o++)t[o]=e.getChannelData(o);this.encoder.postMessage({command:\"encode\",buffers:t})}},i.prototype.initAudioContext=function(){this.audioContext=this.config.sourceNode.context?this.config.sourceNode.context:new n,this.monitorGainNode=this.audioContext.createGain(),this.setMonitorGain(this.config.monitorGain),this.recordingGainNode=this.audioContext.createGain(),this.setRecordingGain(this.config.recordingGain)},i.prototype.initEncoder=function(){var e=this;this.audioContext.audioWorklet?(this.encoderNode=new AudioWorkletNode(this.audioContext,\"encoder-worklet\",{numberOfOutputs:0}),this.encoder=this.encoderNode.port):(console.log(\"audioWorklet support not detected. Falling back to scriptProcessor\"),this.encodeBuffers=function(){return delete e.encodeBuffers},this.encoderNode=this.audioContext.createScriptProcessor(this.config.bufferLength,this.config.numberOfChannels,this.config.numberOfChannels),this.encoderNode.onaudioprocess=function(t){var o=t.inputBuffer;return e.encodeBuffers(o)},this.encoderNode.connect(this.audioContext.destination),this.encoder=new t.Worker(this.config.encoderPath))},i.prototype.initSourceNode=function(){var e=this;return this.config.sourceNode.context?(this.sourceNode=this.config.sourceNode,Promise.resolve()):t.navigator.mediaDevices.getUserMedia({audio:this.config.mediaTrackConstraints}).then((function(t){e.stream=t,e.sourceNode=e.audioContext.createMediaStreamSource(t)}))},i.prototype.initWorker=function(){var e=this,t=(this.config.streamPages?this.streamPage:this.storePage).bind(this);return this.recordedPages=[],this.totalLength=0,new Promise((function(n){e.encoder.addEventListener(\"message\",(function o(i){var r=i.data;switch(r.message){case\"ready\":n();break;case\"page\":e.encodedSamplePosition=r.samplePosition,t(r.page);break;case\"done\":e.encoder.removeEventListener(\"message\",o),e.finish()}})),e.encoder.start&&e.encoder.start();var i=e.config,r=(i.sourceNode,o(i,[\"sourceNode\"]));e.encoder.postMessage(Object.assign({command:\"init\",originalSampleRate:e.audioContext.sampleRate,wavSampleRate:e.audioContext.sampleRate},r))}))},i.prototype.initWorklet=function(){return this.audioContext.audioWorklet?this.audioContext.audioWorklet.addModule(this.config.encoderPath):Promise.resolve()},i.prototype.pause=function(e){var t=this;if(\"recording\"===this.state)return this.state=\"paused\",this.recordingGainNode.disconnect(),e&&this.config.streamPages?new Promise((function(e){t.encoder.addEventListener(\"message\",(function o(n){\"flushed\"===n.data.message&&(t.encoder.removeEventListener(\"message\",o),t.onpause(),e())})),t.encoder.start&&t.encoder.start(),t.encoder.postMessage({command:\"flush\"})})):(this.onpause(),Promise.resolve())},i.prototype.resume=function(){\"paused\"===this.state&&(this.state=\"recording\",this.recordingGainNode.connect(this.encoderNode),this.onresume())},i.prototype.setRecordingGain=function(e){this.config.recordingGain=e,this.recordingGainNode&&this.audioContext&&this.recordingGainNode.gain.setTargetAtTime(e,this.audioContext.currentTime,.01)},i.prototype.setMonitorGain=function(e){this.config.monitorGain=e,this.monitorGainNode&&this.audioContext&&this.monitorGainNode.gain.setTargetAtTime(e,this.audioContext.currentTime,.01)},i.prototype.start=function(){var e=this;return\"inactive\"===this.state?(this.state=\"loading\",this.encodedSamplePosition=0,this.audioContext.resume().then((function(){return e.initialize})).then((function(){return Promise.all([e.initSourceNode(),e.initWorker()])})).then((function(){e.state=\"recording\",e.encoder.postMessage({command:\"getHeaderPages\"}),e.sourceNode.connect(e.monitorGainNode),e.sourceNode.connect(e.recordingGainNode),e.monitorGainNode.connect(e.audioContext.destination),e.recordingGainNode.connect(e.encoderNode),e.onstart()})).catch((function(t){throw e.state=\"inactive\",t}))):Promise.resolve()},i.prototype.stop=function(){var e=this;return\"paused\"===this.state||\"recording\"===this.state?(this.state=\"inactive\",this.recordingGainNode.connect(this.encoderNode),this.monitorGainNode.disconnect(),this.clearStream(),new Promise((function(t){e.encoder.addEventListener(\"message\",(function o(n){\"done\"===n.data.message&&(e.encoder.removeEventListener(\"message\",o),t())})),e.encoder.start&&e.encoder.start(),e.encoder.postMessage({command:\"done\"})}))):Promise.resolve()},i.prototype.storePage=function(e){this.recordedPages.push(e),this.totalLength+=e.length},i.prototype.streamPage=function(e){this.ondataavailable(e)},i.prototype.finish=function(){if(!this.config.streamPages){var e=new Uint8Array(this.totalLength);this.recordedPages.reduce((function(t,o){return e.set(o,t),t+o.length}),0),this.ondataavailable(e)}this.onstop()},i.prototype.ondataavailable=function(){},i.prototype.onpause=function(){},i.prototype.onresume=function(){},i.prototype.onstart=function(){},i.prototype.onstop=function(){},e.exports=i}).call(this,o(1))},function(e,t){var o;o=function(){return this}();try{o=o||new Function(\"return this\")()}catch(e){\"object\"==typeof window&&(o=window)}e.exports=o}])}));","export default __webpack_public_path__ + \"wave-encoderWorker.min.9f737c9.js\";","/**\n * Srcset Parser\n *\n * By Alex Bell |  MIT License\n *\n * JS Parser for the string value that appears in markup <img srcset=\"here\">\n *\n * @returns Array [{url: _, d: _, w: _, h:_}, ...]\n *\n * Based super duper closely on the reference algorithm at:\n * https://html.spec.whatwg.org/multipage/embedded-content.html#parse-a-srcset-attribute\n *\n * Most comments are copied in directly from the spec\n * (except for comments in parens).\n */\n\n(function (root, factory) {\n\tif (typeof define === 'function' && define.amd) {\n\t\t// AMD. Register as an anonymous module.\n\t\tdefine([], factory);\n\t} else if (typeof module === 'object' && module.exports) {\n\t\t// Node. Does not work with strict CommonJS, but\n\t\t// only CommonJS-like environments that support module.exports,\n\t\t// like Node.\n\t\tmodule.exports = factory();\n\t} else {\n\t\t// Browser globals (root is window)\n\t\troot.parseSrcset = factory();\n\t}\n}(this, function () {\n\n\t// 1. Let input be the value passed to this algorithm.\n\treturn function (input) {\n\n\t\t// UTILITY FUNCTIONS\n\n\t\t// Manual is faster than RegEx\n\t\t// http://bjorn.tipling.com/state-and-regular-expressions-in-javascript\n\t\t// http://jsperf.com/whitespace-character/5\n\t\tfunction isSpace(c) {\n\t\t\treturn (c === \"\\u0020\" || // space\n\t\t\tc === \"\\u0009\" || // horizontal tab\n\t\t\tc === \"\\u000A\" || // new line\n\t\t\tc === \"\\u000C\" || // form feed\n\t\t\tc === \"\\u000D\");  // carriage return\n\t\t}\n\n\t\tfunction collectCharacters(regEx) {\n\t\t\tvar chars,\n\t\t\t\tmatch = regEx.exec(input.substring(pos));\n\t\t\tif (match) {\n\t\t\t\tchars = match[ 0 ];\n\t\t\t\tpos += chars.length;\n\t\t\t\treturn chars;\n\t\t\t}\n\t\t}\n\n\t\tvar inputLength = input.length,\n\n\t\t\t// (Don't use \\s, to avoid matching non-breaking space)\n\t\t\tregexLeadingSpaces = /^[ \\t\\n\\r\\u000c]+/,\n\t\t\tregexLeadingCommasOrSpaces = /^[, \\t\\n\\r\\u000c]+/,\n\t\t\tregexLeadingNotSpaces = /^[^ \\t\\n\\r\\u000c]+/,\n\t\t\tregexTrailingCommas = /[,]+$/,\n\t\t\tregexNonNegativeInteger = /^\\d+$/,\n\n\t\t\t// ( Positive or negative or unsigned integers or decimals, without or without exponents.\n\t\t\t// Must include at least one digit.\n\t\t\t// According to spec tests any decimal point must be followed by a digit.\n\t\t\t// No leading plus sign is allowed.)\n\t\t\t// https://html.spec.whatwg.org/multipage/infrastructure.html#valid-floating-point-number\n\t\t\tregexFloatingPoint = /^-?(?:[0-9]+|[0-9]*\\.[0-9]+)(?:[eE][+-]?[0-9]+)?$/,\n\n\t\t\turl,\n\t\t\tdescriptors,\n\t\t\tcurrentDescriptor,\n\t\t\tstate,\n\t\t\tc,\n\n\t\t\t// 2. Let position be a pointer into input, initially pointing at the start\n\t\t\t//    of the string.\n\t\t\tpos = 0,\n\n\t\t\t// 3. Let candidates be an initially empty source set.\n\t\t\tcandidates = [];\n\n\t\t// 4. Splitting loop: Collect a sequence of characters that are space\n\t\t//    characters or U+002C COMMA characters. If any U+002C COMMA characters\n\t\t//    were collected, that is a parse error.\n\t\twhile (true) {\n\t\t\tcollectCharacters(regexLeadingCommasOrSpaces);\n\n\t\t\t// 5. If position is past the end of input, return candidates and abort these steps.\n\t\t\tif (pos >= inputLength) {\n\t\t\t\treturn candidates; // (we're done, this is the sole return path)\n\t\t\t}\n\n\t\t\t// 6. Collect a sequence of characters that are not space characters,\n\t\t\t//    and let that be url.\n\t\t\turl = collectCharacters(regexLeadingNotSpaces);\n\n\t\t\t// 7. Let descriptors be a new empty list.\n\t\t\tdescriptors = [];\n\n\t\t\t// 8. If url ends with a U+002C COMMA character (,), follow these substeps:\n\t\t\t//\t\t(1). Remove all trailing U+002C COMMA characters from url. If this removed\n\t\t\t//         more than one character, that is a parse error.\n\t\t\tif (url.slice(-1) === \",\") {\n\t\t\t\turl = url.replace(regexTrailingCommas, \"\");\n\t\t\t\t// (Jump ahead to step 9 to skip tokenization and just push the candidate).\n\t\t\t\tparseDescriptors();\n\n\t\t\t\t//\tOtherwise, follow these substeps:\n\t\t\t} else {\n\t\t\t\ttokenize();\n\t\t\t} // (close else of step 8)\n\n\t\t\t// 16. Return to the step labeled splitting loop.\n\t\t} // (Close of big while loop.)\n\n\t\t/**\n\t\t * Tokenizes descriptor properties prior to parsing\n\t\t * Returns undefined.\n\t\t */\n\t\tfunction tokenize() {\n\n\t\t\t// 8.1. Descriptor tokeniser: Skip whitespace\n\t\t\tcollectCharacters(regexLeadingSpaces);\n\n\t\t\t// 8.2. Let current descriptor be the empty string.\n\t\t\tcurrentDescriptor = \"\";\n\n\t\t\t// 8.3. Let state be in descriptor.\n\t\t\tstate = \"in descriptor\";\n\n\t\t\twhile (true) {\n\n\t\t\t\t// 8.4. Let c be the character at position.\n\t\t\t\tc = input.charAt(pos);\n\n\t\t\t\t//  Do the following depending on the value of state.\n\t\t\t\t//  For the purpose of this step, \"EOF\" is a special character representing\n\t\t\t\t//  that position is past the end of input.\n\n\t\t\t\t// In descriptor\n\t\t\t\tif (state === \"in descriptor\") {\n\t\t\t\t\t// Do the following, depending on the value of c:\n\n\t\t\t\t\t// Space character\n\t\t\t\t\t// If current descriptor is not empty, append current descriptor to\n\t\t\t\t\t// descriptors and let current descriptor be the empty string.\n\t\t\t\t\t// Set state to after descriptor.\n\t\t\t\t\tif (isSpace(c)) {\n\t\t\t\t\t\tif (currentDescriptor) {\n\t\t\t\t\t\t\tdescriptors.push(currentDescriptor);\n\t\t\t\t\t\t\tcurrentDescriptor = \"\";\n\t\t\t\t\t\t\tstate = \"after descriptor\";\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// U+002C COMMA (,)\n\t\t\t\t\t\t// Advance position to the next character in input. If current descriptor\n\t\t\t\t\t\t// is not empty, append current descriptor to descriptors. Jump to the step\n\t\t\t\t\t\t// labeled descriptor parser.\n\t\t\t\t\t} else if (c === \",\") {\n\t\t\t\t\t\tpos += 1;\n\t\t\t\t\t\tif (currentDescriptor) {\n\t\t\t\t\t\t\tdescriptors.push(currentDescriptor);\n\t\t\t\t\t\t}\n\t\t\t\t\t\tparseDescriptors();\n\t\t\t\t\t\treturn;\n\n\t\t\t\t\t\t// U+0028 LEFT PARENTHESIS (()\n\t\t\t\t\t\t// Append c to current descriptor. Set state to in parens.\n\t\t\t\t\t} else if (c === \"\\u0028\") {\n\t\t\t\t\t\tcurrentDescriptor = currentDescriptor + c;\n\t\t\t\t\t\tstate = \"in parens\";\n\n\t\t\t\t\t\t// EOF\n\t\t\t\t\t\t// If current descriptor is not empty, append current descriptor to\n\t\t\t\t\t\t// descriptors. Jump to the step labeled descriptor parser.\n\t\t\t\t\t} else if (c === \"\") {\n\t\t\t\t\t\tif (currentDescriptor) {\n\t\t\t\t\t\t\tdescriptors.push(currentDescriptor);\n\t\t\t\t\t\t}\n\t\t\t\t\t\tparseDescriptors();\n\t\t\t\t\t\treturn;\n\n\t\t\t\t\t\t// Anything else\n\t\t\t\t\t\t// Append c to current descriptor.\n\t\t\t\t\t} else {\n\t\t\t\t\t\tcurrentDescriptor = currentDescriptor + c;\n\t\t\t\t\t}\n\t\t\t\t\t// (end \"in descriptor\"\n\n\t\t\t\t\t// In parens\n\t\t\t\t} else if (state === \"in parens\") {\n\n\t\t\t\t\t// U+0029 RIGHT PARENTHESIS ())\n\t\t\t\t\t// Append c to current descriptor. Set state to in descriptor.\n\t\t\t\t\tif (c === \")\") {\n\t\t\t\t\t\tcurrentDescriptor = currentDescriptor + c;\n\t\t\t\t\t\tstate = \"in descriptor\";\n\n\t\t\t\t\t\t// EOF\n\t\t\t\t\t\t// Append current descriptor to descriptors. Jump to the step labeled\n\t\t\t\t\t\t// descriptor parser.\n\t\t\t\t\t} else if (c === \"\") {\n\t\t\t\t\t\tdescriptors.push(currentDescriptor);\n\t\t\t\t\t\tparseDescriptors();\n\t\t\t\t\t\treturn;\n\n\t\t\t\t\t\t// Anything else\n\t\t\t\t\t\t// Append c to current descriptor.\n\t\t\t\t\t} else {\n\t\t\t\t\t\tcurrentDescriptor = currentDescriptor + c;\n\t\t\t\t\t}\n\n\t\t\t\t\t// After descriptor\n\t\t\t\t} else if (state === \"after descriptor\") {\n\n\t\t\t\t\t// Do the following, depending on the value of c:\n\t\t\t\t\t// Space character: Stay in this state.\n\t\t\t\t\tif (isSpace(c)) {\n\n\t\t\t\t\t\t// EOF: Jump to the step labeled descriptor parser.\n\t\t\t\t\t} else if (c === \"\") {\n\t\t\t\t\t\tparseDescriptors();\n\t\t\t\t\t\treturn;\n\n\t\t\t\t\t\t// Anything else\n\t\t\t\t\t\t// Set state to in descriptor. Set position to the previous character in input.\n\t\t\t\t\t} else {\n\t\t\t\t\t\tstate = \"in descriptor\";\n\t\t\t\t\t\tpos -= 1;\n\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Advance position to the next character in input.\n\t\t\t\tpos += 1;\n\n\t\t\t\t// Repeat this step.\n\t\t\t} // (close while true loop)\n\t\t}\n\n\t\t/**\n\t\t * Adds descriptor properties to a candidate, pushes to the candidates array\n\t\t * @return undefined\n\t\t */\n\t\t// Declared outside of the while loop so that it's only created once.\n\t\tfunction parseDescriptors() {\n\n\t\t\t// 9. Descriptor parser: Let error be no.\n\t\t\tvar pError = false,\n\n\t\t\t\t// 10. Let width be absent.\n\t\t\t\t// 11. Let density be absent.\n\t\t\t\t// 12. Let future-compat-h be absent. (We're implementing it now as h)\n\t\t\t\tw, d, h, i,\n\t\t\t\tcandidate = {},\n\t\t\t\tdesc, lastChar, value, intVal, floatVal;\n\n\t\t\t// 13. For each descriptor in descriptors, run the appropriate set of steps\n\t\t\t// from the following list:\n\t\t\tfor (i = 0 ; i < descriptors.length; i++) {\n\t\t\t\tdesc = descriptors[ i ];\n\n\t\t\t\tlastChar = desc[ desc.length - 1 ];\n\t\t\t\tvalue = desc.substring(0, desc.length - 1);\n\t\t\t\tintVal = parseInt(value, 10);\n\t\t\t\tfloatVal = parseFloat(value);\n\n\t\t\t\t// If the descriptor consists of a valid non-negative integer followed by\n\t\t\t\t// a U+0077 LATIN SMALL LETTER W character\n\t\t\t\tif (regexNonNegativeInteger.test(value) && (lastChar === \"w\")) {\n\n\t\t\t\t\t// If width and density are not both absent, then let error be yes.\n\t\t\t\t\tif (w || d) {pError = true;}\n\n\t\t\t\t\t// Apply the rules for parsing non-negative integers to the descriptor.\n\t\t\t\t\t// If the result is zero, let error be yes.\n\t\t\t\t\t// Otherwise, let width be the result.\n\t\t\t\t\tif (intVal === 0) {pError = true;} else {w = intVal;}\n\n\t\t\t\t\t// If the descriptor consists of a valid floating-point number followed by\n\t\t\t\t\t// a U+0078 LATIN SMALL LETTER X character\n\t\t\t\t} else if (regexFloatingPoint.test(value) && (lastChar === \"x\")) {\n\n\t\t\t\t\t// If width, density and future-compat-h are not all absent, then let error\n\t\t\t\t\t// be yes.\n\t\t\t\t\tif (w || d || h) {pError = true;}\n\n\t\t\t\t\t// Apply the rules for parsing floating-point number values to the descriptor.\n\t\t\t\t\t// If the result is less than zero, let error be yes. Otherwise, let density\n\t\t\t\t\t// be the result.\n\t\t\t\t\tif (floatVal < 0) {pError = true;} else {d = floatVal;}\n\n\t\t\t\t\t// If the descriptor consists of a valid non-negative integer followed by\n\t\t\t\t\t// a U+0068 LATIN SMALL LETTER H character\n\t\t\t\t} else if (regexNonNegativeInteger.test(value) && (lastChar === \"h\")) {\n\n\t\t\t\t\t// If height and density are not both absent, then let error be yes.\n\t\t\t\t\tif (h || d) {pError = true;}\n\n\t\t\t\t\t// Apply the rules for parsing non-negative integers to the descriptor.\n\t\t\t\t\t// If the result is zero, let error be yes. Otherwise, let future-compat-h\n\t\t\t\t\t// be the result.\n\t\t\t\t\tif (intVal === 0) {pError = true;} else {h = intVal;}\n\n\t\t\t\t\t// Anything else, Let error be yes.\n\t\t\t\t} else {pError = true;}\n\t\t\t} // (close step 13 for loop)\n\n\t\t\t// 15. If error is still no, then append a new image source to candidates whose\n\t\t\t// URL is url, associated with a width width if not absent and a pixel\n\t\t\t// density density if not absent. Otherwise, there is a parse error.\n\t\t\tif (!pError) {\n\t\t\t\tcandidate.url = url;\n\t\t\t\tif (w) { candidate.w = w;}\n\t\t\t\tif (d) { candidate.d = d;}\n\t\t\t\tif (h) { candidate.h = h;}\n\t\t\t\tcandidates.push(candidate);\n\t\t\t} else if (console && console.log) {\n\t\t\t\tconsole.log(\"Invalid srcset descriptor found in '\" +\n\t\t\t\t\tinput + \"' at '\" + desc + \"'.\");\n\t\t\t}\n\t\t} // (close parseDescriptors fn)\n\n\t}\n}));\n","var x=String;\nvar create=function() {return {isColorSupported:false,reset:x,bold:x,dim:x,italic:x,underline:x,inverse:x,hidden:x,strikethrough:x,black:x,red:x,green:x,yellow:x,blue:x,magenta:x,cyan:x,white:x,gray:x,bgBlack:x,bgRed:x,bgGreen:x,bgYellow:x,bgBlue:x,bgMagenta:x,bgCyan:x,bgWhite:x,blackBright:x,redBright:x,greenBright:x,yellowBright:x,blueBright:x,magentaBright:x,cyanBright:x,whiteBright:x,bgBlackBright:x,bgRedBright:x,bgGreenBright:x,bgYellowBright:x,bgBlueBright:x,bgMagentaBright:x,bgCyanBright:x,bgWhiteBright:x}};\nmodule.exports=create();\nmodule.exports.createColors = create;\n","'use strict';\n\nmodule.exports = function(entry, count) {\n  var key;\n\n  if (count === 0 && 'zero' in entry) {\n    key = 'zero';\n  }\n\n  key = key || (count === 1 ? 'one' : 'other');\n\n  return entry[key];\n};\n","var crc32 = require('crc-32')\n\nmodule.exports = extractChunks\n\n// Used for fast-ish conversion between uint8s and uint32s/int32s.\n// Also required in order to remain agnostic for both Node Buffers and\n// Uint8Arrays.\nvar uint8 = new Uint8Array(4)\nvar int32 = new Int32Array(uint8.buffer)\nvar uint32 = new Uint32Array(uint8.buffer)\n\nfunction extractChunks (data) {\n  if (data[0] !== 0x89) throw new Error('Invalid .png file header')\n  if (data[1] !== 0x50) throw new Error('Invalid .png file header')\n  if (data[2] !== 0x4E) throw new Error('Invalid .png file header')\n  if (data[3] !== 0x47) throw new Error('Invalid .png file header')\n  if (data[4] !== 0x0D) throw new Error('Invalid .png file header: possibly caused by DOS-Unix line ending conversion?')\n  if (data[5] !== 0x0A) throw new Error('Invalid .png file header: possibly caused by DOS-Unix line ending conversion?')\n  if (data[6] !== 0x1A) throw new Error('Invalid .png file header')\n  if (data[7] !== 0x0A) throw new Error('Invalid .png file header: possibly caused by DOS-Unix line ending conversion?')\n\n  var ended = false\n  var chunks = []\n  var idx = 8\n\n  while (idx < data.length) {\n    // Read the length of the current chunk,\n    // which is stored as a Uint32.\n    uint8[3] = data[idx++]\n    uint8[2] = data[idx++]\n    uint8[1] = data[idx++]\n    uint8[0] = data[idx++]\n\n    // Chunk includes name/type for CRC check (see below).\n    var length = uint32[0] + 4\n    var chunk = new Uint8Array(length)\n    chunk[0] = data[idx++]\n    chunk[1] = data[idx++]\n    chunk[2] = data[idx++]\n    chunk[3] = data[idx++]\n\n    // Get the name in ASCII for identification.\n    var name = (\n      String.fromCharCode(chunk[0]) +\n      String.fromCharCode(chunk[1]) +\n      String.fromCharCode(chunk[2]) +\n      String.fromCharCode(chunk[3])\n    )\n\n    // The IHDR header MUST come first.\n    if (!chunks.length && name !== 'IHDR') {\n      throw new Error('IHDR header missing')\n    }\n\n    // The IEND header marks the end of the file,\n    // so on discovering it break out of the loop.\n    if (name === 'IEND') {\n      ended = true\n      chunks.push({\n        name: name,\n        data: new Uint8Array(0)\n      })\n\n      break\n    }\n\n    // Read the contents of the chunk out of the main buffer.\n    for (var i = 4; i < length; i++) {\n      chunk[i] = data[idx++]\n    }\n\n    // Read out the CRC value for comparison.\n    // It's stored as an Int32.\n    uint8[3] = data[idx++]\n    uint8[2] = data[idx++]\n    uint8[1] = data[idx++]\n    uint8[0] = data[idx++]\n\n    var crcActual = int32[0]\n    var crcExpect = crc32.buf(chunk)\n    if (crcExpect !== crcActual) {\n      throw new Error(\n        'CRC values for ' + name + ' header do not match, PNG file is likely corrupted'\n      )\n    }\n\n    // The chunk data is now copied to remove the 4 preceding\n    // bytes used for the chunk name/type.\n    var chunkData = new Uint8Array(chunk.buffer.slice(4))\n\n    chunks.push({\n      name: name,\n      data: chunkData\n    })\n  }\n\n  if (!ended) {\n    throw new Error('.png file ended prematurely: no IEND header was found')\n  }\n\n  return chunks\n}\n","/* crc32.js (C) 2014-2015 SheetJS -- http://sheetjs.com */\n/* vim: set ts=2: */\nvar CRC32;\n(function (factory) {\n\tif(typeof DO_NOT_EXPORT_CRC === 'undefined') {\n\t\tif('object' === typeof exports) {\n\t\t\tfactory(exports);\n\t\t} else if ('function' === typeof define && define.amd) {\n\t\t\tdefine(function () {\n\t\t\t\tvar module = {};\n\t\t\t\tfactory(module);\n\t\t\t\treturn module;\n\t\t\t});\n\t\t} else {\n\t\t  factory(CRC32 = {});\n\t\t}\n\t} else {\n\t\tfactory(CRC32 = {});\n\t}\n}(function(CRC32) {\nCRC32.version = '0.3.0';\n/* see perf/crc32table.js */\nfunction signed_crc_table() {\n\tvar c = 0, table = new Array(256);\n\n\tfor(var n =0; n != 256; ++n){\n\t\tc = n;\n\t\tc = ((c&1) ? (-306674912 ^ (c >>> 1)) : (c >>> 1));\n\t\tc = ((c&1) ? (-306674912 ^ (c >>> 1)) : (c >>> 1));\n\t\tc = ((c&1) ? (-306674912 ^ (c >>> 1)) : (c >>> 1));\n\t\tc = ((c&1) ? (-306674912 ^ (c >>> 1)) : (c >>> 1));\n\t\tc = ((c&1) ? (-306674912 ^ (c >>> 1)) : (c >>> 1));\n\t\tc = ((c&1) ? (-306674912 ^ (c >>> 1)) : (c >>> 1));\n\t\tc = ((c&1) ? (-306674912 ^ (c >>> 1)) : (c >>> 1));\n\t\tc = ((c&1) ? (-306674912 ^ (c >>> 1)) : (c >>> 1));\n\t\ttable[n] = c;\n\t}\n\n\treturn typeof Int32Array !== 'undefined' ? new Int32Array(table) : table;\n}\n\nvar table = signed_crc_table();\n/* charCodeAt is the best approach for binary strings */\nvar use_buffer = typeof Buffer !== 'undefined';\nfunction crc32_bstr(bstr) {\n\tif(bstr.length > 32768) if(use_buffer) return crc32_buf_8(new Buffer(bstr));\n\tvar crc = -1, L = bstr.length - 1;\n\tfor(var i = 0; i < L;) {\n\t\tcrc =  table[(crc ^ bstr.charCodeAt(i++)) & 0xFF] ^ (crc >>> 8);\n\t\tcrc =  table[(crc ^ bstr.charCodeAt(i++)) & 0xFF] ^ (crc >>> 8);\n\t}\n\tif(i === L) crc = (crc >>> 8) ^ table[(crc ^ bstr.charCodeAt(i)) & 0xFF];\n\treturn crc ^ -1;\n}\n\nfunction crc32_buf(buf) {\n\tif(buf.length > 10000) return crc32_buf_8(buf);\n\tfor(var crc = -1, i = 0, L=buf.length-3; i < L;) {\n\t\tcrc = (crc >>> 8) ^ table[(crc^buf[i++])&0xFF];\n\t\tcrc = (crc >>> 8) ^ table[(crc^buf[i++])&0xFF];\n\t\tcrc = (crc >>> 8) ^ table[(crc^buf[i++])&0xFF];\n\t\tcrc = (crc >>> 8) ^ table[(crc^buf[i++])&0xFF];\n\t}\n\twhile(i < L+3) crc = (crc >>> 8) ^ table[(crc^buf[i++])&0xFF];\n\treturn crc ^ -1;\n}\n\nfunction crc32_buf_8(buf) {\n\tfor(var crc = -1, i = 0, L=buf.length-7; i < L;) {\n\t\tcrc = (crc >>> 8) ^ table[(crc^buf[i++])&0xFF];\n\t\tcrc = (crc >>> 8) ^ table[(crc^buf[i++])&0xFF];\n\t\tcrc = (crc >>> 8) ^ table[(crc^buf[i++])&0xFF];\n\t\tcrc = (crc >>> 8) ^ table[(crc^buf[i++])&0xFF];\n\t\tcrc = (crc >>> 8) ^ table[(crc^buf[i++])&0xFF];\n\t\tcrc = (crc >>> 8) ^ table[(crc^buf[i++])&0xFF];\n\t\tcrc = (crc >>> 8) ^ table[(crc^buf[i++])&0xFF];\n\t\tcrc = (crc >>> 8) ^ table[(crc^buf[i++])&0xFF];\n\t}\n\twhile(i < L+7) crc = (crc >>> 8) ^ table[(crc^buf[i++])&0xFF];\n\treturn crc ^ -1;\n}\n\n/* much much faster to intertwine utf8 and crc */\nfunction crc32_str(str) {\n\tfor(var crc = -1, i = 0, L=str.length, c, d; i < L;) {\n\t\tc = str.charCodeAt(i++);\n\t\tif(c < 0x80) {\n\t\t\tcrc = (crc >>> 8) ^ table[(crc ^ c) & 0xFF];\n\t\t} else if(c < 0x800) {\n\t\t\tcrc = (crc >>> 8) ^ table[(crc ^ (192|((c>>6)&31))) & 0xFF];\n\t\t\tcrc = (crc >>> 8) ^ table[(crc ^ (128|(c&63))) & 0xFF];\n\t\t} else if(c >= 0xD800 && c < 0xE000) {\n\t\t\tc = (c&1023)+64; d = str.charCodeAt(i++) & 1023;\n\t\t\tcrc = (crc >>> 8) ^ table[(crc ^ (240|((c>>8)&7))) & 0xFF];\n\t\t\tcrc = (crc >>> 8) ^ table[(crc ^ (128|((c>>2)&63))) & 0xFF];\n\t\t\tcrc = (crc >>> 8) ^ table[(crc ^ (128|((d>>6)&15)|(c&3))) & 0xFF];\n\t\t\tcrc = (crc >>> 8) ^ table[(crc ^ (128|(d&63))) & 0xFF];\n\t\t} else {\n\t\t\tcrc = (crc >>> 8) ^ table[(crc ^ (224|((c>>12)&15))) & 0xFF];\n\t\t\tcrc = (crc >>> 8) ^ table[(crc ^ (128|((c>>6)&63))) & 0xFF];\n\t\t\tcrc = (crc >>> 8) ^ table[(crc ^ (128|(c&63))) & 0xFF];\n\t\t}\n\t}\n\treturn crc ^ -1;\n}\nCRC32.table = table;\nCRC32.bstr = crc32_bstr;\nCRC32.buf = crc32_buf;\nCRC32.str = crc32_str;\n}));\n","'use strict';\n\n/** @type {import('.')} */\nmodule.exports = [\n\t'Float32Array',\n\t'Float64Array',\n\t'Int8Array',\n\t'Int16Array',\n\t'Int32Array',\n\t'Uint8Array',\n\t'Uint8ClampedArray',\n\t'Uint16Array',\n\t'Uint32Array',\n\t'BigInt64Array',\n\t'BigUint64Array'\n];\n","import { version } from '../package.json'\n\n// overridden in posthog-core,\n// e.g.     Config.DEBUG = Config.DEBUG || instance.config.debug\nconst Config = {\n    DEBUG: false,\n    LIB_VERSION: version,\n}\n\nexport default Config\n","// eslint-disable-next-line posthog-js/no-direct-array-check\nconst nativeIsArray = Array.isArray\nconst ObjProto = Object.prototype\nexport const hasOwnProperty = ObjProto.hasOwnProperty\nconst toString = ObjProto.toString\n\nexport const isArray =\n    nativeIsArray ||\n    function (obj: any): obj is any[] {\n        return toString.call(obj) === '[object Array]'\n    }\nexport const isUint8Array = function (x: unknown): x is Uint8Array {\n    return toString.call(x) === '[object Uint8Array]'\n}\n// from a comment on http://dbj.org/dbj/?p=286\n// fails on only one very rare and deliberate custom object:\n// let bomb = { toString : undefined, valueOf: function(o) { return \"function BOMBA!\"; }};\nexport const isFunction = function (f: any): f is (...args: any[]) => any {\n    // eslint-disable-next-line posthog-js/no-direct-function-check\n    return typeof f === 'function'\n}\n// Underscore Addons\nexport const isObject = function (x: unknown): x is Record<string, any> {\n    // eslint-disable-next-line posthog-js/no-direct-object-check\n    return x === Object(x) && !isArray(x)\n}\nexport const isEmptyObject = function (x: unknown): x is Record<string, any> {\n    if (isObject(x)) {\n        for (const key in x) {\n            if (hasOwnProperty.call(x, key)) {\n                return false\n            }\n        }\n        return true\n    }\n    return false\n}\nexport const isUndefined = function (x: unknown): x is undefined {\n    return x === void 0\n}\n\nexport const isString = function (x: unknown): x is string {\n    // eslint-disable-next-line posthog-js/no-direct-string-check\n    return toString.call(x) == '[object String]'\n}\n\nexport const isEmptyString = function (x: unknown): boolean {\n    return isString(x) && x.trim().length === 0\n}\n\nexport const isNull = function (x: unknown): x is null {\n    // eslint-disable-next-line posthog-js/no-direct-null-check\n    return x === null\n}\n\n/*\n    sometimes you want to check if something is null or undefined\n    that's what this is for\n */\nexport const isNullish = function (x: unknown): x is null | undefined {\n    return isUndefined(x) || isNull(x)\n}\n\nexport const isDate = function (x: unknown): x is Date {\n    // eslint-disable-next-line posthog-js/no-direct-date-check\n    return toString.call(x) == '[object Date]'\n}\nexport const isNumber = function (x: unknown): x is number {\n    // eslint-disable-next-line posthog-js/no-direct-number-check\n    return toString.call(x) == '[object Number]'\n}\nexport const isBoolean = function (x: unknown): x is boolean {\n    // eslint-disable-next-line posthog-js/no-direct-boolean-check\n    return toString.call(x) === '[object Boolean]'\n}\n\nexport const isDocument = (x: unknown): x is Document => {\n    // eslint-disable-next-line posthog-js/no-direct-document-check\n    return x instanceof Document\n}\n\nexport const isFormData = (x: unknown): x is FormData => {\n    // eslint-disable-next-line posthog-js/no-direct-form-data-check\n    return x instanceof FormData\n}\n\nexport const isFile = (x: unknown): x is File => {\n    // eslint-disable-next-line posthog-js/no-direct-file-check\n    return x instanceof File\n}\n","/*\n * Global helpers to protect access to browser globals in a way that is safer for different targets\n * like DOM, SSR, Web workers etc.\n *\n * NOTE: Typically we want the \"window\" but globalThis works for both the typical browser context as\n * well as other contexts such as the web worker context. Window is still exported for any bits that explicitly require it.\n * If in doubt - export the global you need from this file and use that as an optional value. This way the code path is forced\n * to handle the case where the global is not available.\n */\n\n// eslint-disable-next-line no-restricted-globals\nconst win: (Window & typeof globalThis) | undefined = typeof window !== 'undefined' ? window : undefined\n\nconst global: typeof globalThis | undefined = typeof globalThis !== 'undefined' ? globalThis : win\n\nexport const ArrayProto = Array.prototype\nexport const nativeForEach = ArrayProto.forEach\nexport const nativeIndexOf = ArrayProto.indexOf\n\nexport const navigator = global?.navigator\nexport const document = global?.document\nexport const location = global?.location\nexport const fetch = global?.fetch\nexport const XMLHttpRequest =\n    global?.XMLHttpRequest && 'withCredentials' in new global.XMLHttpRequest() ? global.XMLHttpRequest : undefined\nexport const AbortController = global?.AbortController\nexport const userAgent = navigator?.userAgent\nexport const assignableWindow: Window & typeof globalThis & Record<string, any> = win ?? ({} as any)\n\nexport { win as window }\n","import Config from '../config'\nimport { isUndefined } from './type-utils'\nimport { assignableWindow, window } from './globals'\n\nconst LOGGER_PREFIX = '[PostHog.js]'\nexport const logger = {\n    _log: (level: 'log' | 'warn' | 'error', ...args: any[]) => {\n        if (\n            window &&\n            (Config.DEBUG || assignableWindow.POSTHOG_DEBUG) &&\n            !isUndefined(window.console) &&\n            window.console\n        ) {\n            const consoleLog =\n                '__rrweb_original__' in window.console[level]\n                    ? (window.console[level] as any)['__rrweb_original__']\n                    : window.console[level]\n\n            // eslint-disable-next-line no-console\n            consoleLog(LOGGER_PREFIX, ...args)\n        }\n    },\n\n    info: (...args: any[]) => {\n        logger._log('log', ...args)\n    },\n\n    warn: (...args: any[]) => {\n        logger._log('warn', ...args)\n    },\n\n    error: (...args: any[]) => {\n        logger._log('error', ...args)\n    },\n\n    critical: (...args: any[]) => {\n        // Critical errors are always logged to the console\n        // eslint-disable-next-line no-console\n        console.error(LOGGER_PREFIX, ...args)\n    },\n\n    uninitializedWarning: (methodName: string) => {\n        logger.error(`You must initialize PostHog before calling ${methodName}`)\n    },\n}\n","import { Breaker, EventHandler, Properties } from '../types'\nimport { isArray, isFormData, isFunction, isNull, isNullish, isString, hasOwnProperty } from './type-utils'\nimport { logger } from './logger'\nimport { window, nativeForEach, nativeIndexOf } from './globals'\n\nconst breaker: Breaker = {}\n\n// UNDERSCORE\n// Embed part of the Underscore Library\nexport const trim = function (str: string): string {\n    return str.replace(/^[\\s\\uFEFF\\xA0]+|[\\s\\uFEFF\\xA0]+$/g, '')\n}\n\nexport function eachArray<E = any>(\n    obj: E[] | null | undefined,\n    iterator: (value: E, key: number) => void | Breaker,\n    thisArg?: any\n): void {\n    if (isArray(obj)) {\n        if (nativeForEach && obj.forEach === nativeForEach) {\n            obj.forEach(iterator, thisArg)\n        } else if ('length' in obj && obj.length === +obj.length) {\n            for (let i = 0, l = obj.length; i < l; i++) {\n                if (i in obj && iterator.call(thisArg, obj[i], i) === breaker) {\n                    return\n                }\n            }\n        }\n    }\n}\n\n/**\n * @param {*=} obj\n * @param {function(...*)=} iterator\n * @param {Object=} thisArg\n */\nexport function each(obj: any, iterator: (value: any, key: any) => void | Breaker, thisArg?: any): void {\n    if (isNullish(obj)) {\n        return\n    }\n    if (isArray(obj)) {\n        return eachArray(obj, iterator, thisArg)\n    }\n    if (isFormData(obj)) {\n        for (const pair of obj.entries()) {\n            if (iterator.call(thisArg, pair[1], pair[0]) === breaker) {\n                return\n            }\n        }\n        return\n    }\n    for (const key in obj) {\n        if (hasOwnProperty.call(obj, key)) {\n            if (iterator.call(thisArg, obj[key], key) === breaker) {\n                return\n            }\n        }\n    }\n}\n\nexport const extend = function (obj: Record<string, any>, ...args: Record<string, any>[]): Record<string, any> {\n    eachArray(args, function (source) {\n        for (const prop in source) {\n            if (source[prop] !== void 0) {\n                obj[prop] = source[prop]\n            }\n        }\n    })\n    return obj\n}\n\nexport const include = function (\n    obj: null | string | Array<any> | Record<string, any>,\n    target: any\n): boolean | Breaker {\n    let found = false\n    if (isNull(obj)) {\n        return found\n    }\n    if (nativeIndexOf && obj.indexOf === nativeIndexOf) {\n        return obj.indexOf(target) != -1\n    }\n    each(obj, function (value) {\n        if (found || (found = value === target)) {\n            return breaker\n        }\n        return\n    })\n    return found\n}\n\nexport function includes<T = any>(str: T[] | string, needle: T): boolean {\n    return (str as any).indexOf(needle) !== -1\n}\n\n/**\n * Object.entries() polyfill\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/entries\n */\nexport function entries<T = any>(obj: Record<string, T>): [string, T][] {\n    const ownProps = Object.keys(obj)\n    let i = ownProps.length\n    const resArray = new Array(i) // preallocate the Array\n\n    while (i--) {\n        resArray[i] = [ownProps[i], obj[ownProps[i]]]\n    }\n    return resArray\n}\n\nexport const isValidRegex = function (str: string): boolean {\n    try {\n        new RegExp(str)\n    } catch (error) {\n        return false\n    }\n    return true\n}\n\nexport const timestamp = function (): number {\n    Date.now =\n        Date.now ||\n        function () {\n            return +new Date()\n        }\n    return Date.now()\n}\n\nexport const trySafe = function <T>(fn: () => T): T | undefined {\n    try {\n        return fn()\n    } catch (e) {\n        return undefined\n    }\n}\n\nexport const safewrap = function <F extends (...args: any[]) => any = (...args: any[]) => any>(f: F): F {\n    return function (...args) {\n        try {\n            // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n            // @ts-ignore\n            return f.apply(this, args)\n        } catch (e) {\n            logger.critical(\n                'Implementation error. Please turn on debug mode and open a ticket on https://app.posthog.com/home#panel=support%3Asupport%3A.'\n            )\n            logger.critical(e)\n        }\n    } as F\n}\n\n// eslint-disable-next-line @typescript-eslint/ban-types\nexport const safewrapClass = function (klass: Function, functions: string[]): void {\n    for (let i = 0; i < functions.length; i++) {\n        klass.prototype[functions[i]] = safewrap(klass.prototype[functions[i]])\n    }\n}\n\nexport const stripEmptyProperties = function (p: Properties): Properties {\n    const ret: Properties = {}\n    each(p, function (v, k) {\n        if (isString(v) && v.length > 0) {\n            ret[k] = v\n        }\n    })\n    return ret\n}\n\nexport const stripLeadingDollar = function (s: string): string {\n    return s.replace(/^\\$/, '')\n}\n\n/**\n * Deep copies an object.\n * It handles cycles by replacing all references to them with `undefined`\n * Also supports customizing native values\n *\n * @param value\n * @param customizer\n * @returns {{}|undefined|*}\n */\nfunction deepCircularCopy<T extends Record<string, any> = Record<string, any>>(\n    value: T,\n    customizer?: <K extends keyof T = keyof T>(value: T[K], key?: K) => T[K]\n): T | undefined {\n    const COPY_IN_PROGRESS_SET = new Set()\n\n    function internalDeepCircularCopy(value: T, key?: string): T | undefined {\n        if (value !== Object(value)) return customizer ? customizer(value as any, key) : value // primitive value\n\n        if (COPY_IN_PROGRESS_SET.has(value)) return undefined\n        COPY_IN_PROGRESS_SET.add(value)\n        let result: T\n\n        if (isArray(value)) {\n            result = [] as any as T\n            eachArray(value, (it) => {\n                result.push(internalDeepCircularCopy(it))\n            })\n        } else {\n            result = {} as T\n            each(value, (val, key) => {\n                if (!COPY_IN_PROGRESS_SET.has(val)) {\n                    ;(result as any)[key] = internalDeepCircularCopy(val, key)\n                }\n            })\n        }\n        return result\n    }\n    return internalDeepCircularCopy(value)\n}\n\nexport function _copyAndTruncateStrings<T extends Record<string, any> = Record<string, any>>(\n    object: T,\n    maxStringLength: number | null\n): T {\n    return deepCircularCopy(object, (value: any) => {\n        if (isString(value) && !isNull(maxStringLength)) {\n            return (value as string).slice(0, maxStringLength)\n        }\n        return value\n    }) as T\n}\n\nexport function _base64Encode(data: null): null\nexport function _base64Encode(data: undefined): undefined\nexport function _base64Encode(data: string): string\nexport function _base64Encode(data: string | null | undefined): string | null | undefined {\n    const b64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='\n    let o1,\n        o2,\n        o3,\n        h1,\n        h2,\n        h3,\n        h4,\n        bits,\n        i = 0,\n        ac = 0,\n        enc = ''\n    const tmp_arr: string[] = []\n\n    if (!data) {\n        return data\n    }\n\n    data = utf8Encode(data)\n\n    do {\n        // pack three octets into four hexets\n        o1 = data.charCodeAt(i++)\n        o2 = data.charCodeAt(i++)\n        o3 = data.charCodeAt(i++)\n\n        bits = (o1 << 16) | (o2 << 8) | o3\n\n        h1 = (bits >> 18) & 0x3f\n        h2 = (bits >> 12) & 0x3f\n        h3 = (bits >> 6) & 0x3f\n        h4 = bits & 0x3f\n\n        // use hexets to index into b64, and append result to encoded string\n        tmp_arr[ac++] = b64.charAt(h1) + b64.charAt(h2) + b64.charAt(h3) + b64.charAt(h4)\n    } while (i < data.length)\n\n    enc = tmp_arr.join('')\n\n    switch (data.length % 3) {\n        case 1:\n            enc = enc.slice(0, -2) + '=='\n            break\n        case 2:\n            enc = enc.slice(0, -1) + '='\n            break\n    }\n\n    return enc\n}\n\nexport const utf8Encode = function (string: string): string {\n    string = (string + '').replace(/\\r\\n/g, '\\n').replace(/\\r/g, '\\n')\n\n    let utftext = '',\n        start,\n        end\n    let stringl = 0,\n        n\n\n    start = end = 0\n    stringl = string.length\n\n    for (n = 0; n < stringl; n++) {\n        const c1 = string.charCodeAt(n)\n        let enc = null\n\n        if (c1 < 128) {\n            end++\n        } else if (c1 > 127 && c1 < 2048) {\n            enc = String.fromCharCode((c1 >> 6) | 192, (c1 & 63) | 128)\n        } else {\n            enc = String.fromCharCode((c1 >> 12) | 224, ((c1 >> 6) & 63) | 128, (c1 & 63) | 128)\n        }\n        if (!isNull(enc)) {\n            if (end > start) {\n                utftext += string.substring(start, end)\n            }\n            utftext += enc\n            start = end = n + 1\n        }\n    }\n\n    if (end > start) {\n        utftext += string.substring(start, string.length)\n    }\n\n    return utftext\n}\n\nexport const registerEvent = (function () {\n    // written by Dean Edwards, 2005\n    // with input from Tino Zijdel - crisp@xs4all.nl\n    // with input from Carl Sverre - mail@carlsverre.com\n    // with input from PostHog\n    // http://dean.edwards.name/weblog/2005/10/add-event/\n    // https://gist.github.com/1930440\n\n    /**\n     * @param {Object} element\n     * @param {string} type\n     * @param {function(...*)} handler\n     * @param {boolean=} oldSchool\n     * @param {boolean=} useCapture\n     */\n    const register_event = function (\n        element: Element | Window | Document | Node,\n        type: string,\n        handler: EventHandler,\n        oldSchool?: boolean,\n        useCapture?: boolean\n    ) {\n        if (!element) {\n            logger.error('No valid element provided to register_event')\n            return\n        }\n\n        if (element.addEventListener && !oldSchool) {\n            element.addEventListener(type, handler, !!useCapture)\n        } else {\n            const ontype = 'on' + type\n            const old_handler = (element as any)[ontype] // can be undefined\n            ;(element as any)[ontype] = makeHandler(element, handler, old_handler)\n        }\n    }\n\n    function makeHandler(\n        element: Element | Window | Document | Node,\n        new_handler: EventHandler,\n        old_handlers: EventHandler\n    ) {\n        return function (event: Event): boolean | void {\n            event = event || fixEvent(window?.event)\n\n            // this basically happens in firefox whenever another script\n            // overwrites the onload callback and doesn't pass the event\n            // object to previously defined callbacks.  All the browsers\n            // that don't define window.event implement addEventListener\n            // so the dom_loaded handler will still be fired as usual.\n            if (!event) {\n                return undefined\n            }\n\n            let ret = true\n            let old_result: any\n\n            if (isFunction(old_handlers)) {\n                old_result = old_handlers(event)\n            }\n            const new_result = new_handler.call(element, event)\n\n            if (false === old_result || false === new_result) {\n                ret = false\n            }\n\n            return ret\n        }\n    }\n\n    function fixEvent(event: Event | undefined): Event | undefined {\n        if (event) {\n            event.preventDefault = fixEvent.preventDefault\n            event.stopPropagation = fixEvent.stopPropagation\n        }\n        return event\n    }\n    fixEvent.preventDefault = function () {\n        ;(this as any as Event).returnValue = false\n    }\n    fixEvent.stopPropagation = function () {\n        ;(this as any as Event).cancelBubble = true\n    }\n\n    return register_event\n})()\n\nexport function isCrossDomainCookie(documentLocation: Location | undefined) {\n    const hostname = documentLocation?.hostname\n\n    if (!isString(hostname)) {\n        return false\n    }\n    // split and slice isn't a great way to match arbitrary domains,\n    // but it's good enough for ensuring we only match herokuapp.com when it is the TLD\n    // for the hostname\n    return hostname.split('.').slice(-2).join('.') !== 'herokuapp.com'\n}\n\nexport function isDistinctIdStringLike(value: string): boolean {\n    return ['distinct_id', 'distinctid'].includes(value.toLowerCase())\n}\n\nexport function find<T>(value: T[], predicate: (value: T) => boolean): T | undefined {\n    for (let i = 0; i < value.length; i++) {\n        if (predicate(value[i])) {\n            return value[i]\n        }\n    }\n    return undefined\n}\n","import type { MaskInputOptions, SlimDOMOptions } from 'rrweb-snapshot'\nimport { PostHog } from './posthog-core'\nimport type { SegmentAnalytics } from './extensions/segment-integration'\n\nexport type Property = any\nexport type Properties = Record<string, Property>\n\nexport interface CaptureResult {\n    uuid: string\n    event: string\n    properties: Properties\n    $set?: Properties\n    $set_once?: Properties\n    timestamp?: Date\n}\n\nexport type AutocaptureCompatibleElement = 'a' | 'button' | 'form' | 'input' | 'select' | 'textarea' | 'label'\nexport type DomAutocaptureEvents = 'click' | 'change' | 'submit'\n\n/**\n * If an array is passed for an allowlist, autocapture events will only be sent for elements matching\n * at least one of the elements in the array. Multiple allowlists can be used\n */\nexport interface AutocaptureConfig {\n    /**\n     * List of URLs to allow autocapture on, can be strings to match\n     * or regexes e.g. ['https://example.com', 'test.com/.*']\n     * this is useful when you want to autocapture on specific pages only\n     *\n     * if you set both url_allowlist and url_ignorelist,\n     * we check the allowlist first and then the ignorelist.\n     * the ignorelist can override the allowlist\n     */\n    url_allowlist?: (string | RegExp)[]\n\n    /**\n     * List of URLs to not allow autocapture on, can be strings to match\n     * or regexes e.g. ['https://example.com', 'test.com/.*']\n     * this is useful when you want to autocapture on most pages but not some specific ones\n     *\n     * if you set both url_allowlist and url_ignorelist,\n     * we check the allowlist first and then the ignorelist.\n     * the ignorelist can override the allowlist\n     */\n    url_ignorelist?: (string | RegExp)[]\n\n    /**\n     * List of DOM events to allow autocapture on  e.g. ['click', 'change', 'submit']\n     */\n    dom_event_allowlist?: DomAutocaptureEvents[]\n\n    /**\n     * List of DOM elements to allow autocapture on\n     * e.g. ['a', 'button', 'form', 'input', 'select', 'textarea', 'label']\n     * we consider the tree of elements from the root to the target element of the click event\n     * so for the tree div > div > button > svg\n     * if the allowlist has button then we allow the capture when the button or the svg is the click target\n     * but not if either of the divs are detected as the click target\n     */\n    element_allowlist?: AutocaptureCompatibleElement[]\n\n    /**\n     * List of CSS selectors to allow autocapture on\n     * e.g. ['[ph-capture]']\n     * we consider the tree of elements from the root to the target element of the click event\n     * so for the tree div > div > button > svg\n     * and allow list config `['[id]']`\n     * we will capture the click if the click-target or its parents has any id\n     */\n    css_selector_allowlist?: string[]\n\n    /**\n     * Exclude certain element attributes from autocapture\n     * E.g. ['aria-label'] or [data-attr-pii]\n     */\n    element_attribute_ignorelist?: string[]\n\n    capture_copied_text?: boolean\n}\n\nexport interface BootstrapConfig {\n    distinctID?: string\n    isIdentifiedID?: boolean\n    featureFlags?: Record<string, boolean | string>\n    featureFlagPayloads?: Record<string, JsonType>\n    /**\n     * Optionally provide a sessionID, this is so that you can provide an existing sessionID here to continue a user's session across a domain or device. It MUST be:\n     * - unique to this user\n     * - a valid UUID v7\n     * - the timestamp part must be <= the timestamp of the first event in the session\n     * - the timestamp of the last event in the session must be < the timestamp part + 24 hours\n     * **/\n    sessionID?: string\n}\n\nexport interface PerformanceCaptureConfig {\n    /** works with session replay to use the browser's native performance observer to capture performance metrics */\n    network_timing?: boolean\n    /** works as a passenger event to use chrome's web vitals library to wrap fetch and capture web vitals */\n    web_vitals?: boolean\n    /**\n     * We observe very large values reported by the Chrome web vitals library\n     * These outliers are likely not real, useful values, and we exclude them\n     * You can set this to 0 in order to include all values, NB this is not recommended\n     * if not set this defaults to 15 minutes\n     */\n    __web_vitals_max_value?: number\n}\n\nexport interface HeatmapConfig {\n    /*\n     * how often to send batched data in $$heatmap_data events\n     * if set to 0 or not set, sends using the default interval of 1 second\n     * */\n    flush_interval_milliseconds: number\n}\n\nexport interface PostHogConfig {\n    api_host: string\n    /** @deprecated - This property is no longer supported */\n    api_method?: string\n    api_transport?: 'XHR' | 'fetch'\n    ui_host: string | null\n    token: string\n    autocapture: boolean | AutocaptureConfig\n    rageclick: boolean\n    cross_subdomain_cookie: boolean\n    persistence: 'localStorage' | 'cookie' | 'memory' | 'localStorage+cookie' | 'sessionStorage'\n    persistence_name: string\n    /** @deprecated - Use 'persistence_name' instead */\n    cookie_name?: string\n    loaded: (posthog_instance: PostHog) => void\n    store_google: boolean\n    custom_campaign_params: string[]\n    // a list of strings to be tested against navigator.userAgent to determine if the source is a bot\n    // this is **added to** the default list of bots that we check\n    // defaults to the empty array\n    custom_blocked_useragents: string[]\n    save_referrer: boolean\n    verbose: boolean\n    capture_pageview: boolean\n    capture_pageleave: boolean | 'if_capture_pageview'\n    debug: boolean\n    cookie_expiration: number\n    upgrade: boolean\n    disable_session_recording: boolean\n    disable_persistence: boolean\n    /** @deprecated - use `disable_persistence` instead  */\n    disable_cookie?: boolean\n    disable_surveys: boolean\n    /** If set, posthog-js will never load external scripts such as those needed for Session Replay or Surveys. */\n    disable_external_dependency_loading?: boolean\n    enable_recording_console_log?: boolean\n    secure_cookie: boolean\n    ip: boolean\n    /** Starts the SDK in an opted out state requiring opt_in_capturing() to be called before events will b captured  */\n    opt_out_capturing_by_default: boolean\n    opt_out_capturing_persistence_type: 'localStorage' | 'cookie'\n    /** If set to true this will disable persistence if the user is opted out of capturing. @default false */\n    opt_out_persistence_by_default?: boolean\n    /** Opt out of user agent filtering such as googlebot or other bots. Defaults to `false` */\n    opt_out_useragent_filter: boolean\n\n    opt_out_capturing_cookie_prefix: string | null\n    opt_in_site_apps: boolean\n    respect_dnt: boolean\n    /** @deprecated - use `property_denylist` instead  */\n    property_blacklist?: string[]\n    property_denylist: string[]\n    request_headers: { [header_name: string]: string }\n    on_request_error?: (error: RequestResponse) => void\n    /** @deprecated - use `request_headers` instead  */\n    xhr_headers?: { [header_name: string]: string }\n    /** @deprecated - use `on_request_error` instead  */\n    on_xhr_error?: (failedRequest: XMLHttpRequest) => void\n    inapp_protocol: string\n    inapp_link_new_window: boolean\n    request_batching: boolean\n    sanitize_properties: ((properties: Properties, event_name: string) => Properties) | null\n    properties_string_max_length: number\n    session_recording: SessionRecordingOptions\n    session_idle_timeout_seconds: number\n    mask_all_element_attributes: boolean\n    mask_all_text: boolean\n    advanced_disable_decide: boolean\n    advanced_disable_feature_flags: boolean\n    advanced_disable_feature_flags_on_first_load: boolean\n    advanced_disable_toolbar_metrics: boolean\n    feature_flag_request_timeout_ms: number\n    get_device_id: (uuid: string) => string\n    name: string\n    _onCapture: (eventName: string, eventData: CaptureResult) => void\n    capture_performance?: boolean | PerformanceCaptureConfig\n    // Should only be used for testing. Could negatively impact performance.\n    disable_compression: boolean\n    bootstrap: BootstrapConfig\n    segment?: SegmentAnalytics\n    __preview_send_client_session_params?: boolean\n    /* @deprecated - use `capture_heatmaps` instead */\n    enable_heatmaps?: boolean\n    capture_heatmaps?: boolean | HeatmapConfig\n    disable_scroll_properties?: boolean\n    // Let the pageview scroll stats use a custom css selector for the root element, e.g. `main`\n    scroll_root_selector?: string | string[]\n\n    /** You can control whether events from PostHog-js have person processing enabled with the `person_profiles` config setting. There are three options:\n     * - `person_profiles: 'always'` _(default)_ - we will process persons data for all events\n     * - `person_profiles: 'never'` - we won't process persons for any event. This means that anonymous users will not be merged once they sign up or login, so you lose the ability to create funnels that track users from anonymous to identified. All events (including `$identify`) will be sent with `$process_person_profile: False`.\n     * - `person_profiles: 'identified_only'` - we will only process persons when you call `posthog.identify`, `posthog.alias`, `posthog.setPersonProperties`, `posthog.group`, `posthog.setPersonPropertiesForFlags` or `posthog.setGroupPropertiesForFlags` Anonymous users won't get person profiles.\n     */\n    person_profiles?: 'always' | 'never' | 'identified_only'\n    /** @deprecated - use `person_profiles` instead  */\n    process_person?: 'always' | 'never' | 'identified_only'\n\n    /** Client side rate limiting */\n    rate_limiting?: {\n        /** The average number of events per second that should be permitted (defaults to 10) */\n        events_per_second?: number\n        /** How many events can be captured in a burst. This defaults to 10 times the events_per_second count  */\n        events_burst_limit?: number\n    }\n\n    /**\n     * PREVIEW - MAY CHANGE WITHOUT WARNING - DO NOT USE IN PRODUCTION\n     * whether to wrap fetch and add tracing headers to the request\n     * */\n    __add_tracing_headers?: boolean\n}\n\nexport interface OptInOutCapturingOptions {\n    capture: (event: string, properties: Properties, options: CaptureOptions) => void\n    capture_event_name: string\n    capture_properties: Properties\n    enable_persistence: boolean\n    clear_persistence: boolean\n    persistence_type: 'cookie' | 'localStorage' | 'localStorage+cookie'\n    cookie_prefix: string\n    cookie_expiration: number\n    cross_subdomain_cookie: boolean\n    secure_cookie: boolean\n}\n\nexport interface IsFeatureEnabledOptions {\n    send_event: boolean\n}\n\nexport interface SessionRecordingOptions {\n    blockClass?: string | RegExp\n    blockSelector?: string | null\n    ignoreClass?: string\n    maskTextClass?: string | RegExp\n    maskTextSelector?: string | null\n    maskTextFn?: ((text: string, element: HTMLElement | null) => string) | null\n    maskAllInputs?: boolean\n    maskInputOptions?: MaskInputOptions\n    maskInputFn?: ((text: string, element?: HTMLElement) => string) | null\n    slimDOMOptions?: SlimDOMOptions | 'all' | true\n    collectFonts?: boolean\n    inlineStylesheet?: boolean\n    recordCrossOriginIframes?: boolean\n    /** @deprecated - use maskCapturedNetworkRequestFn instead  */\n    maskNetworkRequestFn?: ((data: NetworkRequest) => NetworkRequest | null | undefined) | null\n    /** Modify the network request before it is captured. Returning null or undefined stops it being captured */\n    maskCapturedNetworkRequestFn?: ((data: CapturedNetworkRequest) => CapturedNetworkRequest | null | undefined) | null\n    // our settings here only support a subset of those proposed for rrweb's network capture plugin\n    recordHeaders?: boolean\n    recordBody?: boolean\n    // ADVANCED: while a user is active we take a full snapshot of the browser every interval. For very few sites playback performance might be better with different interval. Set to 0 to disable\n    full_snapshot_interval_millis?: number\n}\n\nexport type SessionIdChangedCallback = (sessionId: string, windowId: string | null | undefined) => void\n\nexport enum Compression {\n    GZipJS = 'gzip-js',\n    Base64 = 'base64',\n}\n\n// Request types - these should be kept minimal to what request.ts needs\n\n// Minimal class to allow interop between different request methods (xhr / fetch)\nexport interface RequestResponse {\n    statusCode: number\n    text?: string\n    json?: any\n}\n\nexport type RequestCallback = (response: RequestResponse) => void\n\nexport interface RequestOptions {\n    url: string\n    // Data can be a single object or an array of objects when batched\n    data?: Record<string, any> | Record<string, any>[]\n    headers?: Record<string, any>\n    transport?: 'XHR' | 'fetch' | 'sendBeacon'\n    method?: 'POST' | 'GET'\n    urlQueryArgs?: { compression: Compression }\n    callback?: RequestCallback\n    timeout?: number\n    noRetries?: boolean\n    compression?: Compression | 'best-available'\n}\n\n// Queued request types - the same as a request but with additional queueing information\n\nexport interface QueuedRequestOptions extends RequestOptions {\n    batchKey?: string /** key of queue, e.g. 'sessionRecording' vs 'event' */\n}\n\n// Used explicitly for retriable requests\nexport interface RetriableRequestOptions extends QueuedRequestOptions {\n    retriesPerformedSoFar?: number\n}\n\nexport interface CaptureOptions {\n    $set?: Properties /** used with $identify */\n    $set_once?: Properties /** used with $identify */\n    _url?: string /** Used to override the desired endpoint for the captured event */\n    _batchKey?: string /** key of queue, e.g. 'sessionRecording' vs 'event' */\n    _noTruncate?: boolean /** if set, overrides and disables config.properties_string_max_length */\n    send_instantly?: boolean /** if set skips the batched queue */\n    skip_client_rate_limiting?: boolean /** if set skips the client side rate limiting */\n    transport?: RequestOptions['transport'] /** if set, overrides the desired transport method */\n    timestamp?: Date\n}\n\nexport type FlagVariant = { flag: string; variant: string }\n\nexport interface DecideResponse {\n    supportedCompression: Compression[]\n    featureFlags: Record<string, string | boolean>\n    featureFlagPayloads: Record<string, JsonType>\n    errorsWhileComputingFlags: boolean\n    autocapture_opt_out?: boolean\n    /**\n     *     originally capturePerformance was replay only and so boolean true\n     *     is equivalent to { network_timing: true }\n     *     now capture performance can be separately enabled within replay\n     *     and as a standalone web vitals tracker\n     *     people can have them enabled separately\n     *     they work standalone but enhance each other\n     *     TODO: deprecate this so we make a new config that doesn't need this explanation\n     */\n    capturePerformance?: boolean | PerformanceCaptureConfig\n    analytics?: {\n        endpoint?: string\n    }\n    elementsChainAsString?: boolean\n    // this is currently in development and may have breaking changes without a major version bump\n    autocaptureExceptions?:\n        | boolean\n        | {\n              endpoint?: string\n          }\n    sessionRecording?: {\n        endpoint?: string\n        consoleLogRecordingEnabled?: boolean\n        // the API returns a decimal between 0 and 1 as a string\n        sampleRate?: string | null\n        minimumDurationMilliseconds?: number\n        recordCanvas?: boolean | null\n        canvasFps?: number | null\n        // the API returns a decimal between 0 and 1 as a string\n        canvasQuality?: string | null\n        linkedFlag?: string | FlagVariant | null\n        networkPayloadCapture?: Pick<NetworkRecordOptions, 'recordBody' | 'recordHeaders'>\n    }\n    surveys?: boolean\n    toolbarParams: ToolbarParams\n    editorParams?: ToolbarParams /** @deprecated, renamed to toolbarParams, still present on older API responses */\n    toolbarVersion: 'toolbar' /** @deprecated, moved to toolbarParams */\n    isAuthenticated: boolean\n    siteApps: { id: number; url: string }[]\n    heatmaps?: boolean\n}\n\nexport type FeatureFlagsCallback = (\n    flags: string[],\n    variants: Record<string, string | boolean>,\n    context?: {\n        errorsLoading?: boolean\n    }\n) => void\n\nexport interface PersistentStore {\n    is_supported: () => boolean\n    error: (error: any) => void\n    parse: (name: string) => any\n    get: (name: string) => any\n    set: (\n        name: string,\n        value: any,\n        expire_days?: number | null,\n        cross_subdomain?: boolean,\n        secure?: boolean,\n        debug?: boolean\n    ) => void\n    remove: (name: string, cross_subdomain?: boolean) => void\n}\n\n// eslint-disable-next-line @typescript-eslint/ban-types\nexport type Breaker = {}\nexport type EventHandler = (event: Event) => boolean | void\n\nexport type ToolbarUserIntent = 'add-action' | 'edit-action'\nexport type ToolbarSource = 'url' | 'localstorage'\nexport type ToolbarVersion = 'toolbar'\n\n/* sync with posthog */\nexport interface ToolbarParams {\n    token?: string /** public posthog-js token */\n    temporaryToken?: string /** private temporary user token */\n    actionId?: number\n    userIntent?: ToolbarUserIntent\n    source?: ToolbarSource\n    toolbarVersion?: ToolbarVersion\n    instrument?: boolean\n    distinctId?: string\n    userEmail?: string\n    dataAttributes?: string[]\n    featureFlags?: Record<string, string | boolean>\n}\n\nexport type SnippetArrayItem = [method: string, ...args: any[]]\n\nexport type JsonType = string | number | boolean | null | { [key: string]: JsonType } | Array<JsonType>\n\n/** A feature that isn't publicly available yet.*/\nexport interface EarlyAccessFeature {\n    // Sync this with the backend's EarlyAccessFeatureSerializer!\n    name: string\n    description: string\n    stage: 'concept' | 'alpha' | 'beta'\n    documentationUrl: string | null\n    flagKey: string | null\n}\n\nexport type EarlyAccessFeatureCallback = (earlyAccessFeatures: EarlyAccessFeature[]) => void\n\nexport interface EarlyAccessFeatureResponse {\n    earlyAccessFeatures: EarlyAccessFeature[]\n}\n\nexport type Headers = Record<string, string>\n\n/* for rrweb/network@1\n ** when that is released as part of rrweb this can be removed\n ** don't rely on this type, it may change without notice\n */\nexport type InitiatorType =\n    | 'audio'\n    | 'beacon'\n    | 'body'\n    | 'css'\n    | 'early-hint'\n    | 'embed'\n    | 'fetch'\n    | 'frame'\n    | 'iframe'\n    | 'icon'\n    | 'image'\n    | 'img'\n    | 'input'\n    | 'link'\n    | 'navigation'\n    | 'object'\n    | 'ping'\n    | 'script'\n    | 'track'\n    | 'video'\n    | 'xmlhttprequest'\n\nexport type NetworkRecordOptions = {\n    initiatorTypes?: InitiatorType[]\n    maskRequestFn?: (data: CapturedNetworkRequest) => CapturedNetworkRequest | undefined\n    recordHeaders?: boolean | { request: boolean; response: boolean }\n    recordBody?: boolean | string[] | { request: boolean | string[]; response: boolean | string[] }\n    recordInitialRequests?: boolean\n    /**\n     * whether to record PerformanceEntry events for network requests\n     */\n    recordPerformance?: boolean\n    /**\n     * the PerformanceObserver will only observe these entry types\n     */\n    performanceEntryTypeToObserve: string[]\n    /**\n     * the maximum size of the request/response body to record\n     * NB this will be at most 1MB even if set larger\n     */\n    payloadSizeLimitBytes: number\n    /**\n     * some domains we should never record the payload\n     * for example other companies session replay ingestion payloads aren't super useful but are gigantic\n     * if this isn't provided we use a default list\n     * if this is provided - we add the provided list to the default list\n     * i.e. we never record the payloads on the default deny list\n     */\n    payloadHostDenyList?: string[]\n}\n\n/** @deprecated - use CapturedNetworkRequest instead  */\nexport type NetworkRequest = {\n    url: string\n}\n\n// In rrweb this is called NetworkRequest, but we already exposed that as having only URL\n// we also want to vary from the rrweb NetworkRequest because we want to include\n// all PerformanceEntry properties too.\n// that has 4 required properties\n//     readonly duration: DOMHighResTimeStamp;\n//     readonly entryType: string;\n//     readonly name: string;\n//     readonly startTime: DOMHighResTimeStamp;\n// NB: properties below here are ALPHA, don't rely on them, they may change without notice\n\n// we mirror PerformanceEntry since we read into this type from a PerformanceObserver,\n// but we don't want to inherit its readonly-iness\ntype Writable<T> = { -readonly [P in keyof T]: T[P] }\n\nexport type CapturedNetworkRequest = Writable<Omit<PerformanceEntry, 'toJSON'>> & {\n    // properties below here are ALPHA, don't rely on them, they may change without notice\n    method?: string\n    initiatorType?: InitiatorType\n    status?: number\n    timeOrigin?: number\n    timestamp?: number\n    startTime?: number\n    endTime?: number\n    requestHeaders?: Headers\n    requestBody?: string | null\n    responseHeaders?: Headers\n    responseBody?: string | null\n    // was this captured before fetch/xhr could have been wrapped\n    isInitial?: boolean\n}\n\nexport type ErrorEventArgs = [\n    event: string | Event,\n    source?: string | undefined,\n    lineno?: number | undefined,\n    colno?: number | undefined,\n    error?: Error | undefined\n]\n\n// levels originally copied from Sentry to work with the sentry integration\n// and to avoid relying on a frequently changing @sentry/types dependency\n// but provided as an array of literal types, so we can constrain the level below\nexport const severityLevels = ['fatal', 'error', 'warning', 'log', 'info', 'debug'] as const\nexport declare type SeverityLevel = typeof severityLevels[number]\n\nexport interface ErrorProperties {\n    $exception_type: string\n    $exception_message: string\n    $exception_level: SeverityLevel\n    $exception_source?: string\n    $exception_lineno?: number\n    $exception_colno?: number\n    $exception_DOMException_code?: string\n    $exception_is_synthetic?: boolean\n    $exception_stack_trace_raw?: string\n    $exception_handled?: boolean\n    $exception_personURL?: string\n}\n\nexport interface ErrorConversions {\n    errorToProperties: (args: ErrorEventArgs) => ErrorProperties\n    unhandledRejectionToProperties: (args: [ev: PromiseRejectionEvent]) => ErrorProperties\n}\n","/*\n * Constants\n */\n\n/* PROPERTY KEYS */\n\n// This key is deprecated, but we want to check for it to see whether aliasing is allowed.\nexport const PEOPLE_DISTINCT_ID_KEY = '$people_distinct_id'\nexport const DISTINCT_ID = 'distinct_id'\nexport const ALIAS_ID_KEY = '__alias'\nexport const CAMPAIGN_IDS_KEY = '__cmpns'\nexport const EVENT_TIMERS_KEY = '__timers'\nexport const AUTOCAPTURE_DISABLED_SERVER_SIDE = '$autocapture_disabled_server_side'\nexport const HEATMAPS_ENABLED_SERVER_SIDE = '$heatmaps_enabled_server_side'\nexport const EXCEPTION_CAPTURE_ENABLED_SERVER_SIDE = '$exception_capture_enabled_server_side'\nexport const EXCEPTION_CAPTURE_ENDPOINT = '$exception_capture_endpoint'\nexport const WEB_VITALS_ENABLED_SERVER_SIDE = '$web_vitals_enabled_server_side'\nexport const SESSION_RECORDING_ENABLED_SERVER_SIDE = '$session_recording_enabled_server_side'\nexport const CONSOLE_LOG_RECORDING_ENABLED_SERVER_SIDE = '$console_log_recording_enabled_server_side'\nexport const SESSION_RECORDING_NETWORK_PAYLOAD_CAPTURE = '$session_recording_network_payload_capture'\nexport const SESSION_RECORDING_CANVAS_RECORDING = '$session_recording_canvas_recording'\nexport const SESSION_RECORDING_SAMPLE_RATE = '$replay_sample_rate'\nexport const SESSION_RECORDING_MINIMUM_DURATION = '$replay_minimum_duration'\nexport const SESSION_ID = '$sesid'\nexport const SESSION_RECORDING_IS_SAMPLED = '$session_is_sampled'\nexport const ENABLED_FEATURE_FLAGS = '$enabled_feature_flags'\nexport const PERSISTENCE_EARLY_ACCESS_FEATURES = '$early_access_features'\nexport const STORED_PERSON_PROPERTIES_KEY = '$stored_person_properties'\nexport const STORED_GROUP_PROPERTIES_KEY = '$stored_group_properties'\nexport const SURVEYS = '$surveys'\nexport const SURVEYS_ACTIVATED = '$surveys_activated'\nexport const FLAG_CALL_REPORTED = '$flag_call_reported'\nexport const USER_STATE = '$user_state'\nexport const CLIENT_SESSION_PROPS = '$client_session_props'\nexport const CAPTURE_RATE_LIMIT = '$capture_rate_limit'\n\n/** @deprecated Delete this when INITIAL_PERSON_INFO has been around for long enough to ignore backwards compat */\nexport const INITIAL_CAMPAIGN_PARAMS = '$initial_campaign_params'\n/** @deprecated Delete this when INITIAL_PERSON_INFO has been around for long enough to ignore backwards compat */\nexport const INITIAL_REFERRER_INFO = '$initial_referrer_info'\nexport const INITIAL_PERSON_INFO = '$initial_person_info'\nexport const ENABLE_PERSON_PROCESSING = '$epp'\nexport const TOOLBAR_ID = '__POSTHOG_TOOLBAR__'\n\n// These are properties that are reserved and will not be automatically included in events\nexport const PERSISTENCE_RESERVED_PROPERTIES = [\n    PEOPLE_DISTINCT_ID_KEY,\n    ALIAS_ID_KEY,\n    CAMPAIGN_IDS_KEY,\n    EVENT_TIMERS_KEY,\n    SESSION_RECORDING_ENABLED_SERVER_SIDE,\n    HEATMAPS_ENABLED_SERVER_SIDE,\n    SESSION_ID,\n    ENABLED_FEATURE_FLAGS,\n    USER_STATE,\n    PERSISTENCE_EARLY_ACCESS_FEATURES,\n    STORED_GROUP_PROPERTIES_KEY,\n    STORED_PERSON_PROPERTIES_KEY,\n    SURVEYS,\n    FLAG_CALL_REPORTED,\n    CLIENT_SESSION_PROPS,\n    CAPTURE_RATE_LIMIT,\n    INITIAL_CAMPAIGN_PARAMS,\n    INITIAL_REFERRER_INFO,\n    ENABLE_PERSON_PROCESSING,\n]\n","import { entries, extend } from './utils'\nimport { PostHog } from './posthog-core'\nimport {\n    DecideResponse,\n    FeatureFlagsCallback,\n    EarlyAccessFeatureCallback,\n    EarlyAccessFeatureResponse,\n    Properties,\n    JsonType,\n    Compression,\n} from './types'\nimport { PostHogPersistence } from './posthog-persistence'\n\nimport {\n    PERSISTENCE_EARLY_ACCESS_FEATURES,\n    ENABLED_FEATURE_FLAGS,\n    STORED_GROUP_PROPERTIES_KEY,\n    STORED_PERSON_PROPERTIES_KEY,\n    FLAG_CALL_REPORTED,\n} from './constants'\n\nimport { isArray } from './utils/type-utils'\nimport { logger } from './utils/logger'\n\nconst PERSISTENCE_ACTIVE_FEATURE_FLAGS = '$active_feature_flags'\nconst PERSISTENCE_OVERRIDE_FEATURE_FLAGS = '$override_feature_flags'\nconst PERSISTENCE_FEATURE_FLAG_PAYLOADS = '$feature_flag_payloads'\n\nexport const filterActiveFeatureFlags = (featureFlags?: Record<string, string | boolean>) => {\n    const activeFeatureFlags: Record<string, string | boolean> = {}\n    for (const [key, value] of entries(featureFlags || {})) {\n        if (value) {\n            activeFeatureFlags[key] = value\n        }\n    }\n    return activeFeatureFlags\n}\n\nexport const parseFeatureFlagDecideResponse = (\n    response: Partial<DecideResponse>,\n    persistence: PostHogPersistence,\n    currentFlags: Record<string, string | boolean> = {},\n    currentFlagPayloads: Record<string, JsonType> = {}\n) => {\n    const flags = response['featureFlags']\n    const flagPayloads = response['featureFlagPayloads']\n    if (!flags) {\n        return\n    }\n    // using the v1 api\n    if (isArray(flags)) {\n        const $enabled_feature_flags: Record<string, boolean> = {}\n        if (flags) {\n            for (let i = 0; i < flags.length; i++) {\n                $enabled_feature_flags[flags[i]] = true\n            }\n        }\n        persistence &&\n            persistence.register({\n                [PERSISTENCE_ACTIVE_FEATURE_FLAGS]: flags,\n                [ENABLED_FEATURE_FLAGS]: $enabled_feature_flags,\n            })\n        return\n    }\n\n    // using the v2+ api\n    let newFeatureFlags = flags\n    let newFeatureFlagPayloads = flagPayloads\n    if (response.errorsWhileComputingFlags) {\n        // if not all flags were computed, we upsert flags instead of replacing them\n        newFeatureFlags = { ...currentFlags, ...newFeatureFlags }\n        newFeatureFlagPayloads = { ...currentFlagPayloads, ...newFeatureFlagPayloads }\n    }\n    persistence &&\n        persistence.register({\n            [PERSISTENCE_ACTIVE_FEATURE_FLAGS]: Object.keys(filterActiveFeatureFlags(newFeatureFlags)),\n            [ENABLED_FEATURE_FLAGS]: newFeatureFlags || {},\n            [PERSISTENCE_FEATURE_FLAG_PAYLOADS]: newFeatureFlagPayloads || {},\n        })\n}\n\nexport class PostHogFeatureFlags {\n    instance: PostHog\n    _override_warning: boolean\n    featureFlagEventHandlers: FeatureFlagsCallback[]\n    reloadFeatureFlagsQueued: boolean\n    reloadFeatureFlagsInAction: boolean\n    $anon_distinct_id: string | undefined\n\n    constructor(instance: PostHog) {\n        this.instance = instance\n        this._override_warning = false\n        this.featureFlagEventHandlers = []\n\n        this.reloadFeatureFlagsQueued = false\n        this.reloadFeatureFlagsInAction = false\n    }\n\n    getFlags(): string[] {\n        return Object.keys(this.getFlagVariants())\n    }\n\n    getFlagVariants(): Record<string, string | boolean> {\n        const enabledFlags = this.instance.get_property(ENABLED_FEATURE_FLAGS)\n        const overriddenFlags = this.instance.get_property(PERSISTENCE_OVERRIDE_FEATURE_FLAGS)\n        if (!overriddenFlags) {\n            return enabledFlags || {}\n        }\n\n        const finalFlags = extend({}, enabledFlags)\n        const overriddenKeys = Object.keys(overriddenFlags)\n        for (let i = 0; i < overriddenKeys.length; i++) {\n            finalFlags[overriddenKeys[i]] = overriddenFlags[overriddenKeys[i]]\n        }\n        if (!this._override_warning) {\n            logger.warn(' Overriding feature flags!', {\n                enabledFlags,\n                overriddenFlags,\n                finalFlags,\n            })\n            this._override_warning = true\n        }\n        return finalFlags\n    }\n\n    getFlagPayloads(): Record<string, JsonType> {\n        const flagPayloads = this.instance.get_property(PERSISTENCE_FEATURE_FLAG_PAYLOADS)\n        return flagPayloads || {}\n    }\n\n    /**\n     * Reloads feature flags asynchronously.\n     *\n     * Constraints:\n     *\n     * 1. Avoid parallel requests\n     * 2. Delay a few milliseconds after each reloadFeatureFlags call to batch subsequent changes together\n     * 3. Don't call this during initial load (as /decide will be called instead), see posthog-core.js\n     */\n    reloadFeatureFlags(): void {\n        if (!this.reloadFeatureFlagsQueued) {\n            this.reloadFeatureFlagsQueued = true\n            this._startReloadTimer()\n        }\n    }\n\n    setAnonymousDistinctId(anon_distinct_id: string): void {\n        this.$anon_distinct_id = anon_distinct_id\n    }\n\n    setReloadingPaused(isPaused: boolean): void {\n        this.reloadFeatureFlagsInAction = isPaused\n    }\n\n    resetRequestQueue(): void {\n        this.reloadFeatureFlagsQueued = false\n    }\n\n    _startReloadTimer(): void {\n        if (this.reloadFeatureFlagsQueued && !this.reloadFeatureFlagsInAction) {\n            setTimeout(() => {\n                if (!this.reloadFeatureFlagsInAction && this.reloadFeatureFlagsQueued) {\n                    this.reloadFeatureFlagsQueued = false\n                    this._reloadFeatureFlagsRequest()\n                }\n            }, 5)\n        }\n    }\n\n    _reloadFeatureFlagsRequest(): void {\n        if (this.instance.config.advanced_disable_feature_flags) {\n            return\n        }\n\n        this.setReloadingPaused(true)\n        const token = this.instance.config.token\n        const personProperties = this.instance.get_property(STORED_PERSON_PROPERTIES_KEY)\n        const groupProperties = this.instance.get_property(STORED_GROUP_PROPERTIES_KEY)\n        const json_data = {\n            token: token,\n            distinct_id: this.instance.get_distinct_id(),\n            groups: this.instance.getGroups(),\n            $anon_distinct_id: this.$anon_distinct_id,\n            person_properties: personProperties,\n            group_properties: groupProperties,\n            disable_flags: this.instance.config.advanced_disable_feature_flags || undefined,\n        }\n\n        this.instance._send_request({\n            method: 'POST',\n            url: this.instance.requestRouter.endpointFor('api', '/decide/?v=3'),\n            data: json_data,\n            compression: this.instance.config.disable_compression ? undefined : Compression.Base64,\n            timeout: this.instance.config.feature_flag_request_timeout_ms,\n            callback: (response) => {\n                this.setReloadingPaused(false)\n\n                let errorsLoading = true\n\n                if (response.statusCode === 200) {\n                    // successful request\n                    // reset anon_distinct_id after at least a single request with it\n                    // makes it through\n                    this.$anon_distinct_id = undefined\n                    errorsLoading = false\n                }\n                // :TRICKY: We want to fire the callback even if the request fails\n                // and return existing flags if they exist\n                // This is because we don't want to block clients waiting for flags to load.\n                // It's possible they're waiting for the callback to render the UI, but it never occurs.\n                this.receivedFeatureFlags(response.json ?? {}, errorsLoading)\n\n                // :TRICKY: Reload - start another request if queued!\n                this._startReloadTimer()\n            },\n        })\n    }\n\n    /*\n     * Get feature flag's value for user.\n     *\n     * ### Usage:\n     *\n     *     if(posthog.getFeatureFlag('my-flag') === 'some-variant') { // do something }\n     *\n     * @param {Object|String} key Key of the feature flag.\n     * @param {Object|String} options (optional) If {send_event: false}, we won't send an $feature_flag_call event to PostHog.\n     */\n    getFeatureFlag(key: string, options: { send_event?: boolean } = {}): boolean | string | undefined {\n        if (!this.instance.decideEndpointWasHit && !(this.getFlags() && this.getFlags().length > 0)) {\n            logger.warn('getFeatureFlag for key \"' + key + '\" failed. Feature flags didn\\'t load in time.')\n            return undefined\n        }\n        const flagValue = this.getFlagVariants()[key]\n        const flagReportValue = `${flagValue}`\n        const flagCallReported: Record<string, string[]> = this.instance.get_property(FLAG_CALL_REPORTED) || {}\n\n        if (options.send_event || !('send_event' in options)) {\n            if (!(key in flagCallReported) || !flagCallReported[key].includes(flagReportValue)) {\n                if (isArray(flagCallReported[key])) {\n                    flagCallReported[key].push(flagReportValue)\n                } else {\n                    flagCallReported[key] = [flagReportValue]\n                }\n                this.instance.persistence?.register({ [FLAG_CALL_REPORTED]: flagCallReported })\n\n                this.instance.capture('$feature_flag_called', { $feature_flag: key, $feature_flag_response: flagValue })\n            }\n        }\n        return flagValue\n    }\n\n    getFeatureFlagPayload(key: string): JsonType {\n        const payloads = this.getFlagPayloads()\n        return payloads[key]\n    }\n\n    /*\n     * See if feature flag is enabled for user.\n     *\n     * ### Usage:\n     *\n     *     if(posthog.isFeatureEnabled('beta-feature')) { // do something }\n     *\n     * @param {Object|String} key Key of the feature flag.\n     * @param {Object|String} options (optional) If {send_event: false}, we won't send an $feature_flag_call event to PostHog.\n     */\n    isFeatureEnabled(key: string, options: { send_event?: boolean } = {}): boolean | undefined {\n        if (!this.instance.decideEndpointWasHit && !(this.getFlags() && this.getFlags().length > 0)) {\n            logger.warn('isFeatureEnabled for key \"' + key + '\" failed. Feature flags didn\\'t load in time.')\n            return undefined\n        }\n        return !!this.getFeatureFlag(key, options)\n    }\n\n    addFeatureFlagsHandler(handler: FeatureFlagsCallback): void {\n        this.featureFlagEventHandlers.push(handler)\n    }\n\n    removeFeatureFlagsHandler(handler: FeatureFlagsCallback): void {\n        this.featureFlagEventHandlers = this.featureFlagEventHandlers.filter((h) => h !== handler)\n    }\n\n    receivedFeatureFlags(response: Partial<DecideResponse>, errorsLoading?: boolean): void {\n        if (!this.instance.persistence) {\n            return\n        }\n        this.instance.decideEndpointWasHit = true\n        const currentFlags = this.getFlagVariants()\n        const currentFlagPayloads = this.getFlagPayloads()\n        parseFeatureFlagDecideResponse(response, this.instance.persistence, currentFlags, currentFlagPayloads)\n        this._fireFeatureFlagsCallbacks(errorsLoading)\n    }\n\n    /*\n     * Override feature flags on the client-side.  Useful for setting non-persistent feature flags, or for testing/debugging\n     * feature flags in the PostHog app.\n     *\n     * ### Usage:\n     *\n     *     - posthog.feature_flags.override(false)\n     *     - posthog.feature_flags.override(['beta-feature'])\n     *     - posthog.feature_flags.override({'beta-feature': 'variant', 'other-feature': true})\n     *     - posthog.feature_flags.override({'beta-feature': 'variant'}, true) // Suppress warning log\n     *\n     * @param {Object|Array|String} flags Flags to override with.\n     * @param {boolean} [suppressWarning=false] Optional parameter to suppress the override warning.\n     */\n    override(flags: boolean | string[] | Record<string, string | boolean>, suppressWarning: boolean = false): void {\n        if (!this.instance.__loaded || !this.instance.persistence) {\n            return logger.uninitializedWarning('posthog.feature_flags.override')\n        }\n\n        this._override_warning = suppressWarning\n\n        if (flags === false) {\n            this.instance.persistence.unregister(PERSISTENCE_OVERRIDE_FEATURE_FLAGS)\n        } else if (isArray(flags)) {\n            const flagsObj: Record<string, string | boolean> = {}\n            for (let i = 0; i < flags.length; i++) {\n                flagsObj[flags[i]] = true\n            }\n            this.instance.persistence.register({ [PERSISTENCE_OVERRIDE_FEATURE_FLAGS]: flagsObj })\n        } else {\n            this.instance.persistence.register({ [PERSISTENCE_OVERRIDE_FEATURE_FLAGS]: flags })\n        }\n    }\n    /*\n     * Register an event listener that runs when feature flags become available or when they change.\n     * If there are flags, the listener is called immediately in addition to being called on future changes.\n     *\n     * ### Usage:\n     *\n     *     posthog.onFeatureFlags(function(featureFlags) { // do something })\n     *\n     * @param {Function} [callback] The callback function will be called once the feature flags are ready or when they are updated.\n     *                              It'll return a list of feature flags enabled for the user.\n     * @returns {Function} A function that can be called to unsubscribe the listener. Used by useEffect when the component unmounts.\n     */\n    onFeatureFlags(callback: FeatureFlagsCallback): () => void {\n        this.addFeatureFlagsHandler(callback)\n        if (this.instance.decideEndpointWasHit) {\n            const { flags, flagVariants } = this._prepareFeatureFlagsForCallbacks()\n            callback(flags, flagVariants)\n        }\n        return () => this.removeFeatureFlagsHandler(callback)\n    }\n\n    updateEarlyAccessFeatureEnrollment(key: string, isEnrolled: boolean): void {\n        const enrollmentPersonProp = {\n            [`$feature_enrollment/${key}`]: isEnrolled,\n        }\n        this.instance.capture('$feature_enrollment_update', {\n            $feature_flag: key,\n            $feature_enrollment: isEnrolled,\n            $set: enrollmentPersonProp,\n        })\n        this.setPersonPropertiesForFlags(enrollmentPersonProp, false)\n\n        const newFlags = { ...this.getFlagVariants(), [key]: isEnrolled }\n        this.instance.persistence?.register({\n            [PERSISTENCE_ACTIVE_FEATURE_FLAGS]: Object.keys(filterActiveFeatureFlags(newFlags)),\n            [ENABLED_FEATURE_FLAGS]: newFlags,\n        })\n        this._fireFeatureFlagsCallbacks()\n    }\n\n    getEarlyAccessFeatures(callback: EarlyAccessFeatureCallback, force_reload = false): void {\n        const existing_early_access_features = this.instance.get_property(PERSISTENCE_EARLY_ACCESS_FEATURES)\n\n        if (!existing_early_access_features || force_reload) {\n            this.instance._send_request({\n                transport: 'XHR',\n                url: this.instance.requestRouter.endpointFor(\n                    'api',\n                    `/api/early_access_features/?token=${this.instance.config.token}`\n                ),\n                method: 'GET',\n                callback: (response) => {\n                    if (!response.json) {\n                        return\n                    }\n                    const earlyAccessFeatures = (response.json as EarlyAccessFeatureResponse).earlyAccessFeatures\n                    this.instance.persistence?.register({ [PERSISTENCE_EARLY_ACCESS_FEATURES]: earlyAccessFeatures })\n                    return callback(earlyAccessFeatures)\n                },\n            })\n        } else {\n            return callback(existing_early_access_features)\n        }\n    }\n\n    _prepareFeatureFlagsForCallbacks(): { flags: string[]; flagVariants: Record<string, string | boolean> } {\n        const flags = this.getFlags()\n        const flagVariants = this.getFlagVariants()\n\n        // Return truthy\n        const truthyFlags = flags.filter((flag) => flagVariants[flag])\n        const truthyFlagVariants = Object.keys(flagVariants)\n            .filter((variantKey) => flagVariants[variantKey])\n            .reduce((res: Record<string, string | boolean>, key) => {\n                res[key] = flagVariants[key]\n                return res\n            }, {})\n\n        return {\n            flags: truthyFlags,\n            flagVariants: truthyFlagVariants,\n        }\n    }\n\n    _fireFeatureFlagsCallbacks(errorsLoading?: boolean): void {\n        const { flags, flagVariants } = this._prepareFeatureFlagsForCallbacks()\n        this.featureFlagEventHandlers.forEach((handler) => handler(flags, flagVariants, { errorsLoading }))\n    }\n\n    /**\n     * Set override person properties for feature flags.\n     * This is used when dealing with new persons / where you don't want to wait for ingestion\n     * to update user properties.\n     */\n    setPersonPropertiesForFlags(properties: Properties, reloadFeatureFlags = true): void {\n        // Get persisted person properties\n        const existingProperties = this.instance.get_property(STORED_PERSON_PROPERTIES_KEY) || {}\n\n        this.instance.register({\n            [STORED_PERSON_PROPERTIES_KEY]: {\n                ...existingProperties,\n                ...properties,\n            },\n        })\n\n        if (reloadFeatureFlags) {\n            this.instance.reloadFeatureFlags()\n        }\n    }\n\n    resetPersonPropertiesForFlags(): void {\n        this.instance.unregister(STORED_PERSON_PROPERTIES_KEY)\n    }\n\n    /**\n     * Set override group properties for feature flags.\n     * This is used when dealing with new groups / where you don't want to wait for ingestion\n     * to update properties.\n     * Takes in an object, the key of which is the group type.\n     * For example:\n     *     setGroupPropertiesForFlags({'organization': { name: 'CYZ', employees: '11' } })\n     */\n    setGroupPropertiesForFlags(properties: { [type: string]: Properties }, reloadFeatureFlags = true): void {\n        // Get persisted group properties\n        const existingProperties = this.instance.get_property(STORED_GROUP_PROPERTIES_KEY) || {}\n\n        if (Object.keys(existingProperties).length !== 0) {\n            Object.keys(existingProperties).forEach((groupType) => {\n                existingProperties[groupType] = {\n                    ...existingProperties[groupType],\n                    ...properties[groupType],\n                }\n                delete properties[groupType]\n            })\n        }\n\n        this.instance.register({\n            [STORED_GROUP_PROPERTIES_KEY]: {\n                ...existingProperties,\n                ...properties,\n            },\n        })\n\n        if (reloadFeatureFlags) {\n            this.instance.reloadFeatureFlags()\n        }\n    }\n\n    resetGroupPropertiesForFlags(group_type?: string): void {\n        if (group_type) {\n            const existingProperties = this.instance.get_property(STORED_GROUP_PROPERTIES_KEY) || {}\n            this.instance.register({\n                [STORED_GROUP_PROPERTIES_KEY]: { ...existingProperties, [group_type]: {} },\n            })\n        } else {\n            this.instance.unregister(STORED_GROUP_PROPERTIES_KEY)\n        }\n    }\n}\n","/**\n * uuidv7: An experimental implementation of the proposed UUID Version 7\n *\n * @license Apache-2.0\n * @copyright 2021-2023 LiosK\n * @packageDocumentation\n *\n * from https://github.com/LiosK/uuidv7/blob/e501462ea3d23241de13192ceae726956f9b3b7d/src/index.ts\n */\n\n// polyfill for IE11\nimport { window } from './utils/globals'\n\nimport { isNumber, isUndefined } from './utils/type-utils'\n\nif (!Math.trunc) {\n    Math.trunc = function (v) {\n        return v < 0 ? Math.ceil(v) : Math.floor(v)\n    }\n}\n\n// polyfill for IE11\nif (!Number.isInteger) {\n    Number.isInteger = function (value) {\n        return isNumber(value) && isFinite(value) && Math.floor(value) === value\n    }\n}\n\nconst DIGITS = '0123456789abcdef'\n\n/** Represents a UUID as a 16-byte byte array. */\nexport class UUID {\n    /** @param bytes - The 16-byte byte array representation. */\n    constructor(readonly bytes: Readonly<Uint8Array>) {\n        if (bytes.length !== 16) {\n            throw new TypeError('not 128-bit length')\n        }\n    }\n\n    /**\n     * Builds a byte array from UUIDv7 field values.\n     *\n     * @param unixTsMs - A 48-bit `unix_ts_ms` field value.\n     * @param randA - A 12-bit `rand_a` field value.\n     * @param randBHi - The higher 30 bits of 62-bit `rand_b` field value.\n     * @param randBLo - The lower 32 bits of 62-bit `rand_b` field value.\n     */\n    static fromFieldsV7(unixTsMs: number, randA: number, randBHi: number, randBLo: number): UUID {\n        if (\n            !Number.isInteger(unixTsMs) ||\n            !Number.isInteger(randA) ||\n            !Number.isInteger(randBHi) ||\n            !Number.isInteger(randBLo) ||\n            unixTsMs < 0 ||\n            randA < 0 ||\n            randBHi < 0 ||\n            randBLo < 0 ||\n            unixTsMs > 0xffff_ffff_ffff ||\n            randA > 0xfff ||\n            randBHi > 0x3fff_ffff ||\n            randBLo > 0xffff_ffff\n        ) {\n            throw new RangeError('invalid field value')\n        }\n\n        const bytes = new Uint8Array(16)\n        bytes[0] = unixTsMs / 2 ** 40\n        bytes[1] = unixTsMs / 2 ** 32\n        bytes[2] = unixTsMs / 2 ** 24\n        bytes[3] = unixTsMs / 2 ** 16\n        bytes[4] = unixTsMs / 2 ** 8\n        bytes[5] = unixTsMs\n        bytes[6] = 0x70 | (randA >>> 8)\n        bytes[7] = randA\n        bytes[8] = 0x80 | (randBHi >>> 24)\n        bytes[9] = randBHi >>> 16\n        bytes[10] = randBHi >>> 8\n        bytes[11] = randBHi\n        bytes[12] = randBLo >>> 24\n        bytes[13] = randBLo >>> 16\n        bytes[14] = randBLo >>> 8\n        bytes[15] = randBLo\n        return new UUID(bytes)\n    }\n\n    /** @returns The 8-4-4-4-12 canonical hexadecimal string representation. */\n    toString(): string {\n        let text = ''\n        for (let i = 0; i < this.bytes.length; i++) {\n            text = text + DIGITS.charAt(this.bytes[i] >>> 4) + DIGITS.charAt(this.bytes[i] & 0xf)\n            if (i === 3 || i === 5 || i === 7 || i === 9) {\n                text += '-'\n            }\n        }\n\n        if (text.length !== 36) {\n            // We saw one customer whose bundling code was mangling the UUID generation\n            // rather than accept a bad UUID, we throw an error here.\n            throw new Error('Invalid UUIDv7 was generated')\n        }\n        return text\n    }\n\n    /** Creates an object from `this`. */\n    clone(): UUID {\n        return new UUID(this.bytes.slice(0))\n    }\n\n    /** Returns true if `this` is equivalent to `other`. */\n    equals(other: UUID): boolean {\n        return this.compareTo(other) === 0\n    }\n\n    /**\n     * Returns a negative integer, zero, or positive integer if `this` is less\n     * than, equal to, or greater than `other`, respectively.\n     */\n    compareTo(other: UUID): number {\n        for (let i = 0; i < 16; i++) {\n            const diff = this.bytes[i] - other.bytes[i]\n            if (diff !== 0) {\n                return Math.sign(diff)\n            }\n        }\n        return 0\n    }\n}\n\n/** Encapsulates the monotonic counter state. */\nclass V7Generator {\n    private timestamp = 0\n    private counter = 0\n    private readonly random = new DefaultRandom()\n\n    /**\n     * Generates a new UUIDv7 object from the current timestamp, or resets the\n     * generator upon significant timestamp rollback.\n     *\n     * This method returns monotonically increasing UUIDs unless the up-to-date\n     * timestamp is significantly (by ten seconds or more) smaller than the one\n     * embedded in the immediately preceding UUID. If such a significant clock\n     * rollback is detected, this method resets the generator and returns a new\n     * UUID based on the current timestamp.\n     */\n    generate(): UUID {\n        const value = this.generateOrAbort()\n        if (!isUndefined(value)) {\n            return value\n        } else {\n            // reset state and resume\n            this.timestamp = 0\n            const valueAfterReset = this.generateOrAbort()\n            if (isUndefined(valueAfterReset)) {\n                throw new Error('Could not generate UUID after timestamp reset')\n            }\n            return valueAfterReset\n        }\n    }\n\n    /**\n     * Generates a new UUIDv7 object from the current timestamp, or returns\n     * `undefined` upon significant timestamp rollback.\n     *\n     * This method returns monotonically increasing UUIDs unless the up-to-date\n     * timestamp is significantly (by ten seconds or more) smaller than the one\n     * embedded in the immediately preceding UUID. If such a significant clock\n     * rollback is detected, this method aborts and returns `undefined`.\n     */\n    generateOrAbort(): UUID | undefined {\n        const MAX_COUNTER = 0x3ff_ffff_ffff\n        const ROLLBACK_ALLOWANCE = 10_000 // 10 seconds\n\n        const ts = Date.now()\n        if (ts > this.timestamp) {\n            this.timestamp = ts\n            this.resetCounter()\n        } else if (ts + ROLLBACK_ALLOWANCE > this.timestamp) {\n            // go on with previous timestamp if new one is not much smaller\n            this.counter++\n            if (this.counter > MAX_COUNTER) {\n                // increment timestamp at counter overflow\n                this.timestamp++\n                this.resetCounter()\n            }\n        } else {\n            // abort if clock went backwards to unbearable extent\n            return undefined\n        }\n\n        return UUID.fromFieldsV7(\n            this.timestamp,\n            Math.trunc(this.counter / 2 ** 30),\n            this.counter & (2 ** 30 - 1),\n            this.random.nextUint32()\n        )\n    }\n\n    /** Initializes the counter at a 42-bit random integer. */\n    private resetCounter(): void {\n        this.counter = this.random.nextUint32() * 0x400 + (this.random.nextUint32() & 0x3ff)\n    }\n}\n\n/** A global flag to force use of cryptographically strong RNG. */\ndeclare const UUIDV7_DENY_WEAK_RNG: boolean\n\n/** Stores `crypto.getRandomValues()` available in the environment. */\nlet getRandomValues: <T extends Uint8Array | Uint32Array>(buffer: T) => T = (buffer) => {\n    // fall back on Math.random() unless the flag is set to true\n    // TRICKY: don't use the isUndefined method here as can't pass the reference\n    if (typeof UUIDV7_DENY_WEAK_RNG !== 'undefined' && UUIDV7_DENY_WEAK_RNG) {\n        throw new Error('no cryptographically strong RNG available')\n    }\n\n    for (let i = 0; i < buffer.length; i++) {\n        buffer[i] = Math.trunc(Math.random() * 0x1_0000) * 0x1_0000 + Math.trunc(Math.random() * 0x1_0000)\n    }\n    return buffer\n}\n\n// detect Web Crypto API\nif (window && !isUndefined(window.crypto) && crypto.getRandomValues) {\n    getRandomValues = (buffer) => crypto.getRandomValues(buffer)\n}\n\n/**\n * Wraps `crypto.getRandomValues()` and compatibles to enable buffering; this\n * uses a small buffer by default to avoid unbearable throughput decline in some\n * environments as well as the waste of time and space for unused values.\n */\nclass DefaultRandom {\n    private readonly buffer = new Uint32Array(8)\n    private cursor = Infinity\n    nextUint32(): number {\n        if (this.cursor >= this.buffer.length) {\n            getRandomValues(this.buffer)\n            this.cursor = 0\n        }\n        return this.buffer[this.cursor++]\n    }\n}\n\nlet defaultGenerator: V7Generator | undefined\n\n/**\n * Generates a UUIDv7 string.\n *\n * @returns The 8-4-4-4-12 canonical hexadecimal string representation\n * (\"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\").\n */\nexport const uuidv7 = (): string => uuidv7obj().toString()\n\n/** Generates a UUIDv7 object. */\nconst uuidv7obj = (): UUID => (defaultGenerator || (defaultGenerator = new V7Generator())).generate()\n\nexport const uuid7ToTimestampMs = (uuid: string): number => {\n    // remove hyphens\n    const hex = uuid.replace(/-/g, '')\n    // ensure that it's a version 7 UUID\n    if (hex.length !== 32) {\n        throw new Error('Not a valid UUID')\n    }\n    if (hex[12] !== '7') {\n        throw new Error('Not a UUIDv7')\n    }\n    // the first 6 bytes are the timestamp, which means that we can read only the first 12 hex characters\n    return parseInt(hex.substring(0, 12), 16)\n}\n","import { extend } from './utils'\nimport { PersistentStore, Properties } from './types'\nimport { DISTINCT_ID, ENABLE_PERSON_PROCESSING, SESSION_ID, SESSION_RECORDING_IS_SAMPLED } from './constants'\n\nimport { isNull, isUndefined } from './utils/type-utils'\nimport { logger } from './utils/logger'\nimport { window, document } from './utils/globals'\nimport { uuidv7 } from './uuidv7'\n\nconst Y1970 = 'Thu, 01 Jan 1970 00:00:00 GMT'\n// we store the discovered subdomain in memory because it might be read multiple times\nlet firstNonPublicSubDomain = ''\n\n// helper to allow tests to clear this \"cache\"\nexport const resetSubDomainCache = () => {\n    firstNonPublicSubDomain = ''\n}\n\n/**\n * Browsers don't offer a way to check if something is a public suffix\n * e.g. `.com.au`, `.io`, `.org.uk`\n *\n * But they do reject cookies set on public suffixes\n * Setting a cookie on `.co.uk` would mean it was sent for every `.co.uk` site visited\n *\n * So, we can use this to check if a domain is a public suffix\n * by trying to set a cookie on a subdomain of the provided hostname\n * until the browser accepts it\n *\n * inspired by https://github.com/AngusFu/browser-root-domain\n */\nexport function seekFirstNonPublicSubDomain(hostname: string, cookieJar = document): string {\n    if (firstNonPublicSubDomain) {\n        return firstNonPublicSubDomain\n    }\n\n    if (!cookieJar) {\n        return ''\n    }\n    if (['localhost', '127.0.0.1'].includes(hostname)) return ''\n\n    const list = hostname.split('.')\n    let len = Math.min(list.length, 8) // paranoia - we know this number should be small\n    const key = 'dmn_chk_' + uuidv7()\n    const R = new RegExp('(^|;)\\\\s*' + key + '=1')\n\n    while (!firstNonPublicSubDomain && len--) {\n        const candidate = list.slice(len).join('.')\n        const candidateCookieValue = key + '=1;domain=.' + candidate\n\n        // try to set cookie\n        cookieJar.cookie = candidateCookieValue\n\n        if (R.test(cookieJar.cookie)) {\n            // the cookie was accepted by the browser, remove the test cookie\n            cookieJar.cookie = candidateCookieValue + ';expires=' + Y1970\n            firstNonPublicSubDomain = candidate\n        }\n    }\n\n    return firstNonPublicSubDomain\n}\n\nconst DOMAIN_MATCH_REGEX = /[a-z0-9][a-z0-9-]+\\.[a-z]{2,}$/i\nconst originalCookieDomainFn = (hostname: string): string => {\n    const matches = hostname.match(DOMAIN_MATCH_REGEX)\n    return matches ? matches[0] : ''\n}\n\nexport function chooseCookieDomain(hostname: string, cross_subdomain: boolean | undefined): string {\n    if (cross_subdomain) {\n        // NOTE: Could we use this for cross domain tracking?\n        let matchedSubDomain = seekFirstNonPublicSubDomain(hostname)\n\n        if (!matchedSubDomain) {\n            const originalMatch = originalCookieDomainFn(hostname)\n            if (originalMatch !== matchedSubDomain) {\n                logger.info('Warning: cookie subdomain discovery mismatch', originalMatch, matchedSubDomain)\n            }\n            matchedSubDomain = originalMatch\n        }\n\n        return matchedSubDomain ? '; domain=.' + matchedSubDomain : ''\n    }\n    return ''\n}\n\n// Methods partially borrowed from quirksmode.org/js/cookies.html\nexport const cookieStore: PersistentStore = {\n    is_supported: () => !!document,\n\n    error: function (msg) {\n        logger.error('cookieStore error: ' + msg)\n    },\n\n    get: function (name) {\n        if (!document) {\n            return\n        }\n\n        try {\n            const nameEQ = name + '='\n            const ca = document.cookie.split(';').filter((x) => x.length)\n            for (let i = 0; i < ca.length; i++) {\n                let c = ca[i]\n                while (c.charAt(0) == ' ') {\n                    c = c.substring(1, c.length)\n                }\n                if (c.indexOf(nameEQ) === 0) {\n                    return decodeURIComponent(c.substring(nameEQ.length, c.length))\n                }\n            }\n        } catch (err) {}\n        return null\n    },\n\n    parse: function (name) {\n        let cookie\n        try {\n            cookie = JSON.parse(cookieStore.get(name)) || {}\n        } catch (err) {\n            // noop\n        }\n        return cookie\n    },\n\n    set: function (name, value, days, cross_subdomain, is_secure) {\n        if (!document) {\n            return\n        }\n        try {\n            let expires = '',\n                secure = ''\n\n            const cdomain = chooseCookieDomain(document.location.hostname, cross_subdomain)\n\n            if (days) {\n                const date = new Date()\n                date.setTime(date.getTime() + days * 24 * 60 * 60 * 1000)\n                expires = '; expires=' + date.toUTCString()\n            }\n\n            if (is_secure) {\n                secure = '; secure'\n            }\n\n            const new_cookie_val =\n                name +\n                '=' +\n                encodeURIComponent(JSON.stringify(value)) +\n                expires +\n                '; SameSite=Lax; path=/' +\n                cdomain +\n                secure\n\n            // 4096 bytes is the size at which some browsers (e.g. firefox) will not store a cookie, warn slightly before that\n            if (new_cookie_val.length > 4096 * 0.9) {\n                logger.warn('cookieStore warning: large cookie, len=' + new_cookie_val.length)\n            }\n\n            document.cookie = new_cookie_val\n            return new_cookie_val\n        } catch (err) {\n            return\n        }\n    },\n\n    remove: function (name, cross_subdomain) {\n        try {\n            cookieStore.set(name, '', -1, cross_subdomain)\n        } catch (err) {\n            return\n        }\n    },\n}\n\nlet _localStorage_supported: boolean | null = null\n\nexport const localStore: PersistentStore = {\n    is_supported: function () {\n        if (!isNull(_localStorage_supported)) {\n            return _localStorage_supported\n        }\n\n        let supported = true\n        if (!isUndefined(window)) {\n            try {\n                const key = '__mplssupport__',\n                    val = 'xyz'\n                localStore.set(key, val)\n                if (localStore.get(key) !== '\"xyz\"') {\n                    supported = false\n                }\n                localStore.remove(key)\n            } catch (err) {\n                supported = false\n            }\n        } else {\n            supported = false\n        }\n        if (!supported) {\n            logger.error('localStorage unsupported; falling back to cookie store')\n        }\n\n        _localStorage_supported = supported\n        return supported\n    },\n\n    error: function (msg) {\n        logger.error('localStorage error: ' + msg)\n    },\n\n    get: function (name) {\n        try {\n            return window?.localStorage.getItem(name)\n        } catch (err) {\n            localStore.error(err)\n        }\n        return null\n    },\n\n    parse: function (name) {\n        try {\n            return JSON.parse(localStore.get(name)) || {}\n        } catch (err) {\n            // noop\n        }\n        return null\n    },\n\n    set: function (name, value) {\n        try {\n            window?.localStorage.setItem(name, JSON.stringify(value))\n        } catch (err) {\n            localStore.error(err)\n        }\n    },\n\n    remove: function (name) {\n        try {\n            window?.localStorage.removeItem(name)\n        } catch (err) {\n            localStore.error(err)\n        }\n    },\n}\n\n// Use localstorage for most data but still use cookie for COOKIE_PERSISTED_PROPERTIES\n// This solves issues with cookies having too much data in them causing headers too large\n// Also makes sure we don't have to send a ton of data to the server\nconst COOKIE_PERSISTED_PROPERTIES = [DISTINCT_ID, SESSION_ID, SESSION_RECORDING_IS_SAMPLED, ENABLE_PERSON_PROCESSING]\n\nexport const localPlusCookieStore: PersistentStore = {\n    ...localStore,\n    parse: function (name) {\n        try {\n            let cookieProperties: Properties = {}\n            try {\n                // See if there's a cookie stored with data.\n                cookieProperties = cookieStore.parse(name) || {}\n            } catch (err) {}\n            const value = extend(cookieProperties, JSON.parse(localStore.get(name) || '{}'))\n            localStore.set(name, value)\n            return value\n        } catch (err) {\n            // noop\n        }\n        return null\n    },\n\n    set: function (name, value, days, cross_subdomain, is_secure, debug) {\n        try {\n            localStore.set(name, value, undefined, undefined, debug)\n            const cookiePersistedProperties: Record<string, any> = {}\n            COOKIE_PERSISTED_PROPERTIES.forEach((key) => {\n                if (value[key]) {\n                    cookiePersistedProperties[key] = value[key]\n                }\n            })\n\n            if (Object.keys(cookiePersistedProperties).length) {\n                cookieStore.set(name, cookiePersistedProperties, days, cross_subdomain, is_secure, debug)\n            }\n        } catch (err) {\n            localStore.error(err)\n        }\n    },\n\n    remove: function (name, cross_subdomain) {\n        try {\n            window?.localStorage.removeItem(name)\n            cookieStore.remove(name, cross_subdomain)\n        } catch (err) {\n            localStore.error(err)\n        }\n    },\n}\n\nconst memoryStorage: Properties = {}\n\n// Storage that only lasts the length of the pageview if we don't want to use cookies\nexport const memoryStore: PersistentStore = {\n    is_supported: function () {\n        return true\n    },\n\n    error: function (msg) {\n        logger.error('memoryStorage error: ' + msg)\n    },\n\n    get: function (name) {\n        return memoryStorage[name] || null\n    },\n\n    parse: function (name) {\n        return memoryStorage[name] || null\n    },\n\n    set: function (name, value) {\n        memoryStorage[name] = value\n    },\n\n    remove: function (name) {\n        delete memoryStorage[name]\n    },\n}\n\nlet sessionStorageSupported: boolean | null = null\nexport const resetSessionStorageSupported = () => {\n    sessionStorageSupported = null\n}\n// Storage that only lasts the length of a tab/window. Survives page refreshes\nexport const sessionStore: PersistentStore = {\n    is_supported: function () {\n        if (!isNull(sessionStorageSupported)) {\n            return sessionStorageSupported\n        }\n        sessionStorageSupported = true\n        if (!isUndefined(window)) {\n            try {\n                const key = '__support__',\n                    val = 'xyz'\n                sessionStore.set(key, val)\n                if (sessionStore.get(key) !== '\"xyz\"') {\n                    sessionStorageSupported = false\n                }\n                sessionStore.remove(key)\n            } catch (err) {\n                sessionStorageSupported = false\n            }\n        } else {\n            sessionStorageSupported = false\n        }\n        return sessionStorageSupported\n    },\n\n    error: function (msg) {\n        logger.error('sessionStorage error: ', msg)\n    },\n\n    get: function (name) {\n        try {\n            return window?.sessionStorage.getItem(name)\n        } catch (err) {\n            sessionStore.error(err)\n        }\n        return null\n    },\n\n    parse: function (name) {\n        try {\n            return JSON.parse(sessionStore.get(name)) || null\n        } catch (err) {\n            // noop\n        }\n        return null\n    },\n\n    set: function (name, value) {\n        try {\n            window?.sessionStorage.setItem(name, JSON.stringify(value))\n        } catch (err) {\n            sessionStore.error(err)\n        }\n    },\n\n    remove: function (name) {\n        try {\n            window?.sessionStorage.removeItem(name)\n        } catch (err) {\n            sessionStore.error(err)\n        }\n    },\n}\n","import { each, isValidRegex } from './'\n\nimport { isArray, isFile, isUndefined } from './type-utils'\nimport { logger } from './logger'\nimport { document } from './globals'\n\nconst localDomains = ['localhost', '127.0.0.1']\n\n/**\n * IE11 doesn't support `new URL`\n * so we can create an anchor element and use that to parse the URL\n * there's a lot of overlap between HTMLHyperlinkElementUtils and URL\n * meaning useful properties like `pathname` are available on both\n */\nexport const convertToURL = (url: string): HTMLAnchorElement | null => {\n    const location = document?.createElement('a')\n    if (isUndefined(location)) {\n        return null\n    }\n\n    location.href = url\n    return location\n}\n\nexport const isUrlMatchingRegex = function (url: string, pattern: string): boolean {\n    if (!isValidRegex(pattern)) return false\n    return new RegExp(pattern).test(url)\n}\n\nexport const formDataToQuery = function (formdata: Record<string, any> | FormData, arg_separator = '&'): string {\n    let use_val: string\n    let use_key: string\n    const tph_arr: string[] = []\n\n    each(formdata, function (val: File | string | undefined, key: string | undefined) {\n        // the key might be literally the string undefined for e.g. if {undefined: 'something'}\n        if (isUndefined(val) || isUndefined(key) || key === 'undefined') {\n            return\n        }\n\n        use_val = encodeURIComponent(isFile(val) ? val.name : val.toString())\n        use_key = encodeURIComponent(key)\n        tph_arr[tph_arr.length] = use_key + '=' + use_val\n    })\n\n    return tph_arr.join(arg_separator)\n}\n\nexport const getQueryParam = function (url: string, param: string): string {\n    const withoutHash: string = url.split('#')[0] || ''\n    const queryParams: string = withoutHash.split('?')[1] || ''\n\n    const queryParts = queryParams.split('&')\n    let keyValuePair\n\n    for (let i = 0; i < queryParts.length; i++) {\n        const parts = queryParts[i].split('=')\n        if (parts[0] === param) {\n            keyValuePair = parts\n            break\n        }\n    }\n\n    if (!isArray(keyValuePair) || keyValuePair.length < 2) {\n        return ''\n    } else {\n        let result = keyValuePair[1]\n        try {\n            result = decodeURIComponent(result)\n        } catch (err) {\n            logger.error('Skipping decoding for malformed query param: ' + result)\n        }\n        return result.replace(/\\+/g, ' ')\n    }\n}\n\nexport const _getHashParam = function (hash: string, param: string): string | null {\n    const matches = hash.match(new RegExp(param + '=([^&]*)'))\n    return matches ? matches[1] : null\n}\n\nexport const isLocalhost = (): boolean => {\n    return localDomains.includes(location.hostname)\n}\n","import { includes } from './index'\nimport { isFunction, isUndefined } from './type-utils'\n\n/**\n * this device detection code is (at time of writing) about 3% of the size of the entire library\n * this is mostly because the identifiers user in regexes and results can't be minified away since\n * they have meaning\n *\n * so, there are some pre-uglifying choices in the code to help reduce the size\n * e.g. many repeated strings are stored as variables and then old-fashioned concatenated together\n *\n * TL;DR here be dragons\n */\nconst FACEBOOK = 'Facebook'\nconst MOBILE = 'Mobile'\nconst IOS = 'iOS'\nconst ANDROID = 'Android'\nconst TABLET = 'Tablet'\nconst ANDROID_TABLET = ANDROID + ' ' + TABLET\nconst IPAD = 'iPad'\nconst APPLE = 'Apple'\nconst APPLE_WATCH = APPLE + ' Watch'\nconst SAFARI = 'Safari'\nconst BLACKBERRY = 'BlackBerry'\nconst SAMSUNG = 'Samsung'\nconst SAMSUNG_BROWSER = SAMSUNG + 'Browser'\nconst SAMSUNG_INTERNET = SAMSUNG + ' Internet'\nconst CHROME = 'Chrome'\nconst CHROME_OS = CHROME + ' OS'\nconst CHROME_IOS = CHROME + ' ' + IOS\nconst INTERNET_EXPLORER = 'Internet Explorer'\nconst INTERNET_EXPLORER_MOBILE = INTERNET_EXPLORER + ' ' + MOBILE\nconst OPERA = 'Opera'\nconst OPERA_MINI = OPERA + ' Mini'\nconst EDGE = 'Edge'\nconst MICROSOFT_EDGE = 'Microsoft ' + EDGE\nconst FIREFOX = 'Firefox'\nconst FIREFOX_IOS = FIREFOX + ' ' + IOS\nconst NINTENDO = 'Nintendo'\nconst PLAYSTATION = 'PlayStation'\nconst XBOX = 'Xbox'\nconst ANDROID_MOBILE = ANDROID + ' ' + MOBILE\nconst MOBILE_SAFARI = MOBILE + ' ' + SAFARI\nconst WINDOWS = 'Windows'\nconst WINDOWS_PHONE = WINDOWS + ' Phone'\nconst NOKIA = 'Nokia'\nconst OUYA = 'Ouya'\nconst GENERIC = 'Generic'\nconst GENERIC_MOBILE = GENERIC + ' ' + MOBILE.toLowerCase()\nconst GENERIC_TABLET = GENERIC + ' ' + TABLET.toLowerCase()\nconst KONQUEROR = 'Konqueror'\n\nconst BROWSER_VERSION_REGEX_SUFFIX = '(\\\\d+(\\\\.\\\\d+)?)'\nconst DEFAULT_BROWSER_VERSION_REGEX = new RegExp('Version/' + BROWSER_VERSION_REGEX_SUFFIX)\n\nconst XBOX_REGEX = new RegExp(XBOX, 'i')\nconst PLAYSTATION_REGEX = new RegExp(PLAYSTATION + ' \\\\w+', 'i')\nconst NINTENDO_REGEX = new RegExp(NINTENDO + ' \\\\w+', 'i')\nconst BLACKBERRY_REGEX = new RegExp(BLACKBERRY + '|PlayBook|BB10', 'i')\n\nconst windowsVersionMap: Record<string, string> = {\n    'NT3.51': 'NT 3.11',\n    'NT4.0': 'NT 4.0',\n    '5.0': '2000',\n    '5.1': 'XP',\n    '5.2': 'XP',\n    '6.0': 'Vista',\n    '6.1': '7',\n    '6.2': '8',\n    '6.3': '8.1',\n    '6.4': '10',\n    '10.0': '10',\n}\n\n/**\n * Safari detection turns out to be complicated. For e.g. https://stackoverflow.com/a/29696509\n * We can be slightly loose because some options have been ruled out (e.g. firefox on iOS)\n * before this check is made\n */\nfunction isSafari(userAgent: string): boolean {\n    return includes(userAgent, SAFARI) && !includes(userAgent, CHROME) && !includes(userAgent, ANDROID)\n}\n\nconst safariCheck = (ua: string, vendor?: string) => (vendor && includes(vendor, APPLE)) || isSafari(ua)\n\n/**\n * This function detects which browser is running this script.\n * The order of the checks are important since many user agents\n * include keywords used in later checks.\n */\nexport const detectBrowser = function (user_agent: string, vendor: string | undefined): string {\n    vendor = vendor || '' // vendor is undefined for at least IE9\n\n    if (includes(user_agent, ' OPR/') && includes(user_agent, 'Mini')) {\n        return OPERA_MINI\n    } else if (includes(user_agent, ' OPR/')) {\n        return OPERA\n    } else if (BLACKBERRY_REGEX.test(user_agent)) {\n        return BLACKBERRY\n    } else if (includes(user_agent, 'IE' + MOBILE) || includes(user_agent, 'WPDesktop')) {\n        return INTERNET_EXPLORER_MOBILE\n    }\n    // https://developer.samsung.com/internet/user-agent-string-format\n    else if (includes(user_agent, SAMSUNG_BROWSER)) {\n        return SAMSUNG_INTERNET\n    } else if (includes(user_agent, EDGE) || includes(user_agent, 'Edg/')) {\n        return MICROSOFT_EDGE\n    } else if (includes(user_agent, 'FBIOS')) {\n        return FACEBOOK + ' ' + MOBILE\n    } else if (includes(user_agent, 'UCWEB') || includes(user_agent, 'UCBrowser')) {\n        return 'UC Browser'\n    } else if (includes(user_agent, 'CriOS')) {\n        return CHROME_IOS // why not just Chrome?\n    } else if (includes(user_agent, 'CrMo')) {\n        return CHROME\n    } else if (includes(user_agent, ANDROID) && includes(user_agent, SAFARI)) {\n        return ANDROID_MOBILE\n    } else if (includes(user_agent, CHROME)) {\n        return CHROME\n    } else if (includes(user_agent, 'FxiOS')) {\n        return FIREFOX_IOS\n    } else if (includes(user_agent.toLowerCase(), KONQUEROR.toLowerCase())) {\n        return KONQUEROR\n    } else if (safariCheck(user_agent, vendor)) {\n        return includes(user_agent, MOBILE) ? MOBILE_SAFARI : SAFARI\n    } else if (includes(user_agent, FIREFOX)) {\n        return FIREFOX\n    } else if (includes(user_agent, 'MSIE') || includes(user_agent, 'Trident/')) {\n        return INTERNET_EXPLORER\n    } else if (includes(user_agent, 'Gecko')) {\n        return FIREFOX\n    }\n\n    return ''\n}\n\nconst versionRegexes: Record<string, RegExp[]> = {\n    [INTERNET_EXPLORER_MOBILE]: [new RegExp('rv:' + BROWSER_VERSION_REGEX_SUFFIX)],\n    [MICROSOFT_EDGE]: [new RegExp(EDGE + '?\\\\/' + BROWSER_VERSION_REGEX_SUFFIX)],\n    [CHROME]: [new RegExp('(' + CHROME + '|CrMo)\\\\/' + BROWSER_VERSION_REGEX_SUFFIX)],\n    [CHROME_IOS]: [new RegExp('CriOS\\\\/' + BROWSER_VERSION_REGEX_SUFFIX)],\n    'UC Browser': [new RegExp('(UCBrowser|UCWEB)\\\\/' + BROWSER_VERSION_REGEX_SUFFIX)],\n    [SAFARI]: [DEFAULT_BROWSER_VERSION_REGEX],\n    [MOBILE_SAFARI]: [DEFAULT_BROWSER_VERSION_REGEX],\n    [OPERA]: [new RegExp('(' + OPERA + '|OPR)\\\\/' + BROWSER_VERSION_REGEX_SUFFIX)],\n    [FIREFOX]: [new RegExp(FIREFOX + '\\\\/' + BROWSER_VERSION_REGEX_SUFFIX)],\n    [FIREFOX_IOS]: [new RegExp('FxiOS\\\\/' + BROWSER_VERSION_REGEX_SUFFIX)],\n    [KONQUEROR]: [new RegExp('Konqueror[:/]?' + BROWSER_VERSION_REGEX_SUFFIX, 'i')],\n    // not every blackberry user agent has the version after the name\n    [BLACKBERRY]: [new RegExp(BLACKBERRY + ' ' + BROWSER_VERSION_REGEX_SUFFIX), DEFAULT_BROWSER_VERSION_REGEX],\n    [ANDROID_MOBILE]: [new RegExp('android\\\\s' + BROWSER_VERSION_REGEX_SUFFIX, 'i')],\n    [SAMSUNG_INTERNET]: [new RegExp(SAMSUNG_BROWSER + '\\\\/' + BROWSER_VERSION_REGEX_SUFFIX)],\n    [INTERNET_EXPLORER]: [new RegExp('(rv:|MSIE )' + BROWSER_VERSION_REGEX_SUFFIX)],\n    Mozilla: [new RegExp('rv:' + BROWSER_VERSION_REGEX_SUFFIX)],\n}\n\n/**\n * This function detects which browser version is running this script,\n * parsing major and minor version (e.g., 42.1). User agent strings from:\n * http://www.useragentstring.com/pages/useragentstring.php\n *\n * `navigator.vendor` is passed in and used to help with detecting certain browsers\n * NB `navigator.vendor` is deprecated and not present in every browser\n */\nexport const detectBrowserVersion = function (userAgent: string, vendor: string | undefined): number | null {\n    const browser = detectBrowser(userAgent, vendor)\n    const regexes: RegExp[] | undefined = versionRegexes[browser as keyof typeof versionRegexes]\n    if (isUndefined(regexes)) {\n        return null\n    }\n\n    for (let i = 0; i < regexes.length; i++) {\n        const regex = regexes[i]\n        const matches = userAgent.match(regex)\n        if (matches) {\n            return parseFloat(matches[matches.length - 2])\n        }\n    }\n    return null\n}\n\n// to avoid repeating regexes or calling them twice, we have an array of matches\n// the first regex that matches uses its matcher function to return the result\nconst osMatchers: [\n    RegExp,\n    [string, string] | ((match: RegExpMatchArray | null, user_agent: string) => [string, string])\n][] = [\n    [\n        new RegExp(XBOX + '; ' + XBOX + ' (.*?)[);]', 'i'),\n        (match) => {\n            return [XBOX, (match && match[1]) || '']\n        },\n    ],\n    [new RegExp(NINTENDO, 'i'), [NINTENDO, '']],\n    [new RegExp(PLAYSTATION, 'i'), [PLAYSTATION, '']],\n    [BLACKBERRY_REGEX, [BLACKBERRY, '']],\n    [\n        new RegExp(WINDOWS, 'i'),\n        (_, user_agent) => {\n            if (/Phone/.test(user_agent) || /WPDesktop/.test(user_agent)) {\n                return [WINDOWS_PHONE, '']\n            }\n            // not all JS versions support negative lookbehind, so we need two checks here\n            if (new RegExp(MOBILE).test(user_agent) && !/IEMobile\\b/.test(user_agent)) {\n                return [WINDOWS + ' ' + MOBILE, '']\n            }\n            const match = /Windows NT ([0-9.]+)/i.exec(user_agent)\n            if (match && match[1]) {\n                const version = match[1]\n                let osVersion = windowsVersionMap[version] || ''\n                if (/arm/i.test(user_agent)) {\n                    osVersion = 'RT'\n                }\n                return [WINDOWS, osVersion]\n            }\n            return [WINDOWS, '']\n        },\n    ],\n    [\n        /((iPhone|iPad|iPod).*?OS (\\d+)_(\\d+)_?(\\d+)?|iPhone)/,\n        (match) => {\n            if (match && match[3]) {\n                const versionParts = [match[3], match[4], match[5] || '0']\n                return [IOS, versionParts.join('.')]\n            }\n            return [IOS, '']\n        },\n    ],\n    [\n        /(watch.*\\/(\\d+\\.\\d+\\.\\d+)|watch os,(\\d+\\.\\d+),)/i,\n        (match) => {\n            // e.g. Watch4,3/5.3.8 (16U680)\n            let version = ''\n            if (match && match.length >= 3) {\n                version = isUndefined(match[2]) ? match[3] : match[2]\n            }\n            return ['watchOS', version]\n        },\n    ],\n    [\n        new RegExp('(' + ANDROID + ' (\\\\d+)\\\\.(\\\\d+)\\\\.?(\\\\d+)?|' + ANDROID + ')', 'i'),\n        (match) => {\n            if (match && match[2]) {\n                const versionParts = [match[2], match[3], match[4] || '0']\n                return [ANDROID, versionParts.join('.')]\n            }\n            return [ANDROID, '']\n        },\n    ],\n    [\n        /Mac OS X (\\d+)[_.](\\d+)[_.]?(\\d+)?/i,\n        (match) => {\n            const result: [string, string] = ['Mac OS X', '']\n            if (match && match[1]) {\n                const versionParts = [match[1], match[2], match[3] || '0']\n                result[1] = versionParts.join('.')\n            }\n            return result\n        },\n    ],\n    [\n        /Mac/i,\n        // mop up a few non-standard UAs that should match mac\n        ['Mac OS X', ''],\n    ],\n    [/CrOS/, [CHROME_OS, '']],\n    [/Linux|debian/i, ['Linux', '']],\n]\n\nexport const detectOS = function (user_agent: string): [string, string] {\n    for (let i = 0; i < osMatchers.length; i++) {\n        const [rgex, resultOrFn] = osMatchers[i]\n        const match = rgex.exec(user_agent)\n        const result = match && (isFunction(resultOrFn) ? resultOrFn(match, user_agent) : resultOrFn)\n        if (result) {\n            return result\n        }\n    }\n    return ['', '']\n}\n\nexport const detectDevice = function (user_agent: string): string {\n    if (NINTENDO_REGEX.test(user_agent)) {\n        return NINTENDO\n    } else if (PLAYSTATION_REGEX.test(user_agent)) {\n        return PLAYSTATION\n    } else if (XBOX_REGEX.test(user_agent)) {\n        return XBOX\n    } else if (new RegExp(OUYA, 'i').test(user_agent)) {\n        return OUYA\n    } else if (new RegExp('(' + WINDOWS_PHONE + '|WPDesktop)', 'i').test(user_agent)) {\n        return WINDOWS_PHONE\n    } else if (/iPad/.test(user_agent)) {\n        return IPAD\n    } else if (/iPod/.test(user_agent)) {\n        return 'iPod Touch'\n    } else if (/iPhone/.test(user_agent)) {\n        return 'iPhone'\n    } else if (/(watch)(?: ?os[,/]|\\d,\\d\\/)[\\d.]+/i.test(user_agent)) {\n        return APPLE_WATCH\n    } else if (BLACKBERRY_REGEX.test(user_agent)) {\n        return BLACKBERRY\n    } else if (/(kobo)\\s(ereader|touch)/i.test(user_agent)) {\n        return 'Kobo'\n    } else if (new RegExp(NOKIA, 'i').test(user_agent)) {\n        return NOKIA\n    } else if (\n        // Kindle Fire without Silk / Echo Show\n        /(kf[a-z]{2}wi|aeo[c-r]{2})( bui|\\))/i.test(user_agent) ||\n        // Kindle Fire HD\n        /(kf[a-z]+)( bui|\\)).+silk\\//i.test(user_agent)\n    ) {\n        return 'Kindle Fire'\n    } else if (/(Android|ZTE)/i.test(user_agent)) {\n        if (\n            !new RegExp(MOBILE).test(user_agent) ||\n            /(9138B|TB782B|Nexus [97]|pixel c|HUAWEISHT|BTV|noble nook|smart ultra 6)/i.test(user_agent)\n        ) {\n            if (\n                (/pixel[\\daxl ]{1,6}/i.test(user_agent) && !/pixel c/i.test(user_agent)) ||\n                /(huaweimed-al00|tah-|APA|SM-G92|i980|zte|U304AA)/i.test(user_agent) ||\n                (/lmy47v/i.test(user_agent) && !/QTAQZ3/i.test(user_agent))\n            ) {\n                return ANDROID\n            }\n            return ANDROID_TABLET\n        } else {\n            return ANDROID\n        }\n    } else if (new RegExp('(pda|' + MOBILE + ')', 'i').test(user_agent)) {\n        return GENERIC_MOBILE\n    } else if (new RegExp(TABLET, 'i').test(user_agent) && !new RegExp(TABLET + ' pc', 'i').test(user_agent)) {\n        return GENERIC_TABLET\n    } else {\n        return ''\n    }\n}\n\nexport const detectDeviceType = function (user_agent: string): string {\n    const device = detectDevice(user_agent)\n    if (\n        device === IPAD ||\n        device === ANDROID_TABLET ||\n        device === 'Kobo' ||\n        device === 'Kindle Fire' ||\n        device === GENERIC_TABLET\n    ) {\n        return TABLET\n    } else if (device === NINTENDO || device === XBOX || device === PLAYSTATION || device === OUYA) {\n        return 'Console'\n    } else if (device === APPLE_WATCH) {\n        return 'Wearable'\n    } else if (device) {\n        return MOBILE\n    } else {\n        return 'Desktop'\n    }\n}\n","import { getQueryParam, convertToURL } from './request-utils'\nimport { isNull } from './type-utils'\nimport { Properties } from '../types'\nimport Config from '../config'\nimport { each, extend, stripEmptyProperties, stripLeadingDollar, timestamp } from './index'\nimport { document, location, userAgent, window } from './globals'\nimport { detectBrowser, detectBrowserVersion, detectDevice, detectDeviceType, detectOS } from './user-agent-utils'\n\nconst URL_REGEX_PREFIX = 'https?://(.*)'\n\n// Should be kept in sync with https://github.com/PostHog/posthog/blob/master/plugin-server/src/utils/db/utils.ts#L60\nexport const CAMPAIGN_PARAMS = [\n    'utm_source',\n    'utm_medium',\n    'utm_campaign',\n    'utm_content',\n    'utm_term',\n    'gclid', // google ads\n    'gad_source', // google ads\n    'gclsrc', // google ads 360\n    'dclid', // google display ads\n    'gbraid', // google ads, web to app\n    'wbraid', // google ads, app to web\n    'fbclid', // facebook\n    'msclkid', // microsoft\n    'twclid', // twitter\n    'li_fat_id', // linkedin\n    'mc_cid', // mailchimp campaign id\n    'igshid', // instagram\n    'ttclid', // tiktok\n    'rdt_cid', // reddit\n]\n\nexport const Info = {\n    campaignParams: function (customParams?: string[]): Record<string, string> {\n        if (!document) {\n            return {}\n        }\n        return this._campaignParamsFromUrl(document.URL, customParams)\n    },\n\n    _campaignParamsFromUrl: function (url: string, customParams?: string[]): Record<string, string> {\n        const campaign_keywords = CAMPAIGN_PARAMS.concat(customParams || [])\n\n        const params: Record<string, any> = {}\n        each(campaign_keywords, function (kwkey) {\n            const kw = getQueryParam(url, kwkey)\n            if (kw) {\n                params[kwkey] = kw\n            }\n        })\n\n        return params\n    },\n\n    _searchEngine: function (referrer: string): string | null {\n        if (!referrer) {\n            return null\n        } else {\n            if (referrer.search(URL_REGEX_PREFIX + 'google.([^/?]*)') === 0) {\n                return 'google'\n            } else if (referrer.search(URL_REGEX_PREFIX + 'bing.com') === 0) {\n                return 'bing'\n            } else if (referrer.search(URL_REGEX_PREFIX + 'yahoo.com') === 0) {\n                return 'yahoo'\n            } else if (referrer.search(URL_REGEX_PREFIX + 'duckduckgo.com') === 0) {\n                return 'duckduckgo'\n            } else {\n                return null\n            }\n        }\n    },\n\n    _searchInfoFromReferrer: function (referrer: string): Record<string, any> {\n        const search = Info._searchEngine(referrer)\n        const param = search != 'yahoo' ? 'q' : 'p'\n        const ret: Record<string, any> = {}\n\n        if (!isNull(search)) {\n            ret['$search_engine'] = search\n\n            const keyword = document ? getQueryParam(document.referrer, param) : ''\n            if (keyword.length) {\n                ret['ph_keyword'] = keyword\n            }\n        }\n\n        return ret\n    },\n\n    searchInfo: function (): Record<string, any> {\n        const referrer = document?.referrer\n        if (!referrer) {\n            return {}\n        }\n        return this._searchInfoFromReferrer(referrer)\n    },\n\n    /**\n     * This function detects which browser is running this script.\n     * The order of the checks are important since many user agents\n     * include keywords used in later checks.\n     */\n    browser: detectBrowser,\n\n    /**\n     * This function detects which browser version is running this script,\n     * parsing major and minor version (e.g., 42.1). User agent strings from:\n     * http://www.useragentstring.com/pages/useragentstring.php\n     *\n     * `navigator.vendor` is passed in and used to help with detecting certain browsers\n     * NB `navigator.vendor` is deprecated and not present in every browser\n     */\n    browserVersion: detectBrowserVersion,\n\n    browserLanguage: function (): string {\n        return (\n            navigator.language || // Any modern browser\n            (navigator as Record<string, any>).userLanguage // IE11\n        )\n    },\n\n    os: detectOS,\n\n    device: detectDevice,\n\n    deviceType: detectDeviceType,\n\n    referrer: function (): string {\n        return document?.referrer || '$direct'\n    },\n\n    referringDomain: function (): string {\n        if (!document?.referrer) {\n            return '$direct'\n        }\n        return convertToURL(document.referrer)?.host || '$direct'\n    },\n\n    referrerInfo: function (): Record<string, any> {\n        return {\n            $referrer: this.referrer(),\n            $referring_domain: this.referringDomain(),\n        }\n    },\n\n    initialPersonInfo: function (): Record<string, any> {\n        // we're being a bit more economical with bytes here because this is stored in the cookie\n        return {\n            r: this.referrer(),\n            u: location?.href,\n        }\n    },\n\n    initialPersonPropsFromInfo: function (info: Record<string, any>): Record<string, any> {\n        const { r: initial_referrer, u: initial_current_url } = info\n        const referring_domain =\n            initial_referrer == null\n                ? undefined\n                : initial_referrer == '$direct'\n                ? '$direct'\n                : convertToURL(initial_referrer)?.host\n\n        const props: Record<string, string | undefined> = {\n            $initial_referrer: initial_referrer,\n            $initial_referring_domain: referring_domain,\n        }\n        if (initial_current_url) {\n            props['$initial_current_url'] = initial_current_url\n            const location = convertToURL(initial_current_url)\n            props['$initial_host'] = location?.host\n            props['$initial_pathname'] = location?.pathname\n            const campaignParams = this._campaignParamsFromUrl(initial_current_url)\n            each(campaignParams, function (v, k: string) {\n                props['$initial_' + stripLeadingDollar(k)] = v\n            })\n        }\n        if (initial_referrer) {\n            const searchInfo = this._searchInfoFromReferrer(initial_referrer)\n            each(searchInfo, function (v, k: string) {\n                props['$initial_' + stripLeadingDollar(k)] = v\n            })\n        }\n        return props\n    },\n\n    properties: function (): Properties {\n        if (!userAgent) {\n            return {}\n        }\n        const [os_name, os_version] = Info.os(userAgent)\n        return extend(\n            stripEmptyProperties({\n                $os: os_name,\n                $os_version: os_version,\n                $browser: Info.browser(userAgent, navigator.vendor),\n                $device: Info.device(userAgent),\n                $device_type: Info.deviceType(userAgent),\n            }),\n            {\n                $current_url: location?.href,\n                $host: location?.host,\n                $pathname: location?.pathname,\n                $raw_user_agent: userAgent.length > 1000 ? userAgent.substring(0, 997) + '...' : userAgent,\n                $browser_version: Info.browserVersion(userAgent, navigator.vendor),\n                $browser_language: Info.browserLanguage(),\n                $screen_height: window?.screen.height,\n                $screen_width: window?.screen.width,\n                $viewport_height: window?.innerHeight,\n                $viewport_width: window?.innerWidth,\n                $lib: 'web',\n                $lib_version: Config.LIB_VERSION,\n                $insert_id: Math.random().toString(36).substring(2, 10) + Math.random().toString(36).substring(2, 10),\n                $time: timestamp() / 1000, // epoch time in seconds\n            }\n        )\n    },\n\n    people_properties: function (): Properties {\n        if (!userAgent) {\n            return {}\n        }\n\n        const [os_name, os_version] = Info.os(userAgent)\n        return extend(\n            stripEmptyProperties({\n                $os: os_name,\n                $os_version: os_version,\n                $browser: Info.browser(userAgent, navigator.vendor),\n            }),\n            {\n                $browser_version: Info.browserVersion(userAgent, navigator.vendor),\n            }\n        )\n    },\n}\n","/* eslint camelcase: \"off\" */\n\nimport { each, extend, include, stripEmptyProperties, stripLeadingDollar } from './utils'\nimport { cookieStore, localPlusCookieStore, localStore, memoryStore, sessionStore } from './storage'\nimport { PersistentStore, PostHogConfig, Properties } from './types'\nimport {\n    ENABLED_FEATURE_FLAGS,\n    EVENT_TIMERS_KEY,\n    INITIAL_CAMPAIGN_PARAMS,\n    INITIAL_PERSON_INFO,\n    INITIAL_REFERRER_INFO,\n    PERSISTENCE_RESERVED_PROPERTIES,\n} from './constants'\n\nimport { isObject, isUndefined } from './utils/type-utils'\nimport { Info } from './utils/event-utils'\nimport { logger } from './utils/logger'\n\nconst CASE_INSENSITIVE_PERSISTENCE_TYPES: readonly Lowercase<PostHogConfig['persistence']>[] = [\n    'cookie',\n    'localstorage',\n    'localstorage+cookie',\n    'sessionstorage',\n    'memory',\n]\n\nconst parseName = (config: PostHogConfig): string => {\n    let token = ''\n    if (config['token']) {\n        token = config['token'].replace(/\\+/g, 'PL').replace(/\\//g, 'SL').replace(/=/g, 'EQ')\n    }\n\n    if (config['persistence_name']) {\n        return 'ph_' + config['persistence_name']\n    } else {\n        return 'ph_' + token + '_posthog'\n    }\n}\n\n/**\n * PostHog Persistence Object\n * @constructor\n */\nexport class PostHogPersistence {\n    private config: PostHogConfig\n    props: Properties\n    storage: PersistentStore\n    campaign_params_saved: boolean\n    name: string\n    disabled: boolean | undefined\n    secure: boolean | undefined\n    expire_days: number | undefined\n    default_expiry: number | undefined\n    cross_subdomain: boolean | undefined\n\n    constructor(config: PostHogConfig) {\n        this.config = config\n        this.props = {}\n        this.campaign_params_saved = false\n        this.name = parseName(config)\n        this.storage = this.buildStorage(config)\n        this.load()\n        if (config.debug) {\n            logger.info('Persistence loaded', config['persistence'], { ...this.props })\n        }\n        this.update_config(config, config)\n        this.save()\n    }\n\n    private buildStorage(config: PostHogConfig) {\n        if (\n            CASE_INSENSITIVE_PERSISTENCE_TYPES.indexOf(\n                config['persistence'].toLowerCase() as Lowercase<PostHogConfig['persistence']>\n            ) === -1\n        ) {\n            logger.critical(\n                'Unknown persistence type ' + config['persistence'] + '; falling back to localStorage+cookie'\n            )\n            config['persistence'] = 'localStorage+cookie'\n        }\n\n        let store: PersistentStore\n        // We handle storage type in a case-insensitive way for backwards compatibility\n        const storage_type = config['persistence'].toLowerCase() as Lowercase<PostHogConfig['persistence']>\n        if (storage_type === 'localstorage' && localStore.is_supported()) {\n            store = localStore\n        } else if (storage_type === 'localstorage+cookie' && localPlusCookieStore.is_supported()) {\n            store = localPlusCookieStore\n        } else if (storage_type === 'sessionstorage' && sessionStore.is_supported()) {\n            store = sessionStore\n        } else if (storage_type === 'memory') {\n            store = memoryStore\n        } else if (storage_type === 'cookie') {\n            store = cookieStore\n        } else if (localPlusCookieStore.is_supported()) {\n            // selected storage type wasn't supported, fallback to 'localstorage+cookie' if possible\n            store = localPlusCookieStore\n        } else {\n            store = cookieStore\n        }\n\n        return store\n    }\n\n    properties(): Properties {\n        const p: Properties = {}\n        // Filter out reserved properties\n        each(this.props, function (v, k) {\n            if (k === ENABLED_FEATURE_FLAGS && isObject(v)) {\n                const keys = Object.keys(v)\n                for (let i = 0; i < keys.length; i++) {\n                    p[`$feature/${keys[i]}`] = v[keys[i]]\n                }\n            } else if (!include(PERSISTENCE_RESERVED_PROPERTIES, k)) {\n                p[k] = v\n            }\n        })\n        return p\n    }\n\n    load(): void {\n        if (this.disabled) {\n            return\n        }\n\n        const entry = this.storage.parse(this.name)\n\n        if (entry) {\n            this.props = extend({}, entry)\n        }\n    }\n\n    /**\n     * NOTE: Saving frequently causes issues with Recordings and Consent Management Platform (CMP) tools which\n     * observe cookie changes, and modify their UI, often causing infinite loops.\n     * As such callers of this should ideally check that the data has changed beforehand\n     */\n    save(): void {\n        if (this.disabled) {\n            return\n        }\n        this.storage.set(this.name, this.props, this.expire_days, this.cross_subdomain, this.secure, this.config.debug)\n    }\n\n    remove(): void {\n        // remove both domain and subdomain cookies\n        this.storage.remove(this.name, false)\n        this.storage.remove(this.name, true)\n    }\n\n    // removes the storage entry and deletes all loaded data\n    // forced name for tests\n\n    clear(): void {\n        this.remove()\n        this.props = {}\n    }\n\n    /**\n     * @param {Object} props\n     * @param {*=} default_value\n     * @param {number=} days\n     */\n\n    register_once(props: Properties, default_value: any, days?: number): boolean {\n        if (isObject(props)) {\n            if (isUndefined(default_value)) {\n                default_value = 'None'\n            }\n            this.expire_days = isUndefined(days) ? this.default_expiry : days\n\n            let hasChanges = false\n\n            each(props, (val, prop) => {\n                if (!this.props.hasOwnProperty(prop) || this.props[prop] === default_value) {\n                    this.props[prop] = val\n                    hasChanges = true\n                }\n            })\n\n            if (hasChanges) {\n                this.save()\n                return true\n            }\n        }\n        return false\n    }\n\n    /**\n     * @param {Object} props\n     * @param {number=} days\n     */\n\n    register(props: Properties, days?: number): boolean {\n        if (isObject(props)) {\n            this.expire_days = isUndefined(days) ? this.default_expiry : days\n\n            let hasChanges = false\n\n            each(props, (val, prop) => {\n                if (props.hasOwnProperty(prop) && this.props[prop] !== val) {\n                    this.props[prop] = val\n                    hasChanges = true\n                }\n            })\n\n            if (hasChanges) {\n                this.save()\n                return true\n            }\n        }\n        return false\n    }\n\n    unregister(prop: string): void {\n        if (prop in this.props) {\n            delete this.props[prop]\n            this.save()\n        }\n    }\n\n    update_campaign_params(): void {\n        if (!this.campaign_params_saved) {\n            this.register(Info.campaignParams(this.config.custom_campaign_params))\n            this.campaign_params_saved = true\n        }\n    }\n    update_search_keyword(): void {\n        this.register(Info.searchInfo())\n    }\n\n    update_referrer_info(): void {\n        this.register_once(Info.referrerInfo(), undefined)\n    }\n\n    set_initial_person_info(): void {\n        if (this.props[INITIAL_CAMPAIGN_PARAMS] || this.props[INITIAL_REFERRER_INFO]) {\n            // the user has initial properties stored the previous way, don't save them again\n            return\n        }\n\n        this.register_once(\n            {\n                [INITIAL_PERSON_INFO]: Info.initialPersonInfo(),\n            },\n            undefined\n        )\n    }\n\n    get_referrer_info(): Properties {\n        return stripEmptyProperties({\n            $referrer: this['props']['$referrer'],\n            $referring_domain: this['props']['$referring_domain'],\n        })\n    }\n\n    get_initial_props(): Properties {\n        const p: Properties = {}\n\n        // this section isn't written to anymore, but we should keep reading from it for backwards compatibility\n        // for a while\n        each([INITIAL_REFERRER_INFO, INITIAL_CAMPAIGN_PARAMS], (key) => {\n            const initialReferrerInfo = this.props[key]\n            if (initialReferrerInfo) {\n                each(initialReferrerInfo, function (v, k) {\n                    p['$initial_' + stripLeadingDollar(k)] = v\n                })\n            }\n        })\n        const initialPersonInfo = this.props[INITIAL_PERSON_INFO]\n        if (initialPersonInfo) {\n            const initialPersonProps = Info.initialPersonPropsFromInfo(initialPersonInfo)\n            extend(p, initialPersonProps)\n        }\n\n        return p\n    }\n\n    // safely fills the passed in object with stored properties,\n    // does not override any properties defined in both\n    // returns the passed in object\n\n    safe_merge(props: Properties): Properties {\n        each(this.props, function (val, prop) {\n            if (!(prop in props)) {\n                props[prop] = val\n            }\n        })\n\n        return props\n    }\n\n    update_config(config: PostHogConfig, oldConfig: PostHogConfig): void {\n        this.default_expiry = this.expire_days = config['cookie_expiration']\n        this.set_disabled(config['disable_persistence'])\n        this.set_cross_subdomain(config['cross_subdomain_cookie'])\n        this.set_secure(config['secure_cookie'])\n\n        if (config.persistence !== oldConfig.persistence) {\n            // If the persistence type has changed, we need to migrate the data.\n            const newStore = this.buildStorage(config)\n            const props = this.props\n\n            // clear the old store\n            this.clear()\n            this.storage = newStore\n            this.props = props\n\n            this.save()\n        }\n    }\n\n    set_disabled(disabled: boolean): void {\n        this.disabled = disabled\n        if (this.disabled) {\n            this.remove()\n        } else {\n            this.save()\n        }\n    }\n\n    set_cross_subdomain(cross_subdomain: boolean): void {\n        if (cross_subdomain !== this.cross_subdomain) {\n            this.cross_subdomain = cross_subdomain\n            this.remove()\n            this.save()\n        }\n    }\n\n    get_cross_subdomain(): boolean {\n        return !!this.cross_subdomain\n    }\n\n    set_secure(secure: boolean): void {\n        if (secure !== this.secure) {\n            this.secure = secure\n            this.remove()\n            this.save()\n        }\n    }\n\n    set_event_timer(event_name: string, timestamp: number): void {\n        const timers = this.props[EVENT_TIMERS_KEY] || {}\n        timers[event_name] = timestamp\n        this.props[EVENT_TIMERS_KEY] = timers\n        this.save()\n    }\n\n    remove_event_timer(event_name: string): number {\n        const timers = this.props[EVENT_TIMERS_KEY] || {}\n        const timestamp = timers[event_name]\n        if (!isUndefined(timestamp)) {\n            delete this.props[EVENT_TIMERS_KEY][event_name]\n            this.save()\n        }\n        return timestamp\n    }\n\n    get_property(prop: string): any {\n        return this.props[prop]\n    }\n\n    set_property(prop: string, to: any): void {\n        this.props[prop] = to\n        this.save()\n    }\n}\n","import type {\n    blockClass,\n    eventWithTime,\n    hooksParam,\n    KeepIframeSrcFn,\n    listenerHandler,\n    maskTextClass,\n    pluginEvent,\n    RecordPlugin,\n    SamplingStrategy,\n} from '@rrweb/types'\nimport type { DataURLOptions, MaskInputFn, MaskInputOptions, MaskTextFn, Mirror, SlimDOMOptions } from 'rrweb-snapshot'\n\nimport { isObject } from '../../utils/type-utils'\nimport { SnapshotBuffer } from './sessionrecording'\n\n// taken from https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Cyclic_object_value#circular_references\nexport function circularReferenceReplacer() {\n    const ancestors: any[] = []\n    return function (this: any, _key: string, value: any) {\n        if (isObject(value)) {\n            // `this` is the object that value is contained in,\n            // i.e., its direct parent.\n            while (ancestors.length > 0 && ancestors.at(-1) !== this) {\n                ancestors.pop()\n            }\n            if (ancestors.includes(value)) {\n                return '[Circular]'\n            }\n            ancestors.push(value)\n            return value\n        } else {\n            return value\n        }\n    }\n}\n\nexport function estimateSize(sizeable: unknown): number {\n    return JSON.stringify(sizeable, circularReferenceReplacer()).length\n}\n\nexport const replacementImageURI =\n    'data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMTYiIGhlaWdodD0iMTYiIHZpZXdCb3g9IjAgMCAxNiAxNiIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPHJlY3Qgd2lkdGg9IjE2IiBoZWlnaHQ9IjE2IiBmaWxsPSJibGFjayIvPgo8cGF0aCBkPSJNOCAwSDE2TDAgMTZWOEw4IDBaIiBmaWxsPSIjMkQyRDJEIi8+CjxwYXRoIGQ9Ik0xNiA4VjE2SDhMMTYgOFoiIGZpbGw9IiMyRDJEMkQiLz4KPC9zdmc+Cg=='\n\nexport const FULL_SNAPSHOT_EVENT_TYPE = 2\nexport const META_EVENT_TYPE = 4\nexport const INCREMENTAL_SNAPSHOT_EVENT_TYPE = 3\nexport const PLUGIN_EVENT_TYPE = 6\nexport const MUTATION_SOURCE_TYPE = 0\n\nexport const MAX_MESSAGE_SIZE = 5000000 // ~5mb\n\nexport type rrwebRecord = {\n    (options: recordOptions<eventWithTime>): listenerHandler\n    addCustomEvent: (tag: string, payload: any) => void\n    takeFullSnapshot: () => void\n    mirror: Mirror\n}\n\nexport declare type recordOptions<T> = {\n    emit?: (e: T, isCheckout?: boolean) => void\n    checkoutEveryNth?: number\n    checkoutEveryNms?: number\n    blockClass?: blockClass\n    blockSelector?: string\n    ignoreClass?: string\n    maskTextClass?: maskTextClass\n    maskTextSelector?: string\n    maskAllInputs?: boolean\n    maskInputOptions?: MaskInputOptions\n    maskInputFn?: MaskInputFn\n    maskTextFn?: MaskTextFn\n    slimDOMOptions?: SlimDOMOptions | 'all' | true\n    ignoreCSSAttributes?: Set<string>\n    inlineStylesheet?: boolean\n    hooks?: hooksParam\n    // packFn?: PackFn\n    sampling?: SamplingStrategy\n    dataURLOptions?: DataURLOptions\n    recordCanvas?: boolean\n    recordCrossOriginIframes?: boolean\n    recordAfter?: 'DOMContentLoaded' | 'load'\n    userTriggeredOnInput?: boolean\n    collectFonts?: boolean\n    inlineImages?: boolean\n    plugins?: RecordPlugin[]\n    mousemoveWait?: number\n    keepIframeSrcFn?: KeepIframeSrcFn\n    // errorHandler?: ErrorHandler\n}\n\n/*\n * Check whether a data payload is nearing 5mb. If it is, it checks the data for\n * data URIs (the likely culprit for large payloads). If it finds data URIs, it either replaces\n * it with a generic image (if it's an image) or removes it.\n * @data {object} the rr-web data object\n * @returns {object} the rr-web data object with data uris filtered out\n */\nexport function ensureMaxMessageSize(data: eventWithTime): { event: eventWithTime; size: number } {\n    let stringifiedData = JSON.stringify(data)\n    // Note: with compression, this limit may be able to be increased\n    // but we're assuming most of the size is from a data uri which\n    // is unlikely to be compressed further\n\n    if (stringifiedData.length > MAX_MESSAGE_SIZE) {\n        // Regex that matches the pattern for a dataURI with the shape 'data:{mime type};{encoding},{data}'. It:\n        // 1) Checks if the pattern starts with 'data:' (potentially, not at the start of the string)\n        // 2) Extracts the mime type of the data uri in the first group\n        // 3) Determines when the data URI ends.Depending on if it's used in the src tag or css, it can end with a ) or \"\n        const dataURIRegex = /data:([\\w/\\-.]+);(\\w+),([^)\"]*)/gim\n        const matches = stringifiedData.matchAll(dataURIRegex)\n        for (const match of matches) {\n            if (match[1].toLocaleLowerCase().slice(0, 6) === 'image/') {\n                stringifiedData = stringifiedData.replace(match[0], replacementImageURI)\n            } else {\n                stringifiedData = stringifiedData.replace(match[0], '')\n            }\n        }\n    }\n    return { event: JSON.parse(stringifiedData), size: stringifiedData.length }\n}\n\nexport const CONSOLE_LOG_PLUGIN_NAME = 'rrweb/console@1' // The name of the rr-web plugin that emits console logs\n\n// Console logs can be really large. This function truncates large logs\n// It's a simple function that just truncates long strings.\n// TODO: Ideally this function would have better handling of objects + lists,\n// so they could still be rendered in a pretty way after truncation.\nexport function truncateLargeConsoleLogs(_event: eventWithTime) {\n    const event = _event as pluginEvent<{ payload: string[] }>\n\n    const MAX_STRING_SIZE = 2000 // Maximum number of characters allowed in a string\n    const MAX_STRINGS_PER_LOG = 10 // A log can consist of multiple strings (e.g. consol.log('string1', 'string2'))\n\n    if (\n        event &&\n        isObject(event) &&\n        event.type === PLUGIN_EVENT_TYPE &&\n        isObject(event.data) &&\n        event.data.plugin === CONSOLE_LOG_PLUGIN_NAME\n    ) {\n        // Note: event.data.payload.payload comes from rr-web, and is an array of strings\n        if (event.data.payload.payload.length > MAX_STRINGS_PER_LOG) {\n            event.data.payload.payload = event.data.payload.payload.slice(0, MAX_STRINGS_PER_LOG)\n            event.data.payload.payload.push('...[truncated]')\n        }\n        const updatedPayload = []\n        for (let i = 0; i < event.data.payload.payload.length; i++) {\n            if (\n                event.data.payload.payload[i] && // Value can be null\n                event.data.payload.payload[i].length > MAX_STRING_SIZE\n            ) {\n                updatedPayload.push(event.data.payload.payload[i].slice(0, MAX_STRING_SIZE) + '...[truncated]')\n            } else {\n                updatedPayload.push(event.data.payload.payload[i])\n            }\n        }\n        event.data.payload.payload = updatedPayload\n        // Return original type\n        return _event\n    }\n    return _event\n}\n\nexport const SEVEN_MEGABYTES = 1024 * 1024 * 7 * 0.9 // ~7mb (with some wiggle room)\n\n// recursively splits large buffers into smaller ones\n// uses a pretty high size limit to avoid splitting too much\nexport function splitBuffer(buffer: SnapshotBuffer, sizeLimit: number = SEVEN_MEGABYTES): SnapshotBuffer[] {\n    if (buffer.size >= sizeLimit && buffer.data.length > 1) {\n        const half = Math.floor(buffer.data.length / 2)\n        const firstHalf = buffer.data.slice(0, half)\n        const secondHalf = buffer.data.slice(half)\n        return [\n            splitBuffer({\n                size: estimateSize(firstHalf),\n                data: firstHalf,\n                sessionId: buffer.sessionId,\n                windowId: buffer.windowId,\n            }),\n            splitBuffer({\n                size: estimateSize(secondHalf),\n                data: secondHalf,\n                sessionId: buffer.sessionId,\n                windowId: buffer.windowId,\n            }),\n        ].flatMap((x) => x)\n    } else {\n        return [buffer]\n    }\n}\n","var EventType = /* @__PURE__ */ ((EventType2) => {\n  EventType2[EventType2[\"DomContentLoaded\"] = 0] = \"DomContentLoaded\";\n  EventType2[EventType2[\"Load\"] = 1] = \"Load\";\n  EventType2[EventType2[\"FullSnapshot\"] = 2] = \"FullSnapshot\";\n  EventType2[EventType2[\"IncrementalSnapshot\"] = 3] = \"IncrementalSnapshot\";\n  EventType2[EventType2[\"Meta\"] = 4] = \"Meta\";\n  EventType2[EventType2[\"Custom\"] = 5] = \"Custom\";\n  EventType2[EventType2[\"Plugin\"] = 6] = \"Plugin\";\n  return EventType2;\n})(EventType || {});\nvar IncrementalSource = /* @__PURE__ */ ((IncrementalSource2) => {\n  IncrementalSource2[IncrementalSource2[\"Mutation\"] = 0] = \"Mutation\";\n  IncrementalSource2[IncrementalSource2[\"MouseMove\"] = 1] = \"MouseMove\";\n  IncrementalSource2[IncrementalSource2[\"MouseInteraction\"] = 2] = \"MouseInteraction\";\n  IncrementalSource2[IncrementalSource2[\"Scroll\"] = 3] = \"Scroll\";\n  IncrementalSource2[IncrementalSource2[\"ViewportResize\"] = 4] = \"ViewportResize\";\n  IncrementalSource2[IncrementalSource2[\"Input\"] = 5] = \"Input\";\n  IncrementalSource2[IncrementalSource2[\"TouchMove\"] = 6] = \"TouchMove\";\n  IncrementalSource2[IncrementalSource2[\"MediaInteraction\"] = 7] = \"MediaInteraction\";\n  IncrementalSource2[IncrementalSource2[\"StyleSheetRule\"] = 8] = \"StyleSheetRule\";\n  IncrementalSource2[IncrementalSource2[\"CanvasMutation\"] = 9] = \"CanvasMutation\";\n  IncrementalSource2[IncrementalSource2[\"Font\"] = 10] = \"Font\";\n  IncrementalSource2[IncrementalSource2[\"Log\"] = 11] = \"Log\";\n  IncrementalSource2[IncrementalSource2[\"Drag\"] = 12] = \"Drag\";\n  IncrementalSource2[IncrementalSource2[\"StyleDeclaration\"] = 13] = \"StyleDeclaration\";\n  IncrementalSource2[IncrementalSource2[\"Selection\"] = 14] = \"Selection\";\n  IncrementalSource2[IncrementalSource2[\"AdoptedStyleSheet\"] = 15] = \"AdoptedStyleSheet\";\n  IncrementalSource2[IncrementalSource2[\"CustomElement\"] = 16] = \"CustomElement\";\n  return IncrementalSource2;\n})(IncrementalSource || {});\nvar MouseInteractions = /* @__PURE__ */ ((MouseInteractions2) => {\n  MouseInteractions2[MouseInteractions2[\"MouseUp\"] = 0] = \"MouseUp\";\n  MouseInteractions2[MouseInteractions2[\"MouseDown\"] = 1] = \"MouseDown\";\n  MouseInteractions2[MouseInteractions2[\"Click\"] = 2] = \"Click\";\n  MouseInteractions2[MouseInteractions2[\"ContextMenu\"] = 3] = \"ContextMenu\";\n  MouseInteractions2[MouseInteractions2[\"DblClick\"] = 4] = \"DblClick\";\n  MouseInteractions2[MouseInteractions2[\"Focus\"] = 5] = \"Focus\";\n  MouseInteractions2[MouseInteractions2[\"Blur\"] = 6] = \"Blur\";\n  MouseInteractions2[MouseInteractions2[\"TouchStart\"] = 7] = \"TouchStart\";\n  MouseInteractions2[MouseInteractions2[\"TouchMove_Departed\"] = 8] = \"TouchMove_Departed\";\n  MouseInteractions2[MouseInteractions2[\"TouchEnd\"] = 9] = \"TouchEnd\";\n  MouseInteractions2[MouseInteractions2[\"TouchCancel\"] = 10] = \"TouchCancel\";\n  return MouseInteractions2;\n})(MouseInteractions || {});\nvar PointerTypes = /* @__PURE__ */ ((PointerTypes2) => {\n  PointerTypes2[PointerTypes2[\"Mouse\"] = 0] = \"Mouse\";\n  PointerTypes2[PointerTypes2[\"Pen\"] = 1] = \"Pen\";\n  PointerTypes2[PointerTypes2[\"Touch\"] = 2] = \"Touch\";\n  return PointerTypes2;\n})(PointerTypes || {});\nvar CanvasContext = /* @__PURE__ */ ((CanvasContext2) => {\n  CanvasContext2[CanvasContext2[\"2D\"] = 0] = \"2D\";\n  CanvasContext2[CanvasContext2[\"WebGL\"] = 1] = \"WebGL\";\n  CanvasContext2[CanvasContext2[\"WebGL2\"] = 2] = \"WebGL2\";\n  return CanvasContext2;\n})(CanvasContext || {});\nvar MediaInteractions = /* @__PURE__ */ ((MediaInteractions2) => {\n  MediaInteractions2[MediaInteractions2[\"Play\"] = 0] = \"Play\";\n  MediaInteractions2[MediaInteractions2[\"Pause\"] = 1] = \"Pause\";\n  MediaInteractions2[MediaInteractions2[\"Seeked\"] = 2] = \"Seeked\";\n  MediaInteractions2[MediaInteractions2[\"VolumeChange\"] = 3] = \"VolumeChange\";\n  MediaInteractions2[MediaInteractions2[\"RateChange\"] = 4] = \"RateChange\";\n  return MediaInteractions2;\n})(MediaInteractions || {});\nvar ReplayerEvents = /* @__PURE__ */ ((ReplayerEvents2) => {\n  ReplayerEvents2[\"Start\"] = \"start\";\n  ReplayerEvents2[\"Pause\"] = \"pause\";\n  ReplayerEvents2[\"Resume\"] = \"resume\";\n  ReplayerEvents2[\"Resize\"] = \"resize\";\n  ReplayerEvents2[\"Finish\"] = \"finish\";\n  ReplayerEvents2[\"FullsnapshotRebuilded\"] = \"fullsnapshot-rebuilded\";\n  ReplayerEvents2[\"LoadStylesheetStart\"] = \"load-stylesheet-start\";\n  ReplayerEvents2[\"LoadStylesheetEnd\"] = \"load-stylesheet-end\";\n  ReplayerEvents2[\"SkipStart\"] = \"skip-start\";\n  ReplayerEvents2[\"SkipEnd\"] = \"skip-end\";\n  ReplayerEvents2[\"MouseInteraction\"] = \"mouse-interaction\";\n  ReplayerEvents2[\"EventCast\"] = \"event-cast\";\n  ReplayerEvents2[\"CustomEvent\"] = \"custom-event\";\n  ReplayerEvents2[\"Flush\"] = \"flush\";\n  ReplayerEvents2[\"StateChange\"] = \"state-change\";\n  ReplayerEvents2[\"PlayBack\"] = \"play-back\";\n  ReplayerEvents2[\"Destroy\"] = \"destroy\";\n  return ReplayerEvents2;\n})(ReplayerEvents || {});\nexport {\n  CanvasContext,\n  EventType,\n  IncrementalSource,\n  MediaInteractions,\n  MouseInteractions,\n  PointerTypes,\n  ReplayerEvents\n};\n//# sourceMappingURL=types.js.map\n","import { AutocaptureConfig, Properties } from './types'\nimport { each, entries, includes, trim } from './utils'\n\nimport { isArray, isNullish, isString, isUndefined } from './utils/type-utils'\nimport { logger } from './utils/logger'\nimport { window } from './utils/globals'\n\nexport function splitClassString(s: string): string[] {\n    return s ? trim(s).split(/\\s+/) : []\n}\n\nfunction checkForURLMatches(urlsList: (string | RegExp)[]): boolean {\n    const url = window?.location.href\n    return !!(url && urlsList && urlsList.some((regex) => url.match(regex)))\n}\n\n/*\n * Get the className of an element, accounting for edge cases where element.className is an object\n *\n * Because this is a string it can contain unexpected characters\n * So, this method safely splits the className and returns that array.\n */\nexport function getClassNames(el: Element): string[] {\n    let className = ''\n    switch (typeof el.className) {\n        case 'string':\n            className = el.className\n            break\n        // TODO: when is this ever used?\n        case 'object': // handle cases where className might be SVGAnimatedString or some other type\n            className =\n                (el.className && 'baseVal' in el.className ? (el.className as any).baseVal : null) ||\n                el.getAttribute('class') ||\n                ''\n            break\n        default:\n            className = ''\n    }\n\n    return splitClassString(className)\n}\n\nexport function makeSafeText(s: string | null | undefined): string | null {\n    if (isNullish(s)) {\n        return null\n    }\n\n    return (\n        trim(s)\n            // scrub potentially sensitive values\n            .split(/(\\s+)/)\n            .filter((s) => shouldCaptureValue(s))\n            .join('')\n            // normalize whitespace\n            .replace(/[\\r\\n]/g, ' ')\n            .replace(/[ ]+/g, ' ')\n            // truncate\n            .substring(0, 255)\n    )\n}\n\n/*\n * Get the direct text content of an element, protecting against sensitive data collection.\n * Concats textContent of each of the element's text node children; this avoids potential\n * collection of sensitive data that could happen if we used element.textContent and the\n * element had sensitive child elements, since element.textContent includes child content.\n * Scrubs values that look like they could be sensitive (i.e. cc or ssn number).\n * @param {Element} el - element to get the text of\n * @returns {string} the element's direct text content\n */\nexport function getSafeText(el: Element): string {\n    let elText = ''\n\n    if (shouldCaptureElement(el) && !isSensitiveElement(el) && el.childNodes && el.childNodes.length) {\n        each(el.childNodes, function (child) {\n            if (isTextNode(child) && child.textContent) {\n                elText += makeSafeText(child.textContent) ?? ''\n            }\n        })\n    }\n\n    return trim(elText)\n}\n\n/*\n * Check whether an element has nodeType Node.ELEMENT_NODE\n * @param {Element} el - element to check\n * @returns {boolean} whether el is of the correct nodeType\n */\nexport function isElementNode(el: Node | Element | undefined | null): el is Element {\n    return !!el && el.nodeType === 1 // Node.ELEMENT_NODE - use integer constant for browser portability\n}\n\n/*\n * Check whether an element is of a given tag type.\n * Due to potential reference discrepancies (such as the webcomponents.js polyfill),\n * we want to match tagNames instead of specific references because something like\n * element === document.body won't always work because element might not be a native\n * element.\n * @param {Element} el - element to check\n * @param {string} tag - tag name (e.g., \"div\")\n * @returns {boolean} whether el is of the given tag type\n */\nexport function isTag(el: Element | undefined | null, tag: string): el is HTMLElement {\n    return !!el && !!el.tagName && el.tagName.toLowerCase() === tag.toLowerCase()\n}\n\n/*\n * Check whether an element has nodeType Node.TEXT_NODE\n * @param {Element} el - element to check\n * @returns {boolean} whether el is of the correct nodeType\n */\nexport function isTextNode(el: Element | undefined | null): el is HTMLElement {\n    return !!el && el.nodeType === 3 // Node.TEXT_NODE - use integer constant for browser portability\n}\n\n/*\n * Check whether an element has nodeType Node.DOCUMENT_FRAGMENT_NODE\n * @param {Element} el - element to check\n * @returns {boolean} whether el is of the correct nodeType\n */\nexport function isDocumentFragment(el: Element | ParentNode | undefined | null): el is DocumentFragment {\n    return !!el && el.nodeType === 11 // Node.DOCUMENT_FRAGMENT_NODE - use integer constant for browser portability\n}\n\nexport const autocaptureCompatibleElements = ['a', 'button', 'form', 'input', 'select', 'textarea', 'label']\n\n/*\n if there is no config, then all elements are allowed\n if there is a config, and there is an allow list, then only elements in the allow list are allowed\n assumes that some other code is checking this element's parents\n */\nfunction checkIfElementTreePassesElementAllowList(\n    elements: Element[],\n    autocaptureConfig: AutocaptureConfig | undefined\n): boolean {\n    const allowlist = autocaptureConfig?.element_allowlist\n    if (isUndefined(allowlist)) {\n        // everything is allowed, when there is no allow list\n        return true\n    }\n\n    // check each element in the tree\n    // if any of the elements are in the allow list, then the tree is allowed\n    for (const el of elements) {\n        if (allowlist.some((elementType) => el.tagName.toLowerCase() === elementType)) {\n            return true\n        }\n    }\n\n    // otherwise there is an allow list and this element tree didn't match it\n    return false\n}\n\n/*\n if there is no config, then all elements are allowed\n if there is a config, and there is an allow list, then\n only elements that match the css selector in the allow list are allowed\n assumes that some other code is checking this element's parents\n */\nfunction checkIfElementTreePassesCSSSelectorAllowList(\n    elements: Element[],\n    autocaptureConfig: AutocaptureConfig | undefined\n): boolean {\n    const allowlist = autocaptureConfig?.css_selector_allowlist\n    if (isUndefined(allowlist)) {\n        // everything is allowed, when there is no allow list\n        return true\n    }\n\n    // check each element in the tree\n    // if any of the elements are in the allow list, then the tree is allowed\n    for (const el of elements) {\n        if (allowlist.some((selector) => el.matches(selector))) {\n            return true\n        }\n    }\n\n    // otherwise there is an allow list and this element tree didn't match it\n    return false\n}\n\nexport function getParentElement(curEl: Element): Element | false {\n    const parentNode = curEl.parentNode\n    if (!parentNode || !isElementNode(parentNode)) return false\n    return parentNode\n}\n\n/*\n * Check whether a DOM event should be \"captured\" or if it may contain sentitive data\n * using a variety of heuristics.\n * @param {Element} el - element to check\n * @param {Event} event - event to check\n * @param {Object} autocaptureConfig - autocapture config\n * @param {boolean} captureOnAnyElement - whether to capture on any element, clipboard autocapture doesn't restrict to \"clickable\" elements\n * @param {string[]} allowedEventTypes - event types to capture, normally just 'click', but some autocapture types react to different events, some elements have fixed events (e.g., form has \"submit\")\n * @returns {boolean} whether the event should be captured\n */\nexport function shouldCaptureDomEvent(\n    el: Element,\n    event: Event,\n    autocaptureConfig: AutocaptureConfig | undefined = undefined,\n    captureOnAnyElement?: boolean,\n    allowedEventTypes?: string[]\n): boolean {\n    if (!window || !el || isTag(el, 'html') || !isElementNode(el)) {\n        return false\n    }\n\n    if (autocaptureConfig?.url_allowlist) {\n        // if the current URL is not in the allow list, don't capture\n        if (!checkForURLMatches(autocaptureConfig.url_allowlist)) {\n            return false\n        }\n    }\n\n    if (autocaptureConfig?.url_ignorelist) {\n        // if the current URL is in the ignore list, don't capture\n        if (checkForURLMatches(autocaptureConfig.url_ignorelist)) {\n            return false\n        }\n    }\n\n    if (autocaptureConfig?.dom_event_allowlist) {\n        const allowlist = autocaptureConfig.dom_event_allowlist\n        if (allowlist && !allowlist.some((eventType) => event.type === eventType)) {\n            return false\n        }\n    }\n\n    let parentIsUsefulElement = false\n    const targetElementList: Element[] = [el]\n    let parentNode: Element | boolean = true\n    let curEl: Element = el\n    while (curEl.parentNode && !isTag(curEl, 'body')) {\n        // If element is a shadow root, we skip it\n        if (isDocumentFragment(curEl.parentNode)) {\n            targetElementList.push((curEl.parentNode as any).host)\n            curEl = (curEl.parentNode as any).host\n            continue\n        }\n        parentNode = getParentElement(curEl)\n        if (!parentNode) break\n        if (captureOnAnyElement || autocaptureCompatibleElements.indexOf(parentNode.tagName.toLowerCase()) > -1) {\n            parentIsUsefulElement = true\n        } else {\n            const compStyles = window.getComputedStyle(parentNode)\n            if (compStyles && compStyles.getPropertyValue('cursor') === 'pointer') {\n                parentIsUsefulElement = true\n            }\n        }\n\n        targetElementList.push(parentNode)\n        curEl = parentNode\n    }\n\n    if (!checkIfElementTreePassesElementAllowList(targetElementList, autocaptureConfig)) {\n        return false\n    }\n\n    if (!checkIfElementTreePassesCSSSelectorAllowList(targetElementList, autocaptureConfig)) {\n        return false\n    }\n\n    const compStyles = window.getComputedStyle(el)\n    if (compStyles && compStyles.getPropertyValue('cursor') === 'pointer' && event.type === 'click') {\n        return true\n    }\n\n    const tag = el.tagName.toLowerCase()\n    switch (tag) {\n        case 'html':\n            return false\n        case 'form':\n            return (allowedEventTypes || ['submit']).indexOf(event.type) >= 0\n        case 'input':\n        case 'select':\n        case 'textarea':\n            return (allowedEventTypes || ['change', 'click']).indexOf(event.type) >= 0\n        default:\n            if (parentIsUsefulElement) return (allowedEventTypes || ['click']).indexOf(event.type) >= 0\n            return (\n                (allowedEventTypes || ['click']).indexOf(event.type) >= 0 &&\n                (autocaptureCompatibleElements.indexOf(tag) > -1 || el.getAttribute('contenteditable') === 'true')\n            )\n    }\n}\n\n/*\n * Check whether a DOM element should be \"captured\" or if it may contain sentitive data\n * using a variety of heuristics.\n * @param {Element} el - element to check\n * @returns {boolean} whether the element should be captured\n */\nexport function shouldCaptureElement(el: Element): boolean {\n    for (let curEl = el; curEl.parentNode && !isTag(curEl, 'body'); curEl = curEl.parentNode as Element) {\n        const classes = getClassNames(curEl)\n        if (includes(classes, 'ph-sensitive') || includes(classes, 'ph-no-capture')) {\n            return false\n        }\n    }\n\n    if (includes(getClassNames(el), 'ph-include')) {\n        return true\n    }\n\n    // don't include hidden or password fields\n    const type = (el as HTMLInputElement).type || ''\n    if (isString(type)) {\n        // it's possible for el.type to be a DOM element if el is a form with a child input[name=\"type\"]\n        switch (type.toLowerCase()) {\n            case 'hidden':\n                return false\n            case 'password':\n                return false\n        }\n    }\n\n    // filter out data from fields that look like sensitive fields\n    const name = (el as HTMLInputElement).name || el.id || ''\n    // See https://github.com/posthog/posthog-js/issues/165\n    // Under specific circumstances a bug caused .replace to be called on a DOM element\n    // instead of a string, removing the element from the page. Ensure this issue is mitigated.\n    if (isString(name)) {\n        // it's possible for el.name or el.id to be a DOM element if el is a form with a child input[name=\"name\"]\n        const sensitiveNameRegex =\n            /^cc|cardnum|ccnum|creditcard|csc|cvc|cvv|exp|pass|pwd|routing|seccode|securitycode|securitynum|socialsec|socsec|ssn/i\n        if (sensitiveNameRegex.test(name.replace(/[^a-zA-Z0-9]/g, ''))) {\n            return false\n        }\n    }\n\n    return true\n}\n\n/*\n * Check whether a DOM element is 'sensitive' and we should only capture limited data\n * @param {Element} el - element to check\n * @returns {boolean} whether the element should be captured\n */\nexport function isSensitiveElement(el: Element): boolean {\n    // don't send data from inputs or similar elements since there will always be\n    // a risk of clientside javascript placing sensitive data in attributes\n    const allowedInputTypes = ['button', 'checkbox', 'submit', 'reset']\n    if (\n        (isTag(el, 'input') && !allowedInputTypes.includes((el as HTMLInputElement).type)) ||\n        isTag(el, 'select') ||\n        isTag(el, 'textarea') ||\n        el.getAttribute('contenteditable') === 'true'\n    ) {\n        return true\n    }\n    return false\n}\n\n// Define the core pattern for matching credit card numbers\nconst coreCCPattern = `(4[0-9]{12}(?:[0-9]{3})?)|(5[1-5][0-9]{14})|(6(?:011|5[0-9]{2})[0-9]{12})|(3[47][0-9]{13})|(3(?:0[0-5]|[68][0-9])[0-9]{11})|((?:2131|1800|35[0-9]{3})[0-9]{11})`\n// Create the Anchored version of the regex by adding '^' at the start and '$' at the end\nconst anchoredCCRegex = new RegExp(`^(?:${coreCCPattern})$`)\n// The Unanchored version is essentially the core pattern, usable as is for partial matches\nconst unanchoredCCRegex = new RegExp(coreCCPattern)\n\n// Define the core pattern for matching SSNs with optional dashes\nconst coreSSNPattern = `\\\\d{3}-?\\\\d{2}-?\\\\d{4}`\n// Create the Anchored version of the regex by adding '^' at the start and '$' at the end\nconst anchoredSSNRegex = new RegExp(`^(${coreSSNPattern})$`)\n// The Unanchored version is essentially the core pattern itself, usable for partial matches\nconst unanchoredSSNRegex = new RegExp(`(${coreSSNPattern})`)\n\n/*\n * Check whether a string value should be \"captured\" or if it may contain sensitive data\n * using a variety of heuristics.\n * @param {string} value - string value to check\n * @param {boolean} anchorRegexes - whether to anchor the regexes to the start and end of the string\n * @returns {boolean} whether the element should be captured\n */\nexport function shouldCaptureValue(value: string, anchorRegexes = true): boolean {\n    if (isNullish(value)) {\n        return false\n    }\n\n    if (isString(value)) {\n        value = trim(value)\n\n        // check to see if input value looks like a credit card number\n        // see: https://www.safaribooksonline.com/library/view/regular-expressions-cookbook/9781449327453/ch04s20.html\n        const ccRegex = anchorRegexes ? anchoredCCRegex : unanchoredCCRegex\n        if (ccRegex.test((value || '').replace(/[- ]/g, ''))) {\n            return false\n        }\n\n        // check to see if input value looks like a social security number\n        const ssnRegex = anchorRegexes ? anchoredSSNRegex : unanchoredSSNRegex\n        if (ssnRegex.test(value)) {\n            return false\n        }\n    }\n\n    return true\n}\n\n/*\n * Check whether an attribute name is an Angular style attr (either _ngcontent or _nghost)\n * These update on each build and lead to noise in the element chain\n * More details on the attributes here: https://angular.io/guide/view-encapsulation\n * @param {string} attributeName - string value to check\n * @returns {boolean} whether the element is an angular tag\n */\nexport function isAngularStyleAttr(attributeName: string): boolean {\n    if (isString(attributeName)) {\n        return attributeName.substring(0, 10) === '_ngcontent' || attributeName.substring(0, 7) === '_nghost'\n    }\n    return false\n}\n\n/*\n * Iterate through children of a target element looking for span tags\n * and return the text content of the span tags, separated by spaces,\n * along with the direct text content of the target element\n * @param {Element} target - element to check\n * @returns {string} text content of the target element and its child span tags\n */\nexport function getDirectAndNestedSpanText(target: Element): string {\n    let text = getSafeText(target)\n    text = `${text} ${getNestedSpanText(target)}`.trim()\n    return shouldCaptureValue(text) ? text : ''\n}\n\n/*\n * Iterate through children of a target element looking for span tags\n * and return the text content of the span tags, separated by spaces\n * @param {Element} target - element to check\n * @returns {string} text content of span tags\n */\nexport function getNestedSpanText(target: Element): string {\n    let text = ''\n    if (target && target.childNodes && target.childNodes.length) {\n        each(target.childNodes, function (child) {\n            if (child && child.tagName?.toLowerCase() === 'span') {\n                try {\n                    const spanText = getSafeText(child)\n                    text = `${text} ${spanText}`.trim()\n\n                    if (child.childNodes && child.childNodes.length) {\n                        text = `${text} ${getNestedSpanText(child)}`.trim()\n                    }\n                } catch (e) {\n                    logger.error(e)\n                }\n            }\n        })\n    }\n    return text\n}\n\n/*\nBack in the day storing events in Postgres we use Elements for autocapture events.\nNow we're using elements_chain. We used to do this parsing/processing during ingestion.\nThis code is just copied over from ingestion, but we should optimize it\nto create elements_chain string directly.\n*/\nexport function getElementsChainString(elements: Properties[]): string {\n    return elementsToString(extractElements(elements))\n}\n\n// This interface is called 'Element' in plugin-scaffold https://github.com/PostHog/plugin-scaffold/blob/b07d3b879796ecc7e22deb71bf627694ba05386b/src/types.ts#L200\n// However 'Element' is a DOM Element when run in the browser, so we have to rename it\ninterface PHElement {\n    text?: string\n    tag_name?: string\n    href?: string\n    attr_id?: string\n    attr_class?: string[]\n    nth_child?: number\n    nth_of_type?: number\n    attributes?: Record<string, any>\n    event_id?: number\n    order?: number\n    group_id?: number\n}\n\nfunction escapeQuotes(input: string): string {\n    return input.replace(/\"|\\\\\"/g, '\\\\\"')\n}\n\nfunction elementsToString(elements: PHElement[]): string {\n    const ret = elements.map((element) => {\n        let el_string = ''\n        if (element.tag_name) {\n            el_string += element.tag_name\n        }\n        if (element.attr_class) {\n            element.attr_class.sort()\n            for (const single_class of element.attr_class) {\n                el_string += `.${single_class.replace(/\"/g, '')}`\n            }\n        }\n        const attributes: Record<string, any> = {\n            ...(element.text ? { text: element.text } : {}),\n            'nth-child': element.nth_child ?? 0,\n            'nth-of-type': element.nth_of_type ?? 0,\n            ...(element.href ? { href: element.href } : {}),\n            ...(element.attr_id ? { attr_id: element.attr_id } : {}),\n            ...element.attributes,\n        }\n        const sortedAttributes: Record<string, any> = {}\n        entries(attributes)\n            .sort(([a], [b]) => a.localeCompare(b))\n            .forEach(\n                ([key, value]) => (sortedAttributes[escapeQuotes(key.toString())] = escapeQuotes(value.toString()))\n            )\n        el_string += ':'\n        el_string += entries(attributes)\n            .map(([key, value]) => `${key}=\"${value}\"`)\n            .join('')\n        return el_string\n    })\n    return ret.join(';')\n}\n\nfunction extractElements(elements: Properties[]): PHElement[] {\n    return elements.map((el) => {\n        const response = {\n            text: el['$el_text']?.slice(0, 400),\n            tag_name: el['tag_name'],\n            href: el['attr__href']?.slice(0, 2048),\n            attr_class: extractAttrClass(el),\n            attr_id: el['attr__id'],\n            nth_child: el['nth_child'],\n            nth_of_type: el['nth_of_type'],\n            attributes: {} as { [id: string]: any },\n        }\n\n        entries(el)\n            .filter(([key]) => key.indexOf('attr__') === 0)\n            .forEach(([key, value]) => (response.attributes[key] = value))\n        return response\n    })\n}\n\nfunction extractAttrClass(el: Properties): PHElement['attr_class'] {\n    const attr_class = el['attr__class']\n    if (!attr_class) {\n        return undefined\n    } else if (isArray(attr_class)) {\n        return attr_class\n    } else {\n        return splitClassString(attr_class)\n    }\n}\n","import { CapturedNetworkRequest, NetworkRecordOptions, PostHogConfig } from '../../types'\nimport { isFunction, isNullish, isString, isUndefined } from '../../utils/type-utils'\nimport { convertToURL } from '../../utils/request-utils'\nimport { logger } from '../../utils/logger'\nimport { shouldCaptureValue } from '../../autocapture-utils'\nimport { each } from '../../utils'\n\nconst LOGGER_PREFIX = '[SessionRecording]'\nconst REDACTED = 'redacted'\n\nexport const defaultNetworkOptions: Required<NetworkRecordOptions> = {\n    initiatorTypes: [\n        'audio',\n        'beacon',\n        'body',\n        'css',\n        'early-hint',\n        'embed',\n        'fetch',\n        'frame',\n        'iframe',\n        'icon',\n        'image',\n        'img',\n        'input',\n        'link',\n        'navigation',\n        'object',\n        'ping',\n        'script',\n        'track',\n        'video',\n        'xmlhttprequest',\n    ],\n    maskRequestFn: (data: CapturedNetworkRequest) => data,\n    recordHeaders: false,\n    recordBody: false,\n    recordInitialRequests: false,\n    recordPerformance: false,\n    performanceEntryTypeToObserve: [\n        // 'event', // This is too noisy as it covers all browser events\n        'first-input',\n        // 'mark', // Mark is used too liberally. We would need to filter for specific marks\n        // 'measure', // Measure is used too liberally. We would need to filter for specific measures\n        'navigation',\n        'paint',\n        'resource',\n    ],\n    payloadSizeLimitBytes: 1000000,\n    payloadHostDenyList: ['.lr-ingest.io', '.ingest.sentry.io'],\n}\n\nconst HEADER_DENY_LIST = [\n    'authorization',\n    'x-forwarded-for',\n    'authorization',\n    'cookie',\n    'set-cookie',\n    'x-api-key',\n    'x-real-ip',\n    'remote-addr',\n    'forwarded',\n    'proxy-authorization',\n    'x-csrf-token',\n    'x-csrftoken',\n    'x-xsrf-token',\n]\n\nconst PAYLOAD_CONTENT_DENY_LIST = [\n    'password',\n    'secret',\n    'passwd',\n    'api_key',\n    'apikey',\n    'auth',\n    'credentials',\n    'mysql_pwd',\n    'privatekey',\n    'private_key',\n    'token',\n]\n\n// we always remove headers on the deny list because we never want to capture this sensitive data\nconst removeAuthorizationHeader = (data: CapturedNetworkRequest): CapturedNetworkRequest => {\n    const headers = data.requestHeaders\n    if (!isNullish(headers)) {\n        each(Object.keys(headers ?? {}), (header) => {\n            if (HEADER_DENY_LIST.includes(header.toLowerCase())) {\n                headers[header] = REDACTED\n            }\n        })\n    }\n    return data\n}\n\nconst POSTHOG_PATHS_TO_IGNORE = ['/s/', '/e/', '/i/']\n// want to ignore posthog paths when capturing requests, or we can get trapped in a loop\n// because calls to PostHog would be reported using a call to PostHog which would be reported....\nconst ignorePostHogPaths = (data: CapturedNetworkRequest): CapturedNetworkRequest | undefined => {\n    const url = convertToURL(data.name)\n    if (url && url.pathname && POSTHOG_PATHS_TO_IGNORE.some((path) => url.pathname.indexOf(path) === 0)) {\n        return undefined\n    }\n    return data\n}\n\nfunction estimateBytes(payload: string): number {\n    return new Blob([payload]).size\n}\n\nfunction enforcePayloadSizeLimit(\n    payload: string | null | undefined,\n    headers: Record<string, any> | undefined,\n    limit: number,\n    description: string\n): string | null | undefined {\n    if (isNullish(payload)) {\n        return payload\n    }\n\n    let requestContentLength: string | number = headers?.['content-length'] || estimateBytes(payload)\n    if (isString(requestContentLength)) {\n        requestContentLength = parseInt(requestContentLength)\n    }\n\n    if (requestContentLength > limit) {\n        return LOGGER_PREFIX + ` ${description} body too large to record (${requestContentLength} bytes)`\n    }\n\n    return payload\n}\n\n// people can have arbitrarily large payloads on their site, but we don't want to ingest them\nconst limitPayloadSize = (\n    options: NetworkRecordOptions\n): ((data: CapturedNetworkRequest | undefined) => CapturedNetworkRequest | undefined) => {\n    // the smallest of 1MB or the specified limit if there is one\n    const limit = Math.min(1000000, options.payloadSizeLimitBytes ?? 1000000)\n\n    return (data) => {\n        if (data?.requestBody) {\n            data.requestBody = enforcePayloadSizeLimit(data.requestBody, data.requestHeaders, limit, 'Request')\n        }\n\n        if (data?.responseBody) {\n            data.responseBody = enforcePayloadSizeLimit(data.responseBody, data.responseHeaders, limit, 'Response')\n        }\n\n        return data\n    }\n}\n\nfunction scrubPayload(payload: string | null | undefined, label: 'Request' | 'Response'): string | null | undefined {\n    if (isNullish(payload)) {\n        return payload\n    }\n    let scrubbed = payload\n\n    if (!shouldCaptureValue(scrubbed, false)) {\n        scrubbed = LOGGER_PREFIX + ' ' + label + ' body ' + REDACTED\n    }\n    each(PAYLOAD_CONTENT_DENY_LIST, (text) => {\n        if (scrubbed?.length && scrubbed?.indexOf(text) !== -1) {\n            scrubbed = LOGGER_PREFIX + ' ' + label + ' body ' + REDACTED + ' as might contain: ' + text\n        }\n    })\n\n    return scrubbed\n}\n\nfunction scrubPayloads(capturedRequest: CapturedNetworkRequest | undefined): CapturedNetworkRequest | undefined {\n    if (isUndefined(capturedRequest)) {\n        return undefined\n    }\n\n    capturedRequest.requestBody = scrubPayload(capturedRequest.requestBody, 'Request')\n    capturedRequest.responseBody = scrubPayload(capturedRequest.responseBody, 'Response')\n\n    return capturedRequest\n}\n\n/**\n *  whether a maskRequestFn is provided or not,\n *  we ensure that we remove the denied header from requests\n *  we _never_ want to record that header by accident\n *  if someone complains then we'll add an opt-in to let them override it\n */\nexport const buildNetworkRequestOptions = (\n    instanceConfig: PostHogConfig,\n    remoteNetworkOptions: Pick<\n        NetworkRecordOptions,\n        'recordHeaders' | 'recordBody' | 'recordPerformance' | 'payloadHostDenyList'\n    >\n): NetworkRecordOptions => {\n    const config: NetworkRecordOptions = {\n        payloadSizeLimitBytes: defaultNetworkOptions.payloadSizeLimitBytes,\n        performanceEntryTypeToObserve: [...defaultNetworkOptions.performanceEntryTypeToObserve],\n        payloadHostDenyList: [\n            ...(remoteNetworkOptions.payloadHostDenyList || []),\n            ...defaultNetworkOptions.payloadHostDenyList,\n        ],\n    }\n    // client can always disable despite remote options\n    const canRecordHeaders =\n        instanceConfig.session_recording.recordHeaders === false ? false : remoteNetworkOptions.recordHeaders\n    const canRecordBody =\n        instanceConfig.session_recording.recordBody === false ? false : remoteNetworkOptions.recordBody\n    const canRecordPerformance =\n        instanceConfig.capture_performance === false ? false : remoteNetworkOptions.recordPerformance\n\n    const payloadLimiter = limitPayloadSize(config)\n\n    const enforcedCleaningFn: NetworkRecordOptions['maskRequestFn'] = (d: CapturedNetworkRequest) =>\n        payloadLimiter(ignorePostHogPaths(removeAuthorizationHeader(d)))\n\n    const hasDeprecatedMaskFunction = isFunction(instanceConfig.session_recording.maskNetworkRequestFn)\n\n    if (hasDeprecatedMaskFunction && isFunction(instanceConfig.session_recording.maskCapturedNetworkRequestFn)) {\n        logger.warn(\n            'Both `maskNetworkRequestFn` and `maskCapturedNetworkRequestFn` are defined. `maskNetworkRequestFn` will be ignored.'\n        )\n    }\n\n    if (hasDeprecatedMaskFunction) {\n        instanceConfig.session_recording.maskCapturedNetworkRequestFn = (data: CapturedNetworkRequest) => {\n            const cleanedURL = instanceConfig.session_recording.maskNetworkRequestFn!({ url: data.name })\n            return {\n                ...data,\n                name: cleanedURL?.url,\n            } as CapturedNetworkRequest\n        }\n    }\n\n    config.maskRequestFn = isFunction(instanceConfig.session_recording.maskCapturedNetworkRequestFn)\n        ? (data) => {\n              const cleanedRequest = enforcedCleaningFn(data)\n              return cleanedRequest\n                  ? instanceConfig.session_recording.maskCapturedNetworkRequestFn?.(cleanedRequest) ?? undefined\n                  : undefined\n          }\n        : (data) => scrubPayloads(enforcedCleaningFn(data))\n\n    return {\n        ...defaultNetworkOptions,\n        ...config,\n        recordHeaders: canRecordHeaders,\n        recordBody: canRecordBody,\n        recordPerformance: canRecordPerformance,\n        recordInitialRequests: canRecordPerformance,\n    }\n}\n","import { registerEvent, trySafe } from '../utils'\nimport { PostHog } from '../posthog-core'\nimport { ToolbarParams } from '../types'\nimport { _getHashParam } from '../utils/request-utils'\nimport { logger } from '../utils/logger'\nimport { window, document, assignableWindow } from '../utils/globals'\nimport { TOOLBAR_ID } from '../constants'\n\n// TRICKY: Many web frameworks will modify the route on load, potentially before posthog is initialized.\n// To get ahead of this we grab it as soon as the posthog-js is parsed\nconst STATE_FROM_WINDOW = window?.location\n    ? _getHashParam(window.location.hash, '__posthog') || _getHashParam(location.hash, 'state')\n    : null\n\nconst LOCALSTORAGE_KEY = '_postHogToolbarParams'\n\nenum ToolbarState {\n    UNINITIALIZED = 0,\n    LOADING = 1,\n    LOADED = 2,\n}\n\nexport class Toolbar {\n    instance: PostHog\n\n    constructor(instance: PostHog) {\n        this.instance = instance\n    }\n\n    // NOTE: We store the state of the toolbar in the global scope to avoid multiple instances of the SDK loading the toolbar\n    private setToolbarState(state: ToolbarState) {\n        assignableWindow['ph_toolbar_state'] = state\n    }\n\n    private getToolbarState(): ToolbarState {\n        return assignableWindow['ph_toolbar_state'] ?? ToolbarState.UNINITIALIZED\n    }\n\n    /**\n     * To load the toolbar, we need an access token and other state. That state comes from one of three places:\n     * 1. In the URL hash params\n     * 2. From session storage under the key `toolbarParams` if the toolbar was initialized on a previous page\n     */\n    maybeLoadToolbar(\n        location: Location | undefined = undefined,\n        localStorage: Storage | undefined = undefined,\n        history: History | undefined = undefined\n    ): boolean {\n        if (!window || !document) {\n            return false\n        }\n        location = location ?? window.location\n        history = history ?? window.history\n\n        try {\n            // Before running the code we check if we can access localStorage, if not we opt-out\n            if (!localStorage) {\n                try {\n                    window.localStorage.setItem('test', 'test')\n                    window.localStorage.removeItem('test')\n                } catch (error) {\n                    return false\n                }\n\n                // If localStorage was undefined, and localStorage is supported we set the default value\n                localStorage = window?.localStorage\n            }\n\n            /**\n             * Info about the state\n             * The state is a json object\n             * 1. (Legacy) The state can be `state={}` as a urlencoded object of info. In this case\n             * 2. The state should now be found in `__posthog={}` and can be base64 encoded or urlencoded.\n             * 3. Base64 encoding is preferred and will gradually be rolled out everywhere\n             */\n\n            const stateHash =\n                STATE_FROM_WINDOW || _getHashParam(location.hash, '__posthog') || _getHashParam(location.hash, 'state')\n\n            let toolbarParams: ToolbarParams\n            const state = stateHash\n                ? trySafe(() => JSON.parse(atob(decodeURIComponent(stateHash)))) ||\n                  trySafe(() => JSON.parse(decodeURIComponent(stateHash)))\n                : null\n\n            const parseFromUrl = state && state['action'] === 'ph_authorize'\n\n            if (parseFromUrl) {\n                // happens if they are initializing the toolbar using an old snippet\n                toolbarParams = state\n                toolbarParams.source = 'url'\n\n                if (toolbarParams && Object.keys(toolbarParams).length > 0) {\n                    if (state['desiredHash']) {\n                        // hash that was in the url before the redirect\n                        location.hash = state['desiredHash']\n                    } else if (history) {\n                        // second param is unused see https://developer.mozilla.org/en-US/docs/Web/API/History/replaceState\n                        history.replaceState(history.state, '', location.pathname + location.search) // completely remove hash\n                    } else {\n                        location.hash = '' // clear hash (but leaves # unfortunately)\n                    }\n                }\n            } else {\n                // get credentials from localStorage from a previous initialization\n\n                toolbarParams = JSON.parse(localStorage.getItem(LOCALSTORAGE_KEY) || '{}')\n                toolbarParams.source = 'localstorage'\n\n                // delete \"add-action\" or other intent from toolbarParams, otherwise we'll have the same intent\n                // every time we open the page (e.g. you just visiting your own site an hour later)\n                delete toolbarParams.userIntent\n            }\n\n            if (toolbarParams['token'] && this.instance.config.token === toolbarParams['token']) {\n                this.loadToolbar(toolbarParams)\n                return true\n            } else {\n                return false\n            }\n        } catch (e) {\n            return false\n        }\n    }\n\n    private _callLoadToolbar(params: ToolbarParams) {\n        ;(assignableWindow['ph_load_toolbar'] || assignableWindow['ph_load_editor'])(params, this.instance)\n    }\n\n    loadToolbar(params?: ToolbarParams): boolean {\n        const toolbarRunning = !!document?.getElementById(TOOLBAR_ID)\n\n        if (!window || toolbarRunning) {\n            // The toolbar will clear the localStorage key when it's done with it. If it is present that indicates the toolbar is already open and running\n            return false\n        }\n\n        const disableToolbarMetrics =\n            this.instance.requestRouter.region === 'custom' && this.instance.config.advanced_disable_toolbar_metrics\n\n        const toolbarParams = {\n            token: this.instance.config.token,\n            ...params,\n            apiURL: this.instance.requestRouter.endpointFor('ui'),\n            ...(disableToolbarMetrics ? { instrument: false } : {}),\n        }\n        window.localStorage.setItem(\n            LOCALSTORAGE_KEY,\n            JSON.stringify({\n                ...toolbarParams,\n                source: undefined,\n            })\n        )\n\n        if (this.getToolbarState() === ToolbarState.LOADED) {\n            this._callLoadToolbar(toolbarParams)\n        } else if (this.getToolbarState() === ToolbarState.UNINITIALIZED) {\n            // only load the toolbar once, even if there are multiple instances of PostHogLib\n            this.setToolbarState(ToolbarState.LOADING)\n\n            // toolbar.js is served from the PostHog CDN, this has a TTL of 24 hours.\n            // the toolbar asset includes a rotating \"token\" that is valid for 5 minutes.\n            const fiveMinutesInMillis = 5 * 60 * 1000\n            // this ensures that we bust the cache periodically\n            const timestampToNearestFiveMinutes = Math.floor(Date.now() / fiveMinutesInMillis) * fiveMinutesInMillis\n\n            this.instance.requestRouter.loadScript(`/static/toolbar.js?t=${timestampToNearestFiveMinutes}`, (err) => {\n                if (err) {\n                    logger.error('Failed to load toolbar', err)\n                    this.setToolbarState(ToolbarState.UNINITIALIZED)\n                    return\n                }\n                this.setToolbarState(ToolbarState.LOADED)\n                this._callLoadToolbar(toolbarParams)\n            })\n\n            // Turbolinks doesn't fire an onload event but does replace the entire body, including the toolbar.\n            // Thus, we ensure the toolbar is only loaded inside the body, and then reloaded on turbolinks:load.\n            registerEvent(window, 'turbolinks:load', () => {\n                this.setToolbarState(ToolbarState.UNINITIALIZED)\n                this.loadToolbar(toolbarParams)\n            })\n        }\n\n        return true\n    }\n\n    /** @deprecated Use \"loadToolbar\" instead. */\n    _loadEditor(params: ToolbarParams): boolean {\n        return this.loadToolbar(params)\n    }\n\n    /** @deprecated Use \"maybeLoadToolbar\" instead. */\n    maybeLoadEditor(\n        location: Location | undefined = undefined,\n        localStorage: Storage | undefined = undefined,\n        history: History | undefined = undefined\n    ): boolean {\n        return this.maybeLoadToolbar(location, localStorage, history)\n    }\n}\n","import type { eventWithTime, mutationCallbackParam } from '@rrweb/types'\nimport { INCREMENTAL_SNAPSHOT_EVENT_TYPE, MUTATION_SOURCE_TYPE, rrwebRecord } from './sessionrecording-utils'\n\nexport class MutationRateLimiter {\n    private bucketSize = 100\n    private refillRate = 10\n    private mutationBuckets: Record<string, number> = {}\n    private loggedTracker: Record<string, boolean> = {}\n\n    constructor(\n        private readonly rrweb: rrwebRecord,\n        private readonly options: {\n            bucketSize?: number\n            refillRate?: number\n            onBlockedNode?: (id: number, node: Node | null) => void\n        } = {}\n    ) {\n        this.refillRate = this.options.refillRate ?? this.refillRate\n        this.bucketSize = this.options.bucketSize ?? this.bucketSize\n        setInterval(() => {\n            this.refillBuckets()\n        }, 1000)\n    }\n\n    private refillBuckets = () => {\n        Object.keys(this.mutationBuckets).forEach((key) => {\n            this.mutationBuckets[key] = this.mutationBuckets[key] + this.refillRate\n\n            if (this.mutationBuckets[key] >= this.bucketSize) {\n                delete this.mutationBuckets[key]\n            }\n        })\n    }\n\n    private getNodeOrRelevantParent = (id: number): [number, Node | null] => {\n        // For some nodes we know they are part of a larger tree such as an SVG.\n        // For those we want to block the entire node, not just the specific attribute\n\n        const node = this.rrweb.mirror.getNode(id)\n\n        // Check if the node is an Element and then find the closest parent that is an SVG\n        if (node?.nodeName !== 'svg' && node instanceof Element) {\n            const closestSVG = node.closest('svg')\n\n            if (closestSVG) {\n                return [this.rrweb.mirror.getId(closestSVG), closestSVG]\n            }\n        }\n\n        return [id, node]\n    }\n\n    private numberOfChanges = (data: Partial<mutationCallbackParam>) => {\n        return (\n            (data.removes?.length ?? 0) +\n            (data.attributes?.length ?? 0) +\n            (data.texts?.length ?? 0) +\n            (data.adds?.length ?? 0)\n        )\n    }\n\n    public throttleMutations = (event: eventWithTime) => {\n        if (event.type !== INCREMENTAL_SNAPSHOT_EVENT_TYPE || event.data.source !== MUTATION_SOURCE_TYPE) {\n            return event\n        }\n\n        const data = event.data as Partial<mutationCallbackParam>\n        const initialMutationCount = this.numberOfChanges(data)\n\n        if (data.attributes) {\n            // Most problematic mutations come from attrs where the style or minor properties are changed rapidly\n            data.attributes = data.attributes.filter((attr) => {\n                const [nodeId, node] = this.getNodeOrRelevantParent(attr.id)\n\n                if (this.mutationBuckets[nodeId] === 0) {\n                    return false\n                }\n\n                this.mutationBuckets[nodeId] = this.mutationBuckets[nodeId] ?? this.bucketSize\n                this.mutationBuckets[nodeId] = Math.max(this.mutationBuckets[nodeId] - 1, 0)\n\n                if (this.mutationBuckets[nodeId] === 0) {\n                    if (!this.loggedTracker[nodeId]) {\n                        this.loggedTracker[nodeId] = true\n                        this.options.onBlockedNode?.(nodeId, node)\n                    }\n                }\n\n                return attr\n            })\n        }\n\n        // Check if every part of the mutation is empty in which case there is nothing to do\n        const mutationCount = this.numberOfChanges(data)\n\n        if (mutationCount === 0 && initialMutationCount !== mutationCount) {\n            // If we have modified the mutation count and the remaining count is 0, then we don't need the event.\n            return\n        }\n        return event\n    }\n}\n","import {\n    CONSOLE_LOG_RECORDING_ENABLED_SERVER_SIDE,\n    SESSION_RECORDING_CANVAS_RECORDING,\n    SESSION_RECORDING_ENABLED_SERVER_SIDE,\n    SESSION_RECORDING_IS_SAMPLED,\n    SESSION_RECORDING_MINIMUM_DURATION,\n    SESSION_RECORDING_NETWORK_PAYLOAD_CAPTURE,\n    SESSION_RECORDING_SAMPLE_RATE,\n} from '../../constants'\nimport {\n    estimateSize,\n    FULL_SNAPSHOT_EVENT_TYPE,\n    INCREMENTAL_SNAPSHOT_EVENT_TYPE,\n    META_EVENT_TYPE,\n    recordOptions,\n    rrwebRecord,\n    splitBuffer,\n    truncateLargeConsoleLogs,\n} from './sessionrecording-utils'\nimport { PostHog } from '../../posthog-core'\nimport { DecideResponse, FlagVariant, NetworkRecordOptions, NetworkRequest, Properties } from '../../types'\nimport { EventType, type eventWithTime, IncrementalSource, type listenerHandler, RecordPlugin } from '@rrweb/types'\nimport Config from '../../config'\nimport { timestamp } from '../../utils'\n\nimport {\n    isBoolean,\n    isFunction,\n    isNull,\n    isNullish,\n    isNumber,\n    isObject,\n    isString,\n    isUndefined,\n} from '../../utils/type-utils'\nimport { logger } from '../../utils/logger'\nimport { assignableWindow, document, window } from '../../utils/globals'\nimport { buildNetworkRequestOptions } from './config'\nimport { isLocalhost } from '../../utils/request-utils'\nimport { MutationRateLimiter } from './mutation-rate-limiter'\n\nconst BASE_ENDPOINT = '/s/'\n\nconst FIVE_MINUTES = 1000 * 60 * 5\nconst TWO_SECONDS = 2000\nexport const RECORDING_IDLE_ACTIVITY_TIMEOUT_MS = FIVE_MINUTES\nexport const RECORDING_MAX_EVENT_SIZE = 1024 * 1024 * 0.9 // ~1mb (with some wiggle room)\nexport const RECORDING_BUFFER_TIMEOUT = 2000 // 2 seconds\nexport const SESSION_RECORDING_BATCH_KEY = 'recordings'\n\n// NOTE: Importing this type is problematic as we can't safely bundle it to a TS definition so, instead we redefine.\n// import type { record } from 'rrweb2/typings'\n// import type { recordOptions } from 'rrweb/typings/types'\n\nconst ACTIVE_SOURCES = [\n    IncrementalSource.MouseMove,\n    IncrementalSource.MouseInteraction,\n    IncrementalSource.Scroll,\n    IncrementalSource.ViewportResize,\n    IncrementalSource.Input,\n    IncrementalSource.TouchMove,\n    IncrementalSource.MediaInteraction,\n    IncrementalSource.Drag,\n]\n\n/**\n * Session recording starts in buffering mode while waiting for decide response\n * Once the response is received it might be disabled, active or sampled\n * When sampled that means a sample rate is set and the last time the session id was rotated\n * the sample rate determined this session should be sent to the server.\n */\ntype SessionRecordingStatus = 'disabled' | 'sampled' | 'active' | 'buffering'\n\nexport interface SnapshotBuffer {\n    size: number\n    data: any[]\n    sessionId: string\n    windowId: string\n}\n\ninterface QueuedRRWebEvent {\n    rrwebMethod: () => void\n    attempt: number\n    // the timestamp this was first put into this queue\n    enqueuedAt: number\n}\n\nconst newQueuedEvent = (rrwebMethod: () => void): QueuedRRWebEvent => ({\n    rrwebMethod,\n    enqueuedAt: Date.now(),\n    attempt: 1,\n})\n\nconst LOGGER_PREFIX = '[SessionRecording]'\n\nexport class SessionRecording {\n    private _endpoint: string\n    private flushBufferTimer?: any\n\n    // we have a buffer - that contains PostHog snapshot events ready to be sent to the server\n    private buffer: SnapshotBuffer\n    // and a queue - that contains rrweb events that we want to send to rrweb, but rrweb wasn't able to accept them yet\n    private queuedRRWebEvents: QueuedRRWebEvent[] = []\n\n    private mutationRateLimiter?: MutationRateLimiter\n    private _captureStarted: boolean\n    private stopRrweb: listenerHandler | undefined\n    private receivedDecide: boolean\n    private isIdle = false\n\n    private _linkedFlagSeen: boolean = false\n    private _lastActivityTimestamp: number = Date.now()\n    private windowId: string\n    private sessionId: string\n    private _linkedFlag: string | FlagVariant | null = null\n\n    private _fullSnapshotTimer?: ReturnType<typeof setInterval>\n\n    // if pageview capture is disabled\n    // then we can manually track href changes\n    private _lastHref?: string\n\n    // Util to help developers working on this feature manually override\n    _forceAllowLocalhostNetworkCapture = false\n\n    private get rrwebRecord(): rrwebRecord | undefined {\n        return assignableWindow?.rrweb?.record\n    }\n\n    public get started(): boolean {\n        // TODO could we use status instead of _captureStarted?\n        return this._captureStarted\n    }\n\n    private get sessionManager() {\n        if (!this.instance.sessionManager) {\n            throw new Error(LOGGER_PREFIX + ' must be started with a valid sessionManager.')\n        }\n\n        return this.instance.sessionManager\n    }\n\n    private get fullSnapshotIntervalMillis(): number {\n        return this.instance.config.session_recording?.full_snapshot_interval_millis || FIVE_MINUTES\n    }\n\n    private get isSampled(): boolean | null {\n        const currentValue = this.instance.get_property(SESSION_RECORDING_IS_SAMPLED)\n        return isBoolean(currentValue) ? currentValue : null\n    }\n\n    private get sessionDuration(): number | null {\n        const mostRecentSnapshot = this.buffer?.data[this.buffer?.data.length - 1]\n        const { sessionStartTimestamp } = this.sessionManager.checkAndGetSessionAndWindowId(true)\n        return mostRecentSnapshot ? mostRecentSnapshot.timestamp - sessionStartTimestamp : null\n    }\n\n    private get isRecordingEnabled() {\n        const enabled_server_side = !!this.instance.get_property(SESSION_RECORDING_ENABLED_SERVER_SIDE)\n        const enabled_client_side = !this.instance.config.disable_session_recording\n        return window && enabled_server_side && enabled_client_side\n    }\n\n    private get isConsoleLogCaptureEnabled() {\n        const enabled_server_side = !!this.instance.get_property(CONSOLE_LOG_RECORDING_ENABLED_SERVER_SIDE)\n        const enabled_client_side = this.instance.config.enable_recording_console_log\n        return enabled_client_side ?? enabled_server_side\n    }\n\n    private get canvasRecording(): { enabled: boolean; fps: number; quality: number } | undefined {\n        const canvasRecording_server_side = this.instance.get_property(SESSION_RECORDING_CANVAS_RECORDING)\n        return canvasRecording_server_side && canvasRecording_server_side.fps && canvasRecording_server_side.quality\n            ? {\n                  enabled: canvasRecording_server_side.enabled,\n                  fps: canvasRecording_server_side.fps,\n                  quality: canvasRecording_server_side.quality,\n              }\n            : undefined\n    }\n\n    // network payload capture config has three parts\n    // each can be configured server side or client side\n    private get networkPayloadCapture():\n        | Pick<NetworkRecordOptions, 'recordHeaders' | 'recordBody' | 'recordPerformance'>\n        | undefined {\n        const networkPayloadCapture_server_side = this.instance.get_property(SESSION_RECORDING_NETWORK_PAYLOAD_CAPTURE)\n        const networkPayloadCapture_client_side = {\n            recordHeaders: this.instance.config.session_recording?.recordHeaders,\n            recordBody: this.instance.config.session_recording?.recordBody,\n        }\n        const headersEnabled =\n            networkPayloadCapture_client_side?.recordHeaders || networkPayloadCapture_server_side?.recordHeaders\n        const bodyEnabled =\n            networkPayloadCapture_client_side?.recordBody || networkPayloadCapture_server_side?.recordBody\n        const clientConfigForPerformanceCapture = isObject(this.instance.config.capture_performance)\n            ? this.instance.config.capture_performance.network_timing\n            : this.instance.config.capture_performance\n        const networkTimingEnabled = !!(isBoolean(clientConfigForPerformanceCapture)\n            ? clientConfigForPerformanceCapture\n            : networkPayloadCapture_server_side?.capturePerformance)\n\n        return headersEnabled || bodyEnabled || networkTimingEnabled\n            ? { recordHeaders: headersEnabled, recordBody: bodyEnabled, recordPerformance: networkTimingEnabled }\n            : undefined\n    }\n\n    private get sampleRate(): number | null {\n        const rate = this.instance.get_property(SESSION_RECORDING_SAMPLE_RATE)\n        return isNumber(rate) ? rate : null\n    }\n\n    private get minimumDuration(): number | null {\n        const duration = this.instance.get_property(SESSION_RECORDING_MINIMUM_DURATION)\n        return isNumber(duration) ? duration : null\n    }\n\n    /**\n     * defaults to buffering mode until a decide response is received\n     * once a decide response is received status can be disabled, active or sampled\n     */\n    private get status(): SessionRecordingStatus {\n        if (!this.receivedDecide) {\n            return 'buffering'\n        }\n\n        if (!this.isRecordingEnabled) {\n            return 'disabled'\n        }\n\n        if (!isNullish(this._linkedFlag) && !this._linkedFlagSeen) {\n            return 'buffering'\n        }\n\n        if (isBoolean(this.isSampled)) {\n            return this.isSampled ? 'sampled' : 'disabled'\n        } else {\n            return 'active'\n        }\n    }\n\n    constructor(private readonly instance: PostHog) {\n        this._captureStarted = false\n        this._endpoint = BASE_ENDPOINT\n        this.stopRrweb = undefined\n        this.receivedDecide = false\n\n        window?.addEventListener('beforeunload', () => {\n            this._flushBuffer()\n        })\n\n        window?.addEventListener('offline', () => {\n            this._tryAddCustomEvent('browser offline', {})\n        })\n\n        window?.addEventListener('online', () => {\n            this._tryAddCustomEvent('browser online', {})\n        })\n\n        window?.addEventListener('visibilitychange', () => {\n            if (document?.visibilityState) {\n                const label = 'window ' + document.visibilityState\n                this._tryAddCustomEvent(label, {})\n            }\n        })\n\n        if (!this.instance.sessionManager) {\n            logger.error(LOGGER_PREFIX + ' started without valid sessionManager')\n            throw new Error(LOGGER_PREFIX + ' started without valid sessionManager. This is a bug.')\n        }\n\n        // we know there's a sessionManager, so don't need to start without a session id\n        const { sessionId, windowId } = this.sessionManager.checkAndGetSessionAndWindowId()\n        this.sessionId = sessionId\n        this.windowId = windowId\n\n        this.buffer = this.clearBuffer()\n\n        // on reload there might be an already sampled session that should be continued before decide response,\n        // so we call this here _and_ in the decide response\n        this._setupSampling()\n    }\n\n    startIfEnabledOrStop() {\n        if (this.isRecordingEnabled) {\n            this._startCapture()\n            logger.info(LOGGER_PREFIX + ' started')\n        } else {\n            this.stopRecording()\n            this.clearBuffer()\n        }\n    }\n\n    stopRecording() {\n        if (this._captureStarted && this.stopRrweb) {\n            this.stopRrweb()\n            this.stopRrweb = undefined\n            this._captureStarted = false\n            logger.info(LOGGER_PREFIX + ' stopped')\n        }\n    }\n\n    private makeSamplingDecision(sessionId: string): void {\n        const sessionIdChanged = this.sessionId !== sessionId\n\n        // capture the current sample rate,\n        // because it is re-used multiple times\n        // and the bundler won't minimise any of the references\n        const currentSampleRate = this.sampleRate\n\n        if (!isNumber(currentSampleRate)) {\n            this.instance.persistence?.register({\n                [SESSION_RECORDING_IS_SAMPLED]: null,\n            })\n            return\n        }\n\n        const storedIsSampled = this.isSampled\n\n        /**\n         * if we get this far then we should make a sampling decision.\n         * When the session id changes or there is no stored sampling decision for this session id\n         * then we should make a new decision.\n         *\n         * Otherwise, we should use the stored decision.\n         */\n        let shouldSample: boolean\n        const makeDecision = sessionIdChanged || !isBoolean(storedIsSampled)\n        if (makeDecision) {\n            const randomNumber = Math.random()\n            shouldSample = randomNumber < currentSampleRate\n        } else {\n            shouldSample = storedIsSampled\n        }\n\n        if (!shouldSample && makeDecision) {\n            logger.warn(\n                LOGGER_PREFIX +\n                    ` Sample rate (${currentSampleRate}) has determined that this sessionId (${sessionId}) will not be sent to the server.`\n            )\n        }\n        this._tryAddCustomEvent('samplingDecisionMade', {\n            sampleRate: currentSampleRate,\n        })\n\n        this.instance.persistence?.register({\n            [SESSION_RECORDING_IS_SAMPLED]: shouldSample,\n        })\n    }\n\n    afterDecideResponse(response: DecideResponse) {\n        this._persistDecideResponse(response)\n\n        this._linkedFlag = response.sessionRecording?.linkedFlag || null\n\n        if (response.sessionRecording?.endpoint) {\n            this._endpoint = response.sessionRecording?.endpoint\n        }\n\n        this._setupSampling()\n\n        if (!isNullish(this._linkedFlag) && !this._linkedFlagSeen) {\n            const linkedFlag = isString(this._linkedFlag) ? this._linkedFlag : this._linkedFlag.flag\n            const linkedVariant = isString(this._linkedFlag) ? null : this._linkedFlag.variant\n            this.instance.onFeatureFlags((_flags, variants) => {\n                const flagIsPresent = isObject(variants) && linkedFlag in variants\n                const linkedFlagMatches = linkedVariant ? variants[linkedFlag] === linkedVariant : flagIsPresent\n                if (linkedFlagMatches) {\n                    const payload = {\n                        linkedFlag,\n                        linkedVariant,\n                    }\n                    const tag = 'linked flag matched'\n                    logger.info(LOGGER_PREFIX + ' ' + tag, payload)\n                    this._tryAddCustomEvent(tag, payload)\n                }\n                this._linkedFlagSeen = linkedFlagMatches\n            })\n        }\n\n        this.receivedDecide = true\n        this.startIfEnabledOrStop()\n    }\n\n    private _samplingSessionListener: (() => void) | null = null\n\n    /**\n     * This might be called more than once so needs to be idempotent\n     */\n    private _setupSampling() {\n        if (isNumber(this.sampleRate) && isNull(this._samplingSessionListener)) {\n            this._samplingSessionListener = this.sessionManager.onSessionId((sessionId) => {\n                this.makeSamplingDecision(sessionId)\n            })\n        }\n    }\n\n    private _persistDecideResponse(response: DecideResponse): void {\n        if (this.instance.persistence) {\n            const persistence = this.instance.persistence\n\n            const persistResponse = () => {\n                const receivedSampleRate = response.sessionRecording?.sampleRate\n\n                const parsedSampleRate = isNullish(receivedSampleRate) ? null : parseFloat(receivedSampleRate)\n                const receivedMinimumDuration = response.sessionRecording?.minimumDurationMilliseconds\n\n                persistence.register({\n                    [SESSION_RECORDING_ENABLED_SERVER_SIDE]: !!response['sessionRecording'],\n                    [CONSOLE_LOG_RECORDING_ENABLED_SERVER_SIDE]: response.sessionRecording?.consoleLogRecordingEnabled,\n                    [SESSION_RECORDING_NETWORK_PAYLOAD_CAPTURE]: {\n                        capturePerformance: response.capturePerformance,\n                        ...response.sessionRecording?.networkPayloadCapture,\n                    },\n                    [SESSION_RECORDING_CANVAS_RECORDING]: {\n                        enabled: response.sessionRecording?.recordCanvas,\n                        fps: response.sessionRecording?.canvasFps,\n                        quality: response.sessionRecording?.canvasQuality,\n                    },\n                    [SESSION_RECORDING_SAMPLE_RATE]: parsedSampleRate,\n                    [SESSION_RECORDING_MINIMUM_DURATION]: isUndefined(receivedMinimumDuration)\n                        ? null\n                        : receivedMinimumDuration,\n                })\n            }\n\n            persistResponse()\n            this.sessionManager.onSessionId(persistResponse)\n        }\n    }\n\n    log(message: string, level: 'log' | 'warn' | 'error' = 'log') {\n        this.instance.sessionRecording?.onRRwebEmit({\n            type: 6,\n            data: {\n                plugin: 'rrweb/console@1',\n                payload: {\n                    level,\n                    trace: [],\n                    // Even though it is a string we stringify it as that's what rrweb expects\n                    payload: [JSON.stringify(message)],\n                },\n            },\n            timestamp: timestamp(),\n        })\n    }\n\n    private _startCapture() {\n        if (isUndefined(Object.assign)) {\n            // According to the rrweb docs, rrweb is not supported on IE11 and below:\n            // \"rrweb does not support IE11 and below because it uses the MutationObserver API which was supported by these browsers.\"\n            // https://github.com/rrweb-io/rrweb/blob/master/guide.md#compatibility-note\n            //\n            // However, MutationObserver does exist on IE11, it just doesn't work well and does not detect all changes.\n            // Instead, when we load \"recorder.js\", the first JS error is about \"Object.assign\" being undefined.\n            // Thus instead of MutationObserver, we look for this function and block recording if it's undefined.\n            return\n        }\n\n        // We do not switch recorder versions midway through a recording.\n        // do not start if explicitly disabled or if the user has opted out\n        if (\n            this._captureStarted ||\n            this.instance.config.disable_session_recording ||\n            this.instance.consent.isOptedOut()\n        ) {\n            return\n        }\n\n        this._captureStarted = true\n        // We want to ensure the sessionManager is reset if necessary on load of the recorder\n        this.sessionManager.checkAndGetSessionAndWindowId()\n\n        // If recorder.js is already loaded (if array.full.js snippet is used or posthog-js/dist/recorder is\n        // imported), don't load script. Otherwise, remotely import recorder.js from cdn since it hasn't been loaded.\n        if (!this.rrwebRecord) {\n            this.instance.requestRouter.loadScript(`/static/recorder.js?v=${Config.LIB_VERSION}`, (err) => {\n                if (err) {\n                    return logger.error(LOGGER_PREFIX + ` could not load recorder.js`, err)\n                }\n\n                this._onScriptLoaded()\n            })\n        } else {\n            this._onScriptLoaded()\n        }\n    }\n\n    private isInteractiveEvent(event: eventWithTime) {\n        return (\n            event.type === INCREMENTAL_SNAPSHOT_EVENT_TYPE &&\n            ACTIVE_SOURCES.indexOf(event.data?.source as IncrementalSource) !== -1\n        )\n    }\n\n    private _updateWindowAndSessionIds(event: eventWithTime) {\n        // Some recording events are triggered by non-user events (e.g. \"X minutes ago\" text updating on the screen).\n        // We don't want to extend the session or trigger a new session in these cases. These events are designated by event\n        // type -> incremental update, and source -> mutation.\n\n        const isUserInteraction = this.isInteractiveEvent(event)\n\n        if (!isUserInteraction && !this.isIdle) {\n            // We check if the lastActivityTimestamp is old enough to go idle\n            if (event.timestamp - this._lastActivityTimestamp > RECORDING_IDLE_ACTIVITY_TIMEOUT_MS) {\n                this.isIdle = true\n                // don't take full snapshots while idle\n                clearTimeout(this._fullSnapshotTimer)\n                // proactively flush the buffer in case the session is idle for a long time\n                this._flushBuffer()\n            }\n        }\n\n        let returningFromIdle = false\n        if (isUserInteraction) {\n            this._lastActivityTimestamp = event.timestamp\n            if (this.isIdle) {\n                // Remove the idle state\n                this.isIdle = false\n                this._tryAddCustomEvent('sessionNoLongerIdle', {\n                    reason: 'user activity',\n                    type: event.type,\n                })\n                returningFromIdle = true\n            }\n        }\n\n        if (this.isIdle) {\n            return\n        }\n\n        // We only want to extend the session if it is an interactive event.\n        const { windowId, sessionId } = this.sessionManager.checkAndGetSessionAndWindowId(\n            !isUserInteraction,\n            event.timestamp\n        )\n\n        const sessionIdChanged = this.sessionId !== sessionId\n        const windowIdChanged = this.windowId !== windowId\n\n        this.windowId = windowId\n        this.sessionId = sessionId\n\n        if (\n            returningFromIdle ||\n            ([FULL_SNAPSHOT_EVENT_TYPE, META_EVENT_TYPE].indexOf(event.type) === -1 &&\n                (windowIdChanged || sessionIdChanged || isUndefined(this._fullSnapshotTimer)))\n        ) {\n            this._tryTakeFullSnapshot()\n        }\n    }\n\n    private _tryRRWebMethod(queuedRRWebEvent: QueuedRRWebEvent): boolean {\n        try {\n            queuedRRWebEvent.rrwebMethod()\n            return true\n        } catch (e) {\n            // Sometimes a race can occur where the recorder is not fully started yet\n            if (this.queuedRRWebEvents.length < 10) {\n                this.queuedRRWebEvents.push({\n                    enqueuedAt: queuedRRWebEvent.enqueuedAt || Date.now(),\n                    attempt: queuedRRWebEvent.attempt++,\n                    rrwebMethod: queuedRRWebEvent.rrwebMethod,\n                })\n            } else {\n                logger.warn(LOGGER_PREFIX + ' could not emit queued rrweb event.', e, queuedRRWebEvent)\n            }\n\n            return false\n        }\n    }\n\n    private _tryAddCustomEvent(tag: string, payload: any): boolean {\n        return this._tryRRWebMethod(newQueuedEvent(() => this.rrwebRecord!.addCustomEvent(tag, payload)))\n    }\n\n    private _tryTakeFullSnapshot(): boolean {\n        return this._tryRRWebMethod(newQueuedEvent(() => this.rrwebRecord!.takeFullSnapshot()))\n    }\n\n    private _onScriptLoaded() {\n        // rrweb config info: https://github.com/rrweb-io/rrweb/blob/7d5d0033258d6c29599fb08412202d9a2c7b9413/src/record/index.ts#L28\n        const sessionRecordingOptions: recordOptions<eventWithTime> = {\n            // select set of rrweb config options we expose to our users\n            // see https://github.com/rrweb-io/rrweb/blob/master/guide.md\n            blockClass: 'ph-no-capture',\n            blockSelector: undefined,\n            ignoreClass: 'ph-ignore-input',\n            maskTextClass: 'ph-mask',\n            maskTextSelector: undefined,\n            maskTextFn: undefined,\n            maskAllInputs: true,\n            maskInputOptions: { password: true },\n            maskInputFn: undefined,\n            slimDOMOptions: {},\n            collectFonts: false,\n            inlineStylesheet: true,\n            recordCrossOriginIframes: false,\n        }\n\n        // only allows user to set our allow-listed options\n        const userSessionRecordingOptions = this.instance.config.session_recording\n        for (const [key, value] of Object.entries(userSessionRecordingOptions || {})) {\n            if (key in sessionRecordingOptions) {\n                if (key === 'maskInputOptions') {\n                    // ensure password is set if not included\n                    sessionRecordingOptions.maskInputOptions = { password: true, ...value }\n                } else {\n                    // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n                    // @ts-ignore\n                    sessionRecordingOptions[key] = value\n                }\n            }\n        }\n\n        if (this.canvasRecording && this.canvasRecording.enabled) {\n            sessionRecordingOptions.recordCanvas = true\n            sessionRecordingOptions.sampling = { canvas: this.canvasRecording.fps }\n            sessionRecordingOptions.dataURLOptions = { type: 'image/webp', quality: this.canvasRecording.quality }\n        }\n\n        if (!this.rrwebRecord) {\n            logger.error(\n                LOGGER_PREFIX +\n                    'onScriptLoaded was called but rrwebRecord is not available. This indicates something has gone wrong.'\n            )\n            return\n        }\n\n        this.mutationRateLimiter =\n            this.mutationRateLimiter ??\n            new MutationRateLimiter(this.rrwebRecord, {\n                onBlockedNode: (id, node) => {\n                    const message = `Too many mutations on node '${id}'. Rate limiting. This could be due to SVG animations or something similar`\n                    logger.info(message, {\n                        node: node,\n                    })\n\n                    this.log(LOGGER_PREFIX + ' ' + message, 'warn')\n                },\n            })\n\n        const activePlugins = this._gatherRRWebPlugins()\n        this.stopRrweb = this.rrwebRecord({\n            emit: (event) => {\n                this.onRRwebEmit(event)\n            },\n            plugins: activePlugins,\n            ...sessionRecordingOptions,\n        })\n\n        // :TRICKY: rrweb does not capture navigation within SPA-s, so hook into our $pageview events to get access to all events.\n        //   Dropping the initial event is fine (it's always captured by rrweb).\n        this.instance._addCaptureHook((eventName) => {\n            // If anything could go wrong here it has the potential to block the main loop,\n            // so we catch all errors.\n            try {\n                if (eventName === '$pageview') {\n                    const href = window ? this._maskUrl(window.location.href) : ''\n                    if (!href) {\n                        return\n                    }\n                    this._tryAddCustomEvent('$pageview', { href })\n                }\n            } catch (e) {\n                logger.error('Could not add $pageview to rrweb session', e)\n            }\n        })\n\n        // We reset the last activity timestamp, resetting the idle timer\n        this._lastActivityTimestamp = Date.now()\n        this.isIdle = false\n\n        this._tryAddCustomEvent('$session_options', {\n            sessionRecordingOptions,\n            activePlugins: activePlugins.map((p) => p?.name),\n        })\n\n        this._tryAddCustomEvent('$posthog_config', {\n            config: this.instance.config,\n        })\n    }\n\n    private _scheduleFullSnapshot(): void {\n        if (this._fullSnapshotTimer) {\n            clearInterval(this._fullSnapshotTimer)\n        }\n        // we don't schedule snapshots while idle\n        if (this.isIdle) {\n            return\n        }\n\n        const interval = this.fullSnapshotIntervalMillis\n        if (!interval) {\n            return\n        }\n\n        this._fullSnapshotTimer = setInterval(() => {\n            this._tryTakeFullSnapshot()\n        }, interval)\n    }\n\n    private _gatherRRWebPlugins() {\n        const plugins: RecordPlugin<unknown>[] = []\n\n        if (assignableWindow.rrwebConsoleRecord && this.isConsoleLogCaptureEnabled) {\n            plugins.push(assignableWindow.rrwebConsoleRecord.getRecordConsolePlugin())\n        }\n\n        if (this.networkPayloadCapture && isFunction(assignableWindow.getRecordNetworkPlugin)) {\n            const canRecordNetwork = !isLocalhost() || this._forceAllowLocalhostNetworkCapture\n\n            if (canRecordNetwork) {\n                plugins.push(\n                    assignableWindow.getRecordNetworkPlugin(\n                        buildNetworkRequestOptions(this.instance.config, this.networkPayloadCapture)\n                    )\n                )\n            } else {\n                logger.info(LOGGER_PREFIX + ' NetworkCapture not started because we are on localhost.')\n            }\n        }\n\n        return plugins\n    }\n\n    onRRwebEmit(rawEvent: eventWithTime) {\n        this._processQueuedEvents()\n\n        if (!rawEvent || !isObject(rawEvent)) {\n            return\n        }\n\n        if (rawEvent.type === EventType.Meta) {\n            const href = this._maskUrl(rawEvent.data.href)\n            this._lastHref = href\n            if (!href) {\n                return\n            }\n            rawEvent.data.href = href\n        } else {\n            this._pageViewFallBack()\n        }\n\n        // we're processing a full snapshot, so we should reset the timer\n        if (rawEvent.type === EventType.FullSnapshot) {\n            this._scheduleFullSnapshot()\n        }\n\n        const throttledEvent = this.mutationRateLimiter\n            ? this.mutationRateLimiter.throttleMutations(rawEvent)\n            : rawEvent\n\n        if (!throttledEvent) {\n            return\n        }\n\n        // TODO: Re-add ensureMaxMessageSize once we are confident in it\n        const event = truncateLargeConsoleLogs(throttledEvent)\n        const size = estimateSize(event)\n\n        this._updateWindowAndSessionIds(event)\n\n        // When in an idle state we keep recording, but don't capture the events\n        // but we allow custom events even when idle\n        if (this.isIdle && event.type !== EventType.Custom) {\n            return\n        }\n\n        const properties = {\n            $snapshot_bytes: size,\n            $snapshot_data: event,\n            $session_id: this.sessionId,\n            $window_id: this.windowId,\n        }\n\n        if (this.status !== 'disabled') {\n            this._captureSnapshotBuffered(properties)\n        } else {\n            this.clearBuffer()\n        }\n    }\n\n    private _pageViewFallBack() {\n        if (this.instance.config.capture_pageview || !window) {\n            return\n        }\n        const currentUrl = this._maskUrl(window.location.href)\n        if (this._lastHref !== currentUrl) {\n            this._tryAddCustomEvent('$url_changed', { href: currentUrl })\n            this._lastHref = currentUrl\n        }\n    }\n\n    private _processQueuedEvents() {\n        if (this.queuedRRWebEvents.length) {\n            // if rrweb isn't ready to accept events earlier then we queued them up\n            // now that emit has been called rrweb should be ready to accept them\n            // so, before we process this event, we try our queued events _once_ each\n            // we don't want to risk queuing more things and never exiting this loop!\n            // if they fail here, they'll be pushed into a new queue,\n            // and tried on the next loop.\n            // there is a risk of this queue growing in an uncontrolled manner,\n            // so its length is limited elsewhere\n            // for now this is to help us ensure we can capture events that happen\n            // and try to identify more about when it is failing\n            const itemsToProcess = [...this.queuedRRWebEvents]\n            this.queuedRRWebEvents = []\n            itemsToProcess.forEach((queuedRRWebEvent) => {\n                if (Date.now() - queuedRRWebEvent.enqueuedAt <= TWO_SECONDS) {\n                    this._tryRRWebMethod(queuedRRWebEvent)\n                }\n            })\n        }\n    }\n\n    private _maskUrl(url: string): string | undefined {\n        const userSessionRecordingOptions = this.instance.config.session_recording\n\n        if (userSessionRecordingOptions.maskNetworkRequestFn) {\n            let networkRequest: NetworkRequest | null | undefined = {\n                url,\n            }\n\n            // TODO we should deprecate this and use the same function for this masking and the rrweb/network plugin\n            // TODO or deprecate this and provide a new clearer name so this would be `maskURLPerformanceFn` or similar\n            networkRequest = userSessionRecordingOptions.maskNetworkRequestFn(networkRequest)\n\n            return networkRequest?.url\n        }\n\n        return url\n    }\n\n    private clearBuffer(): SnapshotBuffer {\n        this.buffer = {\n            size: 0,\n            data: [],\n            sessionId: this.sessionId,\n            windowId: this.windowId,\n        }\n        return this.buffer\n    }\n\n    private _flushBuffer(): SnapshotBuffer {\n        if (this.flushBufferTimer) {\n            clearTimeout(this.flushBufferTimer)\n            this.flushBufferTimer = undefined\n        }\n\n        const minimumDuration = this.minimumDuration\n        const sessionDuration = this.sessionDuration\n        // if we have old data in the buffer but the session has rotated then the\n        // session duration might be negative, in that case we want to flush the buffer\n        const isPositiveSessionDuration = isNumber(sessionDuration) && sessionDuration >= 0\n        const isBelowMinimumDuration =\n            isNumber(minimumDuration) && isPositiveSessionDuration && sessionDuration < minimumDuration\n\n        if (this.status === 'buffering' || isBelowMinimumDuration) {\n            this.flushBufferTimer = setTimeout(() => {\n                this._flushBuffer()\n            }, RECORDING_BUFFER_TIMEOUT)\n            return this.buffer\n        }\n\n        if (this.buffer.data.length > 0) {\n            const snapshotEvents = splitBuffer(this.buffer)\n            snapshotEvents.forEach((snapshotBuffer) => {\n                this._captureSnapshot({\n                    $snapshot_bytes: snapshotBuffer.size,\n                    $snapshot_data: snapshotBuffer.data,\n                    $session_id: snapshotBuffer.sessionId,\n                    $window_id: snapshotBuffer.windowId,\n                })\n            })\n        }\n\n        // buffer is empty, we clear it in case the session id has changed\n        return this.clearBuffer()\n    }\n\n    private _captureSnapshotBuffered(properties: Properties) {\n        const additionalBytes = 2 + (this.buffer?.data.length || 0) // 2 bytes for the array brackets and 1 byte for each comma\n        if (\n            this.buffer.size + properties.$snapshot_bytes + additionalBytes > RECORDING_MAX_EVENT_SIZE ||\n            this.buffer.sessionId !== this.sessionId\n        ) {\n            this.buffer = this._flushBuffer()\n        }\n\n        this.buffer.size += properties.$snapshot_bytes\n        this.buffer.data.push(properties.$snapshot_data)\n\n        if (!this.flushBufferTimer) {\n            this.flushBufferTimer = setTimeout(() => {\n                this._flushBuffer()\n            }, RECORDING_BUFFER_TIMEOUT)\n        }\n    }\n\n    private _captureSnapshot(properties: Properties) {\n        // :TRICKY: Make sure we batch these requests, use a custom endpoint and don't truncate the strings.\n        this.instance.capture('$snapshot', properties, {\n            _url: this.instance.requestRouter.endpointFor('api', this._endpoint),\n            _noTruncate: true,\n            _batchKey: SESSION_RECORDING_BATCH_KEY,\n        })\n    }\n\n    /**\n     * this ignores the linked flag config and causes capture to start\n     * (if recording would have started had the flag been received i.e. it does not override other config).\n     *\n     * It is not usual to call this directly,\n     * instead call `posthog.startSessionRecording({linked_flag: true})`\n     * */\n    public overrideLinkedFlag() {\n        this._linkedFlagSeen = true\n    }\n}\n","import { PostHog } from './posthog-core'\nimport { Compression, DecideResponse } from './types'\nimport { STORED_GROUP_PROPERTIES_KEY, STORED_PERSON_PROPERTIES_KEY } from './constants'\n\nimport { logger } from './utils/logger'\nimport { document, assignableWindow } from './utils/globals'\n\nexport class Decide {\n    constructor(private readonly instance: PostHog) {\n        // don't need to wait for `decide` to return if flags were provided on initialisation\n        this.instance.decideEndpointWasHit = this.instance._hasBootstrappedFeatureFlags()\n    }\n\n    call(): void {\n        /*\n        Calls /decide endpoint to fetch options for autocapture, session recording, feature flags & compression.\n        */\n        const data = {\n            token: this.instance.config.token,\n            distinct_id: this.instance.get_distinct_id(),\n            groups: this.instance.getGroups(),\n            person_properties: this.instance.get_property(STORED_PERSON_PROPERTIES_KEY),\n            group_properties: this.instance.get_property(STORED_GROUP_PROPERTIES_KEY),\n            disable_flags:\n                this.instance.config.advanced_disable_feature_flags ||\n                this.instance.config.advanced_disable_feature_flags_on_first_load ||\n                undefined,\n        }\n\n        this.instance._send_request({\n            method: 'POST',\n            url: this.instance.requestRouter.endpointFor('api', '/decide/?v=3'),\n            data,\n            compression: this.instance.config.disable_compression ? undefined : Compression.Base64,\n            timeout: this.instance.config.feature_flag_request_timeout_ms,\n            callback: (response) => this.parseDecideResponse(response.json as DecideResponse | undefined),\n        })\n    }\n\n    parseDecideResponse(response?: DecideResponse): void {\n        this.instance.featureFlags.setReloadingPaused(false)\n        // :TRICKY: Reload - start another request if queued!\n        this.instance.featureFlags._startReloadTimer()\n\n        const errorsLoading = !response\n\n        if (\n            !this.instance.config.advanced_disable_feature_flags_on_first_load &&\n            !this.instance.config.advanced_disable_feature_flags\n        ) {\n            this.instance.featureFlags.receivedFeatureFlags(response ?? {}, errorsLoading)\n        }\n\n        if (errorsLoading) {\n            logger.error('Failed to fetch feature flags from PostHog.')\n            return\n        }\n        if (!(document && document.body)) {\n            logger.info('document not ready yet, trying again in 500 milliseconds...')\n            setTimeout(() => {\n                this.parseDecideResponse(response)\n            }, 500)\n            return\n        }\n\n        this.instance._afterDecideResponse(response)\n\n        if (response['siteApps']) {\n            if (this.instance.config.opt_in_site_apps) {\n                for (const { id, url } of response['siteApps']) {\n                    const scriptUrl = this.instance.requestRouter.endpointFor('api', url)\n\n                    assignableWindow[`__$$ph_site_app_${id}`] = this.instance\n\n                    this.instance.requestRouter.loadScript(scriptUrl, (err) => {\n                        if (err) {\n                            return logger.error(`Error while initializing PostHog app with config id ${id}`, err)\n                        }\n                    })\n                }\n            } else if (response['siteApps'].length > 0) {\n                logger.error('PostHog site apps are disabled. Enable the \"opt_in_site_apps\" config to proceed.')\n            }\n        }\n    }\n}\n","import { QueuedRequestOptions } from './types'\nimport { each } from './utils'\n\nimport { isArray, isUndefined } from './utils/type-utils'\n\nexport class RequestQueue {\n    // We start in a paused state and only start flushing when enabled by the parent\n    private isPaused: boolean = true\n    private queue: QueuedRequestOptions[] = []\n    private flushTimeout?: ReturnType<typeof setTimeout>\n    private flushTimeoutMs = 3000\n    private sendRequest: (req: QueuedRequestOptions) => void\n\n    constructor(sendRequest: (req: QueuedRequestOptions) => void) {\n        this.sendRequest = sendRequest\n    }\n\n    enqueue(req: QueuedRequestOptions): void {\n        this.queue.push(req)\n\n        if (!this.flushTimeout) {\n            this.setFlushTimeout()\n        }\n    }\n\n    unload(): void {\n        this.clearFlushTimeout()\n        const requests = this.queue.length > 0 ? this.formatQueue() : {}\n        const requestValues = Object.values(requests)\n\n        // Always force events to be sent before recordings, as events are more important, and recordings are bigger and thus less likely to arrive\n        const sortedRequests = [\n            ...requestValues.filter((r) => r.url.indexOf('/e') === 0),\n            ...requestValues.filter((r) => r.url.indexOf('/e') !== 0),\n        ]\n        sortedRequests.map((req) => {\n            this.sendRequest({ ...req, transport: 'sendBeacon' })\n        })\n    }\n\n    enable(): void {\n        this.isPaused = false\n        this.setFlushTimeout()\n    }\n\n    private setFlushTimeout(): void {\n        if (this.isPaused) {\n            return\n        }\n        this.flushTimeout = setTimeout(() => {\n            this.clearFlushTimeout()\n            if (this.queue.length > 0) {\n                const requests = this.formatQueue()\n                for (const key in requests) {\n                    const req = requests[key]\n                    const now = new Date().getTime()\n\n                    if (req.data && isArray(req.data)) {\n                        each(req.data, (data) => {\n                            data['offset'] = Math.abs(data['timestamp'] - now)\n                            delete data['timestamp']\n                        })\n                    }\n                    this.sendRequest(req)\n                }\n            }\n        }, this.flushTimeoutMs)\n    }\n\n    private clearFlushTimeout(): void {\n        clearTimeout(this.flushTimeout)\n        this.flushTimeout = undefined\n    }\n\n    private formatQueue(): Record<string, QueuedRequestOptions> {\n        const requests: Record<string, QueuedRequestOptions> = {}\n        each(this.queue, (request: QueuedRequestOptions) => {\n            const req = request\n            const key = (req ? req.batchKey : null) || req.url\n            if (isUndefined(requests[key])) {\n                // TODO: What about this -it seems to batch data into an array - do we always want that?\n                requests[key] = { ...req, data: [] }\n            }\n\n            requests[key].data?.push(req.data)\n        })\n\n        this.queue = []\n        return requests\n    }\n}\n","// DEFLATE is a complex format; to read this code, you should probably check the RFC first:\n// https://tools.ietf.org/html/rfc1951\n// You may also wish to take a look at the guide I made about this program:\n// https://gist.github.com/101arrowz/253f31eb5abc3d9275ab943003ffecad\n// Much of the following code is similar to that of UZIP.js:\n// https://github.com/photopea/UZIP.js\n// Many optimizations have been made, so the bundle size is ultimately smaller but performance is similar.\n// Sometimes 0 will appear where -1 would be more appropriate. This is because using a uint\n// is better for memory in most engines (I *think*).\nvar ch2 = {};\nvar wk = (function (c, id, msg, transfer, cb) {\n    var u = ch2[id] || (ch2[id] = URL.createObjectURL(new Blob([c], { type: 'text/javascript' })));\n    var w = new Worker(u);\n    w.onerror = function (e) { return cb(e.error, null); };\n    w.onmessage = function (e) { return cb(null, e.data); };\n    w.postMessage(msg, transfer);\n    return w;\n});\n\n// aliases for shorter compressed code (most minifers don't do this)\nvar u8 = Uint8Array, u16 = Uint16Array, u32 = Uint32Array;\n// fixed length extra bits\nvar fleb = new u8([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, /* unused */ 0, 0, /* impossible */ 0]);\n// fixed distance extra bits\n// see fleb note\nvar fdeb = new u8([0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, /* unused */ 0, 0]);\n// code length index map\nvar clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);\n// get base, reverse index map from extra bits\nvar freb = function (eb, start) {\n    var b = new u16(31);\n    for (var i = 0; i < 31; ++i) {\n        b[i] = start += 1 << eb[i - 1];\n    }\n    // numbers here are at max 18 bits\n    var r = new u32(b[30]);\n    for (var i = 1; i < 30; ++i) {\n        for (var j = b[i]; j < b[i + 1]; ++j) {\n            r[j] = ((j - b[i]) << 5) | i;\n        }\n    }\n    return [b, r];\n};\nvar _a = freb(fleb, 2), fl = _a[0], revfl = _a[1];\n// we can ignore the fact that the other numbers are wrong; they never happen anyway\nfl[28] = 258, revfl[258] = 28;\nvar _b = freb(fdeb, 0), fd = _b[0], revfd = _b[1];\n// map of value to reverse (assuming 16 bits)\nvar rev = new u16(32768);\nfor (var i = 0; i < 32768; ++i) {\n    // reverse table algorithm from SO\n    var x = ((i & 0xAAAA) >>> 1) | ((i & 0x5555) << 1);\n    x = ((x & 0xCCCC) >>> 2) | ((x & 0x3333) << 2);\n    x = ((x & 0xF0F0) >>> 4) | ((x & 0x0F0F) << 4);\n    rev[i] = (((x & 0xFF00) >>> 8) | ((x & 0x00FF) << 8)) >>> 1;\n}\n// create huffman tree from u8 \"map\": index -> code length for code index\n// mb (max bits) must be at most 15\n// TODO: optimize/split up?\nvar hMap = (function (cd, mb, r) {\n    var s = cd.length;\n    // index\n    var i = 0;\n    // u16 \"map\": index -> # of codes with bit length = index\n    var l = new u16(mb);\n    // length of cd must be 288 (total # of codes)\n    for (; i < s; ++i)\n        ++l[cd[i] - 1];\n    // u16 \"map\": index -> minimum code for bit length = index\n    var le = new u16(mb);\n    for (i = 0; i < mb; ++i) {\n        le[i] = (le[i - 1] + l[i - 1]) << 1;\n    }\n    var co;\n    if (r) {\n        // u16 \"map\": index -> number of actual bits, symbol for code\n        co = new u16(1 << mb);\n        // bits to remove for reverser\n        var rvb = 15 - mb;\n        for (i = 0; i < s; ++i) {\n            // ignore 0 lengths\n            if (cd[i]) {\n                // num encoding both symbol and bits read\n                var sv = (i << 4) | cd[i];\n                // free bits\n                var r_1 = mb - cd[i];\n                // start value\n                var v = le[cd[i] - 1]++ << r_1;\n                // m is end value\n                for (var m = v | ((1 << r_1) - 1); v <= m; ++v) {\n                    // every 16 bit value starting with the code yields the same result\n                    co[rev[v] >>> rvb] = sv;\n                }\n            }\n        }\n    }\n    else {\n        co = new u16(s);\n        for (i = 0; i < s; ++i)\n            co[i] = rev[le[cd[i] - 1]++] >>> (15 - cd[i]);\n    }\n    return co;\n});\n// fixed length tree\nvar flt = new u8(288);\nfor (var i = 0; i < 144; ++i)\n    flt[i] = 8;\nfor (var i = 144; i < 256; ++i)\n    flt[i] = 9;\nfor (var i = 256; i < 280; ++i)\n    flt[i] = 7;\nfor (var i = 280; i < 288; ++i)\n    flt[i] = 8;\n// fixed distance tree\nvar fdt = new u8(32);\nfor (var i = 0; i < 32; ++i)\n    fdt[i] = 5;\n// fixed length map\nvar flm = /*#__PURE__*/ hMap(flt, 9, 0), flrm = /*#__PURE__*/ hMap(flt, 9, 1);\n// fixed distance map\nvar fdm = /*#__PURE__*/ hMap(fdt, 5, 0), fdrm = /*#__PURE__*/ hMap(fdt, 5, 1);\n// find max of array\nvar max = function (a) {\n    var m = a[0];\n    for (var i = 1; i < a.length; ++i) {\n        if (a[i] > m)\n            m = a[i];\n    }\n    return m;\n};\n// read d, starting at bit p and mask with m\nvar bits = function (d, p, m) {\n    var o = (p / 8) >> 0;\n    return ((d[o] | (d[o + 1] << 8)) >>> (p & 7)) & m;\n};\n// read d, starting at bit p continuing for at least 16 bits\nvar bits16 = function (d, p) {\n    var o = (p / 8) >> 0;\n    return ((d[o] | (d[o + 1] << 8) | (d[o + 2] << 16)) >>> (p & 7));\n};\n// get end of byte\nvar shft = function (p) { return ((p / 8) >> 0) + (p & 7 && 1); };\n// typed array slice - allows garbage collector to free original reference,\n// while being more compatible than .slice\nvar slc = function (v, s, e) {\n    if (s == null || s < 0)\n        s = 0;\n    if (e == null || e > v.length)\n        e = v.length;\n    // can't use .constructor in case user-supplied\n    var n = new (v instanceof u16 ? u16 : v instanceof u32 ? u32 : u8)(e - s);\n    n.set(v.subarray(s, e));\n    return n;\n};\n// expands raw DEFLATE data\nvar inflt = function (dat, buf, st) {\n    // source length\n    var sl = dat.length;\n    // have to estimate size\n    var noBuf = !buf || st;\n    // no state\n    var noSt = !st || st.i;\n    if (!st)\n        st = {};\n    // Assumes roughly 33% compression ratio average\n    if (!buf)\n        buf = new u8(sl * 3);\n    // ensure buffer can fit at least l elements\n    var cbuf = function (l) {\n        var bl = buf.length;\n        // need to increase size to fit\n        if (l > bl) {\n            // Double or set to necessary, whichever is greater\n            var nbuf = new u8(Math.max(bl * 2, l));\n            nbuf.set(buf);\n            buf = nbuf;\n        }\n    };\n    //  last chunk         bitpos           bytes\n    var final = st.f || 0, pos = st.p || 0, bt = st.b || 0, lm = st.l, dm = st.d, lbt = st.m, dbt = st.n;\n    // total bits\n    var tbts = sl * 8;\n    do {\n        if (!lm) {\n            // BFINAL - this is only 1 when last chunk is next\n            st.f = final = bits(dat, pos, 1);\n            // type: 0 = no compression, 1 = fixed huffman, 2 = dynamic huffman\n            var type = bits(dat, pos + 1, 3);\n            pos += 3;\n            if (!type) {\n                // go to end of byte boundary\n                var s = shft(pos) + 4, l = dat[s - 4] | (dat[s - 3] << 8), t = s + l;\n                if (t > sl) {\n                    if (noSt)\n                        throw 'unexpected EOF';\n                    break;\n                }\n                // ensure size\n                if (noBuf)\n                    cbuf(bt + l);\n                // Copy over uncompressed data\n                buf.set(dat.subarray(s, t), bt);\n                // Get new bitpos, update byte count\n                st.b = bt += l, st.p = pos = t * 8;\n                continue;\n            }\n            else if (type == 1)\n                lm = flrm, dm = fdrm, lbt = 9, dbt = 5;\n            else if (type == 2) {\n                //  literal                            lengths\n                var hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4;\n                var tl = hLit + bits(dat, pos + 5, 31) + 1;\n                pos += 14;\n                // length+distance tree\n                var ldt = new u8(tl);\n                // code length tree\n                var clt = new u8(19);\n                for (var i = 0; i < hcLen; ++i) {\n                    // use index map to get real code\n                    clt[clim[i]] = bits(dat, pos + i * 3, 7);\n                }\n                pos += hcLen * 3;\n                // code lengths bits\n                var clb = max(clt), clbmsk = (1 << clb) - 1;\n                if (!noSt && pos + tl * (clb + 7) > tbts)\n                    break;\n                // code lengths map\n                var clm = hMap(clt, clb, 1);\n                for (var i = 0; i < tl;) {\n                    var r = clm[bits(dat, pos, clbmsk)];\n                    // bits read\n                    pos += r & 15;\n                    // symbol\n                    var s = r >>> 4;\n                    // code length to copy\n                    if (s < 16) {\n                        ldt[i++] = s;\n                    }\n                    else {\n                        //  copy   count\n                        var c = 0, n = 0;\n                        if (s == 16)\n                            n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i - 1];\n                        else if (s == 17)\n                            n = 3 + bits(dat, pos, 7), pos += 3;\n                        else if (s == 18)\n                            n = 11 + bits(dat, pos, 127), pos += 7;\n                        while (n--)\n                            ldt[i++] = c;\n                    }\n                }\n                //    length tree                 distance tree\n                var lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit);\n                // max length bits\n                lbt = max(lt);\n                // max dist bits\n                dbt = max(dt);\n                lm = hMap(lt, lbt, 1);\n                dm = hMap(dt, dbt, 1);\n            }\n            else\n                throw 'invalid block type';\n            if (pos > tbts)\n                throw 'unexpected EOF';\n        }\n        // Make sure the buffer can hold this + the largest possible addition\n        // Maximum chunk size (practically, theoretically infinite) is 2^17;\n        if (noBuf)\n            cbuf(bt + 131072);\n        var lms = (1 << lbt) - 1, dms = (1 << dbt) - 1;\n        var mxa = lbt + dbt + 18;\n        while (noSt || pos + mxa < tbts) {\n            // bits read, code\n            var c = lm[bits16(dat, pos) & lms], sym = c >>> 4;\n            pos += c & 15;\n            if (pos > tbts)\n                throw 'unexpected EOF';\n            if (!c)\n                throw 'invalid length/literal';\n            if (sym < 256)\n                buf[bt++] = sym;\n            else if (sym == 256) {\n                lm = null;\n                break;\n            }\n            else {\n                var add = sym - 254;\n                // no extra bits needed if less\n                if (sym > 264) {\n                    // index\n                    var i = sym - 257, b = fleb[i];\n                    add = bits(dat, pos, (1 << b) - 1) + fl[i];\n                    pos += b;\n                }\n                // dist\n                var d = dm[bits16(dat, pos) & dms], dsym = d >>> 4;\n                if (!d)\n                    throw 'invalid distance';\n                pos += d & 15;\n                var dt = fd[dsym];\n                if (dsym > 3) {\n                    var b = fdeb[dsym];\n                    dt += bits16(dat, pos) & ((1 << b) - 1), pos += b;\n                }\n                if (pos > tbts)\n                    throw 'unexpected EOF';\n                if (noBuf)\n                    cbuf(bt + 131072);\n                var end = bt + add;\n                for (; bt < end; bt += 4) {\n                    buf[bt] = buf[bt - dt];\n                    buf[bt + 1] = buf[bt + 1 - dt];\n                    buf[bt + 2] = buf[bt + 2 - dt];\n                    buf[bt + 3] = buf[bt + 3 - dt];\n                }\n                bt = end;\n            }\n        }\n        st.l = lm, st.p = pos, st.b = bt;\n        if (lm)\n            final = 1, st.m = lbt, st.d = dm, st.n = dbt;\n    } while (!final);\n    return bt == buf.length ? buf : slc(buf, 0, bt);\n};\n// starting at p, write the minimum number of bits that can hold v to d\nvar wbits = function (d, p, v) {\n    v <<= p & 7;\n    var o = (p / 8) >> 0;\n    d[o] |= v;\n    d[o + 1] |= v >>> 8;\n};\n// starting at p, write the minimum number of bits (>8) that can hold v to d\nvar wbits16 = function (d, p, v) {\n    v <<= p & 7;\n    var o = (p / 8) >> 0;\n    d[o] |= v;\n    d[o + 1] |= v >>> 8;\n    d[o + 2] |= v >>> 16;\n};\n// creates code lengths from a frequency table\nvar hTree = function (d, mb) {\n    // Need extra info to make a tree\n    var t = [];\n    for (var i = 0; i < d.length; ++i) {\n        if (d[i])\n            t.push({ s: i, f: d[i] });\n    }\n    var s = t.length;\n    var t2 = t.slice();\n    if (!s)\n        return [new u8(0), 0];\n    if (s == 1) {\n        var v = new u8(t[0].s + 1);\n        v[t[0].s] = 1;\n        return [v, 1];\n    }\n    t.sort(function (a, b) { return a.f - b.f; });\n    // after i2 reaches last ind, will be stopped\n    // freq must be greater than largest possible number of symbols\n    t.push({ s: -1, f: 25001 });\n    var l = t[0], r = t[1], i0 = 0, i1 = 1, i2 = 2;\n    t[0] = { s: -1, f: l.f + r.f, l: l, r: r };\n    // efficient algorithm from UZIP.js\n    // i0 is lookbehind, i2 is lookahead - after processing two low-freq\n    // symbols that combined have high freq, will start processing i2 (high-freq,\n    // non-composite) symbols instead\n    // see https://reddit.com/r/photopea/comments/ikekht/uzipjs_questions/\n    while (i1 != s - 1) {\n        l = t[t[i0].f < t[i2].f ? i0++ : i2++];\n        r = t[i0 != i1 && t[i0].f < t[i2].f ? i0++ : i2++];\n        t[i1++] = { s: -1, f: l.f + r.f, l: l, r: r };\n    }\n    var maxSym = t2[0].s;\n    for (var i = 1; i < s; ++i) {\n        if (t2[i].s > maxSym)\n            maxSym = t2[i].s;\n    }\n    // code lengths\n    var tr = new u16(maxSym + 1);\n    // max bits in tree\n    var mbt = ln(t[i1 - 1], tr, 0);\n    if (mbt > mb) {\n        // more algorithms from UZIP.js\n        // TODO: find out how this code works (debt)\n        //  ind    debt\n        var i = 0, dt = 0;\n        //    left            cost\n        var lft = mbt - mb, cst = 1 << lft;\n        t2.sort(function (a, b) { return tr[b.s] - tr[a.s] || a.f - b.f; });\n        for (; i < s; ++i) {\n            var i2_1 = t2[i].s;\n            if (tr[i2_1] > mb) {\n                dt += cst - (1 << (mbt - tr[i2_1]));\n                tr[i2_1] = mb;\n            }\n            else\n                break;\n        }\n        dt >>>= lft;\n        while (dt > 0) {\n            var i2_2 = t2[i].s;\n            if (tr[i2_2] < mb)\n                dt -= 1 << (mb - tr[i2_2]++ - 1);\n            else\n                ++i;\n        }\n        for (; i >= 0 && dt; --i) {\n            var i2_3 = t2[i].s;\n            if (tr[i2_3] == mb) {\n                --tr[i2_3];\n                ++dt;\n            }\n        }\n        mbt = mb;\n    }\n    return [new u8(tr), mbt];\n};\n// get the max length and assign length codes\nvar ln = function (n, l, d) {\n    return n.s == -1\n        ? Math.max(ln(n.l, l, d + 1), ln(n.r, l, d + 1))\n        : (l[n.s] = d);\n};\n// length codes generation\nvar lc = function (c) {\n    var s = c.length;\n    // Note that the semicolon was intentional\n    while (s && !c[--s])\n        ;\n    var cl = new u16(++s);\n    //  ind      num         streak\n    var cli = 0, cln = c[0], cls = 1;\n    var w = function (v) { cl[cli++] = v; };\n    for (var i = 1; i <= s; ++i) {\n        if (c[i] == cln && i != s)\n            ++cls;\n        else {\n            if (!cln && cls > 2) {\n                for (; cls > 138; cls -= 138)\n                    w(32754);\n                if (cls > 2) {\n                    w(cls > 10 ? ((cls - 11) << 5) | 28690 : ((cls - 3) << 5) | 12305);\n                    cls = 0;\n                }\n            }\n            else if (cls > 3) {\n                w(cln), --cls;\n                for (; cls > 6; cls -= 6)\n                    w(8304);\n                if (cls > 2)\n                    w(((cls - 3) << 5) | 8208), cls = 0;\n            }\n            while (cls--)\n                w(cln);\n            cls = 1;\n            cln = c[i];\n        }\n    }\n    return [cl.subarray(0, cli), s];\n};\n// calculate the length of output from tree, code lengths\nvar clen = function (cf, cl) {\n    var l = 0;\n    for (var i = 0; i < cl.length; ++i)\n        l += cf[i] * cl[i];\n    return l;\n};\n// writes a fixed block\n// returns the new bit pos\nvar wfblk = function (out, pos, dat) {\n    // no need to write 00 as type: TypedArray defaults to 0\n    var s = dat.length;\n    var o = shft(pos + 2);\n    out[o] = s & 255;\n    out[o + 1] = s >>> 8;\n    out[o + 2] = out[o] ^ 255;\n    out[o + 3] = out[o + 1] ^ 255;\n    for (var i = 0; i < s; ++i)\n        out[o + i + 4] = dat[i];\n    return (o + 4 + s) * 8;\n};\n// writes a block\nvar wblk = function (dat, out, final, syms, lf, df, eb, li, bs, bl, p) {\n    wbits(out, p++, final);\n    ++lf[256];\n    var _a = hTree(lf, 15), dlt = _a[0], mlb = _a[1];\n    var _b = hTree(df, 15), ddt = _b[0], mdb = _b[1];\n    var _c = lc(dlt), lclt = _c[0], nlc = _c[1];\n    var _d = lc(ddt), lcdt = _d[0], ndc = _d[1];\n    var lcfreq = new u16(19);\n    for (var i = 0; i < lclt.length; ++i)\n        lcfreq[lclt[i] & 31]++;\n    for (var i = 0; i < lcdt.length; ++i)\n        lcfreq[lcdt[i] & 31]++;\n    var _e = hTree(lcfreq, 7), lct = _e[0], mlcb = _e[1];\n    var nlcc = 19;\n    for (; nlcc > 4 && !lct[clim[nlcc - 1]]; --nlcc)\n        ;\n    var flen = (bl + 5) << 3;\n    var ftlen = clen(lf, flt) + clen(df, fdt) + eb;\n    var dtlen = clen(lf, dlt) + clen(df, ddt) + eb + 14 + 3 * nlcc + clen(lcfreq, lct) + (2 * lcfreq[16] + 3 * lcfreq[17] + 7 * lcfreq[18]);\n    if (flen <= ftlen && flen <= dtlen)\n        return wfblk(out, p, dat.subarray(bs, bs + bl));\n    var lm, ll, dm, dl;\n    wbits(out, p, 1 + (dtlen < ftlen)), p += 2;\n    if (dtlen < ftlen) {\n        lm = hMap(dlt, mlb, 0), ll = dlt, dm = hMap(ddt, mdb, 0), dl = ddt;\n        var llm = hMap(lct, mlcb, 0);\n        wbits(out, p, nlc - 257);\n        wbits(out, p + 5, ndc - 1);\n        wbits(out, p + 10, nlcc - 4);\n        p += 14;\n        for (var i = 0; i < nlcc; ++i)\n            wbits(out, p + 3 * i, lct[clim[i]]);\n        p += 3 * nlcc;\n        var lcts = [lclt, lcdt];\n        for (var it = 0; it < 2; ++it) {\n            var clct = lcts[it];\n            for (var i = 0; i < clct.length; ++i) {\n                var len = clct[i] & 31;\n                wbits(out, p, llm[len]), p += lct[len];\n                if (len > 15)\n                    wbits(out, p, (clct[i] >>> 5) & 127), p += clct[i] >>> 12;\n            }\n        }\n    }\n    else {\n        lm = flm, ll = flt, dm = fdm, dl = fdt;\n    }\n    for (var i = 0; i < li; ++i) {\n        if (syms[i] > 255) {\n            var len = (syms[i] >>> 18) & 31;\n            wbits16(out, p, lm[len + 257]), p += ll[len + 257];\n            if (len > 7)\n                wbits(out, p, (syms[i] >>> 23) & 31), p += fleb[len];\n            var dst = syms[i] & 31;\n            wbits16(out, p, dm[dst]), p += dl[dst];\n            if (dst > 3)\n                wbits16(out, p, (syms[i] >>> 5) & 8191), p += fdeb[dst];\n        }\n        else {\n            wbits16(out, p, lm[syms[i]]), p += ll[syms[i]];\n        }\n    }\n    wbits16(out, p, lm[256]);\n    return p + ll[256];\n};\n// deflate options (nice << 13) | chain\nvar deo = /*#__PURE__*/ new u32([65540, 131080, 131088, 131104, 262176, 1048704, 1048832, 2114560, 2117632]);\n// empty\nvar et = /*#__PURE__*/ new u8(0);\n// compresses data into a raw DEFLATE buffer\nvar dflt = function (dat, lvl, plvl, pre, post, lst) {\n    var s = dat.length;\n    var o = new u8(pre + s + 5 * (1 + Math.floor(s / 7000)) + post);\n    // writing to this writes to the output buffer\n    var w = o.subarray(pre, o.length - post);\n    var pos = 0;\n    if (!lvl || s < 8) {\n        for (var i = 0; i <= s; i += 65535) {\n            // end\n            var e = i + 65535;\n            if (e < s) {\n                // write full block\n                pos = wfblk(w, pos, dat.subarray(i, e));\n            }\n            else {\n                // write final block\n                w[i] = lst;\n                pos = wfblk(w, pos, dat.subarray(i, s));\n            }\n        }\n    }\n    else {\n        var opt = deo[lvl - 1];\n        var n = opt >>> 13, c = opt & 8191;\n        var msk_1 = (1 << plvl) - 1;\n        //    prev 2-byte val map    curr 2-byte val map\n        var prev = new u16(32768), head = new u16(msk_1 + 1);\n        var bs1_1 = Math.ceil(plvl / 3), bs2_1 = 2 * bs1_1;\n        var hsh = function (i) { return (dat[i] ^ (dat[i + 1] << bs1_1) ^ (dat[i + 2] << bs2_1)) & msk_1; };\n        // 24576 is an arbitrary number of maximum symbols per block\n        // 424 buffer for last block\n        var syms = new u32(25000);\n        // length/literal freq   distance freq\n        var lf = new u16(288), df = new u16(32);\n        //  l/lcnt  exbits  index  l/lind  waitdx  bitpos\n        var lc_1 = 0, eb = 0, i = 0, li = 0, wi = 0, bs = 0;\n        for (; i < s; ++i) {\n            // hash value\n            var hv = hsh(i);\n            // index mod 32768\n            var imod = i & 32767;\n            // previous index with this value\n            var pimod = head[hv];\n            prev[imod] = pimod;\n            head[hv] = imod;\n            // We always should modify head and prev, but only add symbols if\n            // this data is not yet processed (\"wait\" for wait index)\n            if (wi <= i) {\n                // bytes remaining\n                var rem = s - i;\n                if ((lc_1 > 7000 || li > 24576) && rem > 423) {\n                    pos = wblk(dat, w, 0, syms, lf, df, eb, li, bs, i - bs, pos);\n                    li = lc_1 = eb = 0, bs = i;\n                    for (var j = 0; j < 286; ++j)\n                        lf[j] = 0;\n                    for (var j = 0; j < 30; ++j)\n                        df[j] = 0;\n                }\n                //  len    dist   chain\n                var l = 2, d = 0, ch_1 = c, dif = (imod - pimod) & 32767;\n                if (rem > 2 && hv == hsh(i - dif)) {\n                    var maxn = Math.min(n, rem) - 1;\n                    var maxd = Math.min(32767, i);\n                    // max possible length\n                    // not capped at dif because decompressors implement \"rolling\" index population\n                    var ml = Math.min(258, rem);\n                    while (dif <= maxd && --ch_1 && imod != pimod) {\n                        if (dat[i + l] == dat[i + l - dif]) {\n                            var nl = 0;\n                            for (; nl < ml && dat[i + nl] == dat[i + nl - dif]; ++nl)\n                                ;\n                            if (nl > l) {\n                                l = nl, d = dif;\n                                // break out early when we reach \"nice\" (we are satisfied enough)\n                                if (nl > maxn)\n                                    break;\n                                // now, find the rarest 2-byte sequence within this\n                                // length of literals and search for that instead.\n                                // Much faster than just using the start\n                                var mmd = Math.min(dif, nl - 2);\n                                var md = 0;\n                                for (var j = 0; j < mmd; ++j) {\n                                    var ti = (i - dif + j + 32768) & 32767;\n                                    var pti = prev[ti];\n                                    var cd = (ti - pti + 32768) & 32767;\n                                    if (cd > md)\n                                        md = cd, pimod = ti;\n                                }\n                            }\n                        }\n                        // check the previous match\n                        imod = pimod, pimod = prev[imod];\n                        dif += (imod - pimod + 32768) & 32767;\n                    }\n                }\n                // d will be nonzero only when a match was found\n                if (d) {\n                    // store both dist and len data in one Uint32\n                    // Make sure this is recognized as a len/dist with 28th bit (2^28)\n                    syms[li++] = 268435456 | (revfl[l] << 18) | revfd[d];\n                    var lin = revfl[l] & 31, din = revfd[d] & 31;\n                    eb += fleb[lin] + fdeb[din];\n                    ++lf[257 + lin];\n                    ++df[din];\n                    wi = i + l;\n                    ++lc_1;\n                }\n                else {\n                    syms[li++] = dat[i];\n                    ++lf[dat[i]];\n                }\n            }\n        }\n        pos = wblk(dat, w, lst, syms, lf, df, eb, li, bs, i - bs, pos);\n        // this is the easiest way to avoid needing to maintain state\n        if (!lst)\n            pos = wfblk(w, pos, et);\n    }\n    return slc(o, 0, pre + shft(pos) + post);\n};\n// CRC32 table\nvar crct = /*#__PURE__*/ (function () {\n    var t = new u32(256);\n    for (var i = 0; i < 256; ++i) {\n        var c = i, k = 9;\n        while (--k)\n            c = ((c & 1) && 0xEDB88320) ^ (c >>> 1);\n        t[i] = c;\n    }\n    return t;\n})();\n// CRC32\nvar crc = function () {\n    var c = 0xFFFFFFFF;\n    return {\n        p: function (d) {\n            // closures have awful performance\n            var cr = c;\n            for (var i = 0; i < d.length; ++i)\n                cr = crct[(cr & 255) ^ d[i]] ^ (cr >>> 8);\n            c = cr;\n        },\n        d: function () { return c ^ 0xFFFFFFFF; }\n    };\n};\n// Alder32\nvar adler = function () {\n    var a = 1, b = 0;\n    return {\n        p: function (d) {\n            // closures have awful performance\n            var n = a, m = b;\n            var l = d.length;\n            for (var i = 0; i != l;) {\n                var e = Math.min(i + 5552, l);\n                for (; i < e; ++i)\n                    n += d[i], m += n;\n                n %= 65521, m %= 65521;\n            }\n            a = n, b = m;\n        },\n        d: function () { return ((a >>> 8) << 16 | (b & 255) << 8 | (b >>> 8)) + ((a & 255) << 23) * 2; }\n    };\n};\n;\n// deflate with opts\nvar dopt = function (dat, opt, pre, post, st) {\n    return dflt(dat, opt.level == null ? 6 : opt.level, opt.mem == null ? Math.ceil(Math.max(8, Math.min(13, Math.log(dat.length))) * 1.5) : (12 + opt.mem), pre, post, !st);\n};\n// Walmart object spread\nvar mrg = function (a, b) {\n    var o = {};\n    for (var k in a)\n        o[k] = a[k];\n    for (var k in b)\n        o[k] = b[k];\n    return o;\n};\n// worker clone\n// This is possibly the craziest part of the entire codebase, despite how simple it may seem.\n// The only parameter to this function is a closure that returns an array of variables outside of the function scope.\n// We're going to try to figure out the variable names used in the closure as strings because that is crucial for workerization.\n// We will return an object mapping of true variable name to value (basically, the current scope as a JS object).\n// The reason we can't just use the original variable names is minifiers mangling the toplevel scope.\n// This took me three weeks to figure out how to do.\nvar wcln = function (fn, fnStr, td) {\n    var dt = fn();\n    var st = fn.toString();\n    var ks = st.slice(st.indexOf('[') + 1, st.lastIndexOf(']')).replace(/ /g, '').split(',');\n    for (var i = 0; i < dt.length; ++i) {\n        var v = dt[i], k = ks[i];\n        if (typeof v == 'function') {\n            fnStr += ';' + k + '=';\n            var st_1 = v.toString();\n            if (v.prototype) {\n                // for global objects\n                if (st_1.indexOf('[native code]') != -1) {\n                    var spInd = st_1.indexOf(' ', 8) + 1;\n                    fnStr += st_1.slice(spInd, st_1.indexOf('(', spInd));\n                }\n                else {\n                    fnStr += st_1;\n                    for (var t in v.prototype)\n                        fnStr += ';' + k + '.prototype.' + t + '=' + v.prototype[t].toString();\n                }\n            }\n            else\n                fnStr += st_1;\n        }\n        else\n            td[k] = v;\n    }\n    return [fnStr, td];\n};\nvar ch = [];\n// clone bufs\nvar cbfs = function (v) {\n    var tl = [];\n    for (var k in v) {\n        if (v[k] instanceof u8 || v[k] instanceof u16 || v[k] instanceof u32)\n            tl.push((v[k] = new v[k].constructor(v[k])).buffer);\n    }\n    return tl;\n};\n// use a worker to execute code\nvar wrkr = function (fns, init, id, cb) {\n    var _a;\n    if (!ch[id]) {\n        var fnStr = '', td_1 = {}, m = fns.length - 1;\n        for (var i = 0; i < m; ++i)\n            _a = wcln(fns[i], fnStr, td_1), fnStr = _a[0], td_1 = _a[1];\n        ch[id] = wcln(fns[m], fnStr, td_1);\n    }\n    var td = mrg({}, ch[id][1]);\n    return wk(ch[id][0] + ';onmessage=function(e){for(var k in e.data)self[k]=e.data[k];onmessage=' + init.toString() + '}', id, td, cbfs(td), cb);\n};\n// base async inflate fn\nvar bInflt = function () { return [u8, u16, u32, fleb, fdeb, clim, fl, fd, flrm, fdrm, rev, hMap, max, bits, bits16, shft, slc, inflt, inflateSync, pbf, gu8]; };\nvar bDflt = function () { return [u8, u16, u32, fleb, fdeb, clim, revfl, revfd, flm, flt, fdm, fdt, rev, deo, et, hMap, wbits, wbits16, hTree, ln, lc, clen, wfblk, wblk, shft, slc, dflt, dopt, deflateSync, pbf]; };\n// gzip extra\nvar gze = function () { return [gzh, gzhl, wbytes, crc, crct]; };\n// gunzip extra\nvar guze = function () { return [gzs, gzl]; };\n// zlib extra\nvar zle = function () { return [zlh, wbytes, adler]; };\n// unzlib extra\nvar zule = function () { return [zlv]; };\n// post buf\nvar pbf = function (msg) { return postMessage(msg, [msg.buffer]); };\n// get u8\nvar gu8 = function (o) { return o && o.size && new u8(o.size); };\n// async helper\nvar cbify = function (dat, opts, fns, init, id, cb) {\n    var w = wrkr(fns, init, id, function (err, dat) {\n        w.terminate();\n        cb(err, dat);\n    });\n    if (!opts.consume)\n        dat = new u8(dat);\n    w.postMessage([dat, opts], [dat.buffer]);\n    return function () { w.terminate(); };\n};\n// auto stream\nvar astrm = function (strm) {\n    strm.ondata = function (dat, final) { return postMessage([dat, final], [dat.buffer]); };\n    return function (ev) { return strm.push(ev.data[0], ev.data[1]); };\n};\n// async stream attach\nvar astrmify = function (fns, strm, opts, init, id) {\n    var t;\n    var w = wrkr(fns, init, id, function (err, dat) {\n        if (err)\n            w.terminate(), strm.ondata.call(strm, err);\n        else {\n            if (dat[1])\n                w.terminate();\n            strm.ondata.call(strm, err, dat[0], dat[1]);\n        }\n    });\n    w.postMessage(opts);\n    strm.push = function (d, f) {\n        if (t)\n            throw 'stream finished';\n        if (!strm.ondata)\n            throw 'no stream handler';\n        w.postMessage([d, t = f], [d.buffer]);\n    };\n    strm.terminate = function () { w.terminate(); };\n};\n// read 2 bytes\nvar b2 = function (d, b) { return d[b] | (d[b + 1] << 8); };\n// read 4 bytes\nvar b4 = function (d, b) { return (d[b] | (d[b + 1] << 8) | (d[b + 2] << 16)) + (d[b + 3] << 23) * 2; };\n// write bytes\nvar wbytes = function (d, b, v) {\n    for (; v; ++b)\n        d[b] = v, v >>>= 8;\n};\n// gzip header\nvar gzh = function (c, o) {\n    var fn = o.filename;\n    c[0] = 31, c[1] = 139, c[2] = 8, c[8] = o.level < 2 ? 4 : o.level == 9 ? 2 : 0, c[9] = 3; // assume Unix\n    if (o.mtime != 0)\n        wbytes(c, 4, Math.floor(new Date(o.mtime || Date.now()) / 1000));\n    if (fn) {\n        c[3] = 8;\n        for (var i = 0; i <= fn.length; ++i)\n            c[i + 10] = fn.charCodeAt(i);\n    }\n};\n// gzip footer: -8 to -4 = CRC, -4 to -0 is length\n// gzip start\nvar gzs = function (d) {\n    if (d[0] != 31 || d[1] != 139 || d[2] != 8)\n        throw 'invalid gzip data';\n    var flg = d[3];\n    var st = 10;\n    if (flg & 4)\n        st += d[10] | (d[11] << 8) + 2;\n    for (var zs = (flg >> 3 & 1) + (flg >> 4 & 1); zs > 0; zs -= !d[st++])\n        ;\n    return st + (flg & 2);\n};\n// gzip length\nvar gzl = function (d) {\n    var l = d.length;\n    return (d[l - 4] | d[l - 3] << 8 | d[l - 2] << 16) + (2 * (d[l - 1] << 23));\n};\n// gzip header length\nvar gzhl = function (o) { return 10 + ((o.filename && (o.filename.length + 1)) || 0); };\n// zlib header\nvar zlh = function (c, o) {\n    var lv = o.level, fl = lv == 0 ? 0 : lv < 6 ? 1 : lv == 9 ? 3 : 2;\n    c[0] = 120, c[1] = (fl << 6) | (fl ? (32 - 2 * fl) : 1);\n};\n// zlib valid\nvar zlv = function (d) {\n    if ((d[0] & 15) != 8 || (d[0] >>> 4) > 7 || ((d[0] << 8 | d[1]) % 31))\n        throw 'invalid zlib data';\n    if (d[1] & 32)\n        throw 'invalid zlib data: preset dictionaries not supported';\n};\nfunction AsyncCmpStrm(opts, cb) {\n    if (!cb && typeof opts == 'function')\n        cb = opts, opts = {};\n    this.ondata = cb;\n    return opts;\n}\n// zlib footer: -4 to -0 is Adler32\n/**\n * Streaming DEFLATE compression\n */\nvar Deflate = /*#__PURE__*/ (function () {\n    function Deflate(opts, cb) {\n        if (!cb && typeof opts == 'function')\n            cb = opts, opts = {};\n        this.ondata = cb;\n        this.o = opts || {};\n    }\n    Deflate.prototype.p = function (c, f) {\n        this.ondata(dopt(c, this.o, 0, 0, !f), f);\n    };\n    /**\n     * Pushes a chunk to be deflated\n     * @param chunk The chunk to push\n     * @param final Whether this is the last chunk\n     */\n    Deflate.prototype.push = function (chunk, final) {\n        if (this.d)\n            throw 'stream finished';\n        if (!this.ondata)\n            throw 'no stream handler';\n        this.d = final;\n        this.p(chunk, final || false);\n    };\n    return Deflate;\n}());\nexport { Deflate };\n/**\n * Asynchronous streaming DEFLATE compression\n */\nvar AsyncDeflate = /*#__PURE__*/ (function () {\n    function AsyncDeflate(opts, cb) {\n        astrmify([\n            bDflt,\n            function () { return [astrm, Deflate]; }\n        ], this, AsyncCmpStrm.call(this, opts, cb), function (ev) {\n            var strm = new Deflate(ev.data);\n            onmessage = astrm(strm);\n        }, 6);\n    }\n    return AsyncDeflate;\n}());\nexport { AsyncDeflate };\nexport function deflate(data, opts, cb) {\n    if (!cb)\n        cb = opts, opts = {};\n    if (typeof cb != 'function')\n        throw 'no callback';\n    return cbify(data, opts, [\n        bDflt,\n    ], function (ev) { return pbf(deflateSync(ev.data[0], ev.data[1])); }, 0, cb);\n}\n/**\n * Compresses data with DEFLATE without any wrapper\n * @param data The data to compress\n * @param opts The compression options\n * @returns The deflated version of the data\n */\nexport function deflateSync(data, opts) {\n    if (opts === void 0) { opts = {}; }\n    return dopt(data, opts, 0, 0);\n}\n/**\n * Streaming DEFLATE decompression\n */\nvar Inflate = /*#__PURE__*/ (function () {\n    /**\n     * Creates an inflation stream\n     * @param cb The callback to call whenever data is inflated\n     */\n    function Inflate(cb) {\n        this.s = {};\n        this.p = new u8(0);\n        this.ondata = cb;\n    }\n    Inflate.prototype.e = function (c) {\n        if (this.d)\n            throw 'stream finished';\n        if (!this.ondata)\n            throw 'no stream handler';\n        var l = this.p.length;\n        var n = new u8(l + c.length);\n        n.set(this.p), n.set(c, l), this.p = n;\n    };\n    Inflate.prototype.c = function (final) {\n        this.d = this.s.i = final || false;\n        var bts = this.s.b;\n        var dt = inflt(this.p, this.o, this.s);\n        this.ondata(slc(dt, bts, this.s.b), this.d);\n        this.o = slc(dt, this.s.b - 32768), this.s.b = this.o.length;\n        this.p = slc(this.p, (this.s.p / 8) >> 0), this.s.p &= 7;\n    };\n    /**\n     * Pushes a chunk to be inflated\n     * @param chunk The chunk to push\n     * @param final Whether this is the final chunk\n     */\n    Inflate.prototype.push = function (chunk, final) {\n        this.e(chunk), this.c(final);\n    };\n    return Inflate;\n}());\nexport { Inflate };\n/**\n * Asynchronous streaming DEFLATE decompression\n */\nvar AsyncInflate = /*#__PURE__*/ (function () {\n    /**\n     * Creates an asynchronous inflation stream\n     * @param cb The callback to call whenever data is deflated\n     */\n    function AsyncInflate(cb) {\n        this.ondata = cb;\n        astrmify([\n            bInflt,\n            function () { return [astrm, Inflate]; }\n        ], this, 0, function () {\n            var strm = new Inflate();\n            onmessage = astrm(strm);\n        }, 7);\n    }\n    return AsyncInflate;\n}());\nexport { AsyncInflate };\nexport function inflate(data, opts, cb) {\n    if (!cb)\n        cb = opts, opts = {};\n    if (typeof cb != 'function')\n        throw 'no callback';\n    return cbify(data, opts, [\n        bInflt\n    ], function (ev) { return pbf(inflateSync(ev.data[0], gu8(ev.data[1]))); }, 1, cb);\n}\n/**\n * Expands DEFLATE data with no wrapper\n * @param data The data to decompress\n * @param out Where to write the data. Saves memory if you know the decompressed size and provide an output buffer of that length.\n * @returns The decompressed version of the data\n */\nexport function inflateSync(data, out) {\n    return inflt(data, out);\n}\n// before you yell at me for not just using extends, my reason is that TS inheritance is hard to workerize.\n/**\n * Streaming GZIP compression\n */\nvar Gzip = /*#__PURE__*/ (function () {\n    function Gzip(opts, cb) {\n        this.c = crc();\n        this.l = 0;\n        this.v = 1;\n        Deflate.call(this, opts, cb);\n    }\n    /**\n     * Pushes a chunk to be GZIPped\n     * @param chunk The chunk to push\n     * @param final Whether this is the last chunk\n     */\n    Gzip.prototype.push = function (chunk, final) {\n        Deflate.prototype.push.call(this, chunk, final);\n    };\n    Gzip.prototype.p = function (c, f) {\n        this.c.p(c);\n        this.l += c.length;\n        var raw = dopt(c, this.o, this.v && gzhl(this.o), f && 8, !f);\n        if (this.v)\n            gzh(raw, this.o), this.v = 0;\n        if (f)\n            wbytes(raw, raw.length - 8, this.c.d()), wbytes(raw, raw.length - 4, this.l);\n        this.ondata(raw, f);\n    };\n    return Gzip;\n}());\nexport { Gzip };\n/**\n * Asynchronous streaming GZIP compression\n */\nvar AsyncGzip = /*#__PURE__*/ (function () {\n    function AsyncGzip(opts, cb) {\n        astrmify([\n            bDflt,\n            gze,\n            function () { return [astrm, Deflate, Gzip]; }\n        ], this, AsyncCmpStrm.call(this, opts, cb), function (ev) {\n            var strm = new Gzip(ev.data);\n            onmessage = astrm(strm);\n        }, 8);\n    }\n    return AsyncGzip;\n}());\nexport { AsyncGzip };\nexport function gzip(data, opts, cb) {\n    if (!cb)\n        cb = opts, opts = {};\n    if (typeof cb != 'function')\n        throw 'no callback';\n    return cbify(data, opts, [\n        bDflt,\n        gze,\n        function () { return [gzipSync]; }\n    ], function (ev) { return pbf(gzipSync(ev.data[0], ev.data[1])); }, 2, cb);\n}\n/**\n * Compresses data with GZIP\n * @param data The data to compress\n * @param opts The compression options\n * @returns The gzipped version of the data\n */\nexport function gzipSync(data, opts) {\n    if (opts === void 0) { opts = {}; }\n    var c = crc(), l = data.length;\n    c.p(data);\n    var d = dopt(data, opts, gzhl(opts), 8), s = d.length;\n    return gzh(d, opts), wbytes(d, s - 8, c.d()), wbytes(d, s - 4, l), d;\n}\n/**\n * Streaming GZIP decompression\n */\nvar Gunzip = /*#__PURE__*/ (function () {\n    /**\n     * Creates a GUNZIP stream\n     * @param cb The callback to call whenever data is inflated\n     */\n    function Gunzip(cb) {\n        this.v = 1;\n        Inflate.call(this, cb);\n    }\n    /**\n     * Pushes a chunk to be GUNZIPped\n     * @param chunk The chunk to push\n     * @param final Whether this is the last chunk\n     */\n    Gunzip.prototype.push = function (chunk, final) {\n        Inflate.prototype.e.call(this, chunk);\n        if (this.v) {\n            var s = gzs(this.p);\n            if (s >= this.p.length && !final)\n                return;\n            this.p = this.p.subarray(s), this.v = 0;\n        }\n        if (final) {\n            if (this.p.length < 8)\n                throw 'invalid gzip stream';\n            this.p = this.p.subarray(0, -8);\n        }\n        // necessary to prevent TS from using the closure value\n        // This allows for workerization to function correctly\n        Inflate.prototype.c.call(this, final);\n    };\n    return Gunzip;\n}());\nexport { Gunzip };\n/**\n * Asynchronous streaming GZIP decompression\n */\nvar AsyncGunzip = /*#__PURE__*/ (function () {\n    /**\n     * Creates an asynchronous GUNZIP stream\n     * @param cb The callback to call whenever data is deflated\n     */\n    function AsyncGunzip(cb) {\n        this.ondata = cb;\n        astrmify([\n            bInflt,\n            guze,\n            function () { return [astrm, Inflate, Gunzip]; }\n        ], this, 0, function () {\n            var strm = new Gunzip();\n            onmessage = astrm(strm);\n        }, 9);\n    }\n    return AsyncGunzip;\n}());\nexport { AsyncGunzip };\nexport function gunzip(data, opts, cb) {\n    if (!cb)\n        cb = opts, opts = {};\n    if (typeof cb != 'function')\n        throw 'no callback';\n    return cbify(data, opts, [\n        bInflt,\n        guze,\n        function () { return [gunzipSync]; }\n    ], function (ev) { return pbf(gunzipSync(ev.data[0])); }, 3, cb);\n}\n/**\n * Expands GZIP data\n * @param data The data to decompress\n * @param out Where to write the data. GZIP already encodes the output size, so providing this doesn't save memory.\n * @returns The decompressed version of the data\n */\nexport function gunzipSync(data, out) {\n    return inflt(data.subarray(gzs(data), -8), out || new u8(gzl(data)));\n}\n/**\n * Streaming Zlib compression\n */\nvar Zlib = /*#__PURE__*/ (function () {\n    function Zlib(opts, cb) {\n        this.c = adler();\n        this.v = 1;\n        Deflate.call(this, opts, cb);\n    }\n    /**\n     * Pushes a chunk to be zlibbed\n     * @param chunk The chunk to push\n     * @param final Whether this is the last chunk\n     */\n    Zlib.prototype.push = function (chunk, final) {\n        Deflate.prototype.push.call(this, chunk, final);\n    };\n    Zlib.prototype.p = function (c, f) {\n        this.c.p(c);\n        var raw = dopt(c, this.o, this.v && 2, f && 4, !f);\n        if (this.v)\n            zlh(raw, this.o), this.v = 0;\n        if (f)\n            wbytes(raw, raw.length - 4, this.c.d());\n        this.ondata(raw, f);\n    };\n    return Zlib;\n}());\nexport { Zlib };\n/**\n * Asynchronous streaming Zlib compression\n */\nvar AsyncZlib = /*#__PURE__*/ (function () {\n    function AsyncZlib(opts, cb) {\n        astrmify([\n            bDflt,\n            zle,\n            function () { return [astrm, Deflate, Zlib]; }\n        ], this, AsyncCmpStrm.call(this, opts, cb), function (ev) {\n            var strm = new Zlib(ev.data);\n            onmessage = astrm(strm);\n        }, 10);\n    }\n    return AsyncZlib;\n}());\nexport { AsyncZlib };\nexport function zlib(data, opts, cb) {\n    if (!cb)\n        cb = opts, opts = {};\n    if (typeof cb != 'function')\n        throw 'no callback';\n    return cbify(data, opts, [\n        bDflt,\n        zle,\n        function () { return [zlibSync]; }\n    ], function (ev) { return pbf(zlibSync(ev.data[0], ev.data[1])); }, 4, cb);\n}\n/**\n * Compress data with Zlib\n * @param data The data to compress\n * @param opts The compression options\n * @returns The zlib-compressed version of the data\n */\nexport function zlibSync(data, opts) {\n    if (opts === void 0) { opts = {}; }\n    var a = adler();\n    a.p(data);\n    var d = dopt(data, opts, 2, 4);\n    return zlh(d, opts), wbytes(d, d.length - 4, a.d()), d;\n}\n/**\n * Streaming Zlib decompression\n */\nvar Unzlib = /*#__PURE__*/ (function () {\n    /**\n     * Creates a Zlib decompression stream\n     * @param cb The callback to call whenever data is inflated\n     */\n    function Unzlib(cb) {\n        this.v = 1;\n        Inflate.call(this, cb);\n    }\n    /**\n     * Pushes a chunk to be unzlibbed\n     * @param chunk The chunk to push\n     * @param final Whether this is the last chunk\n     */\n    Unzlib.prototype.push = function (chunk, final) {\n        Inflate.prototype.e.call(this, chunk);\n        if (this.v) {\n            if (this.p.length < 2 && !final)\n                return;\n            this.p = this.p.subarray(2), this.v = 0;\n        }\n        if (final) {\n            if (this.p.length < 4)\n                throw 'invalid zlib stream';\n            this.p = this.p.subarray(0, -4);\n        }\n        // necessary to prevent TS from using the closure value\n        // This allows for workerization to function correctly\n        Inflate.prototype.c.call(this, final);\n    };\n    return Unzlib;\n}());\nexport { Unzlib };\n/**\n * Asynchronous streaming Zlib decompression\n */\nvar AsyncUnzlib = /*#__PURE__*/ (function () {\n    /**\n     * Creates an asynchronous Zlib decompression stream\n     * @param cb The callback to call whenever data is deflated\n     */\n    function AsyncUnzlib(cb) {\n        this.ondata = cb;\n        astrmify([\n            bInflt,\n            zule,\n            function () { return [astrm, Inflate, Unzlib]; }\n        ], this, 0, function () {\n            var strm = new Unzlib();\n            onmessage = astrm(strm);\n        }, 11);\n    }\n    return AsyncUnzlib;\n}());\nexport { AsyncUnzlib };\nexport function unzlib(data, opts, cb) {\n    if (!cb)\n        cb = opts, opts = {};\n    if (typeof cb != 'function')\n        throw 'no callback';\n    return cbify(data, opts, [\n        bInflt,\n        zule,\n        function () { return [unzlibSync]; }\n    ], function (ev) { return pbf(unzlibSync(ev.data[0], gu8(ev.data[1]))); }, 5, cb);\n}\n/**\n * Expands Zlib data\n * @param data The data to decompress\n * @param out Where to write the data. Saves memory if you know the decompressed size and provide an output buffer of that length.\n * @returns The decompressed version of the data\n */\nexport function unzlibSync(data, out) {\n    return inflt((zlv(data), data.subarray(2, -4)), out);\n}\n// Default algorithm for compression (used because having a known output size allows faster decompression)\nexport { gzip as compress, AsyncGzip as AsyncCompress };\n// Default algorithm for compression (used because having a known output size allows faster decompression)\nexport { gzipSync as compressSync, Gzip as Compress };\n/**\n * Streaming GZIP, Zlib, or raw DEFLATE decompression\n */\nvar Decompress = /*#__PURE__*/ (function () {\n    /**\n     * Creates a decompression stream\n     * @param cb The callback to call whenever data is decompressed\n     */\n    function Decompress(cb) {\n        this.G = Gunzip;\n        this.I = Inflate;\n        this.Z = Unzlib;\n        this.ondata = cb;\n    }\n    /**\n     * Pushes a chunk to be decompressed\n     * @param chunk The chunk to push\n     * @param final Whether this is the last chunk\n     */\n    Decompress.prototype.push = function (chunk, final) {\n        if (!this.ondata)\n            throw 'no stream handler';\n        if (!this.s) {\n            if (this.p && this.p.length) {\n                var n = new u8(this.p.length + chunk.length);\n                n.set(this.p), n.set(chunk, this.p.length);\n            }\n            else\n                this.p = chunk;\n            if (this.p.length > 2) {\n                var _this_1 = this;\n                var cb = function () { _this_1.ondata.apply(_this_1, arguments); };\n                this.s = (this.p[0] == 31 && this.p[1] == 139 && this.p[2] == 8)\n                    ? new this.G(cb)\n                    : ((this.p[0] & 15) != 8 || (this.p[0] >> 4) > 7 || ((this.p[0] << 8 | this.p[1]) % 31))\n                        ? new this.I(cb)\n                        : new this.Z(cb);\n                this.s.push(this.p, final);\n                this.p = null;\n            }\n        }\n        else\n            this.s.push(chunk, final);\n    };\n    return Decompress;\n}());\nexport { Decompress };\n/**\n * Asynchronous streaming GZIP, Zlib, or raw DEFLATE decompression\n */\nvar AsyncDecompress = /*#__PURE__*/ (function () {\n    /**\n   * Creates an asynchronous decompression stream\n   * @param cb The callback to call whenever data is decompressed\n   */\n    function AsyncDecompress(cb) {\n        this.G = AsyncGunzip;\n        this.I = AsyncInflate;\n        this.Z = AsyncUnzlib;\n        this.ondata = cb;\n    }\n    /**\n     * Pushes a chunk to be decompressed\n     * @param chunk The chunk to push\n     * @param final Whether this is the last chunk\n     */\n    AsyncDecompress.prototype.push = function (chunk, final) {\n        Decompress.prototype.push.call(this, chunk, final);\n    };\n    return AsyncDecompress;\n}());\nexport { AsyncDecompress };\nexport function decompress(data, opts, cb) {\n    if (!cb)\n        cb = opts, opts = {};\n    if (typeof cb != 'function')\n        throw 'no callback';\n    return (data[0] == 31 && data[1] == 139 && data[2] == 8)\n        ? gunzip(data, opts, cb)\n        : ((data[0] & 15) != 8 || (data[0] >> 4) > 7 || ((data[0] << 8 | data[1]) % 31))\n            ? inflate(data, opts, cb)\n            : unzlib(data, opts, cb);\n}\n/**\n * Expands compressed GZIP, Zlib, or raw DEFLATE data, automatically detecting the format\n * @param data The data to decompress\n * @param out Where to write the data. Saves memory if you know the decompressed size and provide an output buffer of that length.\n * @returns The decompressed version of the data\n */\nexport function decompressSync(data, out) {\n    return (data[0] == 31 && data[1] == 139 && data[2] == 8)\n        ? gunzipSync(data, out)\n        : ((data[0] & 15) != 8 || (data[0] >> 4) > 7 || ((data[0] << 8 | data[1]) % 31))\n            ? inflateSync(data, out)\n            : unzlibSync(data, out);\n}\n// flatten a directory structure\nvar fltn = function (d, p, t, o) {\n    for (var k in d) {\n        var val = d[k], n = p + k;\n        if (val instanceof u8)\n            t[n] = [val, o];\n        else if (Array.isArray(val))\n            t[n] = [val[0], mrg(o, val[1])];\n        else\n            fltn(val, n + '/', t, o);\n    }\n};\n/**\n * Converts a string into a Uint8Array for use with compression/decompression methods\n * @param str The string to encode\n * @param latin1 Whether or not to interpret the data as Latin-1. This should\n *               not need to be true unless decoding a binary string.\n * @returns The string encoded in UTF-8/Latin-1 binary\n */\nexport function strToU8(str, latin1) {\n    var l = str.length;\n    if (!latin1 && typeof TextEncoder != 'undefined')\n        return new TextEncoder().encode(str);\n    var ar = new u8(str.length + (str.length >>> 1));\n    var ai = 0;\n    var w = function (v) { ar[ai++] = v; };\n    for (var i = 0; i < l; ++i) {\n        if (ai + 5 > ar.length) {\n            var n = new u8(ai + 8 + ((l - i) << 1));\n            n.set(ar);\n            ar = n;\n        }\n        var c = str.charCodeAt(i);\n        if (c < 128 || latin1)\n            w(c);\n        else if (c < 2048)\n            w(192 | (c >>> 6)), w(128 | (c & 63));\n        else if (c > 55295 && c < 57344)\n            c = 65536 + (c & 1023 << 10) | (str.charCodeAt(++i) & 1023),\n                w(240 | (c >>> 18)), w(128 | ((c >>> 12) & 63)), w(128 | ((c >>> 6) & 63)), w(128 | (c & 63));\n        else\n            w(224 | (c >>> 12)), w(128 | ((c >>> 6) & 63)), w(128 | (c & 63));\n    }\n    return slc(ar, 0, ai);\n}\n/**\n * Converts a Uint8Array to a string\n * @param dat The data to decode to string\n * @param latin1 Whether or not to interpret the data as Latin-1. This should\n *               not need to be true unless encoding to binary string.\n * @returns The original UTF-8/Latin-1 string\n */\nexport function strFromU8(dat, latin1) {\n    var r = '';\n    if (!latin1 && typeof TextDecoder != 'undefined')\n        return new TextDecoder().decode(dat);\n    for (var i = 0; i < dat.length;) {\n        var c = dat[i++];\n        if (c < 128 || latin1)\n            r += String.fromCharCode(c);\n        else if (c < 224)\n            r += String.fromCharCode((c & 31) << 6 | (dat[i++] & 63));\n        else if (c < 240)\n            r += String.fromCharCode((c & 15) << 12 | (dat[i++] & 63) << 6 | (dat[i++] & 63));\n        else\n            c = ((c & 15) << 18 | (dat[i++] & 63) << 12 | (dat[i++] & 63) << 6 | (dat[i++] & 63)) - 65536,\n                r += String.fromCharCode(55296 | (c >> 10), 56320 | (c & 1023));\n    }\n    return r;\n}\n;\n// skip local zip header\nvar slzh = function (d, b) { return b + 30 + b2(d, b + 26) + b2(d, b + 28); };\n// read zip header\nvar zh = function (d, b, z) {\n    var fnl = b2(d, b + 28), fn = strFromU8(d.subarray(b + 46, b + 46 + fnl), !(b2(d, b + 8) & 2048)), es = b + 46 + fnl;\n    var _a = z ? z64e(d, es) : [b4(d, b + 20), b4(d, b + 24), b4(d, b + 42)], sc = _a[0], su = _a[1], off = _a[2];\n    return [b2(d, b + 10), sc, su, fn, es + b2(d, b + 30) + b2(d, b + 32), off];\n};\n// read zip64 extra field\nvar z64e = function (d, b) {\n    for (; b2(d, b) != 1; b += 4 + b2(d, b + 2))\n        ;\n    return [b4(d, b + 12), b4(d, b + 4), b4(d, b + 20)];\n};\n// write zip header\nvar wzh = function (d, b, c, cmp, su, fn, u, o, ce, t) {\n    var fl = fn.length, l = cmp.length;\n    wbytes(d, b, ce != null ? 0x2014B50 : 0x4034B50), b += 4;\n    if (ce != null)\n        d[b] = 20, b += 2;\n    d[b] = 20, b += 2; // spec compliance? what's that?\n    d[b++] = (t == 8 && (o.level == 1 ? 6 : o.level < 6 ? 4 : o.level == 9 ? 2 : 0)), d[b++] = u && 8;\n    d[b] = t, b += 2;\n    var dt = new Date(o.mtime || Date.now()), y = dt.getFullYear() - 1980;\n    if (y < 0 || y > 119)\n        throw 'date not in range 1980-2099';\n    wbytes(d, b, ((y << 24) * 2) | ((dt.getMonth() + 1) << 21) | (dt.getDate() << 16) | (dt.getHours() << 11) | (dt.getMinutes() << 5) | (dt.getSeconds() >>> 1));\n    b += 4;\n    wbytes(d, b, c);\n    wbytes(d, b + 4, l);\n    wbytes(d, b + 8, su);\n    wbytes(d, b + 12, fl), b += 16; // skip extra field, comment\n    if (ce != null)\n        wbytes(d, b += 10, ce), b += 4;\n    d.set(fn, b);\n    b += fl;\n    if (ce == null)\n        d.set(cmp, b);\n};\n// write zip footer (end of central directory)\nvar wzf = function (o, b, c, d, e) {\n    wbytes(o, b, 0x6054B50); // skip disk\n    wbytes(o, b + 8, c);\n    wbytes(o, b + 10, c);\n    wbytes(o, b + 12, d);\n    wbytes(o, b + 16, e);\n};\nexport function zip(data, opts, cb) {\n    if (!cb)\n        cb = opts, opts = {};\n    if (typeof cb != 'function')\n        throw 'no callback';\n    var r = {};\n    fltn(data, '', r, opts);\n    var k = Object.keys(r);\n    var lft = k.length, o = 0, tot = 0;\n    var slft = lft, files = new Array(lft);\n    var term = [];\n    var tAll = function () {\n        for (var i = 0; i < term.length; ++i)\n            term[i]();\n    };\n    var cbf = function () {\n        var out = new u8(tot + 22), oe = o, cdl = tot - o;\n        tot = 0;\n        for (var i = 0; i < slft; ++i) {\n            var f = files[i];\n            try {\n                wzh(out, tot, f.c, f.d, f.m, f.n, f.u, f.p, null, f.t);\n                wzh(out, o, f.c, f.d, f.m, f.n, f.u, f.p, tot, f.t), o += 46 + f.n.length, tot += 30 + f.n.length + f.d.length;\n            }\n            catch (e) {\n                return cb(e, null);\n            }\n        }\n        wzf(out, o, files.length, cdl, oe);\n        cb(null, out);\n    };\n    if (!lft)\n        cbf();\n    var _loop_1 = function (i) {\n        var fn = k[i];\n        var _a = r[fn], file = _a[0], p = _a[1];\n        var c = crc(), m = file.length;\n        c.p(file);\n        var n = strToU8(fn), s = n.length;\n        var t = p.level == 0 ? 0 : 8;\n        var cbl = function (e, d) {\n            if (e) {\n                tAll();\n                cb(e, null);\n            }\n            else {\n                var l = d.length;\n                files[i] = {\n                    t: t,\n                    d: d,\n                    m: m,\n                    c: c.d(),\n                    u: fn.length != l,\n                    n: n,\n                    p: p\n                };\n                o += 30 + s + l;\n                tot += 76 + 2 * s + l;\n                if (!--lft)\n                    cbf();\n            }\n        };\n        if (n.length > 65535)\n            cbl('filename too long', null);\n        if (!t)\n            cbl(null, file);\n        else if (m < 160000) {\n            try {\n                cbl(null, deflateSync(file, p));\n            }\n            catch (e) {\n                cbl(e, null);\n            }\n        }\n        else\n            term.push(deflate(file, p, cbl));\n    };\n    // Cannot use lft because it can decrease\n    for (var i = 0; i < slft; ++i) {\n        _loop_1(i);\n    }\n    return tAll;\n}\n/**\n * Synchronously creates a ZIP file. Prefer using `zip` for better performance\n * with more than one file.\n * @param data The directory structure for the ZIP archive\n * @param opts The main options, merged with per-file options\n * @returns The generated ZIP archive\n */\nexport function zipSync(data, opts) {\n    if (opts === void 0) { opts = {}; }\n    var r = {};\n    var files = [];\n    fltn(data, '', r, opts);\n    var o = 0;\n    var tot = 0;\n    for (var fn in r) {\n        var _a = r[fn], file = _a[0], p = _a[1];\n        var t = p.level == 0 ? 0 : 8;\n        var n = strToU8(fn), s = n.length;\n        if (n.length > 65535)\n            throw 'filename too long';\n        var d = t ? deflateSync(file, p) : file, l = d.length;\n        var c = crc();\n        c.p(file);\n        files.push({\n            t: t,\n            d: d,\n            m: file.length,\n            c: c.d(),\n            u: fn.length != s,\n            n: n,\n            o: o,\n            p: p\n        });\n        o += 30 + s + l;\n        tot += 76 + 2 * s + l;\n    }\n    var out = new u8(tot + 22), oe = o, cdl = tot - o;\n    for (var i = 0; i < files.length; ++i) {\n        var f = files[i];\n        wzh(out, f.o, f.c, f.d, f.m, f.n, f.u, f.p, null, f.t);\n        wzh(out, o, f.c, f.d, f.m, f.n, f.u, f.p, f.o, f.t), o += 46 + f.n.length;\n    }\n    wzf(out, o, files.length, cdl, oe);\n    return out;\n}\n/**\n * Asynchronously decompresses a ZIP archive\n * @param data The raw compressed ZIP file\n * @param cb The callback to call with the decompressed files\n * @returns A function that can be used to immediately terminate the unzipping\n */\nexport function unzip(data, cb) {\n    if (typeof cb != 'function')\n        throw 'no callback';\n    var term = [];\n    var tAll = function () {\n        for (var i = 0; i < term.length; ++i)\n            term[i]();\n    };\n    var files = {};\n    var e = data.length - 22;\n    for (; b4(data, e) != 0x6054B50; --e) {\n        if (!e || data.length - e > 65558) {\n            cb('invalid zip file', null);\n            return;\n        }\n    }\n    ;\n    var lft = b2(data, e + 8);\n    if (!lft)\n        cb(null, {});\n    var c = lft;\n    var o = b4(data, e + 16);\n    var z = o == 4294967295;\n    if (z) {\n        e = b4(data, e - 12);\n        if (b4(data, e) != 0x6064B50)\n            throw 'invalid zip file';\n        c = lft = b4(data, e + 32);\n        o = b4(data, e + 48);\n    }\n    var _loop_2 = function (i) {\n        var _a = zh(data, o, z), c_1 = _a[0], sc = _a[1], su = _a[2], fn = _a[3], no = _a[4], off = _a[5], b = slzh(data, off);\n        o = no;\n        var cbl = function (e, d) {\n            if (e) {\n                tAll();\n                cb(e, null);\n            }\n            else {\n                files[fn] = d;\n                if (!--lft)\n                    cb(null, files);\n            }\n        };\n        if (!c_1)\n            cbl(null, slc(data, b, b + sc));\n        else if (c_1 == 8) {\n            var infl = data.subarray(b, b + sc);\n            if (sc < 320000) {\n                try {\n                    cbl(null, inflateSync(infl, new u8(su)));\n                }\n                catch (e) {\n                    cbl(e, null);\n                }\n            }\n            else\n                term.push(inflate(infl, { size: su }, cbl));\n        }\n        else\n            cbl('unknown compression type ' + c_1, null);\n    };\n    for (var i = 0; i < c; ++i) {\n        _loop_2(i);\n    }\n    return tAll;\n}\n/**\n * Synchronously decompresses a ZIP archive. Prefer using `unzip` for better\n * performance with more than one file.\n * @param data The raw compressed ZIP file\n * @returns The decompressed files\n */\nexport function unzipSync(data) {\n    var files = {};\n    var e = data.length - 22;\n    for (; b4(data, e) != 0x6054B50; --e) {\n        if (!e || data.length - e > 65558)\n            throw 'invalid zip file';\n    }\n    ;\n    var c = b2(data, e + 8);\n    if (!c)\n        return {};\n    var o = b4(data, e + 16);\n    var z = o == 4294967295;\n    if (z) {\n        e = b4(data, e - 12);\n        if (b4(data, e) != 0x6064B50)\n            throw 'invalid zip file';\n        c = b4(data, e + 32);\n        o = b4(data, e + 48);\n    }\n    for (var i = 0; i < c; ++i) {\n        var _a = zh(data, o, z), c_2 = _a[0], sc = _a[1], su = _a[2], fn = _a[3], no = _a[4], off = _a[5], b = slzh(data, off);\n        o = no;\n        if (!c_2)\n            files[fn] = slc(data, b, b + sc);\n        else if (c_2 == 8)\n            files[fn] = inflateSync(data.subarray(b, b + sc), new u8(su));\n        else\n            throw 'unknown compression type ' + c_2;\n    }\n    return files;\n}\n","import { _base64Encode, each, find } from './utils'\nimport Config from './config'\nimport { Compression, RequestOptions, RequestResponse } from './types'\nimport { formDataToQuery } from './utils/request-utils'\n\nimport { logger } from './utils/logger'\nimport { fetch, XMLHttpRequest, AbortController, navigator } from './utils/globals'\nimport { gzipSync, strToU8 } from 'fflate'\n\n// eslint-disable-next-line compat/compat\nexport const SUPPORTS_REQUEST = !!XMLHttpRequest || !!fetch\n\nconst CONTENT_TYPE_PLAIN = 'text/plain'\nconst CONTENT_TYPE_JSON = 'application/json'\nconst CONTENT_TYPE_FORM = 'application/x-www-form-urlencoded'\n\ntype EncodedBody = {\n    contentType: string\n    body: string | BlobPart\n}\n\nexport const extendURLParams = (url: string, params: Record<string, any>): string => {\n    const [baseUrl, search] = url.split('?')\n    const newParams = { ...params }\n\n    search?.split('&').forEach((pair) => {\n        const [key] = pair.split('=')\n        delete newParams[key]\n    })\n\n    let newSearch = formDataToQuery(newParams)\n    newSearch = newSearch ? (search ? search + '&' : '') + newSearch : search\n\n    return `${baseUrl}?${newSearch}`\n}\n\nconst encodeToDataString = (data: string | Record<string, any>): string => {\n    return 'data=' + encodeURIComponent(typeof data === 'string' ? data : JSON.stringify(data))\n}\n\nconst encodePostData = ({ data, compression }: RequestOptions): EncodedBody | undefined => {\n    if (!data) {\n        return\n    }\n\n    if (compression === Compression.GZipJS) {\n        const gzipData = gzipSync(strToU8(JSON.stringify(data)), { mtime: 0 })\n        return {\n            contentType: CONTENT_TYPE_PLAIN,\n            body: new Blob([gzipData], { type: CONTENT_TYPE_PLAIN }),\n        }\n    }\n\n    if (compression === Compression.Base64) {\n        const b64data = _base64Encode(JSON.stringify(data))\n\n        return {\n            contentType: CONTENT_TYPE_FORM,\n            body: encodeToDataString(b64data),\n        }\n    }\n\n    return {\n        contentType: CONTENT_TYPE_JSON,\n        body: JSON.stringify(data),\n    }\n}\n\nconst xhr = (options: RequestOptions) => {\n    const req = new XMLHttpRequest!()\n    req.open(options.method || 'GET', options.url, true)\n    const { contentType, body } = encodePostData(options) ?? {}\n\n    each(options.headers, function (headerValue, headerName) {\n        req.setRequestHeader(headerName, headerValue)\n    })\n\n    if (contentType) {\n        req.setRequestHeader('Content-Type', contentType)\n    }\n\n    if (options.timeout) {\n        req.timeout = options.timeout\n    }\n    // send the ph_optout cookie\n    // withCredentials cannot be modified until after calling .open on Android and Mobile Safari\n    req.withCredentials = true\n    req.onreadystatechange = () => {\n        // XMLHttpRequest.DONE == 4, except in safari 4\n        if (req.readyState === 4) {\n            const response: RequestResponse = {\n                statusCode: req.status,\n                text: req.responseText,\n            }\n            if (req.status === 200) {\n                try {\n                    response.json = JSON.parse(req.responseText)\n                } catch (e) {\n                    // logger.error(e)\n                }\n            }\n\n            options.callback?.(response)\n        }\n    }\n    req.send(body)\n}\n\nconst _fetch = (options: RequestOptions) => {\n    const { contentType, body } = encodePostData(options) ?? {}\n\n    // eslint-disable-next-line compat/compat\n    const headers = new Headers()\n    each(options.headers, function (headerValue, headerName) {\n        headers.append(headerName, headerValue)\n    })\n\n    if (contentType) {\n        headers.append('Content-Type', contentType)\n    }\n\n    const url = options.url\n    let aborter: { signal: any; timeout: ReturnType<typeof setTimeout> } | null = null\n\n    if (AbortController) {\n        const controller = new AbortController()\n        aborter = {\n            signal: controller.signal,\n            timeout: setTimeout(() => controller.abort(), options.timeout),\n        }\n    }\n\n    fetch!(url, {\n        method: options?.method || 'GET',\n        headers,\n        keepalive: options.method === 'POST',\n        body,\n        signal: aborter?.signal,\n    })\n        .then((response) => {\n            return response.text().then((responseText) => {\n                const res: RequestResponse = {\n                    statusCode: response.status,\n                    text: responseText,\n                }\n\n                if (response.status === 200) {\n                    try {\n                        res.json = JSON.parse(responseText)\n                    } catch (e) {\n                        logger.error(e)\n                    }\n                }\n\n                options.callback?.(res)\n            })\n        })\n        .catch((error) => {\n            logger.error(error)\n            options.callback?.({ statusCode: 0, text: error })\n        })\n        .finally(() => (aborter ? clearTimeout(aborter.timeout) : null))\n\n    return\n}\n\nconst _sendBeacon = (options: RequestOptions) => {\n    // beacon documentation https://w3c.github.io/beacon/\n    // beacons format the message and use the type property\n\n    const url = extendURLParams(options.url, {\n        beacon: '1',\n    })\n\n    try {\n        const { contentType, body } = encodePostData(options) ?? {}\n        // sendBeacon requires a blob so we convert it\n        const sendBeaconBody = typeof body === 'string' ? new Blob([body], { type: contentType }) : body\n        navigator!.sendBeacon!(url, sendBeaconBody)\n    } catch (e) {\n        // send beacon is a best-effort, fire-and-forget mechanism on page unload,\n        // we don't want to throw errors here\n    }\n}\n\nconst AVAILABLE_TRANSPORTS: { transport: RequestOptions['transport']; method: (options: RequestOptions) => void }[] = []\n\n// We add the transports in order of preference\n\nif (XMLHttpRequest) {\n    AVAILABLE_TRANSPORTS.push({\n        transport: 'XHR',\n        method: xhr,\n    })\n}\n\nif (fetch) {\n    AVAILABLE_TRANSPORTS.push({\n        transport: 'fetch',\n        method: _fetch,\n    })\n}\n\nif (navigator?.sendBeacon) {\n    AVAILABLE_TRANSPORTS.push({\n        transport: 'sendBeacon',\n        method: _sendBeacon,\n    })\n}\n\n// This is the entrypoint. It takes care of sanitizing the options and then calls the appropriate request method.\nexport const request = (_options: RequestOptions) => {\n    // Clone the options so we don't modify the original object\n    const options = { ..._options }\n    options.timeout = options.timeout || 60000\n\n    options.url = extendURLParams(options.url, {\n        _: new Date().getTime().toString(),\n        ver: Config.LIB_VERSION,\n        compression: options.compression,\n    })\n\n    const transport = options.transport ?? 'XHR'\n\n    const transportMethod =\n        find(AVAILABLE_TRANSPORTS, (t) => t.transport === transport)?.method ?? AVAILABLE_TRANSPORTS[0].method\n\n    if (!transportMethod) {\n        throw new Error('No available transport method')\n    }\n\n    transportMethod(options)\n}\n","import { PostHog } from '../posthog-core'\nimport { document } from '../utils/globals'\nimport { logger } from './logger'\n\n/**\n * The request router helps simplify the logic to determine which endpoints should be called for which things\n * The basic idea is that for a given region (US or EU), we have a set of endpoints that we should call depending\n * on the type of request (events, replays, decide, etc.) and handle overrides that may come from configs or the decide endpoint\n */\n\nexport enum RequestRouterRegion {\n    US = 'us',\n    EU = 'eu',\n    CUSTOM = 'custom',\n}\n\nexport type RequestRouterTarget = 'api' | 'ui' | 'assets'\n\nconst ingestionDomain = 'i.posthog.com'\n\nexport class RequestRouter {\n    instance: PostHog\n    private _regionCache: Record<string, RequestRouterRegion> = {}\n\n    constructor(instance: PostHog) {\n        this.instance = instance\n    }\n\n    get apiHost(): string {\n        return this.instance.config.api_host.trim().replace(/\\/$/, '')\n    }\n    get uiHost(): string | undefined {\n        const host = this.instance.config.ui_host?.replace(/\\/$/, '')\n\n        if (host === 'https://app.posthog.com') {\n            return 'https://us.posthog.com'\n        }\n        return host\n    }\n\n    get region(): RequestRouterRegion {\n        // We don't need to compute this every time so we cache the result\n        if (!this._regionCache[this.apiHost]) {\n            if (/https:\\/\\/(app|us|us-assets)(\\.i)?\\.posthog\\.com/i.test(this.apiHost)) {\n                this._regionCache[this.apiHost] = RequestRouterRegion.US\n            } else if (/https:\\/\\/(eu|eu-assets)(\\.i)?\\.posthog\\.com/i.test(this.apiHost)) {\n                this._regionCache[this.apiHost] = RequestRouterRegion.EU\n            } else {\n                this._regionCache[this.apiHost] = RequestRouterRegion.CUSTOM\n            }\n        }\n        return this._regionCache[this.apiHost]\n    }\n\n    endpointFor(target: RequestRouterTarget, path: string = ''): string {\n        if (path) {\n            path = path[0] === '/' ? path : `/${path}`\n        }\n\n        if (target === 'ui') {\n            return (this.uiHost || this.apiHost.replace(`.${ingestionDomain}`, '.posthog.com')) + path\n        }\n\n        if (this.region === RequestRouterRegion.CUSTOM) {\n            return this.apiHost + path\n        }\n\n        const suffix = ingestionDomain + path\n\n        switch (target) {\n            case 'assets':\n                return `https://${this.region}-assets.${suffix}`\n            case 'api':\n                return `https://${this.region}.${suffix}`\n        }\n    }\n\n    loadScript(scriptUrlToLoad: string, callback: (error?: string | Event, event?: Event) => void): void {\n        if (this.instance.config.disable_external_dependency_loading) {\n            logger.warn(`${scriptUrlToLoad} was requested but loading of external scripts is disabled.`)\n            return callback('Loading of external scripts is disabled')\n        }\n\n        const url = scriptUrlToLoad[0] === '/' ? this.endpointFor('assets', scriptUrlToLoad) : scriptUrlToLoad\n\n        const addScript = () => {\n            if (!document) {\n                return callback('document not found')\n            }\n            const scriptTag = document.createElement('script')\n            scriptTag.type = 'text/javascript'\n            scriptTag.src = url\n            scriptTag.onload = (event) => callback(undefined, event)\n            scriptTag.onerror = (error) => callback(error)\n\n            const scripts = document.querySelectorAll('body > script')\n            if (scripts.length > 0) {\n                scripts[0].parentNode?.insertBefore(scriptTag, scripts[0])\n            } else {\n                // In exceptional situations this call might load before the DOM is fully ready.\n                document.body.appendChild(scriptTag)\n            }\n        }\n\n        if (document?.body) {\n            addScript()\n        } else {\n            document?.addEventListener('DOMContentLoaded', addScript)\n        }\n    }\n}\n","import { RetriableRequestOptions } from './types'\n\nimport { isNumber, isUndefined } from './utils/type-utils'\nimport { logger } from './utils/logger'\nimport { window } from './utils/globals'\nimport { PostHog } from './posthog-core'\nimport { extendURLParams } from './request'\n\nconst thirtyMinutes = 30 * 60 * 1000\n\n/**\n * Generates a jitter-ed exponential backoff delay in milliseconds\n *\n * The base value is 6 seconds, which is doubled with each retry\n * up to the maximum of 30 minutes\n *\n * Each value then has +/- 50% jitter\n *\n * Giving a range of 6 seconds up to 45 minutes\n */\nexport function pickNextRetryDelay(retriesPerformedSoFar: number): number {\n    const rawBackoffTime = 3000 * 2 ** retriesPerformedSoFar\n    const minBackoff = rawBackoffTime / 2\n    const cappedBackoffTime = Math.min(thirtyMinutes, rawBackoffTime)\n    const jitterFraction = Math.random() - 0.5 // A random number between -0.5 and 0.5\n    const jitter = jitterFraction * (cappedBackoffTime - minBackoff)\n    return Math.ceil(cappedBackoffTime + jitter)\n}\n\ninterface RetryQueueElement {\n    retryAt: number\n    requestOptions: RetriableRequestOptions\n}\n\nexport class RetryQueue {\n    private isPolling: boolean = false // flag to continue to recursively poll or not\n    private poller: number | undefined // to become interval for reference to clear later\n    private pollIntervalMs: number = 3000\n    private queue: RetryQueueElement[] = []\n    private areWeOnline: boolean\n\n    constructor(private instance: PostHog) {\n        this.queue = []\n        this.areWeOnline = true\n\n        if (!isUndefined(window) && 'onLine' in window.navigator) {\n            this.areWeOnline = window.navigator.onLine\n            window.addEventListener('online', () => {\n                this.areWeOnline = true\n                this.flush()\n            })\n            window.addEventListener('offline', () => {\n                this.areWeOnline = false\n            })\n        }\n    }\n\n    retriableRequest({ retriesPerformedSoFar, ...options }: RetriableRequestOptions): void {\n        if (isNumber(retriesPerformedSoFar) && retriesPerformedSoFar > 0) {\n            options.url = extendURLParams(options.url, { retry_count: retriesPerformedSoFar })\n        }\n\n        this.instance._send_request({\n            ...options,\n            callback: (response) => {\n                if (response.statusCode !== 200 && (response.statusCode < 400 || response.statusCode >= 500)) {\n                    if ((retriesPerformedSoFar ?? 0) < 10) {\n                        this.enqueue({\n                            retriesPerformedSoFar,\n                            ...options,\n                        })\n                        return\n                    }\n                }\n\n                options.callback?.(response)\n            },\n        })\n    }\n\n    private enqueue(requestOptions: RetriableRequestOptions): void {\n        const retriesPerformedSoFar = requestOptions.retriesPerformedSoFar || 0\n        requestOptions.retriesPerformedSoFar = retriesPerformedSoFar + 1\n\n        const msToNextRetry = pickNextRetryDelay(retriesPerformedSoFar)\n        const retryAt = Date.now() + msToNextRetry\n\n        this.queue.push({ retryAt, requestOptions })\n\n        let logMessage = `Enqueued failed request for retry in ${msToNextRetry}`\n        if (!navigator.onLine) {\n            logMessage += ' (Browser is offline)'\n        }\n        logger.warn(logMessage)\n\n        if (!this.isPolling) {\n            this.isPolling = true\n            this.poll()\n        }\n    }\n\n    private poll(): void {\n        this.poller && clearTimeout(this.poller)\n        this.poller = setTimeout(() => {\n            if (this.areWeOnline && this.queue.length > 0) {\n                this.flush()\n            }\n            this.poll()\n        }, this.pollIntervalMs) as any as number\n    }\n\n    private flush(): void {\n        const now = Date.now()\n        const notToFlush: RetryQueueElement[] = []\n        const toFlush = this.queue.filter((item) => {\n            if (item.retryAt < now) {\n                return true\n            }\n            notToFlush.push(item)\n            return false\n        })\n\n        this.queue = notToFlush\n\n        if (toFlush.length > 0) {\n            for (const { requestOptions } of toFlush) {\n                this.retriableRequest(requestOptions)\n            }\n        }\n    }\n\n    unload(): void {\n        if (this.poller) {\n            clearTimeout(this.poller)\n            this.poller = undefined\n        }\n\n        for (const { requestOptions } of this.queue) {\n            try {\n                // we've had send beacon in place for at least 2 years\n                // eslint-disable-next-line compat/compat\n                this.instance._send_request({\n                    ...requestOptions,\n                    transport: 'sendBeacon',\n                })\n            } catch (e) {\n                // Note sendBeacon automatically retries, and after the first retry it will lose reference to contextual `this`.\n                // This means in some cases `this.getConfig` will be undefined.\n                logger.error(e)\n            }\n        }\n        this.queue = []\n    }\n}\n","import { PostHogPersistence } from './posthog-persistence'\nimport { SESSION_ID } from './constants'\nimport { sessionStore } from './storage'\nimport { PostHogConfig, SessionIdChangedCallback } from './types'\nimport { uuid7ToTimestampMs, uuidv7 } from './uuidv7'\nimport { window } from './utils/globals'\n\nimport { isArray, isNumber, isUndefined } from './utils/type-utils'\nimport { logger } from './utils/logger'\n\nconst MAX_SESSION_IDLE_TIMEOUT = 30 * 60 // 30 minutes\nconst MIN_SESSION_IDLE_TIMEOUT = 60 // 1 minute\nconst SESSION_LENGTH_LIMIT = 24 * 3600 * 1000 // 24 hours\n\nexport class SessionIdManager {\n    private readonly _sessionIdGenerator: () => string\n    private readonly _windowIdGenerator: () => string\n    private config: Partial<PostHogConfig>\n    private persistence: PostHogPersistence\n    private _windowId: string | null | undefined\n    private _sessionId: string | null | undefined\n    private readonly _window_id_storage_key: string\n    private readonly _primary_window_exists_storage_key: string\n    private _sessionStartTimestamp: number | null\n\n    private _sessionActivityTimestamp: number | null\n    private readonly _sessionTimeoutMs: number\n    private _sessionIdChangedHandlers: SessionIdChangedCallback[] = []\n\n    constructor(\n        config: Partial<PostHogConfig>,\n        persistence: PostHogPersistence,\n        sessionIdGenerator?: () => string,\n        windowIdGenerator?: () => string\n    ) {\n        this.config = config\n        this.persistence = persistence\n        this._windowId = undefined\n        this._sessionId = undefined\n        this._sessionStartTimestamp = null\n        this._sessionActivityTimestamp = null\n        this._sessionIdGenerator = sessionIdGenerator || uuidv7\n        this._windowIdGenerator = windowIdGenerator || uuidv7\n\n        const persistenceName = config['persistence_name'] || config['token']\n        let desiredTimeout = config['session_idle_timeout_seconds'] || MAX_SESSION_IDLE_TIMEOUT\n\n        if (!isNumber(desiredTimeout)) {\n            logger.warn('session_idle_timeout_seconds must be a number. Defaulting to 30 minutes.')\n            desiredTimeout = MAX_SESSION_IDLE_TIMEOUT\n        } else if (desiredTimeout > MAX_SESSION_IDLE_TIMEOUT) {\n            logger.warn('session_idle_timeout_seconds cannot be  greater than 30 minutes. Using 30 minutes instead.')\n        } else if (desiredTimeout < MIN_SESSION_IDLE_TIMEOUT) {\n            logger.warn('session_idle_timeout_seconds cannot be less than 60 seconds. Using 60 seconds instead.')\n        }\n\n        this._sessionTimeoutMs =\n            Math.min(Math.max(desiredTimeout, MIN_SESSION_IDLE_TIMEOUT), MAX_SESSION_IDLE_TIMEOUT) * 1000\n        this._window_id_storage_key = 'ph_' + persistenceName + '_window_id'\n        this._primary_window_exists_storage_key = 'ph_' + persistenceName + '_primary_window_exists'\n\n        // primary_window_exists is set when the DOM has been loaded and is cleared on unload\n        // if it exists here it means there was no unload which suggests this window is opened as a tab duplication, window.open, etc.\n        if (this._canUseSessionStorage()) {\n            const lastWindowId = sessionStore.parse(this._window_id_storage_key)\n\n            const primaryWindowExists = sessionStore.parse(this._primary_window_exists_storage_key)\n            if (lastWindowId && !primaryWindowExists) {\n                // Persist window from previous storage state\n                this._windowId = lastWindowId\n            } else {\n                // Wipe any reference to previous window id\n                sessionStore.remove(this._window_id_storage_key)\n            }\n            // Flag this session as having a primary window\n            sessionStore.set(this._primary_window_exists_storage_key, true)\n        }\n\n        if (this.config.bootstrap?.sessionID) {\n            try {\n                const sessionStartTimestamp = uuid7ToTimestampMs(this.config.bootstrap.sessionID)\n                this._setSessionId(this.config.bootstrap.sessionID, new Date().getTime(), sessionStartTimestamp)\n            } catch (e) {\n                logger.error('Invalid sessionID in bootstrap', e)\n            }\n        }\n\n        this._listenToReloadWindow()\n    }\n\n    onSessionId(callback: SessionIdChangedCallback): () => void {\n        // KLUDGE: when running in tests the handlers array was always undefined\n        // it's yucky but safe to set it here so that it's always definitely available\n        if (isUndefined(this._sessionIdChangedHandlers)) {\n            this._sessionIdChangedHandlers = []\n        }\n\n        this._sessionIdChangedHandlers.push(callback)\n        if (this._sessionId) {\n            callback(this._sessionId, this._windowId)\n        }\n        return () => {\n            this._sessionIdChangedHandlers = this._sessionIdChangedHandlers.filter((h) => h !== callback)\n        }\n    }\n\n    private _canUseSessionStorage(): boolean {\n        // We only want to use sessionStorage if persistence is enabled and not memory storage\n        return this.config.persistence !== 'memory' && !this.persistence.disabled && sessionStore.is_supported()\n    }\n\n    // Note: this tries to store the windowId in sessionStorage. SessionStorage is unique to the current window/tab,\n    // and persists page loads/reloads. So it's uniquely suited for storing the windowId. This function also respects\n    // when persistence is disabled (by user config) and when sessionStorage is not supported (it *should* be supported on all browsers),\n    // and in that case, it falls back to memory (which sadly, won't persist page loads)\n    private _setWindowId(windowId: string): void {\n        if (windowId !== this._windowId) {\n            this._windowId = windowId\n            if (this._canUseSessionStorage()) {\n                sessionStore.set(this._window_id_storage_key, windowId)\n            }\n        }\n    }\n\n    private _getWindowId(): string | null {\n        if (this._windowId) {\n            return this._windowId\n        }\n        if (this._canUseSessionStorage()) {\n            return sessionStore.parse(this._window_id_storage_key)\n        }\n        // New window id will be generated\n        return null\n    }\n\n    // Note: 'this.persistence.register' can be disabled in the config.\n    // In that case, this works by storing sessionId and the timestamp in memory.\n    private _setSessionId(\n        sessionId: string | null,\n        sessionActivityTimestamp: number | null,\n        sessionStartTimestamp: number | null\n    ): void {\n        if (\n            sessionId !== this._sessionId ||\n            sessionActivityTimestamp !== this._sessionActivityTimestamp ||\n            sessionStartTimestamp !== this._sessionStartTimestamp\n        ) {\n            this._sessionStartTimestamp = sessionStartTimestamp\n            this._sessionActivityTimestamp = sessionActivityTimestamp\n            this._sessionId = sessionId\n\n            this.persistence.register({\n                [SESSION_ID]: [sessionActivityTimestamp, sessionId, sessionStartTimestamp],\n            })\n        }\n    }\n\n    private _getSessionId(): [number, string, number] {\n        if (this._sessionId && this._sessionActivityTimestamp && this._sessionStartTimestamp) {\n            return [this._sessionActivityTimestamp, this._sessionId, this._sessionStartTimestamp]\n        }\n        const sessionId = this.persistence.props[SESSION_ID]\n\n        if (isArray(sessionId) && sessionId.length === 2) {\n            // Storage does not yet have a session start time. Add the last activity timestamp as the start time\n            sessionId.push(sessionId[0])\n        }\n\n        return sessionId || [0, null, 0]\n    }\n\n    // Resets the session id by setting it to null. On the subsequent call to checkAndGetSessionAndWindowId,\n    // new ids will be generated.\n    resetSessionId(): void {\n        this._setSessionId(null, null, null)\n    }\n\n    /*\n     * Listens to window unloads and removes the primaryWindowExists key from sessionStorage.\n     * Reloaded or fresh tabs created after a DOM unloads (reloading the same tab) WILL NOT have this primaryWindowExists flag in session storage.\n     * Cloned sessions (new tab, tab duplication, window.open(), ...) WILL have this primaryWindowExists flag in their copied session storage.\n     * We conditionally check the primaryWindowExists value in the constructor to decide if the window id in the last session storage should be carried over.\n     */\n    private _listenToReloadWindow(): void {\n        window?.addEventListener('beforeunload', () => {\n            if (this._canUseSessionStorage()) {\n                sessionStore.remove(this._primary_window_exists_storage_key)\n            }\n        })\n    }\n\n    /*\n     * This function returns the current sessionId and windowId. It should be used to\n     * access these values over directly calling `._sessionId` or `._windowId`.\n     * In addition to returning the sessionId and windowId, this function also manages cycling the\n     * sessionId and windowId when appropriate by doing the following:\n     *\n     * 1. If the sessionId or windowId is not set, it will generate a new one and store it.\n     * 2. If the readOnly param is set to false, it will:\n     *    a. Check if it has been > SESSION_CHANGE_THRESHOLD since the last call with this flag set.\n     *       If so, it will generate a new sessionId and store it.\n     *    b. Update the timestamp stored with the sessionId to ensure the current session is extended\n     *       for the appropriate amount of time.\n     *\n     * @param {boolean} readOnly (optional) Defaults to False. Should be set to True when the call to the function should not extend or cycle the session (e.g. being called for non-user generated events)\n     * @param {Number} timestamp (optional) Defaults to the current time. The timestamp to be stored with the sessionId (used when determining if a new sessionId should be generated)\n     */\n    checkAndGetSessionAndWindowId(readOnly = false, _timestamp: number | null = null) {\n        const timestamp = _timestamp || new Date().getTime()\n\n        // eslint-disable-next-line prefer-const\n        let [lastTimestamp, sessionId, startTimestamp] = this._getSessionId()\n        let windowId = this._getWindowId()\n\n        const sessionPastMaximumLength =\n            startTimestamp && startTimestamp > 0 && Math.abs(timestamp - startTimestamp) > SESSION_LENGTH_LIMIT\n\n        let valuesChanged = false\n        const noSessionId = !sessionId\n        const activityTimeout = !readOnly && Math.abs(timestamp - lastTimestamp) > this._sessionTimeoutMs\n        if (noSessionId || activityTimeout || sessionPastMaximumLength) {\n            sessionId = this._sessionIdGenerator()\n            windowId = this._windowIdGenerator()\n            logger.info('[SessionId] new session ID generated', {\n                sessionId,\n                windowId,\n                changeReason: { noSessionId, activityTimeout, sessionPastMaximumLength },\n            })\n            startTimestamp = timestamp\n            valuesChanged = true\n        } else if (!windowId) {\n            windowId = this._windowIdGenerator()\n            valuesChanged = true\n        }\n\n        const newTimestamp = lastTimestamp === 0 || !readOnly || sessionPastMaximumLength ? timestamp : lastTimestamp\n        const sessionStartTimestamp = startTimestamp === 0 ? new Date().getTime() : startTimestamp\n\n        this._setWindowId(windowId)\n        this._setSessionId(sessionId, newTimestamp, sessionStartTimestamp)\n\n        if (valuesChanged) {\n            this._sessionIdChangedHandlers.forEach((handler) => handler(sessionId, windowId))\n        }\n\n        return {\n            sessionId,\n            windowId,\n            sessionStartTimestamp,\n        }\n    }\n}\n","import { window } from '../../utils/globals'\nimport { PostHog } from '../../posthog-core'\nimport { DecideResponse, Properties } from '../../types'\n\nimport { isObject } from '../../utils/type-utils'\nimport { logger } from '../../utils/logger'\nimport { EXCEPTION_CAPTURE_ENABLED_SERVER_SIDE, EXCEPTION_CAPTURE_ENDPOINT } from '../../constants'\nimport Config from '../../config'\n\n// TODO: move this to /x/ as default\nexport const BASE_ERROR_ENDPOINT = '/e/'\nconst LOGGER_PREFIX = '[Exception Capture]'\n\nexport class ExceptionObserver {\n    private _endpoint: string\n    instance: PostHog\n    remoteEnabled: boolean | undefined\n    private originalOnUnhandledRejectionHandler: Window['onunhandledrejection'] | null | undefined = undefined\n    private unwrapOnError: (() => void) | undefined\n    private unwrapUnhandledRejection: (() => void) | undefined\n\n    constructor(instance: PostHog) {\n        this.instance = instance\n        this.remoteEnabled = !!this.instance.persistence?.props[EXCEPTION_CAPTURE_ENABLED_SERVER_SIDE]\n\n        // TODO: once BASE_ERROR_ENDPOINT is no longer /e/ this can be removed\n        this._endpoint = this.instance.persistence?.props[EXCEPTION_CAPTURE_ENDPOINT] || BASE_ERROR_ENDPOINT\n\n        this.startIfEnabled()\n    }\n\n    get endpoint() {\n        return this._endpoint\n    }\n\n    get isEnabled() {\n        return this.remoteEnabled ?? false\n    }\n\n    get isCapturing() {\n        return !!(window?.onerror as any)?.__POSTHOG_INSTRUMENTED__\n    }\n\n    get hasHandlers() {\n        return this.originalOnUnhandledRejectionHandler || this.unwrapOnError\n    }\n\n    startIfEnabled(): void {\n        if (this.isEnabled && !this.isCapturing) {\n            logger.info(LOGGER_PREFIX + ' enabled, starting...')\n            this.loadScript(this.startCapturing)\n        }\n    }\n\n    private loadScript(cb: () => void): void {\n        if (this.hasHandlers) {\n            // already loaded\n            cb()\n        }\n\n        this.instance.requestRouter.loadScript(`/static/exception-autocapture.js?v=${Config.LIB_VERSION}`, (err) => {\n            if (err) {\n                return logger.error(LOGGER_PREFIX + ' failed to load script', err)\n            }\n            cb()\n        })\n    }\n\n    private startCapturing = () => {\n        if (!window || !this.isEnabled || this.hasHandlers || (window.onerror as any)?.__POSTHOG_INSTRUMENTED__) {\n            return\n        }\n\n        const wrapOnError = (window as any).posthogErrorWrappingFunctions.wrapOnError\n        const wrapUnhandledRejection = (window as any).posthogErrorWrappingFunctions.wrapUnhandledRejection\n\n        if (!wrapOnError || !wrapUnhandledRejection) {\n            logger.error(LOGGER_PREFIX + ' failed to load error wrapping functions - cannot start')\n            return\n        }\n\n        try {\n            this.unwrapOnError = wrapOnError(this.captureException.bind(this))\n            this.unwrapUnhandledRejection = wrapUnhandledRejection(this.captureException.bind(this))\n        } catch (e) {\n            logger.error(LOGGER_PREFIX + ' failed to start', e)\n            this.stopCapturing()\n        }\n    }\n\n    private stopCapturing() {\n        this.unwrapOnError?.()\n        this.unwrapUnhandledRejection?.()\n    }\n\n    afterDecideResponse(response: DecideResponse) {\n        const autocaptureExceptionsResponse = response.autocaptureExceptions\n\n        // store this in-memory in case persistence is disabled\n        this.remoteEnabled = !!autocaptureExceptionsResponse || false\n        this._endpoint = isObject(autocaptureExceptionsResponse)\n            ? autocaptureExceptionsResponse.endpoint || BASE_ERROR_ENDPOINT\n            : BASE_ERROR_ENDPOINT\n\n        if (this.instance.persistence) {\n            this.instance.persistence.register({\n                [EXCEPTION_CAPTURE_ENABLED_SERVER_SIDE]: this.remoteEnabled,\n            })\n            // when we come to moving the endpoint to not /e/\n            // we'll want that to persist between startup and decide response\n            // TODO: once BASE_ENDPOINT is no longer /e/ this can be removed\n            this.instance.persistence.register({\n                [EXCEPTION_CAPTURE_ENDPOINT]: this._endpoint,\n            })\n        }\n\n        this.startIfEnabled()\n    }\n\n    captureException(errorProperties: Properties) {\n        const posthogHost = this.instance.requestRouter.endpointFor('ui')\n\n        errorProperties.$exception_personURL = `${posthogHost}/project/${\n            this.instance.config.token\n        }/person/${this.instance.get_distinct_id()}`\n\n        this.sendExceptionEvent(errorProperties)\n    }\n\n    /**\n     * :TRICKY: Make sure we batch these requests\n     */\n    sendExceptionEvent(properties: { [key: string]: any }) {\n        this.instance.capture('$exception', properties, {\n            _noTruncate: true,\n            _batchKey: 'exceptionEvent',\n            _url: this.endpoint,\n        })\n    }\n}\n","/**\n * Integrate Sentry with PostHog. This will add a direct link to the person in Sentry, and an $exception event in PostHog\n *\n * ### Usage\n *\n *     Sentry.init({\n *          dsn: 'https://example',\n *          integrations: [\n *              new posthog.SentryIntegration(posthog)\n *          ]\n *     })\n *\n * @param {Object} [posthog] The posthog object\n * @param {string} [organization] Optional: The Sentry organization, used to send a direct link from PostHog to Sentry\n * @param {Number} [projectId] Optional: The Sentry project id, used to send a direct link from PostHog to Sentry\n * @param {string} [prefix] Optional: Url of a self-hosted sentry instance (default: https://sentry.io/organizations/)\n */\n\nimport { PostHog } from '../posthog-core'\nimport { SeverityLevel } from '../types'\nimport { BASE_ERROR_ENDPOINT } from './exception-autocapture'\n\n// NOTE - we can't import from @sentry/types because it changes frequently and causes clashes\n// We only use a small subset of the types, so we can just define the integration overall and use any for the rest\n\n// import {\n//     Event as _SentryEvent,\n//     EventProcessor as _SentryEventProcessor,\n//     Hub as _SentryHub,\n//     Integration as _SentryIntegration,\n//     SeverityLevel as _SeverityLevel,\n//     IntegrationClass as _SentryIntegrationClass,\n// } from '@sentry/types'\n\n// Uncomment the above and comment the below to get type checking for development\n\ntype _SentryEvent = any\ntype _SentryEventProcessor = any\ntype _SentryHub = any\n\ninterface _SentryIntegrationClass {\n    name: string\n    setupOnce(addGlobalEventProcessor: (callback: _SentryEventProcessor) => void, getCurrentHub: () => _SentryHub): void\n}\n\ninterface _SentryIntegration {\n    name: string\n    processEvent(event: _SentryEvent): _SentryEvent\n}\n\ninterface SentryExceptionProperties {\n    $sentry_event_id: any\n    $sentry_exception: any\n    $sentry_exception_message: any\n    $sentry_exception_type: any\n    $sentry_tags: any\n    $sentry_url?: string\n}\n\nexport type SentryIntegrationOptions = {\n    organization?: string\n    projectId?: number\n    prefix?: string\n    /**\n     * By default, only errors are sent to PostHog. You can set this to '*' to send all events.\n     * Or to an error of SeverityLevel to only send events matching the provided levels.\n     * e.g. ['error', 'fatal'] to send only errors and fatals\n     * e.g. ['error'] to send only errors -- the default when omitted\n     * e.g. '*' to send all events\n     */\n    severityAllowList?: SeverityLevel[] | '*'\n}\n\nconst NAME = 'posthog-js'\n\nexport function createEventProcessor(\n    _posthog: PostHog,\n    { organization, projectId, prefix, severityAllowList = ['error'] }: SentryIntegrationOptions = {}\n): (event: _SentryEvent) => _SentryEvent {\n    return (event) => {\n        const shouldProcessLevel = severityAllowList === '*' || severityAllowList.includes(event.level as SeverityLevel)\n        if (!shouldProcessLevel || !_posthog.__loaded) return event\n        if (!event.tags) event.tags = {}\n\n        const personUrl = _posthog.requestRouter.endpointFor(\n            'ui',\n            `/project/${_posthog.config.token}/person/${_posthog.get_distinct_id()}`\n        )\n        event.tags['PostHog Person URL'] = personUrl\n        if (_posthog.sessionRecordingStarted()) {\n            event.tags['PostHog Recording URL'] = _posthog.get_session_replay_url({ withTimestamp: true })\n        }\n\n        const exceptions = event.exception?.values || []\n\n        const data: SentryExceptionProperties & {\n            // two properties added to match any exception auto-capture\n            // added manually to avoid any dependency on the lazily loaded content\n            $exception_message: any\n            $exception_type: any\n            $exception_personURL: string\n            $exception_level: SeverityLevel\n            $level: SeverityLevel\n        } = {\n            // PostHog Exception Properties,\n            $exception_message: exceptions[0]?.value || event.message,\n            $exception_type: exceptions[0]?.type,\n            $exception_personURL: personUrl,\n            $exception_level: event.level,\n            // Sentry Exception Properties\n            $sentry_event_id: event.event_id,\n            $sentry_exception: event.exception,\n            $sentry_exception_message: exceptions[0]?.value || event.message,\n            $sentry_exception_type: exceptions[0]?.type,\n            $sentry_tags: event.tags,\n            $level: event.level,\n        }\n\n        if (organization && projectId) {\n            data['$sentry_url'] =\n                (prefix || 'https://sentry.io/organizations/') +\n                organization +\n                '/issues/?project=' +\n                projectId +\n                '&query=' +\n                event.event_id\n        }\n\n        // we take the URL from the exception observer\n        // so that when we add error specific URL for ingestion\n        // these errors are sent there too\n        _posthog.capture('$exception', data, { _url: _posthog.exceptionObserver?.endpoint || BASE_ERROR_ENDPOINT })\n\n        return event\n    }\n}\n\n// V8 integration - function based\nexport function sentryIntegration(_posthog: PostHog, options?: SentryIntegrationOptions): _SentryIntegration {\n    const processor = createEventProcessor(_posthog, options)\n    return {\n        name: NAME,\n        processEvent(event) {\n            return processor(event)\n        },\n    }\n}\n// V7 integration - class based\nexport class SentryIntegration implements _SentryIntegrationClass {\n    name: string\n\n    setupOnce: (\n        addGlobalEventProcessor: (callback: _SentryEventProcessor) => void,\n        getCurrentHub: () => _SentryHub\n    ) => void\n\n    constructor(\n        _posthog: PostHog,\n        organization?: string,\n        projectId?: number,\n        prefix?: string,\n        /**\n         * By default, only errors are sent to PostHog. You can set this to '*' to send all events.\n         * Or to an error of SeverityLevel to only send events matching the provided levels.\n         * e.g. ['error', 'fatal'] to send only errors and fatals\n         * e.g. ['error'] to send only errors -- the default when omitted\n         * e.g. '*' to send all events\n         */\n        severityAllowList?: SeverityLevel[] | '*'\n    ) {\n        // setupOnce gets called by Sentry when it intializes the plugin\n        this.name = NAME\n        this.setupOnce = function (addGlobalEventProcessor: (callback: _SentryEventProcessor) => void) {\n            addGlobalEventProcessor(\n                createEventProcessor(_posthog, { organization, projectId, prefix, severityAllowList })\n            )\n        }\n    }\n}\n","import { window } from './utils/globals'\nimport { PostHog } from './posthog-core'\nimport { isUndefined } from './utils/type-utils'\n\ninterface PageViewEventProperties {\n    $prev_pageview_pathname?: string\n    $prev_pageview_duration?: number // seconds\n    $prev_pageview_last_scroll?: number\n    $prev_pageview_last_scroll_percentage?: number\n    $prev_pageview_max_scroll?: number\n    $prev_pageview_max_scroll_percentage?: number\n    $prev_pageview_last_content?: number\n    $prev_pageview_last_content_percentage?: number\n    $prev_pageview_max_content?: number\n    $prev_pageview_max_content_percentage?: number\n}\n\nexport class PageViewManager {\n    _currentPath?: string\n    _prevPageviewTimestamp?: Date\n    _instance: PostHog\n\n    constructor(instance: PostHog) {\n        this._instance = instance\n    }\n\n    doPageView(timestamp: Date): PageViewEventProperties {\n        const response = this._previousPageViewProperties(timestamp)\n\n        // On a pageview we reset the contexts\n        this._currentPath = window?.location.pathname ?? ''\n        this._instance.scrollManager.resetContext()\n        this._prevPageviewTimestamp = timestamp\n\n        return response\n    }\n\n    doPageLeave(timestamp: Date): PageViewEventProperties {\n        return this._previousPageViewProperties(timestamp)\n    }\n\n    private _previousPageViewProperties(timestamp: Date): PageViewEventProperties {\n        const previousPath = this._currentPath\n        const previousTimestamp = this._prevPageviewTimestamp\n        const scrollContext = this._instance.scrollManager.getContext()\n\n        if (!previousTimestamp) {\n            // this means there was no previous pageview\n            return {}\n        }\n\n        let properties: PageViewEventProperties = {}\n        if (scrollContext) {\n            let { maxScrollHeight, lastScrollY, maxScrollY, maxContentHeight, lastContentY, maxContentY } =\n                scrollContext\n\n            if (\n                !isUndefined(maxScrollHeight) &&\n                !isUndefined(lastScrollY) &&\n                !isUndefined(maxScrollY) &&\n                !isUndefined(maxContentHeight) &&\n                !isUndefined(lastContentY) &&\n                !isUndefined(maxContentY)\n            ) {\n                // Use ceil, so that e.g. scrolling 999.5px of a 1000px page is considered 100% scrolled\n                maxScrollHeight = Math.ceil(maxScrollHeight)\n                lastScrollY = Math.ceil(lastScrollY)\n                maxScrollY = Math.ceil(maxScrollY)\n                maxContentHeight = Math.ceil(maxContentHeight)\n                lastContentY = Math.ceil(lastContentY)\n                maxContentY = Math.ceil(maxContentY)\n\n                // if the maximum scroll height is near 0, then the percentage is 1\n                const lastScrollPercentage = maxScrollHeight <= 1 ? 1 : clamp(lastScrollY / maxScrollHeight, 0, 1)\n                const maxScrollPercentage = maxScrollHeight <= 1 ? 1 : clamp(maxScrollY / maxScrollHeight, 0, 1)\n                const lastContentPercentage = maxContentHeight <= 1 ? 1 : clamp(lastContentY / maxContentHeight, 0, 1)\n                const maxContentPercentage = maxContentHeight <= 1 ? 1 : clamp(maxContentY / maxContentHeight, 0, 1)\n\n                properties = {\n                    $prev_pageview_last_scroll: lastScrollY,\n                    $prev_pageview_last_scroll_percentage: lastScrollPercentage,\n                    $prev_pageview_max_scroll: maxScrollY,\n                    $prev_pageview_max_scroll_percentage: maxScrollPercentage,\n                    $prev_pageview_last_content: lastContentY,\n                    $prev_pageview_last_content_percentage: lastContentPercentage,\n                    $prev_pageview_max_content: maxContentY,\n                    $prev_pageview_max_content_percentage: maxContentPercentage,\n                }\n            }\n        }\n\n        if (previousPath) {\n            properties.$prev_pageview_pathname = previousPath\n        }\n        if (previousTimestamp) {\n            // Use seconds, for consistency with our other duration-related properties like $duration\n            properties.$prev_pageview_duration = (timestamp.getTime() - previousTimestamp.getTime()) / 1000\n        }\n\n        return properties\n    }\n}\n\nfunction clamp(x: number, min: number, max: number) {\n    return Math.max(min, Math.min(x, max))\n}\n","/**\n * Having Survey types in types.ts was confusing tsc\n * and generating an invalid module.d.ts\n * See https://github.com/PostHog/posthog-js/issues/698\n */\n\nexport interface SurveyAppearance {\n    // keep in sync with frontend/src/types.ts -> SurveyAppearance\n    backgroundColor?: string\n    submitButtonColor?: string\n    // text color is deprecated, use auto contrast text color instead\n    textColor?: string\n    // deprecate submit button text eventually\n    submitButtonText?: string\n    submitButtonTextColor?: string\n    descriptionTextColor?: string\n    ratingButtonColor?: string\n    ratingButtonActiveColor?: string\n    ratingButtonHoverColor?: string\n    whiteLabel?: boolean\n    autoDisappear?: boolean\n    displayThankYouMessage?: boolean\n    thankYouMessageHeader?: string\n    thankYouMessageDescription?: string\n    thankYouMessageDescriptionContentType?: SurveyQuestionDescriptionContentType\n    thankYouMessageCloseButtonText?: string\n    borderColor?: string\n    position?: 'left' | 'right' | 'center'\n    placeholder?: string\n    shuffleQuestions?: boolean\n    surveyPopupDelaySeconds?: number\n    // widget options\n    widgetType?: 'button' | 'tab' | 'selector'\n    widgetSelector?: string\n    widgetLabel?: string\n    widgetColor?: string\n    // questionable: Not in frontend/src/types.ts -> SurveyAppearance, but used in site app\n    maxWidth?: string\n    zIndex?: string\n}\n\nexport enum SurveyType {\n    Popover = 'popover',\n    API = 'api',\n    Widget = 'widget',\n}\n\nexport type SurveyQuestion = BasicSurveyQuestion | LinkSurveyQuestion | RatingSurveyQuestion | MultipleSurveyQuestion\n\nexport type SurveyQuestionDescriptionContentType = 'html' | 'text'\n\ninterface SurveyQuestionBase {\n    question: string\n    description?: string | null\n    descriptionContentType?: SurveyQuestionDescriptionContentType\n    optional?: boolean\n    buttonText?: string\n    originalQuestionIndex: number\n    branching?: NextQuestionBranching | EndBranching | ResponseBasedBranching | SpecificQuestionBranching\n}\n\nexport interface BasicSurveyQuestion extends SurveyQuestionBase {\n    type: SurveyQuestionType.Open\n}\n\nexport interface LinkSurveyQuestion extends SurveyQuestionBase {\n    type: SurveyQuestionType.Link\n    link?: string | null\n}\n\nexport interface RatingSurveyQuestion extends SurveyQuestionBase {\n    type: SurveyQuestionType.Rating\n    display: 'number' | 'emoji'\n    scale: 3 | 5 | 7 | 10\n    lowerBoundLabel: string\n    upperBoundLabel: string\n}\n\nexport interface MultipleSurveyQuestion extends SurveyQuestionBase {\n    type: SurveyQuestionType.SingleChoice | SurveyQuestionType.MultipleChoice\n    choices: string[]\n    hasOpenChoice?: boolean\n    shuffleOptions?: boolean\n}\n\nexport enum SurveyQuestionType {\n    Open = 'open',\n    MultipleChoice = 'multiple_choice',\n    SingleChoice = 'single_choice',\n    Rating = 'rating',\n    Link = 'link',\n}\n\nexport enum SurveyQuestionBranchingType {\n    NextQuestion = 'next_question',\n    End = 'end',\n    ResponseBased = 'response_based',\n    SpecificQuestion = 'specific_question',\n}\n\ninterface NextQuestionBranching {\n    type: SurveyQuestionBranchingType.NextQuestion\n}\n\ninterface EndBranching {\n    type: SurveyQuestionBranchingType.End\n}\n\ninterface ResponseBasedBranching {\n    type: SurveyQuestionBranchingType.ResponseBased\n    responseValues: Record<string, any>\n}\n\ninterface SpecificQuestionBranching {\n    type: SurveyQuestionBranchingType.SpecificQuestion\n    index: number\n}\n\nexport interface SurveyResponse {\n    surveys: Survey[]\n}\n\nexport type SurveyCallback = (surveys: Survey[]) => void\n\nexport type SurveyUrlMatchType = 'regex' | 'not_regex' | 'exact' | 'is_not' | 'icontains' | 'not_icontains'\n\nexport interface SurveyElement {\n    text?: string\n    $el_text?: string\n    tag_name?: string\n    href?: string\n    attr_id?: string\n    attr_class?: string[]\n    nth_child?: number\n    nth_of_type?: number\n    attributes?: Record<string, any>\n    event_id?: number\n    order?: number\n    group_id?: number\n}\nexport interface SurveyRenderReason {\n    visible: boolean\n    disabledReason?: string\n}\n\nexport interface Survey {\n    // Sync this with the backend's SurveyAPISerializer!\n    id: string\n    name: string\n    description: string\n    type: SurveyType\n    linked_flag_key: string | null\n    targeting_flag_key: string | null\n    internal_targeting_flag_key: string | null\n    questions: SurveyQuestion[]\n    appearance: SurveyAppearance | null\n    conditions: {\n        url?: string\n        selector?: string\n        seenSurveyWaitPeriodInDays?: number\n        urlMatchType?: SurveyUrlMatchType\n        events: {\n            repeatedActivation?: boolean\n            values: {\n                name: string\n            }[]\n        } | null\n        actions: {\n            values: ActionType[]\n        } | null\n    } | null\n    start_date: string | null\n    end_date: string | null\n    current_iteration: number | null\n    current_iteration_start_date: string | null\n}\n\nexport interface ActionType {\n    count?: number\n    created_at: string\n    deleted?: boolean\n    id: number\n    name: string | null\n    steps?: ActionStepType[]\n    tags?: string[]\n    is_action?: true\n    action_id?: number // alias of id to make it compatible with event definitions uuid\n}\n\n/** Sync with plugin-server/src/types.ts */\nexport type ActionStepStringMatching = 'contains' | 'exact' | 'regex'\n\nexport interface ActionStepType {\n    event?: string | null\n    selector?: string | null\n    /** @deprecated Only `selector` should be used now. */\n    tag_name?: string\n    text?: string | null\n    /** @default StringMatching.Exact */\n    text_matching?: ActionStepStringMatching | null\n    href?: string | null\n    /** @default ActionStepStringMatching.Exact */\n    href_matching?: ActionStepStringMatching | null\n    url?: string | null\n    /** @default StringMatching.Contains */\n    url_matching?: ActionStepStringMatching | null\n}\n","export class SimpleEventEmitter {\n    private events: { [key: string]: ((...args: any[]) => void)[] } = {}\n\n    constructor() {\n        this.events = {}\n    }\n\n    on(event: string, listener: (...args: any[]) => void): () => void {\n        if (!this.events[event]) {\n            this.events[event] = []\n        }\n        this.events[event].push(listener)\n\n        return () => {\n            this.events[event] = this.events[event].filter((x) => x !== listener)\n        }\n    }\n\n    emit(event: string, payload: any): void {\n        for (const listener of this.events[event] || []) {\n            listener(payload)\n        }\n        for (const listener of this.events['*'] || []) {\n            listener(event, payload)\n        }\n    }\n}\n","import { PostHog } from '../../posthog-core'\nimport { ActionStepStringMatching, ActionStepType, ActionType, SurveyElement } from '../../posthog-surveys-types'\nimport { SimpleEventEmitter } from '../../utils/simple-event-emitter'\nimport { CaptureResult } from '../../types'\nimport { isUndefined } from '../../utils/type-utils'\nimport { window } from '../../utils/globals'\nimport { isUrlMatchingRegex } from '../../utils/request-utils'\n\nexport class ActionMatcher {\n    private readonly actionRegistry?: Set<ActionType>\n    private readonly instance?: PostHog\n    private readonly actionEvents: Set<string>\n    private _debugEventEmitter = new SimpleEventEmitter()\n\n    constructor(instance?: PostHog) {\n        this.instance = instance\n        this.actionEvents = new Set<string>()\n        this.actionRegistry = new Set<ActionType>()\n    }\n\n    init() {\n        if (!isUndefined(this.instance?._addCaptureHook)) {\n            const matchEventToAction = (eventName: string, eventPayload: any) => {\n                this.on(eventName, eventPayload)\n            }\n            this.instance?._addCaptureHook(matchEventToAction)\n        }\n    }\n\n    register(actions: ActionType[]): void {\n        if (isUndefined(this.instance?._addCaptureHook)) {\n            return\n        }\n\n        actions.forEach((action) => {\n            this.actionRegistry?.add(action)\n            action.steps?.forEach((step) => {\n                this.actionEvents?.add(step?.event || '')\n            })\n        })\n\n        if (this.instance?.autocapture) {\n            const selectorsToWatch: Set<string> = new Set<string>()\n            actions.forEach((action) => {\n                action.steps?.forEach((step) => {\n                    if (step?.selector) {\n                        selectorsToWatch.add(step?.selector)\n                    }\n                })\n            })\n            this.instance?.autocapture.setElementSelectors(selectorsToWatch)\n        }\n    }\n\n    on(eventName: string, eventPayload?: CaptureResult) {\n        if (eventPayload == null || eventName.length == 0) {\n            return\n        }\n\n        if (!this.actionEvents.has(eventName) && !this.actionEvents.has(<string>eventPayload?.event)) {\n            return\n        }\n\n        if (this.actionRegistry && this.actionRegistry?.size > 0) {\n            this.actionRegistry.forEach((action) => {\n                if (this.checkAction(eventPayload, action)) {\n                    this._debugEventEmitter.emit('actionCaptured', action.name)\n                }\n            })\n        }\n    }\n\n    _addActionHook(callback: (actionName: string, eventPayload?: any) => void): void {\n        this.onAction('actionCaptured', (data) => callback(data))\n    }\n\n    private checkAction(event?: CaptureResult, action?: ActionType): boolean {\n        if (action?.steps == null) {\n            return false\n        }\n\n        for (const step of action.steps) {\n            if (this.checkStep(event, step)) {\n                return true\n            }\n        }\n\n        return false\n    }\n\n    onAction(event: 'actionCaptured', cb: (...args: any[]) => void): () => void {\n        return this._debugEventEmitter.on(event, cb)\n    }\n\n    private checkStep = (event?: CaptureResult, step?: ActionStepType): boolean => {\n        return this.checkStepEvent(event, step) && this.checkStepUrl(event, step) && this.checkStepElement(event, step)\n    }\n\n    private checkStepEvent = (event?: CaptureResult, step?: ActionStepType): boolean => {\n        // CHECK CONDITIONS, OTHERWISE SKIPPED\n        if (step?.event && event?.event !== step?.event) {\n            return false // EVENT NAME IS A MISMATCH\n        }\n        return true\n    }\n\n    private checkStepUrl(event?: CaptureResult, step?: ActionStepType): boolean {\n        // CHECK CONDITIONS, OTHERWISE SKIPPED\n        if (step?.url) {\n            const eventUrl = event?.properties?.$current_url\n            if (!eventUrl || typeof eventUrl !== 'string') {\n                return false // URL IS UNKNOWN\n            }\n            if (!ActionMatcher.matchString(eventUrl, step?.url, step?.url_matching || 'contains')) {\n                return false // URL IS A MISMATCH\n            }\n        }\n        return true\n    }\n\n    private static matchString(url: string, pattern: string, matching: ActionStepStringMatching): boolean {\n        switch (matching) {\n            case 'regex':\n                return !!window && isUrlMatchingRegex(url, pattern)\n            case 'exact':\n                return pattern === url\n            case 'contains':\n                // Simulating SQL LIKE behavior (_ = any single character, % = any zero or more characters)\n                // eslint-disable-next-line no-case-declarations\n                const adjustedRegExpStringPattern = ActionMatcher.escapeStringRegexp(pattern)\n                    .replace(/_/g, '.')\n                    .replace(/%/g, '.*')\n                return isUrlMatchingRegex(url, adjustedRegExpStringPattern)\n\n            default:\n                return false\n        }\n    }\n\n    private static escapeStringRegexp(pattern: string): string {\n        // Escape characters with special meaning either inside or outside character sets.\n        // Use a simple backslash escape when it’s always valid, and a `\\xnn` escape when the simpler form would be disallowed by Unicode patterns’ stricter grammar.\n        return pattern.replace(/[|\\\\{}()[\\]^$+*?.]/g, '\\\\$&').replace(/-/g, '\\\\x2d')\n    }\n\n    private checkStepElement(event?: CaptureResult, step?: ActionStepType): boolean {\n        // CHECK CONDITIONS, OTHERWISE SKIPPED\n        if (step?.href || step?.tag_name || step?.text) {\n            const elements = this.getElementsList(event)\n            if (\n                !elements.some((element) => {\n                    if (\n                        step?.href &&\n                        !ActionMatcher.matchString(element.href || '', step?.href, step?.href_matching || 'exact')\n                    ) {\n                        return false // ELEMENT HREF IS A MISMATCH\n                    }\n                    if (step?.tag_name && element.tag_name !== step?.tag_name) {\n                        return false // ELEMENT TAG NAME IS A MISMATCH\n                    }\n                    if (\n                        step?.text &&\n                        !(\n                            ActionMatcher.matchString(element.text || '', step?.text, step?.text_matching || 'exact') ||\n                            ActionMatcher.matchString(\n                                element.$el_text || '',\n                                step?.text,\n                                step?.text_matching || 'exact'\n                            )\n                        )\n                    ) {\n                        return false // ELEMENT TEXT IS A MISMATCH\n                    }\n                    return true\n                })\n            ) {\n                // AT LEAST ONE ELEMENT MUST BE A SUBMATCH\n                return false\n            }\n        }\n\n        if (step?.selector) {\n            const elementSelectors = event?.properties?.$element_selectors as unknown as string[]\n            if (!elementSelectors) {\n                return false // SELECTOR IS A MISMATCH\n            }\n            if (!elementSelectors.includes(step?.selector)) {\n                return false // SELECTOR IS A MISMATCH\n            }\n        }\n\n        return true\n    }\n\n    private getElementsList(event?: CaptureResult): SurveyElement[] {\n        if (event?.properties.$elements == null) {\n            return []\n        }\n\n        return event?.properties.$elements as unknown as SurveyElement[]\n    }\n}\n","import { Survey } from '../posthog-surveys-types'\nimport { SURVEYS_ACTIVATED } from '../constants'\n\nimport { CaptureResult } from '../types'\nimport { ActionMatcher } from '../extensions/surveys/action-matcher'\nimport { PostHog } from '../posthog-core'\nimport { isUndefined } from './type-utils'\n\nexport class SurveyEventReceiver {\n    // eventToSurveys is a mapping of event name to all the surveys that are activated by it\n    private readonly eventToSurveys: Map<string, string[]>\n    // actionToSurveys is a mapping of action name to all the surveys that are activated by it\n    private readonly actionToSurveys: Map<string, string[]>\n    // actionMatcher can look at CaptureResult payloads and match an event to its corresponding action.\n    private actionMatcher?: ActionMatcher | null\n    private readonly instance?: PostHog\n    private static SURVEY_SHOWN_EVENT_NAME = 'survey shown'\n\n    constructor(instance: PostHog) {\n        this.instance = instance\n        this.eventToSurveys = new Map<string, string[]>()\n        this.actionToSurveys = new Map<string, string[]>()\n    }\n\n    register(surveys: Survey[]): void {\n        if (isUndefined(this.instance?._addCaptureHook)) {\n            return\n        }\n\n        this.setupEventBasedSurveys(surveys)\n        this.setupActionBasedSurveys(surveys)\n    }\n\n    private setupActionBasedSurveys(surveys: Survey[]) {\n        const actionBasedSurveys = surveys.filter(\n            (survey: Survey) => survey.conditions?.actions && survey.conditions?.actions?.values?.length > 0\n        )\n\n        if (actionBasedSurveys.length === 0) {\n            return\n        }\n\n        if (this.actionMatcher == null) {\n            this.actionMatcher = new ActionMatcher(this.instance)\n            this.actionMatcher.init()\n            // match any actions to its corresponding survey.\n            const matchActionToSurvey = (actionName: string) => {\n                this.onAction(actionName)\n            }\n\n            this.actionMatcher._addActionHook(matchActionToSurvey)\n        }\n\n        actionBasedSurveys.forEach((survey) => {\n            if (\n                survey.conditions &&\n                survey.conditions?.actions &&\n                survey.conditions?.actions?.values &&\n                survey.conditions?.actions?.values?.length > 0\n            ) {\n                // register the known set of actions with\n                // the action-matcher so it can match\n                // events to actions\n                this.actionMatcher?.register(survey.conditions.actions.values)\n\n                // maintain a mapping of (Action1) => [Survey1, Survey2, Survey3]\n                // where Surveys 1-3 are all activated by Action1\n                survey.conditions?.actions?.values?.forEach((action) => {\n                    if (action && action.name) {\n                        const knownSurveys: string[] | undefined = this.actionToSurveys.get(action.name)\n                        if (knownSurveys) {\n                            knownSurveys.push(survey.id)\n                        }\n                        this.actionToSurveys.set(action.name, knownSurveys || [survey.id])\n                    }\n                })\n            }\n        })\n    }\n\n    private setupEventBasedSurveys(surveys: Survey[]) {\n        const eventBasedSurveys = surveys.filter(\n            (survey: Survey) => survey.conditions?.events && survey.conditions?.events?.values?.length > 0\n        )\n\n        if (eventBasedSurveys.length === 0) {\n            return\n        }\n\n        // match any events to its corresponding survey.\n        const matchEventToSurvey = (eventName: string, eventPayload?: CaptureResult) => {\n            this.onEvent(eventName, eventPayload)\n        }\n        this.instance?._addCaptureHook(matchEventToSurvey)\n\n        surveys.forEach((survey) => {\n            // maintain a mapping of (Event1) => [Survey1, Survey2, Survey3]\n            // where Surveys 1-3 are all activated by Event1\n            survey.conditions?.events?.values?.forEach((event) => {\n                if (event && event.name) {\n                    const knownSurveys: string[] | undefined = this.eventToSurveys.get(event.name)\n                    if (knownSurveys) {\n                        knownSurveys.push(survey.id)\n                    }\n                    this.eventToSurveys.set(event.name, knownSurveys || [survey.id])\n                }\n            })\n        })\n    }\n\n    onEvent(event: string, eventPayload?: CaptureResult): void {\n        const existingActivatedSurveys: string[] = this.instance?.persistence?.props[SURVEYS_ACTIVATED] || []\n        if (\n            SurveyEventReceiver.SURVEY_SHOWN_EVENT_NAME == event &&\n            eventPayload &&\n            existingActivatedSurveys.length > 0\n        ) {\n            // remove survey that from activatedSurveys here.\n            const surveyId = eventPayload?.properties?.$survey_id\n            if (surveyId) {\n                const index = existingActivatedSurveys.indexOf(surveyId)\n                if (index >= 0) {\n                    existingActivatedSurveys.splice(index, 1)\n                    this._updateActivatedSurveys(existingActivatedSurveys)\n                }\n            }\n        } else {\n            if (this.eventToSurveys.has(event)) {\n                this._updateActivatedSurveys(existingActivatedSurveys.concat(this.eventToSurveys.get(event) || []))\n            }\n        }\n    }\n\n    onAction(actionName: string): void {\n        const existingActivatedSurveys: string[] = this.instance?.persistence?.props[SURVEYS_ACTIVATED] || []\n        if (this.actionToSurveys.has(actionName)) {\n            this._updateActivatedSurveys(existingActivatedSurveys.concat(this.actionToSurveys.get(actionName) || []))\n        }\n    }\n\n    private _updateActivatedSurveys(activatedSurveys: string[]) {\n        // we use a new Set here to remove duplicates.\n        this.instance?.persistence?.register({\n            [SURVEYS_ACTIVATED]: [...new Set(activatedSurveys)],\n        })\n    }\n\n    getSurveys(): string[] {\n        const existingActivatedSurveys = this.instance?.persistence?.props[SURVEYS_ACTIVATED]\n        return existingActivatedSurveys ? existingActivatedSurveys : []\n    }\n\n    getEventToSurveys(): Map<string, string[]> {\n        return this.eventToSurveys\n    }\n\n    _getActionMatcher(): ActionMatcher | null | undefined {\n        return this.actionMatcher\n    }\n}\n","import { PostHog } from './posthog-core'\nimport { SURVEYS } from './constants'\nimport {\n    Survey,\n    SurveyCallback,\n    SurveyQuestionBranchingType,\n    SurveyQuestionType,\n    SurveyUrlMatchType,\n} from './posthog-surveys-types'\nimport { isUrlMatchingRegex } from './utils/request-utils'\nimport { SurveyEventReceiver } from './utils/survey-event-receiver'\nimport { assignableWindow, document, window } from './utils/globals'\nimport { DecideResponse } from './types'\nimport { logger } from './utils/logger'\nimport { isNullish } from './utils/type-utils'\n\nconst LOGGER_PREFIX = '[Surveys]'\n\nexport const surveyUrlValidationMap: Record<SurveyUrlMatchType, (conditionsUrl: string) => boolean> = {\n    icontains: (conditionsUrl) =>\n        !!window && window.location.href.toLowerCase().indexOf(conditionsUrl.toLowerCase()) > -1,\n    not_icontains: (conditionsUrl) =>\n        !!window && window.location.href.toLowerCase().indexOf(conditionsUrl.toLowerCase()) === -1,\n    regex: (conditionsUrl) => !!window && isUrlMatchingRegex(window.location.href, conditionsUrl),\n    not_regex: (conditionsUrl) => !!window && !isUrlMatchingRegex(window.location.href, conditionsUrl),\n    exact: (conditionsUrl) => window?.location.href === conditionsUrl,\n    is_not: (conditionsUrl) => window?.location.href !== conditionsUrl,\n}\n\nfunction getRatingBucketForResponseValue(responseValue: number, scale: number) {\n    if (scale === 3) {\n        if (responseValue < 1 || responseValue > 3) {\n            throw new Error('The response must be in range 1-3')\n        }\n\n        return responseValue === 1 ? 'negative' : responseValue === 2 ? 'neutral' : 'positive'\n    } else if (scale === 5) {\n        if (responseValue < 1 || responseValue > 5) {\n            throw new Error('The response must be in range 1-5')\n        }\n\n        return responseValue <= 2 ? 'negative' : responseValue === 3 ? 'neutral' : 'positive'\n    } else if (scale === 10) {\n        if (responseValue < 0 || responseValue > 10) {\n            throw new Error('The response must be in range 0-10')\n        }\n\n        return responseValue <= 6 ? 'detractors' : responseValue <= 8 ? 'passives' : 'promoters'\n    }\n\n    throw new Error('The scale must be one of: 3, 5, 10')\n}\n\nexport class PostHogSurveys {\n    private _decideServerResponse?: boolean\n    public _surveyEventReceiver: SurveyEventReceiver | null\n    private _surveyManager: any\n\n    constructor(private readonly instance: PostHog) {\n        // we set this to undefined here because we need the persistence storage for this type\n        // but that's not initialized until loadIfEnabled is called.\n        this._surveyEventReceiver = null\n    }\n\n    afterDecideResponse(response: DecideResponse) {\n        this._decideServerResponse = !!response['surveys']\n        this.loadIfEnabled()\n    }\n\n    loadIfEnabled() {\n        const surveysGenerator = assignableWindow?.extendPostHogWithSurveys\n\n        if (!this.instance.config.disable_surveys && this._decideServerResponse && !surveysGenerator) {\n            if (this._surveyEventReceiver == null) {\n                this._surveyEventReceiver = new SurveyEventReceiver(this.instance)\n            }\n            this.instance.requestRouter.loadScript('/static/surveys.js', (err) => {\n                if (err) {\n                    return logger.error(LOGGER_PREFIX, 'Could not load surveys script', err)\n                }\n\n                this._surveyManager = assignableWindow.extendPostHogWithSurveys(this.instance)\n            })\n        }\n    }\n\n    getSurveys(callback: SurveyCallback, forceReload = false) {\n        // In case we manage to load the surveys script, but config says not to load surveys\n        // then we shouldn't return survey data\n        if (this.instance.config.disable_surveys) {\n            return callback([])\n        }\n\n        if (this._surveyEventReceiver == null) {\n            this._surveyEventReceiver = new SurveyEventReceiver(this.instance)\n        }\n\n        const existingSurveys = this.instance.get_property(SURVEYS)\n        if (!existingSurveys || forceReload) {\n            this.instance._send_request({\n                url: this.instance.requestRouter.endpointFor(\n                    'api',\n                    `/api/surveys/?token=${this.instance.config.token}`\n                ),\n                method: 'GET',\n                transport: 'XHR',\n                callback: (response) => {\n                    if (response.statusCode !== 200 || !response.json) {\n                        return callback([])\n                    }\n                    const surveys = response.json.surveys || []\n\n                    const eventOrActionBasedSurveys = surveys.filter(\n                        (survey: Survey) =>\n                            (survey.conditions?.events &&\n                                survey.conditions?.events?.values &&\n                                survey.conditions?.events?.values?.length > 0) ||\n                            (survey.conditions?.actions &&\n                                survey.conditions?.actions?.values &&\n                                survey.conditions?.actions?.values?.length > 0)\n                    )\n\n                    if (eventOrActionBasedSurveys.length > 0) {\n                        this._surveyEventReceiver?.register(eventOrActionBasedSurveys)\n                    }\n\n                    this.instance.persistence?.register({ [SURVEYS]: surveys })\n                    return callback(surveys)\n                },\n            })\n        } else {\n            return callback(existingSurveys)\n        }\n    }\n\n    getActiveMatchingSurveys(callback: SurveyCallback, forceReload = false) {\n        this.getSurveys((surveys) => {\n            const activeSurveys = surveys.filter((survey) => {\n                return !!(survey.start_date && !survey.end_date)\n            })\n\n            const conditionMatchedSurveys = activeSurveys.filter((survey) => {\n                if (!survey.conditions) {\n                    return true\n                }\n\n                // use urlMatchType to validate url condition, fallback to contains for backwards compatibility\n                const urlCheck = survey.conditions?.url\n                    ? surveyUrlValidationMap[survey.conditions?.urlMatchType ?? 'icontains'](survey.conditions.url)\n                    : true\n                const selectorCheck = survey.conditions?.selector\n                    ? document?.querySelector(survey.conditions.selector)\n                    : true\n                return urlCheck && selectorCheck\n            })\n\n            // get all the surveys that have been activated so far with user actions.\n            const activatedSurveys: string[] | undefined = this._surveyEventReceiver?.getSurveys()\n            const targetingMatchedSurveys = conditionMatchedSurveys.filter((survey) => {\n                if (!survey.linked_flag_key && !survey.targeting_flag_key && !survey.internal_targeting_flag_key) {\n                    return true\n                }\n                const linkedFlagCheck = survey.linked_flag_key\n                    ? this.instance.featureFlags.isFeatureEnabled(survey.linked_flag_key)\n                    : true\n                const targetingFlagCheck = survey.targeting_flag_key\n                    ? this.instance.featureFlags.isFeatureEnabled(survey.targeting_flag_key)\n                    : true\n\n                const hasEvents =\n                    survey.conditions?.events &&\n                    survey.conditions?.events?.values &&\n                    survey.conditions?.events?.values.length > 0\n\n                const hasActions =\n                    survey.conditions?.actions &&\n                    survey.conditions?.actions?.values &&\n                    survey.conditions?.actions?.values.length > 0\n                const eventBasedTargetingFlagCheck =\n                    hasEvents || hasActions ? activatedSurveys?.includes(survey.id) : true\n\n                const overrideInternalTargetingFlagCheck = this._canActivateRepeatedly(survey)\n                const internalTargetingFlagCheck =\n                    survey.internal_targeting_flag_key && !overrideInternalTargetingFlagCheck\n                        ? this.instance.featureFlags.isFeatureEnabled(survey.internal_targeting_flag_key)\n                        : true\n\n                return (\n                    linkedFlagCheck && targetingFlagCheck && internalTargetingFlagCheck && eventBasedTargetingFlagCheck\n                )\n            })\n\n            return callback(targetingMatchedSurveys)\n        }, forceReload)\n    }\n\n    getNextSurveyStep(survey: Survey, currentQuestionIndex: number, response: string | string[] | number | null) {\n        const question = survey.questions[currentQuestionIndex]\n        const nextQuestionIndex = currentQuestionIndex + 1\n\n        if (!question.branching?.type) {\n            if (currentQuestionIndex === survey.questions.length - 1) {\n                return SurveyQuestionBranchingType.End\n            }\n\n            return nextQuestionIndex\n        }\n\n        if (question.branching.type === SurveyQuestionBranchingType.End) {\n            return SurveyQuestionBranchingType.End\n        } else if (question.branching.type === SurveyQuestionBranchingType.SpecificQuestion) {\n            if (Number.isInteger(question.branching.index)) {\n                return question.branching.index\n            }\n        } else if (question.branching.type === SurveyQuestionBranchingType.ResponseBased) {\n            // Single choice\n            if (question.type === SurveyQuestionType.SingleChoice) {\n                // :KLUDGE: for now, look up the choiceIndex based on the response\n                // TODO: once QuestionTypes.MultipleChoiceQuestion is refactored, pass the selected choiceIndex into this method\n                const selectedChoiceIndex = question.choices.indexOf(`${response}`)\n\n                if (question.branching?.responseValues?.hasOwnProperty(selectedChoiceIndex)) {\n                    const nextStep = question.branching.responseValues[selectedChoiceIndex]\n\n                    // Specific question\n                    if (Number.isInteger(nextStep)) {\n                        return nextStep\n                    }\n\n                    if (nextStep === SurveyQuestionBranchingType.End) {\n                        return SurveyQuestionBranchingType.End\n                    }\n\n                    return nextQuestionIndex\n                }\n            } else if (question.type === SurveyQuestionType.Rating) {\n                if (typeof response !== 'number' || !Number.isInteger(response)) {\n                    throw new Error('The response type must be an integer')\n                }\n\n                const ratingBucket = getRatingBucketForResponseValue(response, question.scale)\n\n                if (question.branching?.responseValues?.hasOwnProperty(ratingBucket)) {\n                    const nextStep = question.branching.responseValues[ratingBucket]\n\n                    // Specific question\n                    if (Number.isInteger(nextStep)) {\n                        return nextStep\n                    }\n\n                    if (nextStep === SurveyQuestionBranchingType.End) {\n                        return SurveyQuestionBranchingType.End\n                    }\n\n                    return nextQuestionIndex\n                }\n            }\n\n            return nextQuestionIndex\n        }\n\n        logger.warn(LOGGER_PREFIX, 'Falling back to next question index due to unexpected branching type')\n        return nextQuestionIndex\n    }\n\n    // this method is lazily loaded onto the window to avoid loading preact and other dependencies if surveys is not enabled\n    private _canActivateRepeatedly(survey: Survey) {\n        if (isNullish(assignableWindow.__PosthogExtensions__.canActivateRepeatedly)) {\n            logger.warn(LOGGER_PREFIX, 'canActivateRepeatedly is not defined, must init before calling')\n        }\n        return assignableWindow.__PosthogExtensions__.canActivateRepeatedly(survey)\n    }\n\n    canRenderSurvey(surveyId: string) {\n        if (isNullish(this._surveyManager)) {\n            logger.warn(LOGGER_PREFIX, 'canActivateRepeatedly is not defined, must init before calling')\n            return\n        }\n        this.getSurveys((surveys) => {\n            const survey = surveys.filter((x) => x.id === surveyId)[0]\n\n            this._surveyManager.canRenderSurvey(survey)\n        })\n    }\n\n    renderSurvey(surveyId: string, selector: string) {\n        if (isNullish(this._surveyManager)) {\n            logger.warn(LOGGER_PREFIX, 'canActivateRepeatedly is not defined, must init before calling')\n            return\n        }\n        this.getSurveys((surveys) => {\n            const survey = surveys.filter((x) => x.id === surveyId)[0]\n\n            this._surveyManager.renderSurvey(survey, document?.querySelector(selector))\n        })\n    }\n}\n","import { CAPTURE_RATE_LIMIT } from './constants'\nimport type { PostHog } from './posthog-core'\nimport { RequestResponse } from './types'\nimport { logger } from './utils/logger'\n\nconst ONE_MINUTE_IN_MILLISECONDS = 60 * 1000\nconst RATE_LIMIT_EVENT = '$$client_ingestion_warning'\n\ninterface CaptureResponse {\n    quota_limited?: string[]\n}\n\nexport class RateLimiter {\n    instance: PostHog\n    serverLimits: Record<string, number> = {}\n\n    captureEventsPerSecond: number\n    captureEventsBurstLimit: number\n    lastEventRateLimited = false\n\n    constructor(instance: PostHog) {\n        this.instance = instance\n\n        this.captureEventsPerSecond = instance.config.rate_limiting?.events_per_second || 10\n        this.captureEventsBurstLimit = Math.max(\n            instance.config.rate_limiting?.events_burst_limit || this.captureEventsPerSecond * 10,\n            this.captureEventsPerSecond\n        )\n\n        this.lastEventRateLimited = this.clientRateLimitContext(true).isRateLimited\n    }\n\n    public clientRateLimitContext(checkOnly = false): {\n        isRateLimited: boolean\n        remainingTokens: number\n    } {\n        // This is primarily to prevent runaway loops from flooding capture with millions of events for a single user.\n        // It's as much for our protection as theirs.\n        const now = new Date().getTime()\n        const bucket = this.instance.persistence?.get_property(CAPTURE_RATE_LIMIT) ?? {\n            tokens: this.captureEventsBurstLimit,\n            last: now,\n        }\n\n        bucket.tokens += ((now - bucket.last) / 1000) * this.captureEventsPerSecond\n        bucket.last = now\n\n        if (bucket.tokens > this.captureEventsBurstLimit) {\n            bucket.tokens = this.captureEventsBurstLimit\n        }\n\n        const isRateLimited = bucket.tokens < 1\n\n        if (!isRateLimited && !checkOnly) {\n            bucket.tokens = Math.max(0, bucket.tokens - 1)\n        }\n\n        if (isRateLimited && !this.lastEventRateLimited && !checkOnly) {\n            this.instance.capture(\n                RATE_LIMIT_EVENT,\n                {\n                    $$client_ingestion_warning_message: `posthog-js client rate limited. Config is set to ${this.captureEventsPerSecond} events per second and ${this.captureEventsBurstLimit} events burst limit.`,\n                },\n                {\n                    skip_client_rate_limiting: true,\n                }\n            )\n        }\n\n        this.lastEventRateLimited = isRateLimited\n        this.instance.persistence?.set_property(CAPTURE_RATE_LIMIT, bucket)\n\n        return {\n            isRateLimited,\n            remainingTokens: bucket.tokens,\n        }\n    }\n\n    public isServerRateLimited(batchKey: string | undefined): boolean {\n        const retryAfter = this.serverLimits[batchKey || 'events'] || false\n\n        if (retryAfter === false) {\n            return false\n        }\n        return new Date().getTime() < retryAfter\n    }\n\n    public checkForLimiting = (httpResponse: RequestResponse): void => {\n        const text = httpResponse.text\n\n        if (!text || !text.length) {\n            return\n        }\n\n        try {\n            const response: CaptureResponse = JSON.parse(text)\n            const quotaLimitedProducts = response.quota_limited || []\n            quotaLimitedProducts.forEach((batchKey) => {\n                logger.info(`[RateLimiter] ${batchKey || 'events'} is quota limited.`)\n                this.serverLimits[batchKey] = new Date().getTime() + ONE_MINUTE_IN_MILLISECONDS\n            })\n        } catch (e: any) {\n            logger.warn(`[RateLimiter] could not rate limit - continuing. Error: \"${e?.message}\"`, { text })\n            return\n        }\n    }\n}\n","/* Client-side session parameters. These are primarily used by web analytics,\n * which relies on these for session analytics without the plugin server being\n * available for the person level set-once properties. Obviously not consistent\n * between client-side events and server-side events but this is acceptable\n * as web analytics only uses client-side.\n *\n * These have the same lifespan as a session_id\n */\nimport { location } from './utils/globals'\nimport { Info } from './utils/event-utils'\nimport { SessionIdManager } from './sessionid'\nimport { PostHogPersistence } from './posthog-persistence'\nimport { CLIENT_SESSION_PROPS } from './constants'\n\ninterface SessionSourceProps {\n    initialPathName: string\n    referringDomain: string // Is actually host, but named domain for internal consistency. Should contain a port if there is one.\n    utm_medium?: string\n    utm_source?: string\n    utm_campaign?: string\n    utm_content?: string\n    utm_term?: string\n}\n\ninterface StoredSessionSourceProps {\n    sessionId: string\n    props: SessionSourceProps\n}\n\nconst generateSessionSourceParams = (): SessionSourceProps => {\n    return {\n        initialPathName: location?.pathname || '',\n        referringDomain: Info.referringDomain(),\n        ...Info.campaignParams(),\n    }\n}\n\nexport class SessionPropsManager {\n    private readonly _sessionIdManager: SessionIdManager\n    private readonly _persistence: PostHogPersistence\n    private readonly _sessionSourceParamGenerator: () => SessionSourceProps\n\n    constructor(\n        sessionIdManager: SessionIdManager,\n        persistence: PostHogPersistence,\n        sessionSourceParamGenerator?: () => SessionSourceProps\n    ) {\n        this._sessionIdManager = sessionIdManager\n        this._persistence = persistence\n        this._sessionSourceParamGenerator = sessionSourceParamGenerator || generateSessionSourceParams\n\n        this._sessionIdManager.onSessionId(this._onSessionIdCallback)\n    }\n\n    _getStoredProps(): StoredSessionSourceProps | undefined {\n        return this._persistence.props[CLIENT_SESSION_PROPS]\n    }\n\n    _onSessionIdCallback = (sessionId: string) => {\n        const stored = this._getStoredProps()\n        if (stored && stored.sessionId === sessionId) {\n            return\n        }\n\n        const newProps: StoredSessionSourceProps = {\n            sessionId,\n            props: this._sessionSourceParamGenerator(),\n        }\n        this._persistence.register({ [CLIENT_SESSION_PROPS]: newProps })\n    }\n\n    getSessionProps() {\n        const p = this._getStoredProps()?.props\n        if (!p) {\n            return {}\n        }\n\n        return {\n            $client_session_initial_referring_host: p.referringDomain,\n            $client_session_initial_pathname: p.initialPathName,\n            $client_session_initial_utm_source: p.utm_source,\n            $client_session_initial_utm_campaign: p.utm_campaign,\n            $client_session_initial_utm_medium: p.utm_medium,\n            $client_session_initial_utm_content: p.utm_content,\n            $client_session_initial_utm_term: p.utm_term,\n        }\n    }\n}\n","export const DEFAULT_BLOCKED_UA_STRS = [\n    'ahrefsbot',\n    'ahrefssiteaudit',\n    'applebot',\n    'baiduspider',\n    'bingbot',\n    'bingpreview',\n    'bot.htm',\n    'bot.php',\n    'crawler',\n    'deepscan',\n    'duckduckbot',\n    'facebookexternal',\n    'facebookcatalog',\n    'gptbot',\n    'http://yandex.com/bots',\n    'hubspot',\n    'ia_archiver',\n    'linkedinbot',\n    'mj12bot',\n    'msnbot',\n    'nessus',\n    'petalbot',\n    'pinterest',\n    'prerender',\n    'rogerbot',\n    'screaming frog',\n    'semrushbot',\n    'sitebulb',\n    'slurp',\n    'turnitin',\n    'twitterbot',\n    'vercelbot',\n    'yahoo! slurp',\n    'yandexbot',\n\n    // headless browsers\n    'headlesschrome',\n    'cypress',\n    // we don't block electron here, as many customers use posthog-js in electron apps\n\n    // a whole bunch of goog-specific crawlers\n    // https://developers.google.com/search/docs/advanced/crawling/overview-google-crawlers\n    'Google-HotelAdsVerifier',\n    'adsbot-google',\n    'apis-google',\n    'duplexweb-google',\n    'feedfetcher-google',\n    'google favicon',\n    'google web preview',\n    'google-read-aloud',\n    'googlebot',\n    'googleweblight',\n    'mediapartners-google',\n    'storebot-google',\n    'Bytespider;',\n]\n\n/**\n * Block various web spiders from executing our JS and sending false capturing data\n */\nexport const isBlockedUA = function (ua: string, customBlockedUserAgents: string[]): boolean {\n    if (!ua) {\n        return false\n    }\n    const uaLower = ua.toLowerCase()\n    return DEFAULT_BLOCKED_UA_STRS.concat(customBlockedUserAgents || []).some((blockedUA) => {\n        const blockedUaLower = blockedUA.toLowerCase()\n\n        // can't use includes because IE 11 :/\n        return uaLower.indexOf(blockedUaLower) !== -1\n    })\n}\n\n// There's more in the type, but this is all we use. It's currently experimental, see\n// https://developer.mozilla.org/en-US/docs/Web/API/Navigator/userAgentData\n// if you're reading this in the future, when it's no longer experimental, please remove this type and use an official one.\n// Be extremely defensive here to ensure backwards and *forwards* compatibility, and remove this defensiveness in the\n// future when it is safe to do so.\nexport interface NavigatorUAData {\n    brands?: {\n        brand: string\n        version: string\n    }[]\n}\ndeclare global {\n    interface Navigator {\n        userAgentData?: NavigatorUAData\n    }\n}\n\nexport const isLikelyBot = function (navigator: Navigator | undefined, customBlockedUserAgents: string[]): boolean {\n    if (!navigator) {\n        return false\n    }\n    const ua = navigator.userAgent\n    if (ua) {\n        if (isBlockedUA(ua, customBlockedUserAgents)) {\n            return true\n        }\n    }\n    try {\n        // eslint-disable-next-line compat/compat\n        const uaData = navigator?.userAgentData as NavigatorUAData\n        if (uaData?.brands && uaData.brands.some((brandObj) => isBlockedUA(brandObj?.brand, customBlockedUserAgents))) {\n            return true\n        }\n    } catch {\n        // ignore the error, we were using experimental browser features\n    }\n\n    return !!navigator.webdriver\n\n    // There's some more enhancements we could make in this area, e.g. it's possible to check if Chrome dev tools are\n    // open, which will detect some bots that are trying to mask themselves and might get past the checks above.\n    // However, this would give false positives for actual humans who have dev tools open.\n\n    // We could also use the data in navigator.userAgentData.getHighEntropyValues() to detect bots, but we should wait\n    // until this stops being experimental. The MDN docs imply that this might eventually require user permission.\n    // See https://developer.mozilla.org/en-US/docs/Web/API/NavigatorUAData/getHighEntropyValues\n    // It would be very bad if posthog-js caused a permission prompt to appear on every page load.\n}\n","// Naive rage click implementation: If mouse has not moved than RAGE_CLICK_THRESHOLD_PX\n// over RAGE_CLICK_CLICK_COUNT clicks with max RAGE_CLICK_TIMEOUT_MS between clicks, it's\n// counted as a rage click\n\nconst RAGE_CLICK_THRESHOLD_PX = 30\nconst RAGE_CLICK_TIMEOUT_MS = 1000\nconst RAGE_CLICK_CLICK_COUNT = 3\n\nexport default class RageClick {\n    clicks: { x: number; y: number; timestamp: number }[]\n\n    constructor() {\n        this.clicks = []\n    }\n\n    isRageClick(x: number, y: number, timestamp: number): boolean {\n        const lastClick = this.clicks[this.clicks.length - 1]\n        if (\n            lastClick &&\n            Math.abs(x - lastClick.x) + Math.abs(y - lastClick.y) < RAGE_CLICK_THRESHOLD_PX &&\n            timestamp - lastClick.timestamp < RAGE_CLICK_TIMEOUT_MS\n        ) {\n            this.clicks.push({ x, y, timestamp })\n\n            if (this.clicks.length === RAGE_CLICK_CLICK_COUNT) {\n                return true\n            }\n        } else {\n            this.clicks = [{ x, y, timestamp }]\n        }\n\n        return false\n    }\n}\n","import { includes, registerEvent } from './utils'\nimport RageClick from './extensions/rageclick'\nimport { DecideResponse, Properties } from './types'\nimport { PostHog } from './posthog-core'\n\nimport { document, window } from './utils/globals'\nimport { getParentElement, isTag } from './autocapture-utils'\nimport { HEATMAPS_ENABLED_SERVER_SIDE, TOOLBAR_ID } from './constants'\nimport { isEmptyObject, isObject, isUndefined } from './utils/type-utils'\nimport { logger } from './utils/logger'\n\nconst DEFAULT_FLUSH_INTERVAL = 5000\nconst HEATMAPS = 'heatmaps'\nconst LOGGER_PREFIX = '[' + HEATMAPS + ']'\n\ntype HeatmapEventBuffer =\n    | {\n          [key: string]: Properties[]\n      }\n    | undefined\n\nfunction elementOrParentPositionMatches(el: Element, matches: string[], breakOnElement?: Element): boolean {\n    let curEl: Element | false = el\n\n    while (curEl && !isTag(curEl, 'body')) {\n        if (curEl === breakOnElement) {\n            return false\n        }\n\n        if (includes(matches, window?.getComputedStyle(curEl).position)) {\n            return true\n        }\n\n        curEl = getParentElement(curEl)\n    }\n\n    return false\n}\n\nfunction elementInToolbar(el: Element): boolean {\n    // NOTE: .closest is not supported in IE11 hence the operator check\n    return el.id === TOOLBAR_ID || !!el.closest?.('#' + TOOLBAR_ID)\n}\n\nexport class Heatmaps {\n    instance: PostHog\n    rageclicks = new RageClick()\n    _enabledServerSide: boolean = false\n    _initialized = false\n    _mouseMoveTimeout: ReturnType<typeof setTimeout> | undefined\n\n    // TODO: Periodically flush this if no other event has taken care of it\n    private buffer: HeatmapEventBuffer\n    private _flushInterval: number | null = null\n\n    constructor(instance: PostHog) {\n        this.instance = instance\n        this._enabledServerSide = !!this.instance.persistence?.props[HEATMAPS_ENABLED_SERVER_SIDE]\n\n        window?.addEventListener('beforeunload', () => {\n            this.flush()\n        })\n    }\n\n    public get flushIntervalMilliseconds(): number {\n        let flushInterval = DEFAULT_FLUSH_INTERVAL\n        if (\n            isObject(this.instance.config.capture_heatmaps) &&\n            this.instance.config.capture_heatmaps.flush_interval_milliseconds\n        ) {\n            flushInterval = this.instance.config.capture_heatmaps.flush_interval_milliseconds\n        }\n        return flushInterval\n    }\n\n    public get isEnabled(): boolean {\n        if (!isUndefined(this.instance.config.capture_heatmaps)) {\n            return this.instance.config.capture_heatmaps !== false\n        }\n        if (!isUndefined(this.instance.config.enable_heatmaps)) {\n            return this.instance.config.enable_heatmaps\n        }\n        return this._enabledServerSide\n    }\n\n    public startIfEnabled(): void {\n        if (this.isEnabled) {\n            // nested if here since we only want to run the else\n            // if this.enabled === false\n            // not if this method is called more than once\n            if (this._initialized) {\n                return\n            }\n            logger.info(LOGGER_PREFIX + ' starting...')\n            this._setupListeners()\n            this._flushInterval = setInterval(this.flush.bind(this), this.flushIntervalMilliseconds)\n        } else {\n            clearInterval(this._flushInterval ?? undefined)\n            this.getAndClearBuffer()\n        }\n    }\n\n    public afterDecideResponse(response: DecideResponse) {\n        const optIn = !!response['heatmaps']\n\n        if (this.instance.persistence) {\n            this.instance.persistence.register({\n                [HEATMAPS_ENABLED_SERVER_SIDE]: optIn,\n            })\n        }\n        // store this in-memory in case persistence is disabled\n        this._enabledServerSide = optIn\n        this.startIfEnabled()\n    }\n\n    public getAndClearBuffer(): HeatmapEventBuffer {\n        const buffer = this.buffer\n        this.buffer = undefined\n        return buffer\n    }\n\n    private _setupListeners(): void {\n        if (!window || !document) {\n            return\n        }\n\n        registerEvent(document, 'click', (e) => this._onClick((e || window?.event) as MouseEvent), false, true)\n        registerEvent(document, 'mousemove', (e) => this._onMouseMove((e || window?.event) as MouseEvent), false, true)\n\n        this._initialized = true\n    }\n\n    private _getProperties(e: MouseEvent, type: string): Properties {\n        // We need to know if the target element is fixed or not\n        // If fixed then we won't account for scrolling\n        // If not then we will account for scrolling\n\n        const scrollY = this.instance.scrollManager.scrollY()\n        const scrollX = this.instance.scrollManager.scrollX()\n        const scrollElement = this.instance.scrollManager.scrollElement()\n\n        const isFixedOrSticky = elementOrParentPositionMatches(e.target as Element, ['fixed', 'sticky'], scrollElement)\n\n        return {\n            x: e.clientX + (isFixedOrSticky ? 0 : scrollX),\n            y: e.clientY + (isFixedOrSticky ? 0 : scrollY),\n            target_fixed: isFixedOrSticky,\n            type,\n        }\n    }\n\n    private _onClick(e: MouseEvent): void {\n        if (elementInToolbar(e.target as Element)) {\n            return\n        }\n        const properties = this._getProperties(e, 'click')\n\n        if (this.rageclicks?.isRageClick(e.clientX, e.clientY, new Date().getTime())) {\n            this._capture({\n                ...properties,\n                type: 'rageclick',\n            })\n        }\n\n        // TODO: Detect deadclicks\n\n        this._capture(properties)\n    }\n\n    private _onMouseMove(e: Event): void {\n        if (elementInToolbar(e.target as Element)) {\n            return\n        }\n        clearTimeout(this._mouseMoveTimeout)\n\n        this._mouseMoveTimeout = setTimeout(() => {\n            this._capture(this._getProperties(e as MouseEvent, 'mousemove'))\n        }, 500)\n    }\n\n    private _capture(properties: Properties): void {\n        if (!window) {\n            return\n        }\n\n        // TODO we should be able to mask this\n        const url = window.location.href\n\n        this.buffer = this.buffer || {}\n\n        if (!this.buffer[url]) {\n            this.buffer[url] = []\n        }\n\n        this.buffer[url].push(properties)\n    }\n\n    private flush(): void {\n        if (!this.buffer || isEmptyObject(this.buffer)) {\n            return\n        }\n\n        this.instance.capture('$$heatmap', {\n            $heatmap_data: this.getAndClearBuffer(),\n        })\n    }\n}\n","import { window } from './utils/globals'\nimport { PostHog } from './posthog-core'\nimport { isArray } from './utils/type-utils'\n\nexport interface ScrollContext {\n    // scroll is how far down the page the user has scrolled,\n    // content is how far down the page the user can view content\n    // (e.g. if the page is 1000 tall, but the user's screen is only 500 tall,\n    // and they don't scroll at all, then scroll is 0 and content is 500)\n    maxScrollHeight?: number\n    maxScrollY?: number\n    lastScrollY?: number\n    maxContentHeight?: number\n    maxContentY?: number\n    lastContentY?: number\n}\n\n// This class is responsible for tracking scroll events and maintaining the scroll context\nexport class ScrollManager {\n    private context: ScrollContext | undefined\n\n    constructor(private instance: PostHog) {}\n\n    getContext(): ScrollContext | undefined {\n        return this.context\n    }\n\n    resetContext(): ScrollContext | undefined {\n        const ctx = this.context\n\n        // update the scroll properties for the new page, but wait until the next tick\n        // of the event loop\n        setTimeout(this._updateScrollData, 0)\n\n        return ctx\n    }\n\n    private _updateScrollData = () => {\n        if (!this.context) {\n            this.context = {}\n        }\n\n        const el = this.scrollElement()\n\n        const scrollY = this.scrollY()\n        const scrollHeight = el ? Math.max(0, el.scrollHeight - el.clientHeight) : 0\n        const contentY = scrollY + (el?.clientHeight || 0)\n        const contentHeight = el?.scrollHeight || 0\n\n        this.context.lastScrollY = Math.ceil(scrollY)\n        this.context.maxScrollY = Math.max(scrollY, this.context.maxScrollY ?? 0)\n        this.context.maxScrollHeight = Math.max(scrollHeight, this.context.maxScrollHeight ?? 0)\n\n        this.context.lastContentY = contentY\n        this.context.maxContentY = Math.max(contentY, this.context.maxContentY ?? 0)\n        this.context.maxContentHeight = Math.max(contentHeight, this.context.maxContentHeight ?? 0)\n    }\n\n    startMeasuringScrollPosition() {\n        // setting the third argument to `true` means that we will receive scroll events for other scrollable elements\n        // on the page, not just the window\n        // see https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#usecapture\n        window?.addEventListener('scroll', this._updateScrollData, true)\n        window?.addEventListener('scrollend', this._updateScrollData, true)\n        window?.addEventListener('resize', this._updateScrollData)\n    }\n\n    public scrollElement(): Element | undefined {\n        if (this.instance.config.scroll_root_selector) {\n            const selectors = isArray(this.instance.config.scroll_root_selector)\n                ? this.instance.config.scroll_root_selector\n                : [this.instance.config.scroll_root_selector]\n            for (const selector of selectors) {\n                const element = window?.document.querySelector(selector)\n                if (element) {\n                    return element\n                }\n            }\n            return undefined\n        } else {\n            return window?.document.documentElement\n        }\n    }\n\n    public scrollY(): number {\n        if (this.instance.config.scroll_root_selector) {\n            const element = this.scrollElement()\n            return (element && element.scrollTop) || 0\n        } else {\n            return window ? window.scrollY || window.pageYOffset || window.document.documentElement.scrollTop || 0 : 0\n        }\n    }\n\n    public scrollX(): number {\n        if (this.instance.config.scroll_root_selector) {\n            const element = this.scrollElement()\n            return (element && element.scrollLeft) || 0\n        } else {\n            return window ? window.scrollX || window.pageXOffset || window.document.documentElement.scrollLeft || 0 : 0\n        }\n    }\n}\n","import { each, extend, includes, registerEvent } from './utils'\nimport {\n    autocaptureCompatibleElements,\n    getClassNames,\n    getDirectAndNestedSpanText,\n    getElementsChainString,\n    getSafeText,\n    isAngularStyleAttr,\n    isDocumentFragment,\n    isElementNode,\n    isSensitiveElement,\n    isTag,\n    isTextNode,\n    makeSafeText,\n    shouldCaptureDomEvent,\n    shouldCaptureElement,\n    shouldCaptureValue,\n    splitClassString,\n} from './autocapture-utils'\nimport RageClick from './extensions/rageclick'\nimport { AutocaptureConfig, DecideResponse, Properties } from './types'\nimport { PostHog } from './posthog-core'\nimport { AUTOCAPTURE_DISABLED_SERVER_SIDE } from './constants'\n\nimport { isBoolean, isFunction, isNull, isObject, isUndefined } from './utils/type-utils'\nimport { logger } from './utils/logger'\nimport { document, window } from './utils/globals'\nimport { convertToURL } from './utils/request-utils'\n\nconst COPY_AUTOCAPTURE_EVENT = '$copy_autocapture'\n\nfunction limitText(length: number, text: string): string {\n    if (text.length > length) {\n        return text.slice(0, length) + '...'\n    }\n    return text\n}\n\nexport class Autocapture {\n    instance: PostHog\n    _initialized: boolean = false\n    _isDisabledServerSide: boolean | null = null\n    _elementSelectors: Set<string> | null\n    rageclicks = new RageClick()\n    _elementsChainAsString = false\n\n    constructor(instance: PostHog) {\n        this.instance = instance\n        this._elementSelectors = null\n    }\n\n    private get config(): AutocaptureConfig {\n        const config = isObject(this.instance.config.autocapture) ? this.instance.config.autocapture : {}\n        // precompile the regex\n        config.url_allowlist = config.url_allowlist?.map((url) => new RegExp(url))\n        config.url_ignorelist = config.url_ignorelist?.map((url) => new RegExp(url))\n        return config\n    }\n\n    _addDomEventHandlers(): void {\n        if (!this.isBrowserSupported()) {\n            logger.info('Disabling Automatic Event Collection because this browser is not supported')\n            return\n        }\n\n        if (!window || !document) {\n            return\n        }\n        const handler = (e: Event) => {\n            e = e || window?.event\n            try {\n                this._captureEvent(e)\n            } catch (error) {\n                logger.error('Failed to capture event', error)\n            }\n        }\n\n        const copiedTextHandler = (e: Event) => {\n            e = e || window?.event\n            this._captureEvent(e, COPY_AUTOCAPTURE_EVENT)\n        }\n\n        registerEvent(document, 'submit', handler, false, true)\n        registerEvent(document, 'change', handler, false, true)\n        registerEvent(document, 'click', handler, false, true)\n\n        if (this.config.capture_copied_text) {\n            registerEvent(document, 'copy', copiedTextHandler, false, true)\n            registerEvent(document, 'cut', copiedTextHandler, false, true)\n        }\n    }\n\n    public startIfEnabled() {\n        if (this.isEnabled && !this._initialized) {\n            this._addDomEventHandlers()\n            this._initialized = true\n        }\n    }\n\n    public afterDecideResponse(response: DecideResponse) {\n        if (response.elementsChainAsString) {\n            this._elementsChainAsString = response.elementsChainAsString\n        }\n\n        if (this.instance.persistence) {\n            this.instance.persistence.register({\n                [AUTOCAPTURE_DISABLED_SERVER_SIDE]: !!response['autocapture_opt_out'],\n            })\n        }\n        // store this in-memory in case persistence is disabled\n        this._isDisabledServerSide = !!response['autocapture_opt_out']\n        this.startIfEnabled()\n    }\n\n    public setElementSelectors(selectors: Set<string>): void {\n        this._elementSelectors = selectors\n    }\n\n    public getElementSelectors(element: Element | null): string[] | null {\n        const elementSelectors: string[] = []\n\n        this._elementSelectors?.forEach((selector) => {\n            const matchedElements = document?.querySelectorAll(selector)\n            matchedElements?.forEach((matchedElement: Element) => {\n                if (element === matchedElement) {\n                    elementSelectors.push(selector)\n                }\n            })\n        })\n\n        return elementSelectors\n    }\n\n    public get isEnabled(): boolean {\n        const persistedServerDisabled = this.instance.persistence?.props[AUTOCAPTURE_DISABLED_SERVER_SIDE]\n        const memoryDisabled = this._isDisabledServerSide\n\n        if (\n            isNull(memoryDisabled) &&\n            !isBoolean(persistedServerDisabled) &&\n            !this.instance.config.advanced_disable_decide\n        ) {\n            // We only enable if we know that the server has not disabled it (unless decide is disabled)\n            return false\n        }\n\n        const disabledServer = this._isDisabledServerSide ?? !!persistedServerDisabled\n        const disabledClient = !this.instance.config.autocapture\n        return !disabledClient && !disabledServer\n    }\n\n    private _previousElementSibling(el: Element): Element | null {\n        if (el.previousElementSibling) {\n            return el.previousElementSibling\n        }\n        let _el: Element | null = el\n        do {\n            _el = _el.previousSibling as Element | null // resolves to ChildNode->Node, which is Element's parent class\n        } while (_el && !isElementNode(_el))\n        return _el\n    }\n\n    private _getAugmentPropertiesFromElement(elem: Element): Properties {\n        const shouldCaptureEl = shouldCaptureElement(elem)\n        if (!shouldCaptureEl) {\n            return {}\n        }\n\n        const props: Properties = {}\n\n        each(elem.attributes, function (attr: Attr) {\n            if (attr.name && attr.name.indexOf('data-ph-capture-attribute') === 0) {\n                const propertyKey = attr.name.replace('data-ph-capture-attribute-', '')\n                const propertyValue = attr.value\n                if (propertyKey && propertyValue && shouldCaptureValue(propertyValue)) {\n                    props[propertyKey] = propertyValue\n                }\n            }\n        })\n\n        return props\n    }\n\n    private _getPropertiesFromElement(elem: Element, maskInputs: boolean, maskText: boolean): Properties {\n        const tag_name = elem.tagName.toLowerCase()\n        const props: Properties = {\n            tag_name: tag_name,\n        }\n        if (autocaptureCompatibleElements.indexOf(tag_name) > -1 && !maskText) {\n            if (tag_name.toLowerCase() === 'a' || tag_name.toLowerCase() === 'button') {\n                props['$el_text'] = limitText(1024, getDirectAndNestedSpanText(elem))\n            } else {\n                props['$el_text'] = limitText(1024, getSafeText(elem))\n            }\n        }\n\n        const classes = getClassNames(elem)\n        if (classes.length > 0)\n            props['classes'] = classes.filter(function (c) {\n                return c !== ''\n            })\n\n        // capture the deny list here because this not-a-class class makes it tricky to use this.config in the function below\n        const elementAttributeIgnorelist = this.config?.element_attribute_ignorelist\n        each(elem.attributes, function (attr: Attr) {\n            // Only capture attributes we know are safe\n            if (isSensitiveElement(elem) && ['name', 'id', 'class', 'aria-label'].indexOf(attr.name) === -1) return\n\n            if (elementAttributeIgnorelist?.includes(attr.name)) return\n\n            if (!maskInputs && shouldCaptureValue(attr.value) && !isAngularStyleAttr(attr.name)) {\n                let value = attr.value\n                if (attr.name === 'class') {\n                    // html attributes can _technically_ contain linebreaks,\n                    // but we're very intolerant of them in the class string,\n                    // so we strip them.\n                    value = splitClassString(value).join(' ')\n                }\n                props['attr__' + attr.name] = limitText(1024, value)\n            }\n        })\n\n        let nthChild = 1\n        let nthOfType = 1\n        let currentElem: Element | null = elem\n        while ((currentElem = this._previousElementSibling(currentElem))) {\n            // eslint-disable-line no-cond-assign\n            nthChild++\n            if (currentElem.tagName === elem.tagName) {\n                nthOfType++\n            }\n        }\n        props['nth_child'] = nthChild\n        props['nth_of_type'] = nthOfType\n\n        return props\n    }\n\n    private _getDefaultProperties(eventType: string): Properties {\n        return {\n            $event_type: eventType,\n            $ce_version: 1,\n        }\n    }\n\n    private _getEventTarget(e: Event): Element | null {\n        // https://developer.mozilla.org/en-US/docs/Web/API/Event/target#Compatibility_notes\n        if (isUndefined(e.target)) {\n            return (e.srcElement as Element) || null\n        } else {\n            if ((e.target as HTMLElement)?.shadowRoot) {\n                return (e.composedPath()[0] as Element) || null\n            }\n            return (e.target as Element) || null\n        }\n    }\n\n    private _captureEvent(e: Event, eventName = '$autocapture'): boolean | void {\n        if (!this.isEnabled) {\n            return\n        }\n\n        /*** Don't mess with this code without running IE8 tests on it ***/\n        let target = this._getEventTarget(e)\n        if (isTextNode(target)) {\n            // defeat Safari bug (see: http://www.quirksmode.org/js/events_properties.html)\n            target = (target.parentNode || null) as Element | null\n        }\n\n        if (eventName === '$autocapture' && e.type === 'click' && e instanceof MouseEvent) {\n            if (\n                this.instance.config.rageclick &&\n                this.rageclicks?.isRageClick(e.clientX, e.clientY, new Date().getTime())\n            ) {\n                this._captureEvent(e, '$rageclick')\n            }\n        }\n\n        const isCopyAutocapture = eventName === COPY_AUTOCAPTURE_EVENT\n        if (\n            target &&\n            shouldCaptureDomEvent(\n                target,\n                e,\n                this.config,\n                // mostly this method cares about the target element, but in the case of copy events,\n                // we want some of the work this check does without insisting on the target element's type\n                isCopyAutocapture,\n                // we also don't want to restrict copy checks to clicks,\n                // so we pass that knowledge in here, rather than add the logic inside the check\n                isCopyAutocapture ? ['copy', 'cut'] : undefined\n            )\n        ) {\n            const targetElementList = [target]\n            let curEl = target\n            while (curEl.parentNode && !isTag(curEl, 'body')) {\n                if (isDocumentFragment(curEl.parentNode)) {\n                    targetElementList.push((curEl.parentNode as any).host)\n                    curEl = (curEl.parentNode as any).host\n                    continue\n                }\n                targetElementList.push(curEl.parentNode as Element)\n                curEl = curEl.parentNode as Element\n            }\n\n            const elementsJson: Properties[] = []\n            const autocaptureAugmentProperties: Properties = {}\n            let href,\n                explicitNoCapture = false\n\n            each(targetElementList, (el) => {\n                const shouldCaptureEl = shouldCaptureElement(el)\n\n                // if the element or a parent element is an anchor tag\n                // include the href as a property\n                if (el.tagName.toLowerCase() === 'a') {\n                    href = el.getAttribute('href')\n                    href = shouldCaptureEl && shouldCaptureValue(href) && href\n                }\n\n                // allow users to programmatically prevent capturing of elements by adding class 'ph-no-capture'\n                const classes = getClassNames(el)\n                if (includes(classes, 'ph-no-capture')) {\n                    explicitNoCapture = true\n                }\n\n                elementsJson.push(\n                    this._getPropertiesFromElement(\n                        el,\n                        this.instance.config.mask_all_element_attributes,\n                        this.instance.config.mask_all_text\n                    )\n                )\n\n                const augmentProperties = this._getAugmentPropertiesFromElement(el)\n                extend(autocaptureAugmentProperties, augmentProperties)\n            })\n\n            if (!this.instance.config.mask_all_text) {\n                // if the element is a button or anchor tag get the span text from any\n                // children and include it as/with the text property on the parent element\n                if (target.tagName.toLowerCase() === 'a' || target.tagName.toLowerCase() === 'button') {\n                    elementsJson[0]['$el_text'] = getDirectAndNestedSpanText(target)\n                } else {\n                    elementsJson[0]['$el_text'] = getSafeText(target)\n                }\n            }\n\n            let externalHref: string | undefined\n            if (href) {\n                elementsJson[0]['attr__href'] = href\n                const hrefHost = convertToURL(href)?.host\n                const locationHost = window?.location?.host\n                if (hrefHost && locationHost && hrefHost !== locationHost) {\n                    externalHref = href\n                }\n            }\n\n            if (explicitNoCapture) {\n                return false\n            }\n\n            const props = extend(\n                this._getDefaultProperties(e.type),\n                this._elementsChainAsString\n                    ? {\n                          $elements_chain: getElementsChainString(elementsJson),\n                      }\n                    : {\n                          $elements: elementsJson,\n                      },\n                elementsJson[0]?.['$el_text'] ? { $el_text: elementsJson[0]?.['$el_text'] } : {},\n                externalHref && e.type === 'click' ? { $external_click_url: externalHref } : {},\n                autocaptureAugmentProperties\n            )\n\n            const elementSelectors = this.getElementSelectors(target)\n            if (elementSelectors && elementSelectors.length > 0) {\n                props['$element_selectors'] = elementSelectors\n            }\n\n            if (eventName === COPY_AUTOCAPTURE_EVENT) {\n                // you can't read the data from the clipboard event,\n                // but you can guess that you can read it from the window's current selection\n                const selectedContent = makeSafeText(window?.getSelection()?.toString())\n                const clipType = (e as ClipboardEvent).type || 'clipboard'\n                if (!selectedContent) {\n                    return false\n                }\n                props['$selected_content'] = selectedContent\n                props['$copy_type'] = clipType\n            }\n\n            this.instance.capture(eventName, props)\n            return true\n        }\n    }\n\n    isBrowserSupported(): boolean {\n        return isFunction(document?.querySelectorAll)\n    }\n}\n","import { PostHog } from './posthog-core'\nimport { find, includes } from './utils'\nimport { assignableWindow, navigator } from './utils/globals'\nimport { cookieStore, localStore } from './storage'\nimport { PersistentStore } from './types'\n\nconst OPT_OUT_PREFIX = '__ph_opt_in_out_'\n\nexport enum ConsentStatus {\n    PENDING = -1,\n    DENIED = 0,\n    GRANTED = 1,\n}\n\n/**\n * ConsentManager provides tools for managing user consent as configured by the application.\n */\nexport class ConsentManager {\n    private _storage?: PersistentStore\n\n    constructor(private instance: PostHog) {}\n\n    private get config() {\n        return this.instance.config\n    }\n\n    public get consent(): ConsentStatus {\n        if (this.getDnt()) {\n            return ConsentStatus.DENIED\n        }\n\n        return this.storedConsent\n    }\n\n    public isOptedOut() {\n        return (\n            this.consent === ConsentStatus.DENIED ||\n            (this.consent === ConsentStatus.PENDING && this.config.opt_out_capturing_by_default)\n        )\n    }\n\n    public isOptedIn() {\n        return !this.isOptedOut()\n    }\n\n    public optInOut(isOptedIn: boolean) {\n        this.storage.set(\n            this.storageKey,\n            isOptedIn ? 1 : 0,\n            this.config.cookie_expiration,\n            this.config.cross_subdomain_cookie,\n            this.config.secure_cookie\n        )\n    }\n\n    public reset() {\n        this.storage.remove(this.storageKey, this.config.cross_subdomain_cookie)\n    }\n\n    private get storageKey() {\n        const { token, opt_out_capturing_cookie_prefix } = this.instance.config\n        return (opt_out_capturing_cookie_prefix || OPT_OUT_PREFIX) + token\n    }\n\n    private get storedConsent(): ConsentStatus {\n        const value = this.storage.get(this.storageKey)\n        return value === '1' ? ConsentStatus.GRANTED : value === '0' ? ConsentStatus.DENIED : ConsentStatus.PENDING\n    }\n\n    private get storage() {\n        if (!this._storage) {\n            const persistenceType = this.config.opt_out_capturing_persistence_type\n            this._storage = persistenceType === 'localStorage' ? localStore : cookieStore\n            const otherStorage = persistenceType === 'localStorage' ? cookieStore : localStore\n\n            if (otherStorage.get(this.storageKey)) {\n                if (!this._storage.get(this.storageKey)) {\n                    // This indicates we have moved to a new storage format so we migrate the value over\n                    this.optInOut(otherStorage.get(this.storageKey) === '1')\n                }\n\n                otherStorage.remove(this.storageKey, this.config.cross_subdomain_cookie)\n            }\n        }\n\n        return this._storage\n    }\n\n    private getDnt(): boolean {\n        if (!this.config.respect_dnt) {\n            return false\n        }\n        return !!find(\n            [\n                navigator?.doNotTrack, // standard\n                (navigator as any)?.['msDoNotTrack'],\n                assignableWindow['doNotTrack'],\n            ],\n            (dntValue): boolean => {\n                return includes([true, 1, '1', 'yes'], dntValue)\n            }\n        )\n    }\n}\n","import { PostHog } from '../posthog-core'\nimport { assignableWindow } from '../utils/globals'\nimport { logger } from '../utils/logger'\nimport Config from '../config'\nimport { isUndefined } from '../utils/type-utils'\n\nconst LOGGER_PREFIX = '[TRACING-HEADERS]'\n\nexport class TracingHeaders {\n    private _restoreXHRPatch: (() => void) | undefined = undefined\n    private _restoreFetchPatch: (() => void) | undefined = undefined\n\n    constructor(private readonly instance: PostHog) {}\n\n    private _loadScript(cb: () => void): void {\n        if (assignableWindow.postHogTracingHeadersPatchFns) {\n            // already loaded\n            cb()\n        }\n\n        this.instance.requestRouter.loadScript(`/static/tracing-headers.js?v=${Config.LIB_VERSION}`, (err) => {\n            if (err) {\n                return logger.error(LOGGER_PREFIX + ' failed to load script', err)\n            }\n            cb()\n        })\n    }\n    public startIfEnabledOrStop() {\n        if (this.instance.config.__add_tracing_headers) {\n            this._loadScript(this._startCapturing)\n        } else {\n            this._restoreXHRPatch?.()\n            this._restoreFetchPatch?.()\n            // we don't want to call these twice so we reset them\n            this._restoreXHRPatch = undefined\n            this._restoreFetchPatch = undefined\n        }\n    }\n\n    private _startCapturing = () => {\n        // NB: we can assert sessionManager is present only because we've checked previously\n        if (isUndefined(this._restoreXHRPatch)) {\n            assignableWindow.postHogTracingHeadersPatchFns._patchXHR(this.instance.sessionManager!)\n        }\n        if (isUndefined(this._restoreFetchPatch)) {\n            assignableWindow.postHogTracingHeadersPatchFns._patchFetch(this.instance.sessionManager!)\n        }\n    }\n}\n","import { PostHog } from '../../posthog-core'\nimport { DecideResponse } from '../../types'\nimport { logger } from '../../utils/logger'\nimport { isBoolean, isNullish, isNumber, isObject, isUndefined } from '../../utils/type-utils'\nimport { WEB_VITALS_ENABLED_SERVER_SIDE } from '../../constants'\nimport { assignableWindow, window } from '../../utils/globals'\nimport Config from '../../config'\n\nexport const FLUSH_TO_CAPTURE_TIMEOUT_MILLISECONDS = 8000\nconst ONE_MINUTE_IN_MILLIS = 60 * 1000\nexport const FIFTEEN_MINUTES_IN_MILLIS = 15 * ONE_MINUTE_IN_MILLIS\n\nconst LOGGER_PREFIX = '[Web Vitals]'\ntype WebVitalsEventBuffer = { url: string | undefined; metrics: any[]; firstMetricTimestamp: number | undefined }\n\nexport class WebVitalsAutocapture {\n    private _enabledServerSide: boolean = false\n    private _initialized = false\n\n    private buffer: WebVitalsEventBuffer = { url: undefined, metrics: [], firstMetricTimestamp: undefined }\n    private _delayedFlushTimer: number | undefined\n\n    constructor(private readonly instance: PostHog) {\n        this._enabledServerSide = !!this.instance.persistence?.props[WEB_VITALS_ENABLED_SERVER_SIDE]\n        this.startIfEnabled()\n    }\n\n    public get _maxAllowedValue(): number {\n        const configured =\n            isObject(this.instance.config.capture_performance) &&\n            isNumber(this.instance.config.capture_performance.__web_vitals_max_value)\n                ? this.instance.config.capture_performance.__web_vitals_max_value\n                : FIFTEEN_MINUTES_IN_MILLIS\n        // you can set to 0 to disable the check or any value over ten seconds\n        // 1 milli to 1 minute will be set to 15 minutes, cos that would be a silly low maximum\n        return 0 < configured && configured <= ONE_MINUTE_IN_MILLIS ? FIFTEEN_MINUTES_IN_MILLIS : configured\n    }\n\n    public get isEnabled(): boolean {\n        const clientConfig = isObject(this.instance.config.capture_performance)\n            ? this.instance.config.capture_performance.web_vitals\n            : undefined\n        return isBoolean(clientConfig) ? clientConfig : this._enabledServerSide\n    }\n\n    public startIfEnabled(): void {\n        if (this.isEnabled && !this._initialized) {\n            logger.info(LOGGER_PREFIX + ' enabled, starting...')\n            this.loadScript(this._startCapturing)\n        }\n    }\n\n    public afterDecideResponse(response: DecideResponse) {\n        const webVitalsOptIn = isObject(response.capturePerformance) && !!response.capturePerformance.web_vitals\n\n        if (this.instance.persistence) {\n            this.instance.persistence.register({\n                [WEB_VITALS_ENABLED_SERVER_SIDE]: webVitalsOptIn,\n            })\n        }\n        // store this in-memory in case persistence is disabled\n        this._enabledServerSide = webVitalsOptIn\n\n        this.startIfEnabled()\n    }\n\n    private loadScript(cb: () => void): void {\n        if ((window as any).postHogWebVitalsCallbacks) {\n            // already loaded\n            cb()\n        }\n\n        this.instance.requestRouter.loadScript(`/static/web-vitals.js?v=${Config.LIB_VERSION}`, (err) => {\n            if (err) {\n                logger.error(LOGGER_PREFIX + ' failed to load script', err)\n                return\n            }\n            cb()\n        })\n    }\n\n    private _currentURL(): string | undefined {\n        // TODO you should be able to mask the URL here\n        const href = window ? window.location.href : undefined\n        if (!href) {\n            logger.error(LOGGER_PREFIX + 'Could not determine current URL')\n        }\n        return href\n    }\n\n    private _flushToCapture = () => {\n        clearTimeout(this._delayedFlushTimer)\n        if (this.buffer.metrics.length === 0) {\n            return\n        }\n\n        this.instance.capture(\n            '$web_vitals',\n            this.buffer.metrics.reduce(\n                (acc, metric) => ({\n                    ...acc,\n                    // the entire event so we can use it in the future e.g. includes google's rating\n                    [`$web_vitals_${metric.name}_event`]: { ...metric },\n                    [`$web_vitals_${metric.name}_value`]: metric.value,\n                }),\n                {}\n            )\n        )\n        this.buffer = { url: undefined, metrics: [], firstMetricTimestamp: undefined }\n    }\n\n    private _addToBuffer = (metric: any) => {\n        const sessionIds = this.instance.sessionManager?.checkAndGetSessionAndWindowId(true)\n        if (isUndefined(sessionIds)) {\n            logger.error(LOGGER_PREFIX + 'Could not read session ID. Dropping metrics!')\n            return\n        }\n\n        this.buffer = this.buffer || { url: undefined, metrics: [], firstMetricTimestamp: undefined }\n\n        const $currentUrl = this._currentURL()\n        if (isUndefined($currentUrl)) {\n            return\n        }\n\n        if (isNullish(metric?.name) || isNullish(metric?.value)) {\n            logger.error(LOGGER_PREFIX + 'Invalid metric received', metric)\n            return\n        }\n\n        // we observe some very large values sometimes, we'll ignore them\n        // since the likelihood of LCP > 1 hour being correct is very low\n        if (this._maxAllowedValue && metric.value >= this._maxAllowedValue) {\n            logger.error(LOGGER_PREFIX + 'Ignoring metric with value >= ' + this._maxAllowedValue, metric)\n            return\n        }\n\n        const urlHasChanged = this.buffer.url !== $currentUrl\n\n        if (urlHasChanged) {\n            // we need to send what we have\n            this._flushToCapture()\n            // poor performance is >4s, we wait twice that time to send\n            // this is in case we haven't received all metrics\n            // we'll at least gather some\n            this._delayedFlushTimer = setTimeout(this._flushToCapture, FLUSH_TO_CAPTURE_TIMEOUT_MILLISECONDS)\n        }\n\n        if (isUndefined(this.buffer.url)) {\n            this.buffer.url = $currentUrl\n        }\n\n        this.buffer.firstMetricTimestamp = isUndefined(this.buffer.firstMetricTimestamp)\n            ? Date.now()\n            : this.buffer.firstMetricTimestamp\n\n        this.buffer.metrics.push({\n            ...metric,\n            $current_url: $currentUrl,\n            $session_id: sessionIds.sessionId,\n            $window_id: sessionIds.windowId,\n            timestamp: Date.now(),\n        })\n\n        if (this.buffer.metrics.length === 4) {\n            // we have all 4 metrics\n            this._flushToCapture()\n        }\n    }\n\n    private _startCapturing = () => {\n        const { onLCP, onCLS, onFCP, onINP } = assignableWindow.postHogWebVitalsCallbacks\n\n        if (!onLCP || !onCLS || !onFCP || !onINP) {\n            logger.error(LOGGER_PREFIX + 'web vitals callbacks not loaded - not starting')\n            return\n        }\n\n        // register performance observers\n        onLCP(this._addToBuffer)\n        onCLS(this._addToBuffer)\n        onFCP(this._addToBuffer)\n        onINP(this._addToBuffer)\n\n        this._initialized = true\n    }\n}\n","import Config from './config'\nimport {\n    _copyAndTruncateStrings,\n    each,\n    eachArray,\n    extend,\n    includes,\n    registerEvent,\n    safewrapClass,\n    isCrossDomainCookie,\n    isDistinctIdStringLike,\n} from './utils'\nimport { assignableWindow, document, location, navigator, userAgent, window } from './utils/globals'\nimport { PostHogFeatureFlags } from './posthog-featureflags'\nimport { PostHogPersistence } from './posthog-persistence'\nimport {\n    ALIAS_ID_KEY,\n    FLAG_CALL_REPORTED,\n    PEOPLE_DISTINCT_ID_KEY,\n    SESSION_RECORDING_IS_SAMPLED,\n    USER_STATE,\n    ENABLE_PERSON_PROCESSING,\n} from './constants'\nimport { SessionRecording } from './extensions/replay/sessionrecording'\nimport { Decide } from './decide'\nimport { Toolbar } from './extensions/toolbar'\nimport { localStore } from './storage'\nimport { RequestQueue } from './request-queue'\nimport { RetryQueue } from './retry-queue'\nimport { SessionIdManager } from './sessionid'\nimport { RequestRouter, RequestRouterRegion } from './utils/request-router'\nimport {\n    CaptureOptions,\n    CaptureResult,\n    Compression,\n    DecideResponse,\n    EarlyAccessFeatureCallback,\n    IsFeatureEnabledOptions,\n    JsonType,\n    PostHogConfig,\n    Properties,\n    Property,\n    QueuedRequestOptions,\n    RequestCallback,\n    SessionIdChangedCallback,\n    SnippetArrayItem,\n    ToolbarParams,\n} from './types'\nimport { SentryIntegration, SentryIntegrationOptions, sentryIntegration } from './extensions/sentry-integration'\nimport { setupSegmentIntegration } from './extensions/segment-integration'\nimport { PageViewManager } from './page-view'\nimport { PostHogSurveys } from './posthog-surveys'\nimport { RateLimiter } from './rate-limiter'\nimport { uuidv7 } from './uuidv7'\nimport { Survey, SurveyCallback, SurveyQuestionBranchingType } from './posthog-surveys-types'\nimport {\n    isArray,\n    isBoolean,\n    isEmptyObject,\n    isEmptyString,\n    isFunction,\n    isNumber,\n    isObject,\n    isString,\n    isUndefined,\n} from './utils/type-utils'\nimport { Info } from './utils/event-utils'\nimport { logger } from './utils/logger'\nimport { SessionPropsManager } from './session-props'\nimport { isLikelyBot } from './utils/blocked-uas'\nimport { extendURLParams, request, SUPPORTS_REQUEST } from './request'\nimport { Heatmaps } from './heatmaps'\nimport { ScrollManager } from './scroll-manager'\nimport { SimpleEventEmitter } from './utils/simple-event-emitter'\nimport { Autocapture } from './autocapture'\nimport { TracingHeaders } from './extensions/tracing-headers'\nimport { ConsentManager } from './consent'\nimport { ExceptionObserver } from './extensions/exception-autocapture'\nimport { WebVitalsAutocapture } from './extensions/web-vitals'\n\n/*\nSIMPLE STYLE GUIDE:\n\nthis.x === public function\nthis._x === internal - only use within this file\nthis.__x === private - only use within the class\n\nGlobals should be all caps\n*/\n\n/* posthog.init is called with `Partial<PostHogConfig>`\n * and we want to ensure that only valid keys are passed to the config object.\n * TypeScript does not enforce that the object passed does not have extra keys.\n * So someone can call with { bootstrap: { distinctId: '123'} }\n * which is not a valid key. They should have passed distinctID (upper case D).\n * That's a really tricky mistake to spot.\n * The OnlyValidKeys type ensures that only keys that are valid in the PostHogConfig type are allowed.\n */\ntype OnlyValidKeys<T, Shape> = T extends Shape ? (Exclude<keyof T, keyof Shape> extends never ? T : never) : never\n\nconst instances: Record<string, PostHog> = {}\n\n// some globals for comparisons\nconst __NOOP = () => {}\n\nconst PRIMARY_INSTANCE_NAME = 'posthog'\n\n/*\n * Dynamic... constants? Is that an oxymoron?\n */\n// http://hacks.mozilla.org/2009/07/cross-site-xmlhttprequest-with-cors/\n// https://developer.mozilla.org/en-US/docs/DOM/XMLHttpRequest#withCredentials\n\n// IE<10 does not support cross-origin XHR's but script tags\n// with defer won't block window.onload; ENQUEUE_REQUESTS\n// should only be true for Opera<12\nlet ENQUEUE_REQUESTS = !SUPPORTS_REQUEST && userAgent?.indexOf('MSIE') === -1 && userAgent?.indexOf('Mozilla') === -1\n\nexport const defaultConfig = (): PostHogConfig => ({\n    api_host: 'https://us.i.posthog.com',\n    ui_host: null,\n    token: '',\n    autocapture: true,\n    rageclick: true,\n    cross_subdomain_cookie: isCrossDomainCookie(document?.location),\n    persistence: 'localStorage+cookie', // up to 1.92.0 this was 'cookie'. It's easy to migrate as 'localStorage+cookie' will migrate data from cookie storage\n    persistence_name: '',\n    loaded: __NOOP,\n    store_google: true,\n    custom_campaign_params: [],\n    custom_blocked_useragents: [],\n    save_referrer: true,\n    capture_pageview: true,\n    capture_pageleave: 'if_capture_pageview', // We'll only capture pageleave events if capture_pageview is also true\n    debug: (location && isString(location?.search) && location.search.indexOf('__posthog_debug=true') !== -1) || false,\n    verbose: false,\n    cookie_expiration: 365,\n    upgrade: false,\n    disable_session_recording: false,\n    disable_persistence: false,\n    disable_surveys: false,\n    enable_recording_console_log: undefined, // When undefined, it falls back to the server-side setting\n    secure_cookie: window?.location?.protocol === 'https:',\n    ip: true,\n    opt_out_capturing_by_default: false,\n    opt_out_persistence_by_default: false,\n    opt_out_useragent_filter: false,\n    opt_out_capturing_persistence_type: 'localStorage',\n    opt_out_capturing_cookie_prefix: null,\n    opt_in_site_apps: false,\n    property_denylist: [],\n    respect_dnt: false,\n    sanitize_properties: null,\n    request_headers: {}, // { header: value, header2: value }\n    inapp_protocol: '//',\n    inapp_link_new_window: false,\n    request_batching: true,\n    properties_string_max_length: 65535,\n    session_recording: {},\n    mask_all_element_attributes: false,\n    mask_all_text: false,\n    advanced_disable_decide: false,\n    advanced_disable_feature_flags: false,\n    advanced_disable_feature_flags_on_first_load: false,\n    advanced_disable_toolbar_metrics: false,\n    feature_flag_request_timeout_ms: 3000,\n    on_request_error: (res) => {\n        const error = 'Bad HTTP status: ' + res.statusCode + ' ' + res.text\n        logger.error(error)\n    },\n    get_device_id: (uuid) => uuid,\n    // Used for internal testing\n    _onCapture: __NOOP,\n    capture_performance: undefined,\n    name: 'posthog',\n    bootstrap: {},\n    disable_compression: false,\n    session_idle_timeout_seconds: 30 * 60, // 30 minutes\n    person_profiles: 'always',\n    __add_tracing_headers: false,\n})\n\nexport const configRenames = (origConfig: Partial<PostHogConfig>): Partial<PostHogConfig> => {\n    const renames: Partial<PostHogConfig> = {}\n    if (!isUndefined(origConfig.process_person)) {\n        renames.person_profiles = origConfig.process_person\n    }\n    if (!isUndefined(origConfig.xhr_headers)) {\n        renames.request_headers = origConfig.xhr_headers\n    }\n    if (!isUndefined(origConfig.cookie_name)) {\n        renames.persistence_name = origConfig.cookie_name\n    }\n    if (!isUndefined(origConfig.disable_cookie)) {\n        renames.disable_persistence = origConfig.disable_cookie\n    }\n    // on_xhr_error is not present, as the type is different to on_request_error\n\n    // the original config takes priority over the renames\n    const newConfig = extend({}, renames, origConfig)\n\n    // merge property_blacklist into property_denylist\n    if (isArray(origConfig.property_blacklist)) {\n        if (isUndefined(origConfig.property_denylist)) {\n            newConfig.property_denylist = origConfig.property_blacklist\n        } else if (isArray(origConfig.property_denylist)) {\n            newConfig.property_denylist = [...origConfig.property_blacklist, ...origConfig.property_denylist]\n        } else {\n            logger.error('Invalid value for property_denylist config: ' + origConfig.property_denylist)\n        }\n    }\n\n    return newConfig\n}\n\nclass DeprecatedWebPerformanceObserver {\n    get _forceAllowLocalhost(): boolean {\n        return this.__forceAllowLocalhost\n    }\n\n    set _forceAllowLocalhost(value: boolean) {\n        logger.error(\n            'WebPerformanceObserver is deprecated and has no impact on network capture. Use `_forceAllowLocalhostNetworkCapture` on `posthog.sessionRecording`'\n        )\n        this.__forceAllowLocalhost = value\n    }\n\n    private __forceAllowLocalhost: boolean = false\n}\n\n/**\n * PostHog Library Object\n * @constructor\n */\nexport class PostHog {\n    __loaded: boolean\n    config: PostHogConfig\n\n    rateLimiter: RateLimiter\n    scrollManager: ScrollManager\n    pageViewManager: PageViewManager\n    featureFlags: PostHogFeatureFlags\n    surveys: PostHogSurveys\n    toolbar: Toolbar\n    consent: ConsentManager\n\n    // These are instance-specific state created after initialisation\n    persistence?: PostHogPersistence\n    sessionPersistence?: PostHogPersistence\n    sessionManager?: SessionIdManager\n    sessionPropsManager?: SessionPropsManager\n    requestRouter: RequestRouter\n    autocapture?: Autocapture\n    heatmaps?: Heatmaps\n    webVitalsAutocapture?: WebVitalsAutocapture\n    exceptionObserver?: ExceptionObserver\n\n    _requestQueue?: RequestQueue\n    _retryQueue?: RetryQueue\n    sessionRecording?: SessionRecording\n    webPerformance = new DeprecatedWebPerformanceObserver()\n\n    _triggered_notifs: any\n    compression?: Compression\n    __request_queue: QueuedRequestOptions[]\n    decideEndpointWasHit: boolean\n    analyticsDefaultEndpoint: string\n    version = Config.LIB_VERSION\n\n    SentryIntegration: typeof SentryIntegration\n    sentryIntegration: (options?: SentryIntegrationOptions) => ReturnType<typeof sentryIntegration>\n\n    private _internalEventEmitter = new SimpleEventEmitter()\n\n    /** DEPRECATED: We keep this to support existing usage but now one should just call .setPersonProperties */\n    people: {\n        set: (prop: string | Properties, to?: string, callback?: RequestCallback) => void\n        set_once: (prop: string | Properties, to?: string, callback?: RequestCallback) => void\n    }\n\n    constructor() {\n        this.config = defaultConfig()\n\n        this.decideEndpointWasHit = false\n        this.SentryIntegration = SentryIntegration\n        this.sentryIntegration = (options?: SentryIntegrationOptions) => sentryIntegration(this, options)\n        this.__request_queue = []\n        this.__loaded = false\n        this.analyticsDefaultEndpoint = '/e/'\n\n        this.featureFlags = new PostHogFeatureFlags(this)\n        this.toolbar = new Toolbar(this)\n        this.scrollManager = new ScrollManager(this)\n        this.pageViewManager = new PageViewManager(this)\n        this.surveys = new PostHogSurveys(this)\n        this.rateLimiter = new RateLimiter(this)\n        this.requestRouter = new RequestRouter(this)\n        this.consent = new ConsentManager(this)\n\n        // NOTE: See the property definition for deprecation notice\n        this.people = {\n            set: (prop: string | Properties, to?: string, callback?: RequestCallback) => {\n                const setProps = isString(prop) ? { [prop]: to } : prop\n                this.setPersonProperties(setProps)\n                callback?.({} as any)\n            },\n            set_once: (prop: string | Properties, to?: string, callback?: RequestCallback) => {\n                const setProps = isString(prop) ? { [prop]: to } : prop\n                this.setPersonProperties(undefined, setProps)\n                callback?.({} as any)\n            },\n        }\n\n        this.on('eventCaptured', (data) => logger.info('send', data))\n    }\n\n    // Initialization methods\n\n    /**\n     * This function initializes a new instance of the PostHog capturing object.\n     * All new instances are added to the main posthog object as sub properties (such as\n     * posthog.library_name) and also returned by this function. To define a\n     * second instance on the page, you would call:\n     *\n     *     posthog.init('new token', { your: 'config' }, 'library_name');\n     *\n     * and use it like so:\n     *\n     *     posthog.library_name.capture(...);\n     *\n     * @param {String} token   Your PostHog API token\n     * @param {Object} [config]  A dictionary of config options to override. <a href=\"https://github.com/posthog/posthog-js/blob/6e0e873/src/posthog-core.js#L57-L91\">See a list of default config options</a>.\n     * @param {String} [name]    The name for the new posthog instance that you want created\n     */\n    init(\n        token: string,\n        config?: OnlyValidKeys<Partial<PostHogConfig>, Partial<PostHogConfig>>,\n        name?: string\n    ): PostHog | undefined {\n        if (!name || name === PRIMARY_INSTANCE_NAME) {\n            // This means we are initializing the primary instance (i.e. this)\n            return this._init(token, config, name)\n        } else {\n            const namedPosthog = instances[name] ?? new PostHog()\n            namedPosthog._init(token, config, name)\n            instances[name] = namedPosthog\n            // Add as a property to the primary instance (this isn't type-safe but its how it was always done)\n            ;(instances[PRIMARY_INSTANCE_NAME] as any)[name] = namedPosthog\n\n            return namedPosthog\n        }\n    }\n\n    // posthog._init(token:string, config:object, name:string)\n    //\n    // This function sets up the current instance of the posthog\n    // library.  The difference between this method and the init(...)\n    // method is this one initializes the actual instance, whereas the\n    // init(...) method sets up a new library and calls _init on it.\n    //\n    // Note that there are operations that can be asynchronous, so we\n    // accept a callback that is called when all the asynchronous work\n    // is done. Note that we do not use promises because we want to be\n    // IE11 compatible. We could use polyfills, which would make the\n    // code a bit cleaner, but will add some overhead.\n    //\n    _init(token: string, config: Partial<PostHogConfig> = {}, name?: string): PostHog {\n        if (isUndefined(token) || isEmptyString(token)) {\n            logger.critical(\n                'PostHog was initialized without a token. This likely indicates a misconfiguration. Please check the first argument passed to posthog.init()'\n            )\n            return this\n        }\n\n        if (this.__loaded) {\n            logger.warn('You have already initialized PostHog! Re-initializing is a no-op')\n            return this\n        }\n\n        this.__loaded = true\n        this.config = {} as PostHogConfig // will be set right below\n        this._triggered_notifs = []\n\n        this.set_config(\n            extend({}, defaultConfig(), configRenames(config), {\n                name: name,\n                token: token,\n            })\n        )\n\n        if (this.config.on_xhr_error) {\n            logger.error('[posthog] on_xhr_error is deprecated. Use on_request_error instead')\n        }\n\n        this.compression = config.disable_compression ? undefined : Compression.GZipJS\n\n        this.persistence = new PostHogPersistence(this.config)\n        this.sessionPersistence =\n            this.config.persistence === 'sessionStorage'\n                ? this.persistence\n                : new PostHogPersistence({ ...this.config, persistence: 'sessionStorage' })\n        const initialPersistenceProps = { ...this.persistence.props }\n        const initialSessionProps = { ...this.sessionPersistence.props }\n\n        this._requestQueue = new RequestQueue((req) => this._send_retriable_request(req))\n        this._retryQueue = new RetryQueue(this)\n        this.__request_queue = []\n\n        this.sessionManager = new SessionIdManager(this.config, this.persistence)\n        this.sessionPropsManager = new SessionPropsManager(this.sessionManager, this.persistence)\n\n        new TracingHeaders(this).startIfEnabledOrStop()\n\n        this.sessionRecording = new SessionRecording(this)\n        this.sessionRecording.startIfEnabledOrStop()\n\n        if (!this.config.disable_scroll_properties) {\n            this.scrollManager.startMeasuringScrollPosition()\n        }\n\n        this.autocapture = new Autocapture(this)\n        this.autocapture.startIfEnabled()\n        this.surveys.loadIfEnabled()\n\n        this.heatmaps = new Heatmaps(this)\n        this.heatmaps.startIfEnabled()\n\n        this.webVitalsAutocapture = new WebVitalsAutocapture(this)\n\n        this.exceptionObserver = new ExceptionObserver(this)\n        this.exceptionObserver.startIfEnabled()\n\n        // if any instance on the page has debug = true, we set the\n        // global debug to be true\n        Config.DEBUG = Config.DEBUG || this.config.debug\n        if (Config.DEBUG) {\n            logger.info('Starting in debug mode', {\n                this: this,\n                config,\n                thisC: { ...this.config },\n                p: initialPersistenceProps,\n                s: initialSessionProps,\n            })\n        }\n\n        this._sync_opt_out_with_persistence()\n\n        // isUndefined doesn't provide typehint here so wouldn't reduce bundle as we'd need to assign\n        // eslint-disable-next-line posthog-js/no-direct-undefined-check\n        if (config.bootstrap?.distinctID !== undefined) {\n            const uuid = this.config.get_device_id(uuidv7())\n            const deviceID = config.bootstrap?.isIdentifiedID ? uuid : config.bootstrap.distinctID\n            this.persistence.set_property(USER_STATE, config.bootstrap?.isIdentifiedID ? 'identified' : 'anonymous')\n            this.register({\n                distinct_id: config.bootstrap.distinctID,\n                $device_id: deviceID,\n            })\n        }\n\n        if (this._hasBootstrappedFeatureFlags()) {\n            const activeFlags = Object.keys(config.bootstrap?.featureFlags || {})\n                .filter((flag) => !!config.bootstrap?.featureFlags?.[flag])\n                .reduce(\n                    (res: Record<string, string | boolean>, key) => (\n                        (res[key] = config.bootstrap?.featureFlags?.[key] || false), res\n                    ),\n                    {}\n                )\n            const featureFlagPayloads = Object.keys(config.bootstrap?.featureFlagPayloads || {})\n                .filter((key) => activeFlags[key])\n                .reduce((res: Record<string, JsonType>, key) => {\n                    if (config.bootstrap?.featureFlagPayloads?.[key]) {\n                        res[key] = config.bootstrap?.featureFlagPayloads?.[key]\n                    }\n                    return res\n                }, {})\n\n            this.featureFlags.receivedFeatureFlags({ featureFlags: activeFlags, featureFlagPayloads })\n        }\n\n        if (!this.get_distinct_id()) {\n            // There is no need to set the distinct id\n            // or the device id if something was already stored\n            // in the persitence\n            const uuid = this.config.get_device_id(uuidv7())\n\n            this.register_once(\n                {\n                    distinct_id: uuid,\n                    $device_id: uuid,\n                },\n                ''\n            )\n            // distinct id == $device_id is a proxy for anonymous user\n            this.persistence.set_property(USER_STATE, 'anonymous')\n        }\n        // Set up event handler for pageleave\n        // Use `onpagehide` if available, see https://calendar.perfplanet.com/2020/beaconing-in-practice/#beaconing-reliability-avoiding-abandons\n        window?.addEventListener?.('onpagehide' in self ? 'pagehide' : 'unload', this._handle_unload.bind(this))\n\n        this.toolbar.maybeLoadToolbar()\n\n        // We wan't to avoid promises for IE11 compatibility, so we use callbacks here\n        if (config.segment) {\n            setupSegmentIntegration(this, () => this._loaded())\n        } else {\n            this._loaded()\n        }\n\n        if (isFunction(this.config._onCapture)) {\n            this.on('eventCaptured', (data) => this.config._onCapture(data.event, data))\n        }\n\n        return this\n    }\n\n    // Private methods\n    _afterDecideResponse(response: DecideResponse) {\n        this.compression = undefined\n        if (response.supportedCompression && !this.config.disable_compression) {\n            this.compression = includes(response['supportedCompression'], Compression.GZipJS)\n                ? Compression.GZipJS\n                : includes(response['supportedCompression'], Compression.Base64)\n                ? Compression.Base64\n                : undefined\n        }\n\n        if (response.analytics?.endpoint) {\n            this.analyticsDefaultEndpoint = response.analytics.endpoint\n        }\n\n        this.sessionRecording?.afterDecideResponse(response)\n        this.autocapture?.afterDecideResponse(response)\n        this.heatmaps?.afterDecideResponse(response)\n        this.surveys?.afterDecideResponse(response)\n        this.webVitalsAutocapture?.afterDecideResponse(response)\n        this.exceptionObserver?.afterDecideResponse(response)\n    }\n\n    _loaded(): void {\n        // Pause `reloadFeatureFlags` calls in config.loaded callback.\n        // These feature flags are loaded in the decide call made right\n        // afterwards\n        const disableDecide = this.config.advanced_disable_decide\n        if (!disableDecide) {\n            this.featureFlags.setReloadingPaused(true)\n        }\n\n        try {\n            this.config.loaded(this)\n        } catch (err) {\n            logger.critical('`loaded` function failed', err)\n        }\n\n        this._start_queue_if_opted_in()\n\n        // this happens after \"loaded\" so a user can call identify or any other things before the pageview fires\n        if (this.config.capture_pageview) {\n            // NOTE: We want to fire this on the next tick as the previous implementation had this side effect\n            // and some clients may rely on it\n            setTimeout(() => {\n                if (document) {\n                    this.capture('$pageview', { title: document.title }, { send_instantly: true })\n                }\n            }, 1)\n        }\n\n        // Call decide to get what features are enabled and other settings.\n        // As a reminder, if the /decide endpoint is disabled, feature flags, toolbar, session recording, autocapture,\n        // and compression will not be available.\n        if (!disableDecide) {\n            new Decide(this).call()\n\n            // TRICKY: Reset any decide reloads queued during config.loaded because they'll be\n            // covered by the decide call right above.\n            this.featureFlags.resetRequestQueue()\n        }\n    }\n\n    _start_queue_if_opted_in(): void {\n        if (!this.has_opted_out_capturing()) {\n            if (this.config.request_batching) {\n                this._requestQueue?.enable()\n            }\n        }\n    }\n\n    _dom_loaded(): void {\n        if (!this.has_opted_out_capturing()) {\n            eachArray(this.__request_queue, (item) => this._send_retriable_request(item))\n        }\n\n        this.__request_queue = []\n        this._start_queue_if_opted_in()\n    }\n\n    _handle_unload(): void {\n        if (!this.config.request_batching) {\n            if (this._shouldCapturePageleave()) {\n                this.capture('$pageleave', null, { transport: 'sendBeacon' })\n            }\n            return\n        }\n\n        if (this._shouldCapturePageleave()) {\n            this.capture('$pageleave')\n        }\n\n        this._requestQueue?.unload()\n        this._retryQueue?.unload()\n    }\n\n    _send_request(options: QueuedRequestOptions): void {\n        if (!this.__loaded) {\n            return\n        }\n\n        if (ENQUEUE_REQUESTS) {\n            this.__request_queue.push(options)\n            return\n        }\n\n        if (this.rateLimiter.isServerRateLimited(options.batchKey)) {\n            return\n        }\n\n        options.transport = options.transport || this.config.api_transport\n        options.url = extendURLParams(options.url, {\n            // Whether to detect ip info or not\n            ip: this.config.ip ? 1 : 0,\n        })\n        options.headers = {\n            ...this.config.request_headers,\n        }\n        options.compression = options.compression === 'best-available' ? this.compression : options.compression\n\n        request({\n            ...options,\n            callback: (response) => {\n                this.rateLimiter.checkForLimiting(response)\n\n                if (response.statusCode >= 400) {\n                    this.config.on_request_error?.(response)\n                }\n\n                options.callback?.(response)\n            },\n        })\n    }\n\n    _send_retriable_request(options: QueuedRequestOptions): void {\n        if (this._retryQueue) {\n            this._retryQueue.retriableRequest(options)\n        } else {\n            this._send_request(options)\n        }\n    }\n\n    /**\n     * _execute_array() deals with processing any posthog function\n     * calls that were called before the PostHog library were loaded\n     * (and are thus stored in an array so they can be called later)\n     *\n     * Note: we fire off all the posthog function calls && user defined\n     * functions BEFORE we fire off posthog capturing calls. This is so\n     * identify/register/set_config calls can properly modify early\n     * capturing calls.\n     *\n     * @param {Array} array\n     */\n    _execute_array(array: SnippetArrayItem[]): void {\n        let fn_name\n        const alias_calls: SnippetArrayItem[] = []\n        const other_calls: SnippetArrayItem[] = []\n        const capturing_calls: SnippetArrayItem[] = []\n        eachArray(array, (item) => {\n            if (item) {\n                fn_name = item[0]\n                if (isArray(fn_name)) {\n                    capturing_calls.push(item) // chained call e.g. posthog.get_group().set()\n                } else if (isFunction(item)) {\n                    ;(item as any).call(this)\n                } else if (isArray(item) && fn_name === 'alias') {\n                    alias_calls.push(item)\n                } else if (isArray(item) && fn_name.indexOf('capture') !== -1 && isFunction((this as any)[fn_name])) {\n                    capturing_calls.push(item)\n                } else {\n                    other_calls.push(item)\n                }\n            }\n        })\n\n        const execute = function (calls: SnippetArrayItem[], thisArg: any) {\n            eachArray(\n                calls,\n                function (item) {\n                    if (isArray(item[0])) {\n                        // chained call\n                        let caller = thisArg\n                        each(item, function (call) {\n                            caller = caller[call[0]].apply(caller, call.slice(1))\n                        })\n                    } else {\n                        // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n                        // @ts-ignore\n                        this[item[0]].apply(this, item.slice(1))\n                    }\n                },\n                thisArg\n            )\n        }\n\n        execute(alias_calls, this)\n        execute(other_calls, this)\n        execute(capturing_calls, this)\n    }\n\n    _hasBootstrappedFeatureFlags(): boolean {\n        return (\n            (this.config.bootstrap?.featureFlags && Object.keys(this.config.bootstrap?.featureFlags).length > 0) ||\n            false\n        )\n    }\n\n    /**\n     * push() keeps the standard async-array-push\n     * behavior around after the lib is loaded.\n     * This is only useful for external integrations that\n     * do not wish to rely on our convenience methods\n     * (created in the snippet).\n     *\n     * ### Usage:\n     *     posthog.push(['register', { a: 'b' }]);\n     *\n     * @param {Array} item A [function_name, args...] array to be executed\n     */\n    push(item: SnippetArrayItem): void {\n        this._execute_array([item])\n    }\n\n    /**\n     * Capture an event. This is the most important and\n     * frequently used PostHog function.\n     *\n     * ### Usage:\n     *\n     *     // capture an event named 'Registered'\n     *     posthog.capture('Registered', {'Gender': 'Male', 'Age': 21});\n     *\n     *     // capture an event using navigator.sendBeacon\n     *     posthog.capture('Left page', {'duration_seconds': 35}, {transport: 'sendBeacon'});\n     *\n     * @param {String} event_name The name of the event. This can be anything the user does - 'Button Click', 'Sign Up', 'Item Purchased', etc.\n     * @param {Object} [properties] A set of properties to include with the event you're sending. These describe the user who did the event or details about the event itself.\n     * @param {Object} [config] Optional configuration for this capture request.\n     * @param {String} [config.transport] Transport method for network request ('XHR' or 'sendBeacon').\n     * @param {Date} [config.timestamp] Timestamp is a Date object. If not set, it'll automatically be set to the current time.\n     */\n    capture(event_name: string, properties?: Properties | null, options?: CaptureOptions): CaptureResult | undefined {\n        // While developing, a developer might purposefully _not_ call init(),\n        // in this case, we would like capture to be a noop.\n        if (!this.__loaded || !this.persistence || !this.sessionPersistence || !this._requestQueue) {\n            logger.uninitializedWarning('posthog.capture')\n            return\n        }\n\n        if (this.consent.isOptedOut()) {\n            return\n        }\n\n        // typing doesn't prevent interesting data\n        if (isUndefined(event_name) || !isString(event_name)) {\n            logger.error('No event name provided to posthog.capture')\n            return\n        }\n\n        if (!this.config.opt_out_useragent_filter && this._is_bot()) {\n            return\n        }\n\n        const clientRateLimitContext = !options?.skip_client_rate_limiting\n            ? this.rateLimiter.clientRateLimitContext()\n            : undefined\n\n        if (clientRateLimitContext?.isRateLimited) {\n            logger.critical('This capture call is ignored due to client rate limiting.')\n            return\n        }\n\n        // update persistence\n        this.sessionPersistence.update_search_keyword()\n\n        // The initial campaign/referrer props need to be stored in the regular persistence, as they are there to mimic\n        // the person-initial props. The non-initial versions are stored in the sessionPersistence, as they are sent\n        // with every event and used by the session table to create session-initial props.\n        if (this.config.store_google) {\n            this.sessionPersistence.update_campaign_params()\n        }\n        if (this.config.save_referrer) {\n            this.sessionPersistence.update_referrer_info()\n        }\n        if (this.config.store_google || this.config.save_referrer) {\n            this.persistence.set_initial_person_info()\n        }\n\n        const systemTime = new Date()\n        const timestamp = options?.timestamp || systemTime\n\n        let data: CaptureResult = {\n            uuid: uuidv7(),\n            event: event_name,\n            properties: this._calculate_event_properties(event_name, properties || {}, timestamp),\n        }\n\n        if (clientRateLimitContext) {\n            data.properties['$lib_rate_limit_remaining_tokens'] = clientRateLimitContext.remainingTokens\n        }\n\n        const setProperties = options?.$set\n        if (setProperties) {\n            data.$set = options?.$set\n        }\n        const setOnceProperties = this._calculate_set_once_properties(options?.$set_once)\n        if (setOnceProperties) {\n            data.$set_once = setOnceProperties\n        }\n\n        data = _copyAndTruncateStrings(data, options?._noTruncate ? null : this.config.properties_string_max_length)\n        data.timestamp = timestamp\n        if (!isUndefined(options?.timestamp)) {\n            data.properties['$event_time_override_provided'] = true\n            data.properties['$event_time_override_system_time'] = systemTime\n        }\n\n        // Top-level $set overriding values from the one from properties is taken from the plugin-server normalizeEvent\n        // This doesn't handle $set_once, because posthog-people doesn't either\n        const finalSet = { ...data.properties['$set'], ...data['$set'] }\n        if (!isEmptyObject(finalSet)) {\n            this.setPersonPropertiesForFlags(finalSet)\n        }\n\n        this._internalEventEmitter.emit('eventCaptured', data)\n\n        const requestOptions: QueuedRequestOptions = {\n            method: 'POST',\n            url: options?._url ?? this.requestRouter.endpointFor('api', this.analyticsDefaultEndpoint),\n            data,\n            compression: 'best-available',\n            batchKey: options?._batchKey,\n        }\n\n        if (this.config.request_batching && (!options || options?._batchKey) && !options?.send_instantly) {\n            this._requestQueue.enqueue(requestOptions)\n        } else {\n            this._send_retriable_request(requestOptions)\n        }\n\n        return data\n    }\n\n    _addCaptureHook(callback: (eventName: string, eventPayload?: CaptureResult) => void): void {\n        this.on('eventCaptured', (data) => callback(data.event, data))\n    }\n\n    _calculate_event_properties(event_name: string, event_properties: Properties, timestamp?: Date): Properties {\n        timestamp = timestamp || new Date()\n        if (!this.persistence || !this.sessionPersistence) {\n            return event_properties\n        }\n\n        // set defaults\n        const startTimestamp = this.persistence.remove_event_timer(event_name)\n        let properties = { ...event_properties }\n        properties['token'] = this.config.token\n\n        if (event_name === '$snapshot') {\n            const persistenceProps = { ...this.persistence.properties(), ...this.sessionPersistence.properties() }\n            properties['distinct_id'] = persistenceProps.distinct_id\n            if (\n                // we spotted one customer that was managing to send `false` for ~9k events a day\n                !(isString(properties['distinct_id']) || isNumber(properties['distinct_id'])) ||\n                isEmptyString(properties['distinct_id'])\n            ) {\n                logger.error('Invalid distinct_id for replay event. This indicates a bug in your implementation')\n            }\n            return properties\n        }\n\n        const infoProperties = Info.properties()\n\n        if (this.sessionManager) {\n            const { sessionId, windowId } = this.sessionManager.checkAndGetSessionAndWindowId()\n            properties['$session_id'] = sessionId\n            properties['$window_id'] = windowId\n        }\n\n        if (this.requestRouter.region === RequestRouterRegion.CUSTOM) {\n            properties['$lib_custom_api_host'] = this.config.api_host\n        }\n\n        if (\n            this.sessionPropsManager &&\n            this.config.__preview_send_client_session_params &&\n            (event_name === '$pageview' || event_name === '$pageleave' || event_name === '$autocapture')\n        ) {\n            const sessionProps = this.sessionPropsManager.getSessionProps()\n            properties = extend(properties, sessionProps)\n        }\n\n        if (!this.config.disable_scroll_properties) {\n            let performanceProperties: Record<string, any> = {}\n            if (event_name === '$pageview') {\n                performanceProperties = this.pageViewManager.doPageView(timestamp)\n            } else if (event_name === '$pageleave') {\n                performanceProperties = this.pageViewManager.doPageLeave(timestamp)\n            }\n            properties = extend(properties, performanceProperties)\n        }\n\n        if (event_name === '$pageview' && document) {\n            properties['title'] = document.title\n        }\n\n        // set $duration if time_event was previously called for this event\n        if (!isUndefined(startTimestamp)) {\n            const duration_in_ms = timestamp.getTime() - startTimestamp\n            properties['$duration'] = parseFloat((duration_in_ms / 1000).toFixed(3))\n        }\n\n        // this is only added when this.config.opt_out_useragent_filter is true,\n        // or it would always add \"browser\"\n        if (userAgent && this.config.opt_out_useragent_filter) {\n            properties['$browser_type'] = this._is_bot() ? 'bot' : 'browser'\n        }\n\n        // note: extend writes to the first object, so lets make sure we\n        // don't write to the persistence properties object and info\n        // properties object by passing in a new object\n\n        // update properties with pageview info and super-properties\n        properties = extend(\n            {},\n            infoProperties,\n            this.persistence.properties(),\n            this.sessionPersistence.properties(),\n            properties\n        )\n\n        properties['$is_identified'] = this._isIdentified()\n\n        if (isArray(this.config.property_denylist)) {\n            each(this.config.property_denylist, function (denylisted_prop) {\n                delete properties[denylisted_prop]\n            })\n        } else {\n            logger.error(\n                'Invalid value for property_denylist config: ' +\n                    this.config.property_denylist +\n                    ' or property_blacklist config: ' +\n                    this.config.property_blacklist\n            )\n        }\n\n        const sanitize_properties = this.config.sanitize_properties\n        if (sanitize_properties) {\n            properties = sanitize_properties(properties, event_name)\n        }\n\n        // add person processing flag as very last step, so it cannot be overridden. process_person=true is default\n        properties['$process_person_profile'] = this._hasPersonProcessing()\n\n        return properties\n    }\n\n    _calculate_set_once_properties(dataSetOnce?: Properties): Properties | undefined {\n        if (!this.persistence || !this._hasPersonProcessing()) {\n            return dataSetOnce\n        }\n        // if we're an identified person, send initial params with every event\n        const setOnceProperties = extend({}, this.persistence.get_initial_props(), dataSetOnce || {})\n        if (isEmptyObject(setOnceProperties)) {\n            return undefined\n        }\n        return setOnceProperties\n    }\n\n    /**\n     * Register a set of super properties, which are included with all\n     * events. This will overwrite previous super property values, except\n     * for session properties (see `register_for_session(properties)`).\n     *\n     * ### Usage:\n     *\n     *     // register 'Gender' as a super property\n     *     posthog.register({'Gender': 'Female'});\n     *\n     *     // register several super properties when a user signs up\n     *     posthog.register({\n     *         'Email': 'jdoe@example.com',\n     *         'Account Type': 'Free'\n     *     });\n     *\n     *     // Display the properties\n     *     console.log(posthog.persistence.properties())\n     *\n     * @param {Object} properties An associative array of properties to store about the user\n     * @param {Number} [days] How many days since the user's last visit to store the super properties\n     */\n    register(properties: Properties, days?: number): void {\n        this.persistence?.register(properties, days)\n    }\n\n    /**\n     * Register a set of super properties only once. These will not\n     * overwrite previous super property values, unlike register().\n     *\n     * ### Usage:\n     *\n     *     // register a super property for the first time only\n     *     posthog.register_once({\n     *         'First Login Date': new Date().toISOString()\n     *     });\n     *\n     *     // Display the properties\n     *     console.log(posthog.persistence.properties())\n     *\n     * ### Notes:\n     *\n     * If default_value is specified, current super properties\n     * with that value will be overwritten.\n     *\n     * @param {Object} properties An associative array of properties to store about the user\n     * @param {*} [default_value] Value to override if already set in super properties (ex: 'False') Default: 'None'\n     * @param {Number} [days] How many days since the users last visit to store the super properties\n     */\n    register_once(properties: Properties, default_value?: Property, days?: number): void {\n        this.persistence?.register_once(properties, default_value, days)\n    }\n\n    /**\n     * Register a set of super properties, which are included with all events, but only\n     * for THIS SESSION. These will overwrite all other super property values.\n     *\n     * Unlike regular super properties, which last in LocalStorage for a long time,\n     * session super properties get cleared after a session ends.\n     *\n     * ### Usage:\n     *\n     *     // register on all events this session\n     *     posthog.register_for_session({'referer': customGetReferer()});\n     *\n     *     // register several session super properties when a user signs up\n     *     posthog.register_for_session({\n     *         'selectedPlan': 'pro',\n     *         'completedSteps': 4,\n     *     });\n     *\n     *     // Display the properties\n     *     console.log(posthog.sessionPersistence.properties())\n     *\n     * @param {Object} properties An associative array of properties to store about the user\n     */\n    register_for_session(properties: Properties): void {\n        this.sessionPersistence?.register(properties)\n    }\n\n    /**\n     * Delete a super property stored with the current user.\n     *\n     * @param {String} property The name of the super property to remove\n     */\n    unregister(property: string): void {\n        this.persistence?.unregister(property)\n    }\n\n    /**\n     * Delete a session super property stored with the current user.\n     *\n     * @param {String} property The name of the session super property to remove\n     */\n    unregister_for_session(property: string): void {\n        this.sessionPersistence?.unregister(property)\n    }\n\n    _register_single(prop: string, value: Property) {\n        this.register({ [prop]: value })\n    }\n\n    /*\n     * Get feature flag value for user (supports multivariate flags).\n     *\n     * ### Usage:\n     *\n     *     if(posthog.getFeatureFlag('beta-feature') === 'some-value') { // do something }\n     *\n     * @param {Object|String} prop Key of the feature flag.\n     * @param {Object|String} options (optional) If {send_event: false}, we won't send an $feature_flag_call event to PostHog.\n     */\n    getFeatureFlag(key: string, options?: { send_event?: boolean }): boolean | string | undefined {\n        return this.featureFlags.getFeatureFlag(key, options)\n    }\n\n    /*\n     * Get feature flag payload value matching key for user (supports multivariate flags).\n     *\n     * ### Usage:\n     *\n     *     if(posthog.getFeatureFlag('beta-feature') === 'some-value') {\n     *          const someValue = posthog.getFeatureFlagPayload('beta-feature')\n     *          // do something\n     *     }\n     *\n     * @param {Object|String} prop Key of the feature flag.\n     */\n    getFeatureFlagPayload(key: string): JsonType {\n        const payload = this.featureFlags.getFeatureFlagPayload(key)\n        try {\n            return JSON.parse(payload as any)\n        } catch {\n            return payload\n        }\n    }\n\n    /*\n     * See if feature flag is enabled for user.\n     *\n     * ### Usage:\n     *\n     *     if(posthog.isFeatureEnabled('beta-feature')) { // do something }\n     *\n     * @param {Object|String} prop Key of the feature flag.\n     * @param {Object|String} options (optional) If {send_event: false}, we won't send an $feature_flag_call event to PostHog.\n     */\n    isFeatureEnabled(key: string, options?: IsFeatureEnabledOptions): boolean | undefined {\n        return this.featureFlags.isFeatureEnabled(key, options)\n    }\n\n    reloadFeatureFlags(): void {\n        this.featureFlags.reloadFeatureFlags()\n    }\n\n    /** Opt the user in or out of an early access feature. */\n    updateEarlyAccessFeatureEnrollment(key: string, isEnrolled: boolean): void {\n        this.featureFlags.updateEarlyAccessFeatureEnrollment(key, isEnrolled)\n    }\n\n    /** Get the list of early access features. To check enrollment status, use `isFeatureEnabled`. */\n    getEarlyAccessFeatures(callback: EarlyAccessFeatureCallback, force_reload = false): void {\n        return this.featureFlags.getEarlyAccessFeatures(callback, force_reload)\n    }\n\n    /**\n     * Exposes a set of events that PostHog will emit.\n     * e.g. `eventCaptured` is emitted immediately before trying to send an event\n     *\n     * Unlike  `onFeatureFlags` and `onSessionId` these are not called when the\n     * listener is registered, the first callback will be the next event\n     * _after_ registering a listener\n     */\n    on(event: 'eventCaptured', cb: (...args: any[]) => void): () => void {\n        return this._internalEventEmitter.on(event, cb)\n    }\n\n    /*\n     * Register an event listener that runs when feature flags become available or when they change.\n     * If there are flags, the listener is called immediately in addition to being called on future changes.\n     *\n     * ### Usage:\n     *\n     *     posthog.onFeatureFlags(function(featureFlags) { // do something })\n     *\n     * @param {Function} [callback] The callback function will be called once the feature flags are ready or when they are updated.\n     *                              It'll return a list of feature flags enabled for the user.\n     * @returns {Function} A function that can be called to unsubscribe the listener. Used by useEffect when the component unmounts.\n     */\n    onFeatureFlags(callback: (flags: string[], variants: Record<string, string | boolean>) => void): () => void {\n        return this.featureFlags.onFeatureFlags(callback)\n    }\n\n    /*\n     * Register an event listener that runs whenever the session id or window id change.\n     * If there is already a session id, the listener is called immediately in addition to being called on future changes.\n     *\n     * Can be used, for example, to sync the PostHog session id with a backend session.\n     *\n     * ### Usage:\n     *\n     *     posthog.onSessionId(function(sessionId, windowId) { // do something })\n     *\n     * @param {Function} [callback] The callback function will be called once a session id is present or when it or the window id are updated.\n     * @returns {Function} A function that can be called to unsubscribe the listener. E.g. Used by useEffect when the component unmounts.\n     */\n    onSessionId(callback: SessionIdChangedCallback): () => void {\n        return this.sessionManager?.onSessionId(callback) ?? (() => {})\n    }\n\n    /** Get list of all surveys. */\n    getSurveys(callback: SurveyCallback, forceReload = false): void {\n        this.surveys.getSurveys(callback, forceReload)\n    }\n\n    /** Get surveys that should be enabled for the current user. */\n    getActiveMatchingSurveys(callback: SurveyCallback, forceReload = false): void {\n        this.surveys.getActiveMatchingSurveys(callback, forceReload)\n    }\n\n    /** Render a survey on a specific element. */\n    renderSurvey(surveyId: string, selector: string): void {\n        this.surveys.renderSurvey(surveyId, selector)\n    }\n\n    /** Checks the feature flags associated with this Survey to see if the survey can be rendered. */\n    canRenderSurvey(surveyId: string): void {\n        this.surveys.canRenderSurvey(surveyId)\n    }\n\n    /** Get the next step of the survey: a question index or `end` */\n    getNextSurveyStep(\n        survey: Survey,\n        currentQuestionIndex: number,\n        response: string | string[] | number | null\n    ): number | SurveyQuestionBranchingType.End {\n        return this.surveys.getNextSurveyStep(survey, currentQuestionIndex, response)\n    }\n\n    /**\n     * Identify a user with a unique ID instead of a PostHog\n     * randomly generated distinct_id. If the method is never called,\n     * then unique visitors will be identified by a UUID that is generated\n     * the first time they visit the site.\n     *\n     * If user properties are passed, they are also sent to posthog.\n     *\n     * ### Usage:\n     *\n     *      posthog.identify('[user unique id]')\n     *      posthog.identify('[user unique id]', { email: 'john@example.com' })\n     *      posthog.identify('[user unique id]', {}, { referral_code: '12345' })\n     *\n     * ### Notes:\n     *\n     * You can call this function to overwrite a previously set\n     * unique ID for the current user.\n     *\n     * If the user has been identified ($user_state in persistence is set to 'identified'),\n     * then capture of $identify is skipped to avoid merging users. For example,\n     * if your system allows an admin user to impersonate another user.\n     *\n     * Then a single browser instance can have:\n     *\n     *  `identify('a') -> capture(1) -> identify('b') -> capture(2)`\n     *\n     * and capture 1 and capture 2 will have the correct distinct_id.\n     * but users a and b will NOT be merged in posthog.\n     *\n     * However, if reset is called then:\n     *\n     *  `identify('a') -> capture(1) -> reset() -> capture(2) -> identify('b') -> capture(3)`\n     *\n     * users a and b are not merged.\n     * Capture 1 is associated with user a.\n     * A new distinct id is generated for capture 2.\n     * which is merged with user b.\n     * So, capture 2 and 3 are associated with user b.\n     *\n     * If you want to merge two identified users, you can call posthog.alias\n     *\n     * @param {String} [new_distinct_id] A string that uniquely identifies a user. If not provided, the distinct_id currently in the persistent store (cookie or localStorage) will be used.\n     * @param {Object} [userPropertiesToSet] Optional: An associative array of properties to store about the user\n     * @param {Object} [userPropertiesToSetOnce] Optional: An associative array of properties to store about the user. If property is previously set, this does not override that value.\n     */\n    identify(new_distinct_id?: string, userPropertiesToSet?: Properties, userPropertiesToSetOnce?: Properties): void {\n        if (!this.__loaded || !this.persistence) {\n            return logger.uninitializedWarning('posthog.identify')\n        }\n        if (isNumber(new_distinct_id)) {\n            new_distinct_id = (new_distinct_id as number).toString()\n            logger.warn(\n                'The first argument to posthog.identify was a number, but it should be a string. It has been converted to a string.'\n            )\n        }\n\n        //if the new_distinct_id has not been set ignore the identify event\n        if (!new_distinct_id) {\n            logger.error('Unique user id has not been set in posthog.identify')\n            return\n        }\n\n        if (isDistinctIdStringLike(new_distinct_id)) {\n            logger.critical(\n                `The string \"${new_distinct_id}\" was set in posthog.identify which indicates an error. This ID should be unique to the user and not a hardcoded string.`\n            )\n            return\n        }\n\n        if (!this._requirePersonProcessing('posthog.identify')) {\n            return\n        }\n\n        const previous_distinct_id = this.get_distinct_id()\n        this.register({ $user_id: new_distinct_id })\n\n        if (!this.get_property('$device_id')) {\n            // The persisted distinct id might not actually be a device id at all\n            // it might be a distinct id of the user from before\n            const device_id = previous_distinct_id\n            this.register_once(\n                {\n                    $had_persisted_distinct_id: true,\n                    $device_id: device_id,\n                },\n                ''\n            )\n        }\n\n        // if the previous distinct id had an alias stored, then we clear it\n        if (new_distinct_id !== previous_distinct_id && new_distinct_id !== this.get_property(ALIAS_ID_KEY)) {\n            this.unregister(ALIAS_ID_KEY)\n            this.register({ distinct_id: new_distinct_id })\n        }\n\n        const isKnownAnonymous = (this.persistence.get_property(USER_STATE) || 'anonymous') === 'anonymous'\n\n        // send an $identify event any time the distinct_id is changing and the old ID is an anonymous ID\n        // - logic on the server will determine whether or not to do anything with it.\n        if (new_distinct_id !== previous_distinct_id && isKnownAnonymous) {\n            this.persistence.set_property(USER_STATE, 'identified')\n\n            // Update current user properties\n            this.setPersonPropertiesForFlags(userPropertiesToSet || {}, false)\n\n            this.capture(\n                '$identify',\n                {\n                    distinct_id: new_distinct_id,\n                    $anon_distinct_id: previous_distinct_id,\n                },\n                { $set: userPropertiesToSet || {}, $set_once: userPropertiesToSetOnce || {} }\n            )\n            // let the reload feature flag request know to send this previous distinct id\n            // for flag consistency\n            this.featureFlags.setAnonymousDistinctId(previous_distinct_id)\n        } else if (userPropertiesToSet || userPropertiesToSetOnce) {\n            // If the distinct_id is not changing, but we have user properties to set, we can go for a $set event\n            this.setPersonProperties(userPropertiesToSet, userPropertiesToSetOnce)\n        }\n\n        // Reload active feature flags if the user identity changes.\n        // Note we don't reload this on property changes as these get processed async\n        if (new_distinct_id !== previous_distinct_id) {\n            this.reloadFeatureFlags()\n            // also clear any stored flag calls\n            this.unregister(FLAG_CALL_REPORTED)\n        }\n    }\n\n    /**\n     * Sets properties for the Person associated with the current distinct_id. If config.person_profiles is set to\n     * identified_only, and a Person profile has not been created yet, this will create one.\n     *\n     *\n     * @param {Object} [userPropertiesToSet] Optional: An associative array of properties to store about the user\n     * @param {Object} [userPropertiesToSetOnce] Optional: An associative array of properties to store about the user. If property is previously set, this does not override that value.\n     */\n    setPersonProperties(userPropertiesToSet?: Properties, userPropertiesToSetOnce?: Properties): void {\n        if (!userPropertiesToSet && !userPropertiesToSetOnce) {\n            return\n        }\n\n        if (!this._requirePersonProcessing('posthog.setPersonProperties')) {\n            return\n        }\n\n        // Update current user properties\n        this.setPersonPropertiesForFlags(userPropertiesToSet || {})\n\n        this.capture('$set', { $set: userPropertiesToSet || {}, $set_once: userPropertiesToSetOnce || {} })\n    }\n\n    /**\n     * Sets group analytics information for subsequent events and reloads feature flags.\n     *\n     * @param {String} groupType Group type (example: 'organization')\n     * @param {String} groupKey Group key (example: 'org::5')\n     * @param {Object} groupPropertiesToSet Optional properties to set for group\n     */\n    group(groupType: string, groupKey: string, groupPropertiesToSet?: Properties): void {\n        if (!groupType || !groupKey) {\n            logger.error('posthog.group requires a group type and group key')\n            return\n        }\n\n        if (!this._requirePersonProcessing('posthog.group')) {\n            return\n        }\n\n        const existingGroups = this.getGroups()\n\n        // if group key changes, remove stored group properties\n        if (existingGroups[groupType] !== groupKey) {\n            this.resetGroupPropertiesForFlags(groupType)\n        }\n\n        this.register({ $groups: { ...existingGroups, [groupType]: groupKey } })\n\n        if (groupPropertiesToSet) {\n            this.capture('$groupidentify', {\n                $group_type: groupType,\n                $group_key: groupKey,\n                $group_set: groupPropertiesToSet,\n            })\n            this.setGroupPropertiesForFlags({ [groupType]: groupPropertiesToSet })\n        }\n\n        // If groups change and no properties change, reload feature flags.\n        // The property change reload case is handled in setGroupPropertiesForFlags.\n        if (existingGroups[groupType] !== groupKey && !groupPropertiesToSet) {\n            this.reloadFeatureFlags()\n        }\n    }\n\n    /**\n     * Resets only the group properties of the user currently logged in.\n     */\n    resetGroups(): void {\n        this.register({ $groups: {} })\n        this.resetGroupPropertiesForFlags()\n\n        // If groups changed, reload feature flags.\n        this.reloadFeatureFlags()\n    }\n\n    /**\n     * Set override person properties for feature flags.\n     * This is used when dealing with new persons / where you don't want to wait for ingestion\n     * to update user properties.\n     */\n    setPersonPropertiesForFlags(properties: Properties, reloadFeatureFlags = true): void {\n        if (!this._requirePersonProcessing('posthog.setPersonPropertiesForFlags')) {\n            return\n        }\n        this.featureFlags.setPersonPropertiesForFlags(properties, reloadFeatureFlags)\n    }\n\n    resetPersonPropertiesForFlags(): void {\n        this.featureFlags.resetPersonPropertiesForFlags()\n    }\n\n    /**\n     * Set override group properties for feature flags.\n     * This is used when dealing with new groups / where you don't want to wait for ingestion\n     * to update properties.\n     * Takes in an object, the key of which is the group type.\n     * For example:\n     *     setGroupPropertiesForFlags({'organization': { name: 'CYZ', employees: '11' } })\n     */\n    setGroupPropertiesForFlags(properties: { [type: string]: Properties }, reloadFeatureFlags = true): void {\n        if (!this._requirePersonProcessing('posthog.setGroupPropertiesForFlags')) {\n            return\n        }\n        this.featureFlags.setGroupPropertiesForFlags(properties, reloadFeatureFlags)\n    }\n\n    resetGroupPropertiesForFlags(group_type?: string): void {\n        this.featureFlags.resetGroupPropertiesForFlags(group_type)\n    }\n\n    /**\n     * Clears super properties and generates a new random distinct_id for this instance.\n     * Useful for clearing data when a user logs out.\n     */\n    reset(reset_device_id?: boolean): void {\n        logger.info('reset')\n        if (!this.__loaded) {\n            return logger.uninitializedWarning('posthog.reset')\n        }\n        const device_id = this.get_property('$device_id')\n        this.consent.reset()\n        this.persistence?.clear()\n        this.sessionPersistence?.clear()\n        this.persistence?.set_property(USER_STATE, 'anonymous')\n        this.sessionManager?.resetSessionId()\n        const uuid = this.config.get_device_id(uuidv7())\n        this.register_once(\n            {\n                distinct_id: uuid,\n                $device_id: reset_device_id ? uuid : device_id,\n            },\n            ''\n        )\n    }\n\n    /**\n     * Returns the current distinct id of the user. This is either the id automatically\n     * generated by the library or the id that has been passed by a call to identify().\n     *\n     * ### Notes:\n     *\n     * get_distinct_id() can only be called after the PostHog library has finished loading.\n     * init() has a loaded function available to handle this automatically. For example:\n     *\n     *     // set distinct_id after the posthog library has loaded\n     *     posthog.init('YOUR PROJECT TOKEN', {\n     *         loaded: function(posthog) {\n     *             distinct_id = posthog.get_distinct_id();\n     *         }\n     *     });\n     */\n    get_distinct_id(): string {\n        return this.get_property('distinct_id')\n    }\n\n    getGroups(): Record<string, any> {\n        return this.get_property('$groups') || {}\n    }\n\n    /**\n     * Returns the current session_id.\n     *\n     * NOTE: This should only be used for informative purposes.\n     * Any actual internal use case for the session_id should be handled by the sessionManager.\n     */\n\n    get_session_id(): string {\n        return this.sessionManager?.checkAndGetSessionAndWindowId(true).sessionId ?? ''\n    }\n\n    /**\n     * Returns the Replay url for the current session.\n     *\n     * @param options Options for the url\n     * @param options.withTimestamp Whether to include the timestamp in the url (defaults to false)\n     * @param options.timestampLookBack How many seconds to look back for the timestamp (defaults to 10)\n     */\n    get_session_replay_url(options?: { withTimestamp?: boolean; timestampLookBack?: number }): string {\n        if (!this.sessionManager) {\n            return ''\n        }\n        const { sessionId, sessionStartTimestamp } = this.sessionManager.checkAndGetSessionAndWindowId(true)\n        let url = this.requestRouter.endpointFor('ui', `/project/${this.config.token}/replay/${sessionId}`)\n        if (options?.withTimestamp && sessionStartTimestamp) {\n            const LOOK_BACK = options.timestampLookBack ?? 10\n            if (!sessionStartTimestamp) {\n                return url\n            }\n            const recordingStartTime = Math.max(\n                Math.floor((new Date().getTime() - sessionStartTimestamp) / 1000) - LOOK_BACK,\n                0\n            )\n            url += `?t=${recordingStartTime}`\n        }\n\n        return url\n    }\n\n    /**\n     * Create an alias, which PostHog will use to link two distinct_ids going forward (not retroactively).\n     * Multiple aliases can map to the same original ID, but not vice-versa. Aliases can also be chained - the\n     * following is a valid scenario:\n     *\n     *     posthog.alias('new_id', 'existing_id');\n     *     ...\n     *     posthog.alias('newer_id', 'new_id');\n     *\n     * If the original ID is not passed in, we will use the current distinct_id - probably the auto-generated GUID.\n     *\n     * ### Notes:\n     *\n     * The best practice is to call alias() when a unique ID is first created for a user\n     * (e.g., when a user first registers for an account and provides an email address).\n     * alias() should never be called more than once for a given user, except to\n     * chain a newer ID to a previously new ID, as described above.\n     *\n     * @param {String} alias A unique identifier that you want to use for this user in the future.\n     * @param {String} [original] The current identifier being used for this user.\n     */\n    alias(alias: string, original?: string): CaptureResult | void | number {\n        // If the $people_distinct_id key exists in persistence, there has been a previous\n        // posthog.people.identify() call made for this user. It is VERY BAD to make an alias with\n        // this ID, as it will duplicate users.\n        if (alias === this.get_property(PEOPLE_DISTINCT_ID_KEY)) {\n            logger.critical('Attempting to create alias for existing People user - aborting.')\n            return -2\n        }\n        if (!this._requirePersonProcessing('posthog.alias')) {\n            return\n        }\n\n        if (isUndefined(original)) {\n            original = this.get_distinct_id()\n        }\n        if (alias !== original) {\n            this._register_single(ALIAS_ID_KEY, alias)\n            return this.capture('$create_alias', { alias: alias, distinct_id: original })\n        } else {\n            logger.warn('alias matches current distinct_id - skipping api call.')\n            this.identify(alias)\n            return -1\n        }\n    }\n\n    /**\n     * Update the configuration of a posthog library instance.\n     *\n     * The default config is:\n     *\n     *     {\n     *       // PostHog API host\n     *       api_host: 'https://us.i.posthog.com',\n     *     *\n     *       // PostHog web app host, currently only used by the Sentry integration.\n     *       // This will only be different from api_host when using a reverse-proxied API host – in that case\n     *       // the original web app host needs to be passed here so that links to the web app are still convenient.\n     *       ui_host: 'https://us.posthog.com',\n     *\n     *       // Automatically capture clicks, form submissions and change events\n     *       autocapture: true\n     *\n     *       // Capture rage clicks\n     *       rageclick: true\n     *\n     *       // transport for sending requests ('XHR' or 'sendBeacon')\n     *       // NB: sendBeacon should only be used for scenarios such as\n     *       // page unload where a \"best-effort\" attempt to send is\n     *       // acceptable; the sendBeacon API does not support callbacks\n     *       // or any way to know the result of the request. PostHog\n     *       // capturing via sendBeacon will not support any event-\n     *       // batching or retry mechanisms.\n     *       api_transport: 'XHR'\n     *\n     *       // super properties cookie expiration (in days)\n     *       cookie_expiration: 365\n     *\n     *       // super properties span subdomains\n     *       cross_subdomain_cookie: true\n     *\n     *       // debug mode\n     *       debug: false\n     *\n     *       // if this is true, the posthog cookie or localStorage entry\n     *       // will be deleted, and no user persistence will take place\n     *       disable_persistence: false\n     *\n     *       // if this is true, PostHog will automatically determine\n     *       // City, Region and Country data using the IP address of\n     *       //the client\n     *       ip: true\n     *\n     *       // opt users out of capturing by this PostHog instance by default\n     *       opt_out_capturing_by_default: false\n     *\n     *       // opt users out of browser data storage by this PostHog instance by default\n     *       opt_out_persistence_by_default: false\n     *\n     *       // opt out of user agent filtering such as googlebot or other bots\n     *       opt_out_useragent_filter: false\n     *\n     *       // persistence mechanism used by opt-in/opt-out methods - cookie\n     *       // or localStorage - falls back to cookie if localStorage is unavailable\n     *       opt_out_capturing_persistence_type: 'localStorage'\n     *\n     *       // customize the name of cookie/localStorage set by opt-in/opt-out methods\n     *       opt_out_capturing_cookie_prefix: null\n     *\n     *       // type of persistent store for super properties (cookie/\n     *       // localStorage) if set to 'localStorage', any existing\n     *       // posthog cookie value with the same persistence_name\n     *       // will be transferred to localStorage and deleted\n     *       persistence: 'cookie'\n     *\n     *       // name for super properties persistent store\n     *       persistence_name: ''\n     *\n     *       // deprecated, use property_denylist instead.\n     *       // names of properties/superproperties which should never\n     *       // be sent with capture() calls.\n     *       property_blacklist: []\n     *\n     *       // names of properties/superproperties which should never\n     *       // be sent with capture() calls.\n     *       property_denylist: []\n     *\n     *       // if this is true, posthog cookies will be marked as\n     *       // secure, meaning they will only be transmitted over https\n     *       secure_cookie: false\n     *\n     *       // should we capture a page view on page load\n     *       capture_pageview: true\n     *\n     *       // if you set upgrade to be true, the library will check for\n     *       // a cookie from our old js library and import super\n     *       // properties from it, then the old cookie is deleted\n     *       // The upgrade config option only works in the initialization,\n     *       // so make sure you set it when you create the library.\n     *       upgrade: false\n     *\n     *       // if this is true, session recording is always disabled.\n     *       disable_session_recording: false,\n     *\n     *       // extra HTTP request headers to set for each API request, in\n     *       // the format {'Header-Name': value}\n     *       response_headers: {}\n     *\n     *       // protocol for fetching in-app message resources, e.g.\n     *       // 'https://' or 'http://'; defaults to '//' (which defers to the\n     *       // current page's protocol)\n     *       inapp_protocol: '//'\n     *\n     *       // whether to open in-app message link in new tab/window\n     *       inapp_link_new_window: false\n     *\n     *      // a set of rrweb config options that PostHog users can configure\n     *      // see https://github.com/rrweb-io/rrweb/blob/master/guide.md\n     *      session_recording: {\n     *         blockClass: 'ph-no-capture',\n     *         blockSelector: null,\n     *         ignoreClass: 'ph-ignore-input',\n     *         maskAllInputs: true,\n     *         maskInputOptions: {password: true},\n     *         maskInputFn: null,\n     *         slimDOMOptions: {},\n     *         collectFonts: false,\n     *         inlineStylesheet: true,\n     *      }\n     *\n     *      // prevent autocapture from capturing any attribute names on elements\n     *      mask_all_element_attributes: false\n     *\n     *      // prevent autocapture from capturing textContent on all elements\n     *      mask_all_text: false\n     *\n     *      // Anonymous users get a random UUID as their device by default.\n     *      // This option allows overriding that option.\n     *      get_device_id: (uuid) => uuid\n     *     }\n     *\n     *\n     * @param {Object} config A dictionary of new configuration values to update\n     */\n\n    set_config(config: Partial<PostHogConfig>): void {\n        const oldConfig = { ...this.config }\n        if (isObject(config)) {\n            extend(this.config, configRenames(config))\n\n            this.persistence?.update_config(this.config, oldConfig)\n            this.sessionPersistence =\n                this.config.persistence === 'sessionStorage'\n                    ? this.persistence\n                    : new PostHogPersistence({ ...this.config, persistence: 'sessionStorage' })\n\n            if (localStore.is_supported() && localStore.get('ph_debug') === 'true') {\n                this.config.debug = true\n            }\n            if (this.config.debug) {\n                Config.DEBUG = true\n                logger.info('set_config', {\n                    config,\n                    oldConfig,\n                    newConfig: { ...this.config },\n                })\n            }\n\n            this.sessionRecording?.startIfEnabledOrStop()\n            this.autocapture?.startIfEnabled()\n            this.heatmaps?.startIfEnabled()\n            this.surveys.loadIfEnabled()\n            this._sync_opt_out_with_persistence()\n        }\n    }\n\n    /**\n     * turns session recording on, and updates the config option `disable_session_recording` to false\n     * @param override.sampling - optional boolean to override the default sampling behavior - ensures the next session recording to start will not be skipped by sampling config.\n     * @param override.linked_flag - optional boolean to override the default linked_flag behavior - ensures the next session recording to start will not be skipped by linked_flag config.\n     * @param override - optional boolean to override the default sampling behavior - ensures the next session recording to start will not be skipped by sampling or linked_flag config. `true` is shorthand for { sampling: true, linked_flag: true }\n     */\n    startSessionRecording(override?: { sampling?: boolean; linked_flag?: boolean } | true): void {\n        const overrideAll = isBoolean(override) && override\n        if (overrideAll || override?.sampling) {\n            // allow the session id check to rotate session id if necessary\n            const ids = this.sessionManager?.checkAndGetSessionAndWindowId()\n            this.persistence?.register({\n                // short-circuits the `makeSamplingDecision` function in the session recording module\n                [SESSION_RECORDING_IS_SAMPLED]: true,\n            })\n            logger.info('Session recording started with sampling override for session: ', ids?.sessionId)\n        }\n        if (overrideAll || override?.linked_flag) {\n            this.sessionRecording?.overrideLinkedFlag()\n            logger.info('Session recording started with linked_flags override')\n        }\n        this.set_config({ disable_session_recording: false })\n    }\n\n    /**\n     * turns session recording off, and updates the config option\n     * disable_session_recording to true\n     */\n    stopSessionRecording(): void {\n        this.set_config({ disable_session_recording: true })\n    }\n\n    /**\n     * returns a boolean indicating whether session recording\n     * is currently running\n     */\n    sessionRecordingStarted(): boolean {\n        return !!this.sessionRecording?.started\n    }\n\n    /**\n     * returns a boolean indicating whether the toolbar loaded\n     * @param toolbarParams\n     */\n\n    loadToolbar(params: ToolbarParams): boolean {\n        return this.toolbar.loadToolbar(params)\n    }\n\n    /**\n     * Returns the value of the super property named property_name. If no such\n     * property is set, get_property() will return the undefined value.\n     *\n     * ### Notes:\n     *\n     * get_property() can only be called after the PostHog library has finished loading.\n     * init() has a loaded function available to handle this automatically. For example:\n     *\n     *     // grab value for '$user_id' after the posthog library has loaded\n     *     posthog.init('YOUR PROJECT TOKEN', {\n     *         loaded: function(posthog) {\n     *             user_id = posthog.get_property('$user_id');\n     *         }\n     *     });\n     *\n     * @param {String} property_name The name of the super property you want to retrieve\n     */\n    get_property(property_name: string): Property | undefined {\n        return this.persistence?.props[property_name]\n    }\n\n    /**\n     * Returns the value of the session super property named property_name. If no such\n     * property is set, getSessionProperty() will return the undefined value.\n     *\n     * ### Notes:\n     *\n     * This is based on browser-level `sessionStorage`, NOT the PostHog session.\n     * getSessionProperty() can only be called after the PostHog library has finished loading.\n     * init() has a loaded function available to handle this automatically. For example:\n     *\n     *     // grab value for 'user_id' after the posthog library has loaded\n     *     posthog.init('YOUR PROJECT TOKEN', {\n     *         loaded: function(posthog) {\n     *             user_id = posthog.getSessionProperty('user_id');\n     *         }\n     *     });\n     *\n     * @param {String} property_name The name of the session super property you want to retrieve\n     */\n    getSessionProperty(property_name: string): Property | undefined {\n        return this.sessionPersistence?.props[property_name]\n    }\n\n    toString(): string {\n        let name = this.config.name ?? PRIMARY_INSTANCE_NAME\n        if (name !== PRIMARY_INSTANCE_NAME) {\n            name = PRIMARY_INSTANCE_NAME + '.' + name\n        }\n        return name\n    }\n\n    _isIdentified(): boolean {\n        return (\n            this.persistence?.get_property(USER_STATE) === 'identified' ||\n            this.sessionPersistence?.get_property(USER_STATE) === 'identified'\n        )\n    }\n\n    _hasPersonProcessing(): boolean {\n        return !(\n            this.config.person_profiles === 'never' ||\n            (this.config.person_profiles === 'identified_only' &&\n                !this._isIdentified() &&\n                isEmptyObject(this.getGroups()) &&\n                !this.persistence?.props?.[ALIAS_ID_KEY] &&\n                !this.persistence?.props?.[ENABLE_PERSON_PROCESSING])\n        )\n    }\n\n    _shouldCapturePageleave(): boolean {\n        return (\n            this.config.capture_pageleave === true ||\n            (this.config.capture_pageleave === 'if_capture_pageview' && this.config.capture_pageview)\n        )\n    }\n\n    /**\n     *  Creates a person profile for the current user, if they don't already have one and config.person_profiles is set\n     *  to 'identified_only'. Produces a warning and does not create a profile if config.person_profiles is set to\n     *  'never'.\n     */\n    createPersonProfile(): void {\n        if (this._hasPersonProcessing()) {\n            // if a person profile already exists, don't send an event when we don't need to\n            return\n        }\n        if (!this._requirePersonProcessing('posthog.createPersonProfile')) {\n            return\n        }\n        // sent a $set event. We don't set any properties here, but attribution props will be added later\n        this.setPersonProperties({}, {})\n    }\n\n    /**\n     * Enables person processing if possible, returns true if it does so or already enabled, false otherwise\n     *\n     * @param function_name\n     */\n    _requirePersonProcessing(function_name: string): boolean {\n        if (this.config.person_profiles === 'never') {\n            logger.error(\n                function_name + ' was called, but process_person is set to \"never\". This call will be ignored.'\n            )\n            return false\n        }\n        this._register_single(ENABLE_PERSON_PROCESSING, true)\n        return true\n    }\n\n    /**\n     * Enable or disable persistence based on options\n     * only enable/disable if persistence is not already in this state\n     * @param {boolean} [disabled] If true, will re-enable sdk persistence\n     */\n    private _sync_opt_out_with_persistence(): void {\n        const isOptedOut = this.consent.isOptedOut()\n        const defaultPersistenceDisabled = this.config.opt_out_persistence_by_default\n\n        // TRICKY: We want a deterministic state for persistence so that a new pageload has the same persistence\n        const persistenceDisabled = this.config.disable_persistence || (isOptedOut && !!defaultPersistenceDisabled)\n\n        if (this.persistence?.disabled !== persistenceDisabled) {\n            this.persistence?.set_disabled(persistenceDisabled)\n        }\n        if (this.sessionPersistence?.disabled !== persistenceDisabled) {\n            this.sessionPersistence?.set_disabled(persistenceDisabled)\n        }\n    }\n\n    /**\n     * Opt the user in to data capturing and cookies/localstorage for this PostHog instance\n     * If the config.opt_out_persistence_by_default is set to false, the SDK persistence will be enabled.\n     *\n     * ### Usage\n     *\n     *     // opt user in\n     *     posthog.opt_in_capturing();\n     *\n     *     // opt user in with specific event name, properties, cookie configuration\n     *     posthog.opt_in_capturing({\n     *         capture_event_name: 'User opted in',\n     *         capture_event_properties: {\n     *             'email': 'jdoe@example.com'\n     *         }\n     *     });\n     *\n     * @param {Object} [config] A dictionary of config options to override\n     * @param {string} [config.capture_event_name=$opt_in] Event name to be used for capturing the opt-in action. Set to `null` or `false` to skip capturing the optin event\n     * @param {Object} [config.capture_properties] Set of properties to be captured along with the opt-in action\n     */\n    opt_in_capturing(options?: {\n        captureEventName?: string | null | false /** event name to be used for capturing the opt-in action */\n        captureProperties?: Properties /** set of properties to be captured along with the opt-in action */\n    }): void {\n        this.consent.optInOut(true)\n        this._sync_opt_out_with_persistence()\n\n        if (!isUndefined(options?.captureEventName) && !options?.captureEventName) {\n            // Don't capture if captureEventName is null or false\n            return\n        }\n\n        this.capture(options?.captureEventName ?? '$opt_in', options?.captureProperties, { send_instantly: true })\n    }\n\n    /**\n     * Opt the user out of data capturing and cookies/localstorage for this PostHog instance.\n     * If the config.opt_out_persistence_by_default is set to true, the SDK persistence will be disabled.\n     *\n     * ### Usage\n     *\n     *     // opt user out\n     *     posthog.opt_out_capturing()\n     */\n    opt_out_capturing(): void {\n        this.consent.optInOut(false)\n        this._sync_opt_out_with_persistence()\n    }\n\n    /**\n     * Check whether the user has opted in to data capturing and cookies/localstorage for this PostHog instance\n     *\n     * ### Usage\n     *\n     *     const has_opted_in = posthog.has_opted_in_capturing();\n     *     // use has_opted_in value\n     *\n     * @returns {boolean} current opt-in status\n     */\n    has_opted_in_capturing(): boolean {\n        return this.consent.isOptedIn()\n    }\n\n    /**\n     * Check whether the user has opted out of data capturing and cookies/localstorage for this PostHog instance\n     *\n     * ### Usage\n     *\n     *     const has_opted_out = posthog.has_opted_out_capturing();\n     *     // use has_opted_out value\n     *\n     * @returns {boolean} current opt-out status\n     */\n    has_opted_out_capturing(): boolean {\n        return this.consent.isOptedOut()\n    }\n\n    /**\n     * Clear the user's opt in/out status of data capturing and cookies/localstorage for this PostHog instance\n     *\n     * ### Usage\n     *\n     *     // clear user's opt-in/out status\n     *     posthog.clear_opt_in_out_capturing();\n     *     *\n     * @param {Object} [config] A dictionary of config options to override\n     */\n    clear_opt_in_out_capturing(): void {\n        this.consent.reset()\n        this._sync_opt_out_with_persistence()\n    }\n\n    _is_bot(): boolean | undefined {\n        if (navigator) {\n            return isLikelyBot(navigator, this.config.custom_blocked_useragents)\n        } else {\n            return undefined\n        }\n    }\n\n    debug(debug?: boolean): void {\n        if (debug === false) {\n            window?.console.log(\"You've disabled debug mode.\")\n            localStorage && localStorage.removeItem('ph_debug')\n            this.set_config({ debug: false })\n        } else {\n            window?.console.log(\n                \"You're now in debug mode. All calls to PostHog will be logged in your console.\\nYou can disable this with `posthog.debug(false)`.\"\n            )\n            localStorage && localStorage.setItem('ph_debug', 'true')\n            this.set_config({ debug: true })\n        }\n    }\n}\n\nsafewrapClass(PostHog, ['identify'])\n\nconst add_dom_loaded_handler = function () {\n    // Cross browser DOM Loaded support\n    function dom_loaded_handler() {\n        // function flag since we only want to execute this once\n        if ((dom_loaded_handler as any).done) {\n            return\n        }\n        ;(dom_loaded_handler as any).done = true\n\n        ENQUEUE_REQUESTS = false\n\n        each(instances, function (inst: PostHog) {\n            inst._dom_loaded()\n        })\n    }\n\n    if (document?.addEventListener) {\n        if (document.readyState === 'complete') {\n            // safari 4 can fire the DOMContentLoaded event before loading all\n            // external JS (including this file). you will see some copypasta\n            // on the internet that checks for 'complete' and 'loaded', but\n            // 'loaded' is an IE thing\n            dom_loaded_handler()\n        } else {\n            document.addEventListener('DOMContentLoaded', dom_loaded_handler, false)\n        }\n    }\n\n    // fallback handler, always will work\n    if (window) {\n        registerEvent(window, 'load', dom_loaded_handler, true)\n    }\n}\n\nexport function init_from_snippet(): void {\n    const posthogMain = (instances[PRIMARY_INSTANCE_NAME] = new PostHog())\n\n    const snippetPostHog = assignableWindow['posthog']\n\n    if (snippetPostHog) {\n        /**\n         * The snippet uses some clever tricks to allow deferred loading of array.js (this code)\n         *\n         * window.posthog is an array which the queue of calls made before the lib is loaded\n         * It has methods attached to it to simulate the posthog object so for instance\n         *\n         * window.posthog.init(\"TOKEN\", {api_host: \"foo\" })\n         * window.posthog.capture(\"my-event\", {foo: \"bar\" })\n         *\n         * ... will mean that window.posthog will look like this:\n         * window.posthog == [\n         *  [\"my-event\", {foo: \"bar\"}]\n         * ]\n         *\n         * window.posthog[_i] == [\n         *   [\"TOKEN\", {api_host: \"foo\" }, \"posthog\"]\n         * ]\n         *\n         * If a name is given to the init function then the same as above is true but as a sub-property on the object:\n         *\n         * window.posthog.init(\"TOKEN\", {}, \"ph2\")\n         * window.posthog.ph2.people.set({foo: \"bar\"})\n         *\n         * window.posthog.ph2 == []\n         * window.posthog.people == [\n         *  [\"set\", {foo: \"bar\"}]\n         * ]\n         *\n         */\n\n        // Call all pre-loaded init calls properly\n\n        each(snippetPostHog['_i'], function (item: [token: string, config: Partial<PostHogConfig>, name: string]) {\n            if (item && isArray(item)) {\n                const instance = posthogMain.init(item[0], item[1], item[2])\n\n                const instanceSnippet = snippetPostHog[item[2]] || snippetPostHog\n\n                if (instance) {\n                    // Crunch through the people queue first - we queue this data up &\n                    // flush on identify, so it's better to do all these operations first\n                    instance._execute_array.call(instance.people, instanceSnippet.people)\n                    instance._execute_array(instanceSnippet)\n                }\n            }\n        })\n    }\n\n    assignableWindow['posthog'] = posthogMain\n\n    add_dom_loaded_handler()\n}\n\nexport function init_as_module(): PostHog {\n    const posthogMain = (instances[PRIMARY_INSTANCE_NAME] = new PostHog())\n\n    add_dom_loaded_handler()\n\n    return posthogMain\n}\n","/**\n * Extend Segment with extra PostHog JS functionality. Required for things like Recordings and feature flags to work correctly.\n *\n * ### Usage\n *\n *  ```js\n *  // After your standard segment anyalytics install\n *  analytics.load(\"GOEDfA21zZTtR7clsBuDvmBKAtAdZ6Np\");\n *\n *  analytics.ready(() => {\n *    posthog.init('<posthog-api-key>', {\n *      capture_pageview: false,\n *      segment: window.analytics, // NOTE: Be sure to use window.analytics here!\n *    });\n *    window.analytics.page();\n *  })\n *  ```\n */\nimport { PostHog } from '../posthog-core'\nimport { logger } from '../utils/logger'\n\nimport { uuidv7 } from '../uuidv7'\nimport { isFunction } from '../utils/type-utils'\nimport { USER_STATE } from '../constants'\n\nexport type SegmentUser = {\n    anonymousId(): string | undefined\n    id(): string | undefined\n}\n\nexport type SegmentAnalytics = {\n    user: () => SegmentUser | Promise<SegmentUser>\n    register: (integration: SegmentPlugin) => Promise<void>\n}\n\n// Loosely based on https://github.com/segmentio/analytics-next/blob/master/packages/core/src/plugins/index.ts\ninterface SegmentContext {\n    event: {\n        event: string\n        userId?: string\n        anonymousId?: string\n        properties: any\n    }\n}\n\ntype SegmentFunction = (ctx: SegmentContext) => Promise<SegmentContext> | SegmentContext\n\ninterface SegmentPlugin {\n    name: string\n    version: string\n    type: 'enrichment'\n    isLoaded: () => boolean\n    load: (ctx: SegmentContext, instance: any, config?: any) => Promise<unknown>\n    unload?: (ctx: SegmentContext, instance: any) => Promise<unknown> | unknown\n    ready?: () => Promise<unknown>\n    track?: SegmentFunction\n    identify?: SegmentFunction\n    page?: SegmentFunction\n    group?: SegmentFunction\n    alias?: SegmentFunction\n    screen?: SegmentFunction\n}\n\nconst createSegmentIntegration = (posthog: PostHog): SegmentPlugin => {\n    if (!Promise || !Promise.resolve) {\n        logger.warn('This browser does not have Promise support, and can not use the segment integration')\n    }\n\n    const enrichEvent = (ctx: SegmentContext, eventName: string | undefined) => {\n        if (!eventName) {\n            return ctx\n        }\n        if (!ctx.event.userId && ctx.event.anonymousId !== posthog.get_distinct_id()) {\n            // This is our only way of detecting that segment's analytics.reset() has been called so we also call it\n            posthog.reset()\n        }\n        if (ctx.event.userId && ctx.event.userId !== posthog.get_distinct_id()) {\n            posthog.register({\n                distinct_id: ctx.event.userId,\n            })\n            posthog.reloadFeatureFlags()\n        }\n\n        const additionalProperties = posthog._calculate_event_properties(\n            eventName,\n            ctx.event.properties ?? {},\n            new Date()\n        )\n        ctx.event.properties = Object.assign({}, additionalProperties, ctx.event.properties)\n        return ctx\n    }\n\n    return {\n        name: 'PostHog JS',\n        type: 'enrichment',\n        version: '1.0.0',\n        isLoaded: () => true,\n        // check and early return above\n        // eslint-disable-next-line compat/compat\n        load: () => Promise.resolve(),\n        track: (ctx) => enrichEvent(ctx, ctx.event.event),\n        page: (ctx) => enrichEvent(ctx, '$pageview'),\n        identify: (ctx) => enrichEvent(ctx, '$identify'),\n        screen: (ctx) => enrichEvent(ctx, '$screen'),\n    }\n}\n\nfunction setupPostHogFromSegment(posthog: PostHog, done: () => void) {\n    const segment = posthog.config.segment\n    if (!segment) {\n        return done()\n    }\n\n    const bootstrapUser = (user: SegmentUser) => {\n        // Use segments anonymousId instead\n        const getSegmentAnonymousId = () => user.anonymousId() || uuidv7()\n        posthog.config.get_device_id = getSegmentAnonymousId\n\n        // If a segment user ID exists, set it as the distinct_id\n        if (user.id()) {\n            posthog.register({\n                distinct_id: user.id(),\n                $device_id: getSegmentAnonymousId(),\n            })\n            posthog.persistence!.set_property(USER_STATE, 'identified')\n        }\n\n        done()\n    }\n\n    const segmentUser = segment.user()\n\n    // If segmentUser is a promise then we need to wait for it to resolve\n    if ('then' in segmentUser && isFunction(segmentUser.then)) {\n        segmentUser.then((user) => bootstrapUser(user))\n    } else {\n        bootstrapUser(segmentUser as SegmentUser)\n    }\n}\n\nexport function setupSegmentIntegration(posthog: PostHog, done: () => void) {\n    const segment = posthog.config.segment\n    if (!segment) {\n        return done()\n    }\n\n    setupPostHogFromSegment(posthog, () => {\n        segment.register(createSegmentIntegration(posthog)).then(() => {\n            done()\n        })\n    })\n}\n","import { init_as_module } from '../posthog-core'\nexport { PostHog } from '../posthog-core'\nexport * from '../types'\nexport * from '../posthog-surveys-types'\nexport const posthog = init_as_module()\nexport default posthog\n","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n","\nconst canPromise = require('./can-promise')\n\nconst QRCode = require('./core/qrcode')\nconst CanvasRenderer = require('./renderer/canvas')\nconst SvgRenderer = require('./renderer/svg-tag.js')\n\nfunction renderCanvas (renderFunc, canvas, text, opts, cb) {\n  const args = [].slice.call(arguments, 1)\n  const argsNum = args.length\n  const isLastArgCb = typeof args[argsNum - 1] === 'function'\n\n  if (!isLastArgCb && !canPromise()) {\n    throw new Error('Callback required as last argument')\n  }\n\n  if (isLastArgCb) {\n    if (argsNum < 2) {\n      throw new Error('Too few arguments provided')\n    }\n\n    if (argsNum === 2) {\n      cb = text\n      text = canvas\n      canvas = opts = undefined\n    } else if (argsNum === 3) {\n      if (canvas.getContext && typeof cb === 'undefined') {\n        cb = opts\n        opts = undefined\n      } else {\n        cb = opts\n        opts = text\n        text = canvas\n        canvas = undefined\n      }\n    }\n  } else {\n    if (argsNum < 1) {\n      throw new Error('Too few arguments provided')\n    }\n\n    if (argsNum === 1) {\n      text = canvas\n      canvas = opts = undefined\n    } else if (argsNum === 2 && !canvas.getContext) {\n      opts = text\n      text = canvas\n      canvas = undefined\n    }\n\n    return new Promise(function (resolve, reject) {\n      try {\n        const data = QRCode.create(text, opts)\n        resolve(renderFunc(data, canvas, opts))\n      } catch (e) {\n        reject(e)\n      }\n    })\n  }\n\n  try {\n    const data = QRCode.create(text, opts)\n    cb(null, renderFunc(data, canvas, opts))\n  } catch (e) {\n    cb(e)\n  }\n}\n\nexports.create = QRCode.create\nexports.toCanvas = renderCanvas.bind(null, CanvasRenderer.render)\nexports.toDataURL = renderCanvas.bind(null, CanvasRenderer.renderToDataURL)\n\n// only svg for now.\nexports.toString = renderCanvas.bind(null, function (data, _, opts) {\n  return SvgRenderer.render(data, opts)\n})\n","// can-promise has a crash in some versions of react native that dont have\n// standard global objects\n// https://github.com/soldair/node-qrcode/issues/157\n\nmodule.exports = function () {\n  return typeof Promise === 'function' && Promise.prototype && Promise.prototype.then\n}\n","/**\n * Alignment pattern are fixed reference pattern in defined positions\n * in a matrix symbology, which enables the decode software to re-synchronise\n * the coordinate mapping of the image modules in the event of moderate amounts\n * of distortion of the image.\n *\n * Alignment patterns are present only in QR Code symbols of version 2 or larger\n * and their number depends on the symbol version.\n */\n\nconst getSymbolSize = require('./utils').getSymbolSize\n\n/**\n * Calculate the row/column coordinates of the center module of each alignment pattern\n * for the specified QR Code version.\n *\n * The alignment patterns are positioned symmetrically on either side of the diagonal\n * running from the top left corner of the symbol to the bottom right corner.\n *\n * Since positions are simmetrical only half of the coordinates are returned.\n * Each item of the array will represent in turn the x and y coordinate.\n * @see {@link getPositions}\n *\n * @param  {Number} version QR Code version\n * @return {Array}          Array of coordinate\n */\nexports.getRowColCoords = function getRowColCoords (version) {\n  if (version === 1) return []\n\n  const posCount = Math.floor(version / 7) + 2\n  const size = getSymbolSize(version)\n  const intervals = size === 145 ? 26 : Math.ceil((size - 13) / (2 * posCount - 2)) * 2\n  const positions = [size - 7] // Last coord is always (size - 7)\n\n  for (let i = 1; i < posCount - 1; i++) {\n    positions[i] = positions[i - 1] - intervals\n  }\n\n  positions.push(6) // First coord is always 6\n\n  return positions.reverse()\n}\n\n/**\n * Returns an array containing the positions of each alignment pattern.\n * Each array's element represent the center point of the pattern as (x, y) coordinates\n *\n * Coordinates are calculated expanding the row/column coordinates returned by {@link getRowColCoords}\n * and filtering out the items that overlaps with finder pattern\n *\n * @example\n * For a Version 7 symbol {@link getRowColCoords} returns values 6, 22 and 38.\n * The alignment patterns, therefore, are to be centered on (row, column)\n * positions (6,22), (22,6), (22,22), (22,38), (38,22), (38,38).\n * Note that the coordinates (6,6), (6,38), (38,6) are occupied by finder patterns\n * and are not therefore used for alignment patterns.\n *\n * let pos = getPositions(7)\n * // [[6,22], [22,6], [22,22], [22,38], [38,22], [38,38]]\n *\n * @param  {Number} version QR Code version\n * @return {Array}          Array of coordinates\n */\nexports.getPositions = function getPositions (version) {\n  const coords = []\n  const pos = exports.getRowColCoords(version)\n  const posLength = pos.length\n\n  for (let i = 0; i < posLength; i++) {\n    for (let j = 0; j < posLength; j++) {\n      // Skip if position is occupied by finder patterns\n      if ((i === 0 && j === 0) || // top-left\n          (i === 0 && j === posLength - 1) || // bottom-left\n          (i === posLength - 1 && j === 0)) { // top-right\n        continue\n      }\n\n      coords.push([pos[i], pos[j]])\n    }\n  }\n\n  return coords\n}\n","const Mode = require('./mode')\n\n/**\n * Array of characters available in alphanumeric mode\n *\n * As per QR Code specification, to each character\n * is assigned a value from 0 to 44 which in this case coincides\n * with the array index\n *\n * @type {Array}\n */\nconst ALPHA_NUM_CHARS = [\n  '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',\n  'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',\n  'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',\n  ' ', '$', '%', '*', '+', '-', '.', '/', ':'\n]\n\nfunction AlphanumericData (data) {\n  this.mode = Mode.ALPHANUMERIC\n  this.data = data\n}\n\nAlphanumericData.getBitsLength = function getBitsLength (length) {\n  return 11 * Math.floor(length / 2) + 6 * (length % 2)\n}\n\nAlphanumericData.prototype.getLength = function getLength () {\n  return this.data.length\n}\n\nAlphanumericData.prototype.getBitsLength = function getBitsLength () {\n  return AlphanumericData.getBitsLength(this.data.length)\n}\n\nAlphanumericData.prototype.write = function write (bitBuffer) {\n  let i\n\n  // Input data characters are divided into groups of two characters\n  // and encoded as 11-bit binary codes.\n  for (i = 0; i + 2 <= this.data.length; i += 2) {\n    // The character value of the first character is multiplied by 45\n    let value = ALPHA_NUM_CHARS.indexOf(this.data[i]) * 45\n\n    // The character value of the second digit is added to the product\n    value += ALPHA_NUM_CHARS.indexOf(this.data[i + 1])\n\n    // The sum is then stored as 11-bit binary number\n    bitBuffer.put(value, 11)\n  }\n\n  // If the number of input data characters is not a multiple of two,\n  // the character value of the final character is encoded as a 6-bit binary number.\n  if (this.data.length % 2) {\n    bitBuffer.put(ALPHA_NUM_CHARS.indexOf(this.data[i]), 6)\n  }\n}\n\nmodule.exports = AlphanumericData\n","function BitBuffer () {\n  this.buffer = []\n  this.length = 0\n}\n\nBitBuffer.prototype = {\n\n  get: function (index) {\n    const bufIndex = Math.floor(index / 8)\n    return ((this.buffer[bufIndex] >>> (7 - index % 8)) & 1) === 1\n  },\n\n  put: function (num, length) {\n    for (let i = 0; i < length; i++) {\n      this.putBit(((num >>> (length - i - 1)) & 1) === 1)\n    }\n  },\n\n  getLengthInBits: function () {\n    return this.length\n  },\n\n  putBit: function (bit) {\n    const bufIndex = Math.floor(this.length / 8)\n    if (this.buffer.length <= bufIndex) {\n      this.buffer.push(0)\n    }\n\n    if (bit) {\n      this.buffer[bufIndex] |= (0x80 >>> (this.length % 8))\n    }\n\n    this.length++\n  }\n}\n\nmodule.exports = BitBuffer\n","/**\n * Helper class to handle QR Code symbol modules\n *\n * @param {Number} size Symbol size\n */\nfunction BitMatrix (size) {\n  if (!size || size < 1) {\n    throw new Error('BitMatrix size must be defined and greater than 0')\n  }\n\n  this.size = size\n  this.data = new Uint8Array(size * size)\n  this.reservedBit = new Uint8Array(size * size)\n}\n\n/**\n * Set bit value at specified location\n * If reserved flag is set, this bit will be ignored during masking process\n *\n * @param {Number}  row\n * @param {Number}  col\n * @param {Boolean} value\n * @param {Boolean} reserved\n */\nBitMatrix.prototype.set = function (row, col, value, reserved) {\n  const index = row * this.size + col\n  this.data[index] = value\n  if (reserved) this.reservedBit[index] = true\n}\n\n/**\n * Returns bit value at specified location\n *\n * @param  {Number}  row\n * @param  {Number}  col\n * @return {Boolean}\n */\nBitMatrix.prototype.get = function (row, col) {\n  return this.data[row * this.size + col]\n}\n\n/**\n * Applies xor operator at specified location\n * (used during masking process)\n *\n * @param {Number}  row\n * @param {Number}  col\n * @param {Boolean} value\n */\nBitMatrix.prototype.xor = function (row, col, value) {\n  this.data[row * this.size + col] ^= value\n}\n\n/**\n * Check if bit at specified location is reserved\n *\n * @param {Number}   row\n * @param {Number}   col\n * @return {Boolean}\n */\nBitMatrix.prototype.isReserved = function (row, col) {\n  return this.reservedBit[row * this.size + col]\n}\n\nmodule.exports = BitMatrix\n","const Mode = require('./mode')\n\nfunction ByteData (data) {\n  this.mode = Mode.BYTE\n  if (typeof (data) === 'string') {\n    this.data = new TextEncoder().encode(data)\n  } else {\n    this.data = new Uint8Array(data)\n  }\n}\n\nByteData.getBitsLength = function getBitsLength (length) {\n  return length * 8\n}\n\nByteData.prototype.getLength = function getLength () {\n  return this.data.length\n}\n\nByteData.prototype.getBitsLength = function getBitsLength () {\n  return ByteData.getBitsLength(this.data.length)\n}\n\nByteData.prototype.write = function (bitBuffer) {\n  for (let i = 0, l = this.data.length; i < l; i++) {\n    bitBuffer.put(this.data[i], 8)\n  }\n}\n\nmodule.exports = ByteData\n","const ECLevel = require('./error-correction-level')\r\n\r\nconst EC_BLOCKS_TABLE = [\r\n// L  M  Q  H\r\n  1, 1, 1, 1,\r\n  1, 1, 1, 1,\r\n  1, 1, 2, 2,\r\n  1, 2, 2, 4,\r\n  1, 2, 4, 4,\r\n  2, 4, 4, 4,\r\n  2, 4, 6, 5,\r\n  2, 4, 6, 6,\r\n  2, 5, 8, 8,\r\n  4, 5, 8, 8,\r\n  4, 5, 8, 11,\r\n  4, 8, 10, 11,\r\n  4, 9, 12, 16,\r\n  4, 9, 16, 16,\r\n  6, 10, 12, 18,\r\n  6, 10, 17, 16,\r\n  6, 11, 16, 19,\r\n  6, 13, 18, 21,\r\n  7, 14, 21, 25,\r\n  8, 16, 20, 25,\r\n  8, 17, 23, 25,\r\n  9, 17, 23, 34,\r\n  9, 18, 25, 30,\r\n  10, 20, 27, 32,\r\n  12, 21, 29, 35,\r\n  12, 23, 34, 37,\r\n  12, 25, 34, 40,\r\n  13, 26, 35, 42,\r\n  14, 28, 38, 45,\r\n  15, 29, 40, 48,\r\n  16, 31, 43, 51,\r\n  17, 33, 45, 54,\r\n  18, 35, 48, 57,\r\n  19, 37, 51, 60,\r\n  19, 38, 53, 63,\r\n  20, 40, 56, 66,\r\n  21, 43, 59, 70,\r\n  22, 45, 62, 74,\r\n  24, 47, 65, 77,\r\n  25, 49, 68, 81\r\n]\r\n\r\nconst EC_CODEWORDS_TABLE = [\r\n// L  M  Q  H\r\n  7, 10, 13, 17,\r\n  10, 16, 22, 28,\r\n  15, 26, 36, 44,\r\n  20, 36, 52, 64,\r\n  26, 48, 72, 88,\r\n  36, 64, 96, 112,\r\n  40, 72, 108, 130,\r\n  48, 88, 132, 156,\r\n  60, 110, 160, 192,\r\n  72, 130, 192, 224,\r\n  80, 150, 224, 264,\r\n  96, 176, 260, 308,\r\n  104, 198, 288, 352,\r\n  120, 216, 320, 384,\r\n  132, 240, 360, 432,\r\n  144, 280, 408, 480,\r\n  168, 308, 448, 532,\r\n  180, 338, 504, 588,\r\n  196, 364, 546, 650,\r\n  224, 416, 600, 700,\r\n  224, 442, 644, 750,\r\n  252, 476, 690, 816,\r\n  270, 504, 750, 900,\r\n  300, 560, 810, 960,\r\n  312, 588, 870, 1050,\r\n  336, 644, 952, 1110,\r\n  360, 700, 1020, 1200,\r\n  390, 728, 1050, 1260,\r\n  420, 784, 1140, 1350,\r\n  450, 812, 1200, 1440,\r\n  480, 868, 1290, 1530,\r\n  510, 924, 1350, 1620,\r\n  540, 980, 1440, 1710,\r\n  570, 1036, 1530, 1800,\r\n  570, 1064, 1590, 1890,\r\n  600, 1120, 1680, 1980,\r\n  630, 1204, 1770, 2100,\r\n  660, 1260, 1860, 2220,\r\n  720, 1316, 1950, 2310,\r\n  750, 1372, 2040, 2430\r\n]\r\n\r\n/**\r\n * Returns the number of error correction block that the QR Code should contain\r\n * for the specified version and error correction level.\r\n *\r\n * @param  {Number} version              QR Code version\r\n * @param  {Number} errorCorrectionLevel Error correction level\r\n * @return {Number}                      Number of error correction blocks\r\n */\r\nexports.getBlocksCount = function getBlocksCount (version, errorCorrectionLevel) {\r\n  switch (errorCorrectionLevel) {\r\n    case ECLevel.L:\r\n      return EC_BLOCKS_TABLE[(version - 1) * 4 + 0]\r\n    case ECLevel.M:\r\n      return EC_BLOCKS_TABLE[(version - 1) * 4 + 1]\r\n    case ECLevel.Q:\r\n      return EC_BLOCKS_TABLE[(version - 1) * 4 + 2]\r\n    case ECLevel.H:\r\n      return EC_BLOCKS_TABLE[(version - 1) * 4 + 3]\r\n    default:\r\n      return undefined\r\n  }\r\n}\r\n\r\n/**\r\n * Returns the number of error correction codewords to use for the specified\r\n * version and error correction level.\r\n *\r\n * @param  {Number} version              QR Code version\r\n * @param  {Number} errorCorrectionLevel Error correction level\r\n * @return {Number}                      Number of error correction codewords\r\n */\r\nexports.getTotalCodewordsCount = function getTotalCodewordsCount (version, errorCorrectionLevel) {\r\n  switch (errorCorrectionLevel) {\r\n    case ECLevel.L:\r\n      return EC_CODEWORDS_TABLE[(version - 1) * 4 + 0]\r\n    case ECLevel.M:\r\n      return EC_CODEWORDS_TABLE[(version - 1) * 4 + 1]\r\n    case ECLevel.Q:\r\n      return EC_CODEWORDS_TABLE[(version - 1) * 4 + 2]\r\n    case ECLevel.H:\r\n      return EC_CODEWORDS_TABLE[(version - 1) * 4 + 3]\r\n    default:\r\n      return undefined\r\n  }\r\n}\r\n","exports.L = { bit: 1 }\nexports.M = { bit: 0 }\nexports.Q = { bit: 3 }\nexports.H = { bit: 2 }\n\nfunction fromString (string) {\n  if (typeof string !== 'string') {\n    throw new Error('Param is not a string')\n  }\n\n  const lcStr = string.toLowerCase()\n\n  switch (lcStr) {\n    case 'l':\n    case 'low':\n      return exports.L\n\n    case 'm':\n    case 'medium':\n      return exports.M\n\n    case 'q':\n    case 'quartile':\n      return exports.Q\n\n    case 'h':\n    case 'high':\n      return exports.H\n\n    default:\n      throw new Error('Unknown EC Level: ' + string)\n  }\n}\n\nexports.isValid = function isValid (level) {\n  return level && typeof level.bit !== 'undefined' &&\n    level.bit >= 0 && level.bit < 4\n}\n\nexports.from = function from (value, defaultValue) {\n  if (exports.isValid(value)) {\n    return value\n  }\n\n  try {\n    return fromString(value)\n  } catch (e) {\n    return defaultValue\n  }\n}\n","const getSymbolSize = require('./utils').getSymbolSize\nconst FINDER_PATTERN_SIZE = 7\n\n/**\n * Returns an array containing the positions of each finder pattern.\n * Each array's element represent the top-left point of the pattern as (x, y) coordinates\n *\n * @param  {Number} version QR Code version\n * @return {Array}          Array of coordinates\n */\nexports.getPositions = function getPositions (version) {\n  const size = getSymbolSize(version)\n\n  return [\n    // top-left\n    [0, 0],\n    // top-right\n    [size - FINDER_PATTERN_SIZE, 0],\n    // bottom-left\n    [0, size - FINDER_PATTERN_SIZE]\n  ]\n}\n","const Utils = require('./utils')\n\nconst G15 = (1 << 10) | (1 << 8) | (1 << 5) | (1 << 4) | (1 << 2) | (1 << 1) | (1 << 0)\nconst G15_MASK = (1 << 14) | (1 << 12) | (1 << 10) | (1 << 4) | (1 << 1)\nconst G15_BCH = Utils.getBCHDigit(G15)\n\n/**\n * Returns format information with relative error correction bits\n *\n * The format information is a 15-bit sequence containing 5 data bits,\n * with 10 error correction bits calculated using the (15, 5) BCH code.\n *\n * @param  {Number} errorCorrectionLevel Error correction level\n * @param  {Number} mask                 Mask pattern\n * @return {Number}                      Encoded format information bits\n */\nexports.getEncodedBits = function getEncodedBits (errorCorrectionLevel, mask) {\n  const data = ((errorCorrectionLevel.bit << 3) | mask)\n  let d = data << 10\n\n  while (Utils.getBCHDigit(d) - G15_BCH >= 0) {\n    d ^= (G15 << (Utils.getBCHDigit(d) - G15_BCH))\n  }\n\n  // xor final data with mask pattern in order to ensure that\n  // no combination of Error Correction Level and data mask pattern\n  // will result in an all-zero data string\n  return ((data << 10) | d) ^ G15_MASK\n}\n","const EXP_TABLE = new Uint8Array(512)\nconst LOG_TABLE = new Uint8Array(256)\n/**\n * Precompute the log and anti-log tables for faster computation later\n *\n * For each possible value in the galois field 2^8, we will pre-compute\n * the logarithm and anti-logarithm (exponential) of this value\n *\n * ref {@link https://en.wikiversity.org/wiki/Reed%E2%80%93Solomon_codes_for_coders#Introduction_to_mathematical_fields}\n */\n;(function initTables () {\n  let x = 1\n  for (let i = 0; i < 255; i++) {\n    EXP_TABLE[i] = x\n    LOG_TABLE[x] = i\n\n    x <<= 1 // multiply by 2\n\n    // The QR code specification says to use byte-wise modulo 100011101 arithmetic.\n    // This means that when a number is 256 or larger, it should be XORed with 0x11D.\n    if (x & 0x100) { // similar to x >= 256, but a lot faster (because 0x100 == 256)\n      x ^= 0x11D\n    }\n  }\n\n  // Optimization: double the size of the anti-log table so that we don't need to mod 255 to\n  // stay inside the bounds (because we will mainly use this table for the multiplication of\n  // two GF numbers, no more).\n  // @see {@link mul}\n  for (let i = 255; i < 512; i++) {\n    EXP_TABLE[i] = EXP_TABLE[i - 255]\n  }\n}())\n\n/**\n * Returns log value of n inside Galois Field\n *\n * @param  {Number} n\n * @return {Number}\n */\nexports.log = function log (n) {\n  if (n < 1) throw new Error('log(' + n + ')')\n  return LOG_TABLE[n]\n}\n\n/**\n * Returns anti-log value of n inside Galois Field\n *\n * @param  {Number} n\n * @return {Number}\n */\nexports.exp = function exp (n) {\n  return EXP_TABLE[n]\n}\n\n/**\n * Multiplies two number inside Galois Field\n *\n * @param  {Number} x\n * @param  {Number} y\n * @return {Number}\n */\nexports.mul = function mul (x, y) {\n  if (x === 0 || y === 0) return 0\n\n  // should be EXP_TABLE[(LOG_TABLE[x] + LOG_TABLE[y]) % 255] if EXP_TABLE wasn't oversized\n  // @see {@link initTables}\n  return EXP_TABLE[LOG_TABLE[x] + LOG_TABLE[y]]\n}\n","const Mode = require('./mode')\nconst Utils = require('./utils')\n\nfunction KanjiData (data) {\n  this.mode = Mode.KANJI\n  this.data = data\n}\n\nKanjiData.getBitsLength = function getBitsLength (length) {\n  return length * 13\n}\n\nKanjiData.prototype.getLength = function getLength () {\n  return this.data.length\n}\n\nKanjiData.prototype.getBitsLength = function getBitsLength () {\n  return KanjiData.getBitsLength(this.data.length)\n}\n\nKanjiData.prototype.write = function (bitBuffer) {\n  let i\n\n  // In the Shift JIS system, Kanji characters are represented by a two byte combination.\n  // These byte values are shifted from the JIS X 0208 values.\n  // JIS X 0208 gives details of the shift coded representation.\n  for (i = 0; i < this.data.length; i++) {\n    let value = Utils.toSJIS(this.data[i])\n\n    // For characters with Shift JIS values from 0x8140 to 0x9FFC:\n    if (value >= 0x8140 && value <= 0x9FFC) {\n      // Subtract 0x8140 from Shift JIS value\n      value -= 0x8140\n\n    // For characters with Shift JIS values from 0xE040 to 0xEBBF\n    } else if (value >= 0xE040 && value <= 0xEBBF) {\n      // Subtract 0xC140 from Shift JIS value\n      value -= 0xC140\n    } else {\n      throw new Error(\n        'Invalid SJIS character: ' + this.data[i] + '\\n' +\n        'Make sure your charset is UTF-8')\n    }\n\n    // Multiply most significant byte of result by 0xC0\n    // and add least significant byte to product\n    value = (((value >>> 8) & 0xff) * 0xC0) + (value & 0xff)\n\n    // Convert result to a 13-bit binary string\n    bitBuffer.put(value, 13)\n  }\n}\n\nmodule.exports = KanjiData\n","/**\n * Data mask pattern reference\n * @type {Object}\n */\nexports.Patterns = {\n  PATTERN000: 0,\n  PATTERN001: 1,\n  PATTERN010: 2,\n  PATTERN011: 3,\n  PATTERN100: 4,\n  PATTERN101: 5,\n  PATTERN110: 6,\n  PATTERN111: 7\n}\n\n/**\n * Weighted penalty scores for the undesirable features\n * @type {Object}\n */\nconst PenaltyScores = {\n  N1: 3,\n  N2: 3,\n  N3: 40,\n  N4: 10\n}\n\n/**\n * Check if mask pattern value is valid\n *\n * @param  {Number}  mask    Mask pattern\n * @return {Boolean}         true if valid, false otherwise\n */\nexports.isValid = function isValid (mask) {\n  return mask != null && mask !== '' && !isNaN(mask) && mask >= 0 && mask <= 7\n}\n\n/**\n * Returns mask pattern from a value.\n * If value is not valid, returns undefined\n *\n * @param  {Number|String} value        Mask pattern value\n * @return {Number}                     Valid mask pattern or undefined\n */\nexports.from = function from (value) {\n  return exports.isValid(value) ? parseInt(value, 10) : undefined\n}\n\n/**\n* Find adjacent modules in row/column with the same color\n* and assign a penalty value.\n*\n* Points: N1 + i\n* i is the amount by which the number of adjacent modules of the same color exceeds 5\n*/\nexports.getPenaltyN1 = function getPenaltyN1 (data) {\n  const size = data.size\n  let points = 0\n  let sameCountCol = 0\n  let sameCountRow = 0\n  let lastCol = null\n  let lastRow = null\n\n  for (let row = 0; row < size; row++) {\n    sameCountCol = sameCountRow = 0\n    lastCol = lastRow = null\n\n    for (let col = 0; col < size; col++) {\n      let module = data.get(row, col)\n      if (module === lastCol) {\n        sameCountCol++\n      } else {\n        if (sameCountCol >= 5) points += PenaltyScores.N1 + (sameCountCol - 5)\n        lastCol = module\n        sameCountCol = 1\n      }\n\n      module = data.get(col, row)\n      if (module === lastRow) {\n        sameCountRow++\n      } else {\n        if (sameCountRow >= 5) points += PenaltyScores.N1 + (sameCountRow - 5)\n        lastRow = module\n        sameCountRow = 1\n      }\n    }\n\n    if (sameCountCol >= 5) points += PenaltyScores.N1 + (sameCountCol - 5)\n    if (sameCountRow >= 5) points += PenaltyScores.N1 + (sameCountRow - 5)\n  }\n\n  return points\n}\n\n/**\n * Find 2x2 blocks with the same color and assign a penalty value\n *\n * Points: N2 * (m - 1) * (n - 1)\n */\nexports.getPenaltyN2 = function getPenaltyN2 (data) {\n  const size = data.size\n  let points = 0\n\n  for (let row = 0; row < size - 1; row++) {\n    for (let col = 0; col < size - 1; col++) {\n      const last = data.get(row, col) +\n        data.get(row, col + 1) +\n        data.get(row + 1, col) +\n        data.get(row + 1, col + 1)\n\n      if (last === 4 || last === 0) points++\n    }\n  }\n\n  return points * PenaltyScores.N2\n}\n\n/**\n * Find 1:1:3:1:1 ratio (dark:light:dark:light:dark) pattern in row/column,\n * preceded or followed by light area 4 modules wide\n *\n * Points: N3 * number of pattern found\n */\nexports.getPenaltyN3 = function getPenaltyN3 (data) {\n  const size = data.size\n  let points = 0\n  let bitsCol = 0\n  let bitsRow = 0\n\n  for (let row = 0; row < size; row++) {\n    bitsCol = bitsRow = 0\n    for (let col = 0; col < size; col++) {\n      bitsCol = ((bitsCol << 1) & 0x7FF) | data.get(row, col)\n      if (col >= 10 && (bitsCol === 0x5D0 || bitsCol === 0x05D)) points++\n\n      bitsRow = ((bitsRow << 1) & 0x7FF) | data.get(col, row)\n      if (col >= 10 && (bitsRow === 0x5D0 || bitsRow === 0x05D)) points++\n    }\n  }\n\n  return points * PenaltyScores.N3\n}\n\n/**\n * Calculate proportion of dark modules in entire symbol\n *\n * Points: N4 * k\n *\n * k is the rating of the deviation of the proportion of dark modules\n * in the symbol from 50% in steps of 5%\n */\nexports.getPenaltyN4 = function getPenaltyN4 (data) {\n  let darkCount = 0\n  const modulesCount = data.data.length\n\n  for (let i = 0; i < modulesCount; i++) darkCount += data.data[i]\n\n  const k = Math.abs(Math.ceil((darkCount * 100 / modulesCount) / 5) - 10)\n\n  return k * PenaltyScores.N4\n}\n\n/**\n * Return mask value at given position\n *\n * @param  {Number} maskPattern Pattern reference value\n * @param  {Number} i           Row\n * @param  {Number} j           Column\n * @return {Boolean}            Mask value\n */\nfunction getMaskAt (maskPattern, i, j) {\n  switch (maskPattern) {\n    case exports.Patterns.PATTERN000: return (i + j) % 2 === 0\n    case exports.Patterns.PATTERN001: return i % 2 === 0\n    case exports.Patterns.PATTERN010: return j % 3 === 0\n    case exports.Patterns.PATTERN011: return (i + j) % 3 === 0\n    case exports.Patterns.PATTERN100: return (Math.floor(i / 2) + Math.floor(j / 3)) % 2 === 0\n    case exports.Patterns.PATTERN101: return (i * j) % 2 + (i * j) % 3 === 0\n    case exports.Patterns.PATTERN110: return ((i * j) % 2 + (i * j) % 3) % 2 === 0\n    case exports.Patterns.PATTERN111: return ((i * j) % 3 + (i + j) % 2) % 2 === 0\n\n    default: throw new Error('bad maskPattern:' + maskPattern)\n  }\n}\n\n/**\n * Apply a mask pattern to a BitMatrix\n *\n * @param  {Number}    pattern Pattern reference number\n * @param  {BitMatrix} data    BitMatrix data\n */\nexports.applyMask = function applyMask (pattern, data) {\n  const size = data.size\n\n  for (let col = 0; col < size; col++) {\n    for (let row = 0; row < size; row++) {\n      if (data.isReserved(row, col)) continue\n      data.xor(row, col, getMaskAt(pattern, row, col))\n    }\n  }\n}\n\n/**\n * Returns the best mask pattern for data\n *\n * @param  {BitMatrix} data\n * @return {Number} Mask pattern reference number\n */\nexports.getBestMask = function getBestMask (data, setupFormatFunc) {\n  const numPatterns = Object.keys(exports.Patterns).length\n  let bestPattern = 0\n  let lowerPenalty = Infinity\n\n  for (let p = 0; p < numPatterns; p++) {\n    setupFormatFunc(p)\n    exports.applyMask(p, data)\n\n    // Calculate penalty\n    const penalty =\n      exports.getPenaltyN1(data) +\n      exports.getPenaltyN2(data) +\n      exports.getPenaltyN3(data) +\n      exports.getPenaltyN4(data)\n\n    // Undo previously applied mask\n    exports.applyMask(p, data)\n\n    if (penalty < lowerPenalty) {\n      lowerPenalty = penalty\n      bestPattern = p\n    }\n  }\n\n  return bestPattern\n}\n","const VersionCheck = require('./version-check')\nconst Regex = require('./regex')\n\n/**\n * Numeric mode encodes data from the decimal digit set (0 - 9)\n * (byte values 30HEX to 39HEX).\n * Normally, 3 data characters are represented by 10 bits.\n *\n * @type {Object}\n */\nexports.NUMERIC = {\n  id: 'Numeric',\n  bit: 1 << 0,\n  ccBits: [10, 12, 14]\n}\n\n/**\n * Alphanumeric mode encodes data from a set of 45 characters,\n * i.e. 10 numeric digits (0 - 9),\n *      26 alphabetic characters (A - Z),\n *   and 9 symbols (SP, $, %, *, +, -, ., /, :).\n * Normally, two input characters are represented by 11 bits.\n *\n * @type {Object}\n */\nexports.ALPHANUMERIC = {\n  id: 'Alphanumeric',\n  bit: 1 << 1,\n  ccBits: [9, 11, 13]\n}\n\n/**\n * In byte mode, data is encoded at 8 bits per character.\n *\n * @type {Object}\n */\nexports.BYTE = {\n  id: 'Byte',\n  bit: 1 << 2,\n  ccBits: [8, 16, 16]\n}\n\n/**\n * The Kanji mode efficiently encodes Kanji characters in accordance with\n * the Shift JIS system based on JIS X 0208.\n * The Shift JIS values are shifted from the JIS X 0208 values.\n * JIS X 0208 gives details of the shift coded representation.\n * Each two-byte character value is compacted to a 13-bit binary codeword.\n *\n * @type {Object}\n */\nexports.KANJI = {\n  id: 'Kanji',\n  bit: 1 << 3,\n  ccBits: [8, 10, 12]\n}\n\n/**\n * Mixed mode will contain a sequences of data in a combination of any of\n * the modes described above\n *\n * @type {Object}\n */\nexports.MIXED = {\n  bit: -1\n}\n\n/**\n * Returns the number of bits needed to store the data length\n * according to QR Code specifications.\n *\n * @param  {Mode}   mode    Data mode\n * @param  {Number} version QR Code version\n * @return {Number}         Number of bits\n */\nexports.getCharCountIndicator = function getCharCountIndicator (mode, version) {\n  if (!mode.ccBits) throw new Error('Invalid mode: ' + mode)\n\n  if (!VersionCheck.isValid(version)) {\n    throw new Error('Invalid version: ' + version)\n  }\n\n  if (version >= 1 && version < 10) return mode.ccBits[0]\n  else if (version < 27) return mode.ccBits[1]\n  return mode.ccBits[2]\n}\n\n/**\n * Returns the most efficient mode to store the specified data\n *\n * @param  {String} dataStr Input data string\n * @return {Mode}           Best mode\n */\nexports.getBestModeForData = function getBestModeForData (dataStr) {\n  if (Regex.testNumeric(dataStr)) return exports.NUMERIC\n  else if (Regex.testAlphanumeric(dataStr)) return exports.ALPHANUMERIC\n  else if (Regex.testKanji(dataStr)) return exports.KANJI\n  else return exports.BYTE\n}\n\n/**\n * Return mode name as string\n *\n * @param {Mode} mode Mode object\n * @returns {String}  Mode name\n */\nexports.toString = function toString (mode) {\n  if (mode && mode.id) return mode.id\n  throw new Error('Invalid mode')\n}\n\n/**\n * Check if input param is a valid mode object\n *\n * @param   {Mode}    mode Mode object\n * @returns {Boolean} True if valid mode, false otherwise\n */\nexports.isValid = function isValid (mode) {\n  return mode && mode.bit && mode.ccBits\n}\n\n/**\n * Get mode object from its name\n *\n * @param   {String} string Mode name\n * @returns {Mode}          Mode object\n */\nfunction fromString (string) {\n  if (typeof string !== 'string') {\n    throw new Error('Param is not a string')\n  }\n\n  const lcStr = string.toLowerCase()\n\n  switch (lcStr) {\n    case 'numeric':\n      return exports.NUMERIC\n    case 'alphanumeric':\n      return exports.ALPHANUMERIC\n    case 'kanji':\n      return exports.KANJI\n    case 'byte':\n      return exports.BYTE\n    default:\n      throw new Error('Unknown mode: ' + string)\n  }\n}\n\n/**\n * Returns mode from a value.\n * If value is not a valid mode, returns defaultValue\n *\n * @param  {Mode|String} value        Encoding mode\n * @param  {Mode}        defaultValue Fallback value\n * @return {Mode}                     Encoding mode\n */\nexports.from = function from (value, defaultValue) {\n  if (exports.isValid(value)) {\n    return value\n  }\n\n  try {\n    return fromString(value)\n  } catch (e) {\n    return defaultValue\n  }\n}\n","const Mode = require('./mode')\n\nfunction NumericData (data) {\n  this.mode = Mode.NUMERIC\n  this.data = data.toString()\n}\n\nNumericData.getBitsLength = function getBitsLength (length) {\n  return 10 * Math.floor(length / 3) + ((length % 3) ? ((length % 3) * 3 + 1) : 0)\n}\n\nNumericData.prototype.getLength = function getLength () {\n  return this.data.length\n}\n\nNumericData.prototype.getBitsLength = function getBitsLength () {\n  return NumericData.getBitsLength(this.data.length)\n}\n\nNumericData.prototype.write = function write (bitBuffer) {\n  let i, group, value\n\n  // The input data string is divided into groups of three digits,\n  // and each group is converted to its 10-bit binary equivalent.\n  for (i = 0; i + 3 <= this.data.length; i += 3) {\n    group = this.data.substr(i, 3)\n    value = parseInt(group, 10)\n\n    bitBuffer.put(value, 10)\n  }\n\n  // If the number of input digits is not an exact multiple of three,\n  // the final one or two digits are converted to 4 or 7 bits respectively.\n  const remainingNum = this.data.length - i\n  if (remainingNum > 0) {\n    group = this.data.substr(i)\n    value = parseInt(group, 10)\n\n    bitBuffer.put(value, remainingNum * 3 + 1)\n  }\n}\n\nmodule.exports = NumericData\n","const GF = require('./galois-field')\n\n/**\n * Multiplies two polynomials inside Galois Field\n *\n * @param  {Uint8Array} p1 Polynomial\n * @param  {Uint8Array} p2 Polynomial\n * @return {Uint8Array}    Product of p1 and p2\n */\nexports.mul = function mul (p1, p2) {\n  const coeff = new Uint8Array(p1.length + p2.length - 1)\n\n  for (let i = 0; i < p1.length; i++) {\n    for (let j = 0; j < p2.length; j++) {\n      coeff[i + j] ^= GF.mul(p1[i], p2[j])\n    }\n  }\n\n  return coeff\n}\n\n/**\n * Calculate the remainder of polynomials division\n *\n * @param  {Uint8Array} divident Polynomial\n * @param  {Uint8Array} divisor  Polynomial\n * @return {Uint8Array}          Remainder\n */\nexports.mod = function mod (divident, divisor) {\n  let result = new Uint8Array(divident)\n\n  while ((result.length - divisor.length) >= 0) {\n    const coeff = result[0]\n\n    for (let i = 0; i < divisor.length; i++) {\n      result[i] ^= GF.mul(divisor[i], coeff)\n    }\n\n    // remove all zeros from buffer head\n    let offset = 0\n    while (offset < result.length && result[offset] === 0) offset++\n    result = result.slice(offset)\n  }\n\n  return result\n}\n\n/**\n * Generate an irreducible generator polynomial of specified degree\n * (used by Reed-Solomon encoder)\n *\n * @param  {Number} degree Degree of the generator polynomial\n * @return {Uint8Array}    Buffer containing polynomial coefficients\n */\nexports.generateECPolynomial = function generateECPolynomial (degree) {\n  let poly = new Uint8Array([1])\n  for (let i = 0; i < degree; i++) {\n    poly = exports.mul(poly, new Uint8Array([1, GF.exp(i)]))\n  }\n\n  return poly\n}\n","const Utils = require('./utils')\nconst ECLevel = require('./error-correction-level')\nconst BitBuffer = require('./bit-buffer')\nconst BitMatrix = require('./bit-matrix')\nconst AlignmentPattern = require('./alignment-pattern')\nconst FinderPattern = require('./finder-pattern')\nconst MaskPattern = require('./mask-pattern')\nconst ECCode = require('./error-correction-code')\nconst ReedSolomonEncoder = require('./reed-solomon-encoder')\nconst Version = require('./version')\nconst FormatInfo = require('./format-info')\nconst Mode = require('./mode')\nconst Segments = require('./segments')\n\n/**\n * QRCode for JavaScript\n *\n * modified by Ryan Day for nodejs support\n * Copyright (c) 2011 Ryan Day\n *\n * Licensed under the MIT license:\n *   http://www.opensource.org/licenses/mit-license.php\n *\n//---------------------------------------------------------------------\n// QRCode for JavaScript\n//\n// Copyright (c) 2009 Kazuhiko Arase\n//\n// URL: http://www.d-project.com/\n//\n// Licensed under the MIT license:\n//   http://www.opensource.org/licenses/mit-license.php\n//\n// The word \"QR Code\" is registered trademark of\n// DENSO WAVE INCORPORATED\n//   http://www.denso-wave.com/qrcode/faqpatent-e.html\n//\n//---------------------------------------------------------------------\n*/\n\n/**\n * Add finder patterns bits to matrix\n *\n * @param  {BitMatrix} matrix  Modules matrix\n * @param  {Number}    version QR Code version\n */\nfunction setupFinderPattern (matrix, version) {\n  const size = matrix.size\n  const pos = FinderPattern.getPositions(version)\n\n  for (let i = 0; i < pos.length; i++) {\n    const row = pos[i][0]\n    const col = pos[i][1]\n\n    for (let r = -1; r <= 7; r++) {\n      if (row + r <= -1 || size <= row + r) continue\n\n      for (let c = -1; c <= 7; c++) {\n        if (col + c <= -1 || size <= col + c) continue\n\n        if ((r >= 0 && r <= 6 && (c === 0 || c === 6)) ||\n          (c >= 0 && c <= 6 && (r === 0 || r === 6)) ||\n          (r >= 2 && r <= 4 && c >= 2 && c <= 4)) {\n          matrix.set(row + r, col + c, true, true)\n        } else {\n          matrix.set(row + r, col + c, false, true)\n        }\n      }\n    }\n  }\n}\n\n/**\n * Add timing pattern bits to matrix\n *\n * Note: this function must be called before {@link setupAlignmentPattern}\n *\n * @param  {BitMatrix} matrix Modules matrix\n */\nfunction setupTimingPattern (matrix) {\n  const size = matrix.size\n\n  for (let r = 8; r < size - 8; r++) {\n    const value = r % 2 === 0\n    matrix.set(r, 6, value, true)\n    matrix.set(6, r, value, true)\n  }\n}\n\n/**\n * Add alignment patterns bits to matrix\n *\n * Note: this function must be called after {@link setupTimingPattern}\n *\n * @param  {BitMatrix} matrix  Modules matrix\n * @param  {Number}    version QR Code version\n */\nfunction setupAlignmentPattern (matrix, version) {\n  const pos = AlignmentPattern.getPositions(version)\n\n  for (let i = 0; i < pos.length; i++) {\n    const row = pos[i][0]\n    const col = pos[i][1]\n\n    for (let r = -2; r <= 2; r++) {\n      for (let c = -2; c <= 2; c++) {\n        if (r === -2 || r === 2 || c === -2 || c === 2 ||\n          (r === 0 && c === 0)) {\n          matrix.set(row + r, col + c, true, true)\n        } else {\n          matrix.set(row + r, col + c, false, true)\n        }\n      }\n    }\n  }\n}\n\n/**\n * Add version info bits to matrix\n *\n * @param  {BitMatrix} matrix  Modules matrix\n * @param  {Number}    version QR Code version\n */\nfunction setupVersionInfo (matrix, version) {\n  const size = matrix.size\n  const bits = Version.getEncodedBits(version)\n  let row, col, mod\n\n  for (let i = 0; i < 18; i++) {\n    row = Math.floor(i / 3)\n    col = i % 3 + size - 8 - 3\n    mod = ((bits >> i) & 1) === 1\n\n    matrix.set(row, col, mod, true)\n    matrix.set(col, row, mod, true)\n  }\n}\n\n/**\n * Add format info bits to matrix\n *\n * @param  {BitMatrix} matrix               Modules matrix\n * @param  {ErrorCorrectionLevel}    errorCorrectionLevel Error correction level\n * @param  {Number}    maskPattern          Mask pattern reference value\n */\nfunction setupFormatInfo (matrix, errorCorrectionLevel, maskPattern) {\n  const size = matrix.size\n  const bits = FormatInfo.getEncodedBits(errorCorrectionLevel, maskPattern)\n  let i, mod\n\n  for (i = 0; i < 15; i++) {\n    mod = ((bits >> i) & 1) === 1\n\n    // vertical\n    if (i < 6) {\n      matrix.set(i, 8, mod, true)\n    } else if (i < 8) {\n      matrix.set(i + 1, 8, mod, true)\n    } else {\n      matrix.set(size - 15 + i, 8, mod, true)\n    }\n\n    // horizontal\n    if (i < 8) {\n      matrix.set(8, size - i - 1, mod, true)\n    } else if (i < 9) {\n      matrix.set(8, 15 - i - 1 + 1, mod, true)\n    } else {\n      matrix.set(8, 15 - i - 1, mod, true)\n    }\n  }\n\n  // fixed module\n  matrix.set(size - 8, 8, 1, true)\n}\n\n/**\n * Add encoded data bits to matrix\n *\n * @param  {BitMatrix}  matrix Modules matrix\n * @param  {Uint8Array} data   Data codewords\n */\nfunction setupData (matrix, data) {\n  const size = matrix.size\n  let inc = -1\n  let row = size - 1\n  let bitIndex = 7\n  let byteIndex = 0\n\n  for (let col = size - 1; col > 0; col -= 2) {\n    if (col === 6) col--\n\n    while (true) {\n      for (let c = 0; c < 2; c++) {\n        if (!matrix.isReserved(row, col - c)) {\n          let dark = false\n\n          if (byteIndex < data.length) {\n            dark = (((data[byteIndex] >>> bitIndex) & 1) === 1)\n          }\n\n          matrix.set(row, col - c, dark)\n          bitIndex--\n\n          if (bitIndex === -1) {\n            byteIndex++\n            bitIndex = 7\n          }\n        }\n      }\n\n      row += inc\n\n      if (row < 0 || size <= row) {\n        row -= inc\n        inc = -inc\n        break\n      }\n    }\n  }\n}\n\n/**\n * Create encoded codewords from data input\n *\n * @param  {Number}   version              QR Code version\n * @param  {ErrorCorrectionLevel}   errorCorrectionLevel Error correction level\n * @param  {ByteData} data                 Data input\n * @return {Uint8Array}                    Buffer containing encoded codewords\n */\nfunction createData (version, errorCorrectionLevel, segments) {\n  // Prepare data buffer\n  const buffer = new BitBuffer()\n\n  segments.forEach(function (data) {\n    // prefix data with mode indicator (4 bits)\n    buffer.put(data.mode.bit, 4)\n\n    // Prefix data with character count indicator.\n    // The character count indicator is a string of bits that represents the\n    // number of characters that are being encoded.\n    // The character count indicator must be placed after the mode indicator\n    // and must be a certain number of bits long, depending on the QR version\n    // and data mode\n    // @see {@link Mode.getCharCountIndicator}.\n    buffer.put(data.getLength(), Mode.getCharCountIndicator(data.mode, version))\n\n    // add binary data sequence to buffer\n    data.write(buffer)\n  })\n\n  // Calculate required number of bits\n  const totalCodewords = Utils.getSymbolTotalCodewords(version)\n  const ecTotalCodewords = ECCode.getTotalCodewordsCount(version, errorCorrectionLevel)\n  const dataTotalCodewordsBits = (totalCodewords - ecTotalCodewords) * 8\n\n  // Add a terminator.\n  // If the bit string is shorter than the total number of required bits,\n  // a terminator of up to four 0s must be added to the right side of the string.\n  // If the bit string is more than four bits shorter than the required number of bits,\n  // add four 0s to the end.\n  if (buffer.getLengthInBits() + 4 <= dataTotalCodewordsBits) {\n    buffer.put(0, 4)\n  }\n\n  // If the bit string is fewer than four bits shorter, add only the number of 0s that\n  // are needed to reach the required number of bits.\n\n  // After adding the terminator, if the number of bits in the string is not a multiple of 8,\n  // pad the string on the right with 0s to make the string's length a multiple of 8.\n  while (buffer.getLengthInBits() % 8 !== 0) {\n    buffer.putBit(0)\n  }\n\n  // Add pad bytes if the string is still shorter than the total number of required bits.\n  // Extend the buffer to fill the data capacity of the symbol corresponding to\n  // the Version and Error Correction Level by adding the Pad Codewords 11101100 (0xEC)\n  // and 00010001 (0x11) alternately.\n  const remainingByte = (dataTotalCodewordsBits - buffer.getLengthInBits()) / 8\n  for (let i = 0; i < remainingByte; i++) {\n    buffer.put(i % 2 ? 0x11 : 0xEC, 8)\n  }\n\n  return createCodewords(buffer, version, errorCorrectionLevel)\n}\n\n/**\n * Encode input data with Reed-Solomon and return codewords with\n * relative error correction bits\n *\n * @param  {BitBuffer} bitBuffer            Data to encode\n * @param  {Number}    version              QR Code version\n * @param  {ErrorCorrectionLevel} errorCorrectionLevel Error correction level\n * @return {Uint8Array}                     Buffer containing encoded codewords\n */\nfunction createCodewords (bitBuffer, version, errorCorrectionLevel) {\n  // Total codewords for this QR code version (Data + Error correction)\n  const totalCodewords = Utils.getSymbolTotalCodewords(version)\n\n  // Total number of error correction codewords\n  const ecTotalCodewords = ECCode.getTotalCodewordsCount(version, errorCorrectionLevel)\n\n  // Total number of data codewords\n  const dataTotalCodewords = totalCodewords - ecTotalCodewords\n\n  // Total number of blocks\n  const ecTotalBlocks = ECCode.getBlocksCount(version, errorCorrectionLevel)\n\n  // Calculate how many blocks each group should contain\n  const blocksInGroup2 = totalCodewords % ecTotalBlocks\n  const blocksInGroup1 = ecTotalBlocks - blocksInGroup2\n\n  const totalCodewordsInGroup1 = Math.floor(totalCodewords / ecTotalBlocks)\n\n  const dataCodewordsInGroup1 = Math.floor(dataTotalCodewords / ecTotalBlocks)\n  const dataCodewordsInGroup2 = dataCodewordsInGroup1 + 1\n\n  // Number of EC codewords is the same for both groups\n  const ecCount = totalCodewordsInGroup1 - dataCodewordsInGroup1\n\n  // Initialize a Reed-Solomon encoder with a generator polynomial of degree ecCount\n  const rs = new ReedSolomonEncoder(ecCount)\n\n  let offset = 0\n  const dcData = new Array(ecTotalBlocks)\n  const ecData = new Array(ecTotalBlocks)\n  let maxDataSize = 0\n  const buffer = new Uint8Array(bitBuffer.buffer)\n\n  // Divide the buffer into the required number of blocks\n  for (let b = 0; b < ecTotalBlocks; b++) {\n    const dataSize = b < blocksInGroup1 ? dataCodewordsInGroup1 : dataCodewordsInGroup2\n\n    // extract a block of data from buffer\n    dcData[b] = buffer.slice(offset, offset + dataSize)\n\n    // Calculate EC codewords for this data block\n    ecData[b] = rs.encode(dcData[b])\n\n    offset += dataSize\n    maxDataSize = Math.max(maxDataSize, dataSize)\n  }\n\n  // Create final data\n  // Interleave the data and error correction codewords from each block\n  const data = new Uint8Array(totalCodewords)\n  let index = 0\n  let i, r\n\n  // Add data codewords\n  for (i = 0; i < maxDataSize; i++) {\n    for (r = 0; r < ecTotalBlocks; r++) {\n      if (i < dcData[r].length) {\n        data[index++] = dcData[r][i]\n      }\n    }\n  }\n\n  // Apped EC codewords\n  for (i = 0; i < ecCount; i++) {\n    for (r = 0; r < ecTotalBlocks; r++) {\n      data[index++] = ecData[r][i]\n    }\n  }\n\n  return data\n}\n\n/**\n * Build QR Code symbol\n *\n * @param  {String} data                 Input string\n * @param  {Number} version              QR Code version\n * @param  {ErrorCorretionLevel} errorCorrectionLevel Error level\n * @param  {MaskPattern} maskPattern     Mask pattern\n * @return {Object}                      Object containing symbol data\n */\nfunction createSymbol (data, version, errorCorrectionLevel, maskPattern) {\n  let segments\n\n  if (Array.isArray(data)) {\n    segments = Segments.fromArray(data)\n  } else if (typeof data === 'string') {\n    let estimatedVersion = version\n\n    if (!estimatedVersion) {\n      const rawSegments = Segments.rawSplit(data)\n\n      // Estimate best version that can contain raw splitted segments\n      estimatedVersion = Version.getBestVersionForData(rawSegments, errorCorrectionLevel)\n    }\n\n    // Build optimized segments\n    // If estimated version is undefined, try with the highest version\n    segments = Segments.fromString(data, estimatedVersion || 40)\n  } else {\n    throw new Error('Invalid data')\n  }\n\n  // Get the min version that can contain data\n  const bestVersion = Version.getBestVersionForData(segments, errorCorrectionLevel)\n\n  // If no version is found, data cannot be stored\n  if (!bestVersion) {\n    throw new Error('The amount of data is too big to be stored in a QR Code')\n  }\n\n  // If not specified, use min version as default\n  if (!version) {\n    version = bestVersion\n\n  // Check if the specified version can contain the data\n  } else if (version < bestVersion) {\n    throw new Error('\\n' +\n      'The chosen QR Code version cannot contain this amount of data.\\n' +\n      'Minimum version required to store current data is: ' + bestVersion + '.\\n'\n    )\n  }\n\n  const dataBits = createData(version, errorCorrectionLevel, segments)\n\n  // Allocate matrix buffer\n  const moduleCount = Utils.getSymbolSize(version)\n  const modules = new BitMatrix(moduleCount)\n\n  // Add function modules\n  setupFinderPattern(modules, version)\n  setupTimingPattern(modules)\n  setupAlignmentPattern(modules, version)\n\n  // Add temporary dummy bits for format info just to set them as reserved.\n  // This is needed to prevent these bits from being masked by {@link MaskPattern.applyMask}\n  // since the masking operation must be performed only on the encoding region.\n  // These blocks will be replaced with correct values later in code.\n  setupFormatInfo(modules, errorCorrectionLevel, 0)\n\n  if (version >= 7) {\n    setupVersionInfo(modules, version)\n  }\n\n  // Add data codewords\n  setupData(modules, dataBits)\n\n  if (isNaN(maskPattern)) {\n    // Find best mask pattern\n    maskPattern = MaskPattern.getBestMask(modules,\n      setupFormatInfo.bind(null, modules, errorCorrectionLevel))\n  }\n\n  // Apply mask pattern\n  MaskPattern.applyMask(maskPattern, modules)\n\n  // Replace format info bits with correct values\n  setupFormatInfo(modules, errorCorrectionLevel, maskPattern)\n\n  return {\n    modules: modules,\n    version: version,\n    errorCorrectionLevel: errorCorrectionLevel,\n    maskPattern: maskPattern,\n    segments: segments\n  }\n}\n\n/**\n * QR Code\n *\n * @param {String | Array} data                 Input data\n * @param {Object} options                      Optional configurations\n * @param {Number} options.version              QR Code version\n * @param {String} options.errorCorrectionLevel Error correction level\n * @param {Function} options.toSJISFunc         Helper func to convert utf8 to sjis\n */\nexports.create = function create (data, options) {\n  if (typeof data === 'undefined' || data === '') {\n    throw new Error('No input text')\n  }\n\n  let errorCorrectionLevel = ECLevel.M\n  let version\n  let mask\n\n  if (typeof options !== 'undefined') {\n    // Use higher error correction level as default\n    errorCorrectionLevel = ECLevel.from(options.errorCorrectionLevel, ECLevel.M)\n    version = Version.from(options.version)\n    mask = MaskPattern.from(options.maskPattern)\n\n    if (options.toSJISFunc) {\n      Utils.setToSJISFunction(options.toSJISFunc)\n    }\n  }\n\n  return createSymbol(data, version, errorCorrectionLevel, mask)\n}\n","const Polynomial = require('./polynomial')\n\nfunction ReedSolomonEncoder (degree) {\n  this.genPoly = undefined\n  this.degree = degree\n\n  if (this.degree) this.initialize(this.degree)\n}\n\n/**\n * Initialize the encoder.\n * The input param should correspond to the number of error correction codewords.\n *\n * @param  {Number} degree\n */\nReedSolomonEncoder.prototype.initialize = function initialize (degree) {\n  // create an irreducible generator polynomial\n  this.degree = degree\n  this.genPoly = Polynomial.generateECPolynomial(this.degree)\n}\n\n/**\n * Encodes a chunk of data\n *\n * @param  {Uint8Array} data Buffer containing input data\n * @return {Uint8Array}      Buffer containing encoded data\n */\nReedSolomonEncoder.prototype.encode = function encode (data) {\n  if (!this.genPoly) {\n    throw new Error('Encoder not initialized')\n  }\n\n  // Calculate EC for this data block\n  // extends data size to data+genPoly size\n  const paddedData = new Uint8Array(data.length + this.degree)\n  paddedData.set(data)\n\n  // The error correction codewords are the remainder after dividing the data codewords\n  // by a generator polynomial\n  const remainder = Polynomial.mod(paddedData, this.genPoly)\n\n  // return EC data blocks (last n byte, where n is the degree of genPoly)\n  // If coefficients number in remainder are less than genPoly degree,\n  // pad with 0s to the left to reach the needed number of coefficients\n  const start = this.degree - remainder.length\n  if (start > 0) {\n    const buff = new Uint8Array(this.degree)\n    buff.set(remainder, start)\n\n    return buff\n  }\n\n  return remainder\n}\n\nmodule.exports = ReedSolomonEncoder\n","const numeric = '[0-9]+'\nconst alphanumeric = '[A-Z $%*+\\\\-./:]+'\nlet kanji = '(?:[u3000-u303F]|[u3040-u309F]|[u30A0-u30FF]|' +\n  '[uFF00-uFFEF]|[u4E00-u9FAF]|[u2605-u2606]|[u2190-u2195]|u203B|' +\n  '[u2010u2015u2018u2019u2025u2026u201Cu201Du2225u2260]|' +\n  '[u0391-u0451]|[u00A7u00A8u00B1u00B4u00D7u00F7])+'\nkanji = kanji.replace(/u/g, '\\\\u')\n\nconst byte = '(?:(?![A-Z0-9 $%*+\\\\-./:]|' + kanji + ')(?:.|[\\r\\n]))+'\n\nexports.KANJI = new RegExp(kanji, 'g')\nexports.BYTE_KANJI = new RegExp('[^A-Z0-9 $%*+\\\\-./:]+', 'g')\nexports.BYTE = new RegExp(byte, 'g')\nexports.NUMERIC = new RegExp(numeric, 'g')\nexports.ALPHANUMERIC = new RegExp(alphanumeric, 'g')\n\nconst TEST_KANJI = new RegExp('^' + kanji + '$')\nconst TEST_NUMERIC = new RegExp('^' + numeric + '$')\nconst TEST_ALPHANUMERIC = new RegExp('^[A-Z0-9 $%*+\\\\-./:]+$')\n\nexports.testKanji = function testKanji (str) {\n  return TEST_KANJI.test(str)\n}\n\nexports.testNumeric = function testNumeric (str) {\n  return TEST_NUMERIC.test(str)\n}\n\nexports.testAlphanumeric = function testAlphanumeric (str) {\n  return TEST_ALPHANUMERIC.test(str)\n}\n","const Mode = require('./mode')\nconst NumericData = require('./numeric-data')\nconst AlphanumericData = require('./alphanumeric-data')\nconst ByteData = require('./byte-data')\nconst KanjiData = require('./kanji-data')\nconst Regex = require('./regex')\nconst Utils = require('./utils')\nconst dijkstra = require('dijkstrajs')\n\n/**\n * Returns UTF8 byte length\n *\n * @param  {String} str Input string\n * @return {Number}     Number of byte\n */\nfunction getStringByteLength (str) {\n  return unescape(encodeURIComponent(str)).length\n}\n\n/**\n * Get a list of segments of the specified mode\n * from a string\n *\n * @param  {Mode}   mode Segment mode\n * @param  {String} str  String to process\n * @return {Array}       Array of object with segments data\n */\nfunction getSegments (regex, mode, str) {\n  const segments = []\n  let result\n\n  while ((result = regex.exec(str)) !== null) {\n    segments.push({\n      data: result[0],\n      index: result.index,\n      mode: mode,\n      length: result[0].length\n    })\n  }\n\n  return segments\n}\n\n/**\n * Extracts a series of segments with the appropriate\n * modes from a string\n *\n * @param  {String} dataStr Input string\n * @return {Array}          Array of object with segments data\n */\nfunction getSegmentsFromString (dataStr) {\n  const numSegs = getSegments(Regex.NUMERIC, Mode.NUMERIC, dataStr)\n  const alphaNumSegs = getSegments(Regex.ALPHANUMERIC, Mode.ALPHANUMERIC, dataStr)\n  let byteSegs\n  let kanjiSegs\n\n  if (Utils.isKanjiModeEnabled()) {\n    byteSegs = getSegments(Regex.BYTE, Mode.BYTE, dataStr)\n    kanjiSegs = getSegments(Regex.KANJI, Mode.KANJI, dataStr)\n  } else {\n    byteSegs = getSegments(Regex.BYTE_KANJI, Mode.BYTE, dataStr)\n    kanjiSegs = []\n  }\n\n  const segs = numSegs.concat(alphaNumSegs, byteSegs, kanjiSegs)\n\n  return segs\n    .sort(function (s1, s2) {\n      return s1.index - s2.index\n    })\n    .map(function (obj) {\n      return {\n        data: obj.data,\n        mode: obj.mode,\n        length: obj.length\n      }\n    })\n}\n\n/**\n * Returns how many bits are needed to encode a string of\n * specified length with the specified mode\n *\n * @param  {Number} length String length\n * @param  {Mode} mode     Segment mode\n * @return {Number}        Bit length\n */\nfunction getSegmentBitsLength (length, mode) {\n  switch (mode) {\n    case Mode.NUMERIC:\n      return NumericData.getBitsLength(length)\n    case Mode.ALPHANUMERIC:\n      return AlphanumericData.getBitsLength(length)\n    case Mode.KANJI:\n      return KanjiData.getBitsLength(length)\n    case Mode.BYTE:\n      return ByteData.getBitsLength(length)\n  }\n}\n\n/**\n * Merges adjacent segments which have the same mode\n *\n * @param  {Array} segs Array of object with segments data\n * @return {Array}      Array of object with segments data\n */\nfunction mergeSegments (segs) {\n  return segs.reduce(function (acc, curr) {\n    const prevSeg = acc.length - 1 >= 0 ? acc[acc.length - 1] : null\n    if (prevSeg && prevSeg.mode === curr.mode) {\n      acc[acc.length - 1].data += curr.data\n      return acc\n    }\n\n    acc.push(curr)\n    return acc\n  }, [])\n}\n\n/**\n * Generates a list of all possible nodes combination which\n * will be used to build a segments graph.\n *\n * Nodes are divided by groups. Each group will contain a list of all the modes\n * in which is possible to encode the given text.\n *\n * For example the text '12345' can be encoded as Numeric, Alphanumeric or Byte.\n * The group for '12345' will contain then 3 objects, one for each\n * possible encoding mode.\n *\n * Each node represents a possible segment.\n *\n * @param  {Array} segs Array of object with segments data\n * @return {Array}      Array of object with segments data\n */\nfunction buildNodes (segs) {\n  const nodes = []\n  for (let i = 0; i < segs.length; i++) {\n    const seg = segs[i]\n\n    switch (seg.mode) {\n      case Mode.NUMERIC:\n        nodes.push([seg,\n          { data: seg.data, mode: Mode.ALPHANUMERIC, length: seg.length },\n          { data: seg.data, mode: Mode.BYTE, length: seg.length }\n        ])\n        break\n      case Mode.ALPHANUMERIC:\n        nodes.push([seg,\n          { data: seg.data, mode: Mode.BYTE, length: seg.length }\n        ])\n        break\n      case Mode.KANJI:\n        nodes.push([seg,\n          { data: seg.data, mode: Mode.BYTE, length: getStringByteLength(seg.data) }\n        ])\n        break\n      case Mode.BYTE:\n        nodes.push([\n          { data: seg.data, mode: Mode.BYTE, length: getStringByteLength(seg.data) }\n        ])\n    }\n  }\n\n  return nodes\n}\n\n/**\n * Builds a graph from a list of nodes.\n * All segments in each node group will be connected with all the segments of\n * the next group and so on.\n *\n * At each connection will be assigned a weight depending on the\n * segment's byte length.\n *\n * @param  {Array} nodes    Array of object with segments data\n * @param  {Number} version QR Code version\n * @return {Object}         Graph of all possible segments\n */\nfunction buildGraph (nodes, version) {\n  const table = {}\n  const graph = { start: {} }\n  let prevNodeIds = ['start']\n\n  for (let i = 0; i < nodes.length; i++) {\n    const nodeGroup = nodes[i]\n    const currentNodeIds = []\n\n    for (let j = 0; j < nodeGroup.length; j++) {\n      const node = nodeGroup[j]\n      const key = '' + i + j\n\n      currentNodeIds.push(key)\n      table[key] = { node: node, lastCount: 0 }\n      graph[key] = {}\n\n      for (let n = 0; n < prevNodeIds.length; n++) {\n        const prevNodeId = prevNodeIds[n]\n\n        if (table[prevNodeId] && table[prevNodeId].node.mode === node.mode) {\n          graph[prevNodeId][key] =\n            getSegmentBitsLength(table[prevNodeId].lastCount + node.length, node.mode) -\n            getSegmentBitsLength(table[prevNodeId].lastCount, node.mode)\n\n          table[prevNodeId].lastCount += node.length\n        } else {\n          if (table[prevNodeId]) table[prevNodeId].lastCount = node.length\n\n          graph[prevNodeId][key] = getSegmentBitsLength(node.length, node.mode) +\n            4 + Mode.getCharCountIndicator(node.mode, version) // switch cost\n        }\n      }\n    }\n\n    prevNodeIds = currentNodeIds\n  }\n\n  for (let n = 0; n < prevNodeIds.length; n++) {\n    graph[prevNodeIds[n]].end = 0\n  }\n\n  return { map: graph, table: table }\n}\n\n/**\n * Builds a segment from a specified data and mode.\n * If a mode is not specified, the more suitable will be used.\n *\n * @param  {String} data             Input data\n * @param  {Mode | String} modesHint Data mode\n * @return {Segment}                 Segment\n */\nfunction buildSingleSegment (data, modesHint) {\n  let mode\n  const bestMode = Mode.getBestModeForData(data)\n\n  mode = Mode.from(modesHint, bestMode)\n\n  // Make sure data can be encoded\n  if (mode !== Mode.BYTE && mode.bit < bestMode.bit) {\n    throw new Error('\"' + data + '\"' +\n      ' cannot be encoded with mode ' + Mode.toString(mode) +\n      '.\\n Suggested mode is: ' + Mode.toString(bestMode))\n  }\n\n  // Use Mode.BYTE if Kanji support is disabled\n  if (mode === Mode.KANJI && !Utils.isKanjiModeEnabled()) {\n    mode = Mode.BYTE\n  }\n\n  switch (mode) {\n    case Mode.NUMERIC:\n      return new NumericData(data)\n\n    case Mode.ALPHANUMERIC:\n      return new AlphanumericData(data)\n\n    case Mode.KANJI:\n      return new KanjiData(data)\n\n    case Mode.BYTE:\n      return new ByteData(data)\n  }\n}\n\n/**\n * Builds a list of segments from an array.\n * Array can contain Strings or Objects with segment's info.\n *\n * For each item which is a string, will be generated a segment with the given\n * string and the more appropriate encoding mode.\n *\n * For each item which is an object, will be generated a segment with the given\n * data and mode.\n * Objects must contain at least the property \"data\".\n * If property \"mode\" is not present, the more suitable mode will be used.\n *\n * @param  {Array} array Array of objects with segments data\n * @return {Array}       Array of Segments\n */\nexports.fromArray = function fromArray (array) {\n  return array.reduce(function (acc, seg) {\n    if (typeof seg === 'string') {\n      acc.push(buildSingleSegment(seg, null))\n    } else if (seg.data) {\n      acc.push(buildSingleSegment(seg.data, seg.mode))\n    }\n\n    return acc\n  }, [])\n}\n\n/**\n * Builds an optimized sequence of segments from a string,\n * which will produce the shortest possible bitstream.\n *\n * @param  {String} data    Input string\n * @param  {Number} version QR Code version\n * @return {Array}          Array of segments\n */\nexports.fromString = function fromString (data, version) {\n  const segs = getSegmentsFromString(data, Utils.isKanjiModeEnabled())\n\n  const nodes = buildNodes(segs)\n  const graph = buildGraph(nodes, version)\n  const path = dijkstra.find_path(graph.map, 'start', 'end')\n\n  const optimizedSegs = []\n  for (let i = 1; i < path.length - 1; i++) {\n    optimizedSegs.push(graph.table[path[i]].node)\n  }\n\n  return exports.fromArray(mergeSegments(optimizedSegs))\n}\n\n/**\n * Splits a string in various segments with the modes which\n * best represent their content.\n * The produced segments are far from being optimized.\n * The output of this function is only used to estimate a QR Code version\n * which may contain the data.\n *\n * @param  {string} data Input string\n * @return {Array}       Array of segments\n */\nexports.rawSplit = function rawSplit (data) {\n  return exports.fromArray(\n    getSegmentsFromString(data, Utils.isKanjiModeEnabled())\n  )\n}\n","let toSJISFunction\nconst CODEWORDS_COUNT = [\n  0, // Not used\n  26, 44, 70, 100, 134, 172, 196, 242, 292, 346,\n  404, 466, 532, 581, 655, 733, 815, 901, 991, 1085,\n  1156, 1258, 1364, 1474, 1588, 1706, 1828, 1921, 2051, 2185,\n  2323, 2465, 2611, 2761, 2876, 3034, 3196, 3362, 3532, 3706\n]\n\n/**\n * Returns the QR Code size for the specified version\n *\n * @param  {Number} version QR Code version\n * @return {Number}         size of QR code\n */\nexports.getSymbolSize = function getSymbolSize (version) {\n  if (!version) throw new Error('\"version\" cannot be null or undefined')\n  if (version < 1 || version > 40) throw new Error('\"version\" should be in range from 1 to 40')\n  return version * 4 + 17\n}\n\n/**\n * Returns the total number of codewords used to store data and EC information.\n *\n * @param  {Number} version QR Code version\n * @return {Number}         Data length in bits\n */\nexports.getSymbolTotalCodewords = function getSymbolTotalCodewords (version) {\n  return CODEWORDS_COUNT[version]\n}\n\n/**\n * Encode data with Bose-Chaudhuri-Hocquenghem\n *\n * @param  {Number} data Value to encode\n * @return {Number}      Encoded value\n */\nexports.getBCHDigit = function (data) {\n  let digit = 0\n\n  while (data !== 0) {\n    digit++\n    data >>>= 1\n  }\n\n  return digit\n}\n\nexports.setToSJISFunction = function setToSJISFunction (f) {\n  if (typeof f !== 'function') {\n    throw new Error('\"toSJISFunc\" is not a valid function.')\n  }\n\n  toSJISFunction = f\n}\n\nexports.isKanjiModeEnabled = function () {\n  return typeof toSJISFunction !== 'undefined'\n}\n\nexports.toSJIS = function toSJIS (kanji) {\n  return toSJISFunction(kanji)\n}\n","/**\n * Check if QR Code version is valid\n *\n * @param  {Number}  version QR Code version\n * @return {Boolean}         true if valid version, false otherwise\n */\nexports.isValid = function isValid (version) {\n  return !isNaN(version) && version >= 1 && version <= 40\n}\n","const Utils = require('./utils')\nconst ECCode = require('./error-correction-code')\nconst ECLevel = require('./error-correction-level')\nconst Mode = require('./mode')\nconst VersionCheck = require('./version-check')\n\n// Generator polynomial used to encode version information\nconst G18 = (1 << 12) | (1 << 11) | (1 << 10) | (1 << 9) | (1 << 8) | (1 << 5) | (1 << 2) | (1 << 0)\nconst G18_BCH = Utils.getBCHDigit(G18)\n\nfunction getBestVersionForDataLength (mode, length, errorCorrectionLevel) {\n  for (let currentVersion = 1; currentVersion <= 40; currentVersion++) {\n    if (length <= exports.getCapacity(currentVersion, errorCorrectionLevel, mode)) {\n      return currentVersion\n    }\n  }\n\n  return undefined\n}\n\nfunction getReservedBitsCount (mode, version) {\n  // Character count indicator + mode indicator bits\n  return Mode.getCharCountIndicator(mode, version) + 4\n}\n\nfunction getTotalBitsFromDataArray (segments, version) {\n  let totalBits = 0\n\n  segments.forEach(function (data) {\n    const reservedBits = getReservedBitsCount(data.mode, version)\n    totalBits += reservedBits + data.getBitsLength()\n  })\n\n  return totalBits\n}\n\nfunction getBestVersionForMixedData (segments, errorCorrectionLevel) {\n  for (let currentVersion = 1; currentVersion <= 40; currentVersion++) {\n    const length = getTotalBitsFromDataArray(segments, currentVersion)\n    if (length <= exports.getCapacity(currentVersion, errorCorrectionLevel, Mode.MIXED)) {\n      return currentVersion\n    }\n  }\n\n  return undefined\n}\n\n/**\n * Returns version number from a value.\n * If value is not a valid version, returns defaultValue\n *\n * @param  {Number|String} value        QR Code version\n * @param  {Number}        defaultValue Fallback value\n * @return {Number}                     QR Code version number\n */\nexports.from = function from (value, defaultValue) {\n  if (VersionCheck.isValid(value)) {\n    return parseInt(value, 10)\n  }\n\n  return defaultValue\n}\n\n/**\n * Returns how much data can be stored with the specified QR code version\n * and error correction level\n *\n * @param  {Number} version              QR Code version (1-40)\n * @param  {Number} errorCorrectionLevel Error correction level\n * @param  {Mode}   mode                 Data mode\n * @return {Number}                      Quantity of storable data\n */\nexports.getCapacity = function getCapacity (version, errorCorrectionLevel, mode) {\n  if (!VersionCheck.isValid(version)) {\n    throw new Error('Invalid QR Code version')\n  }\n\n  // Use Byte mode as default\n  if (typeof mode === 'undefined') mode = Mode.BYTE\n\n  // Total codewords for this QR code version (Data + Error correction)\n  const totalCodewords = Utils.getSymbolTotalCodewords(version)\n\n  // Total number of error correction codewords\n  const ecTotalCodewords = ECCode.getTotalCodewordsCount(version, errorCorrectionLevel)\n\n  // Total number of data codewords\n  const dataTotalCodewordsBits = (totalCodewords - ecTotalCodewords) * 8\n\n  if (mode === Mode.MIXED) return dataTotalCodewordsBits\n\n  const usableBits = dataTotalCodewordsBits - getReservedBitsCount(mode, version)\n\n  // Return max number of storable codewords\n  switch (mode) {\n    case Mode.NUMERIC:\n      return Math.floor((usableBits / 10) * 3)\n\n    case Mode.ALPHANUMERIC:\n      return Math.floor((usableBits / 11) * 2)\n\n    case Mode.KANJI:\n      return Math.floor(usableBits / 13)\n\n    case Mode.BYTE:\n    default:\n      return Math.floor(usableBits / 8)\n  }\n}\n\n/**\n * Returns the minimum version needed to contain the amount of data\n *\n * @param  {Segment} data                    Segment of data\n * @param  {Number} [errorCorrectionLevel=H] Error correction level\n * @param  {Mode} mode                       Data mode\n * @return {Number}                          QR Code version\n */\nexports.getBestVersionForData = function getBestVersionForData (data, errorCorrectionLevel) {\n  let seg\n\n  const ecl = ECLevel.from(errorCorrectionLevel, ECLevel.M)\n\n  if (Array.isArray(data)) {\n    if (data.length > 1) {\n      return getBestVersionForMixedData(data, ecl)\n    }\n\n    if (data.length === 0) {\n      return 1\n    }\n\n    seg = data[0]\n  } else {\n    seg = data\n  }\n\n  return getBestVersionForDataLength(seg.mode, seg.getLength(), ecl)\n}\n\n/**\n * Returns version information with relative error correction bits\n *\n * The version information is included in QR Code symbols of version 7 or larger.\n * It consists of an 18-bit sequence containing 6 data bits,\n * with 12 error correction bits calculated using the (18, 6) Golay code.\n *\n * @param  {Number} version QR Code version\n * @return {Number}         Encoded version info bits\n */\nexports.getEncodedBits = function getEncodedBits (version) {\n  if (!VersionCheck.isValid(version) || version < 7) {\n    throw new Error('Invalid QR Code version')\n  }\n\n  let d = version << 12\n\n  while (Utils.getBCHDigit(d) - G18_BCH >= 0) {\n    d ^= (G18 << (Utils.getBCHDigit(d) - G18_BCH))\n  }\n\n  return (version << 12) | d\n}\n","const Utils = require('./utils')\n\nfunction clearCanvas (ctx, canvas, size) {\n  ctx.clearRect(0, 0, canvas.width, canvas.height)\n\n  if (!canvas.style) canvas.style = {}\n  canvas.height = size\n  canvas.width = size\n  canvas.style.height = size + 'px'\n  canvas.style.width = size + 'px'\n}\n\nfunction getCanvasElement () {\n  try {\n    return document.createElement('canvas')\n  } catch (e) {\n    throw new Error('You need to specify a canvas element')\n  }\n}\n\nexports.render = function render (qrData, canvas, options) {\n  let opts = options\n  let canvasEl = canvas\n\n  if (typeof opts === 'undefined' && (!canvas || !canvas.getContext)) {\n    opts = canvas\n    canvas = undefined\n  }\n\n  if (!canvas) {\n    canvasEl = getCanvasElement()\n  }\n\n  opts = Utils.getOptions(opts)\n  const size = Utils.getImageWidth(qrData.modules.size, opts)\n\n  const ctx = canvasEl.getContext('2d')\n  const image = ctx.createImageData(size, size)\n  Utils.qrToImageData(image.data, qrData, opts)\n\n  clearCanvas(ctx, canvasEl, size)\n  ctx.putImageData(image, 0, 0)\n\n  return canvasEl\n}\n\nexports.renderToDataURL = function renderToDataURL (qrData, canvas, options) {\n  let opts = options\n\n  if (typeof opts === 'undefined' && (!canvas || !canvas.getContext)) {\n    opts = canvas\n    canvas = undefined\n  }\n\n  if (!opts) opts = {}\n\n  const canvasEl = exports.render(qrData, canvas, opts)\n\n  const type = opts.type || 'image/png'\n  const rendererOpts = opts.rendererOpts || {}\n\n  return canvasEl.toDataURL(type, rendererOpts.quality)\n}\n","const Utils = require('./utils')\n\nfunction getColorAttrib (color, attrib) {\n  const alpha = color.a / 255\n  const str = attrib + '=\"' + color.hex + '\"'\n\n  return alpha < 1\n    ? str + ' ' + attrib + '-opacity=\"' + alpha.toFixed(2).slice(1) + '\"'\n    : str\n}\n\nfunction svgCmd (cmd, x, y) {\n  let str = cmd + x\n  if (typeof y !== 'undefined') str += ' ' + y\n\n  return str\n}\n\nfunction qrToPath (data, size, margin) {\n  let path = ''\n  let moveBy = 0\n  let newRow = false\n  let lineLength = 0\n\n  for (let i = 0; i < data.length; i++) {\n    const col = Math.floor(i % size)\n    const row = Math.floor(i / size)\n\n    if (!col && !newRow) newRow = true\n\n    if (data[i]) {\n      lineLength++\n\n      if (!(i > 0 && col > 0 && data[i - 1])) {\n        path += newRow\n          ? svgCmd('M', col + margin, 0.5 + row + margin)\n          : svgCmd('m', moveBy, 0)\n\n        moveBy = 0\n        newRow = false\n      }\n\n      if (!(col + 1 < size && data[i + 1])) {\n        path += svgCmd('h', lineLength)\n        lineLength = 0\n      }\n    } else {\n      moveBy++\n    }\n  }\n\n  return path\n}\n\nexports.render = function render (qrData, options, cb) {\n  const opts = Utils.getOptions(options)\n  const size = qrData.modules.size\n  const data = qrData.modules.data\n  const qrcodesize = size + opts.margin * 2\n\n  const bg = !opts.color.light.a\n    ? ''\n    : '<path ' + getColorAttrib(opts.color.light, 'fill') +\n      ' d=\"M0 0h' + qrcodesize + 'v' + qrcodesize + 'H0z\"/>'\n\n  const path =\n    '<path ' + getColorAttrib(opts.color.dark, 'stroke') +\n    ' d=\"' + qrToPath(data, size, opts.margin) + '\"/>'\n\n  const viewBox = 'viewBox=\"' + '0 0 ' + qrcodesize + ' ' + qrcodesize + '\"'\n\n  const width = !opts.width ? '' : 'width=\"' + opts.width + '\" height=\"' + opts.width + '\" '\n\n  const svgTag = '<svg xmlns=\"http://www.w3.org/2000/svg\" ' + width + viewBox + ' shape-rendering=\"crispEdges\">' + bg + path + '</svg>\\n'\n\n  if (typeof cb === 'function') {\n    cb(null, svgTag)\n  }\n\n  return svgTag\n}\n","function hex2rgba (hex) {\n  if (typeof hex === 'number') {\n    hex = hex.toString()\n  }\n\n  if (typeof hex !== 'string') {\n    throw new Error('Color should be defined as hex string')\n  }\n\n  let hexCode = hex.slice().replace('#', '').split('')\n  if (hexCode.length < 3 || hexCode.length === 5 || hexCode.length > 8) {\n    throw new Error('Invalid hex color: ' + hex)\n  }\n\n  // Convert from short to long form (fff -> ffffff)\n  if (hexCode.length === 3 || hexCode.length === 4) {\n    hexCode = Array.prototype.concat.apply([], hexCode.map(function (c) {\n      return [c, c]\n    }))\n  }\n\n  // Add default alpha value\n  if (hexCode.length === 6) hexCode.push('F', 'F')\n\n  const hexValue = parseInt(hexCode.join(''), 16)\n\n  return {\n    r: (hexValue >> 24) & 255,\n    g: (hexValue >> 16) & 255,\n    b: (hexValue >> 8) & 255,\n    a: hexValue & 255,\n    hex: '#' + hexCode.slice(0, 6).join('')\n  }\n}\n\nexports.getOptions = function getOptions (options) {\n  if (!options) options = {}\n  if (!options.color) options.color = {}\n\n  const margin = typeof options.margin === 'undefined' ||\n    options.margin === null ||\n    options.margin < 0\n    ? 4\n    : options.margin\n\n  const width = options.width && options.width >= 21 ? options.width : undefined\n  const scale = options.scale || 4\n\n  return {\n    width: width,\n    scale: width ? 4 : scale,\n    margin: margin,\n    color: {\n      dark: hex2rgba(options.color.dark || '#000000ff'),\n      light: hex2rgba(options.color.light || '#ffffffff')\n    },\n    type: options.type,\n    rendererOpts: options.rendererOpts || {}\n  }\n}\n\nexports.getScale = function getScale (qrSize, opts) {\n  return opts.width && opts.width >= qrSize + opts.margin * 2\n    ? opts.width / (qrSize + opts.margin * 2)\n    : opts.scale\n}\n\nexports.getImageWidth = function getImageWidth (qrSize, opts) {\n  const scale = exports.getScale(qrSize, opts)\n  return Math.floor((qrSize + opts.margin * 2) * scale)\n}\n\nexports.qrToImageData = function qrToImageData (imgData, qr, opts) {\n  const size = qr.modules.size\n  const data = qr.modules.data\n  const scale = exports.getScale(size, opts)\n  const symbolSize = Math.floor((size + opts.margin * 2) * scale)\n  const scaledMargin = opts.margin * scale\n  const palette = [opts.color.light, opts.color.dark]\n\n  for (let i = 0; i < symbolSize; i++) {\n    for (let j = 0; j < symbolSize; j++) {\n      let posDst = (i * symbolSize + j) * 4\n      let pxColor = opts.color.light\n\n      if (i >= scaledMargin && j >= scaledMargin &&\n        i < symbolSize - scaledMargin && j < symbolSize - scaledMargin) {\n        const iSrc = Math.floor((i - scaledMargin) / scale)\n        const jSrc = Math.floor((j - scaledMargin) / scale)\n        pxColor = palette[data[iSrc * size + jSrc] ? 1 : 0]\n      }\n\n      imgData[posDst++] = pxColor.r\n      imgData[posDst++] = pxColor.g\n      imgData[posDst++] = pxColor.b\n      imgData[posDst] = pxColor.a\n    }\n  }\n}\n","var __extends = (this && this.__extends) || (function () {\n    var extendStatics = function (d, b) {\n        extendStatics = Object.setPrototypeOf ||\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        if (typeof b !== \"function\" && b !== null)\n            throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nvar __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nimport { jsx as _jsx, jsxs as _jsxs } from \"react/jsx-runtime\";\nimport { PureComponent } from 'react';\nimport { flushSync } from 'react-dom';\nimport { Resizer } from './resizer';\nvar DEFAULT_SIZE = {\n    width: 'auto',\n    height: 'auto',\n};\nvar clamp = function (n, min, max) { return Math.max(Math.min(n, max), min); };\nvar snap = function (n, size, gridGap) {\n    var v = Math.round(n / size);\n    return v * size + gridGap * (v - 1);\n};\nvar hasDirection = function (dir, target) {\n    return new RegExp(dir, 'i').test(target);\n};\n// INFO: In case of window is a Proxy and does not porxy Events correctly, use isTouchEvent & isMouseEvent to distinguish event type instead of `instanceof`.\nvar isTouchEvent = function (event) {\n    return Boolean(event.touches && event.touches.length);\n};\nvar isMouseEvent = function (event) {\n    return Boolean((event.clientX || event.clientX === 0) &&\n        (event.clientY || event.clientY === 0));\n};\nvar findClosestSnap = function (n, snapArray, snapGap) {\n    if (snapGap === void 0) { snapGap = 0; }\n    var closestGapIndex = snapArray.reduce(function (prev, curr, index) { return (Math.abs(curr - n) < Math.abs(snapArray[prev] - n) ? index : prev); }, 0);\n    var gap = Math.abs(snapArray[closestGapIndex] - n);\n    return snapGap === 0 || gap < snapGap ? snapArray[closestGapIndex] : n;\n};\nvar getStringSize = function (n) {\n    n = n.toString();\n    if (n === 'auto') {\n        return n;\n    }\n    if (n.endsWith('px')) {\n        return n;\n    }\n    if (n.endsWith('%')) {\n        return n;\n    }\n    if (n.endsWith('vh')) {\n        return n;\n    }\n    if (n.endsWith('vw')) {\n        return n;\n    }\n    if (n.endsWith('vmax')) {\n        return n;\n    }\n    if (n.endsWith('vmin')) {\n        return n;\n    }\n    return \"\".concat(n, \"px\");\n};\nvar getPixelSize = function (size, parentSize, innerWidth, innerHeight) {\n    if (size && typeof size === 'string') {\n        if (size.endsWith('px')) {\n            return Number(size.replace('px', ''));\n        }\n        if (size.endsWith('%')) {\n            var ratio = Number(size.replace('%', '')) / 100;\n            return parentSize * ratio;\n        }\n        if (size.endsWith('vw')) {\n            var ratio = Number(size.replace('vw', '')) / 100;\n            return innerWidth * ratio;\n        }\n        if (size.endsWith('vh')) {\n            var ratio = Number(size.replace('vh', '')) / 100;\n            return innerHeight * ratio;\n        }\n    }\n    return size;\n};\nvar calculateNewMax = function (parentSize, innerWidth, innerHeight, maxWidth, maxHeight, minWidth, minHeight) {\n    maxWidth = getPixelSize(maxWidth, parentSize.width, innerWidth, innerHeight);\n    maxHeight = getPixelSize(maxHeight, parentSize.height, innerWidth, innerHeight);\n    minWidth = getPixelSize(minWidth, parentSize.width, innerWidth, innerHeight);\n    minHeight = getPixelSize(minHeight, parentSize.height, innerWidth, innerHeight);\n    return {\n        maxWidth: typeof maxWidth === 'undefined' ? undefined : Number(maxWidth),\n        maxHeight: typeof maxHeight === 'undefined' ? undefined : Number(maxHeight),\n        minWidth: typeof minWidth === 'undefined' ? undefined : Number(minWidth),\n        minHeight: typeof minHeight === 'undefined' ? undefined : Number(minHeight),\n    };\n};\n/**\n * transform T | [T, T] to [T, T]\n * @param val\n * @returns\n */\n// tslint:disable-next-line\nvar normalizeToPair = function (val) { return (Array.isArray(val) ? val : [val, val]); };\nvar definedProps = [\n    'as',\n    'ref',\n    'style',\n    'className',\n    'grid',\n    'gridGap',\n    'snap',\n    'bounds',\n    'boundsByDirection',\n    'size',\n    'defaultSize',\n    'minWidth',\n    'minHeight',\n    'maxWidth',\n    'maxHeight',\n    'lockAspectRatio',\n    'lockAspectRatioExtraWidth',\n    'lockAspectRatioExtraHeight',\n    'enable',\n    'handleStyles',\n    'handleClasses',\n    'handleWrapperStyle',\n    'handleWrapperClass',\n    'children',\n    'onResizeStart',\n    'onResize',\n    'onResizeStop',\n    'handleComponent',\n    'scale',\n    'resizeRatio',\n    'snapGap',\n];\n// HACK: This class is used to calculate % size.\nvar baseClassName = '__resizable_base__';\nvar Resizable = /** @class */ (function (_super) {\n    __extends(Resizable, _super);\n    function Resizable(props) {\n        var _a, _b, _c, _d;\n        var _this = _super.call(this, props) || this;\n        _this.ratio = 1;\n        _this.resizable = null;\n        // For parent boundary\n        _this.parentLeft = 0;\n        _this.parentTop = 0;\n        // For boundary\n        _this.resizableLeft = 0;\n        _this.resizableRight = 0;\n        _this.resizableTop = 0;\n        _this.resizableBottom = 0;\n        // For target boundary\n        _this.targetLeft = 0;\n        _this.targetTop = 0;\n        _this.delta = {\n            width: 0,\n            height: 0,\n        };\n        _this.appendBase = function () {\n            if (!_this.resizable || !_this.window) {\n                return null;\n            }\n            var parent = _this.parentNode;\n            if (!parent) {\n                return null;\n            }\n            var element = _this.window.document.createElement('div');\n            element.style.width = '100%';\n            element.style.height = '100%';\n            element.style.position = 'absolute';\n            element.style.transform = 'scale(0, 0)';\n            element.style.left = '0';\n            element.style.flex = '0 0 100%';\n            if (element.classList) {\n                element.classList.add(baseClassName);\n            }\n            else {\n                element.className += baseClassName;\n            }\n            parent.appendChild(element);\n            return element;\n        };\n        _this.removeBase = function (base) {\n            var parent = _this.parentNode;\n            if (!parent) {\n                return;\n            }\n            parent.removeChild(base);\n        };\n        _this.state = {\n            isResizing: false,\n            width: (_b = (_a = _this.propsSize) === null || _a === void 0 ? void 0 : _a.width) !== null && _b !== void 0 ? _b : 'auto',\n            height: (_d = (_c = _this.propsSize) === null || _c === void 0 ? void 0 : _c.height) !== null && _d !== void 0 ? _d : 'auto',\n            direction: 'right',\n            original: {\n                x: 0,\n                y: 0,\n                width: 0,\n                height: 0,\n            },\n            backgroundStyle: {\n                height: '100%',\n                width: '100%',\n                backgroundColor: 'rgba(0,0,0,0)',\n                cursor: 'auto',\n                opacity: 0,\n                position: 'fixed',\n                zIndex: 9999,\n                top: '0',\n                left: '0',\n                bottom: '0',\n                right: '0',\n            },\n            flexBasis: undefined,\n        };\n        _this.onResizeStart = _this.onResizeStart.bind(_this);\n        _this.onMouseMove = _this.onMouseMove.bind(_this);\n        _this.onMouseUp = _this.onMouseUp.bind(_this);\n        return _this;\n    }\n    Object.defineProperty(Resizable.prototype, \"parentNode\", {\n        get: function () {\n            if (!this.resizable) {\n                return null;\n            }\n            return this.resizable.parentNode;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Object.defineProperty(Resizable.prototype, \"window\", {\n        get: function () {\n            if (!this.resizable) {\n                return null;\n            }\n            if (!this.resizable.ownerDocument) {\n                return null;\n            }\n            return this.resizable.ownerDocument.defaultView;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Object.defineProperty(Resizable.prototype, \"propsSize\", {\n        get: function () {\n            return this.props.size || this.props.defaultSize || DEFAULT_SIZE;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Object.defineProperty(Resizable.prototype, \"size\", {\n        get: function () {\n            var width = 0;\n            var height = 0;\n            if (this.resizable && this.window) {\n                var orgWidth = this.resizable.offsetWidth;\n                var orgHeight = this.resizable.offsetHeight;\n                // HACK: Set position `relative` to get parent size.\n                //       This is because when re-resizable set `absolute`, I can not get base width correctly.\n                var orgPosition = this.resizable.style.position;\n                if (orgPosition !== 'relative') {\n                    this.resizable.style.position = 'relative';\n                }\n                // INFO: Use original width or height if set auto.\n                width = this.resizable.style.width !== 'auto' ? this.resizable.offsetWidth : orgWidth;\n                height = this.resizable.style.height !== 'auto' ? this.resizable.offsetHeight : orgHeight;\n                // Restore original position\n                this.resizable.style.position = orgPosition;\n            }\n            return { width: width, height: height };\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Object.defineProperty(Resizable.prototype, \"sizeStyle\", {\n        get: function () {\n            var _this = this;\n            var size = this.props.size;\n            var getSize = function (key) {\n                var _a;\n                if (typeof _this.state[key] === 'undefined' || _this.state[key] === 'auto') {\n                    return 'auto';\n                }\n                if (_this.propsSize && _this.propsSize[key] && ((_a = _this.propsSize[key]) === null || _a === void 0 ? void 0 : _a.toString().endsWith('%'))) {\n                    if (_this.state[key].toString().endsWith('%')) {\n                        return _this.state[key].toString();\n                    }\n                    var parentSize = _this.getParentSize();\n                    var value = Number(_this.state[key].toString().replace('px', ''));\n                    var percent = (value / parentSize[key]) * 100;\n                    return \"\".concat(percent, \"%\");\n                }\n                return getStringSize(_this.state[key]);\n            };\n            var width = size && typeof size.width !== 'undefined' && !this.state.isResizing\n                ? getStringSize(size.width)\n                : getSize('width');\n            var height = size && typeof size.height !== 'undefined' && !this.state.isResizing\n                ? getStringSize(size.height)\n                : getSize('height');\n            return { width: width, height: height };\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Resizable.prototype.getParentSize = function () {\n        if (!this.parentNode) {\n            if (!this.window) {\n                return { width: 0, height: 0 };\n            }\n            return { width: this.window.innerWidth, height: this.window.innerHeight };\n        }\n        var base = this.appendBase();\n        if (!base) {\n            return { width: 0, height: 0 };\n        }\n        // INFO: To calculate parent width with flex layout\n        var wrapChanged = false;\n        var wrap = this.parentNode.style.flexWrap;\n        if (wrap !== 'wrap') {\n            wrapChanged = true;\n            this.parentNode.style.flexWrap = 'wrap';\n            // HACK: Use relative to get parent padding size\n        }\n        base.style.position = 'relative';\n        base.style.minWidth = '100%';\n        base.style.minHeight = '100%';\n        var size = {\n            width: base.offsetWidth,\n            height: base.offsetHeight,\n        };\n        if (wrapChanged) {\n            this.parentNode.style.flexWrap = wrap;\n        }\n        this.removeBase(base);\n        return size;\n    };\n    Resizable.prototype.bindEvents = function () {\n        if (this.window) {\n            this.window.addEventListener('mouseup', this.onMouseUp);\n            this.window.addEventListener('mousemove', this.onMouseMove);\n            this.window.addEventListener('mouseleave', this.onMouseUp);\n            this.window.addEventListener('touchmove', this.onMouseMove, {\n                capture: true,\n                passive: false,\n            });\n            this.window.addEventListener('touchend', this.onMouseUp);\n        }\n    };\n    Resizable.prototype.unbindEvents = function () {\n        if (this.window) {\n            this.window.removeEventListener('mouseup', this.onMouseUp);\n            this.window.removeEventListener('mousemove', this.onMouseMove);\n            this.window.removeEventListener('mouseleave', this.onMouseUp);\n            this.window.removeEventListener('touchmove', this.onMouseMove, true);\n            this.window.removeEventListener('touchend', this.onMouseUp);\n        }\n    };\n    Resizable.prototype.componentDidMount = function () {\n        if (!this.resizable || !this.window) {\n            return;\n        }\n        var computedStyle = this.window.getComputedStyle(this.resizable);\n        this.setState({\n            width: this.state.width || this.size.width,\n            height: this.state.height || this.size.height,\n            flexBasis: computedStyle.flexBasis !== 'auto' ? computedStyle.flexBasis : undefined,\n        });\n    };\n    Resizable.prototype.componentWillUnmount = function () {\n        if (this.window) {\n            this.unbindEvents();\n        }\n    };\n    Resizable.prototype.createSizeForCssProperty = function (newSize, kind) {\n        var propsSize = this.propsSize && this.propsSize[kind];\n        return this.state[kind] === 'auto' &&\n            this.state.original[kind] === newSize &&\n            (typeof propsSize === 'undefined' || propsSize === 'auto')\n            ? 'auto'\n            : newSize;\n    };\n    Resizable.prototype.calculateNewMaxFromBoundary = function (maxWidth, maxHeight) {\n        var boundsByDirection = this.props.boundsByDirection;\n        var direction = this.state.direction;\n        var widthByDirection = boundsByDirection && hasDirection('left', direction);\n        var heightByDirection = boundsByDirection && hasDirection('top', direction);\n        var boundWidth;\n        var boundHeight;\n        if (this.props.bounds === 'parent') {\n            var parent_1 = this.parentNode;\n            if (parent_1) {\n                boundWidth = widthByDirection\n                    ? this.resizableRight - this.parentLeft\n                    : parent_1.offsetWidth + (this.parentLeft - this.resizableLeft);\n                boundHeight = heightByDirection\n                    ? this.resizableBottom - this.parentTop\n                    : parent_1.offsetHeight + (this.parentTop - this.resizableTop);\n            }\n        }\n        else if (this.props.bounds === 'window') {\n            if (this.window) {\n                boundWidth = widthByDirection ? this.resizableRight : this.window.innerWidth - this.resizableLeft;\n                boundHeight = heightByDirection ? this.resizableBottom : this.window.innerHeight - this.resizableTop;\n            }\n        }\n        else if (this.props.bounds) {\n            boundWidth = widthByDirection\n                ? this.resizableRight - this.targetLeft\n                : this.props.bounds.offsetWidth + (this.targetLeft - this.resizableLeft);\n            boundHeight = heightByDirection\n                ? this.resizableBottom - this.targetTop\n                : this.props.bounds.offsetHeight + (this.targetTop - this.resizableTop);\n        }\n        if (boundWidth && Number.isFinite(boundWidth)) {\n            maxWidth = maxWidth && maxWidth < boundWidth ? maxWidth : boundWidth;\n        }\n        if (boundHeight && Number.isFinite(boundHeight)) {\n            maxHeight = maxHeight && maxHeight < boundHeight ? maxHeight : boundHeight;\n        }\n        return { maxWidth: maxWidth, maxHeight: maxHeight };\n    };\n    Resizable.prototype.calculateNewSizeFromDirection = function (clientX, clientY) {\n        var scale = this.props.scale || 1;\n        var _a = normalizeToPair(this.props.resizeRatio || 1), resizeRatioX = _a[0], resizeRatioY = _a[1];\n        var _b = this.state, direction = _b.direction, original = _b.original;\n        var _c = this.props, lockAspectRatio = _c.lockAspectRatio, lockAspectRatioExtraHeight = _c.lockAspectRatioExtraHeight, lockAspectRatioExtraWidth = _c.lockAspectRatioExtraWidth;\n        var newWidth = original.width;\n        var newHeight = original.height;\n        var extraHeight = lockAspectRatioExtraHeight || 0;\n        var extraWidth = lockAspectRatioExtraWidth || 0;\n        if (hasDirection('right', direction)) {\n            newWidth = original.width + ((clientX - original.x) * resizeRatioX) / scale;\n            if (lockAspectRatio) {\n                newHeight = (newWidth - extraWidth) / this.ratio + extraHeight;\n            }\n        }\n        if (hasDirection('left', direction)) {\n            newWidth = original.width - ((clientX - original.x) * resizeRatioX) / scale;\n            if (lockAspectRatio) {\n                newHeight = (newWidth - extraWidth) / this.ratio + extraHeight;\n            }\n        }\n        if (hasDirection('bottom', direction)) {\n            newHeight = original.height + ((clientY - original.y) * resizeRatioY) / scale;\n            if (lockAspectRatio) {\n                newWidth = (newHeight - extraHeight) * this.ratio + extraWidth;\n            }\n        }\n        if (hasDirection('top', direction)) {\n            newHeight = original.height - ((clientY - original.y) * resizeRatioY) / scale;\n            if (lockAspectRatio) {\n                newWidth = (newHeight - extraHeight) * this.ratio + extraWidth;\n            }\n        }\n        return { newWidth: newWidth, newHeight: newHeight };\n    };\n    Resizable.prototype.calculateNewSizeFromAspectRatio = function (newWidth, newHeight, max, min) {\n        var _a = this.props, lockAspectRatio = _a.lockAspectRatio, lockAspectRatioExtraHeight = _a.lockAspectRatioExtraHeight, lockAspectRatioExtraWidth = _a.lockAspectRatioExtraWidth;\n        var computedMinWidth = typeof min.width === 'undefined' ? 10 : min.width;\n        var computedMaxWidth = typeof max.width === 'undefined' || max.width < 0 ? newWidth : max.width;\n        var computedMinHeight = typeof min.height === 'undefined' ? 10 : min.height;\n        var computedMaxHeight = typeof max.height === 'undefined' || max.height < 0 ? newHeight : max.height;\n        var extraHeight = lockAspectRatioExtraHeight || 0;\n        var extraWidth = lockAspectRatioExtraWidth || 0;\n        if (lockAspectRatio) {\n            var extraMinWidth = (computedMinHeight - extraHeight) * this.ratio + extraWidth;\n            var extraMaxWidth = (computedMaxHeight - extraHeight) * this.ratio + extraWidth;\n            var extraMinHeight = (computedMinWidth - extraWidth) / this.ratio + extraHeight;\n            var extraMaxHeight = (computedMaxWidth - extraWidth) / this.ratio + extraHeight;\n            var lockedMinWidth = Math.max(computedMinWidth, extraMinWidth);\n            var lockedMaxWidth = Math.min(computedMaxWidth, extraMaxWidth);\n            var lockedMinHeight = Math.max(computedMinHeight, extraMinHeight);\n            var lockedMaxHeight = Math.min(computedMaxHeight, extraMaxHeight);\n            newWidth = clamp(newWidth, lockedMinWidth, lockedMaxWidth);\n            newHeight = clamp(newHeight, lockedMinHeight, lockedMaxHeight);\n        }\n        else {\n            newWidth = clamp(newWidth, computedMinWidth, computedMaxWidth);\n            newHeight = clamp(newHeight, computedMinHeight, computedMaxHeight);\n        }\n        return { newWidth: newWidth, newHeight: newHeight };\n    };\n    Resizable.prototype.setBoundingClientRect = function () {\n        var adjustedScale = 1 / (this.props.scale || 1);\n        // For parent boundary\n        if (this.props.bounds === 'parent') {\n            var parent_2 = this.parentNode;\n            if (parent_2) {\n                var parentRect = parent_2.getBoundingClientRect();\n                this.parentLeft = parentRect.left * adjustedScale;\n                this.parentTop = parentRect.top * adjustedScale;\n            }\n        }\n        // For target(html element) boundary\n        if (this.props.bounds && typeof this.props.bounds !== 'string') {\n            var targetRect = this.props.bounds.getBoundingClientRect();\n            this.targetLeft = targetRect.left * adjustedScale;\n            this.targetTop = targetRect.top * adjustedScale;\n        }\n        // For boundary\n        if (this.resizable) {\n            var _a = this.resizable.getBoundingClientRect(), left = _a.left, top_1 = _a.top, right = _a.right, bottom = _a.bottom;\n            this.resizableLeft = left * adjustedScale;\n            this.resizableRight = right * adjustedScale;\n            this.resizableTop = top_1 * adjustedScale;\n            this.resizableBottom = bottom * adjustedScale;\n        }\n    };\n    Resizable.prototype.onResizeStart = function (event, direction) {\n        if (!this.resizable || !this.window) {\n            return;\n        }\n        var clientX = 0;\n        var clientY = 0;\n        if (event.nativeEvent && isMouseEvent(event.nativeEvent)) {\n            clientX = event.nativeEvent.clientX;\n            clientY = event.nativeEvent.clientY;\n        }\n        else if (event.nativeEvent && isTouchEvent(event.nativeEvent)) {\n            clientX = event.nativeEvent.touches[0].clientX;\n            clientY = event.nativeEvent.touches[0].clientY;\n        }\n        if (this.props.onResizeStart) {\n            if (this.resizable) {\n                var startResize = this.props.onResizeStart(event, direction, this.resizable);\n                if (startResize === false) {\n                    return;\n                }\n            }\n        }\n        // Fix #168\n        if (this.props.size) {\n            if (typeof this.props.size.height !== 'undefined' && this.props.size.height !== this.state.height) {\n                this.setState({ height: this.props.size.height });\n            }\n            if (typeof this.props.size.width !== 'undefined' && this.props.size.width !== this.state.width) {\n                this.setState({ width: this.props.size.width });\n            }\n        }\n        // For lockAspectRatio case\n        this.ratio =\n            typeof this.props.lockAspectRatio === 'number' ? this.props.lockAspectRatio : this.size.width / this.size.height;\n        var flexBasis;\n        var computedStyle = this.window.getComputedStyle(this.resizable);\n        if (computedStyle.flexBasis !== 'auto') {\n            var parent_3 = this.parentNode;\n            if (parent_3) {\n                var dir = this.window.getComputedStyle(parent_3).flexDirection;\n                this.flexDir = dir.startsWith('row') ? 'row' : 'column';\n                flexBasis = computedStyle.flexBasis;\n            }\n        }\n        // For boundary\n        this.setBoundingClientRect();\n        this.bindEvents();\n        var state = {\n            original: {\n                x: clientX,\n                y: clientY,\n                width: this.size.width,\n                height: this.size.height,\n            },\n            isResizing: true,\n            backgroundStyle: __assign(__assign({}, this.state.backgroundStyle), { cursor: this.window.getComputedStyle(event.target).cursor || 'auto' }),\n            direction: direction,\n            flexBasis: flexBasis,\n        };\n        this.setState(state);\n    };\n    Resizable.prototype.onMouseMove = function (event) {\n        var _this = this;\n        if (!this.state.isResizing || !this.resizable || !this.window) {\n            return;\n        }\n        if (this.window.TouchEvent && isTouchEvent(event)) {\n            try {\n                event.preventDefault();\n                event.stopPropagation();\n            }\n            catch (e) {\n                // Ignore on fail\n            }\n        }\n        var _a = this.props, maxWidth = _a.maxWidth, maxHeight = _a.maxHeight, minWidth = _a.minWidth, minHeight = _a.minHeight;\n        var clientX = isTouchEvent(event) ? event.touches[0].clientX : event.clientX;\n        var clientY = isTouchEvent(event) ? event.touches[0].clientY : event.clientY;\n        var _b = this.state, direction = _b.direction, original = _b.original, width = _b.width, height = _b.height;\n        var parentSize = this.getParentSize();\n        var max = calculateNewMax(parentSize, this.window.innerWidth, this.window.innerHeight, maxWidth, maxHeight, minWidth, minHeight);\n        maxWidth = max.maxWidth;\n        maxHeight = max.maxHeight;\n        minWidth = max.minWidth;\n        minHeight = max.minHeight;\n        // Calculate new size\n        var _c = this.calculateNewSizeFromDirection(clientX, clientY), newHeight = _c.newHeight, newWidth = _c.newWidth;\n        // Calculate max size from boundary settings\n        var boundaryMax = this.calculateNewMaxFromBoundary(maxWidth, maxHeight);\n        if (this.props.snap && this.props.snap.x) {\n            newWidth = findClosestSnap(newWidth, this.props.snap.x, this.props.snapGap);\n        }\n        if (this.props.snap && this.props.snap.y) {\n            newHeight = findClosestSnap(newHeight, this.props.snap.y, this.props.snapGap);\n        }\n        // Calculate new size from aspect ratio\n        var newSize = this.calculateNewSizeFromAspectRatio(newWidth, newHeight, { width: boundaryMax.maxWidth, height: boundaryMax.maxHeight }, { width: minWidth, height: minHeight });\n        newWidth = newSize.newWidth;\n        newHeight = newSize.newHeight;\n        if (this.props.grid) {\n            var newGridWidth = snap(newWidth, this.props.grid[0], this.props.gridGap ? this.props.gridGap[0] : 0);\n            var newGridHeight = snap(newHeight, this.props.grid[1], this.props.gridGap ? this.props.gridGap[1] : 0);\n            var gap = this.props.snapGap || 0;\n            var w = gap === 0 || Math.abs(newGridWidth - newWidth) <= gap ? newGridWidth : newWidth;\n            var h = gap === 0 || Math.abs(newGridHeight - newHeight) <= gap ? newGridHeight : newHeight;\n            newWidth = w;\n            newHeight = h;\n        }\n        var delta = {\n            width: newWidth - original.width,\n            height: newHeight - original.height,\n        };\n        this.delta = delta;\n        if (width && typeof width === 'string') {\n            if (width.endsWith('%')) {\n                var percent = (newWidth / parentSize.width) * 100;\n                newWidth = \"\".concat(percent, \"%\");\n            }\n            else if (width.endsWith('vw')) {\n                var vw = (newWidth / this.window.innerWidth) * 100;\n                newWidth = \"\".concat(vw, \"vw\");\n            }\n            else if (width.endsWith('vh')) {\n                var vh = (newWidth / this.window.innerHeight) * 100;\n                newWidth = \"\".concat(vh, \"vh\");\n            }\n        }\n        if (height && typeof height === 'string') {\n            if (height.endsWith('%')) {\n                var percent = (newHeight / parentSize.height) * 100;\n                newHeight = \"\".concat(percent, \"%\");\n            }\n            else if (height.endsWith('vw')) {\n                var vw = (newHeight / this.window.innerWidth) * 100;\n                newHeight = \"\".concat(vw, \"vw\");\n            }\n            else if (height.endsWith('vh')) {\n                var vh = (newHeight / this.window.innerHeight) * 100;\n                newHeight = \"\".concat(vh, \"vh\");\n            }\n        }\n        var newState = {\n            width: this.createSizeForCssProperty(newWidth, 'width'),\n            height: this.createSizeForCssProperty(newHeight, 'height'),\n        };\n        if (this.flexDir === 'row') {\n            newState.flexBasis = newState.width;\n        }\n        else if (this.flexDir === 'column') {\n            newState.flexBasis = newState.height;\n        }\n        var widthChanged = this.state.width !== newState.width;\n        var heightChanged = this.state.height !== newState.height;\n        var flexBaseChanged = this.state.flexBasis !== newState.flexBasis;\n        var changed = widthChanged || heightChanged || flexBaseChanged;\n        if (changed) {\n            // For v18, update state sync\n            flushSync(function () {\n                _this.setState(newState);\n            });\n        }\n        if (this.props.onResize) {\n            if (changed) {\n                this.props.onResize(event, direction, this.resizable, delta);\n            }\n        }\n    };\n    Resizable.prototype.onMouseUp = function (event) {\n        var _a, _b;\n        var _c = this.state, isResizing = _c.isResizing, direction = _c.direction, original = _c.original;\n        if (!isResizing || !this.resizable) {\n            return;\n        }\n        if (this.props.onResizeStop) {\n            this.props.onResizeStop(event, direction, this.resizable, this.delta);\n        }\n        if (this.props.size) {\n            this.setState({ width: (_a = this.props.size.width) !== null && _a !== void 0 ? _a : 'auto', height: (_b = this.props.size.height) !== null && _b !== void 0 ? _b : 'auto' });\n        }\n        this.unbindEvents();\n        this.setState({\n            isResizing: false,\n            backgroundStyle: __assign(__assign({}, this.state.backgroundStyle), { cursor: 'auto' }),\n        });\n    };\n    Resizable.prototype.updateSize = function (size) {\n        var _a, _b;\n        this.setState({ width: (_a = size.width) !== null && _a !== void 0 ? _a : 'auto', height: (_b = size.height) !== null && _b !== void 0 ? _b : 'auto' });\n    };\n    Resizable.prototype.renderResizer = function () {\n        var _this = this;\n        var _a = this.props, enable = _a.enable, handleStyles = _a.handleStyles, handleClasses = _a.handleClasses, handleWrapperStyle = _a.handleWrapperStyle, handleWrapperClass = _a.handleWrapperClass, handleComponent = _a.handleComponent;\n        if (!enable) {\n            return null;\n        }\n        var resizers = Object.keys(enable).map(function (dir) {\n            if (enable[dir] !== false) {\n                return (_jsx(Resizer, { direction: dir, onResizeStart: _this.onResizeStart, replaceStyles: handleStyles && handleStyles[dir], className: handleClasses && handleClasses[dir], children: handleComponent && handleComponent[dir] ? handleComponent[dir] : null }, dir));\n            }\n            return null;\n        });\n        // #93 Wrap the resize box in span (will not break 100% width/height)\n        return (_jsx(\"div\", { className: handleWrapperClass, style: handleWrapperStyle, children: resizers }));\n    };\n    Resizable.prototype.render = function () {\n        var _this = this;\n        var extendsProps = Object.keys(this.props).reduce(function (acc, key) {\n            if (definedProps.indexOf(key) !== -1) {\n                return acc;\n            }\n            acc[key] = _this.props[key];\n            return acc;\n        }, {});\n        var style = __assign(__assign(__assign({ position: 'relative', userSelect: this.state.isResizing ? 'none' : 'auto' }, this.props.style), this.sizeStyle), { maxWidth: this.props.maxWidth, maxHeight: this.props.maxHeight, minWidth: this.props.minWidth, minHeight: this.props.minHeight, boxSizing: 'border-box', flexShrink: 0 });\n        if (this.state.flexBasis) {\n            style.flexBasis = this.state.flexBasis;\n        }\n        var Wrapper = this.props.as || 'div';\n        return (_jsxs(Wrapper, __assign({ style: style, className: this.props.className }, extendsProps, { \n            // `ref` is after `extendsProps` to ensure this one wins over a version\n            // passed in\n            ref: function (c) {\n                if (c) {\n                    _this.resizable = c;\n                }\n            }, children: [this.state.isResizing && _jsx(\"div\", { style: this.state.backgroundStyle }), this.props.children, this.renderResizer()] })));\n    };\n    Resizable.defaultProps = {\n        as: 'div',\n        onResizeStart: function () { },\n        onResize: function () { },\n        onResizeStop: function () { },\n        enable: {\n            top: true,\n            right: true,\n            bottom: true,\n            left: true,\n            topRight: true,\n            bottomRight: true,\n            bottomLeft: true,\n            topLeft: true,\n        },\n        style: {},\n        grid: [1, 1],\n        gridGap: [0, 0],\n        lockAspectRatio: false,\n        lockAspectRatioExtraWidth: 0,\n        lockAspectRatioExtraHeight: 0,\n        scale: 1,\n        resizeRatio: 1,\n        snapGap: 0,\n    };\n    return Resizable;\n}(PureComponent));\nexport { Resizable };\n","var __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nimport { memo, useCallback, useMemo } from 'react';\nvar rowSizeBase = {\n    width: '100%',\n    height: '10px',\n    top: '0px',\n    left: '0px',\n    cursor: 'row-resize',\n};\nvar colSizeBase = {\n    width: '10px',\n    height: '100%',\n    top: '0px',\n    left: '0px',\n    cursor: 'col-resize',\n};\nvar edgeBase = {\n    width: '20px',\n    height: '20px',\n    position: 'absolute',\n    zIndex: 1,\n};\nvar styles = {\n    top: __assign(__assign({}, rowSizeBase), { top: '-5px' }),\n    right: __assign(__assign({}, colSizeBase), { left: undefined, right: '-5px' }),\n    bottom: __assign(__assign({}, rowSizeBase), { top: undefined, bottom: '-5px' }),\n    left: __assign(__assign({}, colSizeBase), { left: '-5px' }),\n    topRight: __assign(__assign({}, edgeBase), { right: '-10px', top: '-10px', cursor: 'ne-resize' }),\n    bottomRight: __assign(__assign({}, edgeBase), { right: '-10px', bottom: '-10px', cursor: 'se-resize' }),\n    bottomLeft: __assign(__assign({}, edgeBase), { left: '-10px', bottom: '-10px', cursor: 'sw-resize' }),\n    topLeft: __assign(__assign({}, edgeBase), { left: '-10px', top: '-10px', cursor: 'nw-resize' }),\n};\nexport var Resizer = memo(function (props) {\n    var onResizeStart = props.onResizeStart, direction = props.direction, children = props.children, replaceStyles = props.replaceStyles, className = props.className;\n    var onMouseDown = useCallback(function (e) {\n        onResizeStart(e, direction);\n    }, [onResizeStart, direction]);\n    var onTouchStart = useCallback(function (e) {\n        onResizeStart(e, direction);\n    }, [onResizeStart, direction]);\n    var style = useMemo(function () {\n        return __assign(__assign({ position: 'absolute', userSelect: 'none' }, styles[direction]), (replaceStyles !== null && replaceStyles !== void 0 ? replaceStyles : {}));\n    }, [replaceStyles, direction]);\n    return (_jsx(\"div\", { className: className || undefined, style: style, onMouseDown: onMouseDown, onTouchStart: onTouchStart, children: children }));\n});\n","import * as React from 'react';\nimport { decode } from 'blurhash';\n\nexport type Props = React.CanvasHTMLAttributes<HTMLCanvasElement> & {\n  hash: string;\n  height?: number;\n  punch?: number;\n  width?: number;\n};\n\nexport default class BlurhashCanvas extends React.PureComponent<Props> {\n  static defaultProps = {\n    height: 128,\n    width: 128,\n  };\n\n  canvas: HTMLCanvasElement = null;\n\n  componentDidUpdate() {\n    this.draw();\n  }\n\n  handleRef = (canvas: HTMLCanvasElement) => {\n    this.canvas = canvas;\n    this.draw();\n  };\n\n  draw = () => {\n    const { hash, height, punch, width } = this.props;\n\n    if (this.canvas) {\n      const pixels = decode(hash, width, height, punch);\n\n      const ctx = this.canvas.getContext('2d');\n      const imageData = ctx.createImageData(width, height);\n      imageData.data.set(pixels);\n      ctx.putImageData(imageData, 0, 0);\n    }\n  };\n\n  render() {\n    const { hash, height, width, ...rest } = this.props;\n\n    return <canvas {...rest} height={height} width={width} ref={this.handleRef} />;\n  }\n}\n","import * as React from 'react';\n\nimport BlurhashCanvas from './BlurhashCanvas';\n\ntype Props = React.HTMLAttributes<HTMLDivElement> & {\n  hash: string;\n  /** CSS height, default: 128 */\n  height?: number | string | 'auto';\n  punch?: number;\n  resolutionX?: number;\n  resolutionY?: number;\n  style?: React.CSSProperties;\n  /** CSS width, default: 128 */\n  width?: number | string | 'auto';\n};\n\nconst canvasStyle: React.CSSProperties = {\n  position: 'absolute',\n  top: 0,\n  bottom: 0,\n  left: 0,\n  right: 0,\n  width: '100%',\n  height: '100%',\n};\n\nexport default class Blurhash extends React.PureComponent<Props> {\n  static defaultProps = {\n    height: 128,\n    width: 128,\n    resolutionX: 32,\n    resolutionY: 32,\n  };\n\n  componentDidUpdate() {\n    if (this.props.resolutionX <= 0) {\n      throw new Error('resolutionX must be larger than zero');\n    }\n\n    if (this.props.resolutionY <= 0) {\n      throw new Error('resolutionY must be larger than zero');\n    }\n  }\n\n  render() {\n    const { hash, height, width, punch, resolutionX, resolutionY, style, ...rest } = this.props;\n\n    return (\n      <div\n        {...rest}\n        style={{ display: 'inline-block', height, width, ...style, position: 'relative' }}\n      >\n        <BlurhashCanvas\n          hash={hash}\n          height={resolutionY}\n          width={resolutionX}\n          punch={punch}\n          style={canvasStyle}\n        />\n      </div>\n    );\n  }\n}\n","/**\n * @license React\n * react-dom.production.min.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n/*\n Modernizr 3.0.0pre (Custom Build) | MIT\n*/\n'use strict';var aa=require(\"react\"),ca=require(\"scheduler\");function p(a){for(var b=\"https://reactjs.org/docs/error-decoder.html?invariant=\"+a,c=1;c<arguments.length;c++)b+=\"&args[]=\"+encodeURIComponent(arguments[c]);return\"Minified React error #\"+a+\"; visit \"+b+\" for the full message or use the non-minified dev environment for full errors and additional helpful warnings.\"}var da=new Set,ea={};function fa(a,b){ha(a,b);ha(a+\"Capture\",b)}\nfunction ha(a,b){ea[a]=b;for(a=0;a<b.length;a++)da.add(b[a])}\nvar ia=!(\"undefined\"===typeof window||\"undefined\"===typeof window.document||\"undefined\"===typeof window.document.createElement),ja=Object.prototype.hasOwnProperty,ka=/^[:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD][:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040]*$/,la=\n{},ma={};function oa(a){if(ja.call(ma,a))return!0;if(ja.call(la,a))return!1;if(ka.test(a))return ma[a]=!0;la[a]=!0;return!1}function pa(a,b,c,d){if(null!==c&&0===c.type)return!1;switch(typeof b){case \"function\":case \"symbol\":return!0;case \"boolean\":if(d)return!1;if(null!==c)return!c.acceptsBooleans;a=a.toLowerCase().slice(0,5);return\"data-\"!==a&&\"aria-\"!==a;default:return!1}}\nfunction qa(a,b,c,d){if(null===b||\"undefined\"===typeof b||pa(a,b,c,d))return!0;if(d)return!1;if(null!==c)switch(c.type){case 3:return!b;case 4:return!1===b;case 5:return isNaN(b);case 6:return isNaN(b)||1>b}return!1}function v(a,b,c,d,e,f,g){this.acceptsBooleans=2===b||3===b||4===b;this.attributeName=d;this.attributeNamespace=e;this.mustUseProperty=c;this.propertyName=a;this.type=b;this.sanitizeURL=f;this.removeEmptyString=g}var z={};\n\"children dangerouslySetInnerHTML defaultValue defaultChecked innerHTML suppressContentEditableWarning suppressHydrationWarning style\".split(\" \").forEach(function(a){z[a]=new v(a,0,!1,a,null,!1,!1)});[[\"acceptCharset\",\"accept-charset\"],[\"className\",\"class\"],[\"htmlFor\",\"for\"],[\"httpEquiv\",\"http-equiv\"]].forEach(function(a){var b=a[0];z[b]=new v(b,1,!1,a[1],null,!1,!1)});[\"contentEditable\",\"draggable\",\"spellCheck\",\"value\"].forEach(function(a){z[a]=new v(a,2,!1,a.toLowerCase(),null,!1,!1)});\n[\"autoReverse\",\"externalResourcesRequired\",\"focusable\",\"preserveAlpha\"].forEach(function(a){z[a]=new v(a,2,!1,a,null,!1,!1)});\"allowFullScreen async autoFocus autoPlay controls default defer disabled disablePictureInPicture disableRemotePlayback formNoValidate hidden loop noModule noValidate open playsInline readOnly required reversed scoped seamless itemScope\".split(\" \").forEach(function(a){z[a]=new v(a,3,!1,a.toLowerCase(),null,!1,!1)});\n[\"checked\",\"multiple\",\"muted\",\"selected\"].forEach(function(a){z[a]=new v(a,3,!0,a,null,!1,!1)});[\"capture\",\"download\"].forEach(function(a){z[a]=new v(a,4,!1,a,null,!1,!1)});[\"cols\",\"rows\",\"size\",\"span\"].forEach(function(a){z[a]=new v(a,6,!1,a,null,!1,!1)});[\"rowSpan\",\"start\"].forEach(function(a){z[a]=new v(a,5,!1,a.toLowerCase(),null,!1,!1)});var ra=/[\\-:]([a-z])/g;function sa(a){return a[1].toUpperCase()}\n\"accent-height alignment-baseline arabic-form baseline-shift cap-height clip-path clip-rule color-interpolation color-interpolation-filters color-profile color-rendering dominant-baseline enable-background fill-opacity fill-rule flood-color flood-opacity font-family font-size font-size-adjust font-stretch font-style font-variant font-weight glyph-name glyph-orientation-horizontal glyph-orientation-vertical horiz-adv-x horiz-origin-x image-rendering letter-spacing lighting-color marker-end marker-mid marker-start overline-position overline-thickness paint-order panose-1 pointer-events rendering-intent shape-rendering stop-color stop-opacity strikethrough-position strikethrough-thickness stroke-dasharray stroke-dashoffset stroke-linecap stroke-linejoin stroke-miterlimit stroke-opacity stroke-width text-anchor text-decoration text-rendering underline-position underline-thickness unicode-bidi unicode-range units-per-em v-alphabetic v-hanging v-ideographic v-mathematical vector-effect vert-adv-y vert-origin-x vert-origin-y word-spacing writing-mode xmlns:xlink x-height\".split(\" \").forEach(function(a){var b=a.replace(ra,\nsa);z[b]=new v(b,1,!1,a,null,!1,!1)});\"xlink:actuate xlink:arcrole xlink:role xlink:show xlink:title xlink:type\".split(\" \").forEach(function(a){var b=a.replace(ra,sa);z[b]=new v(b,1,!1,a,\"http://www.w3.org/1999/xlink\",!1,!1)});[\"xml:base\",\"xml:lang\",\"xml:space\"].forEach(function(a){var b=a.replace(ra,sa);z[b]=new v(b,1,!1,a,\"http://www.w3.org/XML/1998/namespace\",!1,!1)});[\"tabIndex\",\"crossOrigin\"].forEach(function(a){z[a]=new v(a,1,!1,a.toLowerCase(),null,!1,!1)});\nz.xlinkHref=new v(\"xlinkHref\",1,!1,\"xlink:href\",\"http://www.w3.org/1999/xlink\",!0,!1);[\"src\",\"href\",\"action\",\"formAction\"].forEach(function(a){z[a]=new v(a,1,!1,a.toLowerCase(),null,!0,!0)});\nfunction ta(a,b,c,d){var e=z.hasOwnProperty(b)?z[b]:null;if(null!==e?0!==e.type:d||!(2<b.length)||\"o\"!==b[0]&&\"O\"!==b[0]||\"n\"!==b[1]&&\"N\"!==b[1])qa(b,c,e,d)&&(c=null),d||null===e?oa(b)&&(null===c?a.removeAttribute(b):a.setAttribute(b,\"\"+c)):e.mustUseProperty?a[e.propertyName]=null===c?3===e.type?!1:\"\":c:(b=e.attributeName,d=e.attributeNamespace,null===c?a.removeAttribute(b):(e=e.type,c=3===e||4===e&&!0===c?\"\":\"\"+c,d?a.setAttributeNS(d,b,c):a.setAttribute(b,c)))}\nvar ua=aa.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED,va=Symbol.for(\"react.element\"),wa=Symbol.for(\"react.portal\"),ya=Symbol.for(\"react.fragment\"),za=Symbol.for(\"react.strict_mode\"),Aa=Symbol.for(\"react.profiler\"),Ba=Symbol.for(\"react.provider\"),Ca=Symbol.for(\"react.context\"),Da=Symbol.for(\"react.forward_ref\"),Ea=Symbol.for(\"react.suspense\"),Fa=Symbol.for(\"react.suspense_list\"),Ga=Symbol.for(\"react.memo\"),Ha=Symbol.for(\"react.lazy\");Symbol.for(\"react.scope\");Symbol.for(\"react.debug_trace_mode\");\nvar Ia=Symbol.for(\"react.offscreen\");Symbol.for(\"react.legacy_hidden\");Symbol.for(\"react.cache\");Symbol.for(\"react.tracing_marker\");var Ja=Symbol.iterator;function Ka(a){if(null===a||\"object\"!==typeof a)return null;a=Ja&&a[Ja]||a[\"@@iterator\"];return\"function\"===typeof a?a:null}var A=Object.assign,La;function Ma(a){if(void 0===La)try{throw Error();}catch(c){var b=c.stack.trim().match(/\\n( *(at )?)/);La=b&&b[1]||\"\"}return\"\\n\"+La+a}var Na=!1;\nfunction Oa(a,b){if(!a||Na)return\"\";Na=!0;var c=Error.prepareStackTrace;Error.prepareStackTrace=void 0;try{if(b)if(b=function(){throw Error();},Object.defineProperty(b.prototype,\"props\",{set:function(){throw Error();}}),\"object\"===typeof Reflect&&Reflect.construct){try{Reflect.construct(b,[])}catch(l){var d=l}Reflect.construct(a,[],b)}else{try{b.call()}catch(l){d=l}a.call(b.prototype)}else{try{throw Error();}catch(l){d=l}a()}}catch(l){if(l&&d&&\"string\"===typeof l.stack){for(var e=l.stack.split(\"\\n\"),\nf=d.stack.split(\"\\n\"),g=e.length-1,h=f.length-1;1<=g&&0<=h&&e[g]!==f[h];)h--;for(;1<=g&&0<=h;g--,h--)if(e[g]!==f[h]){if(1!==g||1!==h){do if(g--,h--,0>h||e[g]!==f[h]){var k=\"\\n\"+e[g].replace(\" at new \",\" at \");a.displayName&&k.includes(\"<anonymous>\")&&(k=k.replace(\"<anonymous>\",a.displayName));return k}while(1<=g&&0<=h)}break}}}finally{Na=!1,Error.prepareStackTrace=c}return(a=a?a.displayName||a.name:\"\")?Ma(a):\"\"}\nfunction Pa(a){switch(a.tag){case 5:return Ma(a.type);case 16:return Ma(\"Lazy\");case 13:return Ma(\"Suspense\");case 19:return Ma(\"SuspenseList\");case 0:case 2:case 15:return a=Oa(a.type,!1),a;case 11:return a=Oa(a.type.render,!1),a;case 1:return a=Oa(a.type,!0),a;default:return\"\"}}\nfunction Qa(a){if(null==a)return null;if(\"function\"===typeof a)return a.displayName||a.name||null;if(\"string\"===typeof a)return a;switch(a){case ya:return\"Fragment\";case wa:return\"Portal\";case Aa:return\"Profiler\";case za:return\"StrictMode\";case Ea:return\"Suspense\";case Fa:return\"SuspenseList\"}if(\"object\"===typeof a)switch(a.$$typeof){case Ca:return(a.displayName||\"Context\")+\".Consumer\";case Ba:return(a._context.displayName||\"Context\")+\".Provider\";case Da:var b=a.render;a=a.displayName;a||(a=b.displayName||\nb.name||\"\",a=\"\"!==a?\"ForwardRef(\"+a+\")\":\"ForwardRef\");return a;case Ga:return b=a.displayName||null,null!==b?b:Qa(a.type)||\"Memo\";case Ha:b=a._payload;a=a._init;try{return Qa(a(b))}catch(c){}}return null}\nfunction Ra(a){var b=a.type;switch(a.tag){case 24:return\"Cache\";case 9:return(b.displayName||\"Context\")+\".Consumer\";case 10:return(b._context.displayName||\"Context\")+\".Provider\";case 18:return\"DehydratedFragment\";case 11:return a=b.render,a=a.displayName||a.name||\"\",b.displayName||(\"\"!==a?\"ForwardRef(\"+a+\")\":\"ForwardRef\");case 7:return\"Fragment\";case 5:return b;case 4:return\"Portal\";case 3:return\"Root\";case 6:return\"Text\";case 16:return Qa(b);case 8:return b===za?\"StrictMode\":\"Mode\";case 22:return\"Offscreen\";\ncase 12:return\"Profiler\";case 21:return\"Scope\";case 13:return\"Suspense\";case 19:return\"SuspenseList\";case 25:return\"TracingMarker\";case 1:case 0:case 17:case 2:case 14:case 15:if(\"function\"===typeof b)return b.displayName||b.name||null;if(\"string\"===typeof b)return b}return null}function Sa(a){switch(typeof a){case \"boolean\":case \"number\":case \"string\":case \"undefined\":return a;case \"object\":return a;default:return\"\"}}\nfunction Ta(a){var b=a.type;return(a=a.nodeName)&&\"input\"===a.toLowerCase()&&(\"checkbox\"===b||\"radio\"===b)}\nfunction Ua(a){var b=Ta(a)?\"checked\":\"value\",c=Object.getOwnPropertyDescriptor(a.constructor.prototype,b),d=\"\"+a[b];if(!a.hasOwnProperty(b)&&\"undefined\"!==typeof c&&\"function\"===typeof c.get&&\"function\"===typeof c.set){var e=c.get,f=c.set;Object.defineProperty(a,b,{configurable:!0,get:function(){return e.call(this)},set:function(a){d=\"\"+a;f.call(this,a)}});Object.defineProperty(a,b,{enumerable:c.enumerable});return{getValue:function(){return d},setValue:function(a){d=\"\"+a},stopTracking:function(){a._valueTracker=\nnull;delete a[b]}}}}function Va(a){a._valueTracker||(a._valueTracker=Ua(a))}function Wa(a){if(!a)return!1;var b=a._valueTracker;if(!b)return!0;var c=b.getValue();var d=\"\";a&&(d=Ta(a)?a.checked?\"true\":\"false\":a.value);a=d;return a!==c?(b.setValue(a),!0):!1}function Xa(a){a=a||(\"undefined\"!==typeof document?document:void 0);if(\"undefined\"===typeof a)return null;try{return a.activeElement||a.body}catch(b){return a.body}}\nfunction Ya(a,b){var c=b.checked;return A({},b,{defaultChecked:void 0,defaultValue:void 0,value:void 0,checked:null!=c?c:a._wrapperState.initialChecked})}function Za(a,b){var c=null==b.defaultValue?\"\":b.defaultValue,d=null!=b.checked?b.checked:b.defaultChecked;c=Sa(null!=b.value?b.value:c);a._wrapperState={initialChecked:d,initialValue:c,controlled:\"checkbox\"===b.type||\"radio\"===b.type?null!=b.checked:null!=b.value}}function ab(a,b){b=b.checked;null!=b&&ta(a,\"checked\",b,!1)}\nfunction bb(a,b){ab(a,b);var c=Sa(b.value),d=b.type;if(null!=c)if(\"number\"===d){if(0===c&&\"\"===a.value||a.value!=c)a.value=\"\"+c}else a.value!==\"\"+c&&(a.value=\"\"+c);else if(\"submit\"===d||\"reset\"===d){a.removeAttribute(\"value\");return}b.hasOwnProperty(\"value\")?cb(a,b.type,c):b.hasOwnProperty(\"defaultValue\")&&cb(a,b.type,Sa(b.defaultValue));null==b.checked&&null!=b.defaultChecked&&(a.defaultChecked=!!b.defaultChecked)}\nfunction db(a,b,c){if(b.hasOwnProperty(\"value\")||b.hasOwnProperty(\"defaultValue\")){var d=b.type;if(!(\"submit\"!==d&&\"reset\"!==d||void 0!==b.value&&null!==b.value))return;b=\"\"+a._wrapperState.initialValue;c||b===a.value||(a.value=b);a.defaultValue=b}c=a.name;\"\"!==c&&(a.name=\"\");a.defaultChecked=!!a._wrapperState.initialChecked;\"\"!==c&&(a.name=c)}\nfunction cb(a,b,c){if(\"number\"!==b||Xa(a.ownerDocument)!==a)null==c?a.defaultValue=\"\"+a._wrapperState.initialValue:a.defaultValue!==\"\"+c&&(a.defaultValue=\"\"+c)}var eb=Array.isArray;\nfunction fb(a,b,c,d){a=a.options;if(b){b={};for(var e=0;e<c.length;e++)b[\"$\"+c[e]]=!0;for(c=0;c<a.length;c++)e=b.hasOwnProperty(\"$\"+a[c].value),a[c].selected!==e&&(a[c].selected=e),e&&d&&(a[c].defaultSelected=!0)}else{c=\"\"+Sa(c);b=null;for(e=0;e<a.length;e++){if(a[e].value===c){a[e].selected=!0;d&&(a[e].defaultSelected=!0);return}null!==b||a[e].disabled||(b=a[e])}null!==b&&(b.selected=!0)}}\nfunction gb(a,b){if(null!=b.dangerouslySetInnerHTML)throw Error(p(91));return A({},b,{value:void 0,defaultValue:void 0,children:\"\"+a._wrapperState.initialValue})}function hb(a,b){var c=b.value;if(null==c){c=b.children;b=b.defaultValue;if(null!=c){if(null!=b)throw Error(p(92));if(eb(c)){if(1<c.length)throw Error(p(93));c=c[0]}b=c}null==b&&(b=\"\");c=b}a._wrapperState={initialValue:Sa(c)}}\nfunction ib(a,b){var c=Sa(b.value),d=Sa(b.defaultValue);null!=c&&(c=\"\"+c,c!==a.value&&(a.value=c),null==b.defaultValue&&a.defaultValue!==c&&(a.defaultValue=c));null!=d&&(a.defaultValue=\"\"+d)}function jb(a){var b=a.textContent;b===a._wrapperState.initialValue&&\"\"!==b&&null!==b&&(a.value=b)}function kb(a){switch(a){case \"svg\":return\"http://www.w3.org/2000/svg\";case \"math\":return\"http://www.w3.org/1998/Math/MathML\";default:return\"http://www.w3.org/1999/xhtml\"}}\nfunction lb(a,b){return null==a||\"http://www.w3.org/1999/xhtml\"===a?kb(b):\"http://www.w3.org/2000/svg\"===a&&\"foreignObject\"===b?\"http://www.w3.org/1999/xhtml\":a}\nvar mb,nb=function(a){return\"undefined\"!==typeof MSApp&&MSApp.execUnsafeLocalFunction?function(b,c,d,e){MSApp.execUnsafeLocalFunction(function(){return a(b,c,d,e)})}:a}(function(a,b){if(\"http://www.w3.org/2000/svg\"!==a.namespaceURI||\"innerHTML\"in a)a.innerHTML=b;else{mb=mb||document.createElement(\"div\");mb.innerHTML=\"<svg>\"+b.valueOf().toString()+\"</svg>\";for(b=mb.firstChild;a.firstChild;)a.removeChild(a.firstChild);for(;b.firstChild;)a.appendChild(b.firstChild)}});\nfunction ob(a,b){if(b){var c=a.firstChild;if(c&&c===a.lastChild&&3===c.nodeType){c.nodeValue=b;return}}a.textContent=b}\nvar pb={animationIterationCount:!0,aspectRatio:!0,borderImageOutset:!0,borderImageSlice:!0,borderImageWidth:!0,boxFlex:!0,boxFlexGroup:!0,boxOrdinalGroup:!0,columnCount:!0,columns:!0,flex:!0,flexGrow:!0,flexPositive:!0,flexShrink:!0,flexNegative:!0,flexOrder:!0,gridArea:!0,gridRow:!0,gridRowEnd:!0,gridRowSpan:!0,gridRowStart:!0,gridColumn:!0,gridColumnEnd:!0,gridColumnSpan:!0,gridColumnStart:!0,fontWeight:!0,lineClamp:!0,lineHeight:!0,opacity:!0,order:!0,orphans:!0,tabSize:!0,widows:!0,zIndex:!0,\nzoom:!0,fillOpacity:!0,floodOpacity:!0,stopOpacity:!0,strokeDasharray:!0,strokeDashoffset:!0,strokeMiterlimit:!0,strokeOpacity:!0,strokeWidth:!0},qb=[\"Webkit\",\"ms\",\"Moz\",\"O\"];Object.keys(pb).forEach(function(a){qb.forEach(function(b){b=b+a.charAt(0).toUpperCase()+a.substring(1);pb[b]=pb[a]})});function rb(a,b,c){return null==b||\"boolean\"===typeof b||\"\"===b?\"\":c||\"number\"!==typeof b||0===b||pb.hasOwnProperty(a)&&pb[a]?(\"\"+b).trim():b+\"px\"}\nfunction sb(a,b){a=a.style;for(var c in b)if(b.hasOwnProperty(c)){var d=0===c.indexOf(\"--\"),e=rb(c,b[c],d);\"float\"===c&&(c=\"cssFloat\");d?a.setProperty(c,e):a[c]=e}}var tb=A({menuitem:!0},{area:!0,base:!0,br:!0,col:!0,embed:!0,hr:!0,img:!0,input:!0,keygen:!0,link:!0,meta:!0,param:!0,source:!0,track:!0,wbr:!0});\nfunction ub(a,b){if(b){if(tb[a]&&(null!=b.children||null!=b.dangerouslySetInnerHTML))throw Error(p(137,a));if(null!=b.dangerouslySetInnerHTML){if(null!=b.children)throw Error(p(60));if(\"object\"!==typeof b.dangerouslySetInnerHTML||!(\"__html\"in b.dangerouslySetInnerHTML))throw Error(p(61));}if(null!=b.style&&\"object\"!==typeof b.style)throw Error(p(62));}}\nfunction vb(a,b){if(-1===a.indexOf(\"-\"))return\"string\"===typeof b.is;switch(a){case \"annotation-xml\":case \"color-profile\":case \"font-face\":case \"font-face-src\":case \"font-face-uri\":case \"font-face-format\":case \"font-face-name\":case \"missing-glyph\":return!1;default:return!0}}var wb=null;function xb(a){a=a.target||a.srcElement||window;a.correspondingUseElement&&(a=a.correspondingUseElement);return 3===a.nodeType?a.parentNode:a}var yb=null,zb=null,Ab=null;\nfunction Bb(a){if(a=Cb(a)){if(\"function\"!==typeof yb)throw Error(p(280));var b=a.stateNode;b&&(b=Db(b),yb(a.stateNode,a.type,b))}}function Eb(a){zb?Ab?Ab.push(a):Ab=[a]:zb=a}function Fb(){if(zb){var a=zb,b=Ab;Ab=zb=null;Bb(a);if(b)for(a=0;a<b.length;a++)Bb(b[a])}}function Gb(a,b){return a(b)}function Hb(){}var Ib=!1;function Jb(a,b,c){if(Ib)return a(b,c);Ib=!0;try{return Gb(a,b,c)}finally{if(Ib=!1,null!==zb||null!==Ab)Hb(),Fb()}}\nfunction Kb(a,b){var c=a.stateNode;if(null===c)return null;var d=Db(c);if(null===d)return null;c=d[b];a:switch(b){case \"onClick\":case \"onClickCapture\":case \"onDoubleClick\":case \"onDoubleClickCapture\":case \"onMouseDown\":case \"onMouseDownCapture\":case \"onMouseMove\":case \"onMouseMoveCapture\":case \"onMouseUp\":case \"onMouseUpCapture\":case \"onMouseEnter\":(d=!d.disabled)||(a=a.type,d=!(\"button\"===a||\"input\"===a||\"select\"===a||\"textarea\"===a));a=!d;break a;default:a=!1}if(a)return null;if(c&&\"function\"!==\ntypeof c)throw Error(p(231,b,typeof c));return c}var Lb=!1;if(ia)try{var Mb={};Object.defineProperty(Mb,\"passive\",{get:function(){Lb=!0}});window.addEventListener(\"test\",Mb,Mb);window.removeEventListener(\"test\",Mb,Mb)}catch(a){Lb=!1}function Nb(a,b,c,d,e,f,g,h,k){var l=Array.prototype.slice.call(arguments,3);try{b.apply(c,l)}catch(m){this.onError(m)}}var Ob=!1,Pb=null,Qb=!1,Rb=null,Sb={onError:function(a){Ob=!0;Pb=a}};function Tb(a,b,c,d,e,f,g,h,k){Ob=!1;Pb=null;Nb.apply(Sb,arguments)}\nfunction Ub(a,b,c,d,e,f,g,h,k){Tb.apply(this,arguments);if(Ob){if(Ob){var l=Pb;Ob=!1;Pb=null}else throw Error(p(198));Qb||(Qb=!0,Rb=l)}}function Vb(a){var b=a,c=a;if(a.alternate)for(;b.return;)b=b.return;else{a=b;do b=a,0!==(b.flags&4098)&&(c=b.return),a=b.return;while(a)}return 3===b.tag?c:null}function Wb(a){if(13===a.tag){var b=a.memoizedState;null===b&&(a=a.alternate,null!==a&&(b=a.memoizedState));if(null!==b)return b.dehydrated}return null}function Xb(a){if(Vb(a)!==a)throw Error(p(188));}\nfunction Yb(a){var b=a.alternate;if(!b){b=Vb(a);if(null===b)throw Error(p(188));return b!==a?null:a}for(var c=a,d=b;;){var e=c.return;if(null===e)break;var f=e.alternate;if(null===f){d=e.return;if(null!==d){c=d;continue}break}if(e.child===f.child){for(f=e.child;f;){if(f===c)return Xb(e),a;if(f===d)return Xb(e),b;f=f.sibling}throw Error(p(188));}if(c.return!==d.return)c=e,d=f;else{for(var g=!1,h=e.child;h;){if(h===c){g=!0;c=e;d=f;break}if(h===d){g=!0;d=e;c=f;break}h=h.sibling}if(!g){for(h=f.child;h;){if(h===\nc){g=!0;c=f;d=e;break}if(h===d){g=!0;d=f;c=e;break}h=h.sibling}if(!g)throw Error(p(189));}}if(c.alternate!==d)throw Error(p(190));}if(3!==c.tag)throw Error(p(188));return c.stateNode.current===c?a:b}function Zb(a){a=Yb(a);return null!==a?$b(a):null}function $b(a){if(5===a.tag||6===a.tag)return a;for(a=a.child;null!==a;){var b=$b(a);if(null!==b)return b;a=a.sibling}return null}\nvar ac=ca.unstable_scheduleCallback,bc=ca.unstable_cancelCallback,cc=ca.unstable_shouldYield,dc=ca.unstable_requestPaint,B=ca.unstable_now,ec=ca.unstable_getCurrentPriorityLevel,fc=ca.unstable_ImmediatePriority,gc=ca.unstable_UserBlockingPriority,hc=ca.unstable_NormalPriority,ic=ca.unstable_LowPriority,jc=ca.unstable_IdlePriority,kc=null,lc=null;function mc(a){if(lc&&\"function\"===typeof lc.onCommitFiberRoot)try{lc.onCommitFiberRoot(kc,a,void 0,128===(a.current.flags&128))}catch(b){}}\nvar oc=Math.clz32?Math.clz32:nc,pc=Math.log,qc=Math.LN2;function nc(a){a>>>=0;return 0===a?32:31-(pc(a)/qc|0)|0}var rc=64,sc=4194304;\nfunction tc(a){switch(a&-a){case 1:return 1;case 2:return 2;case 4:return 4;case 8:return 8;case 16:return 16;case 32:return 32;case 64:case 128:case 256:case 512:case 1024:case 2048:case 4096:case 8192:case 16384:case 32768:case 65536:case 131072:case 262144:case 524288:case 1048576:case 2097152:return a&4194240;case 4194304:case 8388608:case 16777216:case 33554432:case 67108864:return a&130023424;case 134217728:return 134217728;case 268435456:return 268435456;case 536870912:return 536870912;case 1073741824:return 1073741824;\ndefault:return a}}function uc(a,b){var c=a.pendingLanes;if(0===c)return 0;var d=0,e=a.suspendedLanes,f=a.pingedLanes,g=c&268435455;if(0!==g){var h=g&~e;0!==h?d=tc(h):(f&=g,0!==f&&(d=tc(f)))}else g=c&~e,0!==g?d=tc(g):0!==f&&(d=tc(f));if(0===d)return 0;if(0!==b&&b!==d&&0===(b&e)&&(e=d&-d,f=b&-b,e>=f||16===e&&0!==(f&4194240)))return b;0!==(d&4)&&(d|=c&16);b=a.entangledLanes;if(0!==b)for(a=a.entanglements,b&=d;0<b;)c=31-oc(b),e=1<<c,d|=a[c],b&=~e;return d}\nfunction vc(a,b){switch(a){case 1:case 2:case 4:return b+250;case 8:case 16:case 32:case 64:case 128:case 256:case 512:case 1024:case 2048:case 4096:case 8192:case 16384:case 32768:case 65536:case 131072:case 262144:case 524288:case 1048576:case 2097152:return b+5E3;case 4194304:case 8388608:case 16777216:case 33554432:case 67108864:return-1;case 134217728:case 268435456:case 536870912:case 1073741824:return-1;default:return-1}}\nfunction wc(a,b){for(var c=a.suspendedLanes,d=a.pingedLanes,e=a.expirationTimes,f=a.pendingLanes;0<f;){var g=31-oc(f),h=1<<g,k=e[g];if(-1===k){if(0===(h&c)||0!==(h&d))e[g]=vc(h,b)}else k<=b&&(a.expiredLanes|=h);f&=~h}}function xc(a){a=a.pendingLanes&-1073741825;return 0!==a?a:a&1073741824?1073741824:0}function yc(){var a=rc;rc<<=1;0===(rc&4194240)&&(rc=64);return a}function zc(a){for(var b=[],c=0;31>c;c++)b.push(a);return b}\nfunction Ac(a,b,c){a.pendingLanes|=b;536870912!==b&&(a.suspendedLanes=0,a.pingedLanes=0);a=a.eventTimes;b=31-oc(b);a[b]=c}function Bc(a,b){var c=a.pendingLanes&~b;a.pendingLanes=b;a.suspendedLanes=0;a.pingedLanes=0;a.expiredLanes&=b;a.mutableReadLanes&=b;a.entangledLanes&=b;b=a.entanglements;var d=a.eventTimes;for(a=a.expirationTimes;0<c;){var e=31-oc(c),f=1<<e;b[e]=0;d[e]=-1;a[e]=-1;c&=~f}}\nfunction Cc(a,b){var c=a.entangledLanes|=b;for(a=a.entanglements;c;){var d=31-oc(c),e=1<<d;e&b|a[d]&b&&(a[d]|=b);c&=~e}}var C=0;function Dc(a){a&=-a;return 1<a?4<a?0!==(a&268435455)?16:536870912:4:1}var Ec,Fc,Gc,Hc,Ic,Jc=!1,Kc=[],Lc=null,Mc=null,Nc=null,Oc=new Map,Pc=new Map,Qc=[],Rc=\"mousedown mouseup touchcancel touchend touchstart auxclick dblclick pointercancel pointerdown pointerup dragend dragstart drop compositionend compositionstart keydown keypress keyup input textInput copy cut paste click change contextmenu reset submit\".split(\" \");\nfunction Sc(a,b){switch(a){case \"focusin\":case \"focusout\":Lc=null;break;case \"dragenter\":case \"dragleave\":Mc=null;break;case \"mouseover\":case \"mouseout\":Nc=null;break;case \"pointerover\":case \"pointerout\":Oc.delete(b.pointerId);break;case \"gotpointercapture\":case \"lostpointercapture\":Pc.delete(b.pointerId)}}\nfunction Tc(a,b,c,d,e,f){if(null===a||a.nativeEvent!==f)return a={blockedOn:b,domEventName:c,eventSystemFlags:d,nativeEvent:f,targetContainers:[e]},null!==b&&(b=Cb(b),null!==b&&Fc(b)),a;a.eventSystemFlags|=d;b=a.targetContainers;null!==e&&-1===b.indexOf(e)&&b.push(e);return a}\nfunction Uc(a,b,c,d,e){switch(b){case \"focusin\":return Lc=Tc(Lc,a,b,c,d,e),!0;case \"dragenter\":return Mc=Tc(Mc,a,b,c,d,e),!0;case \"mouseover\":return Nc=Tc(Nc,a,b,c,d,e),!0;case \"pointerover\":var f=e.pointerId;Oc.set(f,Tc(Oc.get(f)||null,a,b,c,d,e));return!0;case \"gotpointercapture\":return f=e.pointerId,Pc.set(f,Tc(Pc.get(f)||null,a,b,c,d,e)),!0}return!1}\nfunction Vc(a){var b=Wc(a.target);if(null!==b){var c=Vb(b);if(null!==c)if(b=c.tag,13===b){if(b=Wb(c),null!==b){a.blockedOn=b;Ic(a.priority,function(){Gc(c)});return}}else if(3===b&&c.stateNode.current.memoizedState.isDehydrated){a.blockedOn=3===c.tag?c.stateNode.containerInfo:null;return}}a.blockedOn=null}\nfunction Xc(a){if(null!==a.blockedOn)return!1;for(var b=a.targetContainers;0<b.length;){var c=Yc(a.domEventName,a.eventSystemFlags,b[0],a.nativeEvent);if(null===c){c=a.nativeEvent;var d=new c.constructor(c.type,c);wb=d;c.target.dispatchEvent(d);wb=null}else return b=Cb(c),null!==b&&Fc(b),a.blockedOn=c,!1;b.shift()}return!0}function Zc(a,b,c){Xc(a)&&c.delete(b)}function $c(){Jc=!1;null!==Lc&&Xc(Lc)&&(Lc=null);null!==Mc&&Xc(Mc)&&(Mc=null);null!==Nc&&Xc(Nc)&&(Nc=null);Oc.forEach(Zc);Pc.forEach(Zc)}\nfunction ad(a,b){a.blockedOn===b&&(a.blockedOn=null,Jc||(Jc=!0,ca.unstable_scheduleCallback(ca.unstable_NormalPriority,$c)))}\nfunction bd(a){function b(b){return ad(b,a)}if(0<Kc.length){ad(Kc[0],a);for(var c=1;c<Kc.length;c++){var d=Kc[c];d.blockedOn===a&&(d.blockedOn=null)}}null!==Lc&&ad(Lc,a);null!==Mc&&ad(Mc,a);null!==Nc&&ad(Nc,a);Oc.forEach(b);Pc.forEach(b);for(c=0;c<Qc.length;c++)d=Qc[c],d.blockedOn===a&&(d.blockedOn=null);for(;0<Qc.length&&(c=Qc[0],null===c.blockedOn);)Vc(c),null===c.blockedOn&&Qc.shift()}var cd=ua.ReactCurrentBatchConfig,dd=!0;\nfunction ed(a,b,c,d){var e=C,f=cd.transition;cd.transition=null;try{C=1,fd(a,b,c,d)}finally{C=e,cd.transition=f}}function gd(a,b,c,d){var e=C,f=cd.transition;cd.transition=null;try{C=4,fd(a,b,c,d)}finally{C=e,cd.transition=f}}\nfunction fd(a,b,c,d){if(dd){var e=Yc(a,b,c,d);if(null===e)hd(a,b,d,id,c),Sc(a,d);else if(Uc(e,a,b,c,d))d.stopPropagation();else if(Sc(a,d),b&4&&-1<Rc.indexOf(a)){for(;null!==e;){var f=Cb(e);null!==f&&Ec(f);f=Yc(a,b,c,d);null===f&&hd(a,b,d,id,c);if(f===e)break;e=f}null!==e&&d.stopPropagation()}else hd(a,b,d,null,c)}}var id=null;\nfunction Yc(a,b,c,d){id=null;a=xb(d);a=Wc(a);if(null!==a)if(b=Vb(a),null===b)a=null;else if(c=b.tag,13===c){a=Wb(b);if(null!==a)return a;a=null}else if(3===c){if(b.stateNode.current.memoizedState.isDehydrated)return 3===b.tag?b.stateNode.containerInfo:null;a=null}else b!==a&&(a=null);id=a;return null}\nfunction jd(a){switch(a){case \"cancel\":case \"click\":case \"close\":case \"contextmenu\":case \"copy\":case \"cut\":case \"auxclick\":case \"dblclick\":case \"dragend\":case \"dragstart\":case \"drop\":case \"focusin\":case \"focusout\":case \"input\":case \"invalid\":case \"keydown\":case \"keypress\":case \"keyup\":case \"mousedown\":case \"mouseup\":case \"paste\":case \"pause\":case \"play\":case \"pointercancel\":case \"pointerdown\":case \"pointerup\":case \"ratechange\":case \"reset\":case \"resize\":case \"seeked\":case \"submit\":case \"touchcancel\":case \"touchend\":case \"touchstart\":case \"volumechange\":case \"change\":case \"selectionchange\":case \"textInput\":case \"compositionstart\":case \"compositionend\":case \"compositionupdate\":case \"beforeblur\":case \"afterblur\":case \"beforeinput\":case \"blur\":case \"fullscreenchange\":case \"focus\":case \"hashchange\":case \"popstate\":case \"select\":case \"selectstart\":return 1;case \"drag\":case \"dragenter\":case \"dragexit\":case \"dragleave\":case \"dragover\":case \"mousemove\":case \"mouseout\":case \"mouseover\":case \"pointermove\":case \"pointerout\":case \"pointerover\":case \"scroll\":case \"toggle\":case \"touchmove\":case \"wheel\":case \"mouseenter\":case \"mouseleave\":case \"pointerenter\":case \"pointerleave\":return 4;\ncase \"message\":switch(ec()){case fc:return 1;case gc:return 4;case hc:case ic:return 16;case jc:return 536870912;default:return 16}default:return 16}}var kd=null,ld=null,md=null;function nd(){if(md)return md;var a,b=ld,c=b.length,d,e=\"value\"in kd?kd.value:kd.textContent,f=e.length;for(a=0;a<c&&b[a]===e[a];a++);var g=c-a;for(d=1;d<=g&&b[c-d]===e[f-d];d++);return md=e.slice(a,1<d?1-d:void 0)}\nfunction od(a){var b=a.keyCode;\"charCode\"in a?(a=a.charCode,0===a&&13===b&&(a=13)):a=b;10===a&&(a=13);return 32<=a||13===a?a:0}function pd(){return!0}function qd(){return!1}\nfunction rd(a){function b(b,d,e,f,g){this._reactName=b;this._targetInst=e;this.type=d;this.nativeEvent=f;this.target=g;this.currentTarget=null;for(var c in a)a.hasOwnProperty(c)&&(b=a[c],this[c]=b?b(f):f[c]);this.isDefaultPrevented=(null!=f.defaultPrevented?f.defaultPrevented:!1===f.returnValue)?pd:qd;this.isPropagationStopped=qd;return this}A(b.prototype,{preventDefault:function(){this.defaultPrevented=!0;var a=this.nativeEvent;a&&(a.preventDefault?a.preventDefault():\"unknown\"!==typeof a.returnValue&&\n(a.returnValue=!1),this.isDefaultPrevented=pd)},stopPropagation:function(){var a=this.nativeEvent;a&&(a.stopPropagation?a.stopPropagation():\"unknown\"!==typeof a.cancelBubble&&(a.cancelBubble=!0),this.isPropagationStopped=pd)},persist:function(){},isPersistent:pd});return b}\nvar sd={eventPhase:0,bubbles:0,cancelable:0,timeStamp:function(a){return a.timeStamp||Date.now()},defaultPrevented:0,isTrusted:0},td=rd(sd),ud=A({},sd,{view:0,detail:0}),vd=rd(ud),wd,xd,yd,Ad=A({},ud,{screenX:0,screenY:0,clientX:0,clientY:0,pageX:0,pageY:0,ctrlKey:0,shiftKey:0,altKey:0,metaKey:0,getModifierState:zd,button:0,buttons:0,relatedTarget:function(a){return void 0===a.relatedTarget?a.fromElement===a.srcElement?a.toElement:a.fromElement:a.relatedTarget},movementX:function(a){if(\"movementX\"in\na)return a.movementX;a!==yd&&(yd&&\"mousemove\"===a.type?(wd=a.screenX-yd.screenX,xd=a.screenY-yd.screenY):xd=wd=0,yd=a);return wd},movementY:function(a){return\"movementY\"in a?a.movementY:xd}}),Bd=rd(Ad),Cd=A({},Ad,{dataTransfer:0}),Dd=rd(Cd),Ed=A({},ud,{relatedTarget:0}),Fd=rd(Ed),Gd=A({},sd,{animationName:0,elapsedTime:0,pseudoElement:0}),Hd=rd(Gd),Id=A({},sd,{clipboardData:function(a){return\"clipboardData\"in a?a.clipboardData:window.clipboardData}}),Jd=rd(Id),Kd=A({},sd,{data:0}),Ld=rd(Kd),Md={Esc:\"Escape\",\nSpacebar:\" \",Left:\"ArrowLeft\",Up:\"ArrowUp\",Right:\"ArrowRight\",Down:\"ArrowDown\",Del:\"Delete\",Win:\"OS\",Menu:\"ContextMenu\",Apps:\"ContextMenu\",Scroll:\"ScrollLock\",MozPrintableKey:\"Unidentified\"},Nd={8:\"Backspace\",9:\"Tab\",12:\"Clear\",13:\"Enter\",16:\"Shift\",17:\"Control\",18:\"Alt\",19:\"Pause\",20:\"CapsLock\",27:\"Escape\",32:\" \",33:\"PageUp\",34:\"PageDown\",35:\"End\",36:\"Home\",37:\"ArrowLeft\",38:\"ArrowUp\",39:\"ArrowRight\",40:\"ArrowDown\",45:\"Insert\",46:\"Delete\",112:\"F1\",113:\"F2\",114:\"F3\",115:\"F4\",116:\"F5\",117:\"F6\",118:\"F7\",\n119:\"F8\",120:\"F9\",121:\"F10\",122:\"F11\",123:\"F12\",144:\"NumLock\",145:\"ScrollLock\",224:\"Meta\"},Od={Alt:\"altKey\",Control:\"ctrlKey\",Meta:\"metaKey\",Shift:\"shiftKey\"};function Pd(a){var b=this.nativeEvent;return b.getModifierState?b.getModifierState(a):(a=Od[a])?!!b[a]:!1}function zd(){return Pd}\nvar Qd=A({},ud,{key:function(a){if(a.key){var b=Md[a.key]||a.key;if(\"Unidentified\"!==b)return b}return\"keypress\"===a.type?(a=od(a),13===a?\"Enter\":String.fromCharCode(a)):\"keydown\"===a.type||\"keyup\"===a.type?Nd[a.keyCode]||\"Unidentified\":\"\"},code:0,location:0,ctrlKey:0,shiftKey:0,altKey:0,metaKey:0,repeat:0,locale:0,getModifierState:zd,charCode:function(a){return\"keypress\"===a.type?od(a):0},keyCode:function(a){return\"keydown\"===a.type||\"keyup\"===a.type?a.keyCode:0},which:function(a){return\"keypress\"===\na.type?od(a):\"keydown\"===a.type||\"keyup\"===a.type?a.keyCode:0}}),Rd=rd(Qd),Sd=A({},Ad,{pointerId:0,width:0,height:0,pressure:0,tangentialPressure:0,tiltX:0,tiltY:0,twist:0,pointerType:0,isPrimary:0}),Td=rd(Sd),Ud=A({},ud,{touches:0,targetTouches:0,changedTouches:0,altKey:0,metaKey:0,ctrlKey:0,shiftKey:0,getModifierState:zd}),Vd=rd(Ud),Wd=A({},sd,{propertyName:0,elapsedTime:0,pseudoElement:0}),Xd=rd(Wd),Yd=A({},Ad,{deltaX:function(a){return\"deltaX\"in a?a.deltaX:\"wheelDeltaX\"in a?-a.wheelDeltaX:0},\ndeltaY:function(a){return\"deltaY\"in a?a.deltaY:\"wheelDeltaY\"in a?-a.wheelDeltaY:\"wheelDelta\"in a?-a.wheelDelta:0},deltaZ:0,deltaMode:0}),Zd=rd(Yd),$d=[9,13,27,32],ae=ia&&\"CompositionEvent\"in window,be=null;ia&&\"documentMode\"in document&&(be=document.documentMode);var ce=ia&&\"TextEvent\"in window&&!be,de=ia&&(!ae||be&&8<be&&11>=be),ee=String.fromCharCode(32),fe=!1;\nfunction ge(a,b){switch(a){case \"keyup\":return-1!==$d.indexOf(b.keyCode);case \"keydown\":return 229!==b.keyCode;case \"keypress\":case \"mousedown\":case \"focusout\":return!0;default:return!1}}function he(a){a=a.detail;return\"object\"===typeof a&&\"data\"in a?a.data:null}var ie=!1;function je(a,b){switch(a){case \"compositionend\":return he(b);case \"keypress\":if(32!==b.which)return null;fe=!0;return ee;case \"textInput\":return a=b.data,a===ee&&fe?null:a;default:return null}}\nfunction ke(a,b){if(ie)return\"compositionend\"===a||!ae&&ge(a,b)?(a=nd(),md=ld=kd=null,ie=!1,a):null;switch(a){case \"paste\":return null;case \"keypress\":if(!(b.ctrlKey||b.altKey||b.metaKey)||b.ctrlKey&&b.altKey){if(b.char&&1<b.char.length)return b.char;if(b.which)return String.fromCharCode(b.which)}return null;case \"compositionend\":return de&&\"ko\"!==b.locale?null:b.data;default:return null}}\nvar le={color:!0,date:!0,datetime:!0,\"datetime-local\":!0,email:!0,month:!0,number:!0,password:!0,range:!0,search:!0,tel:!0,text:!0,time:!0,url:!0,week:!0};function me(a){var b=a&&a.nodeName&&a.nodeName.toLowerCase();return\"input\"===b?!!le[a.type]:\"textarea\"===b?!0:!1}function ne(a,b,c,d){Eb(d);b=oe(b,\"onChange\");0<b.length&&(c=new td(\"onChange\",\"change\",null,c,d),a.push({event:c,listeners:b}))}var pe=null,qe=null;function re(a){se(a,0)}function te(a){var b=ue(a);if(Wa(b))return a}\nfunction ve(a,b){if(\"change\"===a)return b}var we=!1;if(ia){var xe;if(ia){var ye=\"oninput\"in document;if(!ye){var ze=document.createElement(\"div\");ze.setAttribute(\"oninput\",\"return;\");ye=\"function\"===typeof ze.oninput}xe=ye}else xe=!1;we=xe&&(!document.documentMode||9<document.documentMode)}function Ae(){pe&&(pe.detachEvent(\"onpropertychange\",Be),qe=pe=null)}function Be(a){if(\"value\"===a.propertyName&&te(qe)){var b=[];ne(b,qe,a,xb(a));Jb(re,b)}}\nfunction Ce(a,b,c){\"focusin\"===a?(Ae(),pe=b,qe=c,pe.attachEvent(\"onpropertychange\",Be)):\"focusout\"===a&&Ae()}function De(a){if(\"selectionchange\"===a||\"keyup\"===a||\"keydown\"===a)return te(qe)}function Ee(a,b){if(\"click\"===a)return te(b)}function Fe(a,b){if(\"input\"===a||\"change\"===a)return te(b)}function Ge(a,b){return a===b&&(0!==a||1/a===1/b)||a!==a&&b!==b}var He=\"function\"===typeof Object.is?Object.is:Ge;\nfunction Ie(a,b){if(He(a,b))return!0;if(\"object\"!==typeof a||null===a||\"object\"!==typeof b||null===b)return!1;var c=Object.keys(a),d=Object.keys(b);if(c.length!==d.length)return!1;for(d=0;d<c.length;d++){var e=c[d];if(!ja.call(b,e)||!He(a[e],b[e]))return!1}return!0}function Je(a){for(;a&&a.firstChild;)a=a.firstChild;return a}\nfunction Ke(a,b){var c=Je(a);a=0;for(var d;c;){if(3===c.nodeType){d=a+c.textContent.length;if(a<=b&&d>=b)return{node:c,offset:b-a};a=d}a:{for(;c;){if(c.nextSibling){c=c.nextSibling;break a}c=c.parentNode}c=void 0}c=Je(c)}}function Le(a,b){return a&&b?a===b?!0:a&&3===a.nodeType?!1:b&&3===b.nodeType?Le(a,b.parentNode):\"contains\"in a?a.contains(b):a.compareDocumentPosition?!!(a.compareDocumentPosition(b)&16):!1:!1}\nfunction Me(){for(var a=window,b=Xa();b instanceof a.HTMLIFrameElement;){try{var c=\"string\"===typeof b.contentWindow.location.href}catch(d){c=!1}if(c)a=b.contentWindow;else break;b=Xa(a.document)}return b}function Ne(a){var b=a&&a.nodeName&&a.nodeName.toLowerCase();return b&&(\"input\"===b&&(\"text\"===a.type||\"search\"===a.type||\"tel\"===a.type||\"url\"===a.type||\"password\"===a.type)||\"textarea\"===b||\"true\"===a.contentEditable)}\nfunction Oe(a){var b=Me(),c=a.focusedElem,d=a.selectionRange;if(b!==c&&c&&c.ownerDocument&&Le(c.ownerDocument.documentElement,c)){if(null!==d&&Ne(c))if(b=d.start,a=d.end,void 0===a&&(a=b),\"selectionStart\"in c)c.selectionStart=b,c.selectionEnd=Math.min(a,c.value.length);else if(a=(b=c.ownerDocument||document)&&b.defaultView||window,a.getSelection){a=a.getSelection();var e=c.textContent.length,f=Math.min(d.start,e);d=void 0===d.end?f:Math.min(d.end,e);!a.extend&&f>d&&(e=d,d=f,f=e);e=Ke(c,f);var g=Ke(c,\nd);e&&g&&(1!==a.rangeCount||a.anchorNode!==e.node||a.anchorOffset!==e.offset||a.focusNode!==g.node||a.focusOffset!==g.offset)&&(b=b.createRange(),b.setStart(e.node,e.offset),a.removeAllRanges(),f>d?(a.addRange(b),a.extend(g.node,g.offset)):(b.setEnd(g.node,g.offset),a.addRange(b)))}b=[];for(a=c;a=a.parentNode;)1===a.nodeType&&b.push({element:a,left:a.scrollLeft,top:a.scrollTop});\"function\"===typeof c.focus&&c.focus();for(c=0;c<b.length;c++)a=b[c],a.element.scrollLeft=a.left,a.element.scrollTop=a.top}}\nvar Pe=ia&&\"documentMode\"in document&&11>=document.documentMode,Qe=null,Re=null,Se=null,Te=!1;\nfunction Ue(a,b,c){var d=c.window===c?c.document:9===c.nodeType?c:c.ownerDocument;Te||null==Qe||Qe!==Xa(d)||(d=Qe,\"selectionStart\"in d&&Ne(d)?d={start:d.selectionStart,end:d.selectionEnd}:(d=(d.ownerDocument&&d.ownerDocument.defaultView||window).getSelection(),d={anchorNode:d.anchorNode,anchorOffset:d.anchorOffset,focusNode:d.focusNode,focusOffset:d.focusOffset}),Se&&Ie(Se,d)||(Se=d,d=oe(Re,\"onSelect\"),0<d.length&&(b=new td(\"onSelect\",\"select\",null,b,c),a.push({event:b,listeners:d}),b.target=Qe)))}\nfunction Ve(a,b){var c={};c[a.toLowerCase()]=b.toLowerCase();c[\"Webkit\"+a]=\"webkit\"+b;c[\"Moz\"+a]=\"moz\"+b;return c}var We={animationend:Ve(\"Animation\",\"AnimationEnd\"),animationiteration:Ve(\"Animation\",\"AnimationIteration\"),animationstart:Ve(\"Animation\",\"AnimationStart\"),transitionend:Ve(\"Transition\",\"TransitionEnd\")},Xe={},Ye={};\nia&&(Ye=document.createElement(\"div\").style,\"AnimationEvent\"in window||(delete We.animationend.animation,delete We.animationiteration.animation,delete We.animationstart.animation),\"TransitionEvent\"in window||delete We.transitionend.transition);function Ze(a){if(Xe[a])return Xe[a];if(!We[a])return a;var b=We[a],c;for(c in b)if(b.hasOwnProperty(c)&&c in Ye)return Xe[a]=b[c];return a}var $e=Ze(\"animationend\"),af=Ze(\"animationiteration\"),bf=Ze(\"animationstart\"),cf=Ze(\"transitionend\"),df=new Map,ef=\"abort auxClick cancel canPlay canPlayThrough click close contextMenu copy cut drag dragEnd dragEnter dragExit dragLeave dragOver dragStart drop durationChange emptied encrypted ended error gotPointerCapture input invalid keyDown keyPress keyUp load loadedData loadedMetadata loadStart lostPointerCapture mouseDown mouseMove mouseOut mouseOver mouseUp paste pause play playing pointerCancel pointerDown pointerMove pointerOut pointerOver pointerUp progress rateChange reset resize seeked seeking stalled submit suspend timeUpdate touchCancel touchEnd touchStart volumeChange scroll toggle touchMove waiting wheel\".split(\" \");\nfunction ff(a,b){df.set(a,b);fa(b,[a])}for(var gf=0;gf<ef.length;gf++){var hf=ef[gf],jf=hf.toLowerCase(),kf=hf[0].toUpperCase()+hf.slice(1);ff(jf,\"on\"+kf)}ff($e,\"onAnimationEnd\");ff(af,\"onAnimationIteration\");ff(bf,\"onAnimationStart\");ff(\"dblclick\",\"onDoubleClick\");ff(\"focusin\",\"onFocus\");ff(\"focusout\",\"onBlur\");ff(cf,\"onTransitionEnd\");ha(\"onMouseEnter\",[\"mouseout\",\"mouseover\"]);ha(\"onMouseLeave\",[\"mouseout\",\"mouseover\"]);ha(\"onPointerEnter\",[\"pointerout\",\"pointerover\"]);\nha(\"onPointerLeave\",[\"pointerout\",\"pointerover\"]);fa(\"onChange\",\"change click focusin focusout input keydown keyup selectionchange\".split(\" \"));fa(\"onSelect\",\"focusout contextmenu dragend focusin keydown keyup mousedown mouseup selectionchange\".split(\" \"));fa(\"onBeforeInput\",[\"compositionend\",\"keypress\",\"textInput\",\"paste\"]);fa(\"onCompositionEnd\",\"compositionend focusout keydown keypress keyup mousedown\".split(\" \"));fa(\"onCompositionStart\",\"compositionstart focusout keydown keypress keyup mousedown\".split(\" \"));\nfa(\"onCompositionUpdate\",\"compositionupdate focusout keydown keypress keyup mousedown\".split(\" \"));var lf=\"abort canplay canplaythrough durationchange emptied encrypted ended error loadeddata loadedmetadata loadstart pause play playing progress ratechange resize seeked seeking stalled suspend timeupdate volumechange waiting\".split(\" \"),mf=new Set(\"cancel close invalid load scroll toggle\".split(\" \").concat(lf));\nfunction nf(a,b,c){var d=a.type||\"unknown-event\";a.currentTarget=c;Ub(d,b,void 0,a);a.currentTarget=null}\nfunction se(a,b){b=0!==(b&4);for(var c=0;c<a.length;c++){var d=a[c],e=d.event;d=d.listeners;a:{var f=void 0;if(b)for(var g=d.length-1;0<=g;g--){var h=d[g],k=h.instance,l=h.currentTarget;h=h.listener;if(k!==f&&e.isPropagationStopped())break a;nf(e,h,l);f=k}else for(g=0;g<d.length;g++){h=d[g];k=h.instance;l=h.currentTarget;h=h.listener;if(k!==f&&e.isPropagationStopped())break a;nf(e,h,l);f=k}}}if(Qb)throw a=Rb,Qb=!1,Rb=null,a;}\nfunction D(a,b){var c=b[of];void 0===c&&(c=b[of]=new Set);var d=a+\"__bubble\";c.has(d)||(pf(b,a,2,!1),c.add(d))}function qf(a,b,c){var d=0;b&&(d|=4);pf(c,a,d,b)}var rf=\"_reactListening\"+Math.random().toString(36).slice(2);function sf(a){if(!a[rf]){a[rf]=!0;da.forEach(function(b){\"selectionchange\"!==b&&(mf.has(b)||qf(b,!1,a),qf(b,!0,a))});var b=9===a.nodeType?a:a.ownerDocument;null===b||b[rf]||(b[rf]=!0,qf(\"selectionchange\",!1,b))}}\nfunction pf(a,b,c,d){switch(jd(b)){case 1:var e=ed;break;case 4:e=gd;break;default:e=fd}c=e.bind(null,b,c,a);e=void 0;!Lb||\"touchstart\"!==b&&\"touchmove\"!==b&&\"wheel\"!==b||(e=!0);d?void 0!==e?a.addEventListener(b,c,{capture:!0,passive:e}):a.addEventListener(b,c,!0):void 0!==e?a.addEventListener(b,c,{passive:e}):a.addEventListener(b,c,!1)}\nfunction hd(a,b,c,d,e){var f=d;if(0===(b&1)&&0===(b&2)&&null!==d)a:for(;;){if(null===d)return;var g=d.tag;if(3===g||4===g){var h=d.stateNode.containerInfo;if(h===e||8===h.nodeType&&h.parentNode===e)break;if(4===g)for(g=d.return;null!==g;){var k=g.tag;if(3===k||4===k)if(k=g.stateNode.containerInfo,k===e||8===k.nodeType&&k.parentNode===e)return;g=g.return}for(;null!==h;){g=Wc(h);if(null===g)return;k=g.tag;if(5===k||6===k){d=f=g;continue a}h=h.parentNode}}d=d.return}Jb(function(){var d=f,e=xb(c),g=[];\na:{var h=df.get(a);if(void 0!==h){var k=td,n=a;switch(a){case \"keypress\":if(0===od(c))break a;case \"keydown\":case \"keyup\":k=Rd;break;case \"focusin\":n=\"focus\";k=Fd;break;case \"focusout\":n=\"blur\";k=Fd;break;case \"beforeblur\":case \"afterblur\":k=Fd;break;case \"click\":if(2===c.button)break a;case \"auxclick\":case \"dblclick\":case \"mousedown\":case \"mousemove\":case \"mouseup\":case \"mouseout\":case \"mouseover\":case \"contextmenu\":k=Bd;break;case \"drag\":case \"dragend\":case \"dragenter\":case \"dragexit\":case \"dragleave\":case \"dragover\":case \"dragstart\":case \"drop\":k=\nDd;break;case \"touchcancel\":case \"touchend\":case \"touchmove\":case \"touchstart\":k=Vd;break;case $e:case af:case bf:k=Hd;break;case cf:k=Xd;break;case \"scroll\":k=vd;break;case \"wheel\":k=Zd;break;case \"copy\":case \"cut\":case \"paste\":k=Jd;break;case \"gotpointercapture\":case \"lostpointercapture\":case \"pointercancel\":case \"pointerdown\":case \"pointermove\":case \"pointerout\":case \"pointerover\":case \"pointerup\":k=Td}var t=0!==(b&4),J=!t&&\"scroll\"===a,x=t?null!==h?h+\"Capture\":null:h;t=[];for(var w=d,u;null!==\nw;){u=w;var F=u.stateNode;5===u.tag&&null!==F&&(u=F,null!==x&&(F=Kb(w,x),null!=F&&t.push(tf(w,F,u))));if(J)break;w=w.return}0<t.length&&(h=new k(h,n,null,c,e),g.push({event:h,listeners:t}))}}if(0===(b&7)){a:{h=\"mouseover\"===a||\"pointerover\"===a;k=\"mouseout\"===a||\"pointerout\"===a;if(h&&c!==wb&&(n=c.relatedTarget||c.fromElement)&&(Wc(n)||n[uf]))break a;if(k||h){h=e.window===e?e:(h=e.ownerDocument)?h.defaultView||h.parentWindow:window;if(k){if(n=c.relatedTarget||c.toElement,k=d,n=n?Wc(n):null,null!==\nn&&(J=Vb(n),n!==J||5!==n.tag&&6!==n.tag))n=null}else k=null,n=d;if(k!==n){t=Bd;F=\"onMouseLeave\";x=\"onMouseEnter\";w=\"mouse\";if(\"pointerout\"===a||\"pointerover\"===a)t=Td,F=\"onPointerLeave\",x=\"onPointerEnter\",w=\"pointer\";J=null==k?h:ue(k);u=null==n?h:ue(n);h=new t(F,w+\"leave\",k,c,e);h.target=J;h.relatedTarget=u;F=null;Wc(e)===d&&(t=new t(x,w+\"enter\",n,c,e),t.target=u,t.relatedTarget=J,F=t);J=F;if(k&&n)b:{t=k;x=n;w=0;for(u=t;u;u=vf(u))w++;u=0;for(F=x;F;F=vf(F))u++;for(;0<w-u;)t=vf(t),w--;for(;0<u-w;)x=\nvf(x),u--;for(;w--;){if(t===x||null!==x&&t===x.alternate)break b;t=vf(t);x=vf(x)}t=null}else t=null;null!==k&&wf(g,h,k,t,!1);null!==n&&null!==J&&wf(g,J,n,t,!0)}}}a:{h=d?ue(d):window;k=h.nodeName&&h.nodeName.toLowerCase();if(\"select\"===k||\"input\"===k&&\"file\"===h.type)var na=ve;else if(me(h))if(we)na=Fe;else{na=De;var xa=Ce}else(k=h.nodeName)&&\"input\"===k.toLowerCase()&&(\"checkbox\"===h.type||\"radio\"===h.type)&&(na=Ee);if(na&&(na=na(a,d))){ne(g,na,c,e);break a}xa&&xa(a,h,d);\"focusout\"===a&&(xa=h._wrapperState)&&\nxa.controlled&&\"number\"===h.type&&cb(h,\"number\",h.value)}xa=d?ue(d):window;switch(a){case \"focusin\":if(me(xa)||\"true\"===xa.contentEditable)Qe=xa,Re=d,Se=null;break;case \"focusout\":Se=Re=Qe=null;break;case \"mousedown\":Te=!0;break;case \"contextmenu\":case \"mouseup\":case \"dragend\":Te=!1;Ue(g,c,e);break;case \"selectionchange\":if(Pe)break;case \"keydown\":case \"keyup\":Ue(g,c,e)}var $a;if(ae)b:{switch(a){case \"compositionstart\":var ba=\"onCompositionStart\";break b;case \"compositionend\":ba=\"onCompositionEnd\";\nbreak b;case \"compositionupdate\":ba=\"onCompositionUpdate\";break b}ba=void 0}else ie?ge(a,c)&&(ba=\"onCompositionEnd\"):\"keydown\"===a&&229===c.keyCode&&(ba=\"onCompositionStart\");ba&&(de&&\"ko\"!==c.locale&&(ie||\"onCompositionStart\"!==ba?\"onCompositionEnd\"===ba&&ie&&($a=nd()):(kd=e,ld=\"value\"in kd?kd.value:kd.textContent,ie=!0)),xa=oe(d,ba),0<xa.length&&(ba=new Ld(ba,a,null,c,e),g.push({event:ba,listeners:xa}),$a?ba.data=$a:($a=he(c),null!==$a&&(ba.data=$a))));if($a=ce?je(a,c):ke(a,c))d=oe(d,\"onBeforeInput\"),\n0<d.length&&(e=new Ld(\"onBeforeInput\",\"beforeinput\",null,c,e),g.push({event:e,listeners:d}),e.data=$a)}se(g,b)})}function tf(a,b,c){return{instance:a,listener:b,currentTarget:c}}function oe(a,b){for(var c=b+\"Capture\",d=[];null!==a;){var e=a,f=e.stateNode;5===e.tag&&null!==f&&(e=f,f=Kb(a,c),null!=f&&d.unshift(tf(a,f,e)),f=Kb(a,b),null!=f&&d.push(tf(a,f,e)));a=a.return}return d}function vf(a){if(null===a)return null;do a=a.return;while(a&&5!==a.tag);return a?a:null}\nfunction wf(a,b,c,d,e){for(var f=b._reactName,g=[];null!==c&&c!==d;){var h=c,k=h.alternate,l=h.stateNode;if(null!==k&&k===d)break;5===h.tag&&null!==l&&(h=l,e?(k=Kb(c,f),null!=k&&g.unshift(tf(c,k,h))):e||(k=Kb(c,f),null!=k&&g.push(tf(c,k,h))));c=c.return}0!==g.length&&a.push({event:b,listeners:g})}var xf=/\\r\\n?/g,yf=/\\u0000|\\uFFFD/g;function zf(a){return(\"string\"===typeof a?a:\"\"+a).replace(xf,\"\\n\").replace(yf,\"\")}function Af(a,b,c){b=zf(b);if(zf(a)!==b&&c)throw Error(p(425));}function Bf(){}\nvar Cf=null,Df=null;function Ef(a,b){return\"textarea\"===a||\"noscript\"===a||\"string\"===typeof b.children||\"number\"===typeof b.children||\"object\"===typeof b.dangerouslySetInnerHTML&&null!==b.dangerouslySetInnerHTML&&null!=b.dangerouslySetInnerHTML.__html}\nvar Ff=\"function\"===typeof setTimeout?setTimeout:void 0,Gf=\"function\"===typeof clearTimeout?clearTimeout:void 0,Hf=\"function\"===typeof Promise?Promise:void 0,Jf=\"function\"===typeof queueMicrotask?queueMicrotask:\"undefined\"!==typeof Hf?function(a){return Hf.resolve(null).then(a).catch(If)}:Ff;function If(a){setTimeout(function(){throw a;})}\nfunction Kf(a,b){var c=b,d=0;do{var e=c.nextSibling;a.removeChild(c);if(e&&8===e.nodeType)if(c=e.data,\"/$\"===c){if(0===d){a.removeChild(e);bd(b);return}d--}else\"$\"!==c&&\"$?\"!==c&&\"$!\"!==c||d++;c=e}while(c);bd(b)}function Lf(a){for(;null!=a;a=a.nextSibling){var b=a.nodeType;if(1===b||3===b)break;if(8===b){b=a.data;if(\"$\"===b||\"$!\"===b||\"$?\"===b)break;if(\"/$\"===b)return null}}return a}\nfunction Mf(a){a=a.previousSibling;for(var b=0;a;){if(8===a.nodeType){var c=a.data;if(\"$\"===c||\"$!\"===c||\"$?\"===c){if(0===b)return a;b--}else\"/$\"===c&&b++}a=a.previousSibling}return null}var Nf=Math.random().toString(36).slice(2),Of=\"__reactFiber$\"+Nf,Pf=\"__reactProps$\"+Nf,uf=\"__reactContainer$\"+Nf,of=\"__reactEvents$\"+Nf,Qf=\"__reactListeners$\"+Nf,Rf=\"__reactHandles$\"+Nf;\nfunction Wc(a){var b=a[Of];if(b)return b;for(var c=a.parentNode;c;){if(b=c[uf]||c[Of]){c=b.alternate;if(null!==b.child||null!==c&&null!==c.child)for(a=Mf(a);null!==a;){if(c=a[Of])return c;a=Mf(a)}return b}a=c;c=a.parentNode}return null}function Cb(a){a=a[Of]||a[uf];return!a||5!==a.tag&&6!==a.tag&&13!==a.tag&&3!==a.tag?null:a}function ue(a){if(5===a.tag||6===a.tag)return a.stateNode;throw Error(p(33));}function Db(a){return a[Pf]||null}var Sf=[],Tf=-1;function Uf(a){return{current:a}}\nfunction E(a){0>Tf||(a.current=Sf[Tf],Sf[Tf]=null,Tf--)}function G(a,b){Tf++;Sf[Tf]=a.current;a.current=b}var Vf={},H=Uf(Vf),Wf=Uf(!1),Xf=Vf;function Yf(a,b){var c=a.type.contextTypes;if(!c)return Vf;var d=a.stateNode;if(d&&d.__reactInternalMemoizedUnmaskedChildContext===b)return d.__reactInternalMemoizedMaskedChildContext;var e={},f;for(f in c)e[f]=b[f];d&&(a=a.stateNode,a.__reactInternalMemoizedUnmaskedChildContext=b,a.__reactInternalMemoizedMaskedChildContext=e);return e}\nfunction Zf(a){a=a.childContextTypes;return null!==a&&void 0!==a}function $f(){E(Wf);E(H)}function ag(a,b,c){if(H.current!==Vf)throw Error(p(168));G(H,b);G(Wf,c)}function bg(a,b,c){var d=a.stateNode;b=b.childContextTypes;if(\"function\"!==typeof d.getChildContext)return c;d=d.getChildContext();for(var e in d)if(!(e in b))throw Error(p(108,Ra(a)||\"Unknown\",e));return A({},c,d)}\nfunction cg(a){a=(a=a.stateNode)&&a.__reactInternalMemoizedMergedChildContext||Vf;Xf=H.current;G(H,a);G(Wf,Wf.current);return!0}function dg(a,b,c){var d=a.stateNode;if(!d)throw Error(p(169));c?(a=bg(a,b,Xf),d.__reactInternalMemoizedMergedChildContext=a,E(Wf),E(H),G(H,a)):E(Wf);G(Wf,c)}var eg=null,fg=!1,gg=!1;function hg(a){null===eg?eg=[a]:eg.push(a)}function ig(a){fg=!0;hg(a)}\nfunction jg(){if(!gg&&null!==eg){gg=!0;var a=0,b=C;try{var c=eg;for(C=1;a<c.length;a++){var d=c[a];do d=d(!0);while(null!==d)}eg=null;fg=!1}catch(e){throw null!==eg&&(eg=eg.slice(a+1)),ac(fc,jg),e;}finally{C=b,gg=!1}}return null}var kg=[],lg=0,mg=null,ng=0,og=[],pg=0,qg=null,rg=1,sg=\"\";function tg(a,b){kg[lg++]=ng;kg[lg++]=mg;mg=a;ng=b}\nfunction ug(a,b,c){og[pg++]=rg;og[pg++]=sg;og[pg++]=qg;qg=a;var d=rg;a=sg;var e=32-oc(d)-1;d&=~(1<<e);c+=1;var f=32-oc(b)+e;if(30<f){var g=e-e%5;f=(d&(1<<g)-1).toString(32);d>>=g;e-=g;rg=1<<32-oc(b)+e|c<<e|d;sg=f+a}else rg=1<<f|c<<e|d,sg=a}function vg(a){null!==a.return&&(tg(a,1),ug(a,1,0))}function wg(a){for(;a===mg;)mg=kg[--lg],kg[lg]=null,ng=kg[--lg],kg[lg]=null;for(;a===qg;)qg=og[--pg],og[pg]=null,sg=og[--pg],og[pg]=null,rg=og[--pg],og[pg]=null}var xg=null,yg=null,I=!1,zg=null;\nfunction Ag(a,b){var c=Bg(5,null,null,0);c.elementType=\"DELETED\";c.stateNode=b;c.return=a;b=a.deletions;null===b?(a.deletions=[c],a.flags|=16):b.push(c)}\nfunction Cg(a,b){switch(a.tag){case 5:var c=a.type;b=1!==b.nodeType||c.toLowerCase()!==b.nodeName.toLowerCase()?null:b;return null!==b?(a.stateNode=b,xg=a,yg=Lf(b.firstChild),!0):!1;case 6:return b=\"\"===a.pendingProps||3!==b.nodeType?null:b,null!==b?(a.stateNode=b,xg=a,yg=null,!0):!1;case 13:return b=8!==b.nodeType?null:b,null!==b?(c=null!==qg?{id:rg,overflow:sg}:null,a.memoizedState={dehydrated:b,treeContext:c,retryLane:1073741824},c=Bg(18,null,null,0),c.stateNode=b,c.return=a,a.child=c,xg=a,yg=\nnull,!0):!1;default:return!1}}function Dg(a){return 0!==(a.mode&1)&&0===(a.flags&128)}function Eg(a){if(I){var b=yg;if(b){var c=b;if(!Cg(a,b)){if(Dg(a))throw Error(p(418));b=Lf(c.nextSibling);var d=xg;b&&Cg(a,b)?Ag(d,c):(a.flags=a.flags&-4097|2,I=!1,xg=a)}}else{if(Dg(a))throw Error(p(418));a.flags=a.flags&-4097|2;I=!1;xg=a}}}function Fg(a){for(a=a.return;null!==a&&5!==a.tag&&3!==a.tag&&13!==a.tag;)a=a.return;xg=a}\nfunction Gg(a){if(a!==xg)return!1;if(!I)return Fg(a),I=!0,!1;var b;(b=3!==a.tag)&&!(b=5!==a.tag)&&(b=a.type,b=\"head\"!==b&&\"body\"!==b&&!Ef(a.type,a.memoizedProps));if(b&&(b=yg)){if(Dg(a))throw Hg(),Error(p(418));for(;b;)Ag(a,b),b=Lf(b.nextSibling)}Fg(a);if(13===a.tag){a=a.memoizedState;a=null!==a?a.dehydrated:null;if(!a)throw Error(p(317));a:{a=a.nextSibling;for(b=0;a;){if(8===a.nodeType){var c=a.data;if(\"/$\"===c){if(0===b){yg=Lf(a.nextSibling);break a}b--}else\"$\"!==c&&\"$!\"!==c&&\"$?\"!==c||b++}a=a.nextSibling}yg=\nnull}}else yg=xg?Lf(a.stateNode.nextSibling):null;return!0}function Hg(){for(var a=yg;a;)a=Lf(a.nextSibling)}function Ig(){yg=xg=null;I=!1}function Jg(a){null===zg?zg=[a]:zg.push(a)}var Kg=ua.ReactCurrentBatchConfig;\nfunction Lg(a,b,c){a=c.ref;if(null!==a&&\"function\"!==typeof a&&\"object\"!==typeof a){if(c._owner){c=c._owner;if(c){if(1!==c.tag)throw Error(p(309));var d=c.stateNode}if(!d)throw Error(p(147,a));var e=d,f=\"\"+a;if(null!==b&&null!==b.ref&&\"function\"===typeof b.ref&&b.ref._stringRef===f)return b.ref;b=function(a){var b=e.refs;null===a?delete b[f]:b[f]=a};b._stringRef=f;return b}if(\"string\"!==typeof a)throw Error(p(284));if(!c._owner)throw Error(p(290,a));}return a}\nfunction Mg(a,b){a=Object.prototype.toString.call(b);throw Error(p(31,\"[object Object]\"===a?\"object with keys {\"+Object.keys(b).join(\", \")+\"}\":a));}function Ng(a){var b=a._init;return b(a._payload)}\nfunction Og(a){function b(b,c){if(a){var d=b.deletions;null===d?(b.deletions=[c],b.flags|=16):d.push(c)}}function c(c,d){if(!a)return null;for(;null!==d;)b(c,d),d=d.sibling;return null}function d(a,b){for(a=new Map;null!==b;)null!==b.key?a.set(b.key,b):a.set(b.index,b),b=b.sibling;return a}function e(a,b){a=Pg(a,b);a.index=0;a.sibling=null;return a}function f(b,c,d){b.index=d;if(!a)return b.flags|=1048576,c;d=b.alternate;if(null!==d)return d=d.index,d<c?(b.flags|=2,c):d;b.flags|=2;return c}function g(b){a&&\nnull===b.alternate&&(b.flags|=2);return b}function h(a,b,c,d){if(null===b||6!==b.tag)return b=Qg(c,a.mode,d),b.return=a,b;b=e(b,c);b.return=a;return b}function k(a,b,c,d){var f=c.type;if(f===ya)return m(a,b,c.props.children,d,c.key);if(null!==b&&(b.elementType===f||\"object\"===typeof f&&null!==f&&f.$$typeof===Ha&&Ng(f)===b.type))return d=e(b,c.props),d.ref=Lg(a,b,c),d.return=a,d;d=Rg(c.type,c.key,c.props,null,a.mode,d);d.ref=Lg(a,b,c);d.return=a;return d}function l(a,b,c,d){if(null===b||4!==b.tag||\nb.stateNode.containerInfo!==c.containerInfo||b.stateNode.implementation!==c.implementation)return b=Sg(c,a.mode,d),b.return=a,b;b=e(b,c.children||[]);b.return=a;return b}function m(a,b,c,d,f){if(null===b||7!==b.tag)return b=Tg(c,a.mode,d,f),b.return=a,b;b=e(b,c);b.return=a;return b}function q(a,b,c){if(\"string\"===typeof b&&\"\"!==b||\"number\"===typeof b)return b=Qg(\"\"+b,a.mode,c),b.return=a,b;if(\"object\"===typeof b&&null!==b){switch(b.$$typeof){case va:return c=Rg(b.type,b.key,b.props,null,a.mode,c),\nc.ref=Lg(a,null,b),c.return=a,c;case wa:return b=Sg(b,a.mode,c),b.return=a,b;case Ha:var d=b._init;return q(a,d(b._payload),c)}if(eb(b)||Ka(b))return b=Tg(b,a.mode,c,null),b.return=a,b;Mg(a,b)}return null}function r(a,b,c,d){var e=null!==b?b.key:null;if(\"string\"===typeof c&&\"\"!==c||\"number\"===typeof c)return null!==e?null:h(a,b,\"\"+c,d);if(\"object\"===typeof c&&null!==c){switch(c.$$typeof){case va:return c.key===e?k(a,b,c,d):null;case wa:return c.key===e?l(a,b,c,d):null;case Ha:return e=c._init,r(a,\nb,e(c._payload),d)}if(eb(c)||Ka(c))return null!==e?null:m(a,b,c,d,null);Mg(a,c)}return null}function y(a,b,c,d,e){if(\"string\"===typeof d&&\"\"!==d||\"number\"===typeof d)return a=a.get(c)||null,h(b,a,\"\"+d,e);if(\"object\"===typeof d&&null!==d){switch(d.$$typeof){case va:return a=a.get(null===d.key?c:d.key)||null,k(b,a,d,e);case wa:return a=a.get(null===d.key?c:d.key)||null,l(b,a,d,e);case Ha:var f=d._init;return y(a,b,c,f(d._payload),e)}if(eb(d)||Ka(d))return a=a.get(c)||null,m(b,a,d,e,null);Mg(b,d)}return null}\nfunction n(e,g,h,k){for(var l=null,m=null,u=g,w=g=0,x=null;null!==u&&w<h.length;w++){u.index>w?(x=u,u=null):x=u.sibling;var n=r(e,u,h[w],k);if(null===n){null===u&&(u=x);break}a&&u&&null===n.alternate&&b(e,u);g=f(n,g,w);null===m?l=n:m.sibling=n;m=n;u=x}if(w===h.length)return c(e,u),I&&tg(e,w),l;if(null===u){for(;w<h.length;w++)u=q(e,h[w],k),null!==u&&(g=f(u,g,w),null===m?l=u:m.sibling=u,m=u);I&&tg(e,w);return l}for(u=d(e,u);w<h.length;w++)x=y(u,e,w,h[w],k),null!==x&&(a&&null!==x.alternate&&u.delete(null===\nx.key?w:x.key),g=f(x,g,w),null===m?l=x:m.sibling=x,m=x);a&&u.forEach(function(a){return b(e,a)});I&&tg(e,w);return l}function t(e,g,h,k){var l=Ka(h);if(\"function\"!==typeof l)throw Error(p(150));h=l.call(h);if(null==h)throw Error(p(151));for(var u=l=null,m=g,w=g=0,x=null,n=h.next();null!==m&&!n.done;w++,n=h.next()){m.index>w?(x=m,m=null):x=m.sibling;var t=r(e,m,n.value,k);if(null===t){null===m&&(m=x);break}a&&m&&null===t.alternate&&b(e,m);g=f(t,g,w);null===u?l=t:u.sibling=t;u=t;m=x}if(n.done)return c(e,\nm),I&&tg(e,w),l;if(null===m){for(;!n.done;w++,n=h.next())n=q(e,n.value,k),null!==n&&(g=f(n,g,w),null===u?l=n:u.sibling=n,u=n);I&&tg(e,w);return l}for(m=d(e,m);!n.done;w++,n=h.next())n=y(m,e,w,n.value,k),null!==n&&(a&&null!==n.alternate&&m.delete(null===n.key?w:n.key),g=f(n,g,w),null===u?l=n:u.sibling=n,u=n);a&&m.forEach(function(a){return b(e,a)});I&&tg(e,w);return l}function J(a,d,f,h){\"object\"===typeof f&&null!==f&&f.type===ya&&null===f.key&&(f=f.props.children);if(\"object\"===typeof f&&null!==f){switch(f.$$typeof){case va:a:{for(var k=\nf.key,l=d;null!==l;){if(l.key===k){k=f.type;if(k===ya){if(7===l.tag){c(a,l.sibling);d=e(l,f.props.children);d.return=a;a=d;break a}}else if(l.elementType===k||\"object\"===typeof k&&null!==k&&k.$$typeof===Ha&&Ng(k)===l.type){c(a,l.sibling);d=e(l,f.props);d.ref=Lg(a,l,f);d.return=a;a=d;break a}c(a,l);break}else b(a,l);l=l.sibling}f.type===ya?(d=Tg(f.props.children,a.mode,h,f.key),d.return=a,a=d):(h=Rg(f.type,f.key,f.props,null,a.mode,h),h.ref=Lg(a,d,f),h.return=a,a=h)}return g(a);case wa:a:{for(l=f.key;null!==\nd;){if(d.key===l)if(4===d.tag&&d.stateNode.containerInfo===f.containerInfo&&d.stateNode.implementation===f.implementation){c(a,d.sibling);d=e(d,f.children||[]);d.return=a;a=d;break a}else{c(a,d);break}else b(a,d);d=d.sibling}d=Sg(f,a.mode,h);d.return=a;a=d}return g(a);case Ha:return l=f._init,J(a,d,l(f._payload),h)}if(eb(f))return n(a,d,f,h);if(Ka(f))return t(a,d,f,h);Mg(a,f)}return\"string\"===typeof f&&\"\"!==f||\"number\"===typeof f?(f=\"\"+f,null!==d&&6===d.tag?(c(a,d.sibling),d=e(d,f),d.return=a,a=d):\n(c(a,d),d=Qg(f,a.mode,h),d.return=a,a=d),g(a)):c(a,d)}return J}var Ug=Og(!0),Vg=Og(!1),Wg=Uf(null),Xg=null,Yg=null,Zg=null;function $g(){Zg=Yg=Xg=null}function ah(a){var b=Wg.current;E(Wg);a._currentValue=b}function bh(a,b,c){for(;null!==a;){var d=a.alternate;(a.childLanes&b)!==b?(a.childLanes|=b,null!==d&&(d.childLanes|=b)):null!==d&&(d.childLanes&b)!==b&&(d.childLanes|=b);if(a===c)break;a=a.return}}\nfunction ch(a,b){Xg=a;Zg=Yg=null;a=a.dependencies;null!==a&&null!==a.firstContext&&(0!==(a.lanes&b)&&(dh=!0),a.firstContext=null)}function eh(a){var b=a._currentValue;if(Zg!==a)if(a={context:a,memoizedValue:b,next:null},null===Yg){if(null===Xg)throw Error(p(308));Yg=a;Xg.dependencies={lanes:0,firstContext:a}}else Yg=Yg.next=a;return b}var fh=null;function gh(a){null===fh?fh=[a]:fh.push(a)}\nfunction hh(a,b,c,d){var e=b.interleaved;null===e?(c.next=c,gh(b)):(c.next=e.next,e.next=c);b.interleaved=c;return ih(a,d)}function ih(a,b){a.lanes|=b;var c=a.alternate;null!==c&&(c.lanes|=b);c=a;for(a=a.return;null!==a;)a.childLanes|=b,c=a.alternate,null!==c&&(c.childLanes|=b),c=a,a=a.return;return 3===c.tag?c.stateNode:null}var jh=!1;function kh(a){a.updateQueue={baseState:a.memoizedState,firstBaseUpdate:null,lastBaseUpdate:null,shared:{pending:null,interleaved:null,lanes:0},effects:null}}\nfunction lh(a,b){a=a.updateQueue;b.updateQueue===a&&(b.updateQueue={baseState:a.baseState,firstBaseUpdate:a.firstBaseUpdate,lastBaseUpdate:a.lastBaseUpdate,shared:a.shared,effects:a.effects})}function mh(a,b){return{eventTime:a,lane:b,tag:0,payload:null,callback:null,next:null}}\nfunction nh(a,b,c){var d=a.updateQueue;if(null===d)return null;d=d.shared;if(0!==(K&2)){var e=d.pending;null===e?b.next=b:(b.next=e.next,e.next=b);d.pending=b;return ih(a,c)}e=d.interleaved;null===e?(b.next=b,gh(d)):(b.next=e.next,e.next=b);d.interleaved=b;return ih(a,c)}function oh(a,b,c){b=b.updateQueue;if(null!==b&&(b=b.shared,0!==(c&4194240))){var d=b.lanes;d&=a.pendingLanes;c|=d;b.lanes=c;Cc(a,c)}}\nfunction ph(a,b){var c=a.updateQueue,d=a.alternate;if(null!==d&&(d=d.updateQueue,c===d)){var e=null,f=null;c=c.firstBaseUpdate;if(null!==c){do{var g={eventTime:c.eventTime,lane:c.lane,tag:c.tag,payload:c.payload,callback:c.callback,next:null};null===f?e=f=g:f=f.next=g;c=c.next}while(null!==c);null===f?e=f=b:f=f.next=b}else e=f=b;c={baseState:d.baseState,firstBaseUpdate:e,lastBaseUpdate:f,shared:d.shared,effects:d.effects};a.updateQueue=c;return}a=c.lastBaseUpdate;null===a?c.firstBaseUpdate=b:a.next=\nb;c.lastBaseUpdate=b}\nfunction qh(a,b,c,d){var e=a.updateQueue;jh=!1;var f=e.firstBaseUpdate,g=e.lastBaseUpdate,h=e.shared.pending;if(null!==h){e.shared.pending=null;var k=h,l=k.next;k.next=null;null===g?f=l:g.next=l;g=k;var m=a.alternate;null!==m&&(m=m.updateQueue,h=m.lastBaseUpdate,h!==g&&(null===h?m.firstBaseUpdate=l:h.next=l,m.lastBaseUpdate=k))}if(null!==f){var q=e.baseState;g=0;m=l=k=null;h=f;do{var r=h.lane,y=h.eventTime;if((d&r)===r){null!==m&&(m=m.next={eventTime:y,lane:0,tag:h.tag,payload:h.payload,callback:h.callback,\nnext:null});a:{var n=a,t=h;r=b;y=c;switch(t.tag){case 1:n=t.payload;if(\"function\"===typeof n){q=n.call(y,q,r);break a}q=n;break a;case 3:n.flags=n.flags&-65537|128;case 0:n=t.payload;r=\"function\"===typeof n?n.call(y,q,r):n;if(null===r||void 0===r)break a;q=A({},q,r);break a;case 2:jh=!0}}null!==h.callback&&0!==h.lane&&(a.flags|=64,r=e.effects,null===r?e.effects=[h]:r.push(h))}else y={eventTime:y,lane:r,tag:h.tag,payload:h.payload,callback:h.callback,next:null},null===m?(l=m=y,k=q):m=m.next=y,g|=r;\nh=h.next;if(null===h)if(h=e.shared.pending,null===h)break;else r=h,h=r.next,r.next=null,e.lastBaseUpdate=r,e.shared.pending=null}while(1);null===m&&(k=q);e.baseState=k;e.firstBaseUpdate=l;e.lastBaseUpdate=m;b=e.shared.interleaved;if(null!==b){e=b;do g|=e.lane,e=e.next;while(e!==b)}else null===f&&(e.shared.lanes=0);rh|=g;a.lanes=g;a.memoizedState=q}}\nfunction sh(a,b,c){a=b.effects;b.effects=null;if(null!==a)for(b=0;b<a.length;b++){var d=a[b],e=d.callback;if(null!==e){d.callback=null;d=c;if(\"function\"!==typeof e)throw Error(p(191,e));e.call(d)}}}var th={},uh=Uf(th),vh=Uf(th),wh=Uf(th);function xh(a){if(a===th)throw Error(p(174));return a}\nfunction yh(a,b){G(wh,b);G(vh,a);G(uh,th);a=b.nodeType;switch(a){case 9:case 11:b=(b=b.documentElement)?b.namespaceURI:lb(null,\"\");break;default:a=8===a?b.parentNode:b,b=a.namespaceURI||null,a=a.tagName,b=lb(b,a)}E(uh);G(uh,b)}function zh(){E(uh);E(vh);E(wh)}function Ah(a){xh(wh.current);var b=xh(uh.current);var c=lb(b,a.type);b!==c&&(G(vh,a),G(uh,c))}function Bh(a){vh.current===a&&(E(uh),E(vh))}var L=Uf(0);\nfunction Ch(a){for(var b=a;null!==b;){if(13===b.tag){var c=b.memoizedState;if(null!==c&&(c=c.dehydrated,null===c||\"$?\"===c.data||\"$!\"===c.data))return b}else if(19===b.tag&&void 0!==b.memoizedProps.revealOrder){if(0!==(b.flags&128))return b}else if(null!==b.child){b.child.return=b;b=b.child;continue}if(b===a)break;for(;null===b.sibling;){if(null===b.return||b.return===a)return null;b=b.return}b.sibling.return=b.return;b=b.sibling}return null}var Dh=[];\nfunction Eh(){for(var a=0;a<Dh.length;a++)Dh[a]._workInProgressVersionPrimary=null;Dh.length=0}var Fh=ua.ReactCurrentDispatcher,Gh=ua.ReactCurrentBatchConfig,Hh=0,M=null,N=null,O=null,Ih=!1,Jh=!1,Kh=0,Lh=0;function P(){throw Error(p(321));}function Mh(a,b){if(null===b)return!1;for(var c=0;c<b.length&&c<a.length;c++)if(!He(a[c],b[c]))return!1;return!0}\nfunction Nh(a,b,c,d,e,f){Hh=f;M=b;b.memoizedState=null;b.updateQueue=null;b.lanes=0;Fh.current=null===a||null===a.memoizedState?Oh:Ph;a=c(d,e);if(Jh){f=0;do{Jh=!1;Kh=0;if(25<=f)throw Error(p(301));f+=1;O=N=null;b.updateQueue=null;Fh.current=Qh;a=c(d,e)}while(Jh)}Fh.current=Rh;b=null!==N&&null!==N.next;Hh=0;O=N=M=null;Ih=!1;if(b)throw Error(p(300));return a}function Sh(){var a=0!==Kh;Kh=0;return a}\nfunction Th(){var a={memoizedState:null,baseState:null,baseQueue:null,queue:null,next:null};null===O?M.memoizedState=O=a:O=O.next=a;return O}function Uh(){if(null===N){var a=M.alternate;a=null!==a?a.memoizedState:null}else a=N.next;var b=null===O?M.memoizedState:O.next;if(null!==b)O=b,N=a;else{if(null===a)throw Error(p(310));N=a;a={memoizedState:N.memoizedState,baseState:N.baseState,baseQueue:N.baseQueue,queue:N.queue,next:null};null===O?M.memoizedState=O=a:O=O.next=a}return O}\nfunction Vh(a,b){return\"function\"===typeof b?b(a):b}\nfunction Wh(a){var b=Uh(),c=b.queue;if(null===c)throw Error(p(311));c.lastRenderedReducer=a;var d=N,e=d.baseQueue,f=c.pending;if(null!==f){if(null!==e){var g=e.next;e.next=f.next;f.next=g}d.baseQueue=e=f;c.pending=null}if(null!==e){f=e.next;d=d.baseState;var h=g=null,k=null,l=f;do{var m=l.lane;if((Hh&m)===m)null!==k&&(k=k.next={lane:0,action:l.action,hasEagerState:l.hasEagerState,eagerState:l.eagerState,next:null}),d=l.hasEagerState?l.eagerState:a(d,l.action);else{var q={lane:m,action:l.action,hasEagerState:l.hasEagerState,\neagerState:l.eagerState,next:null};null===k?(h=k=q,g=d):k=k.next=q;M.lanes|=m;rh|=m}l=l.next}while(null!==l&&l!==f);null===k?g=d:k.next=h;He(d,b.memoizedState)||(dh=!0);b.memoizedState=d;b.baseState=g;b.baseQueue=k;c.lastRenderedState=d}a=c.interleaved;if(null!==a){e=a;do f=e.lane,M.lanes|=f,rh|=f,e=e.next;while(e!==a)}else null===e&&(c.lanes=0);return[b.memoizedState,c.dispatch]}\nfunction Xh(a){var b=Uh(),c=b.queue;if(null===c)throw Error(p(311));c.lastRenderedReducer=a;var d=c.dispatch,e=c.pending,f=b.memoizedState;if(null!==e){c.pending=null;var g=e=e.next;do f=a(f,g.action),g=g.next;while(g!==e);He(f,b.memoizedState)||(dh=!0);b.memoizedState=f;null===b.baseQueue&&(b.baseState=f);c.lastRenderedState=f}return[f,d]}function Yh(){}\nfunction Zh(a,b){var c=M,d=Uh(),e=b(),f=!He(d.memoizedState,e);f&&(d.memoizedState=e,dh=!0);d=d.queue;$h(ai.bind(null,c,d,a),[a]);if(d.getSnapshot!==b||f||null!==O&&O.memoizedState.tag&1){c.flags|=2048;bi(9,ci.bind(null,c,d,e,b),void 0,null);if(null===Q)throw Error(p(349));0!==(Hh&30)||di(c,b,e)}return e}function di(a,b,c){a.flags|=16384;a={getSnapshot:b,value:c};b=M.updateQueue;null===b?(b={lastEffect:null,stores:null},M.updateQueue=b,b.stores=[a]):(c=b.stores,null===c?b.stores=[a]:c.push(a))}\nfunction ci(a,b,c,d){b.value=c;b.getSnapshot=d;ei(b)&&fi(a)}function ai(a,b,c){return c(function(){ei(b)&&fi(a)})}function ei(a){var b=a.getSnapshot;a=a.value;try{var c=b();return!He(a,c)}catch(d){return!0}}function fi(a){var b=ih(a,1);null!==b&&gi(b,a,1,-1)}\nfunction hi(a){var b=Th();\"function\"===typeof a&&(a=a());b.memoizedState=b.baseState=a;a={pending:null,interleaved:null,lanes:0,dispatch:null,lastRenderedReducer:Vh,lastRenderedState:a};b.queue=a;a=a.dispatch=ii.bind(null,M,a);return[b.memoizedState,a]}\nfunction bi(a,b,c,d){a={tag:a,create:b,destroy:c,deps:d,next:null};b=M.updateQueue;null===b?(b={lastEffect:null,stores:null},M.updateQueue=b,b.lastEffect=a.next=a):(c=b.lastEffect,null===c?b.lastEffect=a.next=a:(d=c.next,c.next=a,a.next=d,b.lastEffect=a));return a}function ji(){return Uh().memoizedState}function ki(a,b,c,d){var e=Th();M.flags|=a;e.memoizedState=bi(1|b,c,void 0,void 0===d?null:d)}\nfunction li(a,b,c,d){var e=Uh();d=void 0===d?null:d;var f=void 0;if(null!==N){var g=N.memoizedState;f=g.destroy;if(null!==d&&Mh(d,g.deps)){e.memoizedState=bi(b,c,f,d);return}}M.flags|=a;e.memoizedState=bi(1|b,c,f,d)}function mi(a,b){return ki(8390656,8,a,b)}function $h(a,b){return li(2048,8,a,b)}function ni(a,b){return li(4,2,a,b)}function oi(a,b){return li(4,4,a,b)}\nfunction pi(a,b){if(\"function\"===typeof b)return a=a(),b(a),function(){b(null)};if(null!==b&&void 0!==b)return a=a(),b.current=a,function(){b.current=null}}function qi(a,b,c){c=null!==c&&void 0!==c?c.concat([a]):null;return li(4,4,pi.bind(null,b,a),c)}function ri(){}function si(a,b){var c=Uh();b=void 0===b?null:b;var d=c.memoizedState;if(null!==d&&null!==b&&Mh(b,d[1]))return d[0];c.memoizedState=[a,b];return a}\nfunction ti(a,b){var c=Uh();b=void 0===b?null:b;var d=c.memoizedState;if(null!==d&&null!==b&&Mh(b,d[1]))return d[0];a=a();c.memoizedState=[a,b];return a}function ui(a,b,c){if(0===(Hh&21))return a.baseState&&(a.baseState=!1,dh=!0),a.memoizedState=c;He(c,b)||(c=yc(),M.lanes|=c,rh|=c,a.baseState=!0);return b}function vi(a,b){var c=C;C=0!==c&&4>c?c:4;a(!0);var d=Gh.transition;Gh.transition={};try{a(!1),b()}finally{C=c,Gh.transition=d}}function wi(){return Uh().memoizedState}\nfunction xi(a,b,c){var d=yi(a);c={lane:d,action:c,hasEagerState:!1,eagerState:null,next:null};if(zi(a))Ai(b,c);else if(c=hh(a,b,c,d),null!==c){var e=R();gi(c,a,d,e);Bi(c,b,d)}}\nfunction ii(a,b,c){var d=yi(a),e={lane:d,action:c,hasEagerState:!1,eagerState:null,next:null};if(zi(a))Ai(b,e);else{var f=a.alternate;if(0===a.lanes&&(null===f||0===f.lanes)&&(f=b.lastRenderedReducer,null!==f))try{var g=b.lastRenderedState,h=f(g,c);e.hasEagerState=!0;e.eagerState=h;if(He(h,g)){var k=b.interleaved;null===k?(e.next=e,gh(b)):(e.next=k.next,k.next=e);b.interleaved=e;return}}catch(l){}finally{}c=hh(a,b,e,d);null!==c&&(e=R(),gi(c,a,d,e),Bi(c,b,d))}}\nfunction zi(a){var b=a.alternate;return a===M||null!==b&&b===M}function Ai(a,b){Jh=Ih=!0;var c=a.pending;null===c?b.next=b:(b.next=c.next,c.next=b);a.pending=b}function Bi(a,b,c){if(0!==(c&4194240)){var d=b.lanes;d&=a.pendingLanes;c|=d;b.lanes=c;Cc(a,c)}}\nvar Rh={readContext:eh,useCallback:P,useContext:P,useEffect:P,useImperativeHandle:P,useInsertionEffect:P,useLayoutEffect:P,useMemo:P,useReducer:P,useRef:P,useState:P,useDebugValue:P,useDeferredValue:P,useTransition:P,useMutableSource:P,useSyncExternalStore:P,useId:P,unstable_isNewReconciler:!1},Oh={readContext:eh,useCallback:function(a,b){Th().memoizedState=[a,void 0===b?null:b];return a},useContext:eh,useEffect:mi,useImperativeHandle:function(a,b,c){c=null!==c&&void 0!==c?c.concat([a]):null;return ki(4194308,\n4,pi.bind(null,b,a),c)},useLayoutEffect:function(a,b){return ki(4194308,4,a,b)},useInsertionEffect:function(a,b){return ki(4,2,a,b)},useMemo:function(a,b){var c=Th();b=void 0===b?null:b;a=a();c.memoizedState=[a,b];return a},useReducer:function(a,b,c){var d=Th();b=void 0!==c?c(b):b;d.memoizedState=d.baseState=b;a={pending:null,interleaved:null,lanes:0,dispatch:null,lastRenderedReducer:a,lastRenderedState:b};d.queue=a;a=a.dispatch=xi.bind(null,M,a);return[d.memoizedState,a]},useRef:function(a){var b=\nTh();a={current:a};return b.memoizedState=a},useState:hi,useDebugValue:ri,useDeferredValue:function(a){return Th().memoizedState=a},useTransition:function(){var a=hi(!1),b=a[0];a=vi.bind(null,a[1]);Th().memoizedState=a;return[b,a]},useMutableSource:function(){},useSyncExternalStore:function(a,b,c){var d=M,e=Th();if(I){if(void 0===c)throw Error(p(407));c=c()}else{c=b();if(null===Q)throw Error(p(349));0!==(Hh&30)||di(d,b,c)}e.memoizedState=c;var f={value:c,getSnapshot:b};e.queue=f;mi(ai.bind(null,d,\nf,a),[a]);d.flags|=2048;bi(9,ci.bind(null,d,f,c,b),void 0,null);return c},useId:function(){var a=Th(),b=Q.identifierPrefix;if(I){var c=sg;var d=rg;c=(d&~(1<<32-oc(d)-1)).toString(32)+c;b=\":\"+b+\"R\"+c;c=Kh++;0<c&&(b+=\"H\"+c.toString(32));b+=\":\"}else c=Lh++,b=\":\"+b+\"r\"+c.toString(32)+\":\";return a.memoizedState=b},unstable_isNewReconciler:!1},Ph={readContext:eh,useCallback:si,useContext:eh,useEffect:$h,useImperativeHandle:qi,useInsertionEffect:ni,useLayoutEffect:oi,useMemo:ti,useReducer:Wh,useRef:ji,useState:function(){return Wh(Vh)},\nuseDebugValue:ri,useDeferredValue:function(a){var b=Uh();return ui(b,N.memoizedState,a)},useTransition:function(){var a=Wh(Vh)[0],b=Uh().memoizedState;return[a,b]},useMutableSource:Yh,useSyncExternalStore:Zh,useId:wi,unstable_isNewReconciler:!1},Qh={readContext:eh,useCallback:si,useContext:eh,useEffect:$h,useImperativeHandle:qi,useInsertionEffect:ni,useLayoutEffect:oi,useMemo:ti,useReducer:Xh,useRef:ji,useState:function(){return Xh(Vh)},useDebugValue:ri,useDeferredValue:function(a){var b=Uh();return null===\nN?b.memoizedState=a:ui(b,N.memoizedState,a)},useTransition:function(){var a=Xh(Vh)[0],b=Uh().memoizedState;return[a,b]},useMutableSource:Yh,useSyncExternalStore:Zh,useId:wi,unstable_isNewReconciler:!1};function Ci(a,b){if(a&&a.defaultProps){b=A({},b);a=a.defaultProps;for(var c in a)void 0===b[c]&&(b[c]=a[c]);return b}return b}function Di(a,b,c,d){b=a.memoizedState;c=c(d,b);c=null===c||void 0===c?b:A({},b,c);a.memoizedState=c;0===a.lanes&&(a.updateQueue.baseState=c)}\nvar Ei={isMounted:function(a){return(a=a._reactInternals)?Vb(a)===a:!1},enqueueSetState:function(a,b,c){a=a._reactInternals;var d=R(),e=yi(a),f=mh(d,e);f.payload=b;void 0!==c&&null!==c&&(f.callback=c);b=nh(a,f,e);null!==b&&(gi(b,a,e,d),oh(b,a,e))},enqueueReplaceState:function(a,b,c){a=a._reactInternals;var d=R(),e=yi(a),f=mh(d,e);f.tag=1;f.payload=b;void 0!==c&&null!==c&&(f.callback=c);b=nh(a,f,e);null!==b&&(gi(b,a,e,d),oh(b,a,e))},enqueueForceUpdate:function(a,b){a=a._reactInternals;var c=R(),d=\nyi(a),e=mh(c,d);e.tag=2;void 0!==b&&null!==b&&(e.callback=b);b=nh(a,e,d);null!==b&&(gi(b,a,d,c),oh(b,a,d))}};function Fi(a,b,c,d,e,f,g){a=a.stateNode;return\"function\"===typeof a.shouldComponentUpdate?a.shouldComponentUpdate(d,f,g):b.prototype&&b.prototype.isPureReactComponent?!Ie(c,d)||!Ie(e,f):!0}\nfunction Gi(a,b,c){var d=!1,e=Vf;var f=b.contextType;\"object\"===typeof f&&null!==f?f=eh(f):(e=Zf(b)?Xf:H.current,d=b.contextTypes,f=(d=null!==d&&void 0!==d)?Yf(a,e):Vf);b=new b(c,f);a.memoizedState=null!==b.state&&void 0!==b.state?b.state:null;b.updater=Ei;a.stateNode=b;b._reactInternals=a;d&&(a=a.stateNode,a.__reactInternalMemoizedUnmaskedChildContext=e,a.__reactInternalMemoizedMaskedChildContext=f);return b}\nfunction Hi(a,b,c,d){a=b.state;\"function\"===typeof b.componentWillReceiveProps&&b.componentWillReceiveProps(c,d);\"function\"===typeof b.UNSAFE_componentWillReceiveProps&&b.UNSAFE_componentWillReceiveProps(c,d);b.state!==a&&Ei.enqueueReplaceState(b,b.state,null)}\nfunction Ii(a,b,c,d){var e=a.stateNode;e.props=c;e.state=a.memoizedState;e.refs={};kh(a);var f=b.contextType;\"object\"===typeof f&&null!==f?e.context=eh(f):(f=Zf(b)?Xf:H.current,e.context=Yf(a,f));e.state=a.memoizedState;f=b.getDerivedStateFromProps;\"function\"===typeof f&&(Di(a,b,f,c),e.state=a.memoizedState);\"function\"===typeof b.getDerivedStateFromProps||\"function\"===typeof e.getSnapshotBeforeUpdate||\"function\"!==typeof e.UNSAFE_componentWillMount&&\"function\"!==typeof e.componentWillMount||(b=e.state,\n\"function\"===typeof e.componentWillMount&&e.componentWillMount(),\"function\"===typeof e.UNSAFE_componentWillMount&&e.UNSAFE_componentWillMount(),b!==e.state&&Ei.enqueueReplaceState(e,e.state,null),qh(a,c,e,d),e.state=a.memoizedState);\"function\"===typeof e.componentDidMount&&(a.flags|=4194308)}function Ji(a,b){try{var c=\"\",d=b;do c+=Pa(d),d=d.return;while(d);var e=c}catch(f){e=\"\\nError generating stack: \"+f.message+\"\\n\"+f.stack}return{value:a,source:b,stack:e,digest:null}}\nfunction Ki(a,b,c){return{value:a,source:null,stack:null!=c?c:null,digest:null!=b?b:null}}function Li(a,b){try{console.error(b.value)}catch(c){setTimeout(function(){throw c;})}}var Mi=\"function\"===typeof WeakMap?WeakMap:Map;function Ni(a,b,c){c=mh(-1,c);c.tag=3;c.payload={element:null};var d=b.value;c.callback=function(){Oi||(Oi=!0,Pi=d);Li(a,b)};return c}\nfunction Qi(a,b,c){c=mh(-1,c);c.tag=3;var d=a.type.getDerivedStateFromError;if(\"function\"===typeof d){var e=b.value;c.payload=function(){return d(e)};c.callback=function(){Li(a,b)}}var f=a.stateNode;null!==f&&\"function\"===typeof f.componentDidCatch&&(c.callback=function(){Li(a,b);\"function\"!==typeof d&&(null===Ri?Ri=new Set([this]):Ri.add(this));var c=b.stack;this.componentDidCatch(b.value,{componentStack:null!==c?c:\"\"})});return c}\nfunction Si(a,b,c){var d=a.pingCache;if(null===d){d=a.pingCache=new Mi;var e=new Set;d.set(b,e)}else e=d.get(b),void 0===e&&(e=new Set,d.set(b,e));e.has(c)||(e.add(c),a=Ti.bind(null,a,b,c),b.then(a,a))}function Ui(a){do{var b;if(b=13===a.tag)b=a.memoizedState,b=null!==b?null!==b.dehydrated?!0:!1:!0;if(b)return a;a=a.return}while(null!==a);return null}\nfunction Vi(a,b,c,d,e){if(0===(a.mode&1))return a===b?a.flags|=65536:(a.flags|=128,c.flags|=131072,c.flags&=-52805,1===c.tag&&(null===c.alternate?c.tag=17:(b=mh(-1,1),b.tag=2,nh(c,b,1))),c.lanes|=1),a;a.flags|=65536;a.lanes=e;return a}var Wi=ua.ReactCurrentOwner,dh=!1;function Xi(a,b,c,d){b.child=null===a?Vg(b,null,c,d):Ug(b,a.child,c,d)}\nfunction Yi(a,b,c,d,e){c=c.render;var f=b.ref;ch(b,e);d=Nh(a,b,c,d,f,e);c=Sh();if(null!==a&&!dh)return b.updateQueue=a.updateQueue,b.flags&=-2053,a.lanes&=~e,Zi(a,b,e);I&&c&&vg(b);b.flags|=1;Xi(a,b,d,e);return b.child}\nfunction $i(a,b,c,d,e){if(null===a){var f=c.type;if(\"function\"===typeof f&&!aj(f)&&void 0===f.defaultProps&&null===c.compare&&void 0===c.defaultProps)return b.tag=15,b.type=f,bj(a,b,f,d,e);a=Rg(c.type,null,d,b,b.mode,e);a.ref=b.ref;a.return=b;return b.child=a}f=a.child;if(0===(a.lanes&e)){var g=f.memoizedProps;c=c.compare;c=null!==c?c:Ie;if(c(g,d)&&a.ref===b.ref)return Zi(a,b,e)}b.flags|=1;a=Pg(f,d);a.ref=b.ref;a.return=b;return b.child=a}\nfunction bj(a,b,c,d,e){if(null!==a){var f=a.memoizedProps;if(Ie(f,d)&&a.ref===b.ref)if(dh=!1,b.pendingProps=d=f,0!==(a.lanes&e))0!==(a.flags&131072)&&(dh=!0);else return b.lanes=a.lanes,Zi(a,b,e)}return cj(a,b,c,d,e)}\nfunction dj(a,b,c){var d=b.pendingProps,e=d.children,f=null!==a?a.memoizedState:null;if(\"hidden\"===d.mode)if(0===(b.mode&1))b.memoizedState={baseLanes:0,cachePool:null,transitions:null},G(ej,fj),fj|=c;else{if(0===(c&1073741824))return a=null!==f?f.baseLanes|c:c,b.lanes=b.childLanes=1073741824,b.memoizedState={baseLanes:a,cachePool:null,transitions:null},b.updateQueue=null,G(ej,fj),fj|=a,null;b.memoizedState={baseLanes:0,cachePool:null,transitions:null};d=null!==f?f.baseLanes:c;G(ej,fj);fj|=d}else null!==\nf?(d=f.baseLanes|c,b.memoizedState=null):d=c,G(ej,fj),fj|=d;Xi(a,b,e,c);return b.child}function gj(a,b){var c=b.ref;if(null===a&&null!==c||null!==a&&a.ref!==c)b.flags|=512,b.flags|=2097152}function cj(a,b,c,d,e){var f=Zf(c)?Xf:H.current;f=Yf(b,f);ch(b,e);c=Nh(a,b,c,d,f,e);d=Sh();if(null!==a&&!dh)return b.updateQueue=a.updateQueue,b.flags&=-2053,a.lanes&=~e,Zi(a,b,e);I&&d&&vg(b);b.flags|=1;Xi(a,b,c,e);return b.child}\nfunction hj(a,b,c,d,e){if(Zf(c)){var f=!0;cg(b)}else f=!1;ch(b,e);if(null===b.stateNode)ij(a,b),Gi(b,c,d),Ii(b,c,d,e),d=!0;else if(null===a){var g=b.stateNode,h=b.memoizedProps;g.props=h;var k=g.context,l=c.contextType;\"object\"===typeof l&&null!==l?l=eh(l):(l=Zf(c)?Xf:H.current,l=Yf(b,l));var m=c.getDerivedStateFromProps,q=\"function\"===typeof m||\"function\"===typeof g.getSnapshotBeforeUpdate;q||\"function\"!==typeof g.UNSAFE_componentWillReceiveProps&&\"function\"!==typeof g.componentWillReceiveProps||\n(h!==d||k!==l)&&Hi(b,g,d,l);jh=!1;var r=b.memoizedState;g.state=r;qh(b,d,g,e);k=b.memoizedState;h!==d||r!==k||Wf.current||jh?(\"function\"===typeof m&&(Di(b,c,m,d),k=b.memoizedState),(h=jh||Fi(b,c,h,d,r,k,l))?(q||\"function\"!==typeof g.UNSAFE_componentWillMount&&\"function\"!==typeof g.componentWillMount||(\"function\"===typeof g.componentWillMount&&g.componentWillMount(),\"function\"===typeof g.UNSAFE_componentWillMount&&g.UNSAFE_componentWillMount()),\"function\"===typeof g.componentDidMount&&(b.flags|=4194308)):\n(\"function\"===typeof g.componentDidMount&&(b.flags|=4194308),b.memoizedProps=d,b.memoizedState=k),g.props=d,g.state=k,g.context=l,d=h):(\"function\"===typeof g.componentDidMount&&(b.flags|=4194308),d=!1)}else{g=b.stateNode;lh(a,b);h=b.memoizedProps;l=b.type===b.elementType?h:Ci(b.type,h);g.props=l;q=b.pendingProps;r=g.context;k=c.contextType;\"object\"===typeof k&&null!==k?k=eh(k):(k=Zf(c)?Xf:H.current,k=Yf(b,k));var y=c.getDerivedStateFromProps;(m=\"function\"===typeof y||\"function\"===typeof g.getSnapshotBeforeUpdate)||\n\"function\"!==typeof g.UNSAFE_componentWillReceiveProps&&\"function\"!==typeof g.componentWillReceiveProps||(h!==q||r!==k)&&Hi(b,g,d,k);jh=!1;r=b.memoizedState;g.state=r;qh(b,d,g,e);var n=b.memoizedState;h!==q||r!==n||Wf.current||jh?(\"function\"===typeof y&&(Di(b,c,y,d),n=b.memoizedState),(l=jh||Fi(b,c,l,d,r,n,k)||!1)?(m||\"function\"!==typeof g.UNSAFE_componentWillUpdate&&\"function\"!==typeof g.componentWillUpdate||(\"function\"===typeof g.componentWillUpdate&&g.componentWillUpdate(d,n,k),\"function\"===typeof g.UNSAFE_componentWillUpdate&&\ng.UNSAFE_componentWillUpdate(d,n,k)),\"function\"===typeof g.componentDidUpdate&&(b.flags|=4),\"function\"===typeof g.getSnapshotBeforeUpdate&&(b.flags|=1024)):(\"function\"!==typeof g.componentDidUpdate||h===a.memoizedProps&&r===a.memoizedState||(b.flags|=4),\"function\"!==typeof g.getSnapshotBeforeUpdate||h===a.memoizedProps&&r===a.memoizedState||(b.flags|=1024),b.memoizedProps=d,b.memoizedState=n),g.props=d,g.state=n,g.context=k,d=l):(\"function\"!==typeof g.componentDidUpdate||h===a.memoizedProps&&r===\na.memoizedState||(b.flags|=4),\"function\"!==typeof g.getSnapshotBeforeUpdate||h===a.memoizedProps&&r===a.memoizedState||(b.flags|=1024),d=!1)}return jj(a,b,c,d,f,e)}\nfunction jj(a,b,c,d,e,f){gj(a,b);var g=0!==(b.flags&128);if(!d&&!g)return e&&dg(b,c,!1),Zi(a,b,f);d=b.stateNode;Wi.current=b;var h=g&&\"function\"!==typeof c.getDerivedStateFromError?null:d.render();b.flags|=1;null!==a&&g?(b.child=Ug(b,a.child,null,f),b.child=Ug(b,null,h,f)):Xi(a,b,h,f);b.memoizedState=d.state;e&&dg(b,c,!0);return b.child}function kj(a){var b=a.stateNode;b.pendingContext?ag(a,b.pendingContext,b.pendingContext!==b.context):b.context&&ag(a,b.context,!1);yh(a,b.containerInfo)}\nfunction lj(a,b,c,d,e){Ig();Jg(e);b.flags|=256;Xi(a,b,c,d);return b.child}var mj={dehydrated:null,treeContext:null,retryLane:0};function nj(a){return{baseLanes:a,cachePool:null,transitions:null}}\nfunction oj(a,b,c){var d=b.pendingProps,e=L.current,f=!1,g=0!==(b.flags&128),h;(h=g)||(h=null!==a&&null===a.memoizedState?!1:0!==(e&2));if(h)f=!0,b.flags&=-129;else if(null===a||null!==a.memoizedState)e|=1;G(L,e&1);if(null===a){Eg(b);a=b.memoizedState;if(null!==a&&(a=a.dehydrated,null!==a))return 0===(b.mode&1)?b.lanes=1:\"$!\"===a.data?b.lanes=8:b.lanes=1073741824,null;g=d.children;a=d.fallback;return f?(d=b.mode,f=b.child,g={mode:\"hidden\",children:g},0===(d&1)&&null!==f?(f.childLanes=0,f.pendingProps=\ng):f=pj(g,d,0,null),a=Tg(a,d,c,null),f.return=b,a.return=b,f.sibling=a,b.child=f,b.child.memoizedState=nj(c),b.memoizedState=mj,a):qj(b,g)}e=a.memoizedState;if(null!==e&&(h=e.dehydrated,null!==h))return rj(a,b,g,d,h,e,c);if(f){f=d.fallback;g=b.mode;e=a.child;h=e.sibling;var k={mode:\"hidden\",children:d.children};0===(g&1)&&b.child!==e?(d=b.child,d.childLanes=0,d.pendingProps=k,b.deletions=null):(d=Pg(e,k),d.subtreeFlags=e.subtreeFlags&14680064);null!==h?f=Pg(h,f):(f=Tg(f,g,c,null),f.flags|=2);f.return=\nb;d.return=b;d.sibling=f;b.child=d;d=f;f=b.child;g=a.child.memoizedState;g=null===g?nj(c):{baseLanes:g.baseLanes|c,cachePool:null,transitions:g.transitions};f.memoizedState=g;f.childLanes=a.childLanes&~c;b.memoizedState=mj;return d}f=a.child;a=f.sibling;d=Pg(f,{mode:\"visible\",children:d.children});0===(b.mode&1)&&(d.lanes=c);d.return=b;d.sibling=null;null!==a&&(c=b.deletions,null===c?(b.deletions=[a],b.flags|=16):c.push(a));b.child=d;b.memoizedState=null;return d}\nfunction qj(a,b){b=pj({mode:\"visible\",children:b},a.mode,0,null);b.return=a;return a.child=b}function sj(a,b,c,d){null!==d&&Jg(d);Ug(b,a.child,null,c);a=qj(b,b.pendingProps.children);a.flags|=2;b.memoizedState=null;return a}\nfunction rj(a,b,c,d,e,f,g){if(c){if(b.flags&256)return b.flags&=-257,d=Ki(Error(p(422))),sj(a,b,g,d);if(null!==b.memoizedState)return b.child=a.child,b.flags|=128,null;f=d.fallback;e=b.mode;d=pj({mode:\"visible\",children:d.children},e,0,null);f=Tg(f,e,g,null);f.flags|=2;d.return=b;f.return=b;d.sibling=f;b.child=d;0!==(b.mode&1)&&Ug(b,a.child,null,g);b.child.memoizedState=nj(g);b.memoizedState=mj;return f}if(0===(b.mode&1))return sj(a,b,g,null);if(\"$!\"===e.data){d=e.nextSibling&&e.nextSibling.dataset;\nif(d)var h=d.dgst;d=h;f=Error(p(419));d=Ki(f,d,void 0);return sj(a,b,g,d)}h=0!==(g&a.childLanes);if(dh||h){d=Q;if(null!==d){switch(g&-g){case 4:e=2;break;case 16:e=8;break;case 64:case 128:case 256:case 512:case 1024:case 2048:case 4096:case 8192:case 16384:case 32768:case 65536:case 131072:case 262144:case 524288:case 1048576:case 2097152:case 4194304:case 8388608:case 16777216:case 33554432:case 67108864:e=32;break;case 536870912:e=268435456;break;default:e=0}e=0!==(e&(d.suspendedLanes|g))?0:e;\n0!==e&&e!==f.retryLane&&(f.retryLane=e,ih(a,e),gi(d,a,e,-1))}tj();d=Ki(Error(p(421)));return sj(a,b,g,d)}if(\"$?\"===e.data)return b.flags|=128,b.child=a.child,b=uj.bind(null,a),e._reactRetry=b,null;a=f.treeContext;yg=Lf(e.nextSibling);xg=b;I=!0;zg=null;null!==a&&(og[pg++]=rg,og[pg++]=sg,og[pg++]=qg,rg=a.id,sg=a.overflow,qg=b);b=qj(b,d.children);b.flags|=4096;return b}function vj(a,b,c){a.lanes|=b;var d=a.alternate;null!==d&&(d.lanes|=b);bh(a.return,b,c)}\nfunction wj(a,b,c,d,e){var f=a.memoizedState;null===f?a.memoizedState={isBackwards:b,rendering:null,renderingStartTime:0,last:d,tail:c,tailMode:e}:(f.isBackwards=b,f.rendering=null,f.renderingStartTime=0,f.last=d,f.tail=c,f.tailMode=e)}\nfunction xj(a,b,c){var d=b.pendingProps,e=d.revealOrder,f=d.tail;Xi(a,b,d.children,c);d=L.current;if(0!==(d&2))d=d&1|2,b.flags|=128;else{if(null!==a&&0!==(a.flags&128))a:for(a=b.child;null!==a;){if(13===a.tag)null!==a.memoizedState&&vj(a,c,b);else if(19===a.tag)vj(a,c,b);else if(null!==a.child){a.child.return=a;a=a.child;continue}if(a===b)break a;for(;null===a.sibling;){if(null===a.return||a.return===b)break a;a=a.return}a.sibling.return=a.return;a=a.sibling}d&=1}G(L,d);if(0===(b.mode&1))b.memoizedState=\nnull;else switch(e){case \"forwards\":c=b.child;for(e=null;null!==c;)a=c.alternate,null!==a&&null===Ch(a)&&(e=c),c=c.sibling;c=e;null===c?(e=b.child,b.child=null):(e=c.sibling,c.sibling=null);wj(b,!1,e,c,f);break;case \"backwards\":c=null;e=b.child;for(b.child=null;null!==e;){a=e.alternate;if(null!==a&&null===Ch(a)){b.child=e;break}a=e.sibling;e.sibling=c;c=e;e=a}wj(b,!0,c,null,f);break;case \"together\":wj(b,!1,null,null,void 0);break;default:b.memoizedState=null}return b.child}\nfunction ij(a,b){0===(b.mode&1)&&null!==a&&(a.alternate=null,b.alternate=null,b.flags|=2)}function Zi(a,b,c){null!==a&&(b.dependencies=a.dependencies);rh|=b.lanes;if(0===(c&b.childLanes))return null;if(null!==a&&b.child!==a.child)throw Error(p(153));if(null!==b.child){a=b.child;c=Pg(a,a.pendingProps);b.child=c;for(c.return=b;null!==a.sibling;)a=a.sibling,c=c.sibling=Pg(a,a.pendingProps),c.return=b;c.sibling=null}return b.child}\nfunction yj(a,b,c){switch(b.tag){case 3:kj(b);Ig();break;case 5:Ah(b);break;case 1:Zf(b.type)&&cg(b);break;case 4:yh(b,b.stateNode.containerInfo);break;case 10:var d=b.type._context,e=b.memoizedProps.value;G(Wg,d._currentValue);d._currentValue=e;break;case 13:d=b.memoizedState;if(null!==d){if(null!==d.dehydrated)return G(L,L.current&1),b.flags|=128,null;if(0!==(c&b.child.childLanes))return oj(a,b,c);G(L,L.current&1);a=Zi(a,b,c);return null!==a?a.sibling:null}G(L,L.current&1);break;case 19:d=0!==(c&\nb.childLanes);if(0!==(a.flags&128)){if(d)return xj(a,b,c);b.flags|=128}e=b.memoizedState;null!==e&&(e.rendering=null,e.tail=null,e.lastEffect=null);G(L,L.current);if(d)break;else return null;case 22:case 23:return b.lanes=0,dj(a,b,c)}return Zi(a,b,c)}var zj,Aj,Bj,Cj;\nzj=function(a,b){for(var c=b.child;null!==c;){if(5===c.tag||6===c.tag)a.appendChild(c.stateNode);else if(4!==c.tag&&null!==c.child){c.child.return=c;c=c.child;continue}if(c===b)break;for(;null===c.sibling;){if(null===c.return||c.return===b)return;c=c.return}c.sibling.return=c.return;c=c.sibling}};Aj=function(){};\nBj=function(a,b,c,d){var e=a.memoizedProps;if(e!==d){a=b.stateNode;xh(uh.current);var f=null;switch(c){case \"input\":e=Ya(a,e);d=Ya(a,d);f=[];break;case \"select\":e=A({},e,{value:void 0});d=A({},d,{value:void 0});f=[];break;case \"textarea\":e=gb(a,e);d=gb(a,d);f=[];break;default:\"function\"!==typeof e.onClick&&\"function\"===typeof d.onClick&&(a.onclick=Bf)}ub(c,d);var g;c=null;for(l in e)if(!d.hasOwnProperty(l)&&e.hasOwnProperty(l)&&null!=e[l])if(\"style\"===l){var h=e[l];for(g in h)h.hasOwnProperty(g)&&\n(c||(c={}),c[g]=\"\")}else\"dangerouslySetInnerHTML\"!==l&&\"children\"!==l&&\"suppressContentEditableWarning\"!==l&&\"suppressHydrationWarning\"!==l&&\"autoFocus\"!==l&&(ea.hasOwnProperty(l)?f||(f=[]):(f=f||[]).push(l,null));for(l in d){var k=d[l];h=null!=e?e[l]:void 0;if(d.hasOwnProperty(l)&&k!==h&&(null!=k||null!=h))if(\"style\"===l)if(h){for(g in h)!h.hasOwnProperty(g)||k&&k.hasOwnProperty(g)||(c||(c={}),c[g]=\"\");for(g in k)k.hasOwnProperty(g)&&h[g]!==k[g]&&(c||(c={}),c[g]=k[g])}else c||(f||(f=[]),f.push(l,\nc)),c=k;else\"dangerouslySetInnerHTML\"===l?(k=k?k.__html:void 0,h=h?h.__html:void 0,null!=k&&h!==k&&(f=f||[]).push(l,k)):\"children\"===l?\"string\"!==typeof k&&\"number\"!==typeof k||(f=f||[]).push(l,\"\"+k):\"suppressContentEditableWarning\"!==l&&\"suppressHydrationWarning\"!==l&&(ea.hasOwnProperty(l)?(null!=k&&\"onScroll\"===l&&D(\"scroll\",a),f||h===k||(f=[])):(f=f||[]).push(l,k))}c&&(f=f||[]).push(\"style\",c);var l=f;if(b.updateQueue=l)b.flags|=4}};Cj=function(a,b,c,d){c!==d&&(b.flags|=4)};\nfunction Dj(a,b){if(!I)switch(a.tailMode){case \"hidden\":b=a.tail;for(var c=null;null!==b;)null!==b.alternate&&(c=b),b=b.sibling;null===c?a.tail=null:c.sibling=null;break;case \"collapsed\":c=a.tail;for(var d=null;null!==c;)null!==c.alternate&&(d=c),c=c.sibling;null===d?b||null===a.tail?a.tail=null:a.tail.sibling=null:d.sibling=null}}\nfunction S(a){var b=null!==a.alternate&&a.alternate.child===a.child,c=0,d=0;if(b)for(var e=a.child;null!==e;)c|=e.lanes|e.childLanes,d|=e.subtreeFlags&14680064,d|=e.flags&14680064,e.return=a,e=e.sibling;else for(e=a.child;null!==e;)c|=e.lanes|e.childLanes,d|=e.subtreeFlags,d|=e.flags,e.return=a,e=e.sibling;a.subtreeFlags|=d;a.childLanes=c;return b}\nfunction Ej(a,b,c){var d=b.pendingProps;wg(b);switch(b.tag){case 2:case 16:case 15:case 0:case 11:case 7:case 8:case 12:case 9:case 14:return S(b),null;case 1:return Zf(b.type)&&$f(),S(b),null;case 3:d=b.stateNode;zh();E(Wf);E(H);Eh();d.pendingContext&&(d.context=d.pendingContext,d.pendingContext=null);if(null===a||null===a.child)Gg(b)?b.flags|=4:null===a||a.memoizedState.isDehydrated&&0===(b.flags&256)||(b.flags|=1024,null!==zg&&(Fj(zg),zg=null));Aj(a,b);S(b);return null;case 5:Bh(b);var e=xh(wh.current);\nc=b.type;if(null!==a&&null!=b.stateNode)Bj(a,b,c,d,e),a.ref!==b.ref&&(b.flags|=512,b.flags|=2097152);else{if(!d){if(null===b.stateNode)throw Error(p(166));S(b);return null}a=xh(uh.current);if(Gg(b)){d=b.stateNode;c=b.type;var f=b.memoizedProps;d[Of]=b;d[Pf]=f;a=0!==(b.mode&1);switch(c){case \"dialog\":D(\"cancel\",d);D(\"close\",d);break;case \"iframe\":case \"object\":case \"embed\":D(\"load\",d);break;case \"video\":case \"audio\":for(e=0;e<lf.length;e++)D(lf[e],d);break;case \"source\":D(\"error\",d);break;case \"img\":case \"image\":case \"link\":D(\"error\",\nd);D(\"load\",d);break;case \"details\":D(\"toggle\",d);break;case \"input\":Za(d,f);D(\"invalid\",d);break;case \"select\":d._wrapperState={wasMultiple:!!f.multiple};D(\"invalid\",d);break;case \"textarea\":hb(d,f),D(\"invalid\",d)}ub(c,f);e=null;for(var g in f)if(f.hasOwnProperty(g)){var h=f[g];\"children\"===g?\"string\"===typeof h?d.textContent!==h&&(!0!==f.suppressHydrationWarning&&Af(d.textContent,h,a),e=[\"children\",h]):\"number\"===typeof h&&d.textContent!==\"\"+h&&(!0!==f.suppressHydrationWarning&&Af(d.textContent,\nh,a),e=[\"children\",\"\"+h]):ea.hasOwnProperty(g)&&null!=h&&\"onScroll\"===g&&D(\"scroll\",d)}switch(c){case \"input\":Va(d);db(d,f,!0);break;case \"textarea\":Va(d);jb(d);break;case \"select\":case \"option\":break;default:\"function\"===typeof f.onClick&&(d.onclick=Bf)}d=e;b.updateQueue=d;null!==d&&(b.flags|=4)}else{g=9===e.nodeType?e:e.ownerDocument;\"http://www.w3.org/1999/xhtml\"===a&&(a=kb(c));\"http://www.w3.org/1999/xhtml\"===a?\"script\"===c?(a=g.createElement(\"div\"),a.innerHTML=\"<script>\\x3c/script>\",a=a.removeChild(a.firstChild)):\n\"string\"===typeof d.is?a=g.createElement(c,{is:d.is}):(a=g.createElement(c),\"select\"===c&&(g=a,d.multiple?g.multiple=!0:d.size&&(g.size=d.size))):a=g.createElementNS(a,c);a[Of]=b;a[Pf]=d;zj(a,b,!1,!1);b.stateNode=a;a:{g=vb(c,d);switch(c){case \"dialog\":D(\"cancel\",a);D(\"close\",a);e=d;break;case \"iframe\":case \"object\":case \"embed\":D(\"load\",a);e=d;break;case \"video\":case \"audio\":for(e=0;e<lf.length;e++)D(lf[e],a);e=d;break;case \"source\":D(\"error\",a);e=d;break;case \"img\":case \"image\":case \"link\":D(\"error\",\na);D(\"load\",a);e=d;break;case \"details\":D(\"toggle\",a);e=d;break;case \"input\":Za(a,d);e=Ya(a,d);D(\"invalid\",a);break;case \"option\":e=d;break;case \"select\":a._wrapperState={wasMultiple:!!d.multiple};e=A({},d,{value:void 0});D(\"invalid\",a);break;case \"textarea\":hb(a,d);e=gb(a,d);D(\"invalid\",a);break;default:e=d}ub(c,e);h=e;for(f in h)if(h.hasOwnProperty(f)){var k=h[f];\"style\"===f?sb(a,k):\"dangerouslySetInnerHTML\"===f?(k=k?k.__html:void 0,null!=k&&nb(a,k)):\"children\"===f?\"string\"===typeof k?(\"textarea\"!==\nc||\"\"!==k)&&ob(a,k):\"number\"===typeof k&&ob(a,\"\"+k):\"suppressContentEditableWarning\"!==f&&\"suppressHydrationWarning\"!==f&&\"autoFocus\"!==f&&(ea.hasOwnProperty(f)?null!=k&&\"onScroll\"===f&&D(\"scroll\",a):null!=k&&ta(a,f,k,g))}switch(c){case \"input\":Va(a);db(a,d,!1);break;case \"textarea\":Va(a);jb(a);break;case \"option\":null!=d.value&&a.setAttribute(\"value\",\"\"+Sa(d.value));break;case \"select\":a.multiple=!!d.multiple;f=d.value;null!=f?fb(a,!!d.multiple,f,!1):null!=d.defaultValue&&fb(a,!!d.multiple,d.defaultValue,\n!0);break;default:\"function\"===typeof e.onClick&&(a.onclick=Bf)}switch(c){case \"button\":case \"input\":case \"select\":case \"textarea\":d=!!d.autoFocus;break a;case \"img\":d=!0;break a;default:d=!1}}d&&(b.flags|=4)}null!==b.ref&&(b.flags|=512,b.flags|=2097152)}S(b);return null;case 6:if(a&&null!=b.stateNode)Cj(a,b,a.memoizedProps,d);else{if(\"string\"!==typeof d&&null===b.stateNode)throw Error(p(166));c=xh(wh.current);xh(uh.current);if(Gg(b)){d=b.stateNode;c=b.memoizedProps;d[Of]=b;if(f=d.nodeValue!==c)if(a=\nxg,null!==a)switch(a.tag){case 3:Af(d.nodeValue,c,0!==(a.mode&1));break;case 5:!0!==a.memoizedProps.suppressHydrationWarning&&Af(d.nodeValue,c,0!==(a.mode&1))}f&&(b.flags|=4)}else d=(9===c.nodeType?c:c.ownerDocument).createTextNode(d),d[Of]=b,b.stateNode=d}S(b);return null;case 13:E(L);d=b.memoizedState;if(null===a||null!==a.memoizedState&&null!==a.memoizedState.dehydrated){if(I&&null!==yg&&0!==(b.mode&1)&&0===(b.flags&128))Hg(),Ig(),b.flags|=98560,f=!1;else if(f=Gg(b),null!==d&&null!==d.dehydrated){if(null===\na){if(!f)throw Error(p(318));f=b.memoizedState;f=null!==f?f.dehydrated:null;if(!f)throw Error(p(317));f[Of]=b}else Ig(),0===(b.flags&128)&&(b.memoizedState=null),b.flags|=4;S(b);f=!1}else null!==zg&&(Fj(zg),zg=null),f=!0;if(!f)return b.flags&65536?b:null}if(0!==(b.flags&128))return b.lanes=c,b;d=null!==d;d!==(null!==a&&null!==a.memoizedState)&&d&&(b.child.flags|=8192,0!==(b.mode&1)&&(null===a||0!==(L.current&1)?0===T&&(T=3):tj()));null!==b.updateQueue&&(b.flags|=4);S(b);return null;case 4:return zh(),\nAj(a,b),null===a&&sf(b.stateNode.containerInfo),S(b),null;case 10:return ah(b.type._context),S(b),null;case 17:return Zf(b.type)&&$f(),S(b),null;case 19:E(L);f=b.memoizedState;if(null===f)return S(b),null;d=0!==(b.flags&128);g=f.rendering;if(null===g)if(d)Dj(f,!1);else{if(0!==T||null!==a&&0!==(a.flags&128))for(a=b.child;null!==a;){g=Ch(a);if(null!==g){b.flags|=128;Dj(f,!1);d=g.updateQueue;null!==d&&(b.updateQueue=d,b.flags|=4);b.subtreeFlags=0;d=c;for(c=b.child;null!==c;)f=c,a=d,f.flags&=14680066,\ng=f.alternate,null===g?(f.childLanes=0,f.lanes=a,f.child=null,f.subtreeFlags=0,f.memoizedProps=null,f.memoizedState=null,f.updateQueue=null,f.dependencies=null,f.stateNode=null):(f.childLanes=g.childLanes,f.lanes=g.lanes,f.child=g.child,f.subtreeFlags=0,f.deletions=null,f.memoizedProps=g.memoizedProps,f.memoizedState=g.memoizedState,f.updateQueue=g.updateQueue,f.type=g.type,a=g.dependencies,f.dependencies=null===a?null:{lanes:a.lanes,firstContext:a.firstContext}),c=c.sibling;G(L,L.current&1|2);return b.child}a=\na.sibling}null!==f.tail&&B()>Gj&&(b.flags|=128,d=!0,Dj(f,!1),b.lanes=4194304)}else{if(!d)if(a=Ch(g),null!==a){if(b.flags|=128,d=!0,c=a.updateQueue,null!==c&&(b.updateQueue=c,b.flags|=4),Dj(f,!0),null===f.tail&&\"hidden\"===f.tailMode&&!g.alternate&&!I)return S(b),null}else 2*B()-f.renderingStartTime>Gj&&1073741824!==c&&(b.flags|=128,d=!0,Dj(f,!1),b.lanes=4194304);f.isBackwards?(g.sibling=b.child,b.child=g):(c=f.last,null!==c?c.sibling=g:b.child=g,f.last=g)}if(null!==f.tail)return b=f.tail,f.rendering=\nb,f.tail=b.sibling,f.renderingStartTime=B(),b.sibling=null,c=L.current,G(L,d?c&1|2:c&1),b;S(b);return null;case 22:case 23:return Hj(),d=null!==b.memoizedState,null!==a&&null!==a.memoizedState!==d&&(b.flags|=8192),d&&0!==(b.mode&1)?0!==(fj&1073741824)&&(S(b),b.subtreeFlags&6&&(b.flags|=8192)):S(b),null;case 24:return null;case 25:return null}throw Error(p(156,b.tag));}\nfunction Ij(a,b){wg(b);switch(b.tag){case 1:return Zf(b.type)&&$f(),a=b.flags,a&65536?(b.flags=a&-65537|128,b):null;case 3:return zh(),E(Wf),E(H),Eh(),a=b.flags,0!==(a&65536)&&0===(a&128)?(b.flags=a&-65537|128,b):null;case 5:return Bh(b),null;case 13:E(L);a=b.memoizedState;if(null!==a&&null!==a.dehydrated){if(null===b.alternate)throw Error(p(340));Ig()}a=b.flags;return a&65536?(b.flags=a&-65537|128,b):null;case 19:return E(L),null;case 4:return zh(),null;case 10:return ah(b.type._context),null;case 22:case 23:return Hj(),\nnull;case 24:return null;default:return null}}var Jj=!1,U=!1,Kj=\"function\"===typeof WeakSet?WeakSet:Set,V=null;function Lj(a,b){var c=a.ref;if(null!==c)if(\"function\"===typeof c)try{c(null)}catch(d){W(a,b,d)}else c.current=null}function Mj(a,b,c){try{c()}catch(d){W(a,b,d)}}var Nj=!1;\nfunction Oj(a,b){Cf=dd;a=Me();if(Ne(a)){if(\"selectionStart\"in a)var c={start:a.selectionStart,end:a.selectionEnd};else a:{c=(c=a.ownerDocument)&&c.defaultView||window;var d=c.getSelection&&c.getSelection();if(d&&0!==d.rangeCount){c=d.anchorNode;var e=d.anchorOffset,f=d.focusNode;d=d.focusOffset;try{c.nodeType,f.nodeType}catch(F){c=null;break a}var g=0,h=-1,k=-1,l=0,m=0,q=a,r=null;b:for(;;){for(var y;;){q!==c||0!==e&&3!==q.nodeType||(h=g+e);q!==f||0!==d&&3!==q.nodeType||(k=g+d);3===q.nodeType&&(g+=\nq.nodeValue.length);if(null===(y=q.firstChild))break;r=q;q=y}for(;;){if(q===a)break b;r===c&&++l===e&&(h=g);r===f&&++m===d&&(k=g);if(null!==(y=q.nextSibling))break;q=r;r=q.parentNode}q=y}c=-1===h||-1===k?null:{start:h,end:k}}else c=null}c=c||{start:0,end:0}}else c=null;Df={focusedElem:a,selectionRange:c};dd=!1;for(V=b;null!==V;)if(b=V,a=b.child,0!==(b.subtreeFlags&1028)&&null!==a)a.return=b,V=a;else for(;null!==V;){b=V;try{var n=b.alternate;if(0!==(b.flags&1024))switch(b.tag){case 0:case 11:case 15:break;\ncase 1:if(null!==n){var t=n.memoizedProps,J=n.memoizedState,x=b.stateNode,w=x.getSnapshotBeforeUpdate(b.elementType===b.type?t:Ci(b.type,t),J);x.__reactInternalSnapshotBeforeUpdate=w}break;case 3:var u=b.stateNode.containerInfo;1===u.nodeType?u.textContent=\"\":9===u.nodeType&&u.documentElement&&u.removeChild(u.documentElement);break;case 5:case 6:case 4:case 17:break;default:throw Error(p(163));}}catch(F){W(b,b.return,F)}a=b.sibling;if(null!==a){a.return=b.return;V=a;break}V=b.return}n=Nj;Nj=!1;return n}\nfunction Pj(a,b,c){var d=b.updateQueue;d=null!==d?d.lastEffect:null;if(null!==d){var e=d=d.next;do{if((e.tag&a)===a){var f=e.destroy;e.destroy=void 0;void 0!==f&&Mj(b,c,f)}e=e.next}while(e!==d)}}function Qj(a,b){b=b.updateQueue;b=null!==b?b.lastEffect:null;if(null!==b){var c=b=b.next;do{if((c.tag&a)===a){var d=c.create;c.destroy=d()}c=c.next}while(c!==b)}}function Rj(a){var b=a.ref;if(null!==b){var c=a.stateNode;switch(a.tag){case 5:a=c;break;default:a=c}\"function\"===typeof b?b(a):b.current=a}}\nfunction Sj(a){var b=a.alternate;null!==b&&(a.alternate=null,Sj(b));a.child=null;a.deletions=null;a.sibling=null;5===a.tag&&(b=a.stateNode,null!==b&&(delete b[Of],delete b[Pf],delete b[of],delete b[Qf],delete b[Rf]));a.stateNode=null;a.return=null;a.dependencies=null;a.memoizedProps=null;a.memoizedState=null;a.pendingProps=null;a.stateNode=null;a.updateQueue=null}function Tj(a){return 5===a.tag||3===a.tag||4===a.tag}\nfunction Uj(a){a:for(;;){for(;null===a.sibling;){if(null===a.return||Tj(a.return))return null;a=a.return}a.sibling.return=a.return;for(a=a.sibling;5!==a.tag&&6!==a.tag&&18!==a.tag;){if(a.flags&2)continue a;if(null===a.child||4===a.tag)continue a;else a.child.return=a,a=a.child}if(!(a.flags&2))return a.stateNode}}\nfunction Vj(a,b,c){var d=a.tag;if(5===d||6===d)a=a.stateNode,b?8===c.nodeType?c.parentNode.insertBefore(a,b):c.insertBefore(a,b):(8===c.nodeType?(b=c.parentNode,b.insertBefore(a,c)):(b=c,b.appendChild(a)),c=c._reactRootContainer,null!==c&&void 0!==c||null!==b.onclick||(b.onclick=Bf));else if(4!==d&&(a=a.child,null!==a))for(Vj(a,b,c),a=a.sibling;null!==a;)Vj(a,b,c),a=a.sibling}\nfunction Wj(a,b,c){var d=a.tag;if(5===d||6===d)a=a.stateNode,b?c.insertBefore(a,b):c.appendChild(a);else if(4!==d&&(a=a.child,null!==a))for(Wj(a,b,c),a=a.sibling;null!==a;)Wj(a,b,c),a=a.sibling}var X=null,Xj=!1;function Yj(a,b,c){for(c=c.child;null!==c;)Zj(a,b,c),c=c.sibling}\nfunction Zj(a,b,c){if(lc&&\"function\"===typeof lc.onCommitFiberUnmount)try{lc.onCommitFiberUnmount(kc,c)}catch(h){}switch(c.tag){case 5:U||Lj(c,b);case 6:var d=X,e=Xj;X=null;Yj(a,b,c);X=d;Xj=e;null!==X&&(Xj?(a=X,c=c.stateNode,8===a.nodeType?a.parentNode.removeChild(c):a.removeChild(c)):X.removeChild(c.stateNode));break;case 18:null!==X&&(Xj?(a=X,c=c.stateNode,8===a.nodeType?Kf(a.parentNode,c):1===a.nodeType&&Kf(a,c),bd(a)):Kf(X,c.stateNode));break;case 4:d=X;e=Xj;X=c.stateNode.containerInfo;Xj=!0;\nYj(a,b,c);X=d;Xj=e;break;case 0:case 11:case 14:case 15:if(!U&&(d=c.updateQueue,null!==d&&(d=d.lastEffect,null!==d))){e=d=d.next;do{var f=e,g=f.destroy;f=f.tag;void 0!==g&&(0!==(f&2)?Mj(c,b,g):0!==(f&4)&&Mj(c,b,g));e=e.next}while(e!==d)}Yj(a,b,c);break;case 1:if(!U&&(Lj(c,b),d=c.stateNode,\"function\"===typeof d.componentWillUnmount))try{d.props=c.memoizedProps,d.state=c.memoizedState,d.componentWillUnmount()}catch(h){W(c,b,h)}Yj(a,b,c);break;case 21:Yj(a,b,c);break;case 22:c.mode&1?(U=(d=U)||null!==\nc.memoizedState,Yj(a,b,c),U=d):Yj(a,b,c);break;default:Yj(a,b,c)}}function ak(a){var b=a.updateQueue;if(null!==b){a.updateQueue=null;var c=a.stateNode;null===c&&(c=a.stateNode=new Kj);b.forEach(function(b){var d=bk.bind(null,a,b);c.has(b)||(c.add(b),b.then(d,d))})}}\nfunction ck(a,b){var c=b.deletions;if(null!==c)for(var d=0;d<c.length;d++){var e=c[d];try{var f=a,g=b,h=g;a:for(;null!==h;){switch(h.tag){case 5:X=h.stateNode;Xj=!1;break a;case 3:X=h.stateNode.containerInfo;Xj=!0;break a;case 4:X=h.stateNode.containerInfo;Xj=!0;break a}h=h.return}if(null===X)throw Error(p(160));Zj(f,g,e);X=null;Xj=!1;var k=e.alternate;null!==k&&(k.return=null);e.return=null}catch(l){W(e,b,l)}}if(b.subtreeFlags&12854)for(b=b.child;null!==b;)dk(b,a),b=b.sibling}\nfunction dk(a,b){var c=a.alternate,d=a.flags;switch(a.tag){case 0:case 11:case 14:case 15:ck(b,a);ek(a);if(d&4){try{Pj(3,a,a.return),Qj(3,a)}catch(t){W(a,a.return,t)}try{Pj(5,a,a.return)}catch(t){W(a,a.return,t)}}break;case 1:ck(b,a);ek(a);d&512&&null!==c&&Lj(c,c.return);break;case 5:ck(b,a);ek(a);d&512&&null!==c&&Lj(c,c.return);if(a.flags&32){var e=a.stateNode;try{ob(e,\"\")}catch(t){W(a,a.return,t)}}if(d&4&&(e=a.stateNode,null!=e)){var f=a.memoizedProps,g=null!==c?c.memoizedProps:f,h=a.type,k=a.updateQueue;\na.updateQueue=null;if(null!==k)try{\"input\"===h&&\"radio\"===f.type&&null!=f.name&&ab(e,f);vb(h,g);var l=vb(h,f);for(g=0;g<k.length;g+=2){var m=k[g],q=k[g+1];\"style\"===m?sb(e,q):\"dangerouslySetInnerHTML\"===m?nb(e,q):\"children\"===m?ob(e,q):ta(e,m,q,l)}switch(h){case \"input\":bb(e,f);break;case \"textarea\":ib(e,f);break;case \"select\":var r=e._wrapperState.wasMultiple;e._wrapperState.wasMultiple=!!f.multiple;var y=f.value;null!=y?fb(e,!!f.multiple,y,!1):r!==!!f.multiple&&(null!=f.defaultValue?fb(e,!!f.multiple,\nf.defaultValue,!0):fb(e,!!f.multiple,f.multiple?[]:\"\",!1))}e[Pf]=f}catch(t){W(a,a.return,t)}}break;case 6:ck(b,a);ek(a);if(d&4){if(null===a.stateNode)throw Error(p(162));e=a.stateNode;f=a.memoizedProps;try{e.nodeValue=f}catch(t){W(a,a.return,t)}}break;case 3:ck(b,a);ek(a);if(d&4&&null!==c&&c.memoizedState.isDehydrated)try{bd(b.containerInfo)}catch(t){W(a,a.return,t)}break;case 4:ck(b,a);ek(a);break;case 13:ck(b,a);ek(a);e=a.child;e.flags&8192&&(f=null!==e.memoizedState,e.stateNode.isHidden=f,!f||\nnull!==e.alternate&&null!==e.alternate.memoizedState||(fk=B()));d&4&&ak(a);break;case 22:m=null!==c&&null!==c.memoizedState;a.mode&1?(U=(l=U)||m,ck(b,a),U=l):ck(b,a);ek(a);if(d&8192){l=null!==a.memoizedState;if((a.stateNode.isHidden=l)&&!m&&0!==(a.mode&1))for(V=a,m=a.child;null!==m;){for(q=V=m;null!==V;){r=V;y=r.child;switch(r.tag){case 0:case 11:case 14:case 15:Pj(4,r,r.return);break;case 1:Lj(r,r.return);var n=r.stateNode;if(\"function\"===typeof n.componentWillUnmount){d=r;c=r.return;try{b=d,n.props=\nb.memoizedProps,n.state=b.memoizedState,n.componentWillUnmount()}catch(t){W(d,c,t)}}break;case 5:Lj(r,r.return);break;case 22:if(null!==r.memoizedState){gk(q);continue}}null!==y?(y.return=r,V=y):gk(q)}m=m.sibling}a:for(m=null,q=a;;){if(5===q.tag){if(null===m){m=q;try{e=q.stateNode,l?(f=e.style,\"function\"===typeof f.setProperty?f.setProperty(\"display\",\"none\",\"important\"):f.display=\"none\"):(h=q.stateNode,k=q.memoizedProps.style,g=void 0!==k&&null!==k&&k.hasOwnProperty(\"display\")?k.display:null,h.style.display=\nrb(\"display\",g))}catch(t){W(a,a.return,t)}}}else if(6===q.tag){if(null===m)try{q.stateNode.nodeValue=l?\"\":q.memoizedProps}catch(t){W(a,a.return,t)}}else if((22!==q.tag&&23!==q.tag||null===q.memoizedState||q===a)&&null!==q.child){q.child.return=q;q=q.child;continue}if(q===a)break a;for(;null===q.sibling;){if(null===q.return||q.return===a)break a;m===q&&(m=null);q=q.return}m===q&&(m=null);q.sibling.return=q.return;q=q.sibling}}break;case 19:ck(b,a);ek(a);d&4&&ak(a);break;case 21:break;default:ck(b,\na),ek(a)}}function ek(a){var b=a.flags;if(b&2){try{a:{for(var c=a.return;null!==c;){if(Tj(c)){var d=c;break a}c=c.return}throw Error(p(160));}switch(d.tag){case 5:var e=d.stateNode;d.flags&32&&(ob(e,\"\"),d.flags&=-33);var f=Uj(a);Wj(a,f,e);break;case 3:case 4:var g=d.stateNode.containerInfo,h=Uj(a);Vj(a,h,g);break;default:throw Error(p(161));}}catch(k){W(a,a.return,k)}a.flags&=-3}b&4096&&(a.flags&=-4097)}function hk(a,b,c){V=a;ik(a,b,c)}\nfunction ik(a,b,c){for(var d=0!==(a.mode&1);null!==V;){var e=V,f=e.child;if(22===e.tag&&d){var g=null!==e.memoizedState||Jj;if(!g){var h=e.alternate,k=null!==h&&null!==h.memoizedState||U;h=Jj;var l=U;Jj=g;if((U=k)&&!l)for(V=e;null!==V;)g=V,k=g.child,22===g.tag&&null!==g.memoizedState?jk(e):null!==k?(k.return=g,V=k):jk(e);for(;null!==f;)V=f,ik(f,b,c),f=f.sibling;V=e;Jj=h;U=l}kk(a,b,c)}else 0!==(e.subtreeFlags&8772)&&null!==f?(f.return=e,V=f):kk(a,b,c)}}\nfunction kk(a){for(;null!==V;){var b=V;if(0!==(b.flags&8772)){var c=b.alternate;try{if(0!==(b.flags&8772))switch(b.tag){case 0:case 11:case 15:U||Qj(5,b);break;case 1:var d=b.stateNode;if(b.flags&4&&!U)if(null===c)d.componentDidMount();else{var e=b.elementType===b.type?c.memoizedProps:Ci(b.type,c.memoizedProps);d.componentDidUpdate(e,c.memoizedState,d.__reactInternalSnapshotBeforeUpdate)}var f=b.updateQueue;null!==f&&sh(b,f,d);break;case 3:var g=b.updateQueue;if(null!==g){c=null;if(null!==b.child)switch(b.child.tag){case 5:c=\nb.child.stateNode;break;case 1:c=b.child.stateNode}sh(b,g,c)}break;case 5:var h=b.stateNode;if(null===c&&b.flags&4){c=h;var k=b.memoizedProps;switch(b.type){case \"button\":case \"input\":case \"select\":case \"textarea\":k.autoFocus&&c.focus();break;case \"img\":k.src&&(c.src=k.src)}}break;case 6:break;case 4:break;case 12:break;case 13:if(null===b.memoizedState){var l=b.alternate;if(null!==l){var m=l.memoizedState;if(null!==m){var q=m.dehydrated;null!==q&&bd(q)}}}break;case 19:case 17:case 21:case 22:case 23:case 25:break;\ndefault:throw Error(p(163));}U||b.flags&512&&Rj(b)}catch(r){W(b,b.return,r)}}if(b===a){V=null;break}c=b.sibling;if(null!==c){c.return=b.return;V=c;break}V=b.return}}function gk(a){for(;null!==V;){var b=V;if(b===a){V=null;break}var c=b.sibling;if(null!==c){c.return=b.return;V=c;break}V=b.return}}\nfunction jk(a){for(;null!==V;){var b=V;try{switch(b.tag){case 0:case 11:case 15:var c=b.return;try{Qj(4,b)}catch(k){W(b,c,k)}break;case 1:var d=b.stateNode;if(\"function\"===typeof d.componentDidMount){var e=b.return;try{d.componentDidMount()}catch(k){W(b,e,k)}}var f=b.return;try{Rj(b)}catch(k){W(b,f,k)}break;case 5:var g=b.return;try{Rj(b)}catch(k){W(b,g,k)}}}catch(k){W(b,b.return,k)}if(b===a){V=null;break}var h=b.sibling;if(null!==h){h.return=b.return;V=h;break}V=b.return}}\nvar lk=Math.ceil,mk=ua.ReactCurrentDispatcher,nk=ua.ReactCurrentOwner,ok=ua.ReactCurrentBatchConfig,K=0,Q=null,Y=null,Z=0,fj=0,ej=Uf(0),T=0,pk=null,rh=0,qk=0,rk=0,sk=null,tk=null,fk=0,Gj=Infinity,uk=null,Oi=!1,Pi=null,Ri=null,vk=!1,wk=null,xk=0,yk=0,zk=null,Ak=-1,Bk=0;function R(){return 0!==(K&6)?B():-1!==Ak?Ak:Ak=B()}\nfunction yi(a){if(0===(a.mode&1))return 1;if(0!==(K&2)&&0!==Z)return Z&-Z;if(null!==Kg.transition)return 0===Bk&&(Bk=yc()),Bk;a=C;if(0!==a)return a;a=window.event;a=void 0===a?16:jd(a.type);return a}function gi(a,b,c,d){if(50<yk)throw yk=0,zk=null,Error(p(185));Ac(a,c,d);if(0===(K&2)||a!==Q)a===Q&&(0===(K&2)&&(qk|=c),4===T&&Ck(a,Z)),Dk(a,d),1===c&&0===K&&0===(b.mode&1)&&(Gj=B()+500,fg&&jg())}\nfunction Dk(a,b){var c=a.callbackNode;wc(a,b);var d=uc(a,a===Q?Z:0);if(0===d)null!==c&&bc(c),a.callbackNode=null,a.callbackPriority=0;else if(b=d&-d,a.callbackPriority!==b){null!=c&&bc(c);if(1===b)0===a.tag?ig(Ek.bind(null,a)):hg(Ek.bind(null,a)),Jf(function(){0===(K&6)&&jg()}),c=null;else{switch(Dc(d)){case 1:c=fc;break;case 4:c=gc;break;case 16:c=hc;break;case 536870912:c=jc;break;default:c=hc}c=Fk(c,Gk.bind(null,a))}a.callbackPriority=b;a.callbackNode=c}}\nfunction Gk(a,b){Ak=-1;Bk=0;if(0!==(K&6))throw Error(p(327));var c=a.callbackNode;if(Hk()&&a.callbackNode!==c)return null;var d=uc(a,a===Q?Z:0);if(0===d)return null;if(0!==(d&30)||0!==(d&a.expiredLanes)||b)b=Ik(a,d);else{b=d;var e=K;K|=2;var f=Jk();if(Q!==a||Z!==b)uk=null,Gj=B()+500,Kk(a,b);do try{Lk();break}catch(h){Mk(a,h)}while(1);$g();mk.current=f;K=e;null!==Y?b=0:(Q=null,Z=0,b=T)}if(0!==b){2===b&&(e=xc(a),0!==e&&(d=e,b=Nk(a,e)));if(1===b)throw c=pk,Kk(a,0),Ck(a,d),Dk(a,B()),c;if(6===b)Ck(a,d);\nelse{e=a.current.alternate;if(0===(d&30)&&!Ok(e)&&(b=Ik(a,d),2===b&&(f=xc(a),0!==f&&(d=f,b=Nk(a,f))),1===b))throw c=pk,Kk(a,0),Ck(a,d),Dk(a,B()),c;a.finishedWork=e;a.finishedLanes=d;switch(b){case 0:case 1:throw Error(p(345));case 2:Pk(a,tk,uk);break;case 3:Ck(a,d);if((d&130023424)===d&&(b=fk+500-B(),10<b)){if(0!==uc(a,0))break;e=a.suspendedLanes;if((e&d)!==d){R();a.pingedLanes|=a.suspendedLanes&e;break}a.timeoutHandle=Ff(Pk.bind(null,a,tk,uk),b);break}Pk(a,tk,uk);break;case 4:Ck(a,d);if((d&4194240)===\nd)break;b=a.eventTimes;for(e=-1;0<d;){var g=31-oc(d);f=1<<g;g=b[g];g>e&&(e=g);d&=~f}d=e;d=B()-d;d=(120>d?120:480>d?480:1080>d?1080:1920>d?1920:3E3>d?3E3:4320>d?4320:1960*lk(d/1960))-d;if(10<d){a.timeoutHandle=Ff(Pk.bind(null,a,tk,uk),d);break}Pk(a,tk,uk);break;case 5:Pk(a,tk,uk);break;default:throw Error(p(329));}}}Dk(a,B());return a.callbackNode===c?Gk.bind(null,a):null}\nfunction Nk(a,b){var c=sk;a.current.memoizedState.isDehydrated&&(Kk(a,b).flags|=256);a=Ik(a,b);2!==a&&(b=tk,tk=c,null!==b&&Fj(b));return a}function Fj(a){null===tk?tk=a:tk.push.apply(tk,a)}\nfunction Ok(a){for(var b=a;;){if(b.flags&16384){var c=b.updateQueue;if(null!==c&&(c=c.stores,null!==c))for(var d=0;d<c.length;d++){var e=c[d],f=e.getSnapshot;e=e.value;try{if(!He(f(),e))return!1}catch(g){return!1}}}c=b.child;if(b.subtreeFlags&16384&&null!==c)c.return=b,b=c;else{if(b===a)break;for(;null===b.sibling;){if(null===b.return||b.return===a)return!0;b=b.return}b.sibling.return=b.return;b=b.sibling}}return!0}\nfunction Ck(a,b){b&=~rk;b&=~qk;a.suspendedLanes|=b;a.pingedLanes&=~b;for(a=a.expirationTimes;0<b;){var c=31-oc(b),d=1<<c;a[c]=-1;b&=~d}}function Ek(a){if(0!==(K&6))throw Error(p(327));Hk();var b=uc(a,0);if(0===(b&1))return Dk(a,B()),null;var c=Ik(a,b);if(0!==a.tag&&2===c){var d=xc(a);0!==d&&(b=d,c=Nk(a,d))}if(1===c)throw c=pk,Kk(a,0),Ck(a,b),Dk(a,B()),c;if(6===c)throw Error(p(345));a.finishedWork=a.current.alternate;a.finishedLanes=b;Pk(a,tk,uk);Dk(a,B());return null}\nfunction Qk(a,b){var c=K;K|=1;try{return a(b)}finally{K=c,0===K&&(Gj=B()+500,fg&&jg())}}function Rk(a){null!==wk&&0===wk.tag&&0===(K&6)&&Hk();var b=K;K|=1;var c=ok.transition,d=C;try{if(ok.transition=null,C=1,a)return a()}finally{C=d,ok.transition=c,K=b,0===(K&6)&&jg()}}function Hj(){fj=ej.current;E(ej)}\nfunction Kk(a,b){a.finishedWork=null;a.finishedLanes=0;var c=a.timeoutHandle;-1!==c&&(a.timeoutHandle=-1,Gf(c));if(null!==Y)for(c=Y.return;null!==c;){var d=c;wg(d);switch(d.tag){case 1:d=d.type.childContextTypes;null!==d&&void 0!==d&&$f();break;case 3:zh();E(Wf);E(H);Eh();break;case 5:Bh(d);break;case 4:zh();break;case 13:E(L);break;case 19:E(L);break;case 10:ah(d.type._context);break;case 22:case 23:Hj()}c=c.return}Q=a;Y=a=Pg(a.current,null);Z=fj=b;T=0;pk=null;rk=qk=rh=0;tk=sk=null;if(null!==fh){for(b=\n0;b<fh.length;b++)if(c=fh[b],d=c.interleaved,null!==d){c.interleaved=null;var e=d.next,f=c.pending;if(null!==f){var g=f.next;f.next=e;d.next=g}c.pending=d}fh=null}return a}\nfunction Mk(a,b){do{var c=Y;try{$g();Fh.current=Rh;if(Ih){for(var d=M.memoizedState;null!==d;){var e=d.queue;null!==e&&(e.pending=null);d=d.next}Ih=!1}Hh=0;O=N=M=null;Jh=!1;Kh=0;nk.current=null;if(null===c||null===c.return){T=1;pk=b;Y=null;break}a:{var f=a,g=c.return,h=c,k=b;b=Z;h.flags|=32768;if(null!==k&&\"object\"===typeof k&&\"function\"===typeof k.then){var l=k,m=h,q=m.tag;if(0===(m.mode&1)&&(0===q||11===q||15===q)){var r=m.alternate;r?(m.updateQueue=r.updateQueue,m.memoizedState=r.memoizedState,\nm.lanes=r.lanes):(m.updateQueue=null,m.memoizedState=null)}var y=Ui(g);if(null!==y){y.flags&=-257;Vi(y,g,h,f,b);y.mode&1&&Si(f,l,b);b=y;k=l;var n=b.updateQueue;if(null===n){var t=new Set;t.add(k);b.updateQueue=t}else n.add(k);break a}else{if(0===(b&1)){Si(f,l,b);tj();break a}k=Error(p(426))}}else if(I&&h.mode&1){var J=Ui(g);if(null!==J){0===(J.flags&65536)&&(J.flags|=256);Vi(J,g,h,f,b);Jg(Ji(k,h));break a}}f=k=Ji(k,h);4!==T&&(T=2);null===sk?sk=[f]:sk.push(f);f=g;do{switch(f.tag){case 3:f.flags|=65536;\nb&=-b;f.lanes|=b;var x=Ni(f,k,b);ph(f,x);break a;case 1:h=k;var w=f.type,u=f.stateNode;if(0===(f.flags&128)&&(\"function\"===typeof w.getDerivedStateFromError||null!==u&&\"function\"===typeof u.componentDidCatch&&(null===Ri||!Ri.has(u)))){f.flags|=65536;b&=-b;f.lanes|=b;var F=Qi(f,h,b);ph(f,F);break a}}f=f.return}while(null!==f)}Sk(c)}catch(na){b=na;Y===c&&null!==c&&(Y=c=c.return);continue}break}while(1)}function Jk(){var a=mk.current;mk.current=Rh;return null===a?Rh:a}\nfunction tj(){if(0===T||3===T||2===T)T=4;null===Q||0===(rh&268435455)&&0===(qk&268435455)||Ck(Q,Z)}function Ik(a,b){var c=K;K|=2;var d=Jk();if(Q!==a||Z!==b)uk=null,Kk(a,b);do try{Tk();break}catch(e){Mk(a,e)}while(1);$g();K=c;mk.current=d;if(null!==Y)throw Error(p(261));Q=null;Z=0;return T}function Tk(){for(;null!==Y;)Uk(Y)}function Lk(){for(;null!==Y&&!cc();)Uk(Y)}function Uk(a){var b=Vk(a.alternate,a,fj);a.memoizedProps=a.pendingProps;null===b?Sk(a):Y=b;nk.current=null}\nfunction Sk(a){var b=a;do{var c=b.alternate;a=b.return;if(0===(b.flags&32768)){if(c=Ej(c,b,fj),null!==c){Y=c;return}}else{c=Ij(c,b);if(null!==c){c.flags&=32767;Y=c;return}if(null!==a)a.flags|=32768,a.subtreeFlags=0,a.deletions=null;else{T=6;Y=null;return}}b=b.sibling;if(null!==b){Y=b;return}Y=b=a}while(null!==b);0===T&&(T=5)}function Pk(a,b,c){var d=C,e=ok.transition;try{ok.transition=null,C=1,Wk(a,b,c,d)}finally{ok.transition=e,C=d}return null}\nfunction Wk(a,b,c,d){do Hk();while(null!==wk);if(0!==(K&6))throw Error(p(327));c=a.finishedWork;var e=a.finishedLanes;if(null===c)return null;a.finishedWork=null;a.finishedLanes=0;if(c===a.current)throw Error(p(177));a.callbackNode=null;a.callbackPriority=0;var f=c.lanes|c.childLanes;Bc(a,f);a===Q&&(Y=Q=null,Z=0);0===(c.subtreeFlags&2064)&&0===(c.flags&2064)||vk||(vk=!0,Fk(hc,function(){Hk();return null}));f=0!==(c.flags&15990);if(0!==(c.subtreeFlags&15990)||f){f=ok.transition;ok.transition=null;\nvar g=C;C=1;var h=K;K|=4;nk.current=null;Oj(a,c);dk(c,a);Oe(Df);dd=!!Cf;Df=Cf=null;a.current=c;hk(c,a,e);dc();K=h;C=g;ok.transition=f}else a.current=c;vk&&(vk=!1,wk=a,xk=e);f=a.pendingLanes;0===f&&(Ri=null);mc(c.stateNode,d);Dk(a,B());if(null!==b)for(d=a.onRecoverableError,c=0;c<b.length;c++)e=b[c],d(e.value,{componentStack:e.stack,digest:e.digest});if(Oi)throw Oi=!1,a=Pi,Pi=null,a;0!==(xk&1)&&0!==a.tag&&Hk();f=a.pendingLanes;0!==(f&1)?a===zk?yk++:(yk=0,zk=a):yk=0;jg();return null}\nfunction Hk(){if(null!==wk){var a=Dc(xk),b=ok.transition,c=C;try{ok.transition=null;C=16>a?16:a;if(null===wk)var d=!1;else{a=wk;wk=null;xk=0;if(0!==(K&6))throw Error(p(331));var e=K;K|=4;for(V=a.current;null!==V;){var f=V,g=f.child;if(0!==(V.flags&16)){var h=f.deletions;if(null!==h){for(var k=0;k<h.length;k++){var l=h[k];for(V=l;null!==V;){var m=V;switch(m.tag){case 0:case 11:case 15:Pj(8,m,f)}var q=m.child;if(null!==q)q.return=m,V=q;else for(;null!==V;){m=V;var r=m.sibling,y=m.return;Sj(m);if(m===\nl){V=null;break}if(null!==r){r.return=y;V=r;break}V=y}}}var n=f.alternate;if(null!==n){var t=n.child;if(null!==t){n.child=null;do{var J=t.sibling;t.sibling=null;t=J}while(null!==t)}}V=f}}if(0!==(f.subtreeFlags&2064)&&null!==g)g.return=f,V=g;else b:for(;null!==V;){f=V;if(0!==(f.flags&2048))switch(f.tag){case 0:case 11:case 15:Pj(9,f,f.return)}var x=f.sibling;if(null!==x){x.return=f.return;V=x;break b}V=f.return}}var w=a.current;for(V=w;null!==V;){g=V;var u=g.child;if(0!==(g.subtreeFlags&2064)&&null!==\nu)u.return=g,V=u;else b:for(g=w;null!==V;){h=V;if(0!==(h.flags&2048))try{switch(h.tag){case 0:case 11:case 15:Qj(9,h)}}catch(na){W(h,h.return,na)}if(h===g){V=null;break b}var F=h.sibling;if(null!==F){F.return=h.return;V=F;break b}V=h.return}}K=e;jg();if(lc&&\"function\"===typeof lc.onPostCommitFiberRoot)try{lc.onPostCommitFiberRoot(kc,a)}catch(na){}d=!0}return d}finally{C=c,ok.transition=b}}return!1}function Xk(a,b,c){b=Ji(c,b);b=Ni(a,b,1);a=nh(a,b,1);b=R();null!==a&&(Ac(a,1,b),Dk(a,b))}\nfunction W(a,b,c){if(3===a.tag)Xk(a,a,c);else for(;null!==b;){if(3===b.tag){Xk(b,a,c);break}else if(1===b.tag){var d=b.stateNode;if(\"function\"===typeof b.type.getDerivedStateFromError||\"function\"===typeof d.componentDidCatch&&(null===Ri||!Ri.has(d))){a=Ji(c,a);a=Qi(b,a,1);b=nh(b,a,1);a=R();null!==b&&(Ac(b,1,a),Dk(b,a));break}}b=b.return}}\nfunction Ti(a,b,c){var d=a.pingCache;null!==d&&d.delete(b);b=R();a.pingedLanes|=a.suspendedLanes&c;Q===a&&(Z&c)===c&&(4===T||3===T&&(Z&130023424)===Z&&500>B()-fk?Kk(a,0):rk|=c);Dk(a,b)}function Yk(a,b){0===b&&(0===(a.mode&1)?b=1:(b=sc,sc<<=1,0===(sc&130023424)&&(sc=4194304)));var c=R();a=ih(a,b);null!==a&&(Ac(a,b,c),Dk(a,c))}function uj(a){var b=a.memoizedState,c=0;null!==b&&(c=b.retryLane);Yk(a,c)}\nfunction bk(a,b){var c=0;switch(a.tag){case 13:var d=a.stateNode;var e=a.memoizedState;null!==e&&(c=e.retryLane);break;case 19:d=a.stateNode;break;default:throw Error(p(314));}null!==d&&d.delete(b);Yk(a,c)}var Vk;\nVk=function(a,b,c){if(null!==a)if(a.memoizedProps!==b.pendingProps||Wf.current)dh=!0;else{if(0===(a.lanes&c)&&0===(b.flags&128))return dh=!1,yj(a,b,c);dh=0!==(a.flags&131072)?!0:!1}else dh=!1,I&&0!==(b.flags&1048576)&&ug(b,ng,b.index);b.lanes=0;switch(b.tag){case 2:var d=b.type;ij(a,b);a=b.pendingProps;var e=Yf(b,H.current);ch(b,c);e=Nh(null,b,d,a,e,c);var f=Sh();b.flags|=1;\"object\"===typeof e&&null!==e&&\"function\"===typeof e.render&&void 0===e.$$typeof?(b.tag=1,b.memoizedState=null,b.updateQueue=\nnull,Zf(d)?(f=!0,cg(b)):f=!1,b.memoizedState=null!==e.state&&void 0!==e.state?e.state:null,kh(b),e.updater=Ei,b.stateNode=e,e._reactInternals=b,Ii(b,d,a,c),b=jj(null,b,d,!0,f,c)):(b.tag=0,I&&f&&vg(b),Xi(null,b,e,c),b=b.child);return b;case 16:d=b.elementType;a:{ij(a,b);a=b.pendingProps;e=d._init;d=e(d._payload);b.type=d;e=b.tag=Zk(d);a=Ci(d,a);switch(e){case 0:b=cj(null,b,d,a,c);break a;case 1:b=hj(null,b,d,a,c);break a;case 11:b=Yi(null,b,d,a,c);break a;case 14:b=$i(null,b,d,Ci(d.type,a),c);break a}throw Error(p(306,\nd,\"\"));}return b;case 0:return d=b.type,e=b.pendingProps,e=b.elementType===d?e:Ci(d,e),cj(a,b,d,e,c);case 1:return d=b.type,e=b.pendingProps,e=b.elementType===d?e:Ci(d,e),hj(a,b,d,e,c);case 3:a:{kj(b);if(null===a)throw Error(p(387));d=b.pendingProps;f=b.memoizedState;e=f.element;lh(a,b);qh(b,d,null,c);var g=b.memoizedState;d=g.element;if(f.isDehydrated)if(f={element:d,isDehydrated:!1,cache:g.cache,pendingSuspenseBoundaries:g.pendingSuspenseBoundaries,transitions:g.transitions},b.updateQueue.baseState=\nf,b.memoizedState=f,b.flags&256){e=Ji(Error(p(423)),b);b=lj(a,b,d,c,e);break a}else if(d!==e){e=Ji(Error(p(424)),b);b=lj(a,b,d,c,e);break a}else for(yg=Lf(b.stateNode.containerInfo.firstChild),xg=b,I=!0,zg=null,c=Vg(b,null,d,c),b.child=c;c;)c.flags=c.flags&-3|4096,c=c.sibling;else{Ig();if(d===e){b=Zi(a,b,c);break a}Xi(a,b,d,c)}b=b.child}return b;case 5:return Ah(b),null===a&&Eg(b),d=b.type,e=b.pendingProps,f=null!==a?a.memoizedProps:null,g=e.children,Ef(d,e)?g=null:null!==f&&Ef(d,f)&&(b.flags|=32),\ngj(a,b),Xi(a,b,g,c),b.child;case 6:return null===a&&Eg(b),null;case 13:return oj(a,b,c);case 4:return yh(b,b.stateNode.containerInfo),d=b.pendingProps,null===a?b.child=Ug(b,null,d,c):Xi(a,b,d,c),b.child;case 11:return d=b.type,e=b.pendingProps,e=b.elementType===d?e:Ci(d,e),Yi(a,b,d,e,c);case 7:return Xi(a,b,b.pendingProps,c),b.child;case 8:return Xi(a,b,b.pendingProps.children,c),b.child;case 12:return Xi(a,b,b.pendingProps.children,c),b.child;case 10:a:{d=b.type._context;e=b.pendingProps;f=b.memoizedProps;\ng=e.value;G(Wg,d._currentValue);d._currentValue=g;if(null!==f)if(He(f.value,g)){if(f.children===e.children&&!Wf.current){b=Zi(a,b,c);break a}}else for(f=b.child,null!==f&&(f.return=b);null!==f;){var h=f.dependencies;if(null!==h){g=f.child;for(var k=h.firstContext;null!==k;){if(k.context===d){if(1===f.tag){k=mh(-1,c&-c);k.tag=2;var l=f.updateQueue;if(null!==l){l=l.shared;var m=l.pending;null===m?k.next=k:(k.next=m.next,m.next=k);l.pending=k}}f.lanes|=c;k=f.alternate;null!==k&&(k.lanes|=c);bh(f.return,\nc,b);h.lanes|=c;break}k=k.next}}else if(10===f.tag)g=f.type===b.type?null:f.child;else if(18===f.tag){g=f.return;if(null===g)throw Error(p(341));g.lanes|=c;h=g.alternate;null!==h&&(h.lanes|=c);bh(g,c,b);g=f.sibling}else g=f.child;if(null!==g)g.return=f;else for(g=f;null!==g;){if(g===b){g=null;break}f=g.sibling;if(null!==f){f.return=g.return;g=f;break}g=g.return}f=g}Xi(a,b,e.children,c);b=b.child}return b;case 9:return e=b.type,d=b.pendingProps.children,ch(b,c),e=eh(e),d=d(e),b.flags|=1,Xi(a,b,d,c),\nb.child;case 14:return d=b.type,e=Ci(d,b.pendingProps),e=Ci(d.type,e),$i(a,b,d,e,c);case 15:return bj(a,b,b.type,b.pendingProps,c);case 17:return d=b.type,e=b.pendingProps,e=b.elementType===d?e:Ci(d,e),ij(a,b),b.tag=1,Zf(d)?(a=!0,cg(b)):a=!1,ch(b,c),Gi(b,d,e),Ii(b,d,e,c),jj(null,b,d,!0,a,c);case 19:return xj(a,b,c);case 22:return dj(a,b,c)}throw Error(p(156,b.tag));};function Fk(a,b){return ac(a,b)}\nfunction $k(a,b,c,d){this.tag=a;this.key=c;this.sibling=this.child=this.return=this.stateNode=this.type=this.elementType=null;this.index=0;this.ref=null;this.pendingProps=b;this.dependencies=this.memoizedState=this.updateQueue=this.memoizedProps=null;this.mode=d;this.subtreeFlags=this.flags=0;this.deletions=null;this.childLanes=this.lanes=0;this.alternate=null}function Bg(a,b,c,d){return new $k(a,b,c,d)}function aj(a){a=a.prototype;return!(!a||!a.isReactComponent)}\nfunction Zk(a){if(\"function\"===typeof a)return aj(a)?1:0;if(void 0!==a&&null!==a){a=a.$$typeof;if(a===Da)return 11;if(a===Ga)return 14}return 2}\nfunction Pg(a,b){var c=a.alternate;null===c?(c=Bg(a.tag,b,a.key,a.mode),c.elementType=a.elementType,c.type=a.type,c.stateNode=a.stateNode,c.alternate=a,a.alternate=c):(c.pendingProps=b,c.type=a.type,c.flags=0,c.subtreeFlags=0,c.deletions=null);c.flags=a.flags&14680064;c.childLanes=a.childLanes;c.lanes=a.lanes;c.child=a.child;c.memoizedProps=a.memoizedProps;c.memoizedState=a.memoizedState;c.updateQueue=a.updateQueue;b=a.dependencies;c.dependencies=null===b?null:{lanes:b.lanes,firstContext:b.firstContext};\nc.sibling=a.sibling;c.index=a.index;c.ref=a.ref;return c}\nfunction Rg(a,b,c,d,e,f){var g=2;d=a;if(\"function\"===typeof a)aj(a)&&(g=1);else if(\"string\"===typeof a)g=5;else a:switch(a){case ya:return Tg(c.children,e,f,b);case za:g=8;e|=8;break;case Aa:return a=Bg(12,c,b,e|2),a.elementType=Aa,a.lanes=f,a;case Ea:return a=Bg(13,c,b,e),a.elementType=Ea,a.lanes=f,a;case Fa:return a=Bg(19,c,b,e),a.elementType=Fa,a.lanes=f,a;case Ia:return pj(c,e,f,b);default:if(\"object\"===typeof a&&null!==a)switch(a.$$typeof){case Ba:g=10;break a;case Ca:g=9;break a;case Da:g=11;\nbreak a;case Ga:g=14;break a;case Ha:g=16;d=null;break a}throw Error(p(130,null==a?a:typeof a,\"\"));}b=Bg(g,c,b,e);b.elementType=a;b.type=d;b.lanes=f;return b}function Tg(a,b,c,d){a=Bg(7,a,d,b);a.lanes=c;return a}function pj(a,b,c,d){a=Bg(22,a,d,b);a.elementType=Ia;a.lanes=c;a.stateNode={isHidden:!1};return a}function Qg(a,b,c){a=Bg(6,a,null,b);a.lanes=c;return a}\nfunction Sg(a,b,c){b=Bg(4,null!==a.children?a.children:[],a.key,b);b.lanes=c;b.stateNode={containerInfo:a.containerInfo,pendingChildren:null,implementation:a.implementation};return b}\nfunction al(a,b,c,d,e){this.tag=b;this.containerInfo=a;this.finishedWork=this.pingCache=this.current=this.pendingChildren=null;this.timeoutHandle=-1;this.callbackNode=this.pendingContext=this.context=null;this.callbackPriority=0;this.eventTimes=zc(0);this.expirationTimes=zc(-1);this.entangledLanes=this.finishedLanes=this.mutableReadLanes=this.expiredLanes=this.pingedLanes=this.suspendedLanes=this.pendingLanes=0;this.entanglements=zc(0);this.identifierPrefix=d;this.onRecoverableError=e;this.mutableSourceEagerHydrationData=\nnull}function bl(a,b,c,d,e,f,g,h,k){a=new al(a,b,c,h,k);1===b?(b=1,!0===f&&(b|=8)):b=0;f=Bg(3,null,null,b);a.current=f;f.stateNode=a;f.memoizedState={element:d,isDehydrated:c,cache:null,transitions:null,pendingSuspenseBoundaries:null};kh(f);return a}function cl(a,b,c){var d=3<arguments.length&&void 0!==arguments[3]?arguments[3]:null;return{$$typeof:wa,key:null==d?null:\"\"+d,children:a,containerInfo:b,implementation:c}}\nfunction dl(a){if(!a)return Vf;a=a._reactInternals;a:{if(Vb(a)!==a||1!==a.tag)throw Error(p(170));var b=a;do{switch(b.tag){case 3:b=b.stateNode.context;break a;case 1:if(Zf(b.type)){b=b.stateNode.__reactInternalMemoizedMergedChildContext;break a}}b=b.return}while(null!==b);throw Error(p(171));}if(1===a.tag){var c=a.type;if(Zf(c))return bg(a,c,b)}return b}\nfunction el(a,b,c,d,e,f,g,h,k){a=bl(c,d,!0,a,e,f,g,h,k);a.context=dl(null);c=a.current;d=R();e=yi(c);f=mh(d,e);f.callback=void 0!==b&&null!==b?b:null;nh(c,f,e);a.current.lanes=e;Ac(a,e,d);Dk(a,d);return a}function fl(a,b,c,d){var e=b.current,f=R(),g=yi(e);c=dl(c);null===b.context?b.context=c:b.pendingContext=c;b=mh(f,g);b.payload={element:a};d=void 0===d?null:d;null!==d&&(b.callback=d);a=nh(e,b,g);null!==a&&(gi(a,e,g,f),oh(a,e,g));return g}\nfunction gl(a){a=a.current;if(!a.child)return null;switch(a.child.tag){case 5:return a.child.stateNode;default:return a.child.stateNode}}function hl(a,b){a=a.memoizedState;if(null!==a&&null!==a.dehydrated){var c=a.retryLane;a.retryLane=0!==c&&c<b?c:b}}function il(a,b){hl(a,b);(a=a.alternate)&&hl(a,b)}function jl(){return null}var kl=\"function\"===typeof reportError?reportError:function(a){console.error(a)};function ll(a){this._internalRoot=a}\nml.prototype.render=ll.prototype.render=function(a){var b=this._internalRoot;if(null===b)throw Error(p(409));fl(a,b,null,null)};ml.prototype.unmount=ll.prototype.unmount=function(){var a=this._internalRoot;if(null!==a){this._internalRoot=null;var b=a.containerInfo;Rk(function(){fl(null,a,null,null)});b[uf]=null}};function ml(a){this._internalRoot=a}\nml.prototype.unstable_scheduleHydration=function(a){if(a){var b=Hc();a={blockedOn:null,target:a,priority:b};for(var c=0;c<Qc.length&&0!==b&&b<Qc[c].priority;c++);Qc.splice(c,0,a);0===c&&Vc(a)}};function nl(a){return!(!a||1!==a.nodeType&&9!==a.nodeType&&11!==a.nodeType)}function ol(a){return!(!a||1!==a.nodeType&&9!==a.nodeType&&11!==a.nodeType&&(8!==a.nodeType||\" react-mount-point-unstable \"!==a.nodeValue))}function pl(){}\nfunction ql(a,b,c,d,e){if(e){if(\"function\"===typeof d){var f=d;d=function(){var a=gl(g);f.call(a)}}var g=el(b,d,a,0,null,!1,!1,\"\",pl);a._reactRootContainer=g;a[uf]=g.current;sf(8===a.nodeType?a.parentNode:a);Rk();return g}for(;e=a.lastChild;)a.removeChild(e);if(\"function\"===typeof d){var h=d;d=function(){var a=gl(k);h.call(a)}}var k=bl(a,0,!1,null,null,!1,!1,\"\",pl);a._reactRootContainer=k;a[uf]=k.current;sf(8===a.nodeType?a.parentNode:a);Rk(function(){fl(b,k,c,d)});return k}\nfunction rl(a,b,c,d,e){var f=c._reactRootContainer;if(f){var g=f;if(\"function\"===typeof e){var h=e;e=function(){var a=gl(g);h.call(a)}}fl(b,g,a,e)}else g=ql(c,b,a,e,d);return gl(g)}Ec=function(a){switch(a.tag){case 3:var b=a.stateNode;if(b.current.memoizedState.isDehydrated){var c=tc(b.pendingLanes);0!==c&&(Cc(b,c|1),Dk(b,B()),0===(K&6)&&(Gj=B()+500,jg()))}break;case 13:Rk(function(){var b=ih(a,1);if(null!==b){var c=R();gi(b,a,1,c)}}),il(a,1)}};\nFc=function(a){if(13===a.tag){var b=ih(a,134217728);if(null!==b){var c=R();gi(b,a,134217728,c)}il(a,134217728)}};Gc=function(a){if(13===a.tag){var b=yi(a),c=ih(a,b);if(null!==c){var d=R();gi(c,a,b,d)}il(a,b)}};Hc=function(){return C};Ic=function(a,b){var c=C;try{return C=a,b()}finally{C=c}};\nyb=function(a,b,c){switch(b){case \"input\":bb(a,c);b=c.name;if(\"radio\"===c.type&&null!=b){for(c=a;c.parentNode;)c=c.parentNode;c=c.querySelectorAll(\"input[name=\"+JSON.stringify(\"\"+b)+'][type=\"radio\"]');for(b=0;b<c.length;b++){var d=c[b];if(d!==a&&d.form===a.form){var e=Db(d);if(!e)throw Error(p(90));Wa(d);bb(d,e)}}}break;case \"textarea\":ib(a,c);break;case \"select\":b=c.value,null!=b&&fb(a,!!c.multiple,b,!1)}};Gb=Qk;Hb=Rk;\nvar sl={usingClientEntryPoint:!1,Events:[Cb,ue,Db,Eb,Fb,Qk]},tl={findFiberByHostInstance:Wc,bundleType:0,version:\"18.3.1\",rendererPackageName:\"react-dom\"};\nvar ul={bundleType:tl.bundleType,version:tl.version,rendererPackageName:tl.rendererPackageName,rendererConfig:tl.rendererConfig,overrideHookState:null,overrideHookStateDeletePath:null,overrideHookStateRenamePath:null,overrideProps:null,overridePropsDeletePath:null,overridePropsRenamePath:null,setErrorHandler:null,setSuspenseHandler:null,scheduleUpdate:null,currentDispatcherRef:ua.ReactCurrentDispatcher,findHostInstanceByFiber:function(a){a=Zb(a);return null===a?null:a.stateNode},findFiberByHostInstance:tl.findFiberByHostInstance||\njl,findHostInstancesForRefresh:null,scheduleRefresh:null,scheduleRoot:null,setRefreshHandler:null,getCurrentFiber:null,reconcilerVersion:\"18.3.1-next-f1338f8080-20240426\"};if(\"undefined\"!==typeof __REACT_DEVTOOLS_GLOBAL_HOOK__){var vl=__REACT_DEVTOOLS_GLOBAL_HOOK__;if(!vl.isDisabled&&vl.supportsFiber)try{kc=vl.inject(ul),lc=vl}catch(a){}}exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED=sl;\nexports.createPortal=function(a,b){var c=2<arguments.length&&void 0!==arguments[2]?arguments[2]:null;if(!nl(b))throw Error(p(200));return cl(a,b,null,c)};exports.createRoot=function(a,b){if(!nl(a))throw Error(p(299));var c=!1,d=\"\",e=kl;null!==b&&void 0!==b&&(!0===b.unstable_strictMode&&(c=!0),void 0!==b.identifierPrefix&&(d=b.identifierPrefix),void 0!==b.onRecoverableError&&(e=b.onRecoverableError));b=bl(a,1,!1,null,null,c,!1,d,e);a[uf]=b.current;sf(8===a.nodeType?a.parentNode:a);return new ll(b)};\nexports.findDOMNode=function(a){if(null==a)return null;if(1===a.nodeType)return a;var b=a._reactInternals;if(void 0===b){if(\"function\"===typeof a.render)throw Error(p(188));a=Object.keys(a).join(\",\");throw Error(p(268,a));}a=Zb(b);a=null===a?null:a.stateNode;return a};exports.flushSync=function(a){return Rk(a)};exports.hydrate=function(a,b,c){if(!ol(b))throw Error(p(200));return rl(null,a,b,!0,c)};\nexports.hydrateRoot=function(a,b,c){if(!nl(a))throw Error(p(405));var d=null!=c&&c.hydratedSources||null,e=!1,f=\"\",g=kl;null!==c&&void 0!==c&&(!0===c.unstable_strictMode&&(e=!0),void 0!==c.identifierPrefix&&(f=c.identifierPrefix),void 0!==c.onRecoverableError&&(g=c.onRecoverableError));b=el(b,null,a,1,null!=c?c:null,e,!1,f,g);a[uf]=b.current;sf(a);if(d)for(a=0;a<d.length;a++)c=d[a],e=c._getVersion,e=e(c._source),null==b.mutableSourceEagerHydrationData?b.mutableSourceEagerHydrationData=[c,e]:b.mutableSourceEagerHydrationData.push(c,\ne);return new ml(b)};exports.render=function(a,b,c){if(!ol(b))throw Error(p(200));return rl(null,a,b,!1,c)};exports.unmountComponentAtNode=function(a){if(!ol(a))throw Error(p(40));return a._reactRootContainer?(Rk(function(){rl(null,null,a,!1,function(){a._reactRootContainer=null;a[uf]=null})}),!0):!1};exports.unstable_batchedUpdates=Qk;\nexports.unstable_renderSubtreeIntoContainer=function(a,b,c,d){if(!ol(c))throw Error(p(200));if(null==a||void 0===a._reactInternals)throw Error(p(38));return rl(a,b,c,!1,d)};exports.version=\"18.3.1-next-f1338f8080-20240426\";\n","'use strict';\n\nvar m = require('react-dom');\nif (process.env.NODE_ENV === 'production') {\n  exports.createRoot = m.createRoot;\n  exports.hydrateRoot = m.hydrateRoot;\n} else {\n  var i = m.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;\n  exports.createRoot = function(c, o) {\n    i.usingClientEntryPoint = true;\n    try {\n      return m.createRoot(c, o);\n    } finally {\n      i.usingClientEntryPoint = false;\n    }\n  };\n  exports.hydrateRoot = function(c, h, o) {\n    i.usingClientEntryPoint = true;\n    try {\n      return m.hydrateRoot(c, h, o);\n    } finally {\n      i.usingClientEntryPoint = false;\n    }\n  };\n}\n","'use strict';\n\nfunction checkDCE() {\n  /* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */\n  if (\n    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ === 'undefined' ||\n    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE !== 'function'\n  ) {\n    return;\n  }\n  if (process.env.NODE_ENV !== 'production') {\n    // This branch is unreachable because this function is only called\n    // in production, but the condition is true only in development.\n    // Therefore if the branch is still here, dead code elimination wasn't\n    // properly applied.\n    // Don't change the message. React DevTools relies on it. Also make sure\n    // this message doesn't occur elsewhere in this function, or it will cause\n    // a false positive.\n    throw new Error('^_^');\n  }\n  try {\n    // Verify that the code above has been dead code eliminated (DCE'd).\n    __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE(checkDCE);\n  } catch (err) {\n    // DevTools shouldn't crash React, no matter what.\n    // We should still report in case we break this code.\n    console.error(err);\n  }\n}\n\nif (process.env.NODE_ENV === 'production') {\n  // DCE check should happen before ReactDOM bundle executes so that\n  // DevTools can report bad minification during injection.\n  checkDCE();\n  module.exports = require('./cjs/react-dom.production.min.js');\n} else {\n  module.exports = require('./cjs/react-dom.development.js');\n}\n","/**\n * defines a focus group\n */\nexport var FOCUS_GROUP = 'data-focus-lock';\n/**\n * disables element discovery inside a group marked by key\n */\nexport var FOCUS_DISABLED = 'data-focus-lock-disabled';\n/**\n * allows uncontrolled focus within the marked area, effectively disabling focus lock for it's content\n */\nexport var FOCUS_ALLOW = 'data-no-focus-lock';\n/**\n * instructs autofocus engine to pick default autofocus inside a given node\n * can be set on the element or container\n */\nexport var FOCUS_AUTO = 'data-autofocus-inside';\n/**\n * instructs autofocus to ignore elements within a given node\n * can be set on the element or container\n */\nexport var FOCUS_NO_AUTOFOCUS = 'data-no-autofocus';\n","/**\n * Assigns a value for a given ref, no matter of the ref format\n * @param {RefObject} ref - a callback function or ref object\n * @param value - a new value\n *\n * @see https://github.com/theKashey/use-callback-ref#assignref\n * @example\n * const refObject = useRef();\n * const refFn = (ref) => {....}\n *\n * assignRef(refObject, \"refValue\");\n * assignRef(refFn, \"refValue\");\n */\nexport function assignRef(ref, value) {\n    if (typeof ref === 'function') {\n        ref(value);\n    }\n    else if (ref) {\n        ref.current = value;\n    }\n    return ref;\n}\n","import * as React from 'react';\nimport { assignRef } from './assignRef';\nimport { useCallbackRef } from './useRef';\nvar useIsomorphicLayoutEffect = typeof window !== 'undefined' ? React.useLayoutEffect : React.useEffect;\nvar currentValues = new WeakMap();\n/**\n * Merges two or more refs together providing a single interface to set their value\n * @param {RefObject|Ref} refs\n * @returns {MutableRefObject} - a new ref, which translates all changes to {refs}\n *\n * @see {@link mergeRefs} a version without buit-in memoization\n * @see https://github.com/theKashey/use-callback-ref#usemergerefs\n * @example\n * const Component = React.forwardRef((props, ref) => {\n *   const ownRef = useRef();\n *   const domRef = useMergeRefs([ref, ownRef]); // 👈 merge together\n *   return <div ref={domRef}>...</div>\n * }\n */\nexport function useMergeRefs(refs, defaultValue) {\n    var callbackRef = useCallbackRef(defaultValue || null, function (newValue) {\n        return refs.forEach(function (ref) { return assignRef(ref, newValue); });\n    });\n    // handle refs changes - added or removed\n    useIsomorphicLayoutEffect(function () {\n        var oldValue = currentValues.get(callbackRef);\n        if (oldValue) {\n            var prevRefs_1 = new Set(oldValue);\n            var nextRefs_1 = new Set(refs);\n            var current_1 = callbackRef.current;\n            prevRefs_1.forEach(function (ref) {\n                if (!nextRefs_1.has(ref)) {\n                    assignRef(ref, null);\n                }\n            });\n            nextRefs_1.forEach(function (ref) {\n                if (!prevRefs_1.has(ref)) {\n                    assignRef(ref, current_1);\n                }\n            });\n        }\n        currentValues.set(callbackRef, refs);\n    }, [refs]);\n    return callbackRef;\n}\n","import { useState } from 'react';\n/**\n * creates a MutableRef with ref change callback\n * @param initialValue - initial ref value\n * @param {Function} callback - a callback to run when value changes\n *\n * @example\n * const ref = useCallbackRef(0, (newValue, oldValue) => console.log(oldValue, '->', newValue);\n * ref.current = 1;\n * // prints 0 -> 1\n *\n * @see https://reactjs.org/docs/hooks-reference.html#useref\n * @see https://github.com/theKashey/use-callback-ref#usecallbackref---to-replace-reactuseref\n * @returns {MutableRefObject}\n */\nexport function useCallbackRef(initialValue, callback) {\n    var ref = useState(function () { return ({\n        // value\n        value: initialValue,\n        // last callback\n        callback: callback,\n        // \"memoized\" public interface\n        facade: {\n            get current() {\n                return ref.value;\n            },\n            set current(value) {\n                var last = ref.value;\n                if (last !== value) {\n                    ref.value = value;\n                    ref.callback(value, last);\n                }\n            },\n        },\n    }); })[0];\n    // update callback\n    ref.callback = callback;\n    return ref.facade;\n}\n","import React, { Fragment } from 'react';\nimport PropTypes from 'prop-types';\nexport var hiddenGuard = {\n  width: '1px',\n  height: '0px',\n  padding: 0,\n  overflow: 'hidden',\n  position: 'fixed',\n  top: '1px',\n  left: '1px'\n};\nvar InFocusGuard = function InFocusGuard(_ref) {\n  var _ref$children = _ref.children,\n    children = _ref$children === void 0 ? null : _ref$children;\n  return /*#__PURE__*/React.createElement(Fragment, null, /*#__PURE__*/React.createElement(\"div\", {\n    key: \"guard-first\",\n    \"data-focus-guard\": true,\n    \"data-focus-auto-guard\": true,\n    style: hiddenGuard\n  }), children, children && /*#__PURE__*/React.createElement(\"div\", {\n    key: \"guard-last\",\n    \"data-focus-guard\": true,\n    \"data-focus-auto-guard\": true,\n    style: hiddenGuard\n  }));\n};\nInFocusGuard.propTypes = process.env.NODE_ENV !== \"production\" ? {\n  children: PropTypes.node\n} : {};\nexport default InFocusGuard;","import { createMedium, createSidecarMedium } from 'use-sidecar';\nexport var mediumFocus = createMedium({}, function (_ref) {\n  var target = _ref.target,\n    currentTarget = _ref.currentTarget;\n  return {\n    target: target,\n    currentTarget: currentTarget\n  };\n});\nexport var mediumBlur = createMedium();\nexport var mediumEffect = createMedium();\nexport var mediumSidecar = createSidecarMedium({\n  async: true,\n  ssr: typeof document !== 'undefined'\n});","import { createContext } from 'react';\nexport var focusScope = /*#__PURE__*/createContext(undefined);","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport React, { forwardRef, useRef, useState, useCallback, useEffect, useMemo, Fragment } from 'react';\nimport { node, bool, string, any, arrayOf, oneOfType, object, func } from 'prop-types';\nimport { FOCUS_DISABLED, FOCUS_GROUP } from 'focus-lock/constants';\nimport { useMergeRefs } from 'use-callback-ref';\nimport { hiddenGuard } from './FocusGuard';\nimport { mediumFocus, mediumBlur, mediumSidecar } from './medium';\nimport { focusScope } from './scope';\nvar emptyArray = [];\nvar FocusLock = /*#__PURE__*/forwardRef(function FocusLockUI(props, parentRef) {\n  var _extends2;\n  var _useState = useState(),\n    realObserved = _useState[0],\n    setObserved = _useState[1];\n  var observed = useRef();\n  var isActive = useRef(false);\n  var originalFocusedElement = useRef(null);\n  var _useState2 = useState({}),\n    update = _useState2[1];\n  var children = props.children,\n    _props$disabled = props.disabled,\n    disabled = _props$disabled === void 0 ? false : _props$disabled,\n    _props$noFocusGuards = props.noFocusGuards,\n    noFocusGuards = _props$noFocusGuards === void 0 ? false : _props$noFocusGuards,\n    _props$persistentFocu = props.persistentFocus,\n    persistentFocus = _props$persistentFocu === void 0 ? false : _props$persistentFocu,\n    _props$crossFrame = props.crossFrame,\n    crossFrame = _props$crossFrame === void 0 ? true : _props$crossFrame,\n    _props$autoFocus = props.autoFocus,\n    autoFocus = _props$autoFocus === void 0 ? true : _props$autoFocus,\n    allowTextSelection = props.allowTextSelection,\n    group = props.group,\n    className = props.className,\n    whiteList = props.whiteList,\n    hasPositiveIndices = props.hasPositiveIndices,\n    _props$shards = props.shards,\n    shards = _props$shards === void 0 ? emptyArray : _props$shards,\n    _props$as = props.as,\n    Container = _props$as === void 0 ? 'div' : _props$as,\n    _props$lockProps = props.lockProps,\n    containerProps = _props$lockProps === void 0 ? {} : _props$lockProps,\n    SideCar = props.sideCar,\n    _props$returnFocus = props.returnFocus,\n    shouldReturnFocus = _props$returnFocus === void 0 ? false : _props$returnFocus,\n    focusOptions = props.focusOptions,\n    onActivationCallback = props.onActivation,\n    onDeactivationCallback = props.onDeactivation;\n  var _useState3 = useState({}),\n    id = _useState3[0];\n  var onActivation = useCallback(function (_ref) {\n    var captureFocusRestore = _ref.captureFocusRestore;\n    if (!originalFocusedElement.current) {\n      var _document;\n      var activeElement = (_document = document) == null ? void 0 : _document.activeElement;\n      originalFocusedElement.current = activeElement;\n      if (activeElement !== document.body) {\n        originalFocusedElement.current = captureFocusRestore(activeElement);\n      }\n    }\n    if (observed.current && onActivationCallback) {\n      onActivationCallback(observed.current);\n    }\n    isActive.current = true;\n    update();\n  }, [onActivationCallback]);\n  var onDeactivation = useCallback(function () {\n    isActive.current = false;\n    if (onDeactivationCallback) {\n      onDeactivationCallback(observed.current);\n    }\n    update();\n  }, [onDeactivationCallback]);\n  var returnFocus = useCallback(function (allowDefer) {\n    var focusRestore = originalFocusedElement.current;\n    if (focusRestore) {\n      var returnFocusTo = (typeof focusRestore === 'function' ? focusRestore() : focusRestore) || document.body;\n      var howToReturnFocus = typeof shouldReturnFocus === 'function' ? shouldReturnFocus(returnFocusTo) : shouldReturnFocus;\n      if (howToReturnFocus) {\n        var returnFocusOptions = typeof howToReturnFocus === 'object' ? howToReturnFocus : undefined;\n        originalFocusedElement.current = null;\n        if (allowDefer) {\n          Promise.resolve().then(function () {\n            return returnFocusTo.focus(returnFocusOptions);\n          });\n        } else {\n          returnFocusTo.focus(returnFocusOptions);\n        }\n      }\n    }\n  }, [shouldReturnFocus]);\n  var onFocus = useCallback(function (event) {\n    if (isActive.current) {\n      mediumFocus.useMedium(event);\n    }\n  }, []);\n  var onBlur = mediumBlur.useMedium;\n  var setObserveNode = useCallback(function (newObserved) {\n    if (observed.current !== newObserved) {\n      observed.current = newObserved;\n      setObserved(newObserved);\n    }\n  }, []);\n  if (process.env.NODE_ENV !== 'production') {\n    if (typeof allowTextSelection !== 'undefined') {\n      console.warn('React-Focus-Lock: allowTextSelection is deprecated and enabled by default');\n    }\n    useEffect(function () {\n      if (!observed.current && typeof Container !== 'string') {\n        console.error('FocusLock: could not obtain ref to internal node');\n      }\n    }, []);\n  }\n  var lockProps = _extends((_extends2 = {}, _extends2[FOCUS_DISABLED] = disabled && 'disabled', _extends2[FOCUS_GROUP] = group, _extends2), containerProps);\n  var hasLeadingGuards = noFocusGuards !== true;\n  var hasTailingGuards = hasLeadingGuards && noFocusGuards !== 'tail';\n  var mergedRef = useMergeRefs([parentRef, setObserveNode]);\n  var focusScopeValue = useMemo(function () {\n    return {\n      observed: observed,\n      shards: shards,\n      enabled: !disabled,\n      active: isActive.current\n    };\n  }, [disabled, isActive.current, shards, realObserved]);\n  return /*#__PURE__*/React.createElement(Fragment, null, hasLeadingGuards && [\n  /*#__PURE__*/\n  React.createElement(\"div\", {\n    key: \"guard-first\",\n    \"data-focus-guard\": true,\n    tabIndex: disabled ? -1 : 0,\n    style: hiddenGuard\n  }), hasPositiveIndices ? /*#__PURE__*/React.createElement(\"div\", {\n    key: \"guard-nearest\",\n    \"data-focus-guard\": true,\n    tabIndex: disabled ? -1 : 1,\n    style: hiddenGuard\n  }) : null], !disabled && /*#__PURE__*/React.createElement(SideCar, {\n    id: id,\n    sideCar: mediumSidecar,\n    observed: realObserved,\n    disabled: disabled,\n    persistentFocus: persistentFocus,\n    crossFrame: crossFrame,\n    autoFocus: autoFocus,\n    whiteList: whiteList,\n    shards: shards,\n    onActivation: onActivation,\n    onDeactivation: onDeactivation,\n    returnFocus: returnFocus,\n    focusOptions: focusOptions,\n    noFocusGuards: noFocusGuards\n  }), /*#__PURE__*/React.createElement(Container, _extends({\n    ref: mergedRef\n  }, lockProps, {\n    className: className,\n    onBlur: onBlur,\n    onFocus: onFocus\n  }), /*#__PURE__*/React.createElement(focusScope.Provider, {\n    value: focusScopeValue\n  }, children)), hasTailingGuards && /*#__PURE__*/React.createElement(\"div\", {\n    \"data-focus-guard\": true,\n    tabIndex: disabled ? -1 : 0,\n    style: hiddenGuard\n  }));\n});\nFocusLock.propTypes = process.env.NODE_ENV !== \"production\" ? {\n  children: node,\n  disabled: bool,\n  returnFocus: oneOfType([bool, object, func]),\n  focusOptions: object,\n  noFocusGuards: bool,\n  hasPositiveIndices: bool,\n  allowTextSelection: bool,\n  autoFocus: bool,\n  persistentFocus: bool,\n  crossFrame: bool,\n  group: string,\n  className: string,\n  whiteList: func,\n  shards: arrayOf(any),\n  as: oneOfType([string, func, object]),\n  lockProps: object,\n  onActivation: func,\n  onDeactivation: func,\n  sideCar: any.isRequired\n} : {};\nexport default FocusLock;","import _inheritsLoose from '@babel/runtime/helpers/esm/inheritsLoose';\nimport _defineProperty from '@babel/runtime/helpers/esm/defineProperty';\nimport React, { PureComponent } from 'react';\n\nfunction withSideEffect(reducePropsToState, handleStateChangeOnClient) {\n  if (process.env.NODE_ENV !== \"production\") {\n    if (typeof reducePropsToState !== 'function') {\n      throw new Error('Expected reducePropsToState to be a function.');\n    }\n\n    if (typeof handleStateChangeOnClient !== 'function') {\n      throw new Error('Expected handleStateChangeOnClient to be a function.');\n    }\n  }\n\n  function getDisplayName(WrappedComponent) {\n    return WrappedComponent.displayName || WrappedComponent.name || 'Component';\n  }\n\n  return function wrap(WrappedComponent) {\n    if (process.env.NODE_ENV !== \"production\") {\n      if (typeof WrappedComponent !== 'function') {\n        throw new Error('Expected WrappedComponent to be a React component.');\n      }\n    }\n\n    var mountedInstances = [];\n    var state;\n\n    function emitChange() {\n      state = reducePropsToState(mountedInstances.map(function (instance) {\n        return instance.props;\n      }));\n      handleStateChangeOnClient(state);\n    }\n\n    var SideEffect = /*#__PURE__*/function (_PureComponent) {\n      _inheritsLoose(SideEffect, _PureComponent);\n\n      function SideEffect() {\n        return _PureComponent.apply(this, arguments) || this;\n      }\n\n      // Try to use displayName of wrapped component\n      SideEffect.peek = function peek() {\n        return state;\n      };\n\n      var _proto = SideEffect.prototype;\n\n      _proto.componentDidMount = function componentDidMount() {\n        mountedInstances.push(this);\n        emitChange();\n      };\n\n      _proto.componentDidUpdate = function componentDidUpdate() {\n        emitChange();\n      };\n\n      _proto.componentWillUnmount = function componentWillUnmount() {\n        var index = mountedInstances.indexOf(this);\n        mountedInstances.splice(index, 1);\n        emitChange();\n      };\n\n      _proto.render = function render() {\n        return /*#__PURE__*/React.createElement(WrappedComponent, this.props);\n      };\n\n      return SideEffect;\n    }(PureComponent);\n\n    _defineProperty(SideEffect, \"displayName\", \"SideEffect(\" + getDisplayName(WrappedComponent) + \")\");\n\n    return SideEffect;\n  };\n}\n\nexport default withSideEffect;\n","/*\nIE11 support\n */\nexport var toArray = function (a) {\n    var ret = Array(a.length);\n    for (var i = 0; i < a.length; ++i) {\n        ret[i] = a[i];\n    }\n    return ret;\n};\nexport var asArray = function (a) { return (Array.isArray(a) ? a : [a]); };\nexport var getFirst = function (a) { return (Array.isArray(a) ? a[0] : a); };\n","import { FOCUS_NO_AUTOFOCUS } from '../constants';\nvar isElementHidden = function (node) {\n    // we can measure only \"elements\"\n    // consider others as \"visible\"\n    if (node.nodeType !== Node.ELEMENT_NODE) {\n        return false;\n    }\n    var computedStyle = window.getComputedStyle(node, null);\n    if (!computedStyle || !computedStyle.getPropertyValue) {\n        return false;\n    }\n    return (computedStyle.getPropertyValue('display') === 'none' || computedStyle.getPropertyValue('visibility') === 'hidden');\n};\nvar getParentNode = function (node) {\n    // DOCUMENT_FRAGMENT_NODE can also point on ShadowRoot. In this case .host will point on the next node\n    return node.parentNode && node.parentNode.nodeType === Node.DOCUMENT_FRAGMENT_NODE\n        ? // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            node.parentNode.host\n        : node.parentNode;\n};\nvar isTopNode = function (node) {\n    // @ts-ignore\n    return node === document || (node && node.nodeType === Node.DOCUMENT_NODE);\n};\nvar isInert = function (node) { return node.hasAttribute('inert'); };\n/**\n * @see https://github.com/testing-library/jest-dom/blob/main/src/to-be-visible.js\n */\nvar isVisibleUncached = function (node, checkParent) {\n    return !node || isTopNode(node) || (!isElementHidden(node) && !isInert(node) && checkParent(getParentNode(node)));\n};\nexport var isVisibleCached = function (visibilityCache, node) {\n    var cached = visibilityCache.get(node);\n    if (cached !== undefined) {\n        return cached;\n    }\n    var result = isVisibleUncached(node, isVisibleCached.bind(undefined, visibilityCache));\n    visibilityCache.set(node, result);\n    return result;\n};\nvar isAutoFocusAllowedUncached = function (node, checkParent) {\n    return node && !isTopNode(node) ? (isAutoFocusAllowed(node) ? checkParent(getParentNode(node)) : false) : true;\n};\nexport var isAutoFocusAllowedCached = function (cache, node) {\n    var cached = cache.get(node);\n    if (cached !== undefined) {\n        return cached;\n    }\n    var result = isAutoFocusAllowedUncached(node, isAutoFocusAllowedCached.bind(undefined, cache));\n    cache.set(node, result);\n    return result;\n};\nexport var getDataset = function (node) {\n    // @ts-ignore\n    return node.dataset;\n};\nexport var isHTMLButtonElement = function (node) { return node.tagName === 'BUTTON'; };\nexport var isHTMLInputElement = function (node) { return node.tagName === 'INPUT'; };\nexport var isRadioElement = function (node) {\n    return isHTMLInputElement(node) && node.type === 'radio';\n};\nexport var notHiddenInput = function (node) {\n    return !((isHTMLInputElement(node) || isHTMLButtonElement(node)) && (node.type === 'hidden' || node.disabled));\n};\nexport var isAutoFocusAllowed = function (node) {\n    var attribute = node.getAttribute(FOCUS_NO_AUTOFOCUS);\n    return ![true, 'true', ''].includes(attribute);\n};\nexport var isGuard = function (node) { var _a; return Boolean(node && ((_a = getDataset(node)) === null || _a === void 0 ? void 0 : _a.focusGuard)); };\nexport var isNotAGuard = function (node) { return !isGuard(node); };\nexport var isDefined = function (x) { return Boolean(x); };\n","import { toArray } from './array';\nexport var tabSort = function (a, b) {\n    var aTab = Math.max(0, a.tabIndex);\n    var bTab = Math.max(0, b.tabIndex);\n    var tabDiff = aTab - bTab;\n    var indexDiff = a.index - b.index;\n    if (tabDiff) {\n        if (!aTab) {\n            return 1;\n        }\n        if (!bTab) {\n            return -1;\n        }\n    }\n    return tabDiff || indexDiff;\n};\nvar getTabIndex = function (node) {\n    if (node.tabIndex < 0) {\n        // all \"focusable\" elements are already preselected\n        // but some might have implicit negative tabIndex\n        // return 0 for <audio without tabIndex attribute - it is \"tabbable\"\n        if (!node.hasAttribute('tabindex')) {\n            return 0;\n        }\n    }\n    return node.tabIndex;\n};\nexport var orderByTabIndex = function (nodes, filterNegative, keepGuards) {\n    return toArray(nodes)\n        .map(function (node, index) {\n        var tabIndex = getTabIndex(node);\n        return {\n            node: node,\n            index: index,\n            tabIndex: keepGuards && tabIndex === -1 ? ((node.dataset || {}).focusGuard ? 0 : -1) : tabIndex,\n        };\n    })\n        .filter(function (data) { return !filterNegative || data.tabIndex >= 0; })\n        .sort(tabSort);\n};\n","import { FOCUS_AUTO } from '../constants';\nimport { toArray } from './array';\nimport { tabbables } from './tabbables';\nvar queryTabbables = tabbables.join(',');\nvar queryGuardTabbables = \"\".concat(queryTabbables, \", [data-focus-guard]\");\nvar getFocusablesWithShadowDom = function (parent, withGuards) {\n    return toArray((parent.shadowRoot || parent).children).reduce(function (acc, child) {\n        return acc.concat(child.matches(withGuards ? queryGuardTabbables : queryTabbables) ? [child] : [], getFocusablesWithShadowDom(child));\n    }, []);\n};\nvar getFocusablesWithIFrame = function (parent, withGuards) {\n    var _a;\n    // contentDocument of iframe will be null if current origin cannot access it\n    if (parent instanceof HTMLIFrameElement && ((_a = parent.contentDocument) === null || _a === void 0 ? void 0 : _a.body)) {\n        return getFocusables([parent.contentDocument.body], withGuards);\n    }\n    return [parent];\n};\nexport var getFocusables = function (parents, withGuards) {\n    return parents.reduce(function (acc, parent) {\n        var _a;\n        var focusableWithShadowDom = getFocusablesWithShadowDom(parent, withGuards);\n        var focusableWithIframes = (_a = []).concat.apply(_a, focusableWithShadowDom.map(function (node) { return getFocusablesWithIFrame(node, withGuards); }));\n        return acc.concat(\n        // add all tabbables inside and within shadow DOMs in DOM order\n        focusableWithIframes, \n        // add if node is tabbable itself\n        parent.parentNode\n            ? toArray(parent.parentNode.querySelectorAll(queryTabbables)).filter(function (node) { return node === parent; })\n            : []);\n    }, []);\n};\n/**\n * return a list of focusable nodes within an area marked as \"auto-focusable\"\n * @param parent\n */\nexport var getParentAutofocusables = function (parent) {\n    var parentFocus = parent.querySelectorAll(\"[\".concat(FOCUS_AUTO, \"]\"));\n    return toArray(parentFocus)\n        .map(function (node) { return getFocusables([node]); })\n        .reduce(function (acc, nodes) { return acc.concat(nodes); }, []);\n};\n","/**\n * list of the object to be considered as focusable\n */\nexport var tabbables = [\n    'button:enabled',\n    'select:enabled',\n    'textarea:enabled',\n    'input:enabled',\n    // elements with explicit roles will also use explicit tabindex\n    // '[role=\"button\"]',\n    'a[href]',\n    'area[href]',\n    'summary',\n    'iframe',\n    'object',\n    'embed',\n    'audio[controls]',\n    'video[controls]',\n    '[tabindex]',\n    '[contenteditable]',\n    '[autofocus]',\n];\n","import { toArray } from './array';\nimport { isAutoFocusAllowedCached, isVisibleCached, notHiddenInput } from './is';\nimport { orderByTabIndex } from './tabOrder';\nimport { getFocusables, getParentAutofocusables } from './tabUtils';\n/**\n * given list of focusable elements keeps the ones user can interact with\n * @param nodes\n * @param visibilityCache\n */\nexport var filterFocusable = function (nodes, visibilityCache) {\n    return toArray(nodes)\n        .filter(function (node) { return isVisibleCached(visibilityCache, node); })\n        .filter(function (node) { return notHiddenInput(node); });\n};\nexport var filterAutoFocusable = function (nodes, cache) {\n    if (cache === void 0) { cache = new Map(); }\n    return toArray(nodes).filter(function (node) { return isAutoFocusAllowedCached(cache, node); });\n};\n/**\n * !__WARNING__! Low level API.\n * @returns all tabbable nodes\n *\n * @see {@link getFocusableNodes} to get any focusable element\n *\n * @param topNodes - array of top level HTMLElements to search inside\n * @param visibilityCache - an cache to store intermediate measurements. Expected to be a fresh `new Map` on every call\n */\nexport var getTabbableNodes = function (topNodes, visibilityCache, withGuards) {\n    return orderByTabIndex(filterFocusable(getFocusables(topNodes, withGuards), visibilityCache), true, withGuards);\n};\n/**\n * !__WARNING__! Low level API.\n *\n * @returns anything \"focusable\", not only tabbable. The difference is in `tabIndex=-1`\n * (without guards, as long as they are not expected to be ever focused)\n *\n * @see {@link getTabbableNodes} to get only tabble nodes element\n *\n * @param topNodes - array of top level HTMLElements to search inside\n * @param visibilityCache - an cache to store intermediate measurements. Expected to be a fresh `new Map` on every call\n */\nexport var getFocusableNodes = function (topNodes, visibilityCache) {\n    return orderByTabIndex(filterFocusable(getFocusables(topNodes), visibilityCache), false);\n};\n/**\n * return list of nodes which are expected to be auto-focused\n * @param topNode\n * @param visibilityCache\n */\nexport var parentAutofocusables = function (topNode, visibilityCache) {\n    return filterFocusable(getParentAutofocusables(topNode), visibilityCache);\n};\n/*\n * Determines if element is contained in scope, including nested shadow DOMs\n */\nexport var contains = function (scope, element) {\n    if (scope.shadowRoot) {\n        return contains(scope.shadowRoot, element);\n    }\n    else {\n        if (Object.getPrototypeOf(scope).contains !== undefined &&\n            Object.getPrototypeOf(scope).contains.call(scope, element)) {\n            return true;\n        }\n        return toArray(scope.children).some(function (child) {\n            var _a;\n            if (child instanceof HTMLIFrameElement) {\n                var iframeBody = (_a = child.contentDocument) === null || _a === void 0 ? void 0 : _a.body;\n                if (iframeBody) {\n                    return contains(iframeBody, element);\n                }\n                return false;\n            }\n            return contains(child, element);\n        });\n    }\n};\n","/**\n * returns active element from document or from nested shadowdoms\n */\nimport { safeProbe } from './safe';\n/**\n * returns current active element. If the active element is a \"container\" itself(shadowRoot or iframe) returns active element inside it\n * @param [inDocument]\n */\nexport var getActiveElement = function (inDocument) {\n    if (inDocument === void 0) { inDocument = document; }\n    if (!inDocument || !inDocument.activeElement) {\n        return undefined;\n    }\n    var activeElement = inDocument.activeElement;\n    return (activeElement.shadowRoot\n        ? getActiveElement(activeElement.shadowRoot)\n        : activeElement instanceof HTMLIFrameElement && safeProbe(function () { return activeElement.contentWindow.document; })\n            ? getActiveElement(activeElement.contentWindow.document)\n            : activeElement);\n};\n","export var safeProbe = function (cb) {\n    try {\n        return cb();\n    }\n    catch (e) {\n        return undefined;\n    }\n};\n","import { FOCUS_DISABLED, FOCUS_GROUP } from '../constants';\nimport { asArray, toArray } from './array';\n/**\n * in case of multiple nodes nested inside each other\n * keeps only top ones\n * this is O(nlogn)\n * @param nodes\n * @returns {*}\n */\nvar filterNested = function (nodes) {\n    var contained = new Set();\n    var l = nodes.length;\n    for (var i = 0; i < l; i += 1) {\n        for (var j = i + 1; j < l; j += 1) {\n            var position = nodes[i].compareDocumentPosition(nodes[j]);\n            /* eslint-disable no-bitwise */\n            if ((position & Node.DOCUMENT_POSITION_CONTAINED_BY) > 0) {\n                contained.add(j);\n            }\n            if ((position & Node.DOCUMENT_POSITION_CONTAINS) > 0) {\n                contained.add(i);\n            }\n            /* eslint-enable */\n        }\n    }\n    return nodes.filter(function (_, index) { return !contained.has(index); });\n};\n/**\n * finds top most parent for a node\n * @param node\n * @returns {*}\n */\nvar getTopParent = function (node) {\n    return node.parentNode ? getTopParent(node.parentNode) : node;\n};\n/**\n * returns all \"focus containers\" inside a given node\n * @param node - node or nodes to look inside\n * @returns Element[]\n */\nexport var getAllAffectedNodes = function (node) {\n    var nodes = asArray(node);\n    return nodes.filter(Boolean).reduce(function (acc, currentNode) {\n        var group = currentNode.getAttribute(FOCUS_GROUP);\n        acc.push.apply(acc, (group\n            ? filterNested(toArray(getTopParent(currentNode).querySelectorAll(\"[\".concat(FOCUS_GROUP, \"=\\\"\").concat(group, \"\\\"]:not([\").concat(FOCUS_DISABLED, \"=\\\"disabled\\\"])\"))))\n            : [currentNode]));\n        return acc;\n    }, []);\n};\n","import { contains } from './utils/DOMutils';\nimport { getAllAffectedNodes } from './utils/all-affected';\nimport { getFirst, toArray } from './utils/array';\nimport { getActiveElement } from './utils/getActiveElement';\nvar focusInFrame = function (frame, activeElement) { return frame === activeElement; };\nvar focusInsideIframe = function (topNode, activeElement) {\n    return Boolean(toArray(topNode.querySelectorAll('iframe')).some(function (node) { return focusInFrame(node, activeElement); }));\n};\n/**\n * @returns {Boolean} true, if the current focus is inside given node or nodes.\n * Supports nodes hidden inside shadowDom\n */\nexport var focusInside = function (topNode, activeElement) {\n    // const activeElement = document && getActiveElement();\n    if (activeElement === void 0) { activeElement = getActiveElement(getFirst(topNode).ownerDocument); }\n    if (!activeElement || (activeElement.dataset && activeElement.dataset.focusGuard)) {\n        return false;\n    }\n    return getAllAffectedNodes(topNode).some(function (node) {\n        return contains(node, activeElement) || focusInsideIframe(node, activeElement);\n    });\n};\n","export var focusOn = function (target, focusOptions) {\n    if (!target) {\n        // not clear how, but is possible https://github.com/theKashey/focus-lock/issues/53\n        return;\n    }\n    if ('focus' in target) {\n        target.focus(focusOptions);\n    }\n    if ('contentWindow' in target && target.contentWindow) {\n        target.contentWindow.focus();\n    }\n};\n","import { isRadioElement } from './is';\nvar findSelectedRadio = function (node, nodes) {\n    return nodes\n        .filter(isRadioElement)\n        .filter(function (el) { return el.name === node.name; })\n        .filter(function (el) { return el.checked; })[0] || node;\n};\nexport var correctNode = function (node, nodes) {\n    if (isRadioElement(node) && node.name) {\n        return findSelectedRadio(node, nodes);\n    }\n    return node;\n};\n/**\n * giving a set of radio inputs keeps only selected (tabbable) ones\n * @param nodes\n */\nexport var correctNodes = function (nodes) {\n    // IE11 has no Set(array) constructor\n    var resultSet = new Set();\n    nodes.forEach(function (node) { return resultSet.add(correctNode(node, nodes)); });\n    // using filter to support IE11\n    return nodes.filter(function (node) { return resultSet.has(node); });\n};\n","import { correctNode } from './correctFocus';\nexport var pickFirstFocus = function (nodes) {\n    if (nodes[0] && nodes.length > 1) {\n        return correctNode(nodes[0], nodes);\n    }\n    return nodes[0];\n};\nexport var pickFocusable = function (nodes, node) {\n    return nodes.indexOf(correctNode(node, nodes));\n};\n","import { correctNodes } from './utils/correctFocus';\nimport { pickFocusable } from './utils/firstFocus';\nimport { isGuard } from './utils/is';\nexport var NEW_FOCUS = 'NEW_FOCUS';\n/**\n * Main solver for the \"find next focus\" question\n * @param innerNodes - used to control \"return focus\"\n * @param innerTabbables - used to control \"autofocus\"\n * @param outerNodes\n * @param activeElement\n * @param lastNode\n * @returns {number|string|undefined|*}\n */\nexport var newFocus = function (innerNodes, innerTabbables, outerNodes, activeElement, lastNode) {\n    var cnt = innerNodes.length;\n    var firstFocus = innerNodes[0];\n    var lastFocus = innerNodes[cnt - 1];\n    var isOnGuard = isGuard(activeElement);\n    // focus is inside\n    if (activeElement && innerNodes.indexOf(activeElement) >= 0) {\n        return undefined;\n    }\n    var activeIndex = activeElement !== undefined ? outerNodes.indexOf(activeElement) : -1;\n    var lastIndex = lastNode ? outerNodes.indexOf(lastNode) : activeIndex;\n    var lastNodeInside = lastNode ? innerNodes.indexOf(lastNode) : -1;\n    // no active focus (or focus is on the body)\n    if (activeIndex === -1) {\n        // known fallback\n        if (lastNodeInside !== -1) {\n            return lastNodeInside;\n        }\n        return NEW_FOCUS;\n    }\n    // new focus, nothing to calculate\n    if (lastNodeInside === -1) {\n        return NEW_FOCUS;\n    }\n    var indexDiff = activeIndex - lastIndex;\n    var firstNodeIndex = outerNodes.indexOf(firstFocus);\n    var lastNodeIndex = outerNodes.indexOf(lastFocus);\n    var correctedNodes = correctNodes(outerNodes);\n    var currentFocusableIndex = activeElement !== undefined ? correctedNodes.indexOf(activeElement) : -1;\n    var previousFocusableIndex = lastNode ? correctedNodes.indexOf(lastNode) : currentFocusableIndex;\n    var tabbableNodes = correctedNodes.filter(function (node) { return node.tabIndex >= 0; });\n    var currentTabbableIndex = activeElement !== undefined ? tabbableNodes.indexOf(activeElement) : -1;\n    var previousTabbableIndex = lastNode ? tabbableNodes.indexOf(lastNode) : currentTabbableIndex;\n    var focusIndexDiff = currentTabbableIndex >= 0 && previousTabbableIndex >= 0\n        ? // old/new are tabbables, measure distance in tabbable space\n            previousTabbableIndex - currentTabbableIndex\n        : // or else measure in focusable space\n            previousFocusableIndex - currentFocusableIndex;\n    // old focus\n    if (!indexDiff && lastNodeInside >= 0) {\n        return lastNodeInside;\n    }\n    // no tabbable elements, autofocus is not possible\n    if (innerTabbables.length === 0) {\n        // an edge case with no tabbable elements\n        // return the last focusable one\n        // with some probability this will prevent focus from cycling across the lock, but there is no tabbale elements to cycle to\n        return lastNodeInside;\n    }\n    var returnFirstNode = pickFocusable(innerNodes, innerTabbables[0]);\n    var returnLastNode = pickFocusable(innerNodes, innerTabbables[innerTabbables.length - 1]);\n    // first element\n    if (activeIndex <= firstNodeIndex && isOnGuard && Math.abs(indexDiff) > 1) {\n        return returnLastNode;\n    }\n    // last element\n    if (activeIndex >= lastNodeIndex && isOnGuard && Math.abs(indexDiff) > 1) {\n        return returnFirstNode;\n    }\n    // jump out, but not on the guard\n    if (indexDiff && Math.abs(focusIndexDiff) > 1) {\n        return lastNodeInside;\n    }\n    // focus above lock\n    if (activeIndex <= firstNodeIndex) {\n        return returnLastNode;\n    }\n    // focus below lock\n    if (activeIndex > lastNodeIndex) {\n        return returnFirstNode;\n    }\n    // index is inside tab order, but outside Lock\n    if (indexDiff) {\n        if (Math.abs(indexDiff) > 1) {\n            return lastNodeInside;\n        }\n        return (cnt + lastNodeInside + indexDiff) % cnt;\n    }\n    // do nothing\n    return undefined;\n};\n","import { filterAutoFocusable } from './DOMutils';\nimport { pickFirstFocus } from './firstFocus';\nimport { getDataset } from './is';\nvar findAutoFocused = function (autoFocusables) {\n    return function (node) {\n        var _a;\n        var autofocus = (_a = getDataset(node)) === null || _a === void 0 ? void 0 : _a.autofocus;\n        return (\n        // @ts-expect-error\n        node.autofocus ||\n            //\n            (autofocus !== undefined && autofocus !== 'false') ||\n            //\n            autoFocusables.indexOf(node) >= 0);\n    };\n};\nexport var pickAutofocus = function (nodesIndexes, orderedNodes, groups) {\n    var nodes = nodesIndexes.map(function (_a) {\n        var node = _a.node;\n        return node;\n    });\n    var autoFocusable = filterAutoFocusable(nodes.filter(findAutoFocused(groups)));\n    if (autoFocusable && autoFocusable.length) {\n        return pickFirstFocus(autoFocusable);\n    }\n    return pickFirstFocus(filterAutoFocusable(orderedNodes));\n};\n","import { parentAutofocusables } from './DOMutils';\nimport { contains } from './DOMutils';\nimport { asArray } from './array';\nvar getParents = function (node, parents) {\n    if (parents === void 0) { parents = []; }\n    parents.push(node);\n    if (node.parentNode) {\n        getParents(node.parentNode.host || node.parentNode, parents);\n    }\n    return parents;\n};\n/**\n * finds a parent for both nodeA and nodeB\n * @param nodeA\n * @param nodeB\n * @returns {boolean|*}\n */\nexport var getCommonParent = function (nodeA, nodeB) {\n    var parentsA = getParents(nodeA);\n    var parentsB = getParents(nodeB);\n    // tslint:disable-next-line:prefer-for-of\n    for (var i = 0; i < parentsA.length; i += 1) {\n        var currentParent = parentsA[i];\n        if (parentsB.indexOf(currentParent) >= 0) {\n            return currentParent;\n        }\n    }\n    return false;\n};\nexport var getTopCommonParent = function (baseActiveElement, leftEntry, rightEntries) {\n    var activeElements = asArray(baseActiveElement);\n    var leftEntries = asArray(leftEntry);\n    var activeElement = activeElements[0];\n    var topCommon = false;\n    leftEntries.filter(Boolean).forEach(function (entry) {\n        topCommon = getCommonParent(topCommon || entry, entry) || topCommon;\n        rightEntries.filter(Boolean).forEach(function (subEntry) {\n            var common = getCommonParent(activeElement, subEntry);\n            if (common) {\n                if (!topCommon || contains(common, topCommon)) {\n                    topCommon = common;\n                }\n                else {\n                    topCommon = getCommonParent(common, topCommon);\n                }\n            }\n        });\n    });\n    // TODO: add assert here?\n    return topCommon;\n};\n/**\n * return list of nodes which are expected to be autofocused inside a given top nodes\n * @param entries\n * @param visibilityCache\n */\nexport var allParentAutofocusables = function (entries, visibilityCache) {\n    return entries.reduce(function (acc, node) { return acc.concat(parentAutofocusables(node, visibilityCache)); }, []);\n};\n","import { NEW_FOCUS, newFocus } from './solver';\nimport { getFocusableNodes } from './utils/DOMutils';\nimport { getAllAffectedNodes } from './utils/all-affected';\nimport { asArray, getFirst } from './utils/array';\nimport { pickAutofocus } from './utils/auto-focus';\nimport { getActiveElement } from './utils/getActiveElement';\nimport { isDefined, isNotAGuard } from './utils/is';\nimport { allParentAutofocusables, getTopCommonParent } from './utils/parenting';\nvar reorderNodes = function (srcNodes, dstNodes) {\n    var remap = new Map();\n    // no Set(dstNodes) for IE11 :(\n    dstNodes.forEach(function (entity) { return remap.set(entity.node, entity); });\n    // remap to dstNodes\n    return srcNodes.map(function (node) { return remap.get(node); }).filter(isDefined);\n};\n/**\n * contains the main logic of the `focus-lock` package.\n *\n * ! you probably dont need this function !\n *\n * given top node(s) and the last active element returns the element to be focused next\n * @returns element which should be focused to move focus inside\n * @param topNode\n * @param lastNode\n */\nexport var focusSolver = function (topNode, lastNode) {\n    var activeElement = getActiveElement(asArray(topNode).length > 0 ? document : getFirst(topNode).ownerDocument);\n    var entries = getAllAffectedNodes(topNode).filter(isNotAGuard);\n    var commonParent = getTopCommonParent(activeElement || topNode, topNode, entries);\n    var visibilityCache = new Map();\n    var anyFocusable = getFocusableNodes(entries, visibilityCache);\n    var innerElements = anyFocusable.filter(function (_a) {\n        var node = _a.node;\n        return isNotAGuard(node);\n    });\n    if (!innerElements[0]) {\n        return undefined;\n    }\n    var outerNodes = getFocusableNodes([commonParent], visibilityCache).map(function (_a) {\n        var node = _a.node;\n        return node;\n    });\n    var orderedInnerElements = reorderNodes(outerNodes, innerElements);\n    // collect inner focusable and separately tabbables\n    var innerFocusables = orderedInnerElements.map(function (_a) {\n        var node = _a.node;\n        return node;\n    });\n    var innerTabbable = orderedInnerElements.filter(function (_a) {\n        var tabIndex = _a.tabIndex;\n        return tabIndex >= 0;\n    }).map(function (_a) {\n        var node = _a.node;\n        return node;\n    });\n    var newId = newFocus(innerFocusables, innerTabbable, outerNodes, activeElement, lastNode);\n    if (newId === NEW_FOCUS) {\n        var focusNode = \n        // first try only tabbable, and the fallback to all focusable, as long as at least one element should be picked for focus\n        pickAutofocus(anyFocusable, innerTabbable, allParentAutofocusables(entries, visibilityCache)) ||\n            pickAutofocus(anyFocusable, innerFocusables, allParentAutofocusables(entries, visibilityCache));\n        if (focusNode) {\n            return { node: focusNode };\n        }\n        else {\n            console.warn('focus-lock: cannot find any node to move focus into');\n            return undefined;\n        }\n    }\n    if (newId === undefined) {\n        return newId;\n    }\n    return orderedInnerElements[newId];\n};\n","import { focusOn } from './commands';\nimport { focusSolver } from './focusSolver';\nvar guardCount = 0;\nvar lockDisabled = false;\n/**\n * The main functionality of the focus-lock package\n *\n * Contains focus at a given node.\n * The last focused element will help to determine which element(first or last) should be focused.\n * The found element will be focused.\n *\n * This is one time action (move), not a persistent focus-lock\n *\n * HTML markers (see {@link import('./constants').FOCUS_AUTO} constants) can control autofocus\n * @see {@link focusSolver} for the same functionality without autofocus\n */\nexport var moveFocusInside = function (topNode, lastNode, options) {\n    if (options === void 0) { options = {}; }\n    var focusable = focusSolver(topNode, lastNode);\n    // global local side effect to countain recursive lock activation and resolve focus-fighting\n    if (lockDisabled) {\n        return;\n    }\n    if (focusable) {\n        /** +FOCUS-FIGHTING prevention **/\n        if (guardCount > 2) {\n            // we have recursive entered back the lock activation\n            console.error('FocusLock: focus-fighting detected. Only one focus management system could be active. ' +\n                'See https://github.com/theKashey/focus-lock/#focus-fighting');\n            lockDisabled = true;\n            setTimeout(function () {\n                lockDisabled = false;\n            }, 1);\n            return;\n        }\n        guardCount++;\n        focusOn(focusable.node, options.focusOptions);\n        guardCount--;\n    }\n};\n","import { getTabbableNodes } from './utils/DOMutils';\nfunction weakRef(value) {\n    if (!value)\n        return null;\n    // #68 Safari 14.1 dont have it yet\n    // FIXME: remove in 2025\n    if (typeof WeakRef === 'undefined') {\n        return function () { return value || null; };\n    }\n    var w = value ? new WeakRef(value) : null;\n    return function () { return (w === null || w === void 0 ? void 0 : w.deref()) || null; };\n}\nexport var recordElementLocation = function (element) {\n    if (!element) {\n        return null;\n    }\n    var stack = [];\n    var currentElement = element;\n    while (currentElement && currentElement !== document.body) {\n        stack.push({\n            current: weakRef(currentElement),\n            parent: weakRef(currentElement.parentElement),\n            left: weakRef(currentElement.previousElementSibling),\n            right: weakRef(currentElement.nextElementSibling),\n        });\n        currentElement = currentElement.parentElement;\n    }\n    return {\n        element: weakRef(element),\n        stack: stack,\n        ownerDocument: element.ownerDocument,\n    };\n};\nvar restoreFocusTo = function (location) {\n    var _a, _b, _c, _d, _e;\n    if (!location) {\n        return undefined;\n    }\n    var stack = location.stack, ownerDocument = location.ownerDocument;\n    var visibilityCache = new Map();\n    for (var _i = 0, stack_1 = stack; _i < stack_1.length; _i++) {\n        var line = stack_1[_i];\n        var parent_1 = (_a = line.parent) === null || _a === void 0 ? void 0 : _a.call(line);\n        // is it still here?\n        if (parent_1 && ownerDocument.contains(parent_1)) {\n            var left = (_b = line.left) === null || _b === void 0 ? void 0 : _b.call(line);\n            var savedCurrent = line.current();\n            var current = parent_1.contains(savedCurrent) ? savedCurrent : undefined;\n            var right = (_c = line.right) === null || _c === void 0 ? void 0 : _c.call(line);\n            var focusables = getTabbableNodes([parent_1], visibilityCache);\n            var aim = \n            // that is element itself\n            (_e = (_d = current !== null && current !== void 0 ? current : \n            // or something in it's place\n            left === null || left === void 0 ? void 0 : left.nextElementSibling) !== null && _d !== void 0 ? _d : \n            // or somebody to the right, still close enough\n            right) !== null && _e !== void 0 ? _e : \n            // or somebody to the left, something?\n            left;\n            while (aim) {\n                for (var _f = 0, focusables_1 = focusables; _f < focusables_1.length; _f++) {\n                    var focusable = focusables_1[_f];\n                    if (aim === null || aim === void 0 ? void 0 : aim.contains(focusable.node)) {\n                        return focusable.node;\n                    }\n                }\n                aim = aim.nextElementSibling;\n            }\n            if (focusables.length) {\n                // if parent contains a focusable - move there\n                return focusables[0].node;\n            }\n        }\n    }\n    // nothing matched\n    return undefined;\n};\n/**\n * Captures the current focused element to restore focus as close as possible in the future\n * Handles situations where the focused element is removed from the DOM or no longer focusable\n * moving focus to the closest focusable element\n * @param targetElement - element where focus should be restored\n * @returns a function returning a new element to focus\n */\nexport var captureFocusRestore = function (targetElement) {\n    var location = recordElementLocation(targetElement);\n    return function () {\n        return restoreFocusTo(location);\n    };\n};\n","import { focusOn } from './commands';\nimport { getTabbableNodes, contains, getFocusableNodes } from './utils/DOMutils';\nimport { asArray } from './utils/array';\n/**\n * for a given `element` in a given `scope` returns focusable siblings\n * @param element - base element\n * @param scope - common parent. Can be document, but better to narrow it down for performance reasons\n * @returns {prev,next} - references to a focusable element before and after\n * @returns undefined - if operation is not applicable\n */\nexport var getRelativeFocusable = function (element, scope, useTabbables) {\n    if (!element || !scope) {\n        console.error('no element or scope given');\n        return {};\n    }\n    var shards = asArray(scope);\n    if (shards.every(function (shard) { return !contains(shard, element); })) {\n        console.error('Active element is not contained in the scope');\n        return {};\n    }\n    var focusables = useTabbables\n        ? getTabbableNodes(shards, new Map())\n        : getFocusableNodes(shards, new Map());\n    var current = focusables.findIndex(function (_a) {\n        var node = _a.node;\n        return node === element;\n    });\n    if (current === -1) {\n        // an edge case, when anchor element is not found\n        return undefined;\n    }\n    return {\n        prev: focusables[current - 1],\n        next: focusables[current + 1],\n        first: focusables[0],\n        last: focusables[focusables.length - 1],\n    };\n};\nvar getBoundary = function (shards, useTabbables) {\n    var set = useTabbables\n        ? getTabbableNodes(asArray(shards), new Map())\n        : getFocusableNodes(asArray(shards), new Map());\n    return {\n        first: set[0],\n        last: set[set.length - 1],\n    };\n};\nvar defaultOptions = function (options) {\n    return Object.assign({\n        scope: document.body,\n        cycle: true,\n        onlyTabbable: true,\n    }, options);\n};\nvar moveFocus = function (fromElement, options, cb) {\n    if (options === void 0) { options = {}; }\n    var newOptions = defaultOptions(options);\n    var solution = getRelativeFocusable(fromElement, newOptions.scope, newOptions.onlyTabbable);\n    if (!solution) {\n        return;\n    }\n    var target = cb(solution, newOptions.cycle);\n    if (target) {\n        focusOn(target.node, newOptions.focusOptions);\n    }\n};\n/**\n * focuses next element in the tab-order\n * @param fromElement - common parent to scope active element search or tab cycle order\n * @param {FocusNextOptions} [options] - focus options\n */\nexport var focusNextElement = function (fromElement, options) {\n    if (options === void 0) { options = {}; }\n    moveFocus(fromElement, options, function (_a, cycle) {\n        var next = _a.next, first = _a.first;\n        return next || (cycle && first);\n    });\n};\n/**\n * focuses prev element in the tab order\n * @param fromElement - common parent to scope active element search or tab cycle order\n * @param {FocusNextOptions} [options] - focus options\n */\nexport var focusPrevElement = function (fromElement, options) {\n    if (options === void 0) { options = {}; }\n    moveFocus(fromElement, options, function (_a, cycle) {\n        var prev = _a.prev, last = _a.last;\n        return prev || (cycle && last);\n    });\n};\nvar pickBoundary = function (scope, options, what) {\n    var _a;\n    var boundary = getBoundary(scope, (_a = options.onlyTabbable) !== null && _a !== void 0 ? _a : true);\n    var node = boundary[what];\n    if (node) {\n        focusOn(node.node, options.focusOptions);\n    }\n};\n/**\n * focuses first element in the tab-order\n * @param {FocusNextOptions} options - focus options\n */\nexport var focusFirstElement = function (scope, options) {\n    if (options === void 0) { options = {}; }\n    pickBoundary(scope, options, 'first');\n};\n/**\n * focuses last element in the tab order\n * @param {FocusNextOptions} options - focus options\n */\nexport var focusLastElement = function (scope, options) {\n    if (options === void 0) { options = {}; }\n    pickBoundary(scope, options, 'last');\n};\n","export function deferAction(action) {\n  setTimeout(action, 1);\n}\nexport var inlineProp = function inlineProp(name, value) {\n  var obj = {};\n  obj[name] = value;\n  return obj;\n};\nexport var extractRef = function extractRef(ref) {\n  return ref && 'current' in ref ? ref.current : ref;\n};","import React from 'react';\nimport PropTypes from 'prop-types';\nimport withSideEffect from 'react-clientside-effect';\nimport { moveFocusInside, focusInside, focusIsHidden, expandFocusableNodes, getFocusableNodes, focusNextElement, focusPrevElement, focusFirstElement, focusLastElement, captureFocusRestore } from 'focus-lock';\nimport { deferAction, extractRef } from './util';\nimport { mediumFocus, mediumBlur, mediumEffect } from './medium';\nvar focusOnBody = function focusOnBody() {\n  return document && document.activeElement === document.body;\n};\nvar isFreeFocus = function isFreeFocus() {\n  return focusOnBody() || focusIsHidden();\n};\nvar lastActiveTrap = null;\nvar lastActiveFocus = null;\nvar tryRestoreFocus = function tryRestoreFocus() {\n  return null;\n};\nvar lastPortaledElement = null;\nvar focusWasOutsideWindow = false;\nvar windowFocused = false;\nvar defaultWhitelist = function defaultWhitelist() {\n  return true;\n};\nvar focusWhitelisted = function focusWhitelisted(activeElement) {\n  return (lastActiveTrap.whiteList || defaultWhitelist)(activeElement);\n};\nvar recordPortal = function recordPortal(observerNode, portaledElement) {\n  lastPortaledElement = {\n    observerNode: observerNode,\n    portaledElement: portaledElement\n  };\n};\nvar focusIsPortaledPair = function focusIsPortaledPair(element) {\n  return lastPortaledElement && lastPortaledElement.portaledElement === element;\n};\nfunction autoGuard(startIndex, end, step, allNodes) {\n  var lastGuard = null;\n  var i = startIndex;\n  do {\n    var item = allNodes[i];\n    if (item.guard) {\n      if (item.node.dataset.focusAutoGuard) {\n        lastGuard = item;\n      }\n    } else if (item.lockItem) {\n      if (i !== startIndex) {\n        return;\n      }\n      lastGuard = null;\n    } else {\n      break;\n    }\n  } while ((i += step) !== end);\n  if (lastGuard) {\n    lastGuard.node.tabIndex = 0;\n  }\n}\nvar focusWasOutside = function focusWasOutside(crossFrameOption) {\n  if (crossFrameOption) {\n    return Boolean(focusWasOutsideWindow);\n  }\n  return focusWasOutsideWindow === 'meanwhile';\n};\nvar checkInHost = function checkInHost(check, el, boundary) {\n  return el && (el.host === check && (!el.activeElement || boundary.contains(el.activeElement)) || el.parentNode && checkInHost(check, el.parentNode, boundary));\n};\nvar withinHost = function withinHost(activeElement, workingArea) {\n  return workingArea.some(function (area) {\n    return checkInHost(activeElement, area, area);\n  });\n};\nvar getNodeFocusables = function getNodeFocusables(nodes) {\n  return getFocusableNodes(nodes, new Map());\n};\nvar isNotFocusable = function isNotFocusable(node) {\n  return !getNodeFocusables([node.parentNode]).some(function (el) {\n    return el.node === node;\n  });\n};\nvar activateTrap = function activateTrap() {\n  var result = false;\n  if (lastActiveTrap) {\n    var _lastActiveTrap = lastActiveTrap,\n      observed = _lastActiveTrap.observed,\n      persistentFocus = _lastActiveTrap.persistentFocus,\n      autoFocus = _lastActiveTrap.autoFocus,\n      shards = _lastActiveTrap.shards,\n      crossFrame = _lastActiveTrap.crossFrame,\n      focusOptions = _lastActiveTrap.focusOptions,\n      noFocusGuards = _lastActiveTrap.noFocusGuards;\n    var workingNode = observed || lastPortaledElement && lastPortaledElement.portaledElement;\n    if (focusOnBody() && lastActiveFocus && lastActiveFocus !== document.body) {\n      if (!document.body.contains(lastActiveFocus) || isNotFocusable(lastActiveFocus)) {\n        var newTarget = tryRestoreFocus();\n        if (newTarget) {\n          newTarget.focus();\n        }\n      }\n    }\n    var activeElement = document && document.activeElement;\n    if (workingNode) {\n      var workingArea = [workingNode].concat(shards.map(extractRef).filter(Boolean));\n      var shouldForceRestoreFocus = function shouldForceRestoreFocus() {\n        if (!focusWasOutside(crossFrame) || !noFocusGuards || !lastActiveFocus || windowFocused) {\n          return false;\n        }\n        var nodes = getNodeFocusables(workingArea);\n        var lastIndex = nodes.findIndex(function (_ref) {\n          var node = _ref.node;\n          return node === lastActiveFocus;\n        });\n        return lastIndex === 0 || lastIndex === nodes.length - 1;\n      };\n      if (!activeElement || focusWhitelisted(activeElement)) {\n        if (persistentFocus || shouldForceRestoreFocus() || !isFreeFocus() || !lastActiveFocus && autoFocus) {\n          if (workingNode && !(focusInside(workingArea) || activeElement && withinHost(activeElement, workingArea) || focusIsPortaledPair(activeElement, workingNode))) {\n            if (document && !lastActiveFocus && activeElement && !autoFocus) {\n              if (activeElement.blur) {\n                activeElement.blur();\n              }\n              document.body.focus();\n            } else {\n              result = moveFocusInside(workingArea, lastActiveFocus, {\n                focusOptions: focusOptions\n              });\n              lastPortaledElement = {};\n            }\n          }\n          lastActiveFocus = document && document.activeElement;\n          if (lastActiveFocus !== document.body) {\n            tryRestoreFocus = captureFocusRestore(lastActiveFocus);\n          }\n          focusWasOutsideWindow = false;\n        }\n      }\n      if (document && activeElement !== document.activeElement && document.querySelector('[data-focus-auto-guard]')) {\n        var newActiveElement = document && document.activeElement;\n        var allNodes = expandFocusableNodes(workingArea);\n        var focusedIndex = allNodes.map(function (_ref2) {\n          var node = _ref2.node;\n          return node;\n        }).indexOf(newActiveElement);\n        if (focusedIndex > -1) {\n          allNodes.filter(function (_ref3) {\n            var guard = _ref3.guard,\n              node = _ref3.node;\n            return guard && node.dataset.focusAutoGuard;\n          }).forEach(function (_ref4) {\n            var node = _ref4.node;\n            return node.removeAttribute('tabIndex');\n          });\n          autoGuard(focusedIndex, allNodes.length, +1, allNodes);\n          autoGuard(focusedIndex, -1, -1, allNodes);\n        }\n      }\n    }\n  }\n  return result;\n};\nvar onTrap = function onTrap(event) {\n  if (activateTrap() && event) {\n    event.stopPropagation();\n    event.preventDefault();\n  }\n};\nvar onBlur = function onBlur() {\n  return deferAction(activateTrap);\n};\nvar onFocus = function onFocus(event) {\n  var source = event.target;\n  var currentNode = event.currentTarget;\n  if (!currentNode.contains(source)) {\n    recordPortal(currentNode, source);\n  }\n};\nvar FocusWatcher = function FocusWatcher() {\n  return null;\n};\nvar FocusTrap = function FocusTrap(_ref5) {\n  var children = _ref5.children;\n  return /*#__PURE__*/React.createElement(\"div\", {\n    onBlur: onBlur,\n    onFocus: onFocus\n  }, children);\n};\nFocusTrap.propTypes = process.env.NODE_ENV !== \"production\" ? {\n  children: PropTypes.node.isRequired\n} : {};\nvar onWindowFocus = function onWindowFocus() {\n  windowFocused = true;\n};\nvar onWindowBlur = function onWindowBlur() {\n  windowFocused = false;\n  focusWasOutsideWindow = 'just';\n  deferAction(function () {\n    focusWasOutsideWindow = 'meanwhile';\n  });\n};\nvar attachHandler = function attachHandler() {\n  document.addEventListener('focusin', onTrap);\n  document.addEventListener('focusout', onBlur);\n  window.addEventListener('focus', onWindowFocus);\n  window.addEventListener('blur', onWindowBlur);\n};\nvar detachHandler = function detachHandler() {\n  document.removeEventListener('focusin', onTrap);\n  document.removeEventListener('focusout', onBlur);\n  window.removeEventListener('focus', onWindowFocus);\n  window.removeEventListener('blur', onWindowBlur);\n};\nfunction reducePropsToState(propsList) {\n  return propsList.filter(function (_ref6) {\n    var disabled = _ref6.disabled;\n    return !disabled;\n  });\n}\nvar focusLockAPI = {\n  moveFocusInside: moveFocusInside,\n  focusInside: focusInside,\n  focusNextElement: focusNextElement,\n  focusPrevElement: focusPrevElement,\n  focusFirstElement: focusFirstElement,\n  focusLastElement: focusLastElement,\n  captureFocusRestore: captureFocusRestore\n};\nfunction handleStateChangeOnClient(traps) {\n  var trap = traps.slice(-1)[0];\n  if (trap && !lastActiveTrap) {\n    attachHandler();\n  }\n  var lastTrap = lastActiveTrap;\n  var sameTrap = lastTrap && trap && trap.id === lastTrap.id;\n  lastActiveTrap = trap;\n  if (lastTrap && !sameTrap) {\n    lastTrap.onDeactivation();\n    if (!traps.filter(function (_ref7) {\n      var id = _ref7.id;\n      return id === lastTrap.id;\n    }).length) {\n      lastTrap.returnFocus(!trap);\n    }\n  }\n  if (trap) {\n    lastActiveFocus = null;\n    if (!sameTrap || lastTrap.observed !== trap.observed) {\n      trap.onActivation(focusLockAPI);\n    }\n    activateTrap(true);\n    deferAction(activateTrap);\n  } else {\n    detachHandler();\n    lastActiveFocus = null;\n  }\n}\nmediumFocus.assignSyncMedium(onFocus);\nmediumBlur.assignMedium(onBlur);\nmediumEffect.assignMedium(function (cb) {\n  return cb(focusLockAPI);\n});\nexport default withSideEffect(reducePropsToState, handleStateChangeOnClient)(FocusWatcher);","import { FOCUS_ALLOW } from './constants';\nimport { contains } from './utils/DOMutils';\nimport { toArray } from './utils/array';\nimport { getActiveElement } from './utils/getActiveElement';\n/**\n * checks if focus is hidden FROM the focus-lock\n * ie contained inside a node focus-lock shall ignore\n *\n * This is a utility function coupled with {@link FOCUS_ALLOW} constant\n *\n * @returns {boolean} focus is currently is in \"allow\" area\n */\nexport var focusIsHidden = function (inDocument) {\n    if (inDocument === void 0) { inDocument = document; }\n    var activeElement = getActiveElement(inDocument);\n    if (!activeElement) {\n        return false;\n    }\n    // this does not support setting FOCUS_ALLOW within shadow dom\n    return toArray(inDocument.querySelectorAll(\"[\".concat(FOCUS_ALLOW, \"]\"))).some(function (node) { return contains(node, activeElement); });\n};\n","import { getAllAffectedNodes } from './utils/all-affected';\nimport { isGuard, isNotAGuard } from './utils/is';\nimport { getTopCommonParent } from './utils/parenting';\nimport { orderByTabIndex } from './utils/tabOrder';\nimport { getFocusables } from './utils/tabUtils';\n/**\n * traverses all related nodes (including groups) returning a list of all nodes(outer and internal) with meta information\n * This is low-level API!\n * @returns list of focusable elements inside a given top(!) node.\n * @see {@link getFocusableNodes} providing a simpler API\n */\nexport var expandFocusableNodes = function (topNode) {\n    var entries = getAllAffectedNodes(topNode).filter(isNotAGuard);\n    var commonParent = getTopCommonParent(topNode, topNode, entries);\n    var outerNodes = orderByTabIndex(getFocusables([commonParent], true), true, true);\n    var innerElements = getFocusables(entries, false);\n    return outerNodes.map(function (_a) {\n        var node = _a.node, index = _a.index;\n        return ({\n            node: node,\n            index: index,\n            lockItem: innerElements.indexOf(node) >= 0,\n            guard: isGuard(node),\n        });\n    });\n};\n","import _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport _extends from \"@babel/runtime/helpers/esm/extends\";\nimport React, { forwardRef } from 'react';\nimport FocusLockUI from './Lock';\nimport FocusTrap from './Trap';\nvar FocusLockCombination = /*#__PURE__*/forwardRef(function FocusLockUICombination(props, ref) {\n  return /*#__PURE__*/React.createElement(FocusLockUI, _extends({\n    sideCar: FocusTrap,\n    ref: ref\n  }, props));\n});\nvar _ref = FocusLockUI.propTypes || {},\n  sideCar = _ref.sideCar,\n  propTypes = _objectWithoutPropertiesLoose(_ref, [\"sideCar\"]);\nFocusLockCombination.propTypes = process.env.NODE_ENV !== \"production\" ? propTypes : {};\nexport default FocusLockCombination;","import FocusLock from './Combination';\nexport * from './UI';\nexport default FocusLock;","function replaceClassName(origClass, classToRemove) {\n  return origClass.replace(new RegExp(\"(^|\\\\s)\" + classToRemove + \"(?:\\\\s|$)\", 'g'), '$1').replace(/\\s+/g, ' ').replace(/^\\s*|\\s*$/g, '');\n}\n/**\n * Removes a CSS class from a given element.\n * \n * @param element the element\n * @param className the CSS class name\n */\n\n\nexport default function removeClass(element, className) {\n  if (element.classList) {\n    element.classList.remove(className);\n  } else if (typeof element.className === 'string') {\n    element.className = replaceClassName(element.className, className);\n  } else {\n    element.setAttribute('class', replaceClassName(element.className && element.className.baseVal || '', className));\n  }\n}","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport _inheritsLoose from \"@babel/runtime/helpers/esm/inheritsLoose\";\nimport PropTypes from 'prop-types';\nimport addOneClass from 'dom-helpers/addClass';\nimport removeOneClass from 'dom-helpers/removeClass';\nimport React from 'react';\nimport Transition from './Transition';\nimport { classNamesShape } from './utils/PropTypes';\nimport { forceReflow } from './utils/reflow';\n\nvar _addClass = function addClass(node, classes) {\n  return node && classes && classes.split(' ').forEach(function (c) {\n    return addOneClass(node, c);\n  });\n};\n\nvar removeClass = function removeClass(node, classes) {\n  return node && classes && classes.split(' ').forEach(function (c) {\n    return removeOneClass(node, c);\n  });\n};\n/**\n * A transition component inspired by the excellent\n * [ng-animate](https://docs.angularjs.org/api/ngAnimate) library, you should\n * use it if you're using CSS transitions or animations. It's built upon the\n * [`Transition`](https://reactcommunity.org/react-transition-group/transition)\n * component, so it inherits all of its props.\n *\n * `CSSTransition` applies a pair of class names during the `appear`, `enter`,\n * and `exit` states of the transition. The first class is applied and then a\n * second `*-active` class in order to activate the CSS transition. After the\n * transition, matching `*-done` class names are applied to persist the\n * transition state.\n *\n * ```jsx\n * function App() {\n *   const [inProp, setInProp] = useState(false);\n *   return (\n *     <div>\n *       <CSSTransition in={inProp} timeout={200} classNames=\"my-node\">\n *         <div>\n *           {\"I'll receive my-node-* classes\"}\n *         </div>\n *       </CSSTransition>\n *       <button type=\"button\" onClick={() => setInProp(true)}>\n *         Click to Enter\n *       </button>\n *     </div>\n *   );\n * }\n * ```\n *\n * When the `in` prop is set to `true`, the child component will first receive\n * the class `example-enter`, then the `example-enter-active` will be added in\n * the next tick. `CSSTransition` [forces a\n * reflow](https://github.com/reactjs/react-transition-group/blob/5007303e729a74be66a21c3e2205e4916821524b/src/CSSTransition.js#L208-L215)\n * between before adding the `example-enter-active`. This is an important trick\n * because it allows us to transition between `example-enter` and\n * `example-enter-active` even though they were added immediately one after\n * another. Most notably, this is what makes it possible for us to animate\n * _appearance_.\n *\n * ```css\n * .my-node-enter {\n *   opacity: 0;\n * }\n * .my-node-enter-active {\n *   opacity: 1;\n *   transition: opacity 200ms;\n * }\n * .my-node-exit {\n *   opacity: 1;\n * }\n * .my-node-exit-active {\n *   opacity: 0;\n *   transition: opacity 200ms;\n * }\n * ```\n *\n * `*-active` classes represent which styles you want to animate **to**, so it's\n * important to add `transition` declaration only to them, otherwise transitions\n * might not behave as intended! This might not be obvious when the transitions\n * are symmetrical, i.e. when `*-enter-active` is the same as `*-exit`, like in\n * the example above (minus `transition`), but it becomes apparent in more\n * complex transitions.\n *\n * **Note**: If you're using the\n * [`appear`](http://reactcommunity.org/react-transition-group/transition#Transition-prop-appear)\n * prop, make sure to define styles for `.appear-*` classes as well.\n */\n\n\nvar CSSTransition = /*#__PURE__*/function (_React$Component) {\n  _inheritsLoose(CSSTransition, _React$Component);\n\n  function CSSTransition() {\n    var _this;\n\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    _this = _React$Component.call.apply(_React$Component, [this].concat(args)) || this;\n    _this.appliedClasses = {\n      appear: {},\n      enter: {},\n      exit: {}\n    };\n\n    _this.onEnter = function (maybeNode, maybeAppearing) {\n      var _this$resolveArgument = _this.resolveArguments(maybeNode, maybeAppearing),\n          node = _this$resolveArgument[0],\n          appearing = _this$resolveArgument[1];\n\n      _this.removeClasses(node, 'exit');\n\n      _this.addClass(node, appearing ? 'appear' : 'enter', 'base');\n\n      if (_this.props.onEnter) {\n        _this.props.onEnter(maybeNode, maybeAppearing);\n      }\n    };\n\n    _this.onEntering = function (maybeNode, maybeAppearing) {\n      var _this$resolveArgument2 = _this.resolveArguments(maybeNode, maybeAppearing),\n          node = _this$resolveArgument2[0],\n          appearing = _this$resolveArgument2[1];\n\n      var type = appearing ? 'appear' : 'enter';\n\n      _this.addClass(node, type, 'active');\n\n      if (_this.props.onEntering) {\n        _this.props.onEntering(maybeNode, maybeAppearing);\n      }\n    };\n\n    _this.onEntered = function (maybeNode, maybeAppearing) {\n      var _this$resolveArgument3 = _this.resolveArguments(maybeNode, maybeAppearing),\n          node = _this$resolveArgument3[0],\n          appearing = _this$resolveArgument3[1];\n\n      var type = appearing ? 'appear' : 'enter';\n\n      _this.removeClasses(node, type);\n\n      _this.addClass(node, type, 'done');\n\n      if (_this.props.onEntered) {\n        _this.props.onEntered(maybeNode, maybeAppearing);\n      }\n    };\n\n    _this.onExit = function (maybeNode) {\n      var _this$resolveArgument4 = _this.resolveArguments(maybeNode),\n          node = _this$resolveArgument4[0];\n\n      _this.removeClasses(node, 'appear');\n\n      _this.removeClasses(node, 'enter');\n\n      _this.addClass(node, 'exit', 'base');\n\n      if (_this.props.onExit) {\n        _this.props.onExit(maybeNode);\n      }\n    };\n\n    _this.onExiting = function (maybeNode) {\n      var _this$resolveArgument5 = _this.resolveArguments(maybeNode),\n          node = _this$resolveArgument5[0];\n\n      _this.addClass(node, 'exit', 'active');\n\n      if (_this.props.onExiting) {\n        _this.props.onExiting(maybeNode);\n      }\n    };\n\n    _this.onExited = function (maybeNode) {\n      var _this$resolveArgument6 = _this.resolveArguments(maybeNode),\n          node = _this$resolveArgument6[0];\n\n      _this.removeClasses(node, 'exit');\n\n      _this.addClass(node, 'exit', 'done');\n\n      if (_this.props.onExited) {\n        _this.props.onExited(maybeNode);\n      }\n    };\n\n    _this.resolveArguments = function (maybeNode, maybeAppearing) {\n      return _this.props.nodeRef ? [_this.props.nodeRef.current, maybeNode] // here `maybeNode` is actually `appearing`\n      : [maybeNode, maybeAppearing];\n    };\n\n    _this.getClassNames = function (type) {\n      var classNames = _this.props.classNames;\n      var isStringClassNames = typeof classNames === 'string';\n      var prefix = isStringClassNames && classNames ? classNames + \"-\" : '';\n      var baseClassName = isStringClassNames ? \"\" + prefix + type : classNames[type];\n      var activeClassName = isStringClassNames ? baseClassName + \"-active\" : classNames[type + \"Active\"];\n      var doneClassName = isStringClassNames ? baseClassName + \"-done\" : classNames[type + \"Done\"];\n      return {\n        baseClassName: baseClassName,\n        activeClassName: activeClassName,\n        doneClassName: doneClassName\n      };\n    };\n\n    return _this;\n  }\n\n  var _proto = CSSTransition.prototype;\n\n  _proto.addClass = function addClass(node, type, phase) {\n    var className = this.getClassNames(type)[phase + \"ClassName\"];\n\n    var _this$getClassNames = this.getClassNames('enter'),\n        doneClassName = _this$getClassNames.doneClassName;\n\n    if (type === 'appear' && phase === 'done' && doneClassName) {\n      className += \" \" + doneClassName;\n    } // This is to force a repaint,\n    // which is necessary in order to transition styles when adding a class name.\n\n\n    if (phase === 'active') {\n      if (node) forceReflow(node);\n    }\n\n    if (className) {\n      this.appliedClasses[type][phase] = className;\n\n      _addClass(node, className);\n    }\n  };\n\n  _proto.removeClasses = function removeClasses(node, type) {\n    var _this$appliedClasses$ = this.appliedClasses[type],\n        baseClassName = _this$appliedClasses$.base,\n        activeClassName = _this$appliedClasses$.active,\n        doneClassName = _this$appliedClasses$.done;\n    this.appliedClasses[type] = {};\n\n    if (baseClassName) {\n      removeClass(node, baseClassName);\n    }\n\n    if (activeClassName) {\n      removeClass(node, activeClassName);\n    }\n\n    if (doneClassName) {\n      removeClass(node, doneClassName);\n    }\n  };\n\n  _proto.render = function render() {\n    var _this$props = this.props,\n        _ = _this$props.classNames,\n        props = _objectWithoutPropertiesLoose(_this$props, [\"classNames\"]);\n\n    return /*#__PURE__*/React.createElement(Transition, _extends({}, props, {\n      onEnter: this.onEnter,\n      onEntered: this.onEntered,\n      onEntering: this.onEntering,\n      onExit: this.onExit,\n      onExiting: this.onExiting,\n      onExited: this.onExited\n    }));\n  };\n\n  return CSSTransition;\n}(React.Component);\n\nCSSTransition.defaultProps = {\n  classNames: ''\n};\nCSSTransition.propTypes = process.env.NODE_ENV !== \"production\" ? _extends({}, Transition.propTypes, {\n  /**\n   * The animation classNames applied to the component as it appears, enters,\n   * exits or has finished the transition. A single name can be provided, which\n   * will be suffixed for each stage, e.g. `classNames=\"fade\"` applies:\n   *\n   * - `fade-appear`, `fade-appear-active`, `fade-appear-done`\n   * - `fade-enter`, `fade-enter-active`, `fade-enter-done`\n   * - `fade-exit`, `fade-exit-active`, `fade-exit-done`\n   *\n   * A few details to note about how these classes are applied:\n   *\n   * 1. They are _joined_ with the ones that are already defined on the child\n   *    component, so if you want to add some base styles, you can use\n   *    `className` without worrying that it will be overridden.\n   *\n   * 2. If the transition component mounts with `in={false}`, no classes are\n   *    applied yet. You might be expecting `*-exit-done`, but if you think\n   *    about it, a component cannot finish exiting if it hasn't entered yet.\n   *\n   * 2. `fade-appear-done` and `fade-enter-done` will _both_ be applied. This\n   *    allows you to define different behavior for when appearing is done and\n   *    when regular entering is done, using selectors like\n   *    `.fade-enter-done:not(.fade-appear-done)`. For example, you could apply\n   *    an epic entrance animation when element first appears in the DOM using\n   *    [Animate.css](https://daneden.github.io/animate.css/). Otherwise you can\n   *    simply use `fade-enter-done` for defining both cases.\n   *\n   * Each individual classNames can also be specified independently like:\n   *\n   * ```js\n   * classNames={{\n   *  appear: 'my-appear',\n   *  appearActive: 'my-active-appear',\n   *  appearDone: 'my-done-appear',\n   *  enter: 'my-enter',\n   *  enterActive: 'my-active-enter',\n   *  enterDone: 'my-done-enter',\n   *  exit: 'my-exit',\n   *  exitActive: 'my-active-exit',\n   *  exitDone: 'my-done-exit',\n   * }}\n   * ```\n   *\n   * If you want to set these classes using CSS Modules:\n   *\n   * ```js\n   * import styles from './styles.css';\n   * ```\n   *\n   * you might want to use camelCase in your CSS file, that way could simply\n   * spread them instead of listing them one by one:\n   *\n   * ```js\n   * classNames={{ ...styles }}\n   * ```\n   *\n   * @type {string | {\n   *  appear?: string,\n   *  appearActive?: string,\n   *  appearDone?: string,\n   *  enter?: string,\n   *  enterActive?: string,\n   *  enterDone?: string,\n   *  exit?: string,\n   *  exitActive?: string,\n   *  exitDone?: string,\n   * }}\n   */\n  classNames: classNamesShape,\n\n  /**\n   * A `<Transition>` callback fired immediately after the 'enter' or 'appear' class is\n   * applied.\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\n   *\n   * @type Function(node: HtmlElement, isAppearing: bool)\n   */\n  onEnter: PropTypes.func,\n\n  /**\n   * A `<Transition>` callback fired immediately after the 'enter-active' or\n   * 'appear-active' class is applied.\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\n   *\n   * @type Function(node: HtmlElement, isAppearing: bool)\n   */\n  onEntering: PropTypes.func,\n\n  /**\n   * A `<Transition>` callback fired immediately after the 'enter' or\n   * 'appear' classes are **removed** and the `done` class is added to the DOM node.\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\n   *\n   * @type Function(node: HtmlElement, isAppearing: bool)\n   */\n  onEntered: PropTypes.func,\n\n  /**\n   * A `<Transition>` callback fired immediately after the 'exit' class is\n   * applied.\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed\n   *\n   * @type Function(node: HtmlElement)\n   */\n  onExit: PropTypes.func,\n\n  /**\n   * A `<Transition>` callback fired immediately after the 'exit-active' is applied.\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed\n   *\n   * @type Function(node: HtmlElement)\n   */\n  onExiting: PropTypes.func,\n\n  /**\n   * A `<Transition>` callback fired immediately after the 'exit' classes\n   * are **removed** and the `exit-done` class is added to the DOM node.\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed\n   *\n   * @type Function(node: HtmlElement)\n   */\n  onExited: PropTypes.func\n}) : {};\nexport default CSSTransition;","import hasClass from './hasClass';\n/**\n * Adds a CSS class to a given element.\n * \n * @param element the element\n * @param className the CSS class name\n */\n\nexport default function addClass(element, className) {\n  if (element.classList) element.classList.add(className);else if (!hasClass(element, className)) if (typeof element.className === 'string') element.className = element.className + \" \" + className;else element.setAttribute('class', (element.className && element.className.baseVal || '') + \" \" + className);\n}","/**\n * Checks if a given element has a CSS class.\n * \n * @param element the element\n * @param className the CSS class name\n */\nexport default function hasClass(element, className) {\n  if (element.classList) return !!className && element.classList.contains(className);\n  return (\" \" + (element.className.baseVal || element.className) + \" \").indexOf(\" \" + className + \" \") !== -1;\n}","import _inheritsLoose from \"@babel/runtime/helpers/esm/inheritsLoose\";\n\nvar _leaveRenders, _enterRenders;\n\nimport React from 'react';\nimport PropTypes from 'prop-types';\nimport { ENTERED, ENTERING, EXITING } from './Transition';\nimport TransitionGroupContext from './TransitionGroupContext';\n\nfunction areChildrenDifferent(oldChildren, newChildren) {\n  if (oldChildren === newChildren) return false;\n\n  if (React.isValidElement(oldChildren) && React.isValidElement(newChildren) && oldChildren.key != null && oldChildren.key === newChildren.key) {\n    return false;\n  }\n\n  return true;\n}\n/**\n * Enum of modes for SwitchTransition component\n * @enum { string }\n */\n\n\nexport var modes = {\n  out: 'out-in',\n  in: 'in-out'\n};\n\nvar callHook = function callHook(element, name, cb) {\n  return function () {\n    var _element$props;\n\n    element.props[name] && (_element$props = element.props)[name].apply(_element$props, arguments);\n    cb();\n  };\n};\n\nvar leaveRenders = (_leaveRenders = {}, _leaveRenders[modes.out] = function (_ref) {\n  var current = _ref.current,\n      changeState = _ref.changeState;\n  return React.cloneElement(current, {\n    in: false,\n    onExited: callHook(current, 'onExited', function () {\n      changeState(ENTERING, null);\n    })\n  });\n}, _leaveRenders[modes.in] = function (_ref2) {\n  var current = _ref2.current,\n      changeState = _ref2.changeState,\n      children = _ref2.children;\n  return [current, React.cloneElement(children, {\n    in: true,\n    onEntered: callHook(children, 'onEntered', function () {\n      changeState(ENTERING);\n    })\n  })];\n}, _leaveRenders);\nvar enterRenders = (_enterRenders = {}, _enterRenders[modes.out] = function (_ref3) {\n  var children = _ref3.children,\n      changeState = _ref3.changeState;\n  return React.cloneElement(children, {\n    in: true,\n    onEntered: callHook(children, 'onEntered', function () {\n      changeState(ENTERED, React.cloneElement(children, {\n        in: true\n      }));\n    })\n  });\n}, _enterRenders[modes.in] = function (_ref4) {\n  var current = _ref4.current,\n      children = _ref4.children,\n      changeState = _ref4.changeState;\n  return [React.cloneElement(current, {\n    in: false,\n    onExited: callHook(current, 'onExited', function () {\n      changeState(ENTERED, React.cloneElement(children, {\n        in: true\n      }));\n    })\n  }), React.cloneElement(children, {\n    in: true\n  })];\n}, _enterRenders);\n/**\n * A transition component inspired by the [vue transition modes](https://vuejs.org/v2/guide/transitions.html#Transition-Modes).\n * You can use it when you want to control the render between state transitions.\n * Based on the selected mode and the child's key which is the `Transition` or `CSSTransition` component, the `SwitchTransition` makes a consistent transition between them.\n *\n * If the `out-in` mode is selected, the `SwitchTransition` waits until the old child leaves and then inserts a new child.\n * If the `in-out` mode is selected, the `SwitchTransition` inserts a new child first, waits for the new child to enter and then removes the old child.\n *\n * **Note**: If you want the animation to happen simultaneously\n * (that is, to have the old child removed and a new child inserted **at the same time**),\n * you should use\n * [`TransitionGroup`](https://reactcommunity.org/react-transition-group/transition-group)\n * instead.\n *\n * ```jsx\n * function App() {\n *  const [state, setState] = useState(false);\n *  return (\n *    <SwitchTransition>\n *      <CSSTransition\n *        key={state ? \"Goodbye, world!\" : \"Hello, world!\"}\n *        addEndListener={(node, done) => node.addEventListener(\"transitionend\", done, false)}\n *        classNames='fade'\n *      >\n *        <button onClick={() => setState(state => !state)}>\n *          {state ? \"Goodbye, world!\" : \"Hello, world!\"}\n *        </button>\n *      </CSSTransition>\n *    </SwitchTransition>\n *  );\n * }\n * ```\n *\n * ```css\n * .fade-enter{\n *    opacity: 0;\n * }\n * .fade-exit{\n *    opacity: 1;\n * }\n * .fade-enter-active{\n *    opacity: 1;\n * }\n * .fade-exit-active{\n *    opacity: 0;\n * }\n * .fade-enter-active,\n * .fade-exit-active{\n *    transition: opacity 500ms;\n * }\n * ```\n */\n\nvar SwitchTransition = /*#__PURE__*/function (_React$Component) {\n  _inheritsLoose(SwitchTransition, _React$Component);\n\n  function SwitchTransition() {\n    var _this;\n\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    _this = _React$Component.call.apply(_React$Component, [this].concat(args)) || this;\n    _this.state = {\n      status: ENTERED,\n      current: null\n    };\n    _this.appeared = false;\n\n    _this.changeState = function (status, current) {\n      if (current === void 0) {\n        current = _this.state.current;\n      }\n\n      _this.setState({\n        status: status,\n        current: current\n      });\n    };\n\n    return _this;\n  }\n\n  var _proto = SwitchTransition.prototype;\n\n  _proto.componentDidMount = function componentDidMount() {\n    this.appeared = true;\n  };\n\n  SwitchTransition.getDerivedStateFromProps = function getDerivedStateFromProps(props, state) {\n    if (props.children == null) {\n      return {\n        current: null\n      };\n    }\n\n    if (state.status === ENTERING && props.mode === modes.in) {\n      return {\n        status: ENTERING\n      };\n    }\n\n    if (state.current && areChildrenDifferent(state.current, props.children)) {\n      return {\n        status: EXITING\n      };\n    }\n\n    return {\n      current: React.cloneElement(props.children, {\n        in: true\n      })\n    };\n  };\n\n  _proto.render = function render() {\n    var _this$props = this.props,\n        children = _this$props.children,\n        mode = _this$props.mode,\n        _this$state = this.state,\n        status = _this$state.status,\n        current = _this$state.current;\n    var data = {\n      children: children,\n      current: current,\n      changeState: this.changeState,\n      status: status\n    };\n    var component;\n\n    switch (status) {\n      case ENTERING:\n        component = enterRenders[mode](data);\n        break;\n\n      case EXITING:\n        component = leaveRenders[mode](data);\n        break;\n\n      case ENTERED:\n        component = current;\n    }\n\n    return /*#__PURE__*/React.createElement(TransitionGroupContext.Provider, {\n      value: {\n        isMounting: !this.appeared\n      }\n    }, component);\n  };\n\n  return SwitchTransition;\n}(React.Component);\n\nSwitchTransition.propTypes = process.env.NODE_ENV !== \"production\" ? {\n  /**\n   * Transition modes.\n   * `out-in`: Current element transitions out first, then when complete, the new element transitions in.\n   * `in-out`: New element transitions in first, then when complete, the current element transitions out.\n   *\n   * @type {'out-in'|'in-out'}\n   */\n  mode: PropTypes.oneOf([modes.in, modes.out]),\n\n  /**\n   * Any `Transition` or `CSSTransition` component.\n   */\n  children: PropTypes.oneOfType([PropTypes.element.isRequired])\n} : {};\nSwitchTransition.defaultProps = {\n  mode: modes.out\n};\nexport default SwitchTransition;","export default {\n  disabled: false\n};","import _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport _inheritsLoose from \"@babel/runtime/helpers/esm/inheritsLoose\";\nimport PropTypes from 'prop-types';\nimport React from 'react';\nimport ReactDOM from 'react-dom';\nimport config from './config';\nimport { timeoutsShape } from './utils/PropTypes';\nimport TransitionGroupContext from './TransitionGroupContext';\nimport { forceReflow } from './utils/reflow';\nexport var UNMOUNTED = 'unmounted';\nexport var EXITED = 'exited';\nexport var ENTERING = 'entering';\nexport var ENTERED = 'entered';\nexport var EXITING = 'exiting';\n/**\n * The Transition component lets you describe a transition from one component\n * state to another _over time_ with a simple declarative API. Most commonly\n * it's used to animate the mounting and unmounting of a component, but can also\n * be used to describe in-place transition states as well.\n *\n * ---\n *\n * **Note**: `Transition` is a platform-agnostic base component. If you're using\n * transitions in CSS, you'll probably want to use\n * [`CSSTransition`](https://reactcommunity.org/react-transition-group/css-transition)\n * instead. It inherits all the features of `Transition`, but contains\n * additional features necessary to play nice with CSS transitions (hence the\n * name of the component).\n *\n * ---\n *\n * By default the `Transition` component does not alter the behavior of the\n * component it renders, it only tracks \"enter\" and \"exit\" states for the\n * components. It's up to you to give meaning and effect to those states. For\n * example we can add styles to a component when it enters or exits:\n *\n * ```jsx\n * import { Transition } from 'react-transition-group';\n *\n * const duration = 300;\n *\n * const defaultStyle = {\n *   transition: `opacity ${duration}ms ease-in-out`,\n *   opacity: 0,\n * }\n *\n * const transitionStyles = {\n *   entering: { opacity: 1 },\n *   entered:  { opacity: 1 },\n *   exiting:  { opacity: 0 },\n *   exited:  { opacity: 0 },\n * };\n *\n * const Fade = ({ in: inProp }) => (\n *   <Transition in={inProp} timeout={duration}>\n *     {state => (\n *       <div style={{\n *         ...defaultStyle,\n *         ...transitionStyles[state]\n *       }}>\n *         I'm a fade Transition!\n *       </div>\n *     )}\n *   </Transition>\n * );\n * ```\n *\n * There are 4 main states a Transition can be in:\n *  - `'entering'`\n *  - `'entered'`\n *  - `'exiting'`\n *  - `'exited'`\n *\n * Transition state is toggled via the `in` prop. When `true` the component\n * begins the \"Enter\" stage. During this stage, the component will shift from\n * its current transition state, to `'entering'` for the duration of the\n * transition and then to the `'entered'` stage once it's complete. Let's take\n * the following example (we'll use the\n * [useState](https://reactjs.org/docs/hooks-reference.html#usestate) hook):\n *\n * ```jsx\n * function App() {\n *   const [inProp, setInProp] = useState(false);\n *   return (\n *     <div>\n *       <Transition in={inProp} timeout={500}>\n *         {state => (\n *           // ...\n *         )}\n *       </Transition>\n *       <button onClick={() => setInProp(true)}>\n *         Click to Enter\n *       </button>\n *     </div>\n *   );\n * }\n * ```\n *\n * When the button is clicked the component will shift to the `'entering'` state\n * and stay there for 500ms (the value of `timeout`) before it finally switches\n * to `'entered'`.\n *\n * When `in` is `false` the same thing happens except the state moves from\n * `'exiting'` to `'exited'`.\n */\n\nvar Transition = /*#__PURE__*/function (_React$Component) {\n  _inheritsLoose(Transition, _React$Component);\n\n  function Transition(props, context) {\n    var _this;\n\n    _this = _React$Component.call(this, props, context) || this;\n    var parentGroup = context; // In the context of a TransitionGroup all enters are really appears\n\n    var appear = parentGroup && !parentGroup.isMounting ? props.enter : props.appear;\n    var initialStatus;\n    _this.appearStatus = null;\n\n    if (props.in) {\n      if (appear) {\n        initialStatus = EXITED;\n        _this.appearStatus = ENTERING;\n      } else {\n        initialStatus = ENTERED;\n      }\n    } else {\n      if (props.unmountOnExit || props.mountOnEnter) {\n        initialStatus = UNMOUNTED;\n      } else {\n        initialStatus = EXITED;\n      }\n    }\n\n    _this.state = {\n      status: initialStatus\n    };\n    _this.nextCallback = null;\n    return _this;\n  }\n\n  Transition.getDerivedStateFromProps = function getDerivedStateFromProps(_ref, prevState) {\n    var nextIn = _ref.in;\n\n    if (nextIn && prevState.status === UNMOUNTED) {\n      return {\n        status: EXITED\n      };\n    }\n\n    return null;\n  } // getSnapshotBeforeUpdate(prevProps) {\n  //   let nextStatus = null\n  //   if (prevProps !== this.props) {\n  //     const { status } = this.state\n  //     if (this.props.in) {\n  //       if (status !== ENTERING && status !== ENTERED) {\n  //         nextStatus = ENTERING\n  //       }\n  //     } else {\n  //       if (status === ENTERING || status === ENTERED) {\n  //         nextStatus = EXITING\n  //       }\n  //     }\n  //   }\n  //   return { nextStatus }\n  // }\n  ;\n\n  var _proto = Transition.prototype;\n\n  _proto.componentDidMount = function componentDidMount() {\n    this.updateStatus(true, this.appearStatus);\n  };\n\n  _proto.componentDidUpdate = function componentDidUpdate(prevProps) {\n    var nextStatus = null;\n\n    if (prevProps !== this.props) {\n      var status = this.state.status;\n\n      if (this.props.in) {\n        if (status !== ENTERING && status !== ENTERED) {\n          nextStatus = ENTERING;\n        }\n      } else {\n        if (status === ENTERING || status === ENTERED) {\n          nextStatus = EXITING;\n        }\n      }\n    }\n\n    this.updateStatus(false, nextStatus);\n  };\n\n  _proto.componentWillUnmount = function componentWillUnmount() {\n    this.cancelNextCallback();\n  };\n\n  _proto.getTimeouts = function getTimeouts() {\n    var timeout = this.props.timeout;\n    var exit, enter, appear;\n    exit = enter = appear = timeout;\n\n    if (timeout != null && typeof timeout !== 'number') {\n      exit = timeout.exit;\n      enter = timeout.enter; // TODO: remove fallback for next major\n\n      appear = timeout.appear !== undefined ? timeout.appear : enter;\n    }\n\n    return {\n      exit: exit,\n      enter: enter,\n      appear: appear\n    };\n  };\n\n  _proto.updateStatus = function updateStatus(mounting, nextStatus) {\n    if (mounting === void 0) {\n      mounting = false;\n    }\n\n    if (nextStatus !== null) {\n      // nextStatus will always be ENTERING or EXITING.\n      this.cancelNextCallback();\n\n      if (nextStatus === ENTERING) {\n        if (this.props.unmountOnExit || this.props.mountOnEnter) {\n          var node = this.props.nodeRef ? this.props.nodeRef.current : ReactDOM.findDOMNode(this); // https://github.com/reactjs/react-transition-group/pull/749\n          // With unmountOnExit or mountOnEnter, the enter animation should happen at the transition between `exited` and `entering`.\n          // To make the animation happen,  we have to separate each rendering and avoid being processed as batched.\n\n          if (node) forceReflow(node);\n        }\n\n        this.performEnter(mounting);\n      } else {\n        this.performExit();\n      }\n    } else if (this.props.unmountOnExit && this.state.status === EXITED) {\n      this.setState({\n        status: UNMOUNTED\n      });\n    }\n  };\n\n  _proto.performEnter = function performEnter(mounting) {\n    var _this2 = this;\n\n    var enter = this.props.enter;\n    var appearing = this.context ? this.context.isMounting : mounting;\n\n    var _ref2 = this.props.nodeRef ? [appearing] : [ReactDOM.findDOMNode(this), appearing],\n        maybeNode = _ref2[0],\n        maybeAppearing = _ref2[1];\n\n    var timeouts = this.getTimeouts();\n    var enterTimeout = appearing ? timeouts.appear : timeouts.enter; // no enter animation skip right to ENTERED\n    // if we are mounting and running this it means appear _must_ be set\n\n    if (!mounting && !enter || config.disabled) {\n      this.safeSetState({\n        status: ENTERED\n      }, function () {\n        _this2.props.onEntered(maybeNode);\n      });\n      return;\n    }\n\n    this.props.onEnter(maybeNode, maybeAppearing);\n    this.safeSetState({\n      status: ENTERING\n    }, function () {\n      _this2.props.onEntering(maybeNode, maybeAppearing);\n\n      _this2.onTransitionEnd(enterTimeout, function () {\n        _this2.safeSetState({\n          status: ENTERED\n        }, function () {\n          _this2.props.onEntered(maybeNode, maybeAppearing);\n        });\n      });\n    });\n  };\n\n  _proto.performExit = function performExit() {\n    var _this3 = this;\n\n    var exit = this.props.exit;\n    var timeouts = this.getTimeouts();\n    var maybeNode = this.props.nodeRef ? undefined : ReactDOM.findDOMNode(this); // no exit animation skip right to EXITED\n\n    if (!exit || config.disabled) {\n      this.safeSetState({\n        status: EXITED\n      }, function () {\n        _this3.props.onExited(maybeNode);\n      });\n      return;\n    }\n\n    this.props.onExit(maybeNode);\n    this.safeSetState({\n      status: EXITING\n    }, function () {\n      _this3.props.onExiting(maybeNode);\n\n      _this3.onTransitionEnd(timeouts.exit, function () {\n        _this3.safeSetState({\n          status: EXITED\n        }, function () {\n          _this3.props.onExited(maybeNode);\n        });\n      });\n    });\n  };\n\n  _proto.cancelNextCallback = function cancelNextCallback() {\n    if (this.nextCallback !== null) {\n      this.nextCallback.cancel();\n      this.nextCallback = null;\n    }\n  };\n\n  _proto.safeSetState = function safeSetState(nextState, callback) {\n    // This shouldn't be necessary, but there are weird race conditions with\n    // setState callbacks and unmounting in testing, so always make sure that\n    // we can cancel any pending setState callbacks after we unmount.\n    callback = this.setNextCallback(callback);\n    this.setState(nextState, callback);\n  };\n\n  _proto.setNextCallback = function setNextCallback(callback) {\n    var _this4 = this;\n\n    var active = true;\n\n    this.nextCallback = function (event) {\n      if (active) {\n        active = false;\n        _this4.nextCallback = null;\n        callback(event);\n      }\n    };\n\n    this.nextCallback.cancel = function () {\n      active = false;\n    };\n\n    return this.nextCallback;\n  };\n\n  _proto.onTransitionEnd = function onTransitionEnd(timeout, handler) {\n    this.setNextCallback(handler);\n    var node = this.props.nodeRef ? this.props.nodeRef.current : ReactDOM.findDOMNode(this);\n    var doesNotHaveTimeoutOrListener = timeout == null && !this.props.addEndListener;\n\n    if (!node || doesNotHaveTimeoutOrListener) {\n      setTimeout(this.nextCallback, 0);\n      return;\n    }\n\n    if (this.props.addEndListener) {\n      var _ref3 = this.props.nodeRef ? [this.nextCallback] : [node, this.nextCallback],\n          maybeNode = _ref3[0],\n          maybeNextCallback = _ref3[1];\n\n      this.props.addEndListener(maybeNode, maybeNextCallback);\n    }\n\n    if (timeout != null) {\n      setTimeout(this.nextCallback, timeout);\n    }\n  };\n\n  _proto.render = function render() {\n    var status = this.state.status;\n\n    if (status === UNMOUNTED) {\n      return null;\n    }\n\n    var _this$props = this.props,\n        children = _this$props.children,\n        _in = _this$props.in,\n        _mountOnEnter = _this$props.mountOnEnter,\n        _unmountOnExit = _this$props.unmountOnExit,\n        _appear = _this$props.appear,\n        _enter = _this$props.enter,\n        _exit = _this$props.exit,\n        _timeout = _this$props.timeout,\n        _addEndListener = _this$props.addEndListener,\n        _onEnter = _this$props.onEnter,\n        _onEntering = _this$props.onEntering,\n        _onEntered = _this$props.onEntered,\n        _onExit = _this$props.onExit,\n        _onExiting = _this$props.onExiting,\n        _onExited = _this$props.onExited,\n        _nodeRef = _this$props.nodeRef,\n        childProps = _objectWithoutPropertiesLoose(_this$props, [\"children\", \"in\", \"mountOnEnter\", \"unmountOnExit\", \"appear\", \"enter\", \"exit\", \"timeout\", \"addEndListener\", \"onEnter\", \"onEntering\", \"onEntered\", \"onExit\", \"onExiting\", \"onExited\", \"nodeRef\"]);\n\n    return (\n      /*#__PURE__*/\n      // allows for nested Transitions\n      React.createElement(TransitionGroupContext.Provider, {\n        value: null\n      }, typeof children === 'function' ? children(status, childProps) : React.cloneElement(React.Children.only(children), childProps))\n    );\n  };\n\n  return Transition;\n}(React.Component);\n\nTransition.contextType = TransitionGroupContext;\nTransition.propTypes = process.env.NODE_ENV !== \"production\" ? {\n  /**\n   * A React reference to DOM element that need to transition:\n   * https://stackoverflow.com/a/51127130/4671932\n   *\n   *   - When `nodeRef` prop is used, `node` is not passed to callback functions\n   *      (e.g. `onEnter`) because user already has direct access to the node.\n   *   - When changing `key` prop of `Transition` in a `TransitionGroup` a new\n   *     `nodeRef` need to be provided to `Transition` with changed `key` prop\n   *     (see\n   *     [test/CSSTransition-test.js](https://github.com/reactjs/react-transition-group/blob/13435f897b3ab71f6e19d724f145596f5910581c/test/CSSTransition-test.js#L362-L437)).\n   */\n  nodeRef: PropTypes.shape({\n    current: typeof Element === 'undefined' ? PropTypes.any : function (propValue, key, componentName, location, propFullName, secret) {\n      var value = propValue[key];\n      return PropTypes.instanceOf(value && 'ownerDocument' in value ? value.ownerDocument.defaultView.Element : Element)(propValue, key, componentName, location, propFullName, secret);\n    }\n  }),\n\n  /**\n   * A `function` child can be used instead of a React element. This function is\n   * called with the current transition status (`'entering'`, `'entered'`,\n   * `'exiting'`, `'exited'`), which can be used to apply context\n   * specific props to a component.\n   *\n   * ```jsx\n   * <Transition in={this.state.in} timeout={150}>\n   *   {state => (\n   *     <MyComponent className={`fade fade-${state}`} />\n   *   )}\n   * </Transition>\n   * ```\n   */\n  children: PropTypes.oneOfType([PropTypes.func.isRequired, PropTypes.element.isRequired]).isRequired,\n\n  /**\n   * Show the component; triggers the enter or exit states\n   */\n  in: PropTypes.bool,\n\n  /**\n   * By default the child component is mounted immediately along with\n   * the parent `Transition` component. If you want to \"lazy mount\" the component on the\n   * first `in={true}` you can set `mountOnEnter`. After the first enter transition the component will stay\n   * mounted, even on \"exited\", unless you also specify `unmountOnExit`.\n   */\n  mountOnEnter: PropTypes.bool,\n\n  /**\n   * By default the child component stays mounted after it reaches the `'exited'` state.\n   * Set `unmountOnExit` if you'd prefer to unmount the component after it finishes exiting.\n   */\n  unmountOnExit: PropTypes.bool,\n\n  /**\n   * By default the child component does not perform the enter transition when\n   * it first mounts, regardless of the value of `in`. If you want this\n   * behavior, set both `appear` and `in` to `true`.\n   *\n   * > **Note**: there are no special appear states like `appearing`/`appeared`, this prop\n   * > only adds an additional enter transition. However, in the\n   * > `<CSSTransition>` component that first enter transition does result in\n   * > additional `.appear-*` classes, that way you can choose to style it\n   * > differently.\n   */\n  appear: PropTypes.bool,\n\n  /**\n   * Enable or disable enter transitions.\n   */\n  enter: PropTypes.bool,\n\n  /**\n   * Enable or disable exit transitions.\n   */\n  exit: PropTypes.bool,\n\n  /**\n   * The duration of the transition, in milliseconds.\n   * Required unless `addEndListener` is provided.\n   *\n   * You may specify a single timeout for all transitions:\n   *\n   * ```jsx\n   * timeout={500}\n   * ```\n   *\n   * or individually:\n   *\n   * ```jsx\n   * timeout={{\n   *  appear: 500,\n   *  enter: 300,\n   *  exit: 500,\n   * }}\n   * ```\n   *\n   * - `appear` defaults to the value of `enter`\n   * - `enter` defaults to `0`\n   * - `exit` defaults to `0`\n   *\n   * @type {number | { enter?: number, exit?: number, appear?: number }}\n   */\n  timeout: function timeout(props) {\n    var pt = timeoutsShape;\n    if (!props.addEndListener) pt = pt.isRequired;\n\n    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n      args[_key - 1] = arguments[_key];\n    }\n\n    return pt.apply(void 0, [props].concat(args));\n  },\n\n  /**\n   * Add a custom transition end trigger. Called with the transitioning\n   * DOM node and a `done` callback. Allows for more fine grained transition end\n   * logic. Timeouts are still used as a fallback if provided.\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\n   *\n   * ```jsx\n   * addEndListener={(node, done) => {\n   *   // use the css transitionend event to mark the finish of a transition\n   *   node.addEventListener('transitionend', done, false);\n   * }}\n   * ```\n   */\n  addEndListener: PropTypes.func,\n\n  /**\n   * Callback fired before the \"entering\" status is applied. An extra parameter\n   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\n   *\n   * @type Function(node: HtmlElement, isAppearing: bool) -> void\n   */\n  onEnter: PropTypes.func,\n\n  /**\n   * Callback fired after the \"entering\" status is applied. An extra parameter\n   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\n   *\n   * @type Function(node: HtmlElement, isAppearing: bool)\n   */\n  onEntering: PropTypes.func,\n\n  /**\n   * Callback fired after the \"entered\" status is applied. An extra parameter\n   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\n   *\n   * @type Function(node: HtmlElement, isAppearing: bool) -> void\n   */\n  onEntered: PropTypes.func,\n\n  /**\n   * Callback fired before the \"exiting\" status is applied.\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\n   *\n   * @type Function(node: HtmlElement) -> void\n   */\n  onExit: PropTypes.func,\n\n  /**\n   * Callback fired after the \"exiting\" status is applied.\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\n   *\n   * @type Function(node: HtmlElement) -> void\n   */\n  onExiting: PropTypes.func,\n\n  /**\n   * Callback fired after the \"exited\" status is applied.\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed\n   *\n   * @type Function(node: HtmlElement) -> void\n   */\n  onExited: PropTypes.func\n} : {}; // Name the function so it is clearer in the documentation\n\nfunction noop() {}\n\nTransition.defaultProps = {\n  in: false,\n  mountOnEnter: false,\n  unmountOnExit: false,\n  appear: false,\n  enter: true,\n  exit: true,\n  onEnter: noop,\n  onEntering: noop,\n  onEntered: noop,\n  onExit: noop,\n  onExiting: noop,\n  onExited: noop\n};\nTransition.UNMOUNTED = UNMOUNTED;\nTransition.EXITED = EXITED;\nTransition.ENTERING = ENTERING;\nTransition.ENTERED = ENTERED;\nTransition.EXITING = EXITING;\nexport default Transition;","import React from 'react';\nexport default React.createContext(null);","export var forceReflow = function forceReflow(node) {\n  return node.scrollTop;\n};","/**\n * @license React\n * react-jsx-runtime.production.min.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n'use strict';var f=require(\"react\"),k=Symbol.for(\"react.element\"),l=Symbol.for(\"react.fragment\"),m=Object.prototype.hasOwnProperty,n=f.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner,p={key:!0,ref:!0,__self:!0,__source:!0};\nfunction q(c,a,g){var b,d={},e=null,h=null;void 0!==g&&(e=\"\"+g);void 0!==a.key&&(e=\"\"+a.key);void 0!==a.ref&&(h=a.ref);for(b in a)m.call(a,b)&&!p.hasOwnProperty(b)&&(d[b]=a[b]);if(c&&c.defaultProps)for(b in a=c.defaultProps,a)void 0===d[b]&&(d[b]=a[b]);return{$$typeof:k,type:c,key:e,ref:h,props:d,_owner:n.current}}exports.Fragment=l;exports.jsx=q;exports.jsxs=q;\n","/**\n * @license React\n * react.production.min.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n'use strict';var l=Symbol.for(\"react.element\"),n=Symbol.for(\"react.portal\"),p=Symbol.for(\"react.fragment\"),q=Symbol.for(\"react.strict_mode\"),r=Symbol.for(\"react.profiler\"),t=Symbol.for(\"react.provider\"),u=Symbol.for(\"react.context\"),v=Symbol.for(\"react.forward_ref\"),w=Symbol.for(\"react.suspense\"),x=Symbol.for(\"react.memo\"),y=Symbol.for(\"react.lazy\"),z=Symbol.iterator;function A(a){if(null===a||\"object\"!==typeof a)return null;a=z&&a[z]||a[\"@@iterator\"];return\"function\"===typeof a?a:null}\nvar B={isMounted:function(){return!1},enqueueForceUpdate:function(){},enqueueReplaceState:function(){},enqueueSetState:function(){}},C=Object.assign,D={};function E(a,b,e){this.props=a;this.context=b;this.refs=D;this.updater=e||B}E.prototype.isReactComponent={};\nE.prototype.setState=function(a,b){if(\"object\"!==typeof a&&\"function\"!==typeof a&&null!=a)throw Error(\"setState(...): takes an object of state variables to update or a function which returns an object of state variables.\");this.updater.enqueueSetState(this,a,b,\"setState\")};E.prototype.forceUpdate=function(a){this.updater.enqueueForceUpdate(this,a,\"forceUpdate\")};function F(){}F.prototype=E.prototype;function G(a,b,e){this.props=a;this.context=b;this.refs=D;this.updater=e||B}var H=G.prototype=new F;\nH.constructor=G;C(H,E.prototype);H.isPureReactComponent=!0;var I=Array.isArray,J=Object.prototype.hasOwnProperty,K={current:null},L={key:!0,ref:!0,__self:!0,__source:!0};\nfunction M(a,b,e){var d,c={},k=null,h=null;if(null!=b)for(d in void 0!==b.ref&&(h=b.ref),void 0!==b.key&&(k=\"\"+b.key),b)J.call(b,d)&&!L.hasOwnProperty(d)&&(c[d]=b[d]);var g=arguments.length-2;if(1===g)c.children=e;else if(1<g){for(var f=Array(g),m=0;m<g;m++)f[m]=arguments[m+2];c.children=f}if(a&&a.defaultProps)for(d in g=a.defaultProps,g)void 0===c[d]&&(c[d]=g[d]);return{$$typeof:l,type:a,key:k,ref:h,props:c,_owner:K.current}}\nfunction N(a,b){return{$$typeof:l,type:a.type,key:b,ref:a.ref,props:a.props,_owner:a._owner}}function O(a){return\"object\"===typeof a&&null!==a&&a.$$typeof===l}function escape(a){var b={\"=\":\"=0\",\":\":\"=2\"};return\"$\"+a.replace(/[=:]/g,function(a){return b[a]})}var P=/\\/+/g;function Q(a,b){return\"object\"===typeof a&&null!==a&&null!=a.key?escape(\"\"+a.key):b.toString(36)}\nfunction R(a,b,e,d,c){var k=typeof a;if(\"undefined\"===k||\"boolean\"===k)a=null;var h=!1;if(null===a)h=!0;else switch(k){case \"string\":case \"number\":h=!0;break;case \"object\":switch(a.$$typeof){case l:case n:h=!0}}if(h)return h=a,c=c(h),a=\"\"===d?\".\"+Q(h,0):d,I(c)?(e=\"\",null!=a&&(e=a.replace(P,\"$&/\")+\"/\"),R(c,b,e,\"\",function(a){return a})):null!=c&&(O(c)&&(c=N(c,e+(!c.key||h&&h.key===c.key?\"\":(\"\"+c.key).replace(P,\"$&/\")+\"/\")+a)),b.push(c)),1;h=0;d=\"\"===d?\".\":d+\":\";if(I(a))for(var g=0;g<a.length;g++){k=\na[g];var f=d+Q(k,g);h+=R(k,b,e,f,c)}else if(f=A(a),\"function\"===typeof f)for(a=f.call(a),g=0;!(k=a.next()).done;)k=k.value,f=d+Q(k,g++),h+=R(k,b,e,f,c);else if(\"object\"===k)throw b=String(a),Error(\"Objects are not valid as a React child (found: \"+(\"[object Object]\"===b?\"object with keys {\"+Object.keys(a).join(\", \")+\"}\":b)+\"). If you meant to render a collection of children, use an array instead.\");return h}\nfunction S(a,b,e){if(null==a)return a;var d=[],c=0;R(a,d,\"\",\"\",function(a){return b.call(e,a,c++)});return d}function T(a){if(-1===a._status){var b=a._result;b=b();b.then(function(b){if(0===a._status||-1===a._status)a._status=1,a._result=b},function(b){if(0===a._status||-1===a._status)a._status=2,a._result=b});-1===a._status&&(a._status=0,a._result=b)}if(1===a._status)return a._result.default;throw a._result;}\nvar U={current:null},V={transition:null},W={ReactCurrentDispatcher:U,ReactCurrentBatchConfig:V,ReactCurrentOwner:K};function X(){throw Error(\"act(...) is not supported in production builds of React.\");}\nexports.Children={map:S,forEach:function(a,b,e){S(a,function(){b.apply(this,arguments)},e)},count:function(a){var b=0;S(a,function(){b++});return b},toArray:function(a){return S(a,function(a){return a})||[]},only:function(a){if(!O(a))throw Error(\"React.Children.only expected to receive a single React element child.\");return a}};exports.Component=E;exports.Fragment=p;exports.Profiler=r;exports.PureComponent=G;exports.StrictMode=q;exports.Suspense=w;\nexports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED=W;exports.act=X;\nexports.cloneElement=function(a,b,e){if(null===a||void 0===a)throw Error(\"React.cloneElement(...): The argument must be a React element, but you passed \"+a+\".\");var d=C({},a.props),c=a.key,k=a.ref,h=a._owner;if(null!=b){void 0!==b.ref&&(k=b.ref,h=K.current);void 0!==b.key&&(c=\"\"+b.key);if(a.type&&a.type.defaultProps)var g=a.type.defaultProps;for(f in b)J.call(b,f)&&!L.hasOwnProperty(f)&&(d[f]=void 0===b[f]&&void 0!==g?g[f]:b[f])}var f=arguments.length-2;if(1===f)d.children=e;else if(1<f){g=Array(f);\nfor(var m=0;m<f;m++)g[m]=arguments[m+2];d.children=g}return{$$typeof:l,type:a.type,key:c,ref:k,props:d,_owner:h}};exports.createContext=function(a){a={$$typeof:u,_currentValue:a,_currentValue2:a,_threadCount:0,Provider:null,Consumer:null,_defaultValue:null,_globalName:null};a.Provider={$$typeof:t,_context:a};return a.Consumer=a};exports.createElement=M;exports.createFactory=function(a){var b=M.bind(null,a);b.type=a;return b};exports.createRef=function(){return{current:null}};\nexports.forwardRef=function(a){return{$$typeof:v,render:a}};exports.isValidElement=O;exports.lazy=function(a){return{$$typeof:y,_payload:{_status:-1,_result:a},_init:T}};exports.memo=function(a,b){return{$$typeof:x,type:a,compare:void 0===b?null:b}};exports.startTransition=function(a){var b=V.transition;V.transition={};try{a()}finally{V.transition=b}};exports.unstable_act=X;exports.useCallback=function(a,b){return U.current.useCallback(a,b)};exports.useContext=function(a){return U.current.useContext(a)};\nexports.useDebugValue=function(){};exports.useDeferredValue=function(a){return U.current.useDeferredValue(a)};exports.useEffect=function(a,b){return U.current.useEffect(a,b)};exports.useId=function(){return U.current.useId()};exports.useImperativeHandle=function(a,b,e){return U.current.useImperativeHandle(a,b,e)};exports.useInsertionEffect=function(a,b){return U.current.useInsertionEffect(a,b)};exports.useLayoutEffect=function(a,b){return U.current.useLayoutEffect(a,b)};\nexports.useMemo=function(a,b){return U.current.useMemo(a,b)};exports.useReducer=function(a,b,e){return U.current.useReducer(a,b,e)};exports.useRef=function(a){return U.current.useRef(a)};exports.useState=function(a){return U.current.useState(a)};exports.useSyncExternalStore=function(a,b,e){return U.current.useSyncExternalStore(a,b,e)};exports.useTransition=function(){return U.current.useTransition()};exports.version=\"18.3.1\";\n","'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('./cjs/react.production.min.js');\n} else {\n  module.exports = require('./cjs/react.development.js');\n}\n","'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('./cjs/react-jsx-runtime.production.min.js');\n} else {\n  module.exports = require('./cjs/react-jsx-runtime.development.js');\n}\n","/* eslint-disable @typescript-eslint/strict-boolean-expressions */\n\n// ---------------------------------------------------------------------------\n// Specific encodings\n// ---------------------------------------------------------------------------\nvar base16Encoding = {\n  chars: '0123456789ABCDEF',\n  bits: 4\n};\nvar base32Encoding = {\n  chars: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567',\n  bits: 5\n};\nvar base32HexEncoding = {\n  chars: '0123456789ABCDEFGHIJKLMNOPQRSTUV',\n  bits: 5\n};\nvar base64Encoding = {\n  chars: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/',\n  bits: 6\n};\nvar base64UrlEncoding = {\n  chars: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_',\n  bits: 6\n};\nvar base16 = {\n  parse: function parse(string, opts) {\n    return _parse(string.toUpperCase(), base16Encoding, opts);\n  },\n  stringify: function stringify(data, opts) {\n    return _stringify(data, base16Encoding, opts);\n  }\n};\nvar base32 = {\n  parse: function parse(string, opts) {\n    if (opts === void 0) {\n      opts = {};\n    }\n    return _parse(opts.loose ? string.toUpperCase().replace(/0/g, 'O').replace(/1/g, 'L').replace(/8/g, 'B') : string, base32Encoding, opts);\n  },\n  stringify: function stringify(data, opts) {\n    return _stringify(data, base32Encoding, opts);\n  }\n};\nvar base32hex = {\n  parse: function parse(string, opts) {\n    return _parse(string, base32HexEncoding, opts);\n  },\n  stringify: function stringify(data, opts) {\n    return _stringify(data, base32HexEncoding, opts);\n  }\n};\nvar base64 = {\n  parse: function parse(string, opts) {\n    return _parse(string, base64Encoding, opts);\n  },\n  stringify: function stringify(data, opts) {\n    return _stringify(data, base64Encoding, opts);\n  }\n};\nvar base64url = {\n  parse: function parse(string, opts) {\n    return _parse(string, base64UrlEncoding, opts);\n  },\n  stringify: function stringify(data, opts) {\n    return _stringify(data, base64UrlEncoding, opts);\n  }\n};\n\n// ---------------------------------------------------------------------------\n// Codec implementation\n// ---------------------------------------------------------------------------\n\nvar codec = {\n  parse: _parse,\n  stringify: _stringify\n};\nfunction _parse(string, encoding, opts) {\n  var _opts$out;\n  if (opts === void 0) {\n    opts = {};\n  }\n  // Build the character lookup table:\n  if (!encoding.codes) {\n    encoding.codes = {};\n    for (var i = 0; i < encoding.chars.length; ++i) {\n      encoding.codes[encoding.chars[i]] = i;\n    }\n  }\n\n  // The string must have a whole number of bytes:\n  if (!opts.loose && string.length * encoding.bits & 7) {\n    throw new SyntaxError('Invalid padding');\n  }\n\n  // Count the padding bytes:\n  var end = string.length;\n  while (string[end - 1] === '=') {\n    --end;\n\n    // If we get a whole number of bytes, there is too much padding:\n    if (!opts.loose && !((string.length - end) * encoding.bits & 7)) {\n      throw new SyntaxError('Invalid padding');\n    }\n  }\n\n  // Allocate the output:\n  var out = new ((_opts$out = opts.out) != null ? _opts$out : Uint8Array)(end * encoding.bits / 8 | 0);\n\n  // Parse the data:\n  var bits = 0; // Number of bits currently in the buffer\n  var buffer = 0; // Bits waiting to be written out, MSB first\n  var written = 0; // Next byte to write\n  for (var _i = 0; _i < end; ++_i) {\n    // Read one character from the string:\n    var value = encoding.codes[string[_i]];\n    if (value === undefined) {\n      throw new SyntaxError('Invalid character ' + string[_i]);\n    }\n\n    // Append the bits to the buffer:\n    buffer = buffer << encoding.bits | value;\n    bits += encoding.bits;\n\n    // Write out some bits if the buffer has a byte's worth:\n    if (bits >= 8) {\n      bits -= 8;\n      out[written++] = 0xff & buffer >> bits;\n    }\n  }\n\n  // Verify that we have received just enough bits:\n  if (bits >= encoding.bits || 0xff & buffer << 8 - bits) {\n    throw new SyntaxError('Unexpected end of data');\n  }\n  return out;\n}\nfunction _stringify(data, encoding, opts) {\n  if (opts === void 0) {\n    opts = {};\n  }\n  var _opts = opts,\n    _opts$pad = _opts.pad,\n    pad = _opts$pad === void 0 ? true : _opts$pad;\n  var mask = (1 << encoding.bits) - 1;\n  var out = '';\n  var bits = 0; // Number of bits currently in the buffer\n  var buffer = 0; // Bits waiting to be written out, MSB first\n  for (var i = 0; i < data.length; ++i) {\n    // Slurp data into the buffer:\n    buffer = buffer << 8 | 0xff & data[i];\n    bits += 8;\n\n    // Write out as much as we can:\n    while (bits > encoding.bits) {\n      bits -= encoding.bits;\n      out += encoding.chars[mask & buffer >> bits];\n    }\n  }\n\n  // Partial character:\n  if (bits) {\n    out += encoding.chars[mask & buffer << encoding.bits - bits];\n  }\n\n  // Add padding characters until we hit a byte boundary:\n  if (pad) {\n    while (out.length * encoding.bits & 7) {\n      out += '=';\n    }\n  }\n  return out;\n}\n\nexport { base16, base32, base32hex, base64, base64url, codec };\n","const htmlparser = require('htmlparser2');\nconst escapeStringRegexp = require('escape-string-regexp');\nconst { isPlainObject } = require('is-plain-object');\nconst deepmerge = require('deepmerge');\nconst parseSrcset = require('parse-srcset');\nconst { parse: postcssParse } = require('postcss');\n// Tags that can conceivably represent stand-alone media.\nconst mediaTags = [\n  'img', 'audio', 'video', 'picture', 'svg',\n  'object', 'map', 'iframe', 'embed'\n];\n// Tags that are inherently vulnerable to being used in XSS attacks.\nconst vulnerableTags = [ 'script', 'style' ];\n\nfunction each(obj, cb) {\n  if (obj) {\n    Object.keys(obj).forEach(function (key) {\n      cb(obj[key], key);\n    });\n  }\n}\n\n// Avoid false positives with .__proto__, .hasOwnProperty, etc.\nfunction has(obj, key) {\n  return ({}).hasOwnProperty.call(obj, key);\n}\n\n// Returns those elements of `a` for which `cb(a)` returns truthy\nfunction filter(a, cb) {\n  const n = [];\n  each(a, function(v) {\n    if (cb(v)) {\n      n.push(v);\n    }\n  });\n  return n;\n}\n\nfunction isEmptyObject(obj) {\n  for (const key in obj) {\n    if (has(obj, key)) {\n      return false;\n    }\n  }\n  return true;\n}\n\nfunction stringifySrcset(parsedSrcset) {\n  return parsedSrcset.map(function(part) {\n    if (!part.url) {\n      throw new Error('URL missing');\n    }\n\n    return (\n      part.url +\n      (part.w ? ` ${part.w}w` : '') +\n      (part.h ? ` ${part.h}h` : '') +\n      (part.d ? ` ${part.d}x` : '')\n    );\n  }).join(', ');\n}\n\nmodule.exports = sanitizeHtml;\n\n// A valid attribute name.\n// We use a tolerant definition based on the set of strings defined by\n// html.spec.whatwg.org/multipage/parsing.html#before-attribute-name-state\n// and html.spec.whatwg.org/multipage/parsing.html#attribute-name-state .\n// The characters accepted are ones which can be appended to the attribute\n// name buffer without triggering a parse error:\n//   * unexpected-equals-sign-before-attribute-name\n//   * unexpected-null-character\n//   * unexpected-character-in-attribute-name\n// We exclude the empty string because it's impossible to get to the after\n// attribute name state with an empty attribute name buffer.\nconst VALID_HTML_ATTRIBUTE_NAME = /^[^\\0\\t\\n\\f\\r /<=>]+$/;\n\n// Ignore the _recursing flag; it's there for recursive\n// invocation as a guard against this exploit:\n// https://github.com/fb55/htmlparser2/issues/105\n\nfunction sanitizeHtml(html, options, _recursing) {\n  if (html == null) {\n    return '';\n  }\n  if (typeof html === 'number') {\n    html = html.toString();\n  }\n\n  let result = '';\n  // Used for hot swapping the result variable with an empty string in order to \"capture\" the text written to it.\n  let tempResult = '';\n\n  function Frame(tag, attribs) {\n    const that = this;\n    this.tag = tag;\n    this.attribs = attribs || {};\n    this.tagPosition = result.length;\n    this.text = ''; // Node inner text\n    this.mediaChildren = [];\n\n    this.updateParentNodeText = function() {\n      if (stack.length) {\n        const parentFrame = stack[stack.length - 1];\n        parentFrame.text += that.text;\n      }\n    };\n\n    this.updateParentNodeMediaChildren = function() {\n      if (stack.length && mediaTags.includes(this.tag)) {\n        const parentFrame = stack[stack.length - 1];\n        parentFrame.mediaChildren.push(this.tag);\n      }\n    };\n  }\n\n  options = Object.assign({}, sanitizeHtml.defaults, options);\n  options.parser = Object.assign({}, htmlParserDefaults, options.parser);\n\n  const tagAllowed = function (name) {\n    return options.allowedTags === false || (options.allowedTags || []).indexOf(name) > -1;\n  };\n\n  // vulnerableTags\n  vulnerableTags.forEach(function (tag) {\n    if (tagAllowed(tag) && !options.allowVulnerableTags) {\n      console.warn(`\\n\\n⚠️ Your \\`allowedTags\\` option includes, \\`${tag}\\`, which is inherently\\nvulnerable to XSS attacks. Please remove it from \\`allowedTags\\`.\\nOr, to disable this warning, add the \\`allowVulnerableTags\\` option\\nand ensure you are accounting for this risk.\\n\\n`);\n    }\n  });\n\n  // Tags that contain something other than HTML, or where discarding\n  // the text when the tag is disallowed makes sense for other reasons.\n  // If we are not allowing these tags, we should drop their content too.\n  // For other tags you would drop the tag but keep its content.\n  const nonTextTagsArray = options.nonTextTags || [\n    'script',\n    'style',\n    'textarea',\n    'option'\n  ];\n  let allowedAttributesMap;\n  let allowedAttributesGlobMap;\n  if (options.allowedAttributes) {\n    allowedAttributesMap = {};\n    allowedAttributesGlobMap = {};\n    each(options.allowedAttributes, function(attributes, tag) {\n      allowedAttributesMap[tag] = [];\n      const globRegex = [];\n      attributes.forEach(function(obj) {\n        if (typeof obj === 'string' && obj.indexOf('*') >= 0) {\n          globRegex.push(escapeStringRegexp(obj).replace(/\\\\\\*/g, '.*'));\n        } else {\n          allowedAttributesMap[tag].push(obj);\n        }\n      });\n      if (globRegex.length) {\n        allowedAttributesGlobMap[tag] = new RegExp('^(' + globRegex.join('|') + ')$');\n      }\n    });\n  }\n  const allowedClassesMap = {};\n  const allowedClassesGlobMap = {};\n  const allowedClassesRegexMap = {};\n  each(options.allowedClasses, function(classes, tag) {\n    // Implicitly allows the class attribute\n    if (allowedAttributesMap) {\n      if (!has(allowedAttributesMap, tag)) {\n        allowedAttributesMap[tag] = [];\n      }\n      allowedAttributesMap[tag].push('class');\n    }\n\n    allowedClassesMap[tag] = classes;\n\n    if (Array.isArray(classes)) {\n      const globRegex = [];\n      allowedClassesMap[tag] = [];\n      allowedClassesRegexMap[tag] = [];\n      classes.forEach(function(obj) {\n        if (typeof obj === 'string' && obj.indexOf('*') >= 0) {\n          globRegex.push(escapeStringRegexp(obj).replace(/\\\\\\*/g, '.*'));\n        } else if (obj instanceof RegExp) {\n          allowedClassesRegexMap[tag].push(obj);\n        } else {\n          allowedClassesMap[tag].push(obj);\n        }\n      });\n      if (globRegex.length) {\n        allowedClassesGlobMap[tag] = new RegExp('^(' + globRegex.join('|') + ')$');\n      }\n    }\n  });\n\n  const transformTagsMap = {};\n  let transformTagsAll;\n  each(options.transformTags, function(transform, tag) {\n    let transFun;\n    if (typeof transform === 'function') {\n      transFun = transform;\n    } else if (typeof transform === 'string') {\n      transFun = sanitizeHtml.simpleTransform(transform);\n    }\n    if (tag === '*') {\n      transformTagsAll = transFun;\n    } else {\n      transformTagsMap[tag] = transFun;\n    }\n  });\n\n  let depth;\n  let stack;\n  let skipMap;\n  let transformMap;\n  let skipText;\n  let skipTextDepth;\n  let addedText = false;\n\n  initializeState();\n\n  const parser = new htmlparser.Parser({\n    onopentag: function(name, attribs) {\n      // If `enforceHtmlBoundary` is `true` and this has found the opening\n      // `html` tag, reset the state.\n      if (options.enforceHtmlBoundary && name === 'html') {\n        initializeState();\n      }\n\n      if (skipText) {\n        skipTextDepth++;\n        return;\n      }\n      const frame = new Frame(name, attribs);\n      stack.push(frame);\n\n      let skip = false;\n      const hasText = !!frame.text;\n      let transformedTag;\n      if (has(transformTagsMap, name)) {\n        transformedTag = transformTagsMap[name](name, attribs);\n\n        frame.attribs = attribs = transformedTag.attribs;\n\n        if (transformedTag.text !== undefined) {\n          frame.innerText = transformedTag.text;\n        }\n\n        if (name !== transformedTag.tagName) {\n          frame.name = name = transformedTag.tagName;\n          transformMap[depth] = transformedTag.tagName;\n        }\n      }\n      if (transformTagsAll) {\n        transformedTag = transformTagsAll(name, attribs);\n\n        frame.attribs = attribs = transformedTag.attribs;\n        if (name !== transformedTag.tagName) {\n          frame.name = name = transformedTag.tagName;\n          transformMap[depth] = transformedTag.tagName;\n        }\n      }\n\n      if (!tagAllowed(name) || (options.disallowedTagsMode === 'recursiveEscape' && !isEmptyObject(skipMap)) || (options.nestingLimit != null && depth >= options.nestingLimit)) {\n        skip = true;\n        skipMap[depth] = true;\n        if (options.disallowedTagsMode === 'discard' || options.disallowedTagsMode === 'completelyDiscard') {\n          if (nonTextTagsArray.indexOf(name) !== -1) {\n            skipText = true;\n            skipTextDepth = 1;\n          }\n        }\n        skipMap[depth] = true;\n      }\n      depth++;\n      if (skip) {\n        if (options.disallowedTagsMode === 'discard' || options.disallowedTagsMode === 'completelyDiscard') {\n          // We want the contents but not this tag\n          if (frame.innerText && !hasText) {\n            const escaped = escapeHtml(frame.innerText);\n            if (options.textFilter) {\n              result += options.textFilter(escaped, name);\n            } else {\n              result += escapeHtml(frame.innerText);\n            }\n            addedText = true;\n          }\n          return;\n        }\n        tempResult = result;\n        result = '';\n      }\n      result += '<' + name;\n\n      if (name === 'script') {\n        if (options.allowedScriptHostnames || options.allowedScriptDomains) {\n          frame.innerText = '';\n        }\n      }\n\n      if (!allowedAttributesMap || has(allowedAttributesMap, name) || allowedAttributesMap['*']) {\n        each(attribs, function(value, a) {\n          if (!VALID_HTML_ATTRIBUTE_NAME.test(a)) {\n            // This prevents part of an attribute name in the output from being\n            // interpreted as the end of an attribute, or end of a tag.\n            delete frame.attribs[a];\n            return;\n          }\n          // If the value is empty, check if the attribute is in the allowedEmptyAttributes array.\n          // If it is not in the allowedEmptyAttributes array, and it is a known non-boolean attribute, delete it\n          // List taken from https://html.spec.whatwg.org/multipage/indices.html#attributes-3\n          if (value === '' && (!options.allowedEmptyAttributes.includes(a)) &&\n            (options.nonBooleanAttributes.includes(a) || options.nonBooleanAttributes.includes('*'))) {\n            delete frame.attribs[a];\n            return;\n          }\n          // check allowedAttributesMap for the element and attribute and modify the value\n          // as necessary if there are specific values defined.\n          let passedAllowedAttributesMapCheck = false;\n          if (!allowedAttributesMap ||\n            (has(allowedAttributesMap, name) && allowedAttributesMap[name].indexOf(a) !== -1) ||\n            (allowedAttributesMap['*'] && allowedAttributesMap['*'].indexOf(a) !== -1) ||\n            (has(allowedAttributesGlobMap, name) && allowedAttributesGlobMap[name].test(a)) ||\n            (allowedAttributesGlobMap['*'] && allowedAttributesGlobMap['*'].test(a))) {\n            passedAllowedAttributesMapCheck = true;\n          } else if (allowedAttributesMap && allowedAttributesMap[name]) {\n            for (const o of allowedAttributesMap[name]) {\n              if (isPlainObject(o) && o.name && (o.name === a)) {\n                passedAllowedAttributesMapCheck = true;\n                let newValue = '';\n                if (o.multiple === true) {\n                  // verify the values that are allowed\n                  const splitStrArray = value.split(' ');\n                  for (const s of splitStrArray) {\n                    if (o.values.indexOf(s) !== -1) {\n                      if (newValue === '') {\n                        newValue = s;\n                      } else {\n                        newValue += ' ' + s;\n                      }\n                    }\n                  }\n                } else if (o.values.indexOf(value) >= 0) {\n                  // verified an allowed value matches the entire attribute value\n                  newValue = value;\n                }\n                value = newValue;\n              }\n            }\n          }\n          if (passedAllowedAttributesMapCheck) {\n            if (options.allowedSchemesAppliedToAttributes.indexOf(a) !== -1) {\n              if (naughtyHref(name, value)) {\n                delete frame.attribs[a];\n                return;\n              }\n            }\n\n            if (name === 'script' && a === 'src') {\n\n              let allowed = true;\n\n              try {\n                const parsed = parseUrl(value);\n\n                if (options.allowedScriptHostnames || options.allowedScriptDomains) {\n                  const allowedHostname = (options.allowedScriptHostnames || []).find(function (hostname) {\n                    return hostname === parsed.url.hostname;\n                  });\n                  const allowedDomain = (options.allowedScriptDomains || []).find(function(domain) {\n                    return parsed.url.hostname === domain || parsed.url.hostname.endsWith(`.${domain}`);\n                  });\n                  allowed = allowedHostname || allowedDomain;\n                }\n              } catch (e) {\n                allowed = false;\n              }\n\n              if (!allowed) {\n                delete frame.attribs[a];\n                return;\n              }\n            }\n\n            if (name === 'iframe' && a === 'src') {\n              let allowed = true;\n              try {\n                const parsed = parseUrl(value);\n\n                if (parsed.isRelativeUrl) {\n                  // default value of allowIframeRelativeUrls is true\n                  // unless allowedIframeHostnames or allowedIframeDomains specified\n                  allowed = has(options, 'allowIframeRelativeUrls')\n                    ? options.allowIframeRelativeUrls\n                    : (!options.allowedIframeHostnames && !options.allowedIframeDomains);\n                } else if (options.allowedIframeHostnames || options.allowedIframeDomains) {\n                  const allowedHostname = (options.allowedIframeHostnames || []).find(function (hostname) {\n                    return hostname === parsed.url.hostname;\n                  });\n                  const allowedDomain = (options.allowedIframeDomains || []).find(function(domain) {\n                    return parsed.url.hostname === domain || parsed.url.hostname.endsWith(`.${domain}`);\n                  });\n                  allowed = allowedHostname || allowedDomain;\n                }\n              } catch (e) {\n                // Unparseable iframe src\n                allowed = false;\n              }\n              if (!allowed) {\n                delete frame.attribs[a];\n                return;\n              }\n            }\n            if (a === 'srcset') {\n              try {\n                let parsed = parseSrcset(value);\n                parsed.forEach(function(value) {\n                  if (naughtyHref('srcset', value.url)) {\n                    value.evil = true;\n                  }\n                });\n                parsed = filter(parsed, function(v) {\n                  return !v.evil;\n                });\n                if (!parsed.length) {\n                  delete frame.attribs[a];\n                  return;\n                } else {\n                  value = stringifySrcset(filter(parsed, function(v) {\n                    return !v.evil;\n                  }));\n                  frame.attribs[a] = value;\n                }\n              } catch (e) {\n                // Unparseable srcset\n                delete frame.attribs[a];\n                return;\n              }\n            }\n            if (a === 'class') {\n              const allowedSpecificClasses = allowedClassesMap[name];\n              const allowedWildcardClasses = allowedClassesMap['*'];\n              const allowedSpecificClassesGlob = allowedClassesGlobMap[name];\n              const allowedSpecificClassesRegex = allowedClassesRegexMap[name];\n              const allowedWildcardClassesRegex = allowedClassesRegexMap['*'];\n              const allowedWildcardClassesGlob = allowedClassesGlobMap['*'];\n              const allowedClassesGlobs = [\n                allowedSpecificClassesGlob,\n                allowedWildcardClassesGlob\n              ]\n                .concat(allowedSpecificClassesRegex, allowedWildcardClassesRegex)\n                .filter(function (t) {\n                  return t;\n                });\n              if (allowedSpecificClasses && allowedWildcardClasses) {\n                value = filterClasses(value, deepmerge(allowedSpecificClasses, allowedWildcardClasses), allowedClassesGlobs);\n              } else {\n                value = filterClasses(value, allowedSpecificClasses || allowedWildcardClasses, allowedClassesGlobs);\n              }\n              if (!value.length) {\n                delete frame.attribs[a];\n                return;\n              }\n            }\n            if (a === 'style') {\n              if (options.parseStyleAttributes) {\n                try {\n                  const abstractSyntaxTree = postcssParse(name + ' {' + value + '}', { map: false });\n                  const filteredAST = filterCss(abstractSyntaxTree, options.allowedStyles);\n\n                  value = stringifyStyleAttributes(filteredAST);\n\n                  if (value.length === 0) {\n                    delete frame.attribs[a];\n                    return;\n                  }\n                } catch (e) {\n                  if (typeof window !== 'undefined') {\n                    console.warn('Failed to parse \"' + name + ' {' + value + '}' + '\", If you\\'re running this in a browser, we recommend to disable style parsing: options.parseStyleAttributes: false, since this only works in a node environment due to a postcss dependency, More info: https://github.com/apostrophecms/sanitize-html/issues/547');\n                  }\n                  delete frame.attribs[a];\n                  return;\n                }\n              } else if (options.allowedStyles) {\n                throw new Error('allowedStyles option cannot be used together with parseStyleAttributes: false.');\n              }\n            }\n            result += ' ' + a;\n            if (value && value.length) {\n              result += '=\"' + escapeHtml(value, true) + '\"';\n            } else if (options.allowedEmptyAttributes.includes(a)) {\n              result += '=\"\"';\n            }\n          } else {\n            delete frame.attribs[a];\n          }\n        });\n      }\n      if (options.selfClosing.indexOf(name) !== -1) {\n        result += ' />';\n      } else {\n        result += '>';\n        if (frame.innerText && !hasText && !options.textFilter) {\n          result += escapeHtml(frame.innerText);\n          addedText = true;\n        }\n      }\n      if (skip) {\n        result = tempResult + escapeHtml(result);\n        tempResult = '';\n      }\n    },\n    ontext: function(text) {\n      if (skipText) {\n        return;\n      }\n      const lastFrame = stack[stack.length - 1];\n      let tag;\n\n      if (lastFrame) {\n        tag = lastFrame.tag;\n        // If inner text was set by transform function then let's use it\n        text = lastFrame.innerText !== undefined ? lastFrame.innerText : text;\n      }\n\n      if (options.disallowedTagsMode === 'completelyDiscard' && !tagAllowed(tag)) {\n        text = '';\n      } else if ((options.disallowedTagsMode === 'discard' || options.disallowedTagsMode === 'completelyDiscard') && ((tag === 'script') || (tag === 'style'))) {\n        // htmlparser2 gives us these as-is. Escaping them ruins the content. Allowing\n        // script tags is, by definition, game over for XSS protection, so if that's\n        // your concern, don't allow them. The same is essentially true for style tags\n        // which have their own collection of XSS vectors.\n        result += text;\n      } else {\n        const escaped = escapeHtml(text, false);\n        if (options.textFilter && !addedText) {\n          result += options.textFilter(escaped, tag);\n        } else if (!addedText) {\n          result += escaped;\n        }\n      }\n      if (stack.length) {\n        const frame = stack[stack.length - 1];\n        frame.text += text;\n      }\n    },\n    onclosetag: function(name, isImplied) {\n\n      if (skipText) {\n        skipTextDepth--;\n        if (!skipTextDepth) {\n          skipText = false;\n        } else {\n          return;\n        }\n      }\n\n      const frame = stack.pop();\n      if (!frame) {\n        // Do not crash on bad markup\n        return;\n      }\n\n      if (frame.tag !== name) {\n        // Another case of bad markup.\n        // Push to stack, so that it will be used in future closing tags.\n        stack.push(frame);\n        return;\n      }\n\n      skipText = options.enforceHtmlBoundary ? name === 'html' : false;\n      depth--;\n      const skip = skipMap[depth];\n      if (skip) {\n        delete skipMap[depth];\n        if (options.disallowedTagsMode === 'discard' || options.disallowedTagsMode === 'completelyDiscard') {\n          frame.updateParentNodeText();\n          return;\n        }\n        tempResult = result;\n        result = '';\n      }\n\n      if (transformMap[depth]) {\n        name = transformMap[depth];\n        delete transformMap[depth];\n      }\n\n      if (options.exclusiveFilter && options.exclusiveFilter(frame)) {\n        result = result.substr(0, frame.tagPosition);\n        return;\n      }\n\n      frame.updateParentNodeMediaChildren();\n      frame.updateParentNodeText();\n\n      if (\n        // Already output />\n        options.selfClosing.indexOf(name) !== -1 ||\n        // Escaped tag, closing tag is implied\n        (isImplied && !tagAllowed(name) && [ 'escape', 'recursiveEscape' ].indexOf(options.disallowedTagsMode) >= 0)\n      ) {\n        if (skip) {\n          result = tempResult;\n          tempResult = '';\n        }\n        return;\n      }\n\n      result += '</' + name + '>';\n      if (skip) {\n        result = tempResult + escapeHtml(result);\n        tempResult = '';\n      }\n      addedText = false;\n    }\n  }, options.parser);\n  parser.write(html);\n  parser.end();\n\n  return result;\n\n  function initializeState() {\n    result = '';\n    depth = 0;\n    stack = [];\n    skipMap = {};\n    transformMap = {};\n    skipText = false;\n    skipTextDepth = 0;\n  }\n\n  function escapeHtml(s, quote) {\n    if (typeof (s) !== 'string') {\n      s = s + '';\n    }\n    if (options.parser.decodeEntities) {\n      s = s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');\n      if (quote) {\n        s = s.replace(/\"/g, '&quot;');\n      }\n    }\n    // TODO: this is inadequate because it will pass `&0;`. This approach\n    // will not work, each & must be considered with regard to whether it\n    // is followed by a 100% syntactically valid entity or not, and escaped\n    // if it is not. If this bothers you, don't set parser.decodeEntities\n    // to false. (The default is true.)\n    s = s.replace(/&(?![a-zA-Z0-9#]{1,20};)/g, '&amp;') // Match ampersands not part of existing HTML entity\n      .replace(/</g, '&lt;')\n      .replace(/>/g, '&gt;');\n    if (quote) {\n      s = s.replace(/\"/g, '&quot;');\n    }\n    return s;\n  }\n\n  function naughtyHref(name, href) {\n    // Browsers ignore character codes of 32 (space) and below in a surprising\n    // number of situations. Start reading here:\n    // https://www.owasp.org/index.php/XSS_Filter_Evasion_Cheat_Sheet#Embedded_tab\n    // eslint-disable-next-line no-control-regex\n    href = href.replace(/[\\x00-\\x20]+/g, '');\n    // Clobber any comments in URLs, which the browser might\n    // interpret inside an XML data island, allowing\n    // a javascript: URL to be snuck through\n    while (true) {\n      const firstIndex = href.indexOf('<!--');\n      if (firstIndex === -1) {\n        break;\n      }\n      const lastIndex = href.indexOf('-->', firstIndex + 4);\n      if (lastIndex === -1) {\n        break;\n      }\n      href = href.substring(0, firstIndex) + href.substring(lastIndex + 3);\n    }\n    // Case insensitive so we don't get faked out by JAVASCRIPT #1\n    // Allow more characters after the first so we don't get faked\n    // out by certain schemes browsers accept\n    const matches = href.match(/^([a-zA-Z][a-zA-Z0-9.\\-+]*):/);\n    if (!matches) {\n      // Protocol-relative URL starting with any combination of '/' and '\\'\n      if (href.match(/^[/\\\\]{2}/)) {\n        return !options.allowProtocolRelative;\n      }\n\n      // No scheme\n      return false;\n    }\n    const scheme = matches[1].toLowerCase();\n\n    if (has(options.allowedSchemesByTag, name)) {\n      return options.allowedSchemesByTag[name].indexOf(scheme) === -1;\n    }\n\n    return !options.allowedSchemes || options.allowedSchemes.indexOf(scheme) === -1;\n  }\n\n  function parseUrl(value) {\n    value = value.replace(/^(\\w+:)?\\s*[\\\\/]\\s*[\\\\/]/, '$1//');\n    if (value.startsWith('relative:')) {\n      // An attempt to exploit our workaround for base URLs being\n      // mandatory for relative URL validation in the WHATWG\n      // URL parser, reject it\n      throw new Error('relative: exploit attempt');\n    }\n    // naughtyHref is in charge of whether protocol relative URLs\n    // are cool. Here we are concerned just with allowed hostnames and\n    // whether to allow relative URLs.\n    //\n    // Build a placeholder \"base URL\" against which any reasonable\n    // relative URL may be parsed successfully\n    let base = 'relative://relative-site';\n    for (let i = 0; (i < 100); i++) {\n      base += `/${i}`;\n    }\n\n    const parsed = new URL(value, base);\n\n    const isRelativeUrl = parsed && parsed.hostname === 'relative-site' && parsed.protocol === 'relative:';\n    return {\n      isRelativeUrl,\n      url: parsed\n    };\n  }\n  /**\n   * Filters user input css properties by allowlisted regex attributes.\n   * Modifies the abstractSyntaxTree object.\n   *\n   * @param {object} abstractSyntaxTree  - Object representation of CSS attributes.\n   * @property {array[Declaration]} abstractSyntaxTree.nodes[0] - Each object cointains prop and value key, i.e { prop: 'color', value: 'red' }.\n   * @param {object} allowedStyles       - Keys are properties (i.e color), value is list of permitted regex rules (i.e /green/i).\n   * @return {object}                    - The modified tree.\n   */\n  function filterCss(abstractSyntaxTree, allowedStyles) {\n    if (!allowedStyles) {\n      return abstractSyntaxTree;\n    }\n\n    const astRules = abstractSyntaxTree.nodes[0];\n    let selectedRule;\n\n    // Merge global and tag-specific styles into new AST.\n    if (allowedStyles[astRules.selector] && allowedStyles['*']) {\n      selectedRule = deepmerge(\n        allowedStyles[astRules.selector],\n        allowedStyles['*']\n      );\n    } else {\n      selectedRule = allowedStyles[astRules.selector] || allowedStyles['*'];\n    }\n\n    if (selectedRule) {\n      abstractSyntaxTree.nodes[0].nodes = astRules.nodes.reduce(filterDeclarations(selectedRule), []);\n    }\n\n    return abstractSyntaxTree;\n  }\n\n  /**\n   * Extracts the style attributes from an AbstractSyntaxTree and formats those\n   * values in the inline style attribute format.\n   *\n   * @param  {AbstractSyntaxTree} filteredAST\n   * @return {string}             - Example: \"color:yellow;text-align:center !important;font-family:helvetica;\"\n   */\n  function stringifyStyleAttributes(filteredAST) {\n    return filteredAST.nodes[0].nodes\n      .reduce(function(extractedAttributes, attrObject) {\n        extractedAttributes.push(\n          `${attrObject.prop}:${attrObject.value}${attrObject.important ? ' !important' : ''}`\n        );\n        return extractedAttributes;\n      }, [])\n      .join(';');\n  }\n\n  /**\n    * Filters the existing attributes for the given property. Discards any attributes\n    * which don't match the allowlist.\n    *\n    * @param  {object} selectedRule             - Example: { color: red, font-family: helvetica }\n    * @param  {array} allowedDeclarationsList   - List of declarations which pass the allowlist.\n    * @param  {object} attributeObject          - Object representing the current css property.\n    * @property {string} attributeObject.type   - Typically 'declaration'.\n    * @property {string} attributeObject.prop   - The CSS property, i.e 'color'.\n    * @property {string} attributeObject.value  - The corresponding value to the css property, i.e 'red'.\n    * @return {function}                        - When used in Array.reduce, will return an array of Declaration objects\n    */\n  function filterDeclarations(selectedRule) {\n    return function (allowedDeclarationsList, attributeObject) {\n      // If this property is allowlisted...\n      if (has(selectedRule, attributeObject.prop)) {\n        const matchesRegex = selectedRule[attributeObject.prop].some(function(regularExpression) {\n          return regularExpression.test(attributeObject.value);\n        });\n\n        if (matchesRegex) {\n          allowedDeclarationsList.push(attributeObject);\n        }\n      }\n      return allowedDeclarationsList;\n    };\n  }\n\n  function filterClasses(classes, allowed, allowedGlobs) {\n    if (!allowed) {\n      // The class attribute is allowed without filtering on this tag\n      return classes;\n    }\n    classes = classes.split(/\\s+/);\n    return classes.filter(function(clss) {\n      return allowed.indexOf(clss) !== -1 || allowedGlobs.some(function(glob) {\n        return glob.test(clss);\n      });\n    }).join(' ');\n  }\n}\n\n// Defaults are accessible to you so that you can use them as a starting point\n// programmatically if you wish\n\nconst htmlParserDefaults = {\n  decodeEntities: true\n};\nsanitizeHtml.defaults = {\n  allowedTags: [\n    // Sections derived from MDN element categories and limited to the more\n    // benign categories.\n    // https://developer.mozilla.org/en-US/docs/Web/HTML/Element\n    // Content sectioning\n    'address', 'article', 'aside', 'footer', 'header',\n    'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'hgroup',\n    'main', 'nav', 'section',\n    // Text content\n    'blockquote', 'dd', 'div', 'dl', 'dt', 'figcaption', 'figure',\n    'hr', 'li', 'main', 'ol', 'p', 'pre', 'ul',\n    // Inline text semantics\n    'a', 'abbr', 'b', 'bdi', 'bdo', 'br', 'cite', 'code', 'data', 'dfn',\n    'em', 'i', 'kbd', 'mark', 'q',\n    'rb', 'rp', 'rt', 'rtc', 'ruby',\n    's', 'samp', 'small', 'span', 'strong', 'sub', 'sup', 'time', 'u', 'var', 'wbr',\n    // Table content\n    'caption', 'col', 'colgroup', 'table', 'tbody', 'td', 'tfoot', 'th',\n    'thead', 'tr'\n  ],\n  // Tags that cannot be boolean\n  nonBooleanAttributes: [\n    'abbr', 'accept', 'accept-charset', 'accesskey', 'action',\n    'allow', 'alt', 'as', 'autocapitalize', 'autocomplete',\n    'blocking', 'charset', 'cite', 'class', 'color', 'cols',\n    'colspan', 'content', 'contenteditable', 'coords', 'crossorigin',\n    'data', 'datetime', 'decoding', 'dir', 'dirname', 'download',\n    'draggable', 'enctype', 'enterkeyhint', 'fetchpriority', 'for',\n    'form', 'formaction', 'formenctype', 'formmethod', 'formtarget',\n    'headers', 'height', 'hidden', 'high', 'href', 'hreflang',\n    'http-equiv', 'id', 'imagesizes', 'imagesrcset', 'inputmode',\n    'integrity', 'is', 'itemid', 'itemprop', 'itemref', 'itemtype',\n    'kind', 'label', 'lang', 'list', 'loading', 'low', 'max',\n    'maxlength', 'media', 'method', 'min', 'minlength', 'name',\n    'nonce', 'optimum', 'pattern', 'ping', 'placeholder', 'popover',\n    'popovertarget', 'popovertargetaction', 'poster', 'preload',\n    'referrerpolicy', 'rel', 'rows', 'rowspan', 'sandbox', 'scope',\n    'shape', 'size', 'sizes', 'slot', 'span', 'spellcheck', 'src',\n    'srcdoc', 'srclang', 'srcset', 'start', 'step', 'style',\n    'tabindex', 'target', 'title', 'translate', 'type', 'usemap',\n    'value', 'width', 'wrap',\n    // Event handlers\n    'onauxclick', 'onafterprint', 'onbeforematch', 'onbeforeprint',\n    'onbeforeunload', 'onbeforetoggle', 'onblur', 'oncancel',\n    'oncanplay', 'oncanplaythrough', 'onchange', 'onclick', 'onclose',\n    'oncontextlost', 'oncontextmenu', 'oncontextrestored', 'oncopy',\n    'oncuechange', 'oncut', 'ondblclick', 'ondrag', 'ondragend',\n    'ondragenter', 'ondragleave', 'ondragover', 'ondragstart',\n    'ondrop', 'ondurationchange', 'onemptied', 'onended',\n    'onerror', 'onfocus', 'onformdata', 'onhashchange', 'oninput',\n    'oninvalid', 'onkeydown', 'onkeypress', 'onkeyup',\n    'onlanguagechange', 'onload', 'onloadeddata', 'onloadedmetadata',\n    'onloadstart', 'onmessage', 'onmessageerror', 'onmousedown',\n    'onmouseenter', 'onmouseleave', 'onmousemove', 'onmouseout',\n    'onmouseover', 'onmouseup', 'onoffline', 'ononline', 'onpagehide',\n    'onpageshow', 'onpaste', 'onpause', 'onplay', 'onplaying',\n    'onpopstate', 'onprogress', 'onratechange', 'onreset', 'onresize',\n    'onrejectionhandled', 'onscroll', 'onscrollend',\n    'onsecuritypolicyviolation', 'onseeked', 'onseeking', 'onselect',\n    'onslotchange', 'onstalled', 'onstorage', 'onsubmit', 'onsuspend',\n    'ontimeupdate', 'ontoggle', 'onunhandledrejection', 'onunload',\n    'onvolumechange', 'onwaiting', 'onwheel'\n  ],\n  disallowedTagsMode: 'discard',\n  allowedAttributes: {\n    a: [ 'href', 'name', 'target' ],\n    // We don't currently allow img itself by default, but\n    // these attributes would make sense if we did.\n    img: [ 'src', 'srcset', 'alt', 'title', 'width', 'height', 'loading' ]\n  },\n  allowedEmptyAttributes: [\n    'alt'\n  ],\n  // Lots of these won't come up by default because we don't allow them\n  selfClosing: [ 'img', 'br', 'hr', 'area', 'base', 'basefont', 'input', 'link', 'meta' ],\n  // URL schemes we permit\n  allowedSchemes: [ 'http', 'https', 'ftp', 'mailto', 'tel' ],\n  allowedSchemesByTag: {},\n  allowedSchemesAppliedToAttributes: [ 'href', 'src', 'cite' ],\n  allowProtocolRelative: true,\n  enforceHtmlBoundary: false,\n  parseStyleAttributes: true\n};\n\nsanitizeHtml.simpleTransform = function(newTagName, newAttribs, merge) {\n  merge = (merge === undefined) ? true : merge;\n  newAttribs = newAttribs || {};\n\n  return function(tagName, attribs) {\n    let attrib;\n    if (merge) {\n      for (attrib in newAttribs) {\n        attribs[attrib] = newAttribs[attrib];\n      }\n    } else {\n      attribs = newAttribs;\n    }\n\n    return {\n      tagName: newTagName,\n      attribs: attribs\n    };\n  };\n};\n","'use strict'\n\nlet Container = require('./container')\n\nclass AtRule extends Container {\n  constructor(defaults) {\n    super(defaults)\n    this.type = 'atrule'\n  }\n\n  append(...children) {\n    if (!this.proxyOf.nodes) this.nodes = []\n    return super.append(...children)\n  }\n\n  prepend(...children) {\n    if (!this.proxyOf.nodes) this.nodes = []\n    return super.prepend(...children)\n  }\n}\n\nmodule.exports = AtRule\nAtRule.default = AtRule\n\nContainer.registerAtRule(AtRule)\n","'use strict'\n\nlet Node = require('./node')\n\nclass Comment extends Node {\n  constructor(defaults) {\n    super(defaults)\n    this.type = 'comment'\n  }\n}\n\nmodule.exports = Comment\nComment.default = Comment\n","'use strict'\n\nlet Comment = require('./comment')\nlet Declaration = require('./declaration')\nlet Node = require('./node')\nlet { isClean, my } = require('./symbols')\n\nlet AtRule, parse, Root, Rule\n\nfunction cleanSource(nodes) {\n  return nodes.map(i => {\n    if (i.nodes) i.nodes = cleanSource(i.nodes)\n    delete i.source\n    return i\n  })\n}\n\nfunction markTreeDirty(node) {\n  node[isClean] = false\n  if (node.proxyOf.nodes) {\n    for (let i of node.proxyOf.nodes) {\n      markTreeDirty(i)\n    }\n  }\n}\n\nclass Container extends Node {\n  append(...children) {\n    for (let child of children) {\n      let nodes = this.normalize(child, this.last)\n      for (let node of nodes) this.proxyOf.nodes.push(node)\n    }\n\n    this.markDirty()\n\n    return this\n  }\n\n  cleanRaws(keepBetween) {\n    super.cleanRaws(keepBetween)\n    if (this.nodes) {\n      for (let node of this.nodes) node.cleanRaws(keepBetween)\n    }\n  }\n\n  each(callback) {\n    if (!this.proxyOf.nodes) return undefined\n    let iterator = this.getIterator()\n\n    let index, result\n    while (this.indexes[iterator] < this.proxyOf.nodes.length) {\n      index = this.indexes[iterator]\n      result = callback(this.proxyOf.nodes[index], index)\n      if (result === false) break\n\n      this.indexes[iterator] += 1\n    }\n\n    delete this.indexes[iterator]\n    return result\n  }\n\n  every(condition) {\n    return this.nodes.every(condition)\n  }\n\n  getIterator() {\n    if (!this.lastEach) this.lastEach = 0\n    if (!this.indexes) this.indexes = {}\n\n    this.lastEach += 1\n    let iterator = this.lastEach\n    this.indexes[iterator] = 0\n\n    return iterator\n  }\n\n  getProxyProcessor() {\n    return {\n      get(node, prop) {\n        if (prop === 'proxyOf') {\n          return node\n        } else if (!node[prop]) {\n          return node[prop]\n        } else if (\n          prop === 'each' ||\n          (typeof prop === 'string' && prop.startsWith('walk'))\n        ) {\n          return (...args) => {\n            return node[prop](\n              ...args.map(i => {\n                if (typeof i === 'function') {\n                  return (child, index) => i(child.toProxy(), index)\n                } else {\n                  return i\n                }\n              })\n            )\n          }\n        } else if (prop === 'every' || prop === 'some') {\n          return cb => {\n            return node[prop]((child, ...other) =>\n              cb(child.toProxy(), ...other)\n            )\n          }\n        } else if (prop === 'root') {\n          return () => node.root().toProxy()\n        } else if (prop === 'nodes') {\n          return node.nodes.map(i => i.toProxy())\n        } else if (prop === 'first' || prop === 'last') {\n          return node[prop].toProxy()\n        } else {\n          return node[prop]\n        }\n      },\n\n      set(node, prop, value) {\n        if (node[prop] === value) return true\n        node[prop] = value\n        if (prop === 'name' || prop === 'params' || prop === 'selector') {\n          node.markDirty()\n        }\n        return true\n      }\n    }\n  }\n\n  index(child) {\n    if (typeof child === 'number') return child\n    if (child.proxyOf) child = child.proxyOf\n    return this.proxyOf.nodes.indexOf(child)\n  }\n\n  insertAfter(exist, add) {\n    let existIndex = this.index(exist)\n    let nodes = this.normalize(add, this.proxyOf.nodes[existIndex]).reverse()\n    existIndex = this.index(exist)\n    for (let node of nodes) this.proxyOf.nodes.splice(existIndex + 1, 0, node)\n\n    let index\n    for (let id in this.indexes) {\n      index = this.indexes[id]\n      if (existIndex < index) {\n        this.indexes[id] = index + nodes.length\n      }\n    }\n\n    this.markDirty()\n\n    return this\n  }\n\n  insertBefore(exist, add) {\n    let existIndex = this.index(exist)\n    let type = existIndex === 0 ? 'prepend' : false\n    let nodes = this.normalize(\n      add,\n      this.proxyOf.nodes[existIndex],\n      type\n    ).reverse()\n    existIndex = this.index(exist)\n    for (let node of nodes) this.proxyOf.nodes.splice(existIndex, 0, node)\n\n    let index\n    for (let id in this.indexes) {\n      index = this.indexes[id]\n      if (existIndex <= index) {\n        this.indexes[id] = index + nodes.length\n      }\n    }\n\n    this.markDirty()\n\n    return this\n  }\n\n  normalize(nodes, sample) {\n    if (typeof nodes === 'string') {\n      nodes = cleanSource(parse(nodes).nodes)\n    } else if (typeof nodes === 'undefined') {\n      nodes = []\n    } else if (Array.isArray(nodes)) {\n      nodes = nodes.slice(0)\n      for (let i of nodes) {\n        if (i.parent) i.parent.removeChild(i, 'ignore')\n      }\n    } else if (nodes.type === 'root' && this.type !== 'document') {\n      nodes = nodes.nodes.slice(0)\n      for (let i of nodes) {\n        if (i.parent) i.parent.removeChild(i, 'ignore')\n      }\n    } else if (nodes.type) {\n      nodes = [nodes]\n    } else if (nodes.prop) {\n      if (typeof nodes.value === 'undefined') {\n        throw new Error('Value field is missed in node creation')\n      } else if (typeof nodes.value !== 'string') {\n        nodes.value = String(nodes.value)\n      }\n      nodes = [new Declaration(nodes)]\n    } else if (nodes.selector || nodes.selectors) {\n      nodes = [new Rule(nodes)]\n    } else if (nodes.name) {\n      nodes = [new AtRule(nodes)]\n    } else if (nodes.text) {\n      nodes = [new Comment(nodes)]\n    } else {\n      throw new Error('Unknown node type in node creation')\n    }\n\n    let processed = nodes.map(i => {\n      /* c8 ignore next */\n      if (!i[my]) Container.rebuild(i)\n      i = i.proxyOf\n      if (i.parent) i.parent.removeChild(i)\n      if (i[isClean]) markTreeDirty(i)\n\n      if (!i.raws) i.raws = {}\n      if (typeof i.raws.before === 'undefined') {\n        if (sample && typeof sample.raws.before !== 'undefined') {\n          i.raws.before = sample.raws.before.replace(/\\S/g, '')\n        }\n      }\n      i.parent = this.proxyOf\n      return i\n    })\n\n    return processed\n  }\n\n  prepend(...children) {\n    children = children.reverse()\n    for (let child of children) {\n      let nodes = this.normalize(child, this.first, 'prepend').reverse()\n      for (let node of nodes) this.proxyOf.nodes.unshift(node)\n      for (let id in this.indexes) {\n        this.indexes[id] = this.indexes[id] + nodes.length\n      }\n    }\n\n    this.markDirty()\n\n    return this\n  }\n\n  push(child) {\n    child.parent = this\n    this.proxyOf.nodes.push(child)\n    return this\n  }\n\n  removeAll() {\n    for (let node of this.proxyOf.nodes) node.parent = undefined\n    this.proxyOf.nodes = []\n\n    this.markDirty()\n\n    return this\n  }\n\n  removeChild(child) {\n    child = this.index(child)\n    this.proxyOf.nodes[child].parent = undefined\n    this.proxyOf.nodes.splice(child, 1)\n\n    let index\n    for (let id in this.indexes) {\n      index = this.indexes[id]\n      if (index >= child) {\n        this.indexes[id] = index - 1\n      }\n    }\n\n    this.markDirty()\n\n    return this\n  }\n\n  replaceValues(pattern, opts, callback) {\n    if (!callback) {\n      callback = opts\n      opts = {}\n    }\n\n    this.walkDecls(decl => {\n      if (opts.props && !opts.props.includes(decl.prop)) return\n      if (opts.fast && !decl.value.includes(opts.fast)) return\n\n      decl.value = decl.value.replace(pattern, callback)\n    })\n\n    this.markDirty()\n\n    return this\n  }\n\n  some(condition) {\n    return this.nodes.some(condition)\n  }\n\n  walk(callback) {\n    return this.each((child, i) => {\n      let result\n      try {\n        result = callback(child, i)\n      } catch (e) {\n        throw child.addToError(e)\n      }\n      if (result !== false && child.walk) {\n        result = child.walk(callback)\n      }\n\n      return result\n    })\n  }\n\n  walkAtRules(name, callback) {\n    if (!callback) {\n      callback = name\n      return this.walk((child, i) => {\n        if (child.type === 'atrule') {\n          return callback(child, i)\n        }\n      })\n    }\n    if (name instanceof RegExp) {\n      return this.walk((child, i) => {\n        if (child.type === 'atrule' && name.test(child.name)) {\n          return callback(child, i)\n        }\n      })\n    }\n    return this.walk((child, i) => {\n      if (child.type === 'atrule' && child.name === name) {\n        return callback(child, i)\n      }\n    })\n  }\n\n  walkComments(callback) {\n    return this.walk((child, i) => {\n      if (child.type === 'comment') {\n        return callback(child, i)\n      }\n    })\n  }\n\n  walkDecls(prop, callback) {\n    if (!callback) {\n      callback = prop\n      return this.walk((child, i) => {\n        if (child.type === 'decl') {\n          return callback(child, i)\n        }\n      })\n    }\n    if (prop instanceof RegExp) {\n      return this.walk((child, i) => {\n        if (child.type === 'decl' && prop.test(child.prop)) {\n          return callback(child, i)\n        }\n      })\n    }\n    return this.walk((child, i) => {\n      if (child.type === 'decl' && child.prop === prop) {\n        return callback(child, i)\n      }\n    })\n  }\n\n  walkRules(selector, callback) {\n    if (!callback) {\n      callback = selector\n\n      return this.walk((child, i) => {\n        if (child.type === 'rule') {\n          return callback(child, i)\n        }\n      })\n    }\n    if (selector instanceof RegExp) {\n      return this.walk((child, i) => {\n        if (child.type === 'rule' && selector.test(child.selector)) {\n          return callback(child, i)\n        }\n      })\n    }\n    return this.walk((child, i) => {\n      if (child.type === 'rule' && child.selector === selector) {\n        return callback(child, i)\n      }\n    })\n  }\n\n  get first() {\n    if (!this.proxyOf.nodes) return undefined\n    return this.proxyOf.nodes[0]\n  }\n\n  get last() {\n    if (!this.proxyOf.nodes) return undefined\n    return this.proxyOf.nodes[this.proxyOf.nodes.length - 1]\n  }\n}\n\nContainer.registerParse = dependant => {\n  parse = dependant\n}\n\nContainer.registerRule = dependant => {\n  Rule = dependant\n}\n\nContainer.registerAtRule = dependant => {\n  AtRule = dependant\n}\n\nContainer.registerRoot = dependant => {\n  Root = dependant\n}\n\nmodule.exports = Container\nContainer.default = Container\n\n/* c8 ignore start */\nContainer.rebuild = node => {\n  if (node.type === 'atrule') {\n    Object.setPrototypeOf(node, AtRule.prototype)\n  } else if (node.type === 'rule') {\n    Object.setPrototypeOf(node, Rule.prototype)\n  } else if (node.type === 'decl') {\n    Object.setPrototypeOf(node, Declaration.prototype)\n  } else if (node.type === 'comment') {\n    Object.setPrototypeOf(node, Comment.prototype)\n  } else if (node.type === 'root') {\n    Object.setPrototypeOf(node, Root.prototype)\n  }\n\n  node[my] = true\n\n  if (node.nodes) {\n    node.nodes.forEach(child => {\n      Container.rebuild(child)\n    })\n  }\n}\n/* c8 ignore stop */\n","'use strict'\n\nlet pico = require('picocolors')\n\nlet terminalHighlight = require('./terminal-highlight')\n\nclass CssSyntaxError extends Error {\n  constructor(message, line, column, source, file, plugin) {\n    super(message)\n    this.name = 'CssSyntaxError'\n    this.reason = message\n\n    if (file) {\n      this.file = file\n    }\n    if (source) {\n      this.source = source\n    }\n    if (plugin) {\n      this.plugin = plugin\n    }\n    if (typeof line !== 'undefined' && typeof column !== 'undefined') {\n      if (typeof line === 'number') {\n        this.line = line\n        this.column = column\n      } else {\n        this.line = line.line\n        this.column = line.column\n        this.endLine = column.line\n        this.endColumn = column.column\n      }\n    }\n\n    this.setMessage()\n\n    if (Error.captureStackTrace) {\n      Error.captureStackTrace(this, CssSyntaxError)\n    }\n  }\n\n  setMessage() {\n    this.message = this.plugin ? this.plugin + ': ' : ''\n    this.message += this.file ? this.file : '<css input>'\n    if (typeof this.line !== 'undefined') {\n      this.message += ':' + this.line + ':' + this.column\n    }\n    this.message += ': ' + this.reason\n  }\n\n  showSourceCode(color) {\n    if (!this.source) return ''\n\n    let css = this.source\n    if (color == null) color = pico.isColorSupported\n\n    let aside = text => text\n    let mark = text => text\n    let highlight = text => text\n    if (color) {\n      let { bold, gray, red } = pico.createColors(true)\n      mark = text => bold(red(text))\n      aside = text => gray(text)\n      if (terminalHighlight) {\n        highlight = text => terminalHighlight(text)\n      }\n    }\n\n    let lines = css.split(/\\r?\\n/)\n    let start = Math.max(this.line - 3, 0)\n    let end = Math.min(this.line + 2, lines.length)\n    let maxWidth = String(end).length\n\n    return lines\n      .slice(start, end)\n      .map((line, index) => {\n        let number = start + 1 + index\n        let gutter = ' ' + (' ' + number).slice(-maxWidth) + ' | '\n        if (number === this.line) {\n          if (line.length > 160) {\n            let padding = 20\n            let subLineStart = Math.max(0, this.column - padding)\n            let subLineEnd = Math.max(\n              this.column + padding,\n              this.endColumn + padding\n            )\n            let subLine = line.slice(subLineStart, subLineEnd)\n\n            let spacing =\n              aside(gutter.replace(/\\d/g, ' ')) +\n              line\n                .slice(0, Math.min(this.column - 1, padding - 1))\n                .replace(/[^\\t]/g, ' ')\n\n            return (\n              mark('>') +\n              aside(gutter) +\n              highlight(subLine) +\n              '\\n ' +\n              spacing +\n              mark('^')\n            )\n          }\n\n          let spacing =\n            aside(gutter.replace(/\\d/g, ' ')) +\n            line.slice(0, this.column - 1).replace(/[^\\t]/g, ' ')\n\n          return (\n            mark('>') +\n            aside(gutter) +\n            highlight(line) +\n            '\\n ' +\n            spacing +\n            mark('^')\n          )\n        }\n\n        return ' ' + aside(gutter) + highlight(line)\n      })\n      .join('\\n')\n  }\n\n  toString() {\n    let code = this.showSourceCode()\n    if (code) {\n      code = '\\n\\n' + code + '\\n'\n    }\n    return this.name + ': ' + this.message + code\n  }\n}\n\nmodule.exports = CssSyntaxError\nCssSyntaxError.default = CssSyntaxError\n","'use strict'\n\nlet Node = require('./node')\n\nclass Declaration extends Node {\n  constructor(defaults) {\n    if (\n      defaults &&\n      typeof defaults.value !== 'undefined' &&\n      typeof defaults.value !== 'string'\n    ) {\n      defaults = { ...defaults, value: String(defaults.value) }\n    }\n    super(defaults)\n    this.type = 'decl'\n  }\n\n  get variable() {\n    return this.prop.startsWith('--') || this.prop[0] === '$'\n  }\n}\n\nmodule.exports = Declaration\nDeclaration.default = Declaration\n","'use strict'\n\nlet Container = require('./container')\n\nlet LazyResult, Processor\n\nclass Document extends Container {\n  constructor(defaults) {\n    // type needs to be passed to super, otherwise child roots won't be normalized correctly\n    super({ type: 'document', ...defaults })\n\n    if (!this.nodes) {\n      this.nodes = []\n    }\n  }\n\n  toResult(opts = {}) {\n    let lazy = new LazyResult(new Processor(), this, opts)\n\n    return lazy.stringify()\n  }\n}\n\nDocument.registerLazyResult = dependant => {\n  LazyResult = dependant\n}\n\nDocument.registerProcessor = dependant => {\n  Processor = dependant\n}\n\nmodule.exports = Document\nDocument.default = Document\n","'use strict'\n\nlet AtRule = require('./at-rule')\nlet Comment = require('./comment')\nlet Declaration = require('./declaration')\nlet Input = require('./input')\nlet PreviousMap = require('./previous-map')\nlet Root = require('./root')\nlet Rule = require('./rule')\n\nfunction fromJSON(json, inputs) {\n  if (Array.isArray(json)) return json.map(n => fromJSON(n))\n\n  let { inputs: ownInputs, ...defaults } = json\n  if (ownInputs) {\n    inputs = []\n    for (let input of ownInputs) {\n      let inputHydrated = { ...input, __proto__: Input.prototype }\n      if (inputHydrated.map) {\n        inputHydrated.map = {\n          ...inputHydrated.map,\n          __proto__: PreviousMap.prototype\n        }\n      }\n      inputs.push(inputHydrated)\n    }\n  }\n  if (defaults.nodes) {\n    defaults.nodes = json.nodes.map(n => fromJSON(n, inputs))\n  }\n  if (defaults.source) {\n    let { inputId, ...source } = defaults.source\n    defaults.source = source\n    if (inputId != null) {\n      defaults.source.input = inputs[inputId]\n    }\n  }\n  if (defaults.type === 'root') {\n    return new Root(defaults)\n  } else if (defaults.type === 'decl') {\n    return new Declaration(defaults)\n  } else if (defaults.type === 'rule') {\n    return new Rule(defaults)\n  } else if (defaults.type === 'comment') {\n    return new Comment(defaults)\n  } else if (defaults.type === 'atrule') {\n    return new AtRule(defaults)\n  } else {\n    throw new Error('Unknown node type: ' + json.type)\n  }\n}\n\nmodule.exports = fromJSON\nfromJSON.default = fromJSON\n","'use strict'\n\nlet { nanoid } = require('nanoid/non-secure')\nlet { isAbsolute, resolve } = require('path')\nlet { SourceMapConsumer, SourceMapGenerator } = require('source-map-js')\nlet { fileURLToPath, pathToFileURL } = require('url')\n\nlet CssSyntaxError = require('./css-syntax-error')\nlet PreviousMap = require('./previous-map')\nlet terminalHighlight = require('./terminal-highlight')\n\nlet fromOffsetCache = Symbol('fromOffsetCache')\n\nlet sourceMapAvailable = Boolean(SourceMapConsumer && SourceMapGenerator)\nlet pathAvailable = Boolean(resolve && isAbsolute)\n\nclass Input {\n  constructor(css, opts = {}) {\n    if (\n      css === null ||\n      typeof css === 'undefined' ||\n      (typeof css === 'object' && !css.toString)\n    ) {\n      throw new Error(`PostCSS received ${css} instead of CSS string`)\n    }\n\n    this.css = css.toString()\n\n    if (this.css[0] === '\\uFEFF' || this.css[0] === '\\uFFFE') {\n      this.hasBOM = true\n      this.css = this.css.slice(1)\n    } else {\n      this.hasBOM = false\n    }\n\n    if (opts.from) {\n      if (\n        !pathAvailable ||\n        /^\\w+:\\/\\//.test(opts.from) ||\n        isAbsolute(opts.from)\n      ) {\n        this.file = opts.from\n      } else {\n        this.file = resolve(opts.from)\n      }\n    }\n\n    if (pathAvailable && sourceMapAvailable) {\n      let map = new PreviousMap(this.css, opts)\n      if (map.text) {\n        this.map = map\n        let file = map.consumer().file\n        if (!this.file && file) this.file = this.mapResolve(file)\n      }\n    }\n\n    if (!this.file) {\n      this.id = '<input css ' + nanoid(6) + '>'\n    }\n    if (this.map) this.map.file = this.from\n  }\n\n  error(message, line, column, opts = {}) {\n    let endColumn, endLine, result\n\n    if (line && typeof line === 'object') {\n      let start = line\n      let end = column\n      if (typeof start.offset === 'number') {\n        let pos = this.fromOffset(start.offset)\n        line = pos.line\n        column = pos.col\n      } else {\n        line = start.line\n        column = start.column\n      }\n      if (typeof end.offset === 'number') {\n        let pos = this.fromOffset(end.offset)\n        endLine = pos.line\n        endColumn = pos.col\n      } else {\n        endLine = end.line\n        endColumn = end.column\n      }\n    } else if (!column) {\n      let pos = this.fromOffset(line)\n      line = pos.line\n      column = pos.col\n    }\n\n    let origin = this.origin(line, column, endLine, endColumn)\n    if (origin) {\n      result = new CssSyntaxError(\n        message,\n        origin.endLine === undefined\n          ? origin.line\n          : { column: origin.column, line: origin.line },\n        origin.endLine === undefined\n          ? origin.column\n          : { column: origin.endColumn, line: origin.endLine },\n        origin.source,\n        origin.file,\n        opts.plugin\n      )\n    } else {\n      result = new CssSyntaxError(\n        message,\n        endLine === undefined ? line : { column, line },\n        endLine === undefined ? column : { column: endColumn, line: endLine },\n        this.css,\n        this.file,\n        opts.plugin\n      )\n    }\n\n    result.input = { column, endColumn, endLine, line, source: this.css }\n    if (this.file) {\n      if (pathToFileURL) {\n        result.input.url = pathToFileURL(this.file).toString()\n      }\n      result.input.file = this.file\n    }\n\n    return result\n  }\n\n  fromOffset(offset) {\n    let lastLine, lineToIndex\n    if (!this[fromOffsetCache]) {\n      let lines = this.css.split('\\n')\n      lineToIndex = new Array(lines.length)\n      let prevIndex = 0\n\n      for (let i = 0, l = lines.length; i < l; i++) {\n        lineToIndex[i] = prevIndex\n        prevIndex += lines[i].length + 1\n      }\n\n      this[fromOffsetCache] = lineToIndex\n    } else {\n      lineToIndex = this[fromOffsetCache]\n    }\n    lastLine = lineToIndex[lineToIndex.length - 1]\n\n    let min = 0\n    if (offset >= lastLine) {\n      min = lineToIndex.length - 1\n    } else {\n      let max = lineToIndex.length - 2\n      let mid\n      while (min < max) {\n        mid = min + ((max - min) >> 1)\n        if (offset < lineToIndex[mid]) {\n          max = mid - 1\n        } else if (offset >= lineToIndex[mid + 1]) {\n          min = mid + 1\n        } else {\n          min = mid\n          break\n        }\n      }\n    }\n    return {\n      col: offset - lineToIndex[min] + 1,\n      line: min + 1\n    }\n  }\n\n  mapResolve(file) {\n    if (/^\\w+:\\/\\//.test(file)) {\n      return file\n    }\n    return resolve(this.map.consumer().sourceRoot || this.map.root || '.', file)\n  }\n\n  origin(line, column, endLine, endColumn) {\n    if (!this.map) return false\n    let consumer = this.map.consumer()\n\n    let from = consumer.originalPositionFor({ column, line })\n    if (!from.source) return false\n\n    let to\n    if (typeof endLine === 'number') {\n      to = consumer.originalPositionFor({ column: endColumn, line: endLine })\n    }\n\n    let fromUrl\n\n    if (isAbsolute(from.source)) {\n      fromUrl = pathToFileURL(from.source)\n    } else {\n      fromUrl = new URL(\n        from.source,\n        this.map.consumer().sourceRoot || pathToFileURL(this.map.mapFile)\n      )\n    }\n\n    let result = {\n      column: from.column,\n      endColumn: to && to.column,\n      endLine: to && to.line,\n      line: from.line,\n      url: fromUrl.toString()\n    }\n\n    if (fromUrl.protocol === 'file:') {\n      if (fileURLToPath) {\n        result.file = fileURLToPath(fromUrl)\n      } else {\n        /* c8 ignore next 2 */\n        throw new Error(`file: protocol is not available in this PostCSS build`)\n      }\n    }\n\n    let source = consumer.sourceContentFor(from.source)\n    if (source) result.source = source\n\n    return result\n  }\n\n  toJSON() {\n    let json = {}\n    for (let name of ['hasBOM', 'css', 'file', 'id']) {\n      if (this[name] != null) {\n        json[name] = this[name]\n      }\n    }\n    if (this.map) {\n      json.map = { ...this.map }\n      if (json.map.consumerCache) {\n        json.map.consumerCache = undefined\n      }\n    }\n    return json\n  }\n\n  get from() {\n    return this.file || this.id\n  }\n}\n\nmodule.exports = Input\nInput.default = Input\n\nif (terminalHighlight && terminalHighlight.registerInput) {\n  terminalHighlight.registerInput(Input)\n}\n","'use strict'\n\nlet Container = require('./container')\nlet Document = require('./document')\nlet MapGenerator = require('./map-generator')\nlet parse = require('./parse')\nlet Result = require('./result')\nlet Root = require('./root')\nlet stringify = require('./stringify')\nlet { isClean, my } = require('./symbols')\nlet warnOnce = require('./warn-once')\n\nconst TYPE_TO_CLASS_NAME = {\n  atrule: 'AtRule',\n  comment: 'Comment',\n  decl: 'Declaration',\n  document: 'Document',\n  root: 'Root',\n  rule: 'Rule'\n}\n\nconst PLUGIN_PROPS = {\n  AtRule: true,\n  AtRuleExit: true,\n  Comment: true,\n  CommentExit: true,\n  Declaration: true,\n  DeclarationExit: true,\n  Document: true,\n  DocumentExit: true,\n  Once: true,\n  OnceExit: true,\n  postcssPlugin: true,\n  prepare: true,\n  Root: true,\n  RootExit: true,\n  Rule: true,\n  RuleExit: true\n}\n\nconst NOT_VISITORS = {\n  Once: true,\n  postcssPlugin: true,\n  prepare: true\n}\n\nconst CHILDREN = 0\n\nfunction isPromise(obj) {\n  return typeof obj === 'object' && typeof obj.then === 'function'\n}\n\nfunction getEvents(node) {\n  let key = false\n  let type = TYPE_TO_CLASS_NAME[node.type]\n  if (node.type === 'decl') {\n    key = node.prop.toLowerCase()\n  } else if (node.type === 'atrule') {\n    key = node.name.toLowerCase()\n  }\n\n  if (key && node.append) {\n    return [\n      type,\n      type + '-' + key,\n      CHILDREN,\n      type + 'Exit',\n      type + 'Exit-' + key\n    ]\n  } else if (key) {\n    return [type, type + '-' + key, type + 'Exit', type + 'Exit-' + key]\n  } else if (node.append) {\n    return [type, CHILDREN, type + 'Exit']\n  } else {\n    return [type, type + 'Exit']\n  }\n}\n\nfunction toStack(node) {\n  let events\n  if (node.type === 'document') {\n    events = ['Document', CHILDREN, 'DocumentExit']\n  } else if (node.type === 'root') {\n    events = ['Root', CHILDREN, 'RootExit']\n  } else {\n    events = getEvents(node)\n  }\n\n  return {\n    eventIndex: 0,\n    events,\n    iterator: 0,\n    node,\n    visitorIndex: 0,\n    visitors: []\n  }\n}\n\nfunction cleanMarks(node) {\n  node[isClean] = false\n  if (node.nodes) node.nodes.forEach(i => cleanMarks(i))\n  return node\n}\n\nlet postcss = {}\n\nclass LazyResult {\n  constructor(processor, css, opts) {\n    this.stringified = false\n    this.processed = false\n\n    let root\n    if (\n      typeof css === 'object' &&\n      css !== null &&\n      (css.type === 'root' || css.type === 'document')\n    ) {\n      root = cleanMarks(css)\n    } else if (css instanceof LazyResult || css instanceof Result) {\n      root = cleanMarks(css.root)\n      if (css.map) {\n        if (typeof opts.map === 'undefined') opts.map = {}\n        if (!opts.map.inline) opts.map.inline = false\n        opts.map.prev = css.map\n      }\n    } else {\n      let parser = parse\n      if (opts.syntax) parser = opts.syntax.parse\n      if (opts.parser) parser = opts.parser\n      if (parser.parse) parser = parser.parse\n\n      try {\n        root = parser(css, opts)\n      } catch (error) {\n        this.processed = true\n        this.error = error\n      }\n\n      if (root && !root[my]) {\n        /* c8 ignore next 2 */\n        Container.rebuild(root)\n      }\n    }\n\n    this.result = new Result(processor, root, opts)\n    this.helpers = { ...postcss, postcss, result: this.result }\n    this.plugins = this.processor.plugins.map(plugin => {\n      if (typeof plugin === 'object' && plugin.prepare) {\n        return { ...plugin, ...plugin.prepare(this.result) }\n      } else {\n        return plugin\n      }\n    })\n  }\n\n  async() {\n    if (this.error) return Promise.reject(this.error)\n    if (this.processed) return Promise.resolve(this.result)\n    if (!this.processing) {\n      this.processing = this.runAsync()\n    }\n    return this.processing\n  }\n\n  catch(onRejected) {\n    return this.async().catch(onRejected)\n  }\n\n  finally(onFinally) {\n    return this.async().then(onFinally, onFinally)\n  }\n\n  getAsyncError() {\n    throw new Error('Use process(css).then(cb) to work with async plugins')\n  }\n\n  handleError(error, node) {\n    let plugin = this.result.lastPlugin\n    try {\n      if (node) node.addToError(error)\n      this.error = error\n      if (error.name === 'CssSyntaxError' && !error.plugin) {\n        error.plugin = plugin.postcssPlugin\n        error.setMessage()\n      } else if (plugin.postcssVersion) {\n        if (process.env.NODE_ENV !== 'production') {\n          let pluginName = plugin.postcssPlugin\n          let pluginVer = plugin.postcssVersion\n          let runtimeVer = this.result.processor.version\n          let a = pluginVer.split('.')\n          let b = runtimeVer.split('.')\n\n          if (a[0] !== b[0] || parseInt(a[1]) > parseInt(b[1])) {\n            // eslint-disable-next-line no-console\n            console.error(\n              'Unknown error from PostCSS plugin. Your current PostCSS ' +\n                'version is ' +\n                runtimeVer +\n                ', but ' +\n                pluginName +\n                ' uses ' +\n                pluginVer +\n                '. Perhaps this is the source of the error below.'\n            )\n          }\n        }\n      }\n    } catch (err) {\n      /* c8 ignore next 3 */\n      // eslint-disable-next-line no-console\n      if (console && console.error) console.error(err)\n    }\n    return error\n  }\n\n  prepareVisitors() {\n    this.listeners = {}\n    let add = (plugin, type, cb) => {\n      if (!this.listeners[type]) this.listeners[type] = []\n      this.listeners[type].push([plugin, cb])\n    }\n    for (let plugin of this.plugins) {\n      if (typeof plugin === 'object') {\n        for (let event in plugin) {\n          if (!PLUGIN_PROPS[event] && /^[A-Z]/.test(event)) {\n            throw new Error(\n              `Unknown event ${event} in ${plugin.postcssPlugin}. ` +\n                `Try to update PostCSS (${this.processor.version} now).`\n            )\n          }\n          if (!NOT_VISITORS[event]) {\n            if (typeof plugin[event] === 'object') {\n              for (let filter in plugin[event]) {\n                if (filter === '*') {\n                  add(plugin, event, plugin[event][filter])\n                } else {\n                  add(\n                    plugin,\n                    event + '-' + filter.toLowerCase(),\n                    plugin[event][filter]\n                  )\n                }\n              }\n            } else if (typeof plugin[event] === 'function') {\n              add(plugin, event, plugin[event])\n            }\n          }\n        }\n      }\n    }\n    this.hasListener = Object.keys(this.listeners).length > 0\n  }\n\n  async runAsync() {\n    this.plugin = 0\n    for (let i = 0; i < this.plugins.length; i++) {\n      let plugin = this.plugins[i]\n      let promise = this.runOnRoot(plugin)\n      if (isPromise(promise)) {\n        try {\n          await promise\n        } catch (error) {\n          throw this.handleError(error)\n        }\n      }\n    }\n\n    this.prepareVisitors()\n    if (this.hasListener) {\n      let root = this.result.root\n      while (!root[isClean]) {\n        root[isClean] = true\n        let stack = [toStack(root)]\n        while (stack.length > 0) {\n          let promise = this.visitTick(stack)\n          if (isPromise(promise)) {\n            try {\n              await promise\n            } catch (e) {\n              let node = stack[stack.length - 1].node\n              throw this.handleError(e, node)\n            }\n          }\n        }\n      }\n\n      if (this.listeners.OnceExit) {\n        for (let [plugin, visitor] of this.listeners.OnceExit) {\n          this.result.lastPlugin = plugin\n          try {\n            if (root.type === 'document') {\n              let roots = root.nodes.map(subRoot =>\n                visitor(subRoot, this.helpers)\n              )\n\n              await Promise.all(roots)\n            } else {\n              await visitor(root, this.helpers)\n            }\n          } catch (e) {\n            throw this.handleError(e)\n          }\n        }\n      }\n    }\n\n    this.processed = true\n    return this.stringify()\n  }\n\n  runOnRoot(plugin) {\n    this.result.lastPlugin = plugin\n    try {\n      if (typeof plugin === 'object' && plugin.Once) {\n        if (this.result.root.type === 'document') {\n          let roots = this.result.root.nodes.map(root =>\n            plugin.Once(root, this.helpers)\n          )\n\n          if (isPromise(roots[0])) {\n            return Promise.all(roots)\n          }\n\n          return roots\n        }\n\n        return plugin.Once(this.result.root, this.helpers)\n      } else if (typeof plugin === 'function') {\n        return plugin(this.result.root, this.result)\n      }\n    } catch (error) {\n      throw this.handleError(error)\n    }\n  }\n\n  stringify() {\n    if (this.error) throw this.error\n    if (this.stringified) return this.result\n    this.stringified = true\n\n    this.sync()\n\n    let opts = this.result.opts\n    let str = stringify\n    if (opts.syntax) str = opts.syntax.stringify\n    if (opts.stringifier) str = opts.stringifier\n    if (str.stringify) str = str.stringify\n\n    let map = new MapGenerator(str, this.result.root, this.result.opts)\n    let data = map.generate()\n    this.result.css = data[0]\n    this.result.map = data[1]\n\n    return this.result\n  }\n\n  sync() {\n    if (this.error) throw this.error\n    if (this.processed) return this.result\n    this.processed = true\n\n    if (this.processing) {\n      throw this.getAsyncError()\n    }\n\n    for (let plugin of this.plugins) {\n      let promise = this.runOnRoot(plugin)\n      if (isPromise(promise)) {\n        throw this.getAsyncError()\n      }\n    }\n\n    this.prepareVisitors()\n    if (this.hasListener) {\n      let root = this.result.root\n      while (!root[isClean]) {\n        root[isClean] = true\n        this.walkSync(root)\n      }\n      if (this.listeners.OnceExit) {\n        if (root.type === 'document') {\n          for (let subRoot of root.nodes) {\n            this.visitSync(this.listeners.OnceExit, subRoot)\n          }\n        } else {\n          this.visitSync(this.listeners.OnceExit, root)\n        }\n      }\n    }\n\n    return this.result\n  }\n\n  then(onFulfilled, onRejected) {\n    if (process.env.NODE_ENV !== 'production') {\n      if (!('from' in this.opts)) {\n        warnOnce(\n          'Without `from` option PostCSS could generate wrong source map ' +\n            'and will not find Browserslist config. Set it to CSS file path ' +\n            'or to `undefined` to prevent this warning.'\n        )\n      }\n    }\n    return this.async().then(onFulfilled, onRejected)\n  }\n\n  toString() {\n    return this.css\n  }\n\n  visitSync(visitors, node) {\n    for (let [plugin, visitor] of visitors) {\n      this.result.lastPlugin = plugin\n      let promise\n      try {\n        promise = visitor(node, this.helpers)\n      } catch (e) {\n        throw this.handleError(e, node.proxyOf)\n      }\n      if (node.type !== 'root' && node.type !== 'document' && !node.parent) {\n        return true\n      }\n      if (isPromise(promise)) {\n        throw this.getAsyncError()\n      }\n    }\n  }\n\n  visitTick(stack) {\n    let visit = stack[stack.length - 1]\n    let { node, visitors } = visit\n\n    if (node.type !== 'root' && node.type !== 'document' && !node.parent) {\n      stack.pop()\n      return\n    }\n\n    if (visitors.length > 0 && visit.visitorIndex < visitors.length) {\n      let [plugin, visitor] = visitors[visit.visitorIndex]\n      visit.visitorIndex += 1\n      if (visit.visitorIndex === visitors.length) {\n        visit.visitors = []\n        visit.visitorIndex = 0\n      }\n      this.result.lastPlugin = plugin\n      try {\n        return visitor(node.toProxy(), this.helpers)\n      } catch (e) {\n        throw this.handleError(e, node)\n      }\n    }\n\n    if (visit.iterator !== 0) {\n      let iterator = visit.iterator\n      let child\n      while ((child = node.nodes[node.indexes[iterator]])) {\n        node.indexes[iterator] += 1\n        if (!child[isClean]) {\n          child[isClean] = true\n          stack.push(toStack(child))\n          return\n        }\n      }\n      visit.iterator = 0\n      delete node.indexes[iterator]\n    }\n\n    let events = visit.events\n    while (visit.eventIndex < events.length) {\n      let event = events[visit.eventIndex]\n      visit.eventIndex += 1\n      if (event === CHILDREN) {\n        if (node.nodes && node.nodes.length) {\n          node[isClean] = true\n          visit.iterator = node.getIterator()\n        }\n        return\n      } else if (this.listeners[event]) {\n        visit.visitors = this.listeners[event]\n        return\n      }\n    }\n    stack.pop()\n  }\n\n  walkSync(node) {\n    node[isClean] = true\n    let events = getEvents(node)\n    for (let event of events) {\n      if (event === CHILDREN) {\n        if (node.nodes) {\n          node.each(child => {\n            if (!child[isClean]) this.walkSync(child)\n          })\n        }\n      } else {\n        let visitors = this.listeners[event]\n        if (visitors) {\n          if (this.visitSync(visitors, node.toProxy())) return\n        }\n      }\n    }\n  }\n\n  warnings() {\n    return this.sync().warnings()\n  }\n\n  get content() {\n    return this.stringify().content\n  }\n\n  get css() {\n    return this.stringify().css\n  }\n\n  get map() {\n    return this.stringify().map\n  }\n\n  get messages() {\n    return this.sync().messages\n  }\n\n  get opts() {\n    return this.result.opts\n  }\n\n  get processor() {\n    return this.result.processor\n  }\n\n  get root() {\n    return this.sync().root\n  }\n\n  get [Symbol.toStringTag]() {\n    return 'LazyResult'\n  }\n}\n\nLazyResult.registerPostcss = dependant => {\n  postcss = dependant\n}\n\nmodule.exports = LazyResult\nLazyResult.default = LazyResult\n\nRoot.registerLazyResult(LazyResult)\nDocument.registerLazyResult(LazyResult)\n","'use strict'\n\nlet list = {\n  comma(string) {\n    return list.split(string, [','], true)\n  },\n\n  space(string) {\n    let spaces = [' ', '\\n', '\\t']\n    return list.split(string, spaces)\n  },\n\n  split(string, separators, last) {\n    let array = []\n    let current = ''\n    let split = false\n\n    let func = 0\n    let inQuote = false\n    let prevQuote = ''\n    let escape = false\n\n    for (let letter of string) {\n      if (escape) {\n        escape = false\n      } else if (letter === '\\\\') {\n        escape = true\n      } else if (inQuote) {\n        if (letter === prevQuote) {\n          inQuote = false\n        }\n      } else if (letter === '\"' || letter === \"'\") {\n        inQuote = true\n        prevQuote = letter\n      } else if (letter === '(') {\n        func += 1\n      } else if (letter === ')') {\n        if (func > 0) func -= 1\n      } else if (func === 0) {\n        if (separators.includes(letter)) split = true\n      }\n\n      if (split) {\n        if (current !== '') array.push(current.trim())\n        current = ''\n        split = false\n      } else {\n        current += letter\n      }\n    }\n\n    if (last || current !== '') array.push(current.trim())\n    return array\n  }\n}\n\nmodule.exports = list\nlist.default = list\n","'use strict'\n\nlet { dirname, relative, resolve, sep } = require('path')\nlet { SourceMapConsumer, SourceMapGenerator } = require('source-map-js')\nlet { pathToFileURL } = require('url')\n\nlet Input = require('./input')\n\nlet sourceMapAvailable = Boolean(SourceMapConsumer && SourceMapGenerator)\nlet pathAvailable = Boolean(dirname && resolve && relative && sep)\n\nclass MapGenerator {\n  constructor(stringify, root, opts, cssString) {\n    this.stringify = stringify\n    this.mapOpts = opts.map || {}\n    this.root = root\n    this.opts = opts\n    this.css = cssString\n    this.originalCSS = cssString\n    this.usesFileUrls = !this.mapOpts.from && this.mapOpts.absolute\n\n    this.memoizedFileURLs = new Map()\n    this.memoizedPaths = new Map()\n    this.memoizedURLs = new Map()\n  }\n\n  addAnnotation() {\n    let content\n\n    if (this.isInline()) {\n      content =\n        'data:application/json;base64,' + this.toBase64(this.map.toString())\n    } else if (typeof this.mapOpts.annotation === 'string') {\n      content = this.mapOpts.annotation\n    } else if (typeof this.mapOpts.annotation === 'function') {\n      content = this.mapOpts.annotation(this.opts.to, this.root)\n    } else {\n      content = this.outputFile() + '.map'\n    }\n    let eol = '\\n'\n    if (this.css.includes('\\r\\n')) eol = '\\r\\n'\n\n    this.css += eol + '/*# sourceMappingURL=' + content + ' */'\n  }\n\n  applyPrevMaps() {\n    for (let prev of this.previous()) {\n      let from = this.toUrl(this.path(prev.file))\n      let root = prev.root || dirname(prev.file)\n      let map\n\n      if (this.mapOpts.sourcesContent === false) {\n        map = new SourceMapConsumer(prev.text)\n        if (map.sourcesContent) {\n          map.sourcesContent = null\n        }\n      } else {\n        map = prev.consumer()\n      }\n\n      this.map.applySourceMap(map, from, this.toUrl(this.path(root)))\n    }\n  }\n\n  clearAnnotation() {\n    if (this.mapOpts.annotation === false) return\n\n    if (this.root) {\n      let node\n      for (let i = this.root.nodes.length - 1; i >= 0; i--) {\n        node = this.root.nodes[i]\n        if (node.type !== 'comment') continue\n        if (node.text.startsWith('# sourceMappingURL=')) {\n          this.root.removeChild(i)\n        }\n      }\n    } else if (this.css) {\n      this.css = this.css.replace(/\\n*\\/\\*#[\\S\\s]*?\\*\\/$/gm, '')\n    }\n  }\n\n  generate() {\n    this.clearAnnotation()\n    if (pathAvailable && sourceMapAvailable && this.isMap()) {\n      return this.generateMap()\n    } else {\n      let result = ''\n      this.stringify(this.root, i => {\n        result += i\n      })\n      return [result]\n    }\n  }\n\n  generateMap() {\n    if (this.root) {\n      this.generateString()\n    } else if (this.previous().length === 1) {\n      let prev = this.previous()[0].consumer()\n      prev.file = this.outputFile()\n      this.map = SourceMapGenerator.fromSourceMap(prev, {\n        ignoreInvalidMapping: true\n      })\n    } else {\n      this.map = new SourceMapGenerator({\n        file: this.outputFile(),\n        ignoreInvalidMapping: true\n      })\n      this.map.addMapping({\n        generated: { column: 0, line: 1 },\n        original: { column: 0, line: 1 },\n        source: this.opts.from\n          ? this.toUrl(this.path(this.opts.from))\n          : '<no source>'\n      })\n    }\n\n    if (this.isSourcesContent()) this.setSourcesContent()\n    if (this.root && this.previous().length > 0) this.applyPrevMaps()\n    if (this.isAnnotation()) this.addAnnotation()\n\n    if (this.isInline()) {\n      return [this.css]\n    } else {\n      return [this.css, this.map]\n    }\n  }\n\n  generateString() {\n    this.css = ''\n    this.map = new SourceMapGenerator({\n      file: this.outputFile(),\n      ignoreInvalidMapping: true\n    })\n\n    let line = 1\n    let column = 1\n\n    let noSource = '<no source>'\n    let mapping = {\n      generated: { column: 0, line: 0 },\n      original: { column: 0, line: 0 },\n      source: ''\n    }\n\n    let last, lines\n    this.stringify(this.root, (str, node, type) => {\n      this.css += str\n\n      if (node && type !== 'end') {\n        mapping.generated.line = line\n        mapping.generated.column = column - 1\n        if (node.source && node.source.start) {\n          mapping.source = this.sourcePath(node)\n          mapping.original.line = node.source.start.line\n          mapping.original.column = node.source.start.column - 1\n          this.map.addMapping(mapping)\n        } else {\n          mapping.source = noSource\n          mapping.original.line = 1\n          mapping.original.column = 0\n          this.map.addMapping(mapping)\n        }\n      }\n\n      lines = str.match(/\\n/g)\n      if (lines) {\n        line += lines.length\n        last = str.lastIndexOf('\\n')\n        column = str.length - last\n      } else {\n        column += str.length\n      }\n\n      if (node && type !== 'start') {\n        let p = node.parent || { raws: {} }\n        let childless =\n          node.type === 'decl' || (node.type === 'atrule' && !node.nodes)\n        if (!childless || node !== p.last || p.raws.semicolon) {\n          if (node.source && node.source.end) {\n            mapping.source = this.sourcePath(node)\n            mapping.original.line = node.source.end.line\n            mapping.original.column = node.source.end.column - 1\n            mapping.generated.line = line\n            mapping.generated.column = column - 2\n            this.map.addMapping(mapping)\n          } else {\n            mapping.source = noSource\n            mapping.original.line = 1\n            mapping.original.column = 0\n            mapping.generated.line = line\n            mapping.generated.column = column - 1\n            this.map.addMapping(mapping)\n          }\n        }\n      }\n    })\n  }\n\n  isAnnotation() {\n    if (this.isInline()) {\n      return true\n    }\n    if (typeof this.mapOpts.annotation !== 'undefined') {\n      return this.mapOpts.annotation\n    }\n    if (this.previous().length) {\n      return this.previous().some(i => i.annotation)\n    }\n    return true\n  }\n\n  isInline() {\n    if (typeof this.mapOpts.inline !== 'undefined') {\n      return this.mapOpts.inline\n    }\n\n    let annotation = this.mapOpts.annotation\n    if (typeof annotation !== 'undefined' && annotation !== true) {\n      return false\n    }\n\n    if (this.previous().length) {\n      return this.previous().some(i => i.inline)\n    }\n    return true\n  }\n\n  isMap() {\n    if (typeof this.opts.map !== 'undefined') {\n      return !!this.opts.map\n    }\n    return this.previous().length > 0\n  }\n\n  isSourcesContent() {\n    if (typeof this.mapOpts.sourcesContent !== 'undefined') {\n      return this.mapOpts.sourcesContent\n    }\n    if (this.previous().length) {\n      return this.previous().some(i => i.withContent())\n    }\n    return true\n  }\n\n  outputFile() {\n    if (this.opts.to) {\n      return this.path(this.opts.to)\n    } else if (this.opts.from) {\n      return this.path(this.opts.from)\n    } else {\n      return 'to.css'\n    }\n  }\n\n  path(file) {\n    if (this.mapOpts.absolute) return file\n    if (file.charCodeAt(0) === 60 /* `<` */) return file\n    if (/^\\w+:\\/\\//.test(file)) return file\n    let cached = this.memoizedPaths.get(file)\n    if (cached) return cached\n\n    let from = this.opts.to ? dirname(this.opts.to) : '.'\n\n    if (typeof this.mapOpts.annotation === 'string') {\n      from = dirname(resolve(from, this.mapOpts.annotation))\n    }\n\n    let path = relative(from, file)\n    this.memoizedPaths.set(file, path)\n\n    return path\n  }\n\n  previous() {\n    if (!this.previousMaps) {\n      this.previousMaps = []\n      if (this.root) {\n        this.root.walk(node => {\n          if (node.source && node.source.input.map) {\n            let map = node.source.input.map\n            if (!this.previousMaps.includes(map)) {\n              this.previousMaps.push(map)\n            }\n          }\n        })\n      } else {\n        let input = new Input(this.originalCSS, this.opts)\n        if (input.map) this.previousMaps.push(input.map)\n      }\n    }\n\n    return this.previousMaps\n  }\n\n  setSourcesContent() {\n    let already = {}\n    if (this.root) {\n      this.root.walk(node => {\n        if (node.source) {\n          let from = node.source.input.from\n          if (from && !already[from]) {\n            already[from] = true\n            let fromUrl = this.usesFileUrls\n              ? this.toFileUrl(from)\n              : this.toUrl(this.path(from))\n            this.map.setSourceContent(fromUrl, node.source.input.css)\n          }\n        }\n      })\n    } else if (this.css) {\n      let from = this.opts.from\n        ? this.toUrl(this.path(this.opts.from))\n        : '<no source>'\n      this.map.setSourceContent(from, this.css)\n    }\n  }\n\n  sourcePath(node) {\n    if (this.mapOpts.from) {\n      return this.toUrl(this.mapOpts.from)\n    } else if (this.usesFileUrls) {\n      return this.toFileUrl(node.source.input.from)\n    } else {\n      return this.toUrl(this.path(node.source.input.from))\n    }\n  }\n\n  toBase64(str) {\n    if (Buffer) {\n      return Buffer.from(str).toString('base64')\n    } else {\n      return window.btoa(unescape(encodeURIComponent(str)))\n    }\n  }\n\n  toFileUrl(path) {\n    let cached = this.memoizedFileURLs.get(path)\n    if (cached) return cached\n\n    if (pathToFileURL) {\n      let fileURL = pathToFileURL(path).toString()\n      this.memoizedFileURLs.set(path, fileURL)\n\n      return fileURL\n    } else {\n      throw new Error(\n        '`map.absolute` option is not available in this PostCSS build'\n      )\n    }\n  }\n\n  toUrl(path) {\n    let cached = this.memoizedURLs.get(path)\n    if (cached) return cached\n\n    if (sep === '\\\\') {\n      path = path.replace(/\\\\/g, '/')\n    }\n\n    let url = encodeURI(path).replace(/[#?]/g, encodeURIComponent)\n    this.memoizedURLs.set(path, url)\n\n    return url\n  }\n}\n\nmodule.exports = MapGenerator\n","'use strict'\n\nlet MapGenerator = require('./map-generator')\nlet parse = require('./parse')\nconst Result = require('./result')\nlet stringify = require('./stringify')\nlet warnOnce = require('./warn-once')\n\nclass NoWorkResult {\n  constructor(processor, css, opts) {\n    css = css.toString()\n    this.stringified = false\n\n    this._processor = processor\n    this._css = css\n    this._opts = opts\n    this._map = undefined\n    let root\n\n    let str = stringify\n    this.result = new Result(this._processor, root, this._opts)\n    this.result.css = css\n\n    let self = this\n    Object.defineProperty(this.result, 'root', {\n      get() {\n        return self.root\n      }\n    })\n\n    let map = new MapGenerator(str, root, this._opts, css)\n    if (map.isMap()) {\n      let [generatedCSS, generatedMap] = map.generate()\n      if (generatedCSS) {\n        this.result.css = generatedCSS\n      }\n      if (generatedMap) {\n        this.result.map = generatedMap\n      }\n    } else {\n      map.clearAnnotation()\n      this.result.css = map.css\n    }\n  }\n\n  async() {\n    if (this.error) return Promise.reject(this.error)\n    return Promise.resolve(this.result)\n  }\n\n  catch(onRejected) {\n    return this.async().catch(onRejected)\n  }\n\n  finally(onFinally) {\n    return this.async().then(onFinally, onFinally)\n  }\n\n  sync() {\n    if (this.error) throw this.error\n    return this.result\n  }\n\n  then(onFulfilled, onRejected) {\n    if (process.env.NODE_ENV !== 'production') {\n      if (!('from' in this._opts)) {\n        warnOnce(\n          'Without `from` option PostCSS could generate wrong source map ' +\n            'and will not find Browserslist config. Set it to CSS file path ' +\n            'or to `undefined` to prevent this warning.'\n        )\n      }\n    }\n\n    return this.async().then(onFulfilled, onRejected)\n  }\n\n  toString() {\n    return this._css\n  }\n\n  warnings() {\n    return []\n  }\n\n  get content() {\n    return this.result.css\n  }\n\n  get css() {\n    return this.result.css\n  }\n\n  get map() {\n    return this.result.map\n  }\n\n  get messages() {\n    return []\n  }\n\n  get opts() {\n    return this.result.opts\n  }\n\n  get processor() {\n    return this.result.processor\n  }\n\n  get root() {\n    if (this._root) {\n      return this._root\n    }\n\n    let root\n    let parser = parse\n\n    try {\n      root = parser(this._css, this._opts)\n    } catch (error) {\n      this.error = error\n    }\n\n    if (this.error) {\n      throw this.error\n    } else {\n      this._root = root\n      return root\n    }\n  }\n\n  get [Symbol.toStringTag]() {\n    return 'NoWorkResult'\n  }\n}\n\nmodule.exports = NoWorkResult\nNoWorkResult.default = NoWorkResult\n","'use strict'\n\nlet CssSyntaxError = require('./css-syntax-error')\nlet Stringifier = require('./stringifier')\nlet stringify = require('./stringify')\nlet { isClean, my } = require('./symbols')\n\nfunction cloneNode(obj, parent) {\n  let cloned = new obj.constructor()\n\n  for (let i in obj) {\n    if (!Object.prototype.hasOwnProperty.call(obj, i)) {\n      /* c8 ignore next 2 */\n      continue\n    }\n    if (i === 'proxyCache') continue\n    let value = obj[i]\n    let type = typeof value\n\n    if (i === 'parent' && type === 'object') {\n      if (parent) cloned[i] = parent\n    } else if (i === 'source') {\n      cloned[i] = value\n    } else if (Array.isArray(value)) {\n      cloned[i] = value.map(j => cloneNode(j, cloned))\n    } else {\n      if (type === 'object' && value !== null) value = cloneNode(value)\n      cloned[i] = value\n    }\n  }\n\n  return cloned\n}\n\nclass Node {\n  constructor(defaults = {}) {\n    this.raws = {}\n    this[isClean] = false\n    this[my] = true\n\n    for (let name in defaults) {\n      if (name === 'nodes') {\n        this.nodes = []\n        for (let node of defaults[name]) {\n          if (typeof node.clone === 'function') {\n            this.append(node.clone())\n          } else {\n            this.append(node)\n          }\n        }\n      } else {\n        this[name] = defaults[name]\n      }\n    }\n  }\n\n  addToError(error) {\n    error.postcssNode = this\n    if (error.stack && this.source && /\\n\\s{4}at /.test(error.stack)) {\n      let s = this.source\n      error.stack = error.stack.replace(\n        /\\n\\s{4}at /,\n        `$&${s.input.from}:${s.start.line}:${s.start.column}$&`\n      )\n    }\n    return error\n  }\n\n  after(add) {\n    this.parent.insertAfter(this, add)\n    return this\n  }\n\n  assign(overrides = {}) {\n    for (let name in overrides) {\n      this[name] = overrides[name]\n    }\n    return this\n  }\n\n  before(add) {\n    this.parent.insertBefore(this, add)\n    return this\n  }\n\n  cleanRaws(keepBetween) {\n    delete this.raws.before\n    delete this.raws.after\n    if (!keepBetween) delete this.raws.between\n  }\n\n  clone(overrides = {}) {\n    let cloned = cloneNode(this)\n    for (let name in overrides) {\n      cloned[name] = overrides[name]\n    }\n    return cloned\n  }\n\n  cloneAfter(overrides = {}) {\n    let cloned = this.clone(overrides)\n    this.parent.insertAfter(this, cloned)\n    return cloned\n  }\n\n  cloneBefore(overrides = {}) {\n    let cloned = this.clone(overrides)\n    this.parent.insertBefore(this, cloned)\n    return cloned\n  }\n\n  error(message, opts = {}) {\n    if (this.source) {\n      let { end, start } = this.rangeBy(opts)\n      return this.source.input.error(\n        message,\n        { column: start.column, line: start.line },\n        { column: end.column, line: end.line },\n        opts\n      )\n    }\n    return new CssSyntaxError(message)\n  }\n\n  getProxyProcessor() {\n    return {\n      get(node, prop) {\n        if (prop === 'proxyOf') {\n          return node\n        } else if (prop === 'root') {\n          return () => node.root().toProxy()\n        } else {\n          return node[prop]\n        }\n      },\n\n      set(node, prop, value) {\n        if (node[prop] === value) return true\n        node[prop] = value\n        if (\n          prop === 'prop' ||\n          prop === 'value' ||\n          prop === 'name' ||\n          prop === 'params' ||\n          prop === 'important' ||\n          /* c8 ignore next */\n          prop === 'text'\n        ) {\n          node.markDirty()\n        }\n        return true\n      }\n    }\n  }\n\n  /* c8 ignore next 3 */\n  markClean() {\n    this[isClean] = true\n  }\n\n  markDirty() {\n    if (this[isClean]) {\n      this[isClean] = false\n      let next = this\n      while ((next = next.parent)) {\n        next[isClean] = false\n      }\n    }\n  }\n\n  next() {\n    if (!this.parent) return undefined\n    let index = this.parent.index(this)\n    return this.parent.nodes[index + 1]\n  }\n\n  positionBy(opts, stringRepresentation) {\n    let pos = this.source.start\n    if (opts.index) {\n      pos = this.positionInside(opts.index, stringRepresentation)\n    } else if (opts.word) {\n      stringRepresentation = this.toString()\n      let index = stringRepresentation.indexOf(opts.word)\n      if (index !== -1) pos = this.positionInside(index, stringRepresentation)\n    }\n    return pos\n  }\n\n  positionInside(index, stringRepresentation) {\n    let string = stringRepresentation || this.toString()\n    let column = this.source.start.column\n    let line = this.source.start.line\n\n    for (let i = 0; i < index; i++) {\n      if (string[i] === '\\n') {\n        column = 1\n        line += 1\n      } else {\n        column += 1\n      }\n    }\n\n    return { column, line }\n  }\n\n  prev() {\n    if (!this.parent) return undefined\n    let index = this.parent.index(this)\n    return this.parent.nodes[index - 1]\n  }\n\n  rangeBy(opts) {\n    let start = {\n      column: this.source.start.column,\n      line: this.source.start.line\n    }\n    let end = this.source.end\n      ? {\n          column: this.source.end.column + 1,\n          line: this.source.end.line\n        }\n      : {\n          column: start.column + 1,\n          line: start.line\n        }\n\n    if (opts.word) {\n      let stringRepresentation = this.toString()\n      let index = stringRepresentation.indexOf(opts.word)\n      if (index !== -1) {\n        start = this.positionInside(index, stringRepresentation)\n        end = this.positionInside(\n          index + opts.word.length,\n          stringRepresentation\n        )\n      }\n    } else {\n      if (opts.start) {\n        start = {\n          column: opts.start.column,\n          line: opts.start.line\n        }\n      } else if (opts.index) {\n        start = this.positionInside(opts.index)\n      }\n\n      if (opts.end) {\n        end = {\n          column: opts.end.column,\n          line: opts.end.line\n        }\n      } else if (typeof opts.endIndex === 'number') {\n        end = this.positionInside(opts.endIndex)\n      } else if (opts.index) {\n        end = this.positionInside(opts.index + 1)\n      }\n    }\n\n    if (\n      end.line < start.line ||\n      (end.line === start.line && end.column <= start.column)\n    ) {\n      end = { column: start.column + 1, line: start.line }\n    }\n\n    return { end, start }\n  }\n\n  raw(prop, defaultType) {\n    let str = new Stringifier()\n    return str.raw(this, prop, defaultType)\n  }\n\n  remove() {\n    if (this.parent) {\n      this.parent.removeChild(this)\n    }\n    this.parent = undefined\n    return this\n  }\n\n  replaceWith(...nodes) {\n    if (this.parent) {\n      let bookmark = this\n      let foundSelf = false\n      for (let node of nodes) {\n        if (node === this) {\n          foundSelf = true\n        } else if (foundSelf) {\n          this.parent.insertAfter(bookmark, node)\n          bookmark = node\n        } else {\n          this.parent.insertBefore(bookmark, node)\n        }\n      }\n\n      if (!foundSelf) {\n        this.remove()\n      }\n    }\n\n    return this\n  }\n\n  root() {\n    let result = this\n    while (result.parent && result.parent.type !== 'document') {\n      result = result.parent\n    }\n    return result\n  }\n\n  toJSON(_, inputs) {\n    let fixed = {}\n    let emitInputs = inputs == null\n    inputs = inputs || new Map()\n    let inputsNextIndex = 0\n\n    for (let name in this) {\n      if (!Object.prototype.hasOwnProperty.call(this, name)) {\n        /* c8 ignore next 2 */\n        continue\n      }\n      if (name === 'parent' || name === 'proxyCache') continue\n      let value = this[name]\n\n      if (Array.isArray(value)) {\n        fixed[name] = value.map(i => {\n          if (typeof i === 'object' && i.toJSON) {\n            return i.toJSON(null, inputs)\n          } else {\n            return i\n          }\n        })\n      } else if (typeof value === 'object' && value.toJSON) {\n        fixed[name] = value.toJSON(null, inputs)\n      } else if (name === 'source') {\n        let inputId = inputs.get(value.input)\n        if (inputId == null) {\n          inputId = inputsNextIndex\n          inputs.set(value.input, inputsNextIndex)\n          inputsNextIndex++\n        }\n        fixed[name] = {\n          end: value.end,\n          inputId,\n          start: value.start\n        }\n      } else {\n        fixed[name] = value\n      }\n    }\n\n    if (emitInputs) {\n      fixed.inputs = [...inputs.keys()].map(input => input.toJSON())\n    }\n\n    return fixed\n  }\n\n  toProxy() {\n    if (!this.proxyCache) {\n      this.proxyCache = new Proxy(this, this.getProxyProcessor())\n    }\n    return this.proxyCache\n  }\n\n  toString(stringifier = stringify) {\n    if (stringifier.stringify) stringifier = stringifier.stringify\n    let result = ''\n    stringifier(this, i => {\n      result += i\n    })\n    return result\n  }\n\n  warn(result, text, opts) {\n    let data = { node: this }\n    for (let i in opts) data[i] = opts[i]\n    return result.warn(text, data)\n  }\n\n  get proxyOf() {\n    return this\n  }\n}\n\nmodule.exports = Node\nNode.default = Node\n","'use strict'\n\nlet Container = require('./container')\nlet Input = require('./input')\nlet Parser = require('./parser')\n\nfunction parse(css, opts) {\n  let input = new Input(css, opts)\n  let parser = new Parser(input)\n  try {\n    parser.parse()\n  } catch (e) {\n    if (process.env.NODE_ENV !== 'production') {\n      if (e.name === 'CssSyntaxError' && opts && opts.from) {\n        if (/\\.scss$/i.test(opts.from)) {\n          e.message +=\n            '\\nYou tried to parse SCSS with ' +\n            'the standard CSS parser; ' +\n            'try again with the postcss-scss parser'\n        } else if (/\\.sass/i.test(opts.from)) {\n          e.message +=\n            '\\nYou tried to parse Sass with ' +\n            'the standard CSS parser; ' +\n            'try again with the postcss-sass parser'\n        } else if (/\\.less$/i.test(opts.from)) {\n          e.message +=\n            '\\nYou tried to parse Less with ' +\n            'the standard CSS parser; ' +\n            'try again with the postcss-less parser'\n        }\n      }\n    }\n    throw e\n  }\n\n  return parser.root\n}\n\nmodule.exports = parse\nparse.default = parse\n\nContainer.registerParse(parse)\n","'use strict'\n\nlet AtRule = require('./at-rule')\nlet Comment = require('./comment')\nlet Declaration = require('./declaration')\nlet Root = require('./root')\nlet Rule = require('./rule')\nlet tokenizer = require('./tokenize')\n\nconst SAFE_COMMENT_NEIGHBOR = {\n  empty: true,\n  space: true\n}\n\nfunction findLastWithPosition(tokens) {\n  for (let i = tokens.length - 1; i >= 0; i--) {\n    let token = tokens[i]\n    let pos = token[3] || token[2]\n    if (pos) return pos\n  }\n}\n\nclass Parser {\n  constructor(input) {\n    this.input = input\n\n    this.root = new Root()\n    this.current = this.root\n    this.spaces = ''\n    this.semicolon = false\n\n    this.createTokenizer()\n    this.root.source = { input, start: { column: 1, line: 1, offset: 0 } }\n  }\n\n  atrule(token) {\n    let node = new AtRule()\n    node.name = token[1].slice(1)\n    if (node.name === '') {\n      this.unnamedAtrule(node, token)\n    }\n    this.init(node, token[2])\n\n    let type\n    let prev\n    let shift\n    let last = false\n    let open = false\n    let params = []\n    let brackets = []\n\n    while (!this.tokenizer.endOfFile()) {\n      token = this.tokenizer.nextToken()\n      type = token[0]\n\n      if (type === '(' || type === '[') {\n        brackets.push(type === '(' ? ')' : ']')\n      } else if (type === '{' && brackets.length > 0) {\n        brackets.push('}')\n      } else if (type === brackets[brackets.length - 1]) {\n        brackets.pop()\n      }\n\n      if (brackets.length === 0) {\n        if (type === ';') {\n          node.source.end = this.getPosition(token[2])\n          node.source.end.offset++\n          this.semicolon = true\n          break\n        } else if (type === '{') {\n          open = true\n          break\n        } else if (type === '}') {\n          if (params.length > 0) {\n            shift = params.length - 1\n            prev = params[shift]\n            while (prev && prev[0] === 'space') {\n              prev = params[--shift]\n            }\n            if (prev) {\n              node.source.end = this.getPosition(prev[3] || prev[2])\n              node.source.end.offset++\n            }\n          }\n          this.end(token)\n          break\n        } else {\n          params.push(token)\n        }\n      } else {\n        params.push(token)\n      }\n\n      if (this.tokenizer.endOfFile()) {\n        last = true\n        break\n      }\n    }\n\n    node.raws.between = this.spacesAndCommentsFromEnd(params)\n    if (params.length) {\n      node.raws.afterName = this.spacesAndCommentsFromStart(params)\n      this.raw(node, 'params', params)\n      if (last) {\n        token = params[params.length - 1]\n        node.source.end = this.getPosition(token[3] || token[2])\n        node.source.end.offset++\n        this.spaces = node.raws.between\n        node.raws.between = ''\n      }\n    } else {\n      node.raws.afterName = ''\n      node.params = ''\n    }\n\n    if (open) {\n      node.nodes = []\n      this.current = node\n    }\n  }\n\n  checkMissedSemicolon(tokens) {\n    let colon = this.colon(tokens)\n    if (colon === false) return\n\n    let founded = 0\n    let token\n    for (let j = colon - 1; j >= 0; j--) {\n      token = tokens[j]\n      if (token[0] !== 'space') {\n        founded += 1\n        if (founded === 2) break\n      }\n    }\n    // If the token is a word, e.g. `!important`, `red` or any other valid property's value.\n    // Then we need to return the colon after that word token. [3] is the \"end\" colon of that word.\n    // And because we need it after that one we do +1 to get the next one.\n    throw this.input.error(\n      'Missed semicolon',\n      token[0] === 'word' ? token[3] + 1 : token[2]\n    )\n  }\n\n  colon(tokens) {\n    let brackets = 0\n    let prev, token, type\n    for (let [i, element] of tokens.entries()) {\n      token = element\n      type = token[0]\n\n      if (type === '(') {\n        brackets += 1\n      }\n      if (type === ')') {\n        brackets -= 1\n      }\n      if (brackets === 0 && type === ':') {\n        if (!prev) {\n          this.doubleColon(token)\n        } else if (prev[0] === 'word' && prev[1] === 'progid') {\n          continue\n        } else {\n          return i\n        }\n      }\n\n      prev = token\n    }\n    return false\n  }\n\n  comment(token) {\n    let node = new Comment()\n    this.init(node, token[2])\n    node.source.end = this.getPosition(token[3] || token[2])\n    node.source.end.offset++\n\n    let text = token[1].slice(2, -2)\n    if (/^\\s*$/.test(text)) {\n      node.text = ''\n      node.raws.left = text\n      node.raws.right = ''\n    } else {\n      let match = text.match(/^(\\s*)([^]*\\S)(\\s*)$/)\n      node.text = match[2]\n      node.raws.left = match[1]\n      node.raws.right = match[3]\n    }\n  }\n\n  createTokenizer() {\n    this.tokenizer = tokenizer(this.input)\n  }\n\n  decl(tokens, customProperty) {\n    let node = new Declaration()\n    this.init(node, tokens[0][2])\n\n    let last = tokens[tokens.length - 1]\n    if (last[0] === ';') {\n      this.semicolon = true\n      tokens.pop()\n    }\n\n    node.source.end = this.getPosition(\n      last[3] || last[2] || findLastWithPosition(tokens)\n    )\n    node.source.end.offset++\n\n    while (tokens[0][0] !== 'word') {\n      if (tokens.length === 1) this.unknownWord(tokens)\n      node.raws.before += tokens.shift()[1]\n    }\n    node.source.start = this.getPosition(tokens[0][2])\n\n    node.prop = ''\n    while (tokens.length) {\n      let type = tokens[0][0]\n      if (type === ':' || type === 'space' || type === 'comment') {\n        break\n      }\n      node.prop += tokens.shift()[1]\n    }\n\n    node.raws.between = ''\n\n    let token\n    while (tokens.length) {\n      token = tokens.shift()\n\n      if (token[0] === ':') {\n        node.raws.between += token[1]\n        break\n      } else {\n        if (token[0] === 'word' && /\\w/.test(token[1])) {\n          this.unknownWord([token])\n        }\n        node.raws.between += token[1]\n      }\n    }\n\n    if (node.prop[0] === '_' || node.prop[0] === '*') {\n      node.raws.before += node.prop[0]\n      node.prop = node.prop.slice(1)\n    }\n\n    let firstSpaces = []\n    let next\n    while (tokens.length) {\n      next = tokens[0][0]\n      if (next !== 'space' && next !== 'comment') break\n      firstSpaces.push(tokens.shift())\n    }\n\n    this.precheckMissedSemicolon(tokens)\n\n    for (let i = tokens.length - 1; i >= 0; i--) {\n      token = tokens[i]\n      if (token[1].toLowerCase() === '!important') {\n        node.important = true\n        let string = this.stringFrom(tokens, i)\n        string = this.spacesFromEnd(tokens) + string\n        if (string !== ' !important') node.raws.important = string\n        break\n      } else if (token[1].toLowerCase() === 'important') {\n        let cache = tokens.slice(0)\n        let str = ''\n        for (let j = i; j > 0; j--) {\n          let type = cache[j][0]\n          if (str.trim().startsWith('!') && type !== 'space') {\n            break\n          }\n          str = cache.pop()[1] + str\n        }\n        if (str.trim().startsWith('!')) {\n          node.important = true\n          node.raws.important = str\n          tokens = cache\n        }\n      }\n\n      if (token[0] !== 'space' && token[0] !== 'comment') {\n        break\n      }\n    }\n\n    let hasWord = tokens.some(i => i[0] !== 'space' && i[0] !== 'comment')\n\n    if (hasWord) {\n      node.raws.between += firstSpaces.map(i => i[1]).join('')\n      firstSpaces = []\n    }\n    this.raw(node, 'value', firstSpaces.concat(tokens), customProperty)\n\n    if (node.value.includes(':') && !customProperty) {\n      this.checkMissedSemicolon(tokens)\n    }\n  }\n\n  doubleColon(token) {\n    throw this.input.error(\n      'Double colon',\n      { offset: token[2] },\n      { offset: token[2] + token[1].length }\n    )\n  }\n\n  emptyRule(token) {\n    let node = new Rule()\n    this.init(node, token[2])\n    node.selector = ''\n    node.raws.between = ''\n    this.current = node\n  }\n\n  end(token) {\n    if (this.current.nodes && this.current.nodes.length) {\n      this.current.raws.semicolon = this.semicolon\n    }\n    this.semicolon = false\n\n    this.current.raws.after = (this.current.raws.after || '') + this.spaces\n    this.spaces = ''\n\n    if (this.current.parent) {\n      this.current.source.end = this.getPosition(token[2])\n      this.current.source.end.offset++\n      this.current = this.current.parent\n    } else {\n      this.unexpectedClose(token)\n    }\n  }\n\n  endFile() {\n    if (this.current.parent) this.unclosedBlock()\n    if (this.current.nodes && this.current.nodes.length) {\n      this.current.raws.semicolon = this.semicolon\n    }\n    this.current.raws.after = (this.current.raws.after || '') + this.spaces\n    this.root.source.end = this.getPosition(this.tokenizer.position())\n  }\n\n  freeSemicolon(token) {\n    this.spaces += token[1]\n    if (this.current.nodes) {\n      let prev = this.current.nodes[this.current.nodes.length - 1]\n      if (prev && prev.type === 'rule' && !prev.raws.ownSemicolon) {\n        prev.raws.ownSemicolon = this.spaces\n        this.spaces = ''\n      }\n    }\n  }\n\n  // Helpers\n\n  getPosition(offset) {\n    let pos = this.input.fromOffset(offset)\n    return {\n      column: pos.col,\n      line: pos.line,\n      offset\n    }\n  }\n\n  init(node, offset) {\n    this.current.push(node)\n    node.source = {\n      input: this.input,\n      start: this.getPosition(offset)\n    }\n    node.raws.before = this.spaces\n    this.spaces = ''\n    if (node.type !== 'comment') this.semicolon = false\n  }\n\n  other(start) {\n    let end = false\n    let type = null\n    let colon = false\n    let bracket = null\n    let brackets = []\n    let customProperty = start[1].startsWith('--')\n\n    let tokens = []\n    let token = start\n    while (token) {\n      type = token[0]\n      tokens.push(token)\n\n      if (type === '(' || type === '[') {\n        if (!bracket) bracket = token\n        brackets.push(type === '(' ? ')' : ']')\n      } else if (customProperty && colon && type === '{') {\n        if (!bracket) bracket = token\n        brackets.push('}')\n      } else if (brackets.length === 0) {\n        if (type === ';') {\n          if (colon) {\n            this.decl(tokens, customProperty)\n            return\n          } else {\n            break\n          }\n        } else if (type === '{') {\n          this.rule(tokens)\n          return\n        } else if (type === '}') {\n          this.tokenizer.back(tokens.pop())\n          end = true\n          break\n        } else if (type === ':') {\n          colon = true\n        }\n      } else if (type === brackets[brackets.length - 1]) {\n        brackets.pop()\n        if (brackets.length === 0) bracket = null\n      }\n\n      token = this.tokenizer.nextToken()\n    }\n\n    if (this.tokenizer.endOfFile()) end = true\n    if (brackets.length > 0) this.unclosedBracket(bracket)\n\n    if (end && colon) {\n      if (!customProperty) {\n        while (tokens.length) {\n          token = tokens[tokens.length - 1][0]\n          if (token !== 'space' && token !== 'comment') break\n          this.tokenizer.back(tokens.pop())\n        }\n      }\n      this.decl(tokens, customProperty)\n    } else {\n      this.unknownWord(tokens)\n    }\n  }\n\n  parse() {\n    let token\n    while (!this.tokenizer.endOfFile()) {\n      token = this.tokenizer.nextToken()\n\n      switch (token[0]) {\n        case 'space':\n          this.spaces += token[1]\n          break\n\n        case ';':\n          this.freeSemicolon(token)\n          break\n\n        case '}':\n          this.end(token)\n          break\n\n        case 'comment':\n          this.comment(token)\n          break\n\n        case 'at-word':\n          this.atrule(token)\n          break\n\n        case '{':\n          this.emptyRule(token)\n          break\n\n        default:\n          this.other(token)\n          break\n      }\n    }\n    this.endFile()\n  }\n\n  precheckMissedSemicolon(/* tokens */) {\n    // Hook for Safe Parser\n  }\n\n  raw(node, prop, tokens, customProperty) {\n    let token, type\n    let length = tokens.length\n    let value = ''\n    let clean = true\n    let next, prev\n\n    for (let i = 0; i < length; i += 1) {\n      token = tokens[i]\n      type = token[0]\n      if (type === 'space' && i === length - 1 && !customProperty) {\n        clean = false\n      } else if (type === 'comment') {\n        prev = tokens[i - 1] ? tokens[i - 1][0] : 'empty'\n        next = tokens[i + 1] ? tokens[i + 1][0] : 'empty'\n        if (!SAFE_COMMENT_NEIGHBOR[prev] && !SAFE_COMMENT_NEIGHBOR[next]) {\n          if (value.slice(-1) === ',') {\n            clean = false\n          } else {\n            value += token[1]\n          }\n        } else {\n          clean = false\n        }\n      } else {\n        value += token[1]\n      }\n    }\n    if (!clean) {\n      let raw = tokens.reduce((all, i) => all + i[1], '')\n      node.raws[prop] = { raw, value }\n    }\n    node[prop] = value\n  }\n\n  rule(tokens) {\n    tokens.pop()\n\n    let node = new Rule()\n    this.init(node, tokens[0][2])\n\n    node.raws.between = this.spacesAndCommentsFromEnd(tokens)\n    this.raw(node, 'selector', tokens)\n    this.current = node\n  }\n\n  spacesAndCommentsFromEnd(tokens) {\n    let lastTokenType\n    let spaces = ''\n    while (tokens.length) {\n      lastTokenType = tokens[tokens.length - 1][0]\n      if (lastTokenType !== 'space' && lastTokenType !== 'comment') break\n      spaces = tokens.pop()[1] + spaces\n    }\n    return spaces\n  }\n\n  // Errors\n\n  spacesAndCommentsFromStart(tokens) {\n    let next\n    let spaces = ''\n    while (tokens.length) {\n      next = tokens[0][0]\n      if (next !== 'space' && next !== 'comment') break\n      spaces += tokens.shift()[1]\n    }\n    return spaces\n  }\n\n  spacesFromEnd(tokens) {\n    let lastTokenType\n    let spaces = ''\n    while (tokens.length) {\n      lastTokenType = tokens[tokens.length - 1][0]\n      if (lastTokenType !== 'space') break\n      spaces = tokens.pop()[1] + spaces\n    }\n    return spaces\n  }\n\n  stringFrom(tokens, from) {\n    let result = ''\n    for (let i = from; i < tokens.length; i++) {\n      result += tokens[i][1]\n    }\n    tokens.splice(from, tokens.length - from)\n    return result\n  }\n\n  unclosedBlock() {\n    let pos = this.current.source.start\n    throw this.input.error('Unclosed block', pos.line, pos.column)\n  }\n\n  unclosedBracket(bracket) {\n    throw this.input.error(\n      'Unclosed bracket',\n      { offset: bracket[2] },\n      { offset: bracket[2] + 1 }\n    )\n  }\n\n  unexpectedClose(token) {\n    throw this.input.error(\n      'Unexpected }',\n      { offset: token[2] },\n      { offset: token[2] + 1 }\n    )\n  }\n\n  unknownWord(tokens) {\n    throw this.input.error(\n      'Unknown word',\n      { offset: tokens[0][2] },\n      { offset: tokens[0][2] + tokens[0][1].length }\n    )\n  }\n\n  unnamedAtrule(node, token) {\n    throw this.input.error(\n      'At-rule without name',\n      { offset: token[2] },\n      { offset: token[2] + token[1].length }\n    )\n  }\n}\n\nmodule.exports = Parser\n","'use strict'\n\nlet AtRule = require('./at-rule')\nlet Comment = require('./comment')\nlet Container = require('./container')\nlet CssSyntaxError = require('./css-syntax-error')\nlet Declaration = require('./declaration')\nlet Document = require('./document')\nlet fromJSON = require('./fromJSON')\nlet Input = require('./input')\nlet LazyResult = require('./lazy-result')\nlet list = require('./list')\nlet Node = require('./node')\nlet parse = require('./parse')\nlet Processor = require('./processor')\nlet Result = require('./result.js')\nlet Root = require('./root')\nlet Rule = require('./rule')\nlet stringify = require('./stringify')\nlet Warning = require('./warning')\n\nfunction postcss(...plugins) {\n  if (plugins.length === 1 && Array.isArray(plugins[0])) {\n    plugins = plugins[0]\n  }\n  return new Processor(plugins)\n}\n\npostcss.plugin = function plugin(name, initializer) {\n  let warningPrinted = false\n  function creator(...args) {\n    // eslint-disable-next-line no-console\n    if (console && console.warn && !warningPrinted) {\n      warningPrinted = true\n      // eslint-disable-next-line no-console\n      console.warn(\n        name +\n          ': postcss.plugin was deprecated. Migration guide:\\n' +\n          'https://evilmartians.com/chronicles/postcss-8-plugin-migration'\n      )\n      if (process.env.LANG && process.env.LANG.startsWith('cn')) {\n        /* c8 ignore next 7 */\n        // eslint-disable-next-line no-console\n        console.warn(\n          name +\n            ': 里面 postcss.plugin 被弃用. 迁移指南:\\n' +\n            'https://www.w3ctech.com/topic/2226'\n        )\n      }\n    }\n    let transformer = initializer(...args)\n    transformer.postcssPlugin = name\n    transformer.postcssVersion = new Processor().version\n    return transformer\n  }\n\n  let cache\n  Object.defineProperty(creator, 'postcss', {\n    get() {\n      if (!cache) cache = creator()\n      return cache\n    }\n  })\n\n  creator.process = function (css, processOpts, pluginOpts) {\n    return postcss([creator(pluginOpts)]).process(css, processOpts)\n  }\n\n  return creator\n}\n\npostcss.stringify = stringify\npostcss.parse = parse\npostcss.fromJSON = fromJSON\npostcss.list = list\n\npostcss.comment = defaults => new Comment(defaults)\npostcss.atRule = defaults => new AtRule(defaults)\npostcss.decl = defaults => new Declaration(defaults)\npostcss.rule = defaults => new Rule(defaults)\npostcss.root = defaults => new Root(defaults)\npostcss.document = defaults => new Document(defaults)\n\npostcss.CssSyntaxError = CssSyntaxError\npostcss.Declaration = Declaration\npostcss.Container = Container\npostcss.Processor = Processor\npostcss.Document = Document\npostcss.Comment = Comment\npostcss.Warning = Warning\npostcss.AtRule = AtRule\npostcss.Result = Result\npostcss.Input = Input\npostcss.Rule = Rule\npostcss.Root = Root\npostcss.Node = Node\n\nLazyResult.registerPostcss(postcss)\n\nmodule.exports = postcss\npostcss.default = postcss\n","'use strict'\n\nlet { existsSync, readFileSync } = require('fs')\nlet { dirname, join } = require('path')\nlet { SourceMapConsumer, SourceMapGenerator } = require('source-map-js')\n\nfunction fromBase64(str) {\n  if (Buffer) {\n    return Buffer.from(str, 'base64').toString()\n  } else {\n    /* c8 ignore next 2 */\n    return window.atob(str)\n  }\n}\n\nclass PreviousMap {\n  constructor(css, opts) {\n    if (opts.map === false) return\n    this.loadAnnotation(css)\n    this.inline = this.startWith(this.annotation, 'data:')\n\n    let prev = opts.map ? opts.map.prev : undefined\n    let text = this.loadMap(opts.from, prev)\n    if (!this.mapFile && opts.from) {\n      this.mapFile = opts.from\n    }\n    if (this.mapFile) this.root = dirname(this.mapFile)\n    if (text) this.text = text\n  }\n\n  consumer() {\n    if (!this.consumerCache) {\n      this.consumerCache = new SourceMapConsumer(this.text)\n    }\n    return this.consumerCache\n  }\n\n  decodeInline(text) {\n    let baseCharsetUri = /^data:application\\/json;charset=utf-?8;base64,/\n    let baseUri = /^data:application\\/json;base64,/\n    let charsetUri = /^data:application\\/json;charset=utf-?8,/\n    let uri = /^data:application\\/json,/\n\n    let uriMatch = text.match(charsetUri) || text.match(uri)\n    if (uriMatch) {\n      return decodeURIComponent(text.substr(uriMatch[0].length))\n    }\n\n    let baseUriMatch = text.match(baseCharsetUri) || text.match(baseUri)\n    if (baseUriMatch) {\n      return fromBase64(text.substr(baseUriMatch[0].length))\n    }\n\n    let encoding = text.match(/data:application\\/json;([^,]+),/)[1]\n    throw new Error('Unsupported source map encoding ' + encoding)\n  }\n\n  getAnnotationURL(sourceMapString) {\n    return sourceMapString.replace(/^\\/\\*\\s*# sourceMappingURL=/, '').trim()\n  }\n\n  isMap(map) {\n    if (typeof map !== 'object') return false\n    return (\n      typeof map.mappings === 'string' ||\n      typeof map._mappings === 'string' ||\n      Array.isArray(map.sections)\n    )\n  }\n\n  loadAnnotation(css) {\n    let comments = css.match(/\\/\\*\\s*# sourceMappingURL=/g)\n    if (!comments) return\n\n    // sourceMappingURLs from comments, strings, etc.\n    let start = css.lastIndexOf(comments.pop())\n    let end = css.indexOf('*/', start)\n\n    if (start > -1 && end > -1) {\n      // Locate the last sourceMappingURL to avoid pickin\n      this.annotation = this.getAnnotationURL(css.substring(start, end))\n    }\n  }\n\n  loadFile(path) {\n    this.root = dirname(path)\n    if (existsSync(path)) {\n      this.mapFile = path\n      return readFileSync(path, 'utf-8').toString().trim()\n    }\n  }\n\n  loadMap(file, prev) {\n    if (prev === false) return false\n\n    if (prev) {\n      if (typeof prev === 'string') {\n        return prev\n      } else if (typeof prev === 'function') {\n        let prevPath = prev(file)\n        if (prevPath) {\n          let map = this.loadFile(prevPath)\n          if (!map) {\n            throw new Error(\n              'Unable to load previous source map: ' + prevPath.toString()\n            )\n          }\n          return map\n        }\n      } else if (prev instanceof SourceMapConsumer) {\n        return SourceMapGenerator.fromSourceMap(prev).toString()\n      } else if (prev instanceof SourceMapGenerator) {\n        return prev.toString()\n      } else if (this.isMap(prev)) {\n        return JSON.stringify(prev)\n      } else {\n        throw new Error(\n          'Unsupported previous source map format: ' + prev.toString()\n        )\n      }\n    } else if (this.inline) {\n      return this.decodeInline(this.annotation)\n    } else if (this.annotation) {\n      let map = this.annotation\n      if (file) map = join(dirname(file), map)\n      return this.loadFile(map)\n    }\n  }\n\n  startWith(string, start) {\n    if (!string) return false\n    return string.substr(0, start.length) === start\n  }\n\n  withContent() {\n    return !!(\n      this.consumer().sourcesContent &&\n      this.consumer().sourcesContent.length > 0\n    )\n  }\n}\n\nmodule.exports = PreviousMap\nPreviousMap.default = PreviousMap\n","'use strict'\n\nlet Document = require('./document')\nlet LazyResult = require('./lazy-result')\nlet NoWorkResult = require('./no-work-result')\nlet Root = require('./root')\n\nclass Processor {\n  constructor(plugins = []) {\n    this.version = '8.4.47'\n    this.plugins = this.normalize(plugins)\n  }\n\n  normalize(plugins) {\n    let normalized = []\n    for (let i of plugins) {\n      if (i.postcss === true) {\n        i = i()\n      } else if (i.postcss) {\n        i = i.postcss\n      }\n\n      if (typeof i === 'object' && Array.isArray(i.plugins)) {\n        normalized = normalized.concat(i.plugins)\n      } else if (typeof i === 'object' && i.postcssPlugin) {\n        normalized.push(i)\n      } else if (typeof i === 'function') {\n        normalized.push(i)\n      } else if (typeof i === 'object' && (i.parse || i.stringify)) {\n        if (process.env.NODE_ENV !== 'production') {\n          throw new Error(\n            'PostCSS syntaxes cannot be used as plugins. Instead, please use ' +\n              'one of the syntax/parser/stringifier options as outlined ' +\n              'in your PostCSS runner documentation.'\n          )\n        }\n      } else {\n        throw new Error(i + ' is not a PostCSS plugin')\n      }\n    }\n    return normalized\n  }\n\n  process(css, opts = {}) {\n    if (\n      !this.plugins.length &&\n      !opts.parser &&\n      !opts.stringifier &&\n      !opts.syntax\n    ) {\n      return new NoWorkResult(this, css, opts)\n    } else {\n      return new LazyResult(this, css, opts)\n    }\n  }\n\n  use(plugin) {\n    this.plugins = this.plugins.concat(this.normalize([plugin]))\n    return this\n  }\n}\n\nmodule.exports = Processor\nProcessor.default = Processor\n\nRoot.registerProcessor(Processor)\nDocument.registerProcessor(Processor)\n","'use strict'\n\nlet Warning = require('./warning')\n\nclass Result {\n  constructor(processor, root, opts) {\n    this.processor = processor\n    this.messages = []\n    this.root = root\n    this.opts = opts\n    this.css = undefined\n    this.map = undefined\n  }\n\n  toString() {\n    return this.css\n  }\n\n  warn(text, opts = {}) {\n    if (!opts.plugin) {\n      if (this.lastPlugin && this.lastPlugin.postcssPlugin) {\n        opts.plugin = this.lastPlugin.postcssPlugin\n      }\n    }\n\n    let warning = new Warning(text, opts)\n    this.messages.push(warning)\n\n    return warning\n  }\n\n  warnings() {\n    return this.messages.filter(i => i.type === 'warning')\n  }\n\n  get content() {\n    return this.css\n  }\n}\n\nmodule.exports = Result\nResult.default = Result\n","'use strict'\n\nlet Container = require('./container')\n\nlet LazyResult, Processor\n\nclass Root extends Container {\n  constructor(defaults) {\n    super(defaults)\n    this.type = 'root'\n    if (!this.nodes) this.nodes = []\n  }\n\n  normalize(child, sample, type) {\n    let nodes = super.normalize(child)\n\n    if (sample) {\n      if (type === 'prepend') {\n        if (this.nodes.length > 1) {\n          sample.raws.before = this.nodes[1].raws.before\n        } else {\n          delete sample.raws.before\n        }\n      } else if (this.first !== sample) {\n        for (let node of nodes) {\n          node.raws.before = sample.raws.before\n        }\n      }\n    }\n\n    return nodes\n  }\n\n  removeChild(child, ignore) {\n    let index = this.index(child)\n\n    if (!ignore && index === 0 && this.nodes.length > 1) {\n      this.nodes[1].raws.before = this.nodes[index].raws.before\n    }\n\n    return super.removeChild(child)\n  }\n\n  toResult(opts = {}) {\n    let lazy = new LazyResult(new Processor(), this, opts)\n    return lazy.stringify()\n  }\n}\n\nRoot.registerLazyResult = dependant => {\n  LazyResult = dependant\n}\n\nRoot.registerProcessor = dependant => {\n  Processor = dependant\n}\n\nmodule.exports = Root\nRoot.default = Root\n\nContainer.registerRoot(Root)\n","'use strict'\n\nlet Container = require('./container')\nlet list = require('./list')\n\nclass Rule extends Container {\n  constructor(defaults) {\n    super(defaults)\n    this.type = 'rule'\n    if (!this.nodes) this.nodes = []\n  }\n\n  get selectors() {\n    return list.comma(this.selector)\n  }\n\n  set selectors(values) {\n    let match = this.selector ? this.selector.match(/,\\s*/) : null\n    let sep = match ? match[0] : ',' + this.raw('between', 'beforeOpen')\n    this.selector = values.join(sep)\n  }\n}\n\nmodule.exports = Rule\nRule.default = Rule\n\nContainer.registerRule(Rule)\n","'use strict'\n\nconst DEFAULT_RAW = {\n  after: '\\n',\n  beforeClose: '\\n',\n  beforeComment: '\\n',\n  beforeDecl: '\\n',\n  beforeOpen: ' ',\n  beforeRule: '\\n',\n  colon: ': ',\n  commentLeft: ' ',\n  commentRight: ' ',\n  emptyBody: '',\n  indent: '    ',\n  semicolon: false\n}\n\nfunction capitalize(str) {\n  return str[0].toUpperCase() + str.slice(1)\n}\n\nclass Stringifier {\n  constructor(builder) {\n    this.builder = builder\n  }\n\n  atrule(node, semicolon) {\n    let name = '@' + node.name\n    let params = node.params ? this.rawValue(node, 'params') : ''\n\n    if (typeof node.raws.afterName !== 'undefined') {\n      name += node.raws.afterName\n    } else if (params) {\n      name += ' '\n    }\n\n    if (node.nodes) {\n      this.block(node, name + params)\n    } else {\n      let end = (node.raws.between || '') + (semicolon ? ';' : '')\n      this.builder(name + params + end, node)\n    }\n  }\n\n  beforeAfter(node, detect) {\n    let value\n    if (node.type === 'decl') {\n      value = this.raw(node, null, 'beforeDecl')\n    } else if (node.type === 'comment') {\n      value = this.raw(node, null, 'beforeComment')\n    } else if (detect === 'before') {\n      value = this.raw(node, null, 'beforeRule')\n    } else {\n      value = this.raw(node, null, 'beforeClose')\n    }\n\n    let buf = node.parent\n    let depth = 0\n    while (buf && buf.type !== 'root') {\n      depth += 1\n      buf = buf.parent\n    }\n\n    if (value.includes('\\n')) {\n      let indent = this.raw(node, null, 'indent')\n      if (indent.length) {\n        for (let step = 0; step < depth; step++) value += indent\n      }\n    }\n\n    return value\n  }\n\n  block(node, start) {\n    let between = this.raw(node, 'between', 'beforeOpen')\n    this.builder(start + between + '{', node, 'start')\n\n    let after\n    if (node.nodes && node.nodes.length) {\n      this.body(node)\n      after = this.raw(node, 'after')\n    } else {\n      after = this.raw(node, 'after', 'emptyBody')\n    }\n\n    if (after) this.builder(after)\n    this.builder('}', node, 'end')\n  }\n\n  body(node) {\n    let last = node.nodes.length - 1\n    while (last > 0) {\n      if (node.nodes[last].type !== 'comment') break\n      last -= 1\n    }\n\n    let semicolon = this.raw(node, 'semicolon')\n    for (let i = 0; i < node.nodes.length; i++) {\n      let child = node.nodes[i]\n      let before = this.raw(child, 'before')\n      if (before) this.builder(before)\n      this.stringify(child, last !== i || semicolon)\n    }\n  }\n\n  comment(node) {\n    let left = this.raw(node, 'left', 'commentLeft')\n    let right = this.raw(node, 'right', 'commentRight')\n    this.builder('/*' + left + node.text + right + '*/', node)\n  }\n\n  decl(node, semicolon) {\n    let between = this.raw(node, 'between', 'colon')\n    let string = node.prop + between + this.rawValue(node, 'value')\n\n    if (node.important) {\n      string += node.raws.important || ' !important'\n    }\n\n    if (semicolon) string += ';'\n    this.builder(string, node)\n  }\n\n  document(node) {\n    this.body(node)\n  }\n\n  raw(node, own, detect) {\n    let value\n    if (!detect) detect = own\n\n    // Already had\n    if (own) {\n      value = node.raws[own]\n      if (typeof value !== 'undefined') return value\n    }\n\n    let parent = node.parent\n\n    if (detect === 'before') {\n      // Hack for first rule in CSS\n      if (!parent || (parent.type === 'root' && parent.first === node)) {\n        return ''\n      }\n\n      // `root` nodes in `document` should use only their own raws\n      if (parent && parent.type === 'document') {\n        return ''\n      }\n    }\n\n    // Floating child without parent\n    if (!parent) return DEFAULT_RAW[detect]\n\n    // Detect style by other nodes\n    let root = node.root()\n    if (!root.rawCache) root.rawCache = {}\n    if (typeof root.rawCache[detect] !== 'undefined') {\n      return root.rawCache[detect]\n    }\n\n    if (detect === 'before' || detect === 'after') {\n      return this.beforeAfter(node, detect)\n    } else {\n      let method = 'raw' + capitalize(detect)\n      if (this[method]) {\n        value = this[method](root, node)\n      } else {\n        root.walk(i => {\n          value = i.raws[own]\n          if (typeof value !== 'undefined') return false\n        })\n      }\n    }\n\n    if (typeof value === 'undefined') value = DEFAULT_RAW[detect]\n\n    root.rawCache[detect] = value\n    return value\n  }\n\n  rawBeforeClose(root) {\n    let value\n    root.walk(i => {\n      if (i.nodes && i.nodes.length > 0) {\n        if (typeof i.raws.after !== 'undefined') {\n          value = i.raws.after\n          if (value.includes('\\n')) {\n            value = value.replace(/[^\\n]+$/, '')\n          }\n          return false\n        }\n      }\n    })\n    if (value) value = value.replace(/\\S/g, '')\n    return value\n  }\n\n  rawBeforeComment(root, node) {\n    let value\n    root.walkComments(i => {\n      if (typeof i.raws.before !== 'undefined') {\n        value = i.raws.before\n        if (value.includes('\\n')) {\n          value = value.replace(/[^\\n]+$/, '')\n        }\n        return false\n      }\n    })\n    if (typeof value === 'undefined') {\n      value = this.raw(node, null, 'beforeDecl')\n    } else if (value) {\n      value = value.replace(/\\S/g, '')\n    }\n    return value\n  }\n\n  rawBeforeDecl(root, node) {\n    let value\n    root.walkDecls(i => {\n      if (typeof i.raws.before !== 'undefined') {\n        value = i.raws.before\n        if (value.includes('\\n')) {\n          value = value.replace(/[^\\n]+$/, '')\n        }\n        return false\n      }\n    })\n    if (typeof value === 'undefined') {\n      value = this.raw(node, null, 'beforeRule')\n    } else if (value) {\n      value = value.replace(/\\S/g, '')\n    }\n    return value\n  }\n\n  rawBeforeOpen(root) {\n    let value\n    root.walk(i => {\n      if (i.type !== 'decl') {\n        value = i.raws.between\n        if (typeof value !== 'undefined') return false\n      }\n    })\n    return value\n  }\n\n  rawBeforeRule(root) {\n    let value\n    root.walk(i => {\n      if (i.nodes && (i.parent !== root || root.first !== i)) {\n        if (typeof i.raws.before !== 'undefined') {\n          value = i.raws.before\n          if (value.includes('\\n')) {\n            value = value.replace(/[^\\n]+$/, '')\n          }\n          return false\n        }\n      }\n    })\n    if (value) value = value.replace(/\\S/g, '')\n    return value\n  }\n\n  rawColon(root) {\n    let value\n    root.walkDecls(i => {\n      if (typeof i.raws.between !== 'undefined') {\n        value = i.raws.between.replace(/[^\\s:]/g, '')\n        return false\n      }\n    })\n    return value\n  }\n\n  rawEmptyBody(root) {\n    let value\n    root.walk(i => {\n      if (i.nodes && i.nodes.length === 0) {\n        value = i.raws.after\n        if (typeof value !== 'undefined') return false\n      }\n    })\n    return value\n  }\n\n  rawIndent(root) {\n    if (root.raws.indent) return root.raws.indent\n    let value\n    root.walk(i => {\n      let p = i.parent\n      if (p && p !== root && p.parent && p.parent === root) {\n        if (typeof i.raws.before !== 'undefined') {\n          let parts = i.raws.before.split('\\n')\n          value = parts[parts.length - 1]\n          value = value.replace(/\\S/g, '')\n          return false\n        }\n      }\n    })\n    return value\n  }\n\n  rawSemicolon(root) {\n    let value\n    root.walk(i => {\n      if (i.nodes && i.nodes.length && i.last.type === 'decl') {\n        value = i.raws.semicolon\n        if (typeof value !== 'undefined') return false\n      }\n    })\n    return value\n  }\n\n  rawValue(node, prop) {\n    let value = node[prop]\n    let raw = node.raws[prop]\n    if (raw && raw.value === value) {\n      return raw.raw\n    }\n\n    return value\n  }\n\n  root(node) {\n    this.body(node)\n    if (node.raws.after) this.builder(node.raws.after)\n  }\n\n  rule(node) {\n    this.block(node, this.rawValue(node, 'selector'))\n    if (node.raws.ownSemicolon) {\n      this.builder(node.raws.ownSemicolon, node, 'end')\n    }\n  }\n\n  stringify(node, semicolon) {\n    /* c8 ignore start */\n    if (!this[node.type]) {\n      throw new Error(\n        'Unknown AST node type ' +\n          node.type +\n          '. ' +\n          'Maybe you need to change PostCSS stringifier.'\n      )\n    }\n    /* c8 ignore stop */\n    this[node.type](node, semicolon)\n  }\n}\n\nmodule.exports = Stringifier\nStringifier.default = Stringifier\n","'use strict'\n\nlet Stringifier = require('./stringifier')\n\nfunction stringify(node, builder) {\n  let str = new Stringifier(builder)\n  str.stringify(node)\n}\n\nmodule.exports = stringify\nstringify.default = stringify\n","'use strict'\n\nmodule.exports.isClean = Symbol('isClean')\n\nmodule.exports.my = Symbol('my')\n","'use strict'\n\nconst SINGLE_QUOTE = \"'\".charCodeAt(0)\nconst DOUBLE_QUOTE = '\"'.charCodeAt(0)\nconst BACKSLASH = '\\\\'.charCodeAt(0)\nconst SLASH = '/'.charCodeAt(0)\nconst NEWLINE = '\\n'.charCodeAt(0)\nconst SPACE = ' '.charCodeAt(0)\nconst FEED = '\\f'.charCodeAt(0)\nconst TAB = '\\t'.charCodeAt(0)\nconst CR = '\\r'.charCodeAt(0)\nconst OPEN_SQUARE = '['.charCodeAt(0)\nconst CLOSE_SQUARE = ']'.charCodeAt(0)\nconst OPEN_PARENTHESES = '('.charCodeAt(0)\nconst CLOSE_PARENTHESES = ')'.charCodeAt(0)\nconst OPEN_CURLY = '{'.charCodeAt(0)\nconst CLOSE_CURLY = '}'.charCodeAt(0)\nconst SEMICOLON = ';'.charCodeAt(0)\nconst ASTERISK = '*'.charCodeAt(0)\nconst COLON = ':'.charCodeAt(0)\nconst AT = '@'.charCodeAt(0)\n\nconst RE_AT_END = /[\\t\\n\\f\\r \"#'()/;[\\\\\\]{}]/g\nconst RE_WORD_END = /[\\t\\n\\f\\r !\"#'():;@[\\\\\\]{}]|\\/(?=\\*)/g\nconst RE_BAD_BRACKET = /.[\\r\\n\"'(/\\\\]/\nconst RE_HEX_ESCAPE = /[\\da-f]/i\n\nmodule.exports = function tokenizer(input, options = {}) {\n  let css = input.css.valueOf()\n  let ignore = options.ignoreErrors\n\n  let code, content, escape, next, quote\n  let currentToken, escaped, escapePos, n, prev\n\n  let length = css.length\n  let pos = 0\n  let buffer = []\n  let returned = []\n\n  function position() {\n    return pos\n  }\n\n  function unclosed(what) {\n    throw input.error('Unclosed ' + what, pos)\n  }\n\n  function endOfFile() {\n    return returned.length === 0 && pos >= length\n  }\n\n  function nextToken(opts) {\n    if (returned.length) return returned.pop()\n    if (pos >= length) return\n\n    let ignoreUnclosed = opts ? opts.ignoreUnclosed : false\n\n    code = css.charCodeAt(pos)\n\n    switch (code) {\n      case NEWLINE:\n      case SPACE:\n      case TAB:\n      case CR:\n      case FEED: {\n        next = pos\n        do {\n          next += 1\n          code = css.charCodeAt(next)\n        } while (\n          code === SPACE ||\n          code === NEWLINE ||\n          code === TAB ||\n          code === CR ||\n          code === FEED\n        )\n\n        currentToken = ['space', css.slice(pos, next)]\n        pos = next - 1\n        break\n      }\n\n      case OPEN_SQUARE:\n      case CLOSE_SQUARE:\n      case OPEN_CURLY:\n      case CLOSE_CURLY:\n      case COLON:\n      case SEMICOLON:\n      case CLOSE_PARENTHESES: {\n        let controlChar = String.fromCharCode(code)\n        currentToken = [controlChar, controlChar, pos]\n        break\n      }\n\n      case OPEN_PARENTHESES: {\n        prev = buffer.length ? buffer.pop()[1] : ''\n        n = css.charCodeAt(pos + 1)\n        if (\n          prev === 'url' &&\n          n !== SINGLE_QUOTE &&\n          n !== DOUBLE_QUOTE &&\n          n !== SPACE &&\n          n !== NEWLINE &&\n          n !== TAB &&\n          n !== FEED &&\n          n !== CR\n        ) {\n          next = pos\n          do {\n            escaped = false\n            next = css.indexOf(')', next + 1)\n            if (next === -1) {\n              if (ignore || ignoreUnclosed) {\n                next = pos\n                break\n              } else {\n                unclosed('bracket')\n              }\n            }\n            escapePos = next\n            while (css.charCodeAt(escapePos - 1) === BACKSLASH) {\n              escapePos -= 1\n              escaped = !escaped\n            }\n          } while (escaped)\n\n          currentToken = ['brackets', css.slice(pos, next + 1), pos, next]\n\n          pos = next\n        } else {\n          next = css.indexOf(')', pos + 1)\n          content = css.slice(pos, next + 1)\n\n          if (next === -1 || RE_BAD_BRACKET.test(content)) {\n            currentToken = ['(', '(', pos]\n          } else {\n            currentToken = ['brackets', content, pos, next]\n            pos = next\n          }\n        }\n\n        break\n      }\n\n      case SINGLE_QUOTE:\n      case DOUBLE_QUOTE: {\n        quote = code === SINGLE_QUOTE ? \"'\" : '\"'\n        next = pos\n        do {\n          escaped = false\n          next = css.indexOf(quote, next + 1)\n          if (next === -1) {\n            if (ignore || ignoreUnclosed) {\n              next = pos + 1\n              break\n            } else {\n              unclosed('string')\n            }\n          }\n          escapePos = next\n          while (css.charCodeAt(escapePos - 1) === BACKSLASH) {\n            escapePos -= 1\n            escaped = !escaped\n          }\n        } while (escaped)\n\n        currentToken = ['string', css.slice(pos, next + 1), pos, next]\n        pos = next\n        break\n      }\n\n      case AT: {\n        RE_AT_END.lastIndex = pos + 1\n        RE_AT_END.test(css)\n        if (RE_AT_END.lastIndex === 0) {\n          next = css.length - 1\n        } else {\n          next = RE_AT_END.lastIndex - 2\n        }\n\n        currentToken = ['at-word', css.slice(pos, next + 1), pos, next]\n\n        pos = next\n        break\n      }\n\n      case BACKSLASH: {\n        next = pos\n        escape = true\n        while (css.charCodeAt(next + 1) === BACKSLASH) {\n          next += 1\n          escape = !escape\n        }\n        code = css.charCodeAt(next + 1)\n        if (\n          escape &&\n          code !== SLASH &&\n          code !== SPACE &&\n          code !== NEWLINE &&\n          code !== TAB &&\n          code !== CR &&\n          code !== FEED\n        ) {\n          next += 1\n          if (RE_HEX_ESCAPE.test(css.charAt(next))) {\n            while (RE_HEX_ESCAPE.test(css.charAt(next + 1))) {\n              next += 1\n            }\n            if (css.charCodeAt(next + 1) === SPACE) {\n              next += 1\n            }\n          }\n        }\n\n        currentToken = ['word', css.slice(pos, next + 1), pos, next]\n\n        pos = next\n        break\n      }\n\n      default: {\n        if (code === SLASH && css.charCodeAt(pos + 1) === ASTERISK) {\n          next = css.indexOf('*/', pos + 2) + 1\n          if (next === 0) {\n            if (ignore || ignoreUnclosed) {\n              next = css.length\n            } else {\n              unclosed('comment')\n            }\n          }\n\n          currentToken = ['comment', css.slice(pos, next + 1), pos, next]\n          pos = next\n        } else {\n          RE_WORD_END.lastIndex = pos + 1\n          RE_WORD_END.test(css)\n          if (RE_WORD_END.lastIndex === 0) {\n            next = css.length - 1\n          } else {\n            next = RE_WORD_END.lastIndex - 2\n          }\n\n          currentToken = ['word', css.slice(pos, next + 1), pos, next]\n          buffer.push(currentToken)\n          pos = next\n        }\n\n        break\n      }\n    }\n\n    pos++\n    return currentToken\n  }\n\n  function back(token) {\n    returned.push(token)\n  }\n\n  return {\n    back,\n    endOfFile,\n    nextToken,\n    position\n  }\n}\n","/* eslint-disable no-console */\n'use strict'\n\nlet printed = {}\n\nmodule.exports = function warnOnce(message) {\n  if (printed[message]) return\n  printed[message] = true\n\n  if (typeof console !== 'undefined' && console.warn) {\n    console.warn(message)\n  }\n}\n","'use strict'\n\nclass Warning {\n  constructor(text, opts = {}) {\n    this.type = 'warning'\n    this.text = text\n\n    if (opts.node && opts.node.source) {\n      let range = opts.node.rangeBy(opts)\n      this.line = range.start.line\n      this.column = range.start.column\n      this.endLine = range.end.line\n      this.endColumn = range.end.column\n    }\n\n    for (let opt in opts) this[opt] = opts[opt]\n  }\n\n  toString() {\n    if (this.node) {\n      return this.node.error(this.text, {\n        index: this.index,\n        plugin: this.plugin,\n        word: this.word\n      }).message\n    }\n\n    if (this.plugin) {\n      return this.plugin + ': ' + this.text\n    }\n\n    return this.text\n  }\n}\n\nmodule.exports = Warning\nWarning.default = Warning\n","/**\n * @license React\n * scheduler.production.min.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n'use strict';function f(a,b){var c=a.length;a.push(b);a:for(;0<c;){var d=c-1>>>1,e=a[d];if(0<g(e,b))a[d]=b,a[c]=e,c=d;else break a}}function h(a){return 0===a.length?null:a[0]}function k(a){if(0===a.length)return null;var b=a[0],c=a.pop();if(c!==b){a[0]=c;a:for(var d=0,e=a.length,w=e>>>1;d<w;){var m=2*(d+1)-1,C=a[m],n=m+1,x=a[n];if(0>g(C,c))n<e&&0>g(x,C)?(a[d]=x,a[n]=c,d=n):(a[d]=C,a[m]=c,d=m);else if(n<e&&0>g(x,c))a[d]=x,a[n]=c,d=n;else break a}}return b}\nfunction g(a,b){var c=a.sortIndex-b.sortIndex;return 0!==c?c:a.id-b.id}if(\"object\"===typeof performance&&\"function\"===typeof performance.now){var l=performance;exports.unstable_now=function(){return l.now()}}else{var p=Date,q=p.now();exports.unstable_now=function(){return p.now()-q}}var r=[],t=[],u=1,v=null,y=3,z=!1,A=!1,B=!1,D=\"function\"===typeof setTimeout?setTimeout:null,E=\"function\"===typeof clearTimeout?clearTimeout:null,F=\"undefined\"!==typeof setImmediate?setImmediate:null;\n\"undefined\"!==typeof navigator&&void 0!==navigator.scheduling&&void 0!==navigator.scheduling.isInputPending&&navigator.scheduling.isInputPending.bind(navigator.scheduling);function G(a){for(var b=h(t);null!==b;){if(null===b.callback)k(t);else if(b.startTime<=a)k(t),b.sortIndex=b.expirationTime,f(r,b);else break;b=h(t)}}function H(a){B=!1;G(a);if(!A)if(null!==h(r))A=!0,I(J);else{var b=h(t);null!==b&&K(H,b.startTime-a)}}\nfunction J(a,b){A=!1;B&&(B=!1,E(L),L=-1);z=!0;var c=y;try{G(b);for(v=h(r);null!==v&&(!(v.expirationTime>b)||a&&!M());){var d=v.callback;if(\"function\"===typeof d){v.callback=null;y=v.priorityLevel;var e=d(v.expirationTime<=b);b=exports.unstable_now();\"function\"===typeof e?v.callback=e:v===h(r)&&k(r);G(b)}else k(r);v=h(r)}if(null!==v)var w=!0;else{var m=h(t);null!==m&&K(H,m.startTime-b);w=!1}return w}finally{v=null,y=c,z=!1}}var N=!1,O=null,L=-1,P=5,Q=-1;\nfunction M(){return exports.unstable_now()-Q<P?!1:!0}function R(){if(null!==O){var a=exports.unstable_now();Q=a;var b=!0;try{b=O(!0,a)}finally{b?S():(N=!1,O=null)}}else N=!1}var S;if(\"function\"===typeof F)S=function(){F(R)};else if(\"undefined\"!==typeof MessageChannel){var T=new MessageChannel,U=T.port2;T.port1.onmessage=R;S=function(){U.postMessage(null)}}else S=function(){D(R,0)};function I(a){O=a;N||(N=!0,S())}function K(a,b){L=D(function(){a(exports.unstable_now())},b)}\nexports.unstable_IdlePriority=5;exports.unstable_ImmediatePriority=1;exports.unstable_LowPriority=4;exports.unstable_NormalPriority=3;exports.unstable_Profiling=null;exports.unstable_UserBlockingPriority=2;exports.unstable_cancelCallback=function(a){a.callback=null};exports.unstable_continueExecution=function(){A||z||(A=!0,I(J))};\nexports.unstable_forceFrameRate=function(a){0>a||125<a?console.error(\"forceFrameRate takes a positive int between 0 and 125, forcing frame rates higher than 125 fps is not supported\"):P=0<a?Math.floor(1E3/a):5};exports.unstable_getCurrentPriorityLevel=function(){return y};exports.unstable_getFirstCallbackNode=function(){return h(r)};exports.unstable_next=function(a){switch(y){case 1:case 2:case 3:var b=3;break;default:b=y}var c=y;y=b;try{return a()}finally{y=c}};exports.unstable_pauseExecution=function(){};\nexports.unstable_requestPaint=function(){};exports.unstable_runWithPriority=function(a,b){switch(a){case 1:case 2:case 3:case 4:case 5:break;default:a=3}var c=y;y=a;try{return b()}finally{y=c}};\nexports.unstable_scheduleCallback=function(a,b,c){var d=exports.unstable_now();\"object\"===typeof c&&null!==c?(c=c.delay,c=\"number\"===typeof c&&0<c?d+c:d):c=d;switch(a){case 1:var e=-1;break;case 2:e=250;break;case 5:e=1073741823;break;case 4:e=1E4;break;default:e=5E3}e=c+e;a={id:u++,callback:b,priorityLevel:a,startTime:c,expirationTime:e,sortIndex:-1};c>d?(a.sortIndex=c,f(t,a),null===h(r)&&a===h(t)&&(B?(E(L),L=-1):B=!0,K(H,c-d))):(a.sortIndex=e,f(r,a),A||z||(A=!0,I(J)));return a};\nexports.unstable_shouldYield=M;exports.unstable_wrapCallback=function(a){var b=y;return function(){var c=y;y=b;try{return a.apply(this,arguments)}finally{y=c}}};\n","'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('./cjs/scheduler.production.min.js');\n} else {\n  module.exports = require('./cjs/scheduler.development.js');\n}\n","var grammar = module.exports = {\n  v: [{\n    name: 'version',\n    reg: /^(\\d*)$/\n  }],\n  o: [{\n    // o=- 20518 0 IN IP4 203.0.113.1\n    // NB: sessionId will be a String in most cases because it is huge\n    name: 'origin',\n    reg: /^(\\S*) (\\d*) (\\d*) (\\S*) IP(\\d) (\\S*)/,\n    names: ['username', 'sessionId', 'sessionVersion', 'netType', 'ipVer', 'address'],\n    format: '%s %s %d %s IP%d %s'\n  }],\n  // default parsing of these only (though some of these feel outdated)\n  s: [{ name: 'name' }],\n  i: [{ name: 'description' }],\n  u: [{ name: 'uri' }],\n  e: [{ name: 'email' }],\n  p: [{ name: 'phone' }],\n  z: [{ name: 'timezones' }], // TODO: this one can actually be parsed properly...\n  r: [{ name: 'repeats' }],   // TODO: this one can also be parsed properly\n  // k: [{}], // outdated thing ignored\n  t: [{\n    // t=0 0\n    name: 'timing',\n    reg: /^(\\d*) (\\d*)/,\n    names: ['start', 'stop'],\n    format: '%d %d'\n  }],\n  c: [{\n    // c=IN IP4 10.47.197.26\n    name: 'connection',\n    reg: /^IN IP(\\d) (\\S*)/,\n    names: ['version', 'ip'],\n    format: 'IN IP%d %s'\n  }],\n  b: [{\n    // b=AS:4000\n    push: 'bandwidth',\n    reg: /^(TIAS|AS|CT|RR|RS):(\\d*)/,\n    names: ['type', 'limit'],\n    format: '%s:%s'\n  }],\n  m: [{\n    // m=video 51744 RTP/AVP 126 97 98 34 31\n    // NB: special - pushes to session\n    // TODO: rtp/fmtp should be filtered by the payloads found here?\n    reg: /^(\\w*) (\\d*) ([\\w/]*)(?: (.*))?/,\n    names: ['type', 'port', 'protocol', 'payloads'],\n    format: '%s %d %s %s'\n  }],\n  a: [\n    {\n      // a=rtpmap:110 opus/48000/2\n      push: 'rtp',\n      reg: /^rtpmap:(\\d*) ([\\w\\-.]*)(?:\\s*\\/(\\d*)(?:\\s*\\/(\\S*))?)?/,\n      names: ['payload', 'codec', 'rate', 'encoding'],\n      format: function (o) {\n        return (o.encoding)\n          ? 'rtpmap:%d %s/%s/%s'\n          : o.rate\n            ? 'rtpmap:%d %s/%s'\n            : 'rtpmap:%d %s';\n      }\n    },\n    {\n      // a=fmtp:108 profile-level-id=24;object=23;bitrate=64000\n      // a=fmtp:111 minptime=10; useinbandfec=1\n      push: 'fmtp',\n      reg: /^fmtp:(\\d*) ([\\S| ]*)/,\n      names: ['payload', 'config'],\n      format: 'fmtp:%d %s'\n    },\n    {\n      // a=control:streamid=0\n      name: 'control',\n      reg: /^control:(.*)/,\n      format: 'control:%s'\n    },\n    {\n      // a=rtcp:65179 IN IP4 193.84.77.194\n      name: 'rtcp',\n      reg: /^rtcp:(\\d*)(?: (\\S*) IP(\\d) (\\S*))?/,\n      names: ['port', 'netType', 'ipVer', 'address'],\n      format: function (o) {\n        return (o.address != null)\n          ? 'rtcp:%d %s IP%d %s'\n          : 'rtcp:%d';\n      }\n    },\n    {\n      // a=rtcp-fb:98 trr-int 100\n      push: 'rtcpFbTrrInt',\n      reg: /^rtcp-fb:(\\*|\\d*) trr-int (\\d*)/,\n      names: ['payload', 'value'],\n      format: 'rtcp-fb:%s trr-int %d'\n    },\n    {\n      // a=rtcp-fb:98 nack rpsi\n      push: 'rtcpFb',\n      reg: /^rtcp-fb:(\\*|\\d*) ([\\w-_]*)(?: ([\\w-_]*))?/,\n      names: ['payload', 'type', 'subtype'],\n      format: function (o) {\n        return (o.subtype != null)\n          ? 'rtcp-fb:%s %s %s'\n          : 'rtcp-fb:%s %s';\n      }\n    },\n    {\n      // a=extmap:2 urn:ietf:params:rtp-hdrext:toffset\n      // a=extmap:1/recvonly URI-gps-string\n      // a=extmap:3 urn:ietf:params:rtp-hdrext:encrypt urn:ietf:params:rtp-hdrext:smpte-tc 25@600/24\n      push: 'ext',\n      reg: /^extmap:(\\d+)(?:\\/(\\w+))?(?: (urn:ietf:params:rtp-hdrext:encrypt))? (\\S*)(?: (\\S*))?/,\n      names: ['value', 'direction', 'encrypt-uri', 'uri', 'config'],\n      format: function (o) {\n        return (\n          'extmap:%d' +\n          (o.direction ? '/%s' : '%v') +\n          (o['encrypt-uri'] ? ' %s' : '%v') +\n          ' %s' +\n          (o.config ? ' %s' : '')\n        );\n      }\n    },\n    {\n      // a=extmap-allow-mixed\n      name: 'extmapAllowMixed',\n      reg: /^(extmap-allow-mixed)/\n    },\n    {\n      // a=crypto:1 AES_CM_128_HMAC_SHA1_80 inline:PS1uQCVeeCFCanVmcjkpPywjNWhcYD0mXXtxaVBR|2^20|1:32\n      push: 'crypto',\n      reg: /^crypto:(\\d*) ([\\w_]*) (\\S*)(?: (\\S*))?/,\n      names: ['id', 'suite', 'config', 'sessionConfig'],\n      format: function (o) {\n        return (o.sessionConfig != null)\n          ? 'crypto:%d %s %s %s'\n          : 'crypto:%d %s %s';\n      }\n    },\n    {\n      // a=setup:actpass\n      name: 'setup',\n      reg: /^setup:(\\w*)/,\n      format: 'setup:%s'\n    },\n    {\n      // a=connection:new\n      name: 'connectionType',\n      reg: /^connection:(new|existing)/,\n      format: 'connection:%s'\n    },\n    {\n      // a=mid:1\n      name: 'mid',\n      reg: /^mid:([^\\s]*)/,\n      format: 'mid:%s'\n    },\n    {\n      // a=msid:0c8b064d-d807-43b4-b434-f92a889d8587 98178685-d409-46e0-8e16-7ef0db0db64a\n      name: 'msid',\n      reg: /^msid:(.*)/,\n      format: 'msid:%s'\n    },\n    {\n      // a=ptime:20\n      name: 'ptime',\n      reg: /^ptime:(\\d*(?:\\.\\d*)*)/,\n      format: 'ptime:%d'\n    },\n    {\n      // a=maxptime:60\n      name: 'maxptime',\n      reg: /^maxptime:(\\d*(?:\\.\\d*)*)/,\n      format: 'maxptime:%d'\n    },\n    {\n      // a=sendrecv\n      name: 'direction',\n      reg: /^(sendrecv|recvonly|sendonly|inactive)/\n    },\n    {\n      // a=ice-lite\n      name: 'icelite',\n      reg: /^(ice-lite)/\n    },\n    {\n      // a=ice-ufrag:F7gI\n      name: 'iceUfrag',\n      reg: /^ice-ufrag:(\\S*)/,\n      format: 'ice-ufrag:%s'\n    },\n    {\n      // a=ice-pwd:x9cml/YzichV2+XlhiMu8g\n      name: 'icePwd',\n      reg: /^ice-pwd:(\\S*)/,\n      format: 'ice-pwd:%s'\n    },\n    {\n      // a=fingerprint:SHA-1 00:11:22:33:44:55:66:77:88:99:AA:BB:CC:DD:EE:FF:00:11:22:33\n      name: 'fingerprint',\n      reg: /^fingerprint:(\\S*) (\\S*)/,\n      names: ['type', 'hash'],\n      format: 'fingerprint:%s %s'\n    },\n    {\n      // a=candidate:0 1 UDP 2113667327 203.0.113.1 54400 typ host\n      // a=candidate:1162875081 1 udp 2113937151 192.168.34.75 60017 typ host generation 0 network-id 3 network-cost 10\n      // a=candidate:3289912957 2 udp 1845501695 193.84.77.194 60017 typ srflx raddr 192.168.34.75 rport 60017 generation 0 network-id 3 network-cost 10\n      // a=candidate:229815620 1 tcp 1518280447 192.168.150.19 60017 typ host tcptype active generation 0 network-id 3 network-cost 10\n      // a=candidate:3289912957 2 tcp 1845501695 193.84.77.194 60017 typ srflx raddr 192.168.34.75 rport 60017 tcptype passive generation 0 network-id 3 network-cost 10\n      push:'candidates',\n      reg: /^candidate:(\\S*) (\\d*) (\\S*) (\\d*) (\\S*) (\\d*) typ (\\S*)(?: raddr (\\S*) rport (\\d*))?(?: tcptype (\\S*))?(?: generation (\\d*))?(?: network-id (\\d*))?(?: network-cost (\\d*))?/,\n      names: ['foundation', 'component', 'transport', 'priority', 'ip', 'port', 'type', 'raddr', 'rport', 'tcptype', 'generation', 'network-id', 'network-cost'],\n      format: function (o) {\n        var str = 'candidate:%s %d %s %d %s %d typ %s';\n\n        str += (o.raddr != null) ? ' raddr %s rport %d' : '%v%v';\n\n        // NB: candidate has three optional chunks, so %void middles one if it's missing\n        str += (o.tcptype != null) ? ' tcptype %s' : '%v';\n\n        if (o.generation != null) {\n          str += ' generation %d';\n        }\n\n        str += (o['network-id'] != null) ? ' network-id %d' : '%v';\n        str += (o['network-cost'] != null) ? ' network-cost %d' : '%v';\n        return str;\n      }\n    },\n    {\n      // a=end-of-candidates (keep after the candidates line for readability)\n      name: 'endOfCandidates',\n      reg: /^(end-of-candidates)/\n    },\n    {\n      // a=remote-candidates:1 203.0.113.1 54400 2 203.0.113.1 54401 ...\n      name: 'remoteCandidates',\n      reg: /^remote-candidates:(.*)/,\n      format: 'remote-candidates:%s'\n    },\n    {\n      // a=ice-options:google-ice\n      name: 'iceOptions',\n      reg: /^ice-options:(\\S*)/,\n      format: 'ice-options:%s'\n    },\n    {\n      // a=ssrc:2566107569 cname:t9YU8M1UxTF8Y1A1\n      push: 'ssrcs',\n      reg: /^ssrc:(\\d*) ([\\w_-]*)(?::(.*))?/,\n      names: ['id', 'attribute', 'value'],\n      format: function (o) {\n        var str = 'ssrc:%d';\n        if (o.attribute != null) {\n          str += ' %s';\n          if (o.value != null) {\n            str += ':%s';\n          }\n        }\n        return str;\n      }\n    },\n    {\n      // a=ssrc-group:FEC 1 2\n      // a=ssrc-group:FEC-FR 3004364195 1080772241\n      push: 'ssrcGroups',\n      // token-char = %x21 / %x23-27 / %x2A-2B / %x2D-2E / %x30-39 / %x41-5A / %x5E-7E\n      reg: /^ssrc-group:([\\x21\\x23\\x24\\x25\\x26\\x27\\x2A\\x2B\\x2D\\x2E\\w]*) (.*)/,\n      names: ['semantics', 'ssrcs'],\n      format: 'ssrc-group:%s %s'\n    },\n    {\n      // a=msid-semantic: WMS Jvlam5X3SX1OP6pn20zWogvaKJz5Hjf9OnlV\n      name: 'msidSemantic',\n      reg: /^msid-semantic:\\s?(\\w*) (\\S*)/,\n      names: ['semantic', 'token'],\n      format: 'msid-semantic: %s %s' // space after ':' is not accidental\n    },\n    {\n      // a=group:BUNDLE audio video\n      push: 'groups',\n      reg: /^group:(\\w*) (.*)/,\n      names: ['type', 'mids'],\n      format: 'group:%s %s'\n    },\n    {\n      // a=rtcp-mux\n      name: 'rtcpMux',\n      reg: /^(rtcp-mux)/\n    },\n    {\n      // a=rtcp-rsize\n      name: 'rtcpRsize',\n      reg: /^(rtcp-rsize)/\n    },\n    {\n      // a=sctpmap:5000 webrtc-datachannel 1024\n      name: 'sctpmap',\n      reg: /^sctpmap:([\\w_/]*) (\\S*)(?: (\\S*))?/,\n      names: ['sctpmapNumber', 'app', 'maxMessageSize'],\n      format: function (o) {\n        return (o.maxMessageSize != null)\n          ? 'sctpmap:%s %s %s'\n          : 'sctpmap:%s %s';\n      }\n    },\n    {\n      // a=x-google-flag:conference\n      name: 'xGoogleFlag',\n      reg: /^x-google-flag:([^\\s]*)/,\n      format: 'x-google-flag:%s'\n    },\n    {\n      // a=rid:1 send max-width=1280;max-height=720;max-fps=30;depend=0\n      push: 'rids',\n      reg: /^rid:([\\d\\w]+) (\\w+)(?: ([\\S| ]*))?/,\n      names: ['id', 'direction', 'params'],\n      format: function (o) {\n        return (o.params) ? 'rid:%s %s %s' : 'rid:%s %s';\n      }\n    },\n    {\n      // a=imageattr:97 send [x=800,y=640,sar=1.1,q=0.6] [x=480,y=320] recv [x=330,y=250]\n      // a=imageattr:* send [x=800,y=640] recv *\n      // a=imageattr:100 recv [x=320,y=240]\n      push: 'imageattrs',\n      reg: new RegExp(\n        // a=imageattr:97\n        '^imageattr:(\\\\d+|\\\\*)' +\n        // send [x=800,y=640,sar=1.1,q=0.6] [x=480,y=320]\n        '[\\\\s\\\\t]+(send|recv)[\\\\s\\\\t]+(\\\\*|\\\\[\\\\S+\\\\](?:[\\\\s\\\\t]+\\\\[\\\\S+\\\\])*)' +\n        // recv [x=330,y=250]\n        '(?:[\\\\s\\\\t]+(recv|send)[\\\\s\\\\t]+(\\\\*|\\\\[\\\\S+\\\\](?:[\\\\s\\\\t]+\\\\[\\\\S+\\\\])*))?'\n      ),\n      names: ['pt', 'dir1', 'attrs1', 'dir2', 'attrs2'],\n      format: function (o) {\n        return 'imageattr:%s %s %s' + (o.dir2 ? ' %s %s' : '');\n      }\n    },\n    {\n      // a=simulcast:send 1,2,3;~4,~5 recv 6;~7,~8\n      // a=simulcast:recv 1;4,5 send 6;7\n      name: 'simulcast',\n      reg: new RegExp(\n        // a=simulcast:\n        '^simulcast:' +\n        // send 1,2,3;~4,~5\n        '(send|recv) ([a-zA-Z0-9\\\\-_~;,]+)' +\n        // space + recv 6;~7,~8\n        '(?:\\\\s?(send|recv) ([a-zA-Z0-9\\\\-_~;,]+))?' +\n        // end\n        '$'\n      ),\n      names: ['dir1', 'list1', 'dir2', 'list2'],\n      format: function (o) {\n        return 'simulcast:%s %s' + (o.dir2 ? ' %s %s' : '');\n      }\n    },\n    {\n      // old simulcast draft 03 (implemented by Firefox)\n      //   https://tools.ietf.org/html/draft-ietf-mmusic-sdp-simulcast-03\n      // a=simulcast: recv pt=97;98 send pt=97\n      // a=simulcast: send rid=5;6;7 paused=6,7\n      name: 'simulcast_03',\n      reg: /^simulcast:[\\s\\t]+([\\S+\\s\\t]+)$/,\n      names: ['value'],\n      format: 'simulcast: %s'\n    },\n    {\n      // a=framerate:25\n      // a=framerate:29.97\n      name: 'framerate',\n      reg: /^framerate:(\\d+(?:$|\\.\\d+))/,\n      format: 'framerate:%s'\n    },\n    {\n      // RFC4570\n      // a=source-filter: incl IN IP4 239.5.2.31 10.1.15.5\n      name: 'sourceFilter',\n      reg: /^source-filter: *(excl|incl) (\\S*) (IP4|IP6|\\*) (\\S*) (.*)/,\n      names: ['filterMode', 'netType', 'addressTypes', 'destAddress', 'srcList'],\n      format: 'source-filter: %s %s %s %s %s'\n    },\n    {\n      // a=bundle-only\n      name: 'bundleOnly',\n      reg: /^(bundle-only)/\n    },\n    {\n      // a=label:1\n      name: 'label',\n      reg: /^label:(.+)/,\n      format: 'label:%s'\n    },\n    {\n      // RFC version 26 for SCTP over DTLS\n      // https://tools.ietf.org/html/draft-ietf-mmusic-sctp-sdp-26#section-5\n      name: 'sctpPort',\n      reg: /^sctp-port:(\\d+)$/,\n      format: 'sctp-port:%s'\n    },\n    {\n      // RFC version 26 for SCTP over DTLS\n      // https://tools.ietf.org/html/draft-ietf-mmusic-sctp-sdp-26#section-6\n      name: 'maxMessageSize',\n      reg: /^max-message-size:(\\d+)$/,\n      format: 'max-message-size:%s'\n    },\n    {\n      // RFC7273\n      // a=ts-refclk:ptp=IEEE1588-2008:39-A7-94-FF-FE-07-CB-D0:37\n      push:'tsRefClocks',\n      reg: /^ts-refclk:([^\\s=]*)(?:=(\\S*))?/,\n      names: ['clksrc', 'clksrcExt'],\n      format: function (o) {\n        return 'ts-refclk:%s' + (o.clksrcExt != null ? '=%s' : '');\n      }\n    },\n    {\n      // RFC7273\n      // a=mediaclk:direct=963214424\n      name:'mediaClk',\n      reg: /^mediaclk:(?:id=(\\S*))? *([^\\s=]*)(?:=(\\S*))?(?: *rate=(\\d+)\\/(\\d+))?/,\n      names: ['id', 'mediaClockName', 'mediaClockValue', 'rateNumerator', 'rateDenominator'],\n      format: function (o) {\n        var str = 'mediaclk:';\n        str += (o.id != null ? 'id=%s %s' : '%v%s');\n        str += (o.mediaClockValue != null ? '=%s' : '');\n        str += (o.rateNumerator != null ? ' rate=%s' : '');\n        str += (o.rateDenominator != null ? '/%s' : '');\n        return str;\n      }\n    },\n    {\n      // a=keywds:keywords\n      name: 'keywords',\n      reg: /^keywds:(.+)$/,\n      format: 'keywds:%s'\n    },\n    {\n      // a=content:main\n      name: 'content',\n      reg: /^content:(.+)/,\n      format: 'content:%s'\n    },\n    // BFCP https://tools.ietf.org/html/rfc4583\n    {\n      // a=floorctrl:c-s\n      name: 'bfcpFloorCtrl',\n      reg: /^floorctrl:(c-only|s-only|c-s)/,\n      format: 'floorctrl:%s'\n    },\n    {\n      // a=confid:1\n      name: 'bfcpConfId',\n      reg: /^confid:(\\d+)/,\n      format: 'confid:%s'\n    },\n    {\n      // a=userid:1\n      name: 'bfcpUserId',\n      reg: /^userid:(\\d+)/,\n      format: 'userid:%s'\n    },\n    {\n      // a=floorid:1\n      name: 'bfcpFloorId',\n      reg: /^floorid:(.+) (?:m-stream|mstrm):(.+)/,\n      names: ['id', 'mStream'],\n      format: 'floorid:%s mstrm:%s'\n    },\n    {\n      // any a= that we don't understand is kept verbatim on media.invalid\n      push: 'invalid',\n      names: ['value']\n    }\n  ]\n};\n\n// set sensible defaults to avoid polluting the grammar with boring details\nObject.keys(grammar).forEach(function (key) {\n  var objs = grammar[key];\n  objs.forEach(function (obj) {\n    if (!obj.reg) {\n      obj.reg = /(.*)/;\n    }\n    if (!obj.format) {\n      obj.format = '%s';\n    }\n  });\n});\n","var parser = require('./parser');\nvar writer = require('./writer');\n\nexports.write = writer;\nexports.parse = parser.parse;\nexports.parseParams = parser.parseParams;\nexports.parseFmtpConfig = parser.parseFmtpConfig; // Alias of parseParams().\nexports.parsePayloads = parser.parsePayloads;\nexports.parseRemoteCandidates = parser.parseRemoteCandidates;\nexports.parseImageAttributes = parser.parseImageAttributes;\nexports.parseSimulcastStreamList = parser.parseSimulcastStreamList;\n","var toIntIfInt = function (v) {\n  return String(Number(v)) === v ? Number(v) : v;\n};\n\nvar attachProperties = function (match, location, names, rawName) {\n  if (rawName && !names) {\n    location[rawName] = toIntIfInt(match[1]);\n  }\n  else {\n    for (var i = 0; i < names.length; i += 1) {\n      if (match[i+1] != null) {\n        location[names[i]] = toIntIfInt(match[i+1]);\n      }\n    }\n  }\n};\n\nvar parseReg = function (obj, location, content) {\n  var needsBlank = obj.name && obj.names;\n  if (obj.push && !location[obj.push]) {\n    location[obj.push] = [];\n  }\n  else if (needsBlank && !location[obj.name]) {\n    location[obj.name] = {};\n  }\n  var keyLocation = obj.push ?\n    {} :  // blank object that will be pushed\n    needsBlank ? location[obj.name] : location; // otherwise, named location or root\n\n  attachProperties(content.match(obj.reg), keyLocation, obj.names, obj.name);\n\n  if (obj.push) {\n    location[obj.push].push(keyLocation);\n  }\n};\n\nvar grammar = require('./grammar');\nvar validLine = RegExp.prototype.test.bind(/^([a-z])=(.*)/);\n\nexports.parse = function (sdp) {\n  var session = {}\n    , media = []\n    , location = session; // points at where properties go under (one of the above)\n\n  // parse lines we understand\n  sdp.split(/(\\r\\n|\\r|\\n)/).filter(validLine).forEach(function (l) {\n    var type = l[0];\n    var content = l.slice(2);\n    if (type === 'm') {\n      media.push({rtp: [], fmtp: []});\n      location = media[media.length-1]; // point at latest media line\n    }\n\n    for (var j = 0; j < (grammar[type] || []).length; j += 1) {\n      var obj = grammar[type][j];\n      if (obj.reg.test(content)) {\n        return parseReg(obj, location, content);\n      }\n    }\n  });\n\n  session.media = media; // link it up\n  return session;\n};\n\nvar paramReducer = function (acc, expr) {\n  var s = expr.split(/=(.+)/, 2);\n  if (s.length === 2) {\n    acc[s[0]] = toIntIfInt(s[1]);\n  } else if (s.length === 1 && expr.length > 1) {\n    acc[s[0]] = undefined;\n  }\n  return acc;\n};\n\nexports.parseParams = function (str) {\n  return str.split(/;\\s?/).reduce(paramReducer, {});\n};\n\n// For backward compatibility - alias will be removed in 3.0.0\nexports.parseFmtpConfig = exports.parseParams;\n\nexports.parsePayloads = function (str) {\n  return str.toString().split(' ').map(Number);\n};\n\nexports.parseRemoteCandidates = function (str) {\n  var candidates = [];\n  var parts = str.split(' ').map(toIntIfInt);\n  for (var i = 0; i < parts.length; i += 3) {\n    candidates.push({\n      component: parts[i],\n      ip: parts[i + 1],\n      port: parts[i + 2]\n    });\n  }\n  return candidates;\n};\n\nexports.parseImageAttributes = function (str) {\n  return str.split(' ').map(function (item) {\n    return item.substring(1, item.length-1).split(',').reduce(paramReducer, {});\n  });\n};\n\nexports.parseSimulcastStreamList = function (str) {\n  return str.split(';').map(function (stream) {\n    return stream.split(',').map(function (format) {\n      var scid, paused = false;\n\n      if (format[0] !== '~') {\n        scid = toIntIfInt(format);\n      } else {\n        scid = toIntIfInt(format.substring(1, format.length));\n        paused = true;\n      }\n\n      return {\n        scid: scid,\n        paused: paused\n      };\n    });\n  });\n};\n","var grammar = require('./grammar');\n\n// customized util.format - discards excess arguments and can void middle ones\nvar formatRegExp = /%[sdv%]/g;\nvar format = function (formatStr) {\n  var i = 1;\n  var args = arguments;\n  var len = args.length;\n  return formatStr.replace(formatRegExp, function (x) {\n    if (i >= len) {\n      return x; // missing argument\n    }\n    var arg = args[i];\n    i += 1;\n    switch (x) {\n    case '%%':\n      return '%';\n    case '%s':\n      return String(arg);\n    case '%d':\n      return Number(arg);\n    case '%v':\n      return '';\n    }\n  });\n  // NB: we discard excess arguments - they are typically undefined from makeLine\n};\n\nvar makeLine = function (type, obj, location) {\n  var str = obj.format instanceof Function ?\n    (obj.format(obj.push ? location : location[obj.name])) :\n    obj.format;\n\n  var args = [type + '=' + str];\n  if (obj.names) {\n    for (var i = 0; i < obj.names.length; i += 1) {\n      var n = obj.names[i];\n      if (obj.name) {\n        args.push(location[obj.name][n]);\n      }\n      else { // for mLine and push attributes\n        args.push(location[obj.names[i]]);\n      }\n    }\n  }\n  else {\n    args.push(location[obj.name]);\n  }\n  return format.apply(null, args);\n};\n\n// RFC specified order\n// TODO: extend this with all the rest\nvar defaultOuterOrder = [\n  'v', 'o', 's', 'i',\n  'u', 'e', 'p', 'c',\n  'b', 't', 'r', 'z', 'a'\n];\nvar defaultInnerOrder = ['i', 'c', 'b', 'a'];\n\n\nmodule.exports = function (session, opts) {\n  opts = opts || {};\n  // ensure certain properties exist\n  if (session.version == null) {\n    session.version = 0; // 'v=0' must be there (only defined version atm)\n  }\n  if (session.name == null) {\n    session.name = ' '; // 's= ' must be there if no meaningful name set\n  }\n  session.media.forEach(function (mLine) {\n    if (mLine.payloads == null) {\n      mLine.payloads = '';\n    }\n  });\n\n  var outerOrder = opts.outerOrder || defaultOuterOrder;\n  var innerOrder = opts.innerOrder || defaultInnerOrder;\n  var sdp = [];\n\n  // loop through outerOrder for matching properties on session\n  outerOrder.forEach(function (type) {\n    grammar[type].forEach(function (obj) {\n      if (obj.name in session && session[obj.name] != null) {\n        sdp.push(makeLine(type, obj, session));\n      }\n      else if (obj.push in session && session[obj.push] != null) {\n        session[obj.push].forEach(function (el) {\n          sdp.push(makeLine(type, obj, el));\n        });\n      }\n    });\n  });\n\n  // then for each media line, follow the innerOrder\n  session.media.forEach(function (mLine) {\n    sdp.push(makeLine('m', grammar.m[0], mLine));\n\n    innerOrder.forEach(function (type) {\n      grammar[type].forEach(function (obj) {\n        if (obj.name in mLine && mLine[obj.name] != null) {\n          sdp.push(makeLine(type, obj, mLine));\n        }\n        else if (obj.push in mLine && mLine[obj.push] != null) {\n          mLine[obj.push].forEach(function (el) {\n            sdp.push(makeLine(type, obj, el));\n          });\n        }\n      });\n    });\n  });\n\n  return sdp.join('\\r\\n') + '\\r\\n';\n};\n","'use strict';\n\nvar GetIntrinsic = require('get-intrinsic');\nvar define = require('define-data-property');\nvar hasDescriptors = require('has-property-descriptors')();\nvar gOPD = require('gopd');\n\nvar $TypeError = require('es-errors/type');\nvar $floor = GetIntrinsic('%Math.floor%');\n\n/** @type {import('.')} */\nmodule.exports = function setFunctionLength(fn, length) {\n\tif (typeof fn !== 'function') {\n\t\tthrow new $TypeError('`fn` is not a function');\n\t}\n\tif (typeof length !== 'number' || length < 0 || length > 0xFFFFFFFF || $floor(length) !== length) {\n\t\tthrow new $TypeError('`length` must be a positive 32-bit integer');\n\t}\n\n\tvar loose = arguments.length > 2 && !!arguments[2];\n\n\tvar functionLengthIsConfigurable = true;\n\tvar functionLengthIsWritable = true;\n\tif ('length' in fn && gOPD) {\n\t\tvar desc = gOPD(fn, 'length');\n\t\tif (desc && !desc.configurable) {\n\t\t\tfunctionLengthIsConfigurable = false;\n\t\t}\n\t\tif (desc && !desc.writable) {\n\t\t\tfunctionLengthIsWritable = false;\n\t\t}\n\t}\n\n\tif (functionLengthIsConfigurable || functionLengthIsWritable || !loose) {\n\t\tif (hasDescriptors) {\n\t\t\tdefine(/** @type {Parameters<define>[0]} */ (fn), 'length', length, true, true);\n\t\t} else {\n\t\t\tdefine(/** @type {Parameters<define>[0]} */ (fn), 'length', length);\n\t\t}\n\t}\n\treturn fn;\n};\n","/* global window, exports, define */\n\n!function() {\n    'use strict'\n\n    var re = {\n        not_string: /[^s]/,\n        not_bool: /[^t]/,\n        not_type: /[^T]/,\n        not_primitive: /[^v]/,\n        number: /[diefg]/,\n        numeric_arg: /[bcdiefguxX]/,\n        json: /[j]/,\n        not_json: /[^j]/,\n        text: /^[^\\x25]+/,\n        modulo: /^\\x25{2}/,\n        placeholder: /^\\x25(?:([1-9]\\d*)\\$|\\(([^)]+)\\))?(\\+)?(0|'[^$])?(-)?(\\d+)?(?:\\.(\\d+))?([b-gijostTuvxX])/,\n        key: /^([a-z_][a-z_\\d]*)/i,\n        key_access: /^\\.([a-z_][a-z_\\d]*)/i,\n        index_access: /^\\[(\\d+)\\]/,\n        sign: /^[+-]/\n    }\n\n    function sprintf(key) {\n        // `arguments` is not an array, but should be fine for this call\n        return sprintf_format(sprintf_parse(key), arguments)\n    }\n\n    function vsprintf(fmt, argv) {\n        return sprintf.apply(null, [fmt].concat(argv || []))\n    }\n\n    function sprintf_format(parse_tree, argv) {\n        var cursor = 1, tree_length = parse_tree.length, arg, output = '', i, k, ph, pad, pad_character, pad_length, is_positive, sign\n        for (i = 0; i < tree_length; i++) {\n            if (typeof parse_tree[i] === 'string') {\n                output += parse_tree[i]\n            }\n            else if (typeof parse_tree[i] === 'object') {\n                ph = parse_tree[i] // convenience purposes only\n                if (ph.keys) { // keyword argument\n                    arg = argv[cursor]\n                    for (k = 0; k < ph.keys.length; k++) {\n                        if (arg == undefined) {\n                            throw new Error(sprintf('[sprintf] Cannot access property \"%s\" of undefined value \"%s\"', ph.keys[k], ph.keys[k-1]))\n                        }\n                        arg = arg[ph.keys[k]]\n                    }\n                }\n                else if (ph.param_no) { // positional argument (explicit)\n                    arg = argv[ph.param_no]\n                }\n                else { // positional argument (implicit)\n                    arg = argv[cursor++]\n                }\n\n                if (re.not_type.test(ph.type) && re.not_primitive.test(ph.type) && arg instanceof Function) {\n                    arg = arg()\n                }\n\n                if (re.numeric_arg.test(ph.type) && (typeof arg !== 'number' && isNaN(arg))) {\n                    throw new TypeError(sprintf('[sprintf] expecting number but found %T', arg))\n                }\n\n                if (re.number.test(ph.type)) {\n                    is_positive = arg >= 0\n                }\n\n                switch (ph.type) {\n                    case 'b':\n                        arg = parseInt(arg, 10).toString(2)\n                        break\n                    case 'c':\n                        arg = String.fromCharCode(parseInt(arg, 10))\n                        break\n                    case 'd':\n                    case 'i':\n                        arg = parseInt(arg, 10)\n                        break\n                    case 'j':\n                        arg = JSON.stringify(arg, null, ph.width ? parseInt(ph.width) : 0)\n                        break\n                    case 'e':\n                        arg = ph.precision ? parseFloat(arg).toExponential(ph.precision) : parseFloat(arg).toExponential()\n                        break\n                    case 'f':\n                        arg = ph.precision ? parseFloat(arg).toFixed(ph.precision) : parseFloat(arg)\n                        break\n                    case 'g':\n                        arg = ph.precision ? String(Number(arg.toPrecision(ph.precision))) : parseFloat(arg)\n                        break\n                    case 'o':\n                        arg = (parseInt(arg, 10) >>> 0).toString(8)\n                        break\n                    case 's':\n                        arg = String(arg)\n                        arg = (ph.precision ? arg.substring(0, ph.precision) : arg)\n                        break\n                    case 't':\n                        arg = String(!!arg)\n                        arg = (ph.precision ? arg.substring(0, ph.precision) : arg)\n                        break\n                    case 'T':\n                        arg = Object.prototype.toString.call(arg).slice(8, -1).toLowerCase()\n                        arg = (ph.precision ? arg.substring(0, ph.precision) : arg)\n                        break\n                    case 'u':\n                        arg = parseInt(arg, 10) >>> 0\n                        break\n                    case 'v':\n                        arg = arg.valueOf()\n                        arg = (ph.precision ? arg.substring(0, ph.precision) : arg)\n                        break\n                    case 'x':\n                        arg = (parseInt(arg, 10) >>> 0).toString(16)\n                        break\n                    case 'X':\n                        arg = (parseInt(arg, 10) >>> 0).toString(16).toUpperCase()\n                        break\n                }\n                if (re.json.test(ph.type)) {\n                    output += arg\n                }\n                else {\n                    if (re.number.test(ph.type) && (!is_positive || ph.sign)) {\n                        sign = is_positive ? '+' : '-'\n                        arg = arg.toString().replace(re.sign, '')\n                    }\n                    else {\n                        sign = ''\n                    }\n                    pad_character = ph.pad_char ? ph.pad_char === '0' ? '0' : ph.pad_char.charAt(1) : ' '\n                    pad_length = ph.width - (sign + arg).length\n                    pad = ph.width ? (pad_length > 0 ? pad_character.repeat(pad_length) : '') : ''\n                    output += ph.align ? sign + arg + pad : (pad_character === '0' ? sign + pad + arg : pad + sign + arg)\n                }\n            }\n        }\n        return output\n    }\n\n    var sprintf_cache = Object.create(null)\n\n    function sprintf_parse(fmt) {\n        if (sprintf_cache[fmt]) {\n            return sprintf_cache[fmt]\n        }\n\n        var _fmt = fmt, match, parse_tree = [], arg_names = 0\n        while (_fmt) {\n            if ((match = re.text.exec(_fmt)) !== null) {\n                parse_tree.push(match[0])\n            }\n            else if ((match = re.modulo.exec(_fmt)) !== null) {\n                parse_tree.push('%')\n            }\n            else if ((match = re.placeholder.exec(_fmt)) !== null) {\n                if (match[2]) {\n                    arg_names |= 1\n                    var field_list = [], replacement_field = match[2], field_match = []\n                    if ((field_match = re.key.exec(replacement_field)) !== null) {\n                        field_list.push(field_match[1])\n                        while ((replacement_field = replacement_field.substring(field_match[0].length)) !== '') {\n                            if ((field_match = re.key_access.exec(replacement_field)) !== null) {\n                                field_list.push(field_match[1])\n                            }\n                            else if ((field_match = re.index_access.exec(replacement_field)) !== null) {\n                                field_list.push(field_match[1])\n                            }\n                            else {\n                                throw new SyntaxError('[sprintf] failed to parse named argument key')\n                            }\n                        }\n                    }\n                    else {\n                        throw new SyntaxError('[sprintf] failed to parse named argument key')\n                    }\n                    match[2] = field_list\n                }\n                else {\n                    arg_names |= 2\n                }\n                if (arg_names === 3) {\n                    throw new Error('[sprintf] mixing positional and named placeholders is not (yet) supported')\n                }\n\n                parse_tree.push(\n                    {\n                        placeholder: match[0],\n                        param_no:    match[1],\n                        keys:        match[2],\n                        sign:        match[3],\n                        pad_char:    match[4],\n                        align:       match[5],\n                        width:       match[6],\n                        precision:   match[7],\n                        type:        match[8]\n                    }\n                )\n            }\n            else {\n                throw new SyntaxError('[sprintf] unexpected placeholder')\n            }\n            _fmt = _fmt.substring(match[0].length)\n        }\n        return sprintf_cache[fmt] = parse_tree\n    }\n\n    /**\n     * export to either browser or node.js\n     */\n    /* eslint-disable quote-props */\n    if (typeof exports !== 'undefined') {\n        exports['sprintf'] = sprintf\n        exports['vsprintf'] = vsprintf\n    }\n    if (typeof window !== 'undefined') {\n        window['sprintf'] = sprintf\n        window['vsprintf'] = vsprintf\n\n        if (typeof define === 'function' && define['amd']) {\n            define(function() {\n                return {\n                    'sprintf': sprintf,\n                    'vsprintf': vsprintf\n                }\n            })\n        }\n    }\n    /* eslint-enable quote-props */\n}(); // eslint-disable-line\n","function clampProp(e, n, t, o, r) {\n  return clampEntity(n, getDefinedProp(e, n), t, o, r);\n}\n\nfunction clampEntity(e, n, t, o, r, i) {\n  const a = clampNumber(n, t, o);\n  if (r && n !== a) {\n    throw new RangeError(numberOutOfRange(e, n, t, o, i));\n  }\n  return a;\n}\n\nfunction getDefinedProp(e, n) {\n  const t = e[n];\n  if (void 0 === t) {\n    throw new TypeError(missingField(n));\n  }\n  return t;\n}\n\nfunction z(e) {\n  return null !== e && /object|function/.test(typeof e);\n}\n\nfunction Jn(e, n = Map) {\n  const t = new n;\n  return (n, ...o) => {\n    if (t.has(n)) {\n      return t.get(n);\n    }\n    const r = e(n, ...o);\n    return t.set(n, r), r;\n  };\n}\n\nfunction D(e) {\n  return p({\n    name: e\n  }, 1);\n}\n\nfunction p(e, n) {\n  return T((e => ({\n    value: e,\n    configurable: 1,\n    writable: !n\n  })), e);\n}\n\nfunction O(e) {\n  return T((e => ({\n    get: e,\n    configurable: 1\n  })), e);\n}\n\nfunction h(e) {\n  return {\n    [Symbol.toStringTag]: {\n      value: e,\n      configurable: 1\n    }\n  };\n}\n\nfunction zipProps(e, n) {\n  const t = {};\n  let o = e.length;\n  for (const r of n) {\n    t[e[--o]] = r;\n  }\n  return t;\n}\n\nfunction T(e, n, t) {\n  const o = {};\n  for (const r in n) {\n    o[r] = e(n[r], r, t);\n  }\n  return o;\n}\n\nfunction b(e, n, t) {\n  const o = {};\n  for (let r = 0; r < n.length; r++) {\n    const i = n[r];\n    o[i] = e(i, r, t);\n  }\n  return o;\n}\n\nfunction remapProps(e, n, t) {\n  const o = {};\n  for (let r = 0; r < e.length; r++) {\n    o[n[r]] = t[e[r]];\n  }\n  return o;\n}\n\nfunction Vn(e, n) {\n  const t = {};\n  for (const o of e) {\n    t[o] = n[o];\n  }\n  return t;\n}\n\nfunction V(e, n) {\n  const t = {};\n  for (const o in n) {\n    e.has(o) || (t[o] = n[o]);\n  }\n  return t;\n}\n\nfunction nn(e) {\n  e = {\n    ...e\n  };\n  const n = Object.keys(e);\n  for (const t of n) {\n    void 0 === e[t] && delete e[t];\n  }\n  return e;\n}\n\nfunction C(e, n) {\n  for (const t of n) {\n    if (!(t in e)) {\n      return 0;\n    }\n  }\n  return 1;\n}\n\nfunction allPropsEqual(e, n, t) {\n  for (const o of e) {\n    if (n[o] !== t[o]) {\n      return 0;\n    }\n  }\n  return 1;\n}\n\nfunction zeroOutProps(e, n, t) {\n  const o = {\n    ...t\n  };\n  for (let t = 0; t < n; t++) {\n    o[e[t]] = 0;\n  }\n  return o;\n}\n\nfunction E(e, ...n) {\n  return (...t) => e(...n, ...t);\n}\n\nfunction capitalize(e) {\n  return e[0].toUpperCase() + e.substring(1);\n}\n\nfunction sortStrings(e) {\n  return e.slice().sort();\n}\n\nfunction padNumber(e, n) {\n  return String(n).padStart(e, \"0\");\n}\n\nfunction compareNumbers(e, n) {\n  return Math.sign(e - n);\n}\n\nfunction clampNumber(e, n, t) {\n  return Math.min(Math.max(e, n), t);\n}\n\nfunction divModFloor(e, n) {\n  return [ Math.floor(e / n), modFloor(e, n) ];\n}\n\nfunction modFloor(e, n) {\n  return (e % n + n) % n;\n}\n\nfunction divModTrunc(e, n) {\n  return [ divTrunc(e, n), modTrunc(e, n) ];\n}\n\nfunction divTrunc(e, n) {\n  return Math.trunc(e / n) || 0;\n}\n\nfunction modTrunc(e, n) {\n  return e % n || 0;\n}\n\nfunction hasHalf(e) {\n  return .5 === Math.abs(e % 1);\n}\n\nfunction givenFieldsToBigNano(e, n, t) {\n  let o = 0, r = 0;\n  for (let i = 0; i <= n; i++) {\n    const n = e[t[i]], a = Xr[i], s = Qr / a, [c, u] = divModTrunc(n, s);\n    o += u * a, r += c;\n  }\n  const [i, a] = divModTrunc(o, Qr);\n  return [ r + i, a ];\n}\n\nfunction nanoToGivenFields(e, n, t) {\n  const o = {};\n  for (let r = n; r >= 0; r--) {\n    const n = Xr[r];\n    o[t[r]] = divTrunc(e, n), e = modTrunc(e, n);\n  }\n  return o;\n}\n\nfunction un(e) {\n  return e === X ? si : [];\n}\n\nfunction cn(e) {\n  return e === X ? li : [];\n}\n\nfunction ln(e) {\n  return e === X ? [ \"year\", \"day\" ] : [];\n}\n\nfunction l(e) {\n  if (void 0 !== e) {\n    return m(e);\n  }\n}\n\nfunction S(e) {\n  if (void 0 !== e) {\n    return d(e);\n  }\n}\n\nfunction c(e) {\n  if (void 0 !== e) {\n    return u(e);\n  }\n}\n\nfunction d(e) {\n  return requireNumberIsPositive(u(e));\n}\n\nfunction u(e) {\n  return requireNumberIsInteger(Mi(e));\n}\n\nfunction on(e) {\n  if (null == e) {\n    throw new TypeError(\"Cannot be null or undefined\");\n  }\n  return e;\n}\n\nfunction requirePropDefined(e, n) {\n  if (null == n) {\n    throw new RangeError(missingField(e));\n  }\n  return n;\n}\n\nfunction de(e) {\n  if (!z(e)) {\n    throw new TypeError(hr);\n  }\n  return e;\n}\n\nfunction requireType(e, n, t = e) {\n  if (typeof n !== e) {\n    throw new TypeError(invalidEntity(t, n));\n  }\n  return n;\n}\n\nfunction requireNumberIsInteger(e, n = \"number\") {\n  if (!Number.isInteger(e)) {\n    throw new RangeError(expectedInteger(n, e));\n  }\n  return e || 0;\n}\n\nfunction requireNumberIsPositive(e, n = \"number\") {\n  if (e <= 0) {\n    throw new RangeError(expectedPositive(n, e));\n  }\n  return e;\n}\n\nfunction toString(e) {\n  if (\"symbol\" == typeof e) {\n    throw new TypeError(pr);\n  }\n  return String(e);\n}\n\nfunction toStringViaPrimitive(e, n) {\n  return z(e) ? String(e) : m(e, n);\n}\n\nfunction toBigInt(e) {\n  if (\"string\" == typeof e) {\n    return BigInt(e);\n  }\n  if (\"bigint\" != typeof e) {\n    throw new TypeError(invalidBigInt(e));\n  }\n  return e;\n}\n\nfunction toNumber(e, n = \"number\") {\n  if (\"bigint\" == typeof e) {\n    throw new TypeError(forbiddenBigIntToNumber(n));\n  }\n  if (e = Number(e), !Number.isFinite(e)) {\n    throw new RangeError(expectedFinite(n, e));\n  }\n  return e;\n}\n\nfunction toInteger(e, n) {\n  return Math.trunc(toNumber(e, n)) || 0;\n}\n\nfunction toStrictInteger(e, n) {\n  return requireNumberIsInteger(toNumber(e, n), n);\n}\n\nfunction toPositiveInteger(e, n) {\n  return requireNumberIsPositive(toInteger(e, n), n);\n}\n\nfunction createBigNano(e, n) {\n  let [t, o] = divModTrunc(n, Qr), r = e + t;\n  const i = Math.sign(r);\n  return i && i === -Math.sign(o) && (r -= i, o += i * Qr), [ r, o ];\n}\n\nfunction addBigNanos(e, n, t = 1) {\n  return createBigNano(e[0] + n[0] * t, e[1] + n[1] * t);\n}\n\nfunction moveBigNano(e, n) {\n  return createBigNano(e[0], e[1] + n);\n}\n\nfunction re(e, n) {\n  return addBigNanos(n, e, -1);\n}\n\nfunction te(e, n) {\n  return compareNumbers(e[0], n[0]) || compareNumbers(e[1], n[1]);\n}\n\nfunction bigNanoOutside(e, n, t) {\n  return -1 === te(e, n) || 1 === te(e, t);\n}\n\nfunction bigIntToBigNano(e, n = 1) {\n  const t = BigInt(Qr / n);\n  return [ Number(e / t), Number(e % t) * n ];\n}\n\nfunction he(e, n = 1) {\n  const t = Qr / n, [o, r] = divModTrunc(e, t);\n  return [ o, r * n ];\n}\n\nfunction bigNanoToBigInt(e, n = 1) {\n  const [t, o] = e, r = Math.floor(o / n), i = Qr / n;\n  return BigInt(t) * BigInt(i) + BigInt(r);\n}\n\nfunction oe(e, n = 1, t) {\n  const [o, r] = e, [i, a] = divModTrunc(r, n);\n  return o * (Qr / n) + (i + (t ? a / n : 0));\n}\n\nfunction divModBigNano(e, n, t = divModFloor) {\n  const [o, r] = e, [i, a] = t(r, n);\n  return [ o * (Qr / n) + i, a ];\n}\n\nfunction hashIntlFormatParts(e, n) {\n  const t = e.formatToParts(n), o = {};\n  for (const e of t) {\n    o[e.type] = e.value;\n  }\n  return o;\n}\n\nfunction checkIsoYearMonthInBounds(e) {\n  return clampProp(e, \"isoYear\", Li, Ai, 1), e.isoYear === Li ? clampProp(e, \"isoMonth\", 4, 12, 1) : e.isoYear === Ai && clampProp(e, \"isoMonth\", 1, 9, 1), \n  e;\n}\n\nfunction checkIsoDateInBounds(e) {\n  return checkIsoDateTimeInBounds({\n    ...e,\n    ...Dt,\n    isoHour: 12\n  }), e;\n}\n\nfunction checkIsoDateTimeInBounds(e) {\n  const n = clampProp(e, \"isoYear\", Li, Ai, 1), t = n === Li ? 1 : n === Ai ? -1 : 0;\n  return t && checkEpochNanoInBounds(isoToEpochNano({\n    ...e,\n    isoDay: e.isoDay + t,\n    isoNanosecond: e.isoNanosecond - t\n  })), e;\n}\n\nfunction checkEpochNanoInBounds(e) {\n  if (!e || bigNanoOutside(e, Ui, qi)) {\n    throw new RangeError(Cr);\n  }\n  return e;\n}\n\nfunction isoTimeFieldsToNano(e) {\n  return givenFieldsToBigNano(e, 5, j)[1];\n}\n\nfunction nanoToIsoTimeAndDay(e) {\n  const [n, t] = divModFloor(e, Qr);\n  return [ nanoToGivenFields(t, 5, j), n ];\n}\n\nfunction epochNanoToSec(e) {\n  return epochNanoToSecMod(e)[0];\n}\n\nfunction epochNanoToSecMod(e) {\n  return divModBigNano(e, _r);\n}\n\nfunction isoToEpochMilli(e) {\n  return isoArgsToEpochMilli(e.isoYear, e.isoMonth, e.isoDay, e.isoHour, e.isoMinute, e.isoSecond, e.isoMillisecond);\n}\n\nfunction isoToEpochNano(e) {\n  const n = isoToEpochMilli(e);\n  if (void 0 !== n) {\n    const [t, o] = divModTrunc(n, Gr);\n    return [ t, o * be + (e.isoMicrosecond || 0) * Vr + (e.isoNanosecond || 0) ];\n  }\n}\n\nfunction isoToEpochNanoWithOffset(e, n) {\n  const [t, o] = nanoToIsoTimeAndDay(isoTimeFieldsToNano(e) - n);\n  return checkEpochNanoInBounds(isoToEpochNano({\n    ...e,\n    isoDay: e.isoDay + o,\n    ...t\n  }));\n}\n\nfunction isoArgsToEpochSec(...e) {\n  return isoArgsToEpochMilli(...e) / Hr;\n}\n\nfunction isoArgsToEpochMilli(...e) {\n  const [n, t] = isoToLegacyDate(...e), o = n.valueOf();\n  if (!isNaN(o)) {\n    return o - t * Gr;\n  }\n}\n\nfunction isoToLegacyDate(e, n = 1, t = 1, o = 0, r = 0, i = 0, a = 0) {\n  const s = e === Li ? 1 : e === Ai ? -1 : 0, c = new Date;\n  return c.setUTCHours(o, r, i, a), c.setUTCFullYear(e, n - 1, t + s), [ c, s ];\n}\n\nfunction Ie(e, n) {\n  let [t, o] = moveBigNano(e, n);\n  o < 0 && (o += Qr, t -= 1);\n  const [r, i] = divModFloor(o, be), [a, s] = divModFloor(i, Vr);\n  return epochMilliToIso(t * Gr + r, a, s);\n}\n\nfunction epochMilliToIso(e, n = 0, t = 0) {\n  const o = Math.ceil(Math.max(0, Math.abs(e) - zi) / Gr) * Math.sign(e), r = new Date(e - o * Gr);\n  return zipProps(wi, [ r.getUTCFullYear(), r.getUTCMonth() + 1, r.getUTCDate() + o, r.getUTCHours(), r.getUTCMinutes(), r.getUTCSeconds(), r.getUTCMilliseconds(), n, t ]);\n}\n\nfunction computeIsoDateParts(e) {\n  return [ e.isoYear, e.isoMonth, e.isoDay ];\n}\n\nfunction computeIsoMonthsInYear() {\n  return xi;\n}\n\nfunction computeIsoDaysInMonth(e, n) {\n  switch (n) {\n   case 2:\n    return computeIsoInLeapYear(e) ? 29 : 28;\n\n   case 4:\n   case 6:\n   case 9:\n   case 11:\n    return 30;\n  }\n  return 31;\n}\n\nfunction computeIsoDaysInYear(e) {\n  return computeIsoInLeapYear(e) ? 366 : 365;\n}\n\nfunction computeIsoInLeapYear(e) {\n  return e % 4 == 0 && (e % 100 != 0 || e % 400 == 0);\n}\n\nfunction computeIsoDayOfWeek(e) {\n  const [n, t] = isoToLegacyDate(e.isoYear, e.isoMonth, e.isoDay);\n  return modFloor(n.getUTCDay() - t, 7) || 7;\n}\n\nfunction computeGregoryEraParts({isoYear: e}) {\n  return e < 1 ? [ \"bce\", 1 - e ] : [ \"ce\", e ];\n}\n\nfunction computeJapaneseEraParts(e) {\n  const n = isoToEpochMilli(e);\n  if (n < $i) {\n    return computeGregoryEraParts(e);\n  }\n  const t = hashIntlFormatParts(La(Ti), n), {era: o, eraYear: r} = parseIntlYear(t, Ti);\n  return [ o, r ];\n}\n\nfunction checkIsoDateTimeFields(e) {\n  return checkIsoDateFields(e), constrainIsoTimeFields(e, 1), e;\n}\n\nfunction checkIsoDateFields(e) {\n  return constrainIsoDateFields(e, 1), e;\n}\n\nfunction isIsoDateFieldsValid(e) {\n  return allPropsEqual(Oi, e, constrainIsoDateFields(e));\n}\n\nfunction constrainIsoDateFields(e, n) {\n  const {isoYear: t} = e, o = clampProp(e, \"isoMonth\", 1, computeIsoMonthsInYear(), n);\n  return {\n    isoYear: t,\n    isoMonth: o,\n    isoDay: clampProp(e, \"isoDay\", 1, computeIsoDaysInMonth(t, o), n)\n  };\n}\n\nfunction constrainIsoTimeFields(e, n) {\n  return zipProps(j, [ clampProp(e, \"isoHour\", 0, 23, n), clampProp(e, \"isoMinute\", 0, 59, n), clampProp(e, \"isoSecond\", 0, 59, n), clampProp(e, \"isoMillisecond\", 0, 999, n), clampProp(e, \"isoMicrosecond\", 0, 999, n), clampProp(e, \"isoNanosecond\", 0, 999, n) ]);\n}\n\nfunction H(e) {\n  return void 0 === e ? 0 : ua(de(e));\n}\n\nfunction wn(e, n = 0) {\n  e = normalizeOptions(e);\n  const t = la(e), o = fa(e, n);\n  return [ ua(e), o, t ];\n}\n\nfunction ve(e) {\n  return la(normalizeOptions(e));\n}\n\nfunction _t(e) {\n  return e = normalizeOptions(e), sa(e, 9, 6, 1);\n}\n\nfunction refineDiffOptions(e, n, t, o = 9, r = 0, i = 4) {\n  n = normalizeOptions(n);\n  let a = sa(n, o, r), s = parseRoundingIncInteger(n), c = ha(n, i);\n  const u = aa(n, o, r, 1);\n  return null == a ? a = Math.max(t, u) : checkLargestSmallestUnit(a, u), s = refineRoundingInc(s, u, 1), \n  e && (c = (e => e < 4 ? (e + 2) % 4 : e)(c)), [ a, u, s, c ];\n}\n\nfunction refineRoundingOptions(e, n = 6, t) {\n  let o = parseRoundingIncInteger(e = normalizeOptionsOrString(e, Hi));\n  const r = ha(e, 7);\n  let i = aa(e, n);\n  return i = requirePropDefined(Hi, i), o = refineRoundingInc(o, i, void 0, t), [ i, o, r ];\n}\n\nfunction refineDateDisplayOptions(e) {\n  return da(normalizeOptions(e));\n}\n\nfunction refineTimeDisplayOptions(e, n) {\n  return refineTimeDisplayTuple(normalizeOptions(e), n);\n}\n\nfunction refineTimeDisplayTuple(e, n = 4) {\n  const t = refineSubsecDigits(e);\n  return [ ha(e, 4), ...refineSmallestUnitAndSubsecDigits(aa(e, n), t) ];\n}\n\nfunction refineSmallestUnitAndSubsecDigits(e, n) {\n  return null != e ? [ Xr[e], e < 4 ? 9 - 3 * e : -1 ] : [ void 0 === n ? 1 : 10 ** (9 - n), n ];\n}\n\nfunction parseRoundingIncInteger(e) {\n  const n = e[_i];\n  return void 0 === n ? 1 : toInteger(n, _i);\n}\n\nfunction refineRoundingInc(e, n, t, o) {\n  const r = o ? Qr : Xr[n + 1];\n  if (r) {\n    const t = Xr[n];\n    if (r % ((e = clampEntity(_i, e, 1, r / t - (o ? 0 : 1), 1)) * t)) {\n      throw new RangeError(invalidEntity(_i, e));\n    }\n  } else {\n    e = clampEntity(_i, e, 1, t ? 10 ** 9 : 1, 1);\n  }\n  return e;\n}\n\nfunction refineSubsecDigits(e) {\n  let n = e[Ji];\n  if (void 0 !== n) {\n    if (\"number\" != typeof n) {\n      if (\"auto\" === toString(n)) {\n        return;\n      }\n      throw new RangeError(invalidEntity(Ji, n));\n    }\n    n = clampEntity(Ji, Math.floor(n), 0, 9, 1);\n  }\n  return n;\n}\n\nfunction normalizeOptions(e) {\n  return void 0 === e ? {} : de(e);\n}\n\nfunction normalizeOptionsOrString(e, n) {\n  return \"string\" == typeof e ? {\n    [n]: e\n  } : de(e);\n}\n\nfunction U(e) {\n  if (void 0 !== e) {\n    if (z(e)) {\n      return Object.assign(Object.create(null), e);\n    }\n    throw new TypeError(hr);\n  }\n}\n\nfunction overrideOverflowOptions(e, n) {\n  return e && Object.assign(Object.create(null), e, {\n    overflow: Xi[n]\n  });\n}\n\nfunction refineUnitOption(e, n, t = 9, o = 0, r) {\n  let i = n[e];\n  if (void 0 === i) {\n    return r ? o : void 0;\n  }\n  if (i = toString(i), \"auto\" === i) {\n    return r ? o : null;\n  }\n  let a = $r[i];\n  if (void 0 === a && (a = Ei[i]), void 0 === a) {\n    throw new RangeError(invalidChoice(e, i, $r));\n  }\n  return clampEntity(e, a, o, t, 1, Et), a;\n}\n\nfunction refineChoiceOption(e, n, t, o = 0) {\n  const r = t[e];\n  if (void 0 === r) {\n    return o;\n  }\n  const i = toString(r), a = n[i];\n  if (void 0 === a) {\n    throw new RangeError(invalidChoice(e, i, n));\n  }\n  return a;\n}\n\nfunction checkLargestSmallestUnit(e, n) {\n  if (n > e) {\n    throw new RangeError(Ar);\n  }\n}\n\nfunction _(e) {\n  return {\n    branding: Oe,\n    epochNanoseconds: e\n  };\n}\n\nfunction Yn(e, n, t) {\n  return {\n    branding: Te,\n    calendar: t,\n    timeZone: n,\n    epochNanoseconds: e\n  };\n}\n\nfunction ee(e, n = e.calendar) {\n  return {\n    branding: We,\n    calendar: n,\n    ...Vn(Yi, e)\n  };\n}\n\nfunction v(e, n = e.calendar) {\n  return {\n    branding: J,\n    calendar: n,\n    ...Vn(Bi, e)\n  };\n}\n\nfunction createPlainYearMonthSlots(e, n = e.calendar) {\n  return {\n    branding: L,\n    calendar: n,\n    ...Vn(Bi, e)\n  };\n}\n\nfunction createPlainMonthDaySlots(e, n = e.calendar) {\n  return {\n    branding: q,\n    calendar: n,\n    ...Vn(Bi, e)\n  };\n}\n\nfunction Ge(e) {\n  return {\n    branding: xe,\n    ...Vn(ki, e)\n  };\n}\n\nfunction Vt(e) {\n  return {\n    branding: qt,\n    sign: computeDurationSign(e),\n    ...Vn(Ni, e)\n  };\n}\n\nfunction M(e) {\n  return epochNanoToSec(e.epochNanoseconds);\n}\n\nfunction y(e) {\n  return divModBigNano(e.epochNanoseconds, be)[0];\n}\n\nfunction N(e) {\n  return bigNanoToBigInt(e.epochNanoseconds, Vr);\n}\n\nfunction B(e) {\n  return bigNanoToBigInt(e.epochNanoseconds);\n}\n\nfunction extractEpochNano(e) {\n  return e.epochNanoseconds;\n}\n\nfunction I(e) {\n  return \"string\" == typeof e ? e : m(e.id);\n}\n\nfunction isIdLikeEqual(e, n) {\n  return e === n || I(e) === I(n);\n}\n\nfunction Ut(e, n, t, o, r) {\n  const i = getMaxDurationUnit(o), [a, s] = ((e, n) => {\n    const t = n((e = normalizeOptionsOrString(e, Vi))[Ki]);\n    let o = ca(e);\n    return o = requirePropDefined(Vi, o), [ o, t ];\n  })(r, e);\n  if (isUniformUnit(Math.max(a, i), s)) {\n    return totalDayTimeDuration(o, a);\n  }\n  if (!s) {\n    throw new RangeError(zr);\n  }\n  const [c, u, l] = createMarkerSystem(n, t, s), f = createMarkerToEpochNano(l), d = createMoveMarker(l), m = createDiffMarkers(l), p = d(u, c, o), h = m(u, c, p, a);\n  return isUniformUnit(a, s) ? totalDayTimeDuration(h, a) : ((e, n, t, o, r, i, a) => {\n    const s = computeDurationSign(e), [c, u] = clampRelativeDuration(o, bi(t, e), t, s, r, i, a), l = computeEpochNanoFrac(n, c, u);\n    return e[F[t]] + l * s;\n  })(h, f(p), a, u, c, f, d);\n}\n\nfunction totalDayTimeDuration(e, n) {\n  return oe(durationFieldsToBigNano(e), Xr[n], 1);\n}\n\nfunction clampRelativeDuration(e, n, t, o, r, i, a) {\n  const s = F[t], c = {\n    ...n,\n    [s]: n[s] + o\n  }, u = a(e, r, n), l = a(e, r, c);\n  return [ i(u), i(l) ];\n}\n\nfunction computeEpochNanoFrac(e, n, t) {\n  const o = oe(re(n, t));\n  if (!o) {\n    throw new RangeError(vr);\n  }\n  return oe(re(n, e)) / o;\n}\n\nfunction ce(e, n) {\n  const [t, o, r] = refineRoundingOptions(n, 5, 1);\n  return _(roundBigNano(e.epochNanoseconds, t, o, r, 1));\n}\n\nfunction Pn(e, n, t) {\n  let {epochNanoseconds: o, timeZone: r, calendar: i} = n;\n  const [a, s, c] = refineRoundingOptions(t);\n  if (0 === a && 1 === s) {\n    return n;\n  }\n  const u = e(r);\n  if (6 === a) {\n    o = ((e, n, t, o) => {\n      const r = fn(t, n), [i, a] = e(r), s = t.epochNanoseconds, c = we(n, i), u = we(n, a);\n      if (bigNanoOutside(s, c, u)) {\n        throw new RangeError(vr);\n      }\n      return roundWithMode(computeEpochNanoFrac(s, c, u), o) ? u : c;\n    })(computeDayInterval, u, n, c);\n  } else {\n    const e = u.getOffsetNanosecondsFor(o);\n    o = getMatchingInstantFor(u, roundDateTime(Ie(o, e), a, s, c), e, 2, 0, 1);\n  }\n  return Yn(o, r, i);\n}\n\nfunction dt(e, n) {\n  return ee(roundDateTime(e, ...refineRoundingOptions(n)), e.calendar);\n}\n\nfunction Ee(e, n) {\n  const [t, o, r] = refineRoundingOptions(n, 5);\n  var i;\n  return Ge((i = r, roundTimeToNano(e, computeNanoInc(t, o), i)[0]));\n}\n\nfunction dn(e, n) {\n  const t = e(n.timeZone), o = fn(n, t), [r, i] = computeDayInterval(o), a = oe(re(we(t, r), we(t, i)), Kr, 1);\n  if (a <= 0) {\n    throw new RangeError(vr);\n  }\n  return a;\n}\n\nfunction Cn(e, n) {\n  const {timeZone: t, calendar: o} = n, r = ((e, n, t) => we(n, e(fn(t, n))))(computeDayFloor, e(t), n);\n  return Yn(r, t, o);\n}\n\nfunction roundDateTime(e, n, t, o) {\n  return roundDateTimeToNano(e, computeNanoInc(n, t), o);\n}\n\nfunction roundDateTimeToNano(e, n, t) {\n  const [o, r] = roundTimeToNano(e, n, t);\n  return checkIsoDateTimeInBounds({\n    ...moveByDays(e, r),\n    ...o\n  });\n}\n\nfunction roundTimeToNano(e, n, t) {\n  return nanoToIsoTimeAndDay(roundByInc(isoTimeFieldsToNano(e), n, t));\n}\n\nfunction roundToMinute(e) {\n  return roundByInc(e, Jr, 7);\n}\n\nfunction computeNanoInc(e, n) {\n  return Xr[e] * n;\n}\n\nfunction computeDayInterval(e) {\n  const n = computeDayFloor(e);\n  return [ n, moveByDays(n, 1) ];\n}\n\nfunction computeDayFloor(e) {\n  return Ci(6, e);\n}\n\nfunction roundDayTimeDurationByInc(e, n, t) {\n  const o = Math.min(getMaxDurationUnit(e), 6);\n  return nanoToDurationDayTimeFields(roundBigNanoByInc(durationFieldsToBigNano(e, o), n, t), o);\n}\n\nfunction roundRelativeDuration(e, n, t, o, r, i, a, s, c, u) {\n  if (0 === o && 1 === r) {\n    return e;\n  }\n  const l = isUniformUnit(o, s) ? isZonedEpochSlots(s) && o < 6 && t >= 6 ? nudgeZonedTimeDuration : nudgeDayTimeDuration : nudgeRelativeDuration;\n  let [f, d, m] = l(e, n, t, o, r, i, a, s, c, u);\n  return m && 7 !== o && (f = ((e, n, t, o, r, i, a, s) => {\n    const c = computeDurationSign(e);\n    for (let u = o + 1; u <= t; u++) {\n      if (7 === u && 7 !== t) {\n        continue;\n      }\n      const o = bi(u, e);\n      o[F[u]] += c;\n      const l = oe(re(a(s(r, i, o)), n));\n      if (l && Math.sign(l) !== c) {\n        break;\n      }\n      e = o;\n    }\n    return e;\n  })(f, d, t, Math.max(6, o), a, s, c, u)), f;\n}\n\nfunction roundBigNano(e, n, t, o, r) {\n  if (6 === n) {\n    const n = (e => e[0] + e[1] / Qr)(e);\n    return [ roundByInc(n, t, o), 0 ];\n  }\n  return roundBigNanoByInc(e, computeNanoInc(n, t), o, r);\n}\n\nfunction roundBigNanoByInc(e, n, t, o) {\n  let [r, i] = e;\n  o && i < 0 && (i += Qr, r -= 1);\n  const [a, s] = divModFloor(roundByInc(i, n, t), Qr);\n  return createBigNano(r + a, s);\n}\n\nfunction roundByInc(e, n, t) {\n  return roundWithMode(e / n, t) * n;\n}\n\nfunction roundWithMode(e, n) {\n  return ga[n](e);\n}\n\nfunction nudgeDayTimeDuration(e, n, t, o, r, i) {\n  const a = computeDurationSign(e), s = durationFieldsToBigNano(e), c = roundBigNano(s, o, r, i), u = re(s, c), l = Math.sign(c[0] - s[0]) === a, f = nanoToDurationDayTimeFields(c, Math.min(t, 6));\n  return [ {\n    ...e,\n    ...f\n  }, addBigNanos(n, u), l ];\n}\n\nfunction nudgeZonedTimeDuration(e, n, t, o, r, i, a, s, c, u) {\n  const l = computeDurationSign(e), f = oe(durationFieldsToBigNano(e, 5)), d = computeNanoInc(o, r);\n  let m = roundByInc(f, d, i);\n  const [p, h] = clampRelativeDuration(a, {\n    ...e,\n    ...Fi\n  }, 6, l, s, c, u), g = m - oe(re(p, h));\n  let T = 0;\n  g && Math.sign(g) !== l ? n = moveBigNano(p, m) : (T += l, m = roundByInc(g, d, i), \n  n = moveBigNano(h, m));\n  const D = nanoToDurationTimeFields(m);\n  return [ {\n    ...e,\n    ...D,\n    days: e.days + T\n  }, n, Boolean(T) ];\n}\n\nfunction nudgeRelativeDuration(e, n, t, o, r, i, a, s, c, u) {\n  const l = computeDurationSign(e), f = F[o], d = bi(o, e);\n  7 === o && (e = {\n    ...e,\n    weeks: e.weeks + Math.trunc(e.days / 7)\n  });\n  const m = divTrunc(e[f], r) * r;\n  d[f] = m;\n  const [p, h] = clampRelativeDuration(a, d, o, r * l, s, c, u), g = m + computeEpochNanoFrac(n, p, h) * l * r, T = roundByInc(g, r, i), D = Math.sign(T - g) === l;\n  return d[f] = T, [ d, D ? h : p, D ];\n}\n\nfunction me(e, n, t, o) {\n  const [r, i, a, s] = (e => {\n    const n = refineTimeDisplayTuple(e = normalizeOptions(e));\n    return [ e.timeZone, ...n ];\n  })(o), c = void 0 !== r;\n  return ((e, n, t, o, r, i) => {\n    t = roundBigNanoByInc(t, r, o, 1);\n    const a = n.getOffsetNanosecondsFor(t);\n    return formatIsoDateTimeFields(Ie(t, a), i) + (e ? Fe(roundToMinute(a)) : \"Z\");\n  })(c, n(c ? e(r) : Ta), t.epochNanoseconds, i, a, s);\n}\n\nfunction In(e, n, t) {\n  const [o, r, i, a, s, c] = (e => {\n    e = normalizeOptions(e);\n    const n = da(e), t = refineSubsecDigits(e), o = pa(e), r = ha(e, 4), i = aa(e, 4);\n    return [ n, ma(e), o, r, ...refineSmallestUnitAndSubsecDigits(i, t) ];\n  })(t);\n  return ((e, n, t, o, r, i, a, s, c, u) => {\n    o = roundBigNanoByInc(o, c, s, 1);\n    const l = e(t).getOffsetNanosecondsFor(o);\n    return formatIsoDateTimeFields(Ie(o, l), u) + Fe(roundToMinute(l), a) + ((e, n) => 1 !== n ? \"[\" + (2 === n ? \"!\" : \"\") + I(e) + \"]\" : \"\")(t, i) + formatCalendar(n, r);\n  })(e, n.calendar, n.timeZone, n.epochNanoseconds, o, r, i, a, s, c);\n}\n\nfunction Tt(e, n) {\n  const [t, o, r, i] = (e => (e = normalizeOptions(e), [ da(e), ...refineTimeDisplayTuple(e) ]))(n);\n  return a = e.calendar, s = t, c = i, formatIsoDateTimeFields(roundDateTimeToNano(e, r, o), c) + formatCalendar(a, s);\n  var a, s, c;\n}\n\nfunction yt(e, n) {\n  return t = e.calendar, o = e, r = refineDateDisplayOptions(n), formatIsoDateFields(o) + formatCalendar(t, r);\n  var t, o, r;\n}\n\nfunction et(e, n) {\n  return formatDateLikeIso(e.calendar, formatIsoYearMonthFields, e, refineDateDisplayOptions(n));\n}\n\nfunction W(e, n) {\n  return formatDateLikeIso(e.calendar, formatIsoMonthDayFields, e, refineDateDisplayOptions(n));\n}\n\nfunction qe(e, n) {\n  const [t, o, r] = refineTimeDisplayOptions(n);\n  return i = r, formatIsoTimeFields(roundTimeToNano(e, o, t)[0], i);\n  var i;\n}\n\nfunction zt(e, n) {\n  const [t, o, r] = refineTimeDisplayOptions(n, 3);\n  return o > 1 && (e = {\n    ...e,\n    ...roundDayTimeDurationByInc(e, o, t)\n  }), ((e, n) => {\n    const {sign: t} = e, o = -1 === t ? negateDurationFields(e) : e, {hours: r, minutes: i} = o, [a, s] = divModBigNano(durationFieldsToBigNano(o, 3), _r, divModTrunc);\n    checkDurationTimeUnit(a);\n    const c = formatSubsecNano(s, n), u = n >= 0 || !t || c;\n    return (t < 0 ? \"-\" : \"\") + \"P\" + formatDurationFragments({\n      Y: formatDurationNumber(o.years),\n      M: formatDurationNumber(o.months),\n      W: formatDurationNumber(o.weeks),\n      D: formatDurationNumber(o.days)\n    }) + (r || i || a || u ? \"T\" + formatDurationFragments({\n      H: formatDurationNumber(r),\n      M: formatDurationNumber(i),\n      S: formatDurationNumber(a, u) + c\n    }) : \"\");\n  })(e, r);\n}\n\nfunction formatDateLikeIso(e, n, t, o) {\n  const r = I(e), i = o > 1 || 0 === o && r !== X;\n  return 1 === o ? r === X ? n(t) : formatIsoDateFields(t) : i ? formatIsoDateFields(t) + formatCalendarId(r, 2 === o) : n(t);\n}\n\nfunction formatDurationFragments(e) {\n  const n = [];\n  for (const t in e) {\n    const o = e[t];\n    o && n.push(o, t);\n  }\n  return n.join(\"\");\n}\n\nfunction formatIsoDateTimeFields(e, n) {\n  return formatIsoDateFields(e) + \"T\" + formatIsoTimeFields(e, n);\n}\n\nfunction formatIsoDateFields(e) {\n  return formatIsoYearMonthFields(e) + \"-\" + xr(e.isoDay);\n}\n\nfunction formatIsoYearMonthFields(e) {\n  const {isoYear: n} = e;\n  return (n < 0 || n > 9999 ? getSignStr(n) + padNumber(6, Math.abs(n)) : padNumber(4, n)) + \"-\" + xr(e.isoMonth);\n}\n\nfunction formatIsoMonthDayFields(e) {\n  return xr(e.isoMonth) + \"-\" + xr(e.isoDay);\n}\n\nfunction formatIsoTimeFields(e, n) {\n  const t = [ xr(e.isoHour), xr(e.isoMinute) ];\n  return -1 !== n && t.push(xr(e.isoSecond) + ((e, n, t, o) => formatSubsecNano(e * be + n * Vr + t, o))(e.isoMillisecond, e.isoMicrosecond, e.isoNanosecond, n)), \n  t.join(\":\");\n}\n\nfunction Fe(e, n = 0) {\n  if (1 === n) {\n    return \"\";\n  }\n  const [t, o] = divModFloor(Math.abs(e), Kr), [r, i] = divModFloor(o, Jr), [a, s] = divModFloor(i, _r);\n  return getSignStr(e) + xr(t) + \":\" + xr(r) + (a || s ? \":\" + xr(a) + formatSubsecNano(s) : \"\");\n}\n\nfunction formatCalendar(e, n) {\n  if (1 !== n) {\n    const t = I(e);\n    if (n > 1 || 0 === n && t !== X) {\n      return formatCalendarId(t, 2 === n);\n    }\n  }\n  return \"\";\n}\n\nfunction formatCalendarId(e, n) {\n  return \"[\" + (n ? \"!\" : \"\") + \"u-ca=\" + e + \"]\";\n}\n\nfunction formatSubsecNano(e, n) {\n  let t = padNumber(9, e);\n  return t = void 0 === n ? t.replace(Na, \"\") : t.slice(0, n), t ? \".\" + t : \"\";\n}\n\nfunction getSignStr(e) {\n  return e < 0 ? \"-\" : \"+\";\n}\n\nfunction formatDurationNumber(e, n) {\n  return e || n ? e.toLocaleString(\"fullwide\", {\n    useGrouping: 0\n  }) : \"\";\n}\n\nfunction _zonedEpochSlotsToIso(e, n) {\n  const {epochNanoseconds: t} = e, o = (n.getOffsetNanosecondsFor ? n : n(e.timeZone)).getOffsetNanosecondsFor(t), r = Ie(t, o);\n  return {\n    calendar: e.calendar,\n    ...r,\n    offsetNanoseconds: o\n  };\n}\n\nfunction mn(e, n) {\n  const t = fn(n, e);\n  return {\n    calendar: n.calendar,\n    ...Vn(Yi, t),\n    offset: Fe(t.offsetNanoseconds),\n    timeZone: n.timeZone\n  };\n}\n\nfunction getMatchingInstantFor(e, n, t, o = 0, r = 0, i, a) {\n  if (void 0 !== t && 1 === o && (1 === o || a)) {\n    return isoToEpochNanoWithOffset(n, t);\n  }\n  const s = e.getPossibleInstantsFor(n);\n  if (void 0 !== t && 3 !== o) {\n    const e = ((e, n, t, o) => {\n      const r = isoToEpochNano(n);\n      o && (t = roundToMinute(t));\n      for (const n of e) {\n        let e = oe(re(n, r));\n        if (o && (e = roundToMinute(e)), e === t) {\n          return n;\n        }\n      }\n    })(s, n, t, i);\n    if (void 0 !== e) {\n      return e;\n    }\n    if (0 === o) {\n      throw new RangeError(kr);\n    }\n  }\n  return a ? isoToEpochNano(n) : we(e, n, r, s);\n}\n\nfunction we(e, n, t = 0, o = e.getPossibleInstantsFor(n)) {\n  if (1 === o.length) {\n    return o[0];\n  }\n  if (1 === t) {\n    throw new RangeError(Yr);\n  }\n  if (o.length) {\n    return o[3 === t ? 1 : 0];\n  }\n  const r = isoToEpochNano(n), i = ((e, n) => {\n    const t = e.getOffsetNanosecondsFor(moveBigNano(n, -Qr));\n    return ne(e.getOffsetNanosecondsFor(moveBigNano(n, Qr)) - t);\n  })(e, r), a = i * (2 === t ? -1 : 1);\n  return (o = e.getPossibleInstantsFor(Ie(r, a)))[2 === t ? 0 : o.length - 1];\n}\n\nfunction ae(e) {\n  if (Math.abs(e) >= Qr) {\n    throw new RangeError(wr);\n  }\n  return e;\n}\n\nfunction ne(e) {\n  if (e > Qr) {\n    throw new RangeError(Br);\n  }\n  return e;\n}\n\nfunction se(e, n, t) {\n  return _(checkEpochNanoInBounds(addBigNanos(n.epochNanoseconds, (e => {\n    if (durationHasDateParts(e)) {\n      throw new RangeError(qr);\n    }\n    return durationFieldsToBigNano(e, 5);\n  })(e ? negateDurationFields(t) : t))));\n}\n\nfunction hn(e, n, t, o, r, i = Object.create(null)) {\n  const a = n(o.timeZone), s = e(o.calendar);\n  return {\n    ...o,\n    ...moveZonedEpochs(a, s, o, t ? negateDurationFields(r) : r, i)\n  };\n}\n\nfunction ct(e, n, t, o, r = Object.create(null)) {\n  const {calendar: i} = t;\n  return ee(moveDateTime(e(i), t, n ? negateDurationFields(o) : o, r), i);\n}\n\nfunction bt(e, n, t, o, r) {\n  const {calendar: i} = t;\n  return v(moveDate(e(i), t, n ? negateDurationFields(o) : o, r), i);\n}\n\nfunction Qe(e, n, t, o, r = Object.create(null)) {\n  const i = t.calendar, a = e(i);\n  let s = moveToDayOfMonthUnsafe(a, t);\n  n && (o = xt(o)), o.sign < 0 && (s = a.dateAdd(s, {\n    ...Si,\n    months: 1\n  }), s = moveByDays(s, -1));\n  const c = a.dateAdd(s, o, r);\n  return createPlainYearMonthSlots(moveToDayOfMonthUnsafe(a, c), i);\n}\n\nfunction Ye(e, n, t) {\n  return Ge(moveTime(n, e ? negateDurationFields(t) : t)[0]);\n}\n\nfunction moveZonedEpochs(e, n, t, o, r) {\n  const i = durationFieldsToBigNano(o, 5);\n  let a = t.epochNanoseconds;\n  if (durationHasDateParts(o)) {\n    const s = fn(t, e);\n    a = addBigNanos(we(e, {\n      ...moveDate(n, s, {\n        ...o,\n        ...Fi\n      }, r),\n      ...Vn(j, s)\n    }), i);\n  } else {\n    a = addBigNanos(a, i), H(r);\n  }\n  return {\n    epochNanoseconds: checkEpochNanoInBounds(a)\n  };\n}\n\nfunction moveDateTime(e, n, t, o) {\n  const [r, i] = moveTime(n, t);\n  return checkIsoDateTimeInBounds({\n    ...moveDate(e, n, {\n      ...t,\n      ...Fi,\n      days: t.days + i\n    }, o),\n    ...r\n  });\n}\n\nfunction moveDate(e, n, t, o) {\n  if (t.years || t.months || t.weeks) {\n    return e.dateAdd(n, t, o);\n  }\n  H(o);\n  const r = t.days + durationFieldsToBigNano(t, 5)[0];\n  return r ? checkIsoDateInBounds(moveByDays(n, r)) : n;\n}\n\nfunction moveToDayOfMonthUnsafe(e, n, t = 1) {\n  return moveByDays(n, t - e.day(n));\n}\n\nfunction moveTime(e, n) {\n  const [t, o] = durationFieldsToBigNano(n, 5), [r, i] = nanoToIsoTimeAndDay(isoTimeFieldsToNano(e) + o);\n  return [ r, t + i ];\n}\n\nfunction moveByDays(e, n) {\n  return n ? {\n    ...e,\n    ...epochMilliToIso(isoToEpochMilli(e) + n * Gr)\n  } : e;\n}\n\nfunction createMarkerSystem(e, n, t) {\n  const o = e(t.calendar);\n  return isZonedEpochSlots(t) ? [ t, o, n(t.timeZone) ] : [ {\n    ...t,\n    ...Dt\n  }, o ];\n}\n\nfunction createMarkerToEpochNano(e) {\n  return e ? extractEpochNano : isoToEpochNano;\n}\n\nfunction createMoveMarker(e) {\n  return e ? E(moveZonedEpochs, e) : moveDateTime;\n}\n\nfunction createDiffMarkers(e) {\n  return e ? E(diffZonedEpochsExact, e) : diffDateTimesExact;\n}\n\nfunction isZonedEpochSlots(e) {\n  return e && e.epochNanoseconds;\n}\n\nfunction isUniformUnit(e, n) {\n  return e <= 6 - (isZonedEpochSlots(n) ? 1 : 0);\n}\n\nfunction Wt(e, n, t, o, r, i, a) {\n  const s = e(normalizeOptions(a).relativeTo), c = Math.max(getMaxDurationUnit(r), getMaxDurationUnit(i));\n  if (isUniformUnit(c, s)) {\n    return Vt(checkDurationUnits(((e, n, t, o) => {\n      const r = addBigNanos(durationFieldsToBigNano(e), durationFieldsToBigNano(n), o ? -1 : 1);\n      if (!Number.isFinite(r[0])) {\n        throw new RangeError(Cr);\n      }\n      return {\n        ...Si,\n        ...nanoToDurationDayTimeFields(r, t)\n      };\n    })(r, i, c, o)));\n  }\n  if (!s) {\n    throw new RangeError(zr);\n  }\n  o && (i = negateDurationFields(i));\n  const [u, l, f] = createMarkerSystem(n, t, s), d = createMoveMarker(f), m = createDiffMarkers(f), p = d(l, u, r);\n  return Vt(m(l, u, d(l, p, i), c));\n}\n\nfunction Gt(e, n, t, o, r) {\n  const i = getMaxDurationUnit(o), [a, s, c, u, l] = ((e, n, t) => {\n    e = normalizeOptionsOrString(e, Hi);\n    let o = sa(e);\n    const r = t(e[Ki]);\n    let i = parseRoundingIncInteger(e);\n    const a = ha(e, 7);\n    let s = aa(e);\n    if (void 0 === o && void 0 === s) {\n      throw new RangeError(Ur);\n    }\n    return null == s && (s = 0), null == o && (o = Math.max(s, n)), checkLargestSmallestUnit(o, s), \n    i = refineRoundingInc(i, s, 1), [ o, s, i, a, r ];\n  })(r, i, e), f = Math.max(i, a);\n  if (!isZonedEpochSlots(l) && f <= 6) {\n    return Vt(checkDurationUnits(((e, n, t, o, r) => {\n      const i = roundBigNano(durationFieldsToBigNano(e), t, o, r);\n      return {\n        ...Si,\n        ...nanoToDurationDayTimeFields(i, n)\n      };\n    })(o, a, s, c, u)));\n  }\n  if (!l) {\n    throw new RangeError(zr);\n  }\n  const [d, m, p] = createMarkerSystem(n, t, l), h = createMarkerToEpochNano(p), g = createMoveMarker(p), T = createDiffMarkers(p), D = g(m, d, o);\n  let I = T(m, d, D, a);\n  const M = o.sign, N = computeDurationSign(I);\n  if (M && N && M !== N) {\n    throw new RangeError(vr);\n  }\n  return N && (I = roundRelativeDuration(I, h(D), a, s, c, u, m, d, h, g)), Vt(I);\n}\n\nfunction Rt(e) {\n  return -1 === e.sign ? xt(e) : e;\n}\n\nfunction xt(e) {\n  return Vt(negateDurationFields(e));\n}\n\nfunction negateDurationFields(e) {\n  const n = {};\n  for (const t of F) {\n    n[t] = -1 * e[t] || 0;\n  }\n  return n;\n}\n\nfunction Jt(e) {\n  return !e.sign;\n}\n\nfunction computeDurationSign(e, n = F) {\n  let t = 0;\n  for (const o of n) {\n    const n = Math.sign(e[o]);\n    if (n) {\n      if (t && t !== n) {\n        throw new RangeError(Rr);\n      }\n      t = n;\n    }\n  }\n  return t;\n}\n\nfunction checkDurationUnits(e) {\n  for (const n of vi) {\n    clampEntity(n, e[n], -ya, ya, 1);\n  }\n  return checkDurationTimeUnit(oe(durationFieldsToBigNano(e), _r)), e;\n}\n\nfunction checkDurationTimeUnit(e) {\n  if (!Number.isSafeInteger(e)) {\n    throw new RangeError(Zr);\n  }\n}\n\nfunction durationFieldsToBigNano(e, n = 6) {\n  return givenFieldsToBigNano(e, n, F);\n}\n\nfunction nanoToDurationDayTimeFields(e, n = 6) {\n  const [t, o] = e, r = nanoToGivenFields(o, n, F);\n  if (r[F[n]] += t * (Qr / Xr[n]), !Number.isFinite(r[F[n]])) {\n    throw new RangeError(Cr);\n  }\n  return r;\n}\n\nfunction nanoToDurationTimeFields(e, n = 5) {\n  return nanoToGivenFields(e, n, F);\n}\n\nfunction durationHasDateParts(e) {\n  return Boolean(computeDurationSign(e, Pi));\n}\n\nfunction getMaxDurationUnit(e) {\n  let n = 9;\n  for (;n > 0 && !e[F[n]]; n--) {}\n  return n;\n}\n\nfunction createSplitTuple(e, n) {\n  return [ e, n ];\n}\n\nfunction computePeriod(e) {\n  const n = Math.floor(e / Da) * Da;\n  return [ n, n + Da ];\n}\n\nfunction pe(e) {\n  const n = parseDateTimeLike(e = toStringViaPrimitive(e));\n  if (!n) {\n    throw new RangeError(failedParse(e));\n  }\n  let t;\n  if (n.m) {\n    t = 0;\n  } else {\n    if (!n.offset) {\n      throw new RangeError(failedParse(e));\n    }\n    t = parseOffsetNano(n.offset);\n  }\n  return n.timeZone && parseOffsetNanoMaybe(n.timeZone, 1), _(isoToEpochNanoWithOffset(checkIsoDateTimeFields(n), t));\n}\n\nfunction Xt(e) {\n  const n = parseDateTimeLike(m(e));\n  if (!n) {\n    throw new RangeError(failedParse(e));\n  }\n  if (n.timeZone) {\n    return finalizeZonedDateTime(n, n.offset ? parseOffsetNano(n.offset) : void 0);\n  }\n  if (n.m) {\n    throw new RangeError(failedParse(e));\n  }\n  return finalizeDate(n);\n}\n\nfunction Mn(e, n) {\n  const t = parseDateTimeLike(m(e));\n  if (!t || !t.timeZone) {\n    throw new RangeError(failedParse(e));\n  }\n  const {offset: o} = t, r = o ? parseOffsetNano(o) : void 0, [, i, a] = wn(n);\n  return finalizeZonedDateTime(t, r, i, a);\n}\n\nfunction parseOffsetNano(e) {\n  const n = parseOffsetNanoMaybe(e);\n  if (void 0 === n) {\n    throw new RangeError(failedParse(e));\n  }\n  return n;\n}\n\nfunction Ct(e) {\n  const n = parseDateTimeLike(m(e));\n  if (!n || n.m) {\n    throw new RangeError(failedParse(e));\n  }\n  return ee(finalizeDateTime(n));\n}\n\nfunction At(e) {\n  const n = parseDateTimeLike(m(e));\n  if (!n || n.m) {\n    throw new RangeError(failedParse(e));\n  }\n  return v(n.p ? finalizeDateTime(n) : finalizeDate(n));\n}\n\nfunction ot(e, n) {\n  const t = parseYearMonthOnly(m(n));\n  if (t) {\n    return requireIsoCalendar(t), createPlainYearMonthSlots(checkIsoYearMonthInBounds(checkIsoDateFields(t)));\n  }\n  const o = At(n);\n  return createPlainYearMonthSlots(moveToDayOfMonthUnsafe(e(o.calendar), o));\n}\n\nfunction requireIsoCalendar(e) {\n  if (e.calendar !== X) {\n    throw new RangeError(invalidSubstring(e.calendar));\n  }\n}\n\nfunction Q(e, n) {\n  const t = parseMonthDayOnly(m(n));\n  if (t) {\n    return requireIsoCalendar(t), createPlainMonthDaySlots(checkIsoDateFields(t));\n  }\n  const o = At(n), {calendar: r} = o, i = e(r), [a, s, c] = i.h(o), [u, l] = i.I(a, s), [f, d] = i.N(u, l, c);\n  return createPlainMonthDaySlots(checkIsoDateInBounds(i.P(f, d, c)), r);\n}\n\nfunction ze(e) {\n  let n, t = (e => {\n    const n = Ca.exec(e);\n    return n ? (organizeAnnotationParts(n[10]), organizeTimeParts(n)) : void 0;\n  })(m(e));\n  if (!t) {\n    if (t = parseDateTimeLike(e), !t) {\n      throw new RangeError(failedParse(e));\n    }\n    if (!t.p) {\n      throw new RangeError(failedParse(e));\n    }\n    if (t.m) {\n      throw new RangeError(invalidSubstring(\"Z\"));\n    }\n    requireIsoCalendar(t);\n  }\n  if ((n = parseYearMonthOnly(e)) && isIsoDateFieldsValid(n)) {\n    throw new RangeError(failedParse(e));\n  }\n  if ((n = parseMonthDayOnly(e)) && isIsoDateFieldsValid(n)) {\n    throw new RangeError(failedParse(e));\n  }\n  return Ge(constrainIsoTimeFields(t, 1));\n}\n\nfunction Kt(e) {\n  const n = (e => {\n    const n = za.exec(e);\n    return n ? (e => {\n      function parseUnit(e, r, i) {\n        let a = 0, s = 0;\n        if (i && ([a, o] = divModFloor(o, Xr[i])), void 0 !== e) {\n          if (t) {\n            throw new RangeError(invalidSubstring(e));\n          }\n          s = (e => {\n            const n = parseInt(e);\n            if (!Number.isFinite(n)) {\n              throw new RangeError(invalidSubstring(e));\n            }\n            return n;\n          })(e), n = 1, r && (o = parseSubsecNano(r) * (Xr[i] / _r), t = 1);\n        }\n        return a + s;\n      }\n      let n = 0, t = 0, o = 0, r = {\n        ...zipProps(F, [ parseUnit(e[2]), parseUnit(e[3]), parseUnit(e[4]), parseUnit(e[5]), parseUnit(e[6], e[7], 5), parseUnit(e[8], e[9], 4), parseUnit(e[10], e[11], 3) ]),\n        ...nanoToGivenFields(o, 2, F)\n      };\n      if (!n) {\n        throw new RangeError(noValidFields(F));\n      }\n      return parseSign(e[1]) < 0 && (r = negateDurationFields(r)), r;\n    })(n) : void 0;\n  })(m(e));\n  if (!n) {\n    throw new RangeError(failedParse(e));\n  }\n  return Vt(checkDurationUnits(n));\n}\n\nfunction sn(e) {\n  const n = parseDateTimeLike(e) || parseYearMonthOnly(e) || parseMonthDayOnly(e);\n  return n ? n.calendar : e;\n}\n\nfunction Ne(e) {\n  const n = parseDateTimeLike(e);\n  return n && (n.timeZone || n.m && Ta || n.offset) || e;\n}\n\nfunction finalizeZonedDateTime(e, n, t = 0, o = 0) {\n  const r = ye(e.timeZone), i = ie(r);\n  return Yn(getMatchingInstantFor(i, checkIsoDateTimeFields(e), n, t, o, !i.v, e.m), r, an(e.calendar));\n}\n\nfunction finalizeDateTime(e) {\n  return resolveSlotsCalendar(checkIsoDateTimeInBounds(checkIsoDateTimeFields(e)));\n}\n\nfunction finalizeDate(e) {\n  return resolveSlotsCalendar(checkIsoDateInBounds(checkIsoDateFields(e)));\n}\n\nfunction resolveSlotsCalendar(e) {\n  return {\n    ...e,\n    calendar: an(e.calendar)\n  };\n}\n\nfunction parseDateTimeLike(e) {\n  const n = Ya.exec(e);\n  return n ? (e => {\n    const n = e[10], t = \"Z\" === (n || \"\").toUpperCase();\n    return {\n      isoYear: organizeIsoYearParts(e),\n      isoMonth: parseInt(e[4]),\n      isoDay: parseInt(e[5]),\n      ...organizeTimeParts(e.slice(5)),\n      ...organizeAnnotationParts(e[16]),\n      p: Boolean(e[6]),\n      m: t,\n      offset: t ? void 0 : n\n    };\n  })(n) : void 0;\n}\n\nfunction parseYearMonthOnly(e) {\n  const n = Ba.exec(e);\n  return n ? (e => ({\n    isoYear: organizeIsoYearParts(e),\n    isoMonth: parseInt(e[4]),\n    isoDay: 1,\n    ...organizeAnnotationParts(e[5])\n  }))(n) : void 0;\n}\n\nfunction parseMonthDayOnly(e) {\n  const n = ka.exec(e);\n  return n ? (e => ({\n    isoYear: ji,\n    isoMonth: parseInt(e[1]),\n    isoDay: parseInt(e[2]),\n    ...organizeAnnotationParts(e[3])\n  }))(n) : void 0;\n}\n\nfunction parseOffsetNanoMaybe(e, n) {\n  const t = Za.exec(e);\n  return t ? ((e, n) => {\n    const t = e[4] || e[5];\n    if (n && t) {\n      throw new RangeError(invalidSubstring(t));\n    }\n    return ae((parseInt0(e[2]) * Kr + parseInt0(e[3]) * Jr + parseInt0(e[4]) * _r + parseSubsecNano(e[5] || \"\")) * parseSign(e[1]));\n  })(t, n) : void 0;\n}\n\nfunction organizeIsoYearParts(e) {\n  const n = parseSign(e[1]), t = parseInt(e[2] || e[3]);\n  if (n < 0 && !t) {\n    throw new RangeError(invalidSubstring(-0));\n  }\n  return n * t;\n}\n\nfunction organizeTimeParts(e) {\n  const n = parseInt0(e[3]);\n  return {\n    ...nanoToIsoTimeAndDay(parseSubsecNano(e[4] || \"\"))[0],\n    isoHour: parseInt0(e[1]),\n    isoMinute: parseInt0(e[2]),\n    isoSecond: 60 === n ? 59 : n\n  };\n}\n\nfunction organizeAnnotationParts(e) {\n  let n, t;\n  const o = [];\n  if (e.replace(Ra, ((e, r, i) => {\n    const a = Boolean(r), [s, c] = i.split(\"=\").reverse();\n    if (c) {\n      if (\"u-ca\" === c) {\n        o.push(s), n || (n = a);\n      } else if (a || /[A-Z]/.test(c)) {\n        throw new RangeError(invalidSubstring(e));\n      }\n    } else {\n      if (t) {\n        throw new RangeError(invalidSubstring(e));\n      }\n      t = s;\n    }\n    return \"\";\n  })), o.length > 1 && n) {\n    throw new RangeError(invalidSubstring(e));\n  }\n  return {\n    timeZone: t,\n    calendar: o[0] || X\n  };\n}\n\nfunction parseSubsecNano(e) {\n  return parseInt(e.padEnd(9, \"0\"));\n}\n\nfunction createRegExp(e) {\n  return new RegExp(`^${e}$`, \"i\");\n}\n\nfunction parseSign(e) {\n  return e && \"+\" !== e ? -1 : 1;\n}\n\nfunction parseInt0(e) {\n  return void 0 === e ? 0 : parseInt(e);\n}\n\nfunction Me(e) {\n  return ye(m(e));\n}\n\nfunction ye(e) {\n  const n = getTimeZoneEssence(e);\n  return \"number\" == typeof n ? Fe(n) : n ? (e => {\n    if (Ua.test(e)) {\n      throw new RangeError(br);\n    }\n    return e.toLowerCase().split(\"/\").map(((e, n) => (e.length <= 3 || /\\d/.test(e)) && !/etc|yap/.test(e) ? e.toUpperCase() : e.replace(/baja|dumont|[a-z]+/g, ((e, t) => e.length <= 2 && !n || \"in\" === e || \"chat\" === e ? e.toUpperCase() : e.length > 2 || !t ? capitalize(e).replace(/island|noronha|murdo|rivadavia|urville/, capitalize) : e)))).join(\"/\");\n  })(e) : Ta;\n}\n\nfunction getTimeZoneAtomic(e) {\n  const n = getTimeZoneEssence(e);\n  return \"number\" == typeof n ? n : n ? n.resolvedOptions().timeZone : Ta;\n}\n\nfunction getTimeZoneEssence(e) {\n  const n = parseOffsetNanoMaybe(e = e.toUpperCase(), 1);\n  return void 0 !== n ? n : e !== Ta ? qa(e) : void 0;\n}\n\nfunction Ze(e, n) {\n  return te(e.epochNanoseconds, n.epochNanoseconds);\n}\n\nfunction yn(e, n) {\n  return te(e.epochNanoseconds, n.epochNanoseconds);\n}\n\nfunction $t(e, n, t, o, r, i) {\n  const a = e(normalizeOptions(i).relativeTo), s = Math.max(getMaxDurationUnit(o), getMaxDurationUnit(r));\n  if (allPropsEqual(F, o, r)) {\n    return 0;\n  }\n  if (isUniformUnit(s, a)) {\n    return te(durationFieldsToBigNano(o), durationFieldsToBigNano(r));\n  }\n  if (!a) {\n    throw new RangeError(zr);\n  }\n  const [c, u, l] = createMarkerSystem(n, t, a), f = createMarkerToEpochNano(l), d = createMoveMarker(l);\n  return te(f(d(u, c, o)), f(d(u, c, r)));\n}\n\nfunction gt(e, n) {\n  return rt(e, n) || He(e, n);\n}\n\nfunction rt(e, n) {\n  return compareNumbers(isoToEpochMilli(e), isoToEpochMilli(n));\n}\n\nfunction He(e, n) {\n  return compareNumbers(isoTimeFieldsToNano(e), isoTimeFieldsToNano(n));\n}\n\nfunction ue(e, n) {\n  return !Ze(e, n);\n}\n\nfunction gn(e, n) {\n  return !yn(e, n) && !!je(e.timeZone, n.timeZone) && isIdLikeEqual(e.calendar, n.calendar);\n}\n\nfunction ft(e, n) {\n  return !gt(e, n) && isIdLikeEqual(e.calendar, n.calendar);\n}\n\nfunction It(e, n) {\n  return !rt(e, n) && isIdLikeEqual(e.calendar, n.calendar);\n}\n\nfunction $e(e, n) {\n  return !rt(e, n) && isIdLikeEqual(e.calendar, n.calendar);\n}\n\nfunction x(e, n) {\n  return !rt(e, n) && isIdLikeEqual(e.calendar, n.calendar);\n}\n\nfunction Ve(e, n) {\n  return !He(e, n);\n}\n\nfunction je(e, n) {\n  if (e === n) {\n    return 1;\n  }\n  const t = I(e), o = I(n);\n  if (t === o) {\n    return 1;\n  }\n  try {\n    return getTimeZoneAtomic(t) === getTimeZoneAtomic(o);\n  } catch (e) {}\n}\n\nfunction le(e, n, t, o) {\n  const r = refineDiffOptions(e, U(o), 3, 5), i = diffEpochNanos(n.epochNanoseconds, t.epochNanoseconds, ...r);\n  return Vt(e ? negateDurationFields(i) : i);\n}\n\nfunction Dn(e, n, t, o, r, i) {\n  const a = getCommonCalendarSlot(o.calendar, r.calendar), s = U(i), [c, u, l, f] = refineDiffOptions(t, s, 5), d = o.epochNanoseconds, m = r.epochNanoseconds, p = te(m, d);\n  let h;\n  if (p) {\n    if (c < 6) {\n      h = diffEpochNanos(d, m, c, u, l, f);\n    } else {\n      const t = n(((e, n) => {\n        if (!je(e, n)) {\n          throw new RangeError(Fr);\n        }\n        return e;\n      })(o.timeZone, r.timeZone)), i = e(a);\n      h = diffZonedEpochsBig(i, t, o, r, p, c, s), h = roundRelativeDuration(h, m, c, u, l, f, i, o, extractEpochNano, E(moveZonedEpochs, t));\n    }\n  } else {\n    h = Si;\n  }\n  return Vt(t ? negateDurationFields(h) : h);\n}\n\nfunction ut(e, n, t, o, r) {\n  const i = getCommonCalendarSlot(t.calendar, o.calendar), a = U(r), [s, c, u, l] = refineDiffOptions(n, a, 6), f = isoToEpochNano(t), d = isoToEpochNano(o), m = te(d, f);\n  let p;\n  if (m) {\n    if (s <= 6) {\n      p = diffEpochNanos(f, d, s, c, u, l);\n    } else {\n      const n = e(i);\n      p = diffDateTimesBig(n, t, o, m, s, a), p = roundRelativeDuration(p, d, s, c, u, l, n, t, isoToEpochNano, moveDateTime);\n    }\n  } else {\n    p = Si;\n  }\n  return Vt(n ? negateDurationFields(p) : p);\n}\n\nfunction Ft(e, n, t, o, r) {\n  const i = getCommonCalendarSlot(t.calendar, o.calendar), a = U(r);\n  return diffDateLike(n, (() => e(i)), t, o, ...refineDiffOptions(n, a, 6, 9, 6), a);\n}\n\nfunction Xe(e, n, t, o, r) {\n  const i = getCommonCalendarSlot(t.calendar, o.calendar), a = U(r), s = refineDiffOptions(n, a, 9, 9, 8), c = e(i);\n  return diffDateLike(n, (() => c), moveToDayOfMonthUnsafe(c, t), moveToDayOfMonthUnsafe(c, o), ...s, a);\n}\n\nfunction diffDateLike(e, n, t, o, r, i, a, s, c) {\n  const u = isoToEpochNano(t), l = isoToEpochNano(o);\n  let f;\n  if (te(l, u)) {\n    if (6 === r) {\n      f = diffEpochNanos(u, l, r, i, a, s);\n    } else {\n      const e = n();\n      f = e.dateUntil(t, o, r, c), 6 === i && 1 === a || (f = roundRelativeDuration(f, l, r, i, a, s, e, t, isoToEpochNano, moveDate));\n    }\n  } else {\n    f = Si;\n  }\n  return Vt(e ? negateDurationFields(f) : f);\n}\n\nfunction Ae(e, n, t, o) {\n  const r = U(o), [i, a, s, c] = refineDiffOptions(e, r, 5, 5), u = roundByInc(diffTimes(n, t), computeNanoInc(a, s), c), l = {\n    ...Si,\n    ...nanoToDurationTimeFields(u, i)\n  };\n  return Vt(e ? negateDurationFields(l) : l);\n}\n\nfunction diffZonedEpochsExact(e, n, t, o, r, i) {\n  const a = te(o.epochNanoseconds, t.epochNanoseconds);\n  return a ? r < 6 ? diffEpochNanosExact(t.epochNanoseconds, o.epochNanoseconds, r) : diffZonedEpochsBig(n, e, t, o, a, r, i) : Si;\n}\n\nfunction diffDateTimesExact(e, n, t, o, r) {\n  const i = isoToEpochNano(n), a = isoToEpochNano(t), s = te(a, i);\n  return s ? o <= 6 ? diffEpochNanosExact(i, a, o) : diffDateTimesBig(e, n, t, s, o, r) : Si;\n}\n\nfunction diffZonedEpochsBig(e, n, t, o, r, i, a) {\n  const [s, c, u] = ((e, n, t, o) => {\n    function updateMid() {\n      return l = {\n        ...moveByDays(a, c++ * -o),\n        ...i\n      }, f = we(e, l), te(s, f) === -o;\n    }\n    const r = fn(n, e), i = Vn(j, r), a = fn(t, e), s = t.epochNanoseconds;\n    let c = 0;\n    const u = diffTimes(r, a);\n    let l, f;\n    if (Math.sign(u) === -o && c++, updateMid() && (-1 === o || updateMid())) {\n      throw new RangeError(vr);\n    }\n    const d = oe(re(f, s));\n    return [ r, l, d ];\n  })(n, t, o, r);\n  var l, f;\n  return {\n    ...6 === i ? (l = s, f = c, {\n      ...Si,\n      days: diffDays(l, f)\n    }) : e.dateUntil(s, c, i, a),\n    ...nanoToDurationTimeFields(u)\n  };\n}\n\nfunction diffDateTimesBig(e, n, t, o, r, i) {\n  const [a, s, c] = ((e, n, t) => {\n    let o = n, r = diffTimes(e, n);\n    return Math.sign(r) === -t && (o = moveByDays(n, -t), r += Qr * t), [ e, o, r ];\n  })(n, t, o);\n  return {\n    ...e.dateUntil(a, s, r, i),\n    ...nanoToDurationTimeFields(c)\n  };\n}\n\nfunction diffEpochNanos(e, n, t, o, r, i) {\n  return {\n    ...Si,\n    ...nanoToDurationDayTimeFields(roundBigNano(re(e, n), o, r, i), t)\n  };\n}\n\nfunction diffEpochNanosExact(e, n, t) {\n  return {\n    ...Si,\n    ...nanoToDurationDayTimeFields(re(e, n), t)\n  };\n}\n\nfunction diffDays(e, n) {\n  return diffEpochMilliByDay(isoToEpochMilli(e), isoToEpochMilli(n));\n}\n\nfunction diffEpochMilliByDay(e, n) {\n  return Math.trunc((n - e) / Gr);\n}\n\nfunction diffTimes(e, n) {\n  return isoTimeFieldsToNano(n) - isoTimeFieldsToNano(e);\n}\n\nfunction getCommonCalendarSlot(e, n) {\n  if (!isIdLikeEqual(e, n)) {\n    throw new RangeError(Er);\n  }\n  return e;\n}\n\nfunction createIntlCalendar(e) {\n  function epochMilliToIntlFields(e) {\n    return ((e, n) => ({\n      ...parseIntlYear(e, n),\n      F: e.month,\n      day: parseInt(e.day)\n    }))(hashIntlFormatParts(n, e), t);\n  }\n  const n = La(e), t = computeCalendarIdBase(e);\n  return {\n    id: e,\n    O: createIntlFieldCache(epochMilliToIntlFields),\n    B: createIntlYearDataCache(epochMilliToIntlFields)\n  };\n}\n\nfunction createIntlFieldCache(e) {\n  return Jn((n => {\n    const t = isoToEpochMilli(n);\n    return e(t);\n  }), WeakMap);\n}\n\nfunction createIntlYearDataCache(e) {\n  const n = e(0).year - Wi;\n  return Jn((t => {\n    let o, r = isoArgsToEpochMilli(t - n);\n    const i = [], a = [];\n    do {\n      r += 400 * Gr;\n    } while ((o = e(r)).year <= t);\n    do {\n      r += (1 - o.day) * Gr, o.year === t && (i.push(r), a.push(o.F)), r -= Gr;\n    } while ((o = e(r)).year >= t);\n    return {\n      k: i.reverse(),\n      C: Wr(a.reverse())\n    };\n  }));\n}\n\nfunction parseIntlYear(e, n) {\n  let t, o, r = parseIntlPartsYear(e);\n  if (e.era) {\n    const i = Di[n];\n    void 0 !== i && (t = \"islamic\" === n ? \"ah\" : e.era.normalize(\"NFD\").toLowerCase().replace(/[^a-z0-9]/g, \"\"), \n    \"bc\" === t || \"b\" === t ? t = \"bce\" : \"ad\" !== t && \"a\" !== t || (t = \"ce\"), o = r, \n    r = eraYearToYear(o, i[t] || 0));\n  }\n  return {\n    era: t,\n    eraYear: o,\n    year: r\n  };\n}\n\nfunction parseIntlPartsYear(e) {\n  return parseInt(e.relatedYear || e.year);\n}\n\nfunction computeIntlDateParts(e) {\n  const {year: n, F: t, day: o} = this.O(e), {C: r} = this.B(n);\n  return [ n, r[t] + 1, o ];\n}\n\nfunction computeIntlEpochMilli(e, n = 1, t = 1) {\n  return this.B(e).k[n - 1] + (t - 1) * Gr;\n}\n\nfunction computeIntlLeapMonth(e) {\n  const n = queryMonthStrings(this, e), t = queryMonthStrings(this, e - 1), o = n.length;\n  if (o > t.length) {\n    const e = getCalendarLeapMonthMeta(this);\n    if (e < 0) {\n      return -e;\n    }\n    for (let e = 0; e < o; e++) {\n      if (n[e] !== t[e]) {\n        return e + 1;\n      }\n    }\n  }\n}\n\nfunction computeIntlDaysInYear(e) {\n  return diffEpochMilliByDay(computeIntlEpochMilli.call(this, e), computeIntlEpochMilli.call(this, e + 1));\n}\n\nfunction computeIntlDaysInMonth(e, n) {\n  const {k: t} = this.B(e);\n  let o = n + 1, r = t;\n  return o > t.length && (o = 1, r = this.B(e + 1).k), diffEpochMilliByDay(t[n - 1], r[o - 1]);\n}\n\nfunction computeIntlMonthsInYear(e) {\n  return this.B(e).k.length;\n}\n\nfunction queryMonthStrings(e, n) {\n  return Object.keys(e.B(n).C);\n}\n\nfunction rn(e) {\n  return an(m(e));\n}\n\nfunction an(e) {\n  if ((e = e.toLowerCase()) !== X && e !== gi && computeCalendarIdBase(e) !== computeCalendarIdBase(La(e).resolvedOptions().calendar)) {\n    throw new RangeError(invalidCalendar(e));\n  }\n  return e;\n}\n\nfunction computeCalendarIdBase(e) {\n  return \"islamicc\" === e && (e = \"islamic\"), e.split(\"-\")[0];\n}\n\nfunction computeNativeWeekOfYear(e) {\n  return this.R(e)[0];\n}\n\nfunction computeNativeYearOfWeek(e) {\n  return this.R(e)[1];\n}\n\nfunction computeNativeDayOfYear(e) {\n  const [n] = this.h(e);\n  return diffEpochMilliByDay(this.q(n), isoToEpochMilli(e)) + 1;\n}\n\nfunction parseMonthCode(e) {\n  const n = Wa.exec(e);\n  if (!n) {\n    throw new RangeError(invalidMonthCode(e));\n  }\n  return [ parseInt(n[1]), Boolean(n[2]) ];\n}\n\nfunction monthCodeNumberToMonth(e, n, t) {\n  return e + (n || t && e >= t ? 1 : 0);\n}\n\nfunction monthToMonthCodeNumber(e, n) {\n  return e - (n && e >= n ? 1 : 0);\n}\n\nfunction eraYearToYear(e, n) {\n  return (n + e) * (Math.sign(n) || 1) || 0;\n}\n\nfunction getCalendarEraOrigins(e) {\n  return Di[getCalendarIdBase(e)];\n}\n\nfunction getCalendarLeapMonthMeta(e) {\n  return Ii[getCalendarIdBase(e)];\n}\n\nfunction getCalendarIdBase(e) {\n  return computeCalendarIdBase(e.id || X);\n}\n\nfunction Qt(e, n, t, o) {\n  const r = refineCalendarFields(t, o, en, [], ri);\n  if (void 0 !== r.timeZone) {\n    const o = t.dateFromFields(r), i = refineTimeBag(r), a = e(r.timeZone);\n    return {\n      epochNanoseconds: getMatchingInstantFor(n(a), {\n        ...o,\n        ...i\n      }, void 0 !== r.offset ? parseOffsetNano(r.offset) : void 0),\n      timeZone: a\n    };\n  }\n  return {\n    ...t.dateFromFields(r),\n    ...Dt\n  };\n}\n\nfunction jn(e, n, t, o, r, i) {\n  const a = refineCalendarFields(t, r, en, ti, ri), s = e(a.timeZone), [c, u, l] = wn(i), f = t.dateFromFields(a, overrideOverflowOptions(i, c)), d = refineTimeBag(a, c);\n  return Yn(getMatchingInstantFor(n(s), {\n    ...f,\n    ...d\n  }, void 0 !== a.offset ? parseOffsetNano(a.offset) : void 0, u, l), s, o);\n}\n\nfunction Pt(e, n, t) {\n  const o = refineCalendarFields(e, n, en, [], w), r = H(t);\n  return ee(checkIsoDateTimeInBounds({\n    ...e.dateFromFields(o, overrideOverflowOptions(t, r)),\n    ...refineTimeBag(o, r)\n  }));\n}\n\nfunction Yt(e, n, t, o = []) {\n  const r = refineCalendarFields(e, n, en, o);\n  return e.dateFromFields(r, t);\n}\n\nfunction nt(e, n, t, o) {\n  const r = refineCalendarFields(e, n, fi, o);\n  return e.yearMonthFromFields(r, t);\n}\n\nfunction K(e, n, t, o, r = []) {\n  const i = refineCalendarFields(e, t, en, r);\n  return n && void 0 !== i.month && void 0 === i.monthCode && void 0 === i.year && (i.year = ji), \n  e.monthDayFromFields(i, o);\n}\n\nfunction Ue(e, n) {\n  const t = H(n);\n  return Ge(refineTimeBag(refineFields(e, ei, [], 1), t));\n}\n\nfunction Ht(e) {\n  const n = refineFields(e, Ni);\n  return Vt(checkDurationUnits({\n    ...Si,\n    ...n\n  }));\n}\n\nfunction refineCalendarFields(e, n, t, o = [], r = []) {\n  return refineFields(n, [ ...e.fields(t), ...r ].sort(), o);\n}\n\nfunction refineFields(e, n, t, o = !t) {\n  const r = {};\n  let i, a = 0;\n  for (const o of n) {\n    if (o === i) {\n      throw new RangeError(duplicateFields(o));\n    }\n    if (\"constructor\" === o || \"__proto__\" === o) {\n      throw new RangeError(tn(o));\n    }\n    let n = e[o];\n    if (void 0 !== n) {\n      a = 1, Ga[o] && (n = Ga[o](n, o)), r[o] = n;\n    } else if (t) {\n      if (t.includes(o)) {\n        throw new TypeError(missingField(o));\n      }\n      r[o] = hi[o];\n    }\n    i = o;\n  }\n  if (o && !a) {\n    throw new TypeError(noValidFields(n));\n  }\n  return r;\n}\n\nfunction refineTimeBag(e, n) {\n  return constrainIsoTimeFields(Ha({\n    ...hi,\n    ...e\n  }), n);\n}\n\nfunction Sn(e, n, t, o, r, i) {\n  const a = U(i), {calendar: s, timeZone: c} = t;\n  return Yn(((e, n, t, o, r) => {\n    const i = mergeCalendarFields(e, t, o, en, oi, ni), [a, s, c] = wn(r, 2);\n    return getMatchingInstantFor(n, {\n      ...e.dateFromFields(i, overrideOverflowOptions(r, a)),\n      ...refineTimeBag(i, a)\n    }, parseOffsetNano(i.offset), s, c);\n  })(e(s), n(c), o, r, a), c, s);\n}\n\nfunction at(e, n, t, o, r) {\n  const i = U(r);\n  return ee(((e, n, t, o) => {\n    const r = mergeCalendarFields(e, n, t, en, w), i = H(o);\n    return checkIsoDateTimeInBounds({\n      ...e.dateFromFields(r, overrideOverflowOptions(o, i)),\n      ...refineTimeBag(r, i)\n    });\n  })(e(n.calendar), t, o, i));\n}\n\nfunction Zt(e, n, t, o, r) {\n  const i = U(r);\n  return ((e, n, t, o) => {\n    const r = mergeCalendarFields(e, n, t, en);\n    return e.dateFromFields(r, o);\n  })(e(n.calendar), t, o, i);\n}\n\nfunction Ke(e, n, t, o, r) {\n  const i = U(r);\n  return createPlainYearMonthSlots(((e, n, t, o) => {\n    const r = mergeCalendarFields(e, n, t, fi);\n    return e.yearMonthFromFields(r, o);\n  })(e(n.calendar), t, o, i));\n}\n\nfunction k(e, n, t, o, r) {\n  const i = U(r);\n  return ((e, n, t, o) => {\n    const r = mergeCalendarFields(e, n, t, en);\n    return e.monthDayFromFields(r, o);\n  })(e(n.calendar), t, o, i);\n}\n\nfunction Be(e, n, t) {\n  return Ge(((e, n, t) => {\n    const o = H(t);\n    return refineTimeBag({\n      ...Vn(ei, e),\n      ...refineFields(n, ei)\n    }, o);\n  })(e, n, t));\n}\n\nfunction kt(e, n) {\n  return Vt((t = e, o = n, checkDurationUnits({\n    ...t,\n    ...refineFields(o, Ni)\n  })));\n  var t, o;\n}\n\nfunction mergeCalendarFields(e, n, t, o, r = [], i = []) {\n  const a = [ ...e.fields(o), ...r ].sort();\n  let s = refineFields(n, a, i);\n  const c = refineFields(t, a);\n  return s = e.mergeFields(s, c), refineFields(s, a, []);\n}\n\nfunction convertToPlainMonthDay(e, n) {\n  const t = refineCalendarFields(e, n, pi);\n  return e.monthDayFromFields(t);\n}\n\nfunction convertToPlainYearMonth(e, n, t) {\n  const o = refineCalendarFields(e, n, di);\n  return e.yearMonthFromFields(o, t);\n}\n\nfunction convertToIso(e, n, t, o, r) {\n  n = Vn(t = e.fields(t), n), o = refineFields(o, r = e.fields(r), []);\n  let i = e.mergeFields(n, o);\n  return i = refineFields(i, [ ...t, ...r ].sort(), []), e.dateFromFields(i);\n}\n\nfunction refineYear(e, n) {\n  let {era: t, eraYear: o, year: r} = n;\n  const i = getCalendarEraOrigins(e);\n  if (void 0 !== t || void 0 !== o) {\n    if (void 0 === t || void 0 === o) {\n      throw new TypeError(Dr);\n    }\n    if (!i) {\n      throw new RangeError(gr);\n    }\n    const e = i[t];\n    if (void 0 === e) {\n      throw new RangeError(invalidEra(t));\n    }\n    const n = eraYearToYear(o, e);\n    if (void 0 !== r && r !== n) {\n      throw new RangeError(Ir);\n    }\n    r = n;\n  } else if (void 0 === r) {\n    throw new TypeError(missingYear(i));\n  }\n  return r;\n}\n\nfunction refineMonth(e, n, t, o) {\n  let {month: r, monthCode: i} = n;\n  if (void 0 !== i) {\n    const n = ((e, n, t, o) => {\n      const r = e.U(t), [i, a] = parseMonthCode(n);\n      let s = monthCodeNumberToMonth(i, a, r);\n      if (a) {\n        const n = getCalendarLeapMonthMeta(e);\n        if (void 0 === n) {\n          throw new RangeError(Pr);\n        }\n        if (n > 0) {\n          if (s > n) {\n            throw new RangeError(Pr);\n          }\n          if (void 0 === r) {\n            if (1 === o) {\n              throw new RangeError(Pr);\n            }\n            s--;\n          }\n        } else {\n          if (s !== -n) {\n            throw new RangeError(Pr);\n          }\n          if (void 0 === r && 1 === o) {\n            throw new RangeError(Pr);\n          }\n        }\n      }\n      return s;\n    })(e, i, t, o);\n    if (void 0 !== r && r !== n) {\n      throw new RangeError(Mr);\n    }\n    r = n, o = 1;\n  } else if (void 0 === r) {\n    throw new TypeError(Nr);\n  }\n  return clampEntity(\"month\", r, 1, e.L(t), o);\n}\n\nfunction refineDay(e, n, t, o, r) {\n  return clampProp(n, \"day\", 1, e.j(o, t), r);\n}\n\nfunction spliceFields(e, n, t, o) {\n  let r = 0;\n  const i = [];\n  for (const e of t) {\n    void 0 !== n[e] ? r = 1 : i.push(e);\n  }\n  if (Object.assign(e, n), r) {\n    for (const n of o || i) {\n      delete e[n];\n    }\n  }\n}\n\nfunction Se(e) {\n  return _(checkEpochNanoInBounds(bigIntToBigNano(toBigInt(e))));\n}\n\nfunction vn(e, n, t, o, r = X) {\n  return Yn(checkEpochNanoInBounds(bigIntToBigNano(toBigInt(t))), n(o), e(r));\n}\n\nfunction pt(e, n, t, o, r = 0, i = 0, a = 0, s = 0, c = 0, u = 0, l = X) {\n  return ee(checkIsoDateTimeInBounds(checkIsoDateTimeFields(T(toInteger, zipProps(wi, [ n, t, o, r, i, a, s, c, u ])))), e(l));\n}\n\nfunction Nt(e, n, t, o, r = X) {\n  return v(checkIsoDateInBounds(checkIsoDateFields(T(toInteger, {\n    isoYear: n,\n    isoMonth: t,\n    isoDay: o\n  }))), e(r));\n}\n\nfunction tt(e, n, t, o = X, r = 1) {\n  const i = toInteger(n), a = toInteger(t), s = e(o);\n  return createPlainYearMonthSlots(checkIsoYearMonthInBounds(checkIsoDateFields({\n    isoYear: i,\n    isoMonth: a,\n    isoDay: toInteger(r)\n  })), s);\n}\n\nfunction G(e, n, t, o = X, r = ji) {\n  const i = toInteger(n), a = toInteger(t), s = e(o);\n  return createPlainMonthDaySlots(checkIsoDateInBounds(checkIsoDateFields({\n    isoYear: toInteger(r),\n    isoMonth: i,\n    isoDay: a\n  })), s);\n}\n\nfunction ke(e = 0, n = 0, t = 0, o = 0, r = 0, i = 0) {\n  return Ge(constrainIsoTimeFields(T(toInteger, zipProps(j, [ e, n, t, o, r, i ])), 1));\n}\n\nfunction Lt(e = 0, n = 0, t = 0, o = 0, r = 0, i = 0, a = 0, s = 0, c = 0, u = 0) {\n  return Vt(checkDurationUnits(T(toStrictInteger, zipProps(F, [ e, n, t, o, r, i, a, s, c, u ]))));\n}\n\nfunction fe(e, n, t = X) {\n  return Yn(e.epochNanoseconds, n, t);\n}\n\nfunction Zn(e) {\n  return _(e.epochNanoseconds);\n}\n\nfunction ht(e, n) {\n  return ee(fn(n, e));\n}\n\nfunction Bt(e, n) {\n  return v(fn(n, e));\n}\n\nfunction bn(e, n, t) {\n  return convertToPlainYearMonth(e(n.calendar), t);\n}\n\nfunction Fn(e, n, t) {\n  return convertToPlainMonthDay(e(n.calendar), t);\n}\n\nfunction Re(e, n) {\n  return Ge(fn(n, e));\n}\n\nfunction mt(e, n, t, o) {\n  const r = ((e, n, t, o) => {\n    const r = ve(o);\n    return we(e(n), t, r);\n  })(e, t, n, o);\n  return Yn(checkEpochNanoInBounds(r), t, n.calendar);\n}\n\nfunction St(e, n, t) {\n  const o = e(n.calendar);\n  return createPlainYearMonthSlots({\n    ...n,\n    ...convertToPlainYearMonth(o, t)\n  });\n}\n\nfunction Ot(e, n, t) {\n  return convertToPlainMonthDay(e(n.calendar), t);\n}\n\nfunction vt(e, n, t, o, r) {\n  const i = e(r.timeZone), a = r.plainTime, s = void 0 !== a ? n(a) : Dt;\n  return Yn(we(t(i), {\n    ...o,\n    ...s\n  }), i, o.calendar);\n}\n\nfunction wt(e, n = Dt) {\n  return ee(checkIsoDateTimeInBounds({\n    ...e,\n    ...n\n  }));\n}\n\nfunction jt(e, n, t) {\n  return convertToPlainYearMonth(e(n.calendar), t);\n}\n\nfunction Mt(e, n, t) {\n  return convertToPlainMonthDay(e(n.calendar), t);\n}\n\nfunction _e(e, n, t, o) {\n  return ((e, n, t) => convertToIso(e, n, di, de(t), li))(e(n.calendar), t, o);\n}\n\nfunction R(e, n, t, o) {\n  return ((e, n, t) => convertToIso(e, n, pi, de(t), si))(e(n.calendar), t, o);\n}\n\nfunction Je(e, n, t, o, r) {\n  const i = de(r), a = n(i.plainDate), s = e(i.timeZone);\n  return Yn(we(t(s), {\n    ...a,\n    ...o\n  }), s, a.calendar);\n}\n\nfunction Le(e, n) {\n  return ee(checkIsoDateTimeInBounds({\n    ...e,\n    ...n\n  }));\n}\n\nfunction De(e) {\n  return _(checkEpochNanoInBounds(he(e, _r)));\n}\n\nfunction Pe(e) {\n  return _(checkEpochNanoInBounds(he(e, be)));\n}\n\nfunction Ce(e) {\n  return _(checkEpochNanoInBounds(bigIntToBigNano(toBigInt(e), Vr)));\n}\n\nfunction ge(e) {\n  return _(checkEpochNanoInBounds(bigIntToBigNano(toBigInt(e))));\n}\n\nfunction pn(e, n, t = Dt) {\n  const o = n.timeZone, r = e(o), i = {\n    ...fn(n, r),\n    ...t\n  };\n  return Yn(getMatchingInstantFor(r, i, i.offsetNanoseconds, 2), o, n.calendar);\n}\n\nfunction Tn(e, n, t) {\n  const o = n.timeZone, r = e(o), i = {\n    ...fn(n, r),\n    ...t\n  }, a = getPreferredCalendarSlot(n.calendar, t.calendar);\n  return Yn(getMatchingInstantFor(r, i, i.offsetNanoseconds, 2), o, a);\n}\n\nfunction lt(e, n = Dt) {\n  return ee({\n    ...e,\n    ...n\n  });\n}\n\nfunction st(e, n) {\n  return ee({\n    ...e,\n    ...n\n  }, getPreferredCalendarSlot(e.calendar, n.calendar));\n}\n\nfunction it(e, n) {\n  return {\n    ...e,\n    calendar: n\n  };\n}\n\nfunction On(e, n) {\n  return {\n    ...e,\n    timeZone: n\n  };\n}\n\nfunction getPreferredCalendarSlot(e, n) {\n  if (e === n) {\n    return e;\n  }\n  const t = I(e), o = I(n);\n  if (t === o || t === X) {\n    return n;\n  }\n  if (o === X) {\n    return e;\n  }\n  throw new RangeError(Er);\n}\n\nfunction createNativeOpsCreator(e, n) {\n  return t => t === X ? e : t === gi || t === Ti ? Object.assign(Object.create(e), {\n    id: t\n  }) : Object.assign(Object.create(n), Aa(t));\n}\n\nfunction createOptionsTransformer(e, n, t) {\n  const o = new Set(t);\n  return r => (((e, n) => {\n    for (const t of n) {\n      if (t in e) {\n        return 1;\n      }\n    }\n    return 0;\n  })(r = V(o, r), e) || Object.assign(r, n), t && (r.timeZone = Ta, [ \"full\", \"long\" ].includes(r.timeStyle) && (r.timeStyle = \"medium\")), \n  r);\n}\n\nfunction e(e, n = qn) {\n  const [t, , , o] = e;\n  return (r, i = Ns, ...a) => {\n    const s = n(o && o(...a), r, i, t), c = s.resolvedOptions();\n    return [ s, ...toEpochMillis(e, c, a) ];\n  };\n}\n\nfunction qn(e, n, t, o) {\n  if (t = o(t), e) {\n    if (void 0 !== t.timeZone) {\n      throw new TypeError(Lr);\n    }\n    t.timeZone = e;\n  }\n  return new En(n, t);\n}\n\nfunction toEpochMillis(e, n, t) {\n  const [, o, r] = e;\n  return t.map((e => (e.calendar && ((e, n, t) => {\n    if ((t || e !== X) && e !== n) {\n      throw new RangeError(Er);\n    }\n  })(I(e.calendar), n.calendar, r), o(e, n))));\n}\n\nfunction An(e) {\n  const n = Bn();\n  return Ie(n, e.getOffsetNanosecondsFor(n));\n}\n\nfunction Bn() {\n  return he(Date.now(), be);\n}\n\nfunction Nn() {\n  return ys || (ys = (new En).resolvedOptions().timeZone);\n}\n\nconst expectedInteger = (e, n) => `Non-integer ${e}: ${n}`, expectedPositive = (e, n) => `Non-positive ${e}: ${n}`, expectedFinite = (e, n) => `Non-finite ${e}: ${n}`, forbiddenBigIntToNumber = e => `Cannot convert bigint to ${e}`, invalidBigInt = e => `Invalid bigint: ${e}`, pr = \"Cannot convert Symbol to string\", hr = \"Invalid object\", numberOutOfRange = (e, n, t, o, r) => r ? numberOutOfRange(e, r[n], r[t], r[o]) : invalidEntity(e, n) + `; must be between ${t}-${o}`, invalidEntity = (e, n) => `Invalid ${e}: ${n}`, missingField = e => `Missing ${e}`, tn = e => `Invalid field ${e}`, duplicateFields = e => `Duplicate field ${e}`, noValidFields = e => \"No valid fields: \" + e.join(), Z = \"Invalid bag\", invalidChoice = (e, n, t) => invalidEntity(e, n) + \"; must be \" + Object.keys(t).join(), A = \"Cannot use valueOf\", P = \"Invalid calling context\", gr = \"Forbidden era/eraYear\", Dr = \"Mismatching era/eraYear\", Ir = \"Mismatching year/eraYear\", invalidEra = e => `Invalid era: ${e}`, missingYear = e => \"Missing year\" + (e ? \"/era/eraYear\" : \"\"), invalidMonthCode = e => `Invalid monthCode: ${e}`, Mr = \"Mismatching month/monthCode\", Nr = \"Missing month/monthCode\", yr = \"Cannot guess year\", Pr = \"Invalid leap month\", g = \"Invalid protocol\", vr = \"Invalid protocol results\", Er = \"Mismatching Calendars\", invalidCalendar = e => `Invalid Calendar: ${e}`, Fr = \"Mismatching TimeZones\", br = \"Forbidden ICU TimeZone\", wr = \"Out-of-bounds offset\", Br = \"Out-of-bounds TimeZone gap\", kr = \"Invalid TimeZone offset\", Yr = \"Ambiguous offset\", Cr = \"Out-of-bounds date\", Zr = \"Out-of-bounds duration\", Rr = \"Cannot mix duration signs\", zr = \"Missing relativeTo\", qr = \"Cannot use large units\", Ur = \"Required smallestUnit or largestUnit\", Ar = \"smallestUnit > largestUnit\", failedParse = e => `Cannot parse: ${e}`, invalidSubstring = e => `Invalid substring: ${e}`, Ln = e => `Cannot format ${e}`, kn = \"Mismatching types for formatting\", Lr = \"Cannot specify TimeZone\", Wr = /*@__PURE__*/ E(b, ((e, n) => n)), jr = /*@__PURE__*/ E(b, ((e, n, t) => t)), xr = /*@__PURE__*/ E(padNumber, 2), $r = {\n  nanosecond: 0,\n  microsecond: 1,\n  millisecond: 2,\n  second: 3,\n  minute: 4,\n  hour: 5,\n  day: 6,\n  week: 7,\n  month: 8,\n  year: 9\n}, Et = /*@__PURE__*/ Object.keys($r), Gr = 864e5, Hr = 1e3, Vr = 1e3, be = 1e6, _r = 1e9, Jr = 6e10, Kr = 36e11, Qr = 864e11, Xr = [ 1, Vr, be, _r, Jr, Kr, Qr ], w = /*@__PURE__*/ Et.slice(0, 6), ei = /*@__PURE__*/ sortStrings(w), ni = [ \"offset\" ], ti = [ \"timeZone\" ], oi = /*@__PURE__*/ w.concat(ni), ri = /*@__PURE__*/ oi.concat(ti), ii = [ \"era\", \"eraYear\" ], ai = /*@__PURE__*/ ii.concat([ \"year\" ]), si = [ \"year\" ], ci = [ \"monthCode\" ], ui = /*@__PURE__*/ [ \"month\" ].concat(ci), li = [ \"day\" ], fi = /*@__PURE__*/ ui.concat(si), di = /*@__PURE__*/ ci.concat(si), en = /*@__PURE__*/ li.concat(fi), mi = /*@__PURE__*/ li.concat(ui), pi = /*@__PURE__*/ li.concat(ci), hi = /*@__PURE__*/ jr(w, 0), X = \"iso8601\", gi = \"gregory\", Ti = \"japanese\", Di = {\n  [gi]: {\n    bce: -1,\n    ce: 0\n  },\n  [Ti]: {\n    bce: -1,\n    ce: 0,\n    meiji: 1867,\n    taisho: 1911,\n    showa: 1925,\n    heisei: 1988,\n    reiwa: 2018\n  },\n  ethioaa: {\n    era0: 0\n  },\n  ethiopic: {\n    era0: 0,\n    era1: 5500\n  },\n  coptic: {\n    era0: -1,\n    era1: 0\n  },\n  roc: {\n    beforeroc: -1,\n    minguo: 0\n  },\n  buddhist: {\n    be: 0\n  },\n  islamic: {\n    ah: 0\n  },\n  indian: {\n    saka: 0\n  },\n  persian: {\n    ap: 0\n  }\n}, Ii = {\n  chinese: 13,\n  dangi: 13,\n  hebrew: -6\n}, m = /*@__PURE__*/ E(requireType, \"string\"), f = /*@__PURE__*/ E(requireType, \"boolean\"), Mi = /*@__PURE__*/ E(requireType, \"number\"), $ = /*@__PURE__*/ E(requireType, \"function\"), F = /*@__PURE__*/ Et.map((e => e + \"s\")), Ni = /*@__PURE__*/ sortStrings(F), yi = /*@__PURE__*/ F.slice(0, 6), Pi = /*@__PURE__*/ F.slice(6), vi = /*@__PURE__*/ Pi.slice(1), Ei = /*@__PURE__*/ Wr(F), Si = /*@__PURE__*/ jr(F, 0), Fi = /*@__PURE__*/ jr(yi, 0), bi = /*@__PURE__*/ E(zeroOutProps, F), j = [ \"isoNanosecond\", \"isoMicrosecond\", \"isoMillisecond\", \"isoSecond\", \"isoMinute\", \"isoHour\" ], Oi = [ \"isoDay\", \"isoMonth\", \"isoYear\" ], wi = /*@__PURE__*/ j.concat(Oi), Bi = /*@__PURE__*/ sortStrings(Oi), ki = /*@__PURE__*/ sortStrings(j), Yi = /*@__PURE__*/ sortStrings(wi), Dt = /*@__PURE__*/ jr(ki, 0), Ci = /*@__PURE__*/ E(zeroOutProps, wi), En = Intl.DateTimeFormat, Zi = \"en-GB\", Ri = 1e8, zi = Ri * Gr, qi = [ Ri, 0 ], Ui = [ -Ri, 0 ], Ai = 275760, Li = -271821, Wi = 1970, ji = 1972, xi = 12, $i = /*@__PURE__*/ isoArgsToEpochMilli(1868, 9, 8), Gi = /*@__PURE__*/ Jn(computeJapaneseEraParts, WeakMap), Hi = \"smallestUnit\", Vi = \"unit\", _i = \"roundingIncrement\", Ji = \"fractionalSecondDigits\", Ki = \"relativeTo\", Qi = {\n  constrain: 0,\n  reject: 1\n}, Xi = /*@__PURE__*/ Object.keys(Qi), ea = {\n  compatible: 0,\n  reject: 1,\n  earlier: 2,\n  later: 3\n}, na = {\n  reject: 0,\n  use: 1,\n  prefer: 2,\n  ignore: 3\n}, ta = {\n  auto: 0,\n  never: 1,\n  critical: 2,\n  always: 3\n}, oa = {\n  auto: 0,\n  never: 1,\n  critical: 2\n}, ra = {\n  auto: 0,\n  never: 1\n}, ia = {\n  floor: 0,\n  halfFloor: 1,\n  ceil: 2,\n  halfCeil: 3,\n  trunc: 4,\n  halfTrunc: 5,\n  expand: 6,\n  halfExpand: 7,\n  halfEven: 8\n}, aa = /*@__PURE__*/ E(refineUnitOption, Hi), sa = /*@__PURE__*/ E(refineUnitOption, \"largestUnit\"), ca = /*@__PURE__*/ E(refineUnitOption, Vi), ua = /*@__PURE__*/ E(refineChoiceOption, \"overflow\", Qi), la = /*@__PURE__*/ E(refineChoiceOption, \"disambiguation\", ea), fa = /*@__PURE__*/ E(refineChoiceOption, \"offset\", na), da = /*@__PURE__*/ E(refineChoiceOption, \"calendarName\", ta), ma = /*@__PURE__*/ E(refineChoiceOption, \"timeZoneName\", oa), pa = /*@__PURE__*/ E(refineChoiceOption, \"offset\", ra), ha = /*@__PURE__*/ E(refineChoiceOption, \"roundingMode\", ia), L = \"PlainYearMonth\", q = \"PlainMonthDay\", J = \"PlainDate\", We = \"PlainDateTime\", xe = \"PlainTime\", Te = \"ZonedDateTime\", Oe = \"Instant\", qt = \"Duration\", ga = [ Math.floor, e => hasHalf(e) ? Math.floor(e) : Math.round(e), Math.ceil, e => hasHalf(e) ? Math.ceil(e) : Math.round(e), Math.trunc, e => hasHalf(e) ? Math.trunc(e) || 0 : Math.round(e), e => e < 0 ? Math.floor(e) : Math.ceil(e), e => Math.sign(e) * Math.round(Math.abs(e)) || 0, e => hasHalf(e) ? (e = Math.trunc(e) || 0) + e % 2 : Math.round(e) ], Ta = \"UTC\", Da = 5184e3, Ia = /*@__PURE__*/ isoArgsToEpochSec(1847), Ma = /*@__PURE__*/ isoArgsToEpochSec(/*@__PURE__*/ (/*@__PURE__*/ new Date).getUTCFullYear() + 10), Na = /0+$/, fn = /*@__PURE__*/ Jn(_zonedEpochSlotsToIso, WeakMap), ya = 2 ** 32 - 1, ie = /*@__PURE__*/ Jn((e => {\n  const n = getTimeZoneEssence(e);\n  return \"object\" == typeof n ? new IntlTimeZone(n) : new FixedTimeZone(n || 0);\n}));\n\nclass FixedTimeZone {\n  constructor(e) {\n    this.v = e;\n  }\n  getOffsetNanosecondsFor() {\n    return this.v;\n  }\n  getPossibleInstantsFor(e) {\n    return [ isoToEpochNanoWithOffset(e, this.v) ];\n  }\n  l() {}\n}\n\nclass IntlTimeZone {\n  constructor(e) {\n    this.$ = (e => {\n      function getOffsetSec(e) {\n        const i = clampNumber(e, o, r), [a, s] = computePeriod(i), c = n(a), u = n(s);\n        return c === u ? c : pinch(t(a, s), c, u, e);\n      }\n      function pinch(n, t, o, r) {\n        let i, a;\n        for (;(void 0 === r || void 0 === (i = r < n[0] ? t : r >= n[1] ? o : void 0)) && (a = n[1] - n[0]); ) {\n          const t = n[0] + Math.floor(a / 2);\n          e(t) === o ? n[1] = t : n[0] = t + 1;\n        }\n        return i;\n      }\n      const n = Jn(e), t = Jn(createSplitTuple);\n      let o = Ia, r = Ma;\n      return {\n        G(e) {\n          const n = getOffsetSec(e - 86400), t = getOffsetSec(e + 86400), o = e - n, r = e - t;\n          if (n === t) {\n            return [ o ];\n          }\n          const i = getOffsetSec(o);\n          return i === getOffsetSec(r) ? [ e - i ] : n > t ? [ o, r ] : [];\n        },\n        V: getOffsetSec,\n        l(e, i) {\n          const a = clampNumber(e, o, r);\n          let [s, c] = computePeriod(a);\n          const u = Da * i, l = i < 0 ? () => c > o || (o = a, 0) : () => s < r || (r = a, \n          0);\n          for (;l(); ) {\n            const o = n(s), r = n(c);\n            if (o !== r) {\n              const n = t(s, c);\n              pinch(n, o, r);\n              const a = n[0];\n              if ((compareNumbers(a, e) || 1) === i) {\n                return a;\n              }\n            }\n            s += u, c += u;\n          }\n        }\n      };\n    })((e => n => {\n      const t = hashIntlFormatParts(e, n * Hr);\n      return isoArgsToEpochSec(parseIntlPartsYear(t), parseInt(t.month), parseInt(t.day), parseInt(t.hour), parseInt(t.minute), parseInt(t.second)) - n;\n    })(e));\n  }\n  getOffsetNanosecondsFor(e) {\n    return this.$.V(epochNanoToSec(e)) * _r;\n  }\n  getPossibleInstantsFor(e) {\n    const [n, t] = [ isoArgsToEpochSec((o = e).isoYear, o.isoMonth, o.isoDay, o.isoHour, o.isoMinute, o.isoSecond), o.isoMillisecond * be + o.isoMicrosecond * Vr + o.isoNanosecond ];\n    var o;\n    return this.$.G(n).map((e => checkEpochNanoInBounds(moveBigNano(he(e, _r), t))));\n  }\n  l(e, n) {\n    const [t, o] = epochNanoToSecMod(e), r = this.$.l(t + (n > 0 || o ? 1 : 0), n);\n    if (void 0 !== r) {\n      return he(r, _r);\n    }\n  }\n}\n\nconst Pa = \"([+−-])\", va = \"(?:[.,](\\\\d{1,9}))?\", Ea = `(?:(?:${Pa}(\\\\d{6}))|(\\\\d{4}))-?(\\\\d{2})`, Sa = \"(\\\\d{2})(?::?(\\\\d{2})(?::?(\\\\d{2})\" + va + \")?)?\", Fa = Pa + Sa, ba = Ea + \"-?(\\\\d{2})(?:[T ]\" + Sa + \"(Z|\" + Fa + \")?)?\", Oa = \"\\\\[(!?)([^\\\\]]*)\\\\]\", wa = `((?:${Oa}){0,9})`, Ba = /*@__PURE__*/ createRegExp(Ea + wa), ka = /*@__PURE__*/ createRegExp(\"(?:--)?(\\\\d{2})-?(\\\\d{2})\" + wa), Ya = /*@__PURE__*/ createRegExp(ba + wa), Ca = /*@__PURE__*/ createRegExp(\"T?\" + Sa + \"(?:\" + Fa + \")?\" + wa), Za = /*@__PURE__*/ createRegExp(Fa), Ra = /*@__PURE__*/ new RegExp(Oa, \"g\"), za = /*@__PURE__*/ createRegExp(`${Pa}?P(\\\\d+Y)?(\\\\d+M)?(\\\\d+W)?(\\\\d+D)?(?:T(?:(\\\\d+)${va}H)?(?:(\\\\d+)${va}M)?(?:(\\\\d+)${va}S)?)?`), qa = /*@__PURE__*/ Jn((e => new En(Zi, {\n  timeZone: e,\n  era: \"short\",\n  year: \"numeric\",\n  month: \"numeric\",\n  day: \"numeric\",\n  hour: \"numeric\",\n  minute: \"numeric\",\n  second: \"numeric\"\n}))), Ua = /^(AC|AE|AG|AR|AS|BE|BS|CA|CN|CS|CT|EA|EC|IE|IS|JS|MI|NE|NS|PL|PN|PR|PS|SS|VS)T$/, Aa = /*@__PURE__*/ Jn(createIntlCalendar), La = /*@__PURE__*/ Jn((e => new En(Zi, {\n  calendar: e,\n  timeZone: Ta,\n  era: \"short\",\n  year: \"numeric\",\n  month: \"short\",\n  day: \"numeric\"\n}))), Wa = /^M(\\d{2})(L?)$/, ja = {\n  era: toStringViaPrimitive,\n  eraYear: toInteger,\n  year: toInteger,\n  month: toPositiveInteger,\n  monthCode: toStringViaPrimitive,\n  day: toPositiveInteger\n}, xa = /*@__PURE__*/ jr(w, toInteger), $a = /*@__PURE__*/ jr(F, toStrictInteger), Ga = /*@__PURE__*/ Object.assign({}, ja, xa, $a, {\n  offset: toStringViaPrimitive\n}), Ha = /*@__PURE__*/ E(remapProps, w, j), Va = {\n  dateAdd(e, n, t) {\n    const o = H(t);\n    let r, {years: i, months: a, weeks: s, days: c} = n;\n    if (c += durationFieldsToBigNano(n, 5)[0], i || a) {\n      r = ((e, n, t, o, r) => {\n        let [i, a, s] = e.h(n);\n        if (t) {\n          const [n, o] = e.I(i, a);\n          i += t, a = monthCodeNumberToMonth(n, o, e.U(i)), a = clampEntity(\"month\", a, 1, e.L(i), r);\n        }\n        return o && ([i, a] = e._(i, a, o)), s = clampEntity(\"day\", s, 1, e.j(i, a), r), \n        e.q(i, a, s);\n      })(this, e, i, a, o);\n    } else {\n      if (!s && !c) {\n        return e;\n      }\n      r = isoToEpochMilli(e);\n    }\n    return r += (7 * s + c) * Gr, checkIsoDateInBounds(epochMilliToIso(r));\n  },\n  dateUntil(e, n, t) {\n    if (t <= 7) {\n      let o = 0, r = diffDays({\n        ...e,\n        ...Dt\n      }, {\n        ...n,\n        ...Dt\n      });\n      return 7 === t && ([o, r] = divModTrunc(r, 7)), {\n        ...Si,\n        weeks: o,\n        days: r\n      };\n    }\n    const o = this.h(e), r = this.h(n);\n    let [i, a, s] = ((e, n, t, o, r, i, a) => {\n      let s = r - n, c = i - t, u = a - o;\n      if (s || c) {\n        const l = Math.sign(s || c);\n        let f = e.j(r, i), d = 0;\n        if (Math.sign(u) === -l) {\n          const o = f;\n          [r, i] = e._(r, i, -l), s = r - n, c = i - t, f = e.j(r, i), d = l < 0 ? -o : f;\n        }\n        if (u = a - Math.min(o, f) + d, s) {\n          const [o, a] = e.I(n, t), [u, f] = e.I(r, i);\n          if (c = u - o || Number(f) - Number(a), Math.sign(c) === -l) {\n            const t = l < 0 && -e.L(r);\n            s = (r -= l) - n, c = i - monthCodeNumberToMonth(o, a, e.U(r)) + (t || e.L(r));\n          }\n        }\n      }\n      return [ s, c, u ];\n    })(this, ...o, ...r);\n    return 8 === t && (a += this.J(i, o[0]), i = 0), {\n      ...Si,\n      years: i,\n      months: a,\n      days: s\n    };\n  },\n  dateFromFields(e, n) {\n    const t = H(n), o = refineYear(this, e), r = refineMonth(this, e, o, t), i = refineDay(this, e, r, o, t);\n    return v(checkIsoDateInBounds(this.P(o, r, i)), this.id || X);\n  },\n  yearMonthFromFields(e, n) {\n    const t = H(n), o = refineYear(this, e), r = refineMonth(this, e, o, t);\n    return createPlainYearMonthSlots(checkIsoYearMonthInBounds(this.P(o, r, 1)), this.id || X);\n  },\n  monthDayFromFields(e, n) {\n    const t = H(n), o = !this.id, {monthCode: r, year: i, month: a} = e;\n    let s, c, u, l, f;\n    if (void 0 !== r) {\n      [s, c] = parseMonthCode(r), f = getDefinedProp(e, \"day\");\n      const n = this.N(s, c, f);\n      if (!n) {\n        throw new RangeError(yr);\n      }\n      if ([u, l] = n, void 0 !== a && a !== l) {\n        throw new RangeError(Mr);\n      }\n      o && (l = clampEntity(\"month\", l, 1, xi, 1), f = clampEntity(\"day\", f, 1, computeIsoDaysInMonth(void 0 !== i ? i : u, l), t));\n    } else {\n      u = void 0 === i && o ? ji : refineYear(this, e), l = refineMonth(this, e, u, t), \n      f = refineDay(this, e, l, u, t);\n      const n = this.U(u);\n      c = l === n, s = monthToMonthCodeNumber(l, n);\n      const r = this.N(s, c, f);\n      if (!r) {\n        throw new RangeError(yr);\n      }\n      [u, l] = r;\n    }\n    return createPlainMonthDaySlots(checkIsoDateInBounds(this.P(u, l, f)), this.id || X);\n  },\n  fields(e) {\n    return getCalendarEraOrigins(this) && e.includes(\"year\") ? [ ...e, ...ii ] : e;\n  },\n  mergeFields(e, n) {\n    const t = Object.assign(Object.create(null), e);\n    return spliceFields(t, n, ui), getCalendarEraOrigins(this) && (spliceFields(t, n, ai), \n    this.id === Ti && spliceFields(t, n, mi, ii)), t;\n  },\n  inLeapYear(e) {\n    const [n] = this.h(e);\n    return this.K(n);\n  },\n  monthsInYear(e) {\n    const [n] = this.h(e);\n    return this.L(n);\n  },\n  daysInMonth(e) {\n    const [n, t] = this.h(e);\n    return this.j(n, t);\n  },\n  daysInYear(e) {\n    const [n] = this.h(e);\n    return this.X(n);\n  },\n  dayOfYear: computeNativeDayOfYear,\n  era(e) {\n    return this.ee(e)[0];\n  },\n  eraYear(e) {\n    return this.ee(e)[1];\n  },\n  monthCode(e) {\n    const [n, t] = this.h(e), [o, r] = this.I(n, t);\n    return ((e, n) => \"M\" + xr(e) + (n ? \"L\" : \"\"))(o, r);\n  },\n  dayOfWeek: computeIsoDayOfWeek,\n  daysInWeek() {\n    return 7;\n  }\n}, _a = {\n  dayOfYear: computeNativeDayOfYear,\n  h: computeIsoDateParts,\n  q: isoArgsToEpochMilli\n}, Ja = /*@__PURE__*/ Object.assign({}, _a, {\n  weekOfYear: computeNativeWeekOfYear,\n  yearOfWeek: computeNativeYearOfWeek,\n  R(e) {\n    function computeWeekShift(e) {\n      return (7 - e < n ? 7 : 0) - e;\n    }\n    function computeWeeksInYear(e) {\n      const n = computeIsoDaysInYear(l + e), t = e || 1, o = computeWeekShift(modFloor(a + n * t, 7));\n      return c = (n + (o - s) * t) / 7;\n    }\n    const n = this.id ? 1 : 4, t = computeIsoDayOfWeek(e), o = this.dayOfYear(e), r = modFloor(t - 1, 7), i = o - 1, a = modFloor(r - i, 7), s = computeWeekShift(a);\n    let c, u = Math.floor((i - s) / 7) + 1, l = e.isoYear;\n    return u ? u > computeWeeksInYear(0) && (u = 1, l++) : (u = computeWeeksInYear(-1), \n    l--), [ u, l, c ];\n  }\n}), Ka = {\n  dayOfYear: computeNativeDayOfYear,\n  h: computeIntlDateParts,\n  q: computeIntlEpochMilli,\n  weekOfYear: computeNativeWeekOfYear,\n  yearOfWeek: computeNativeYearOfWeek,\n  R() {\n    return [];\n  }\n}, Y = /*@__PURE__*/ createNativeOpsCreator(/*@__PURE__*/ Object.assign({}, Va, Ja, {\n  h: computeIsoDateParts,\n  ee(e) {\n    return this.id === gi ? computeGregoryEraParts(e) : this.id === Ti ? Gi(e) : [];\n  },\n  I: (e, n) => [ n, 0 ],\n  N(e, n) {\n    if (!n) {\n      return [ ji, e ];\n    }\n  },\n  K: computeIsoInLeapYear,\n  U() {},\n  L: computeIsoMonthsInYear,\n  J: e => e * xi,\n  j: computeIsoDaysInMonth,\n  X: computeIsoDaysInYear,\n  P: (e, n, t) => ({\n    isoYear: e,\n    isoMonth: n,\n    isoDay: t\n  }),\n  q: isoArgsToEpochMilli,\n  _: (e, n, t) => (e += divTrunc(t, xi), (n += modTrunc(t, xi)) < 1 ? (e--, n += xi) : n > xi && (e++, \n  n -= xi), [ e, n ]),\n  year(e) {\n    return e.isoYear;\n  },\n  month(e) {\n    return e.isoMonth;\n  },\n  day: e => e.isoDay\n}), /*@__PURE__*/ Object.assign({}, Va, Ka, {\n  h: computeIntlDateParts,\n  ee(e) {\n    const n = this.O(e);\n    return [ n.era, n.eraYear ];\n  },\n  I(e, n) {\n    const t = computeIntlLeapMonth.call(this, e);\n    return [ monthToMonthCodeNumber(n, t), t === n ];\n  },\n  N(e, n, t) {\n    let [o, r, i] = computeIntlDateParts.call(this, {\n      isoYear: ji,\n      isoMonth: xi,\n      isoDay: 31\n    });\n    const a = computeIntlLeapMonth.call(this, o), s = r === a;\n    1 === (compareNumbers(e, monthToMonthCodeNumber(r, a)) || compareNumbers(Number(n), Number(s)) || compareNumbers(t, i)) && o--;\n    for (let r = 0; r < 100; r++) {\n      const i = o - r, a = computeIntlLeapMonth.call(this, i), s = monthCodeNumberToMonth(e, n, a);\n      if (n === (s === a) && t <= computeIntlDaysInMonth.call(this, i, s)) {\n        return [ i, s ];\n      }\n    }\n  },\n  K(e) {\n    const n = computeIntlDaysInYear.call(this, e);\n    return n > computeIntlDaysInYear.call(this, e - 1) && n > computeIntlDaysInYear.call(this, e + 1);\n  },\n  U: computeIntlLeapMonth,\n  L: computeIntlMonthsInYear,\n  J(e, n) {\n    const t = n + e, o = Math.sign(e), r = o < 0 ? -1 : 0;\n    let i = 0;\n    for (let e = n; e !== t; e += o) {\n      i += computeIntlMonthsInYear.call(this, e + r);\n    }\n    return i;\n  },\n  j: computeIntlDaysInMonth,\n  X: computeIntlDaysInYear,\n  P(e, n, t) {\n    return epochMilliToIso(computeIntlEpochMilli.call(this, e, n, t));\n  },\n  q: computeIntlEpochMilli,\n  _(e, n, t) {\n    if (t) {\n      if (n += t, !Number.isSafeInteger(n)) {\n        throw new RangeError(Cr);\n      }\n      if (t < 0) {\n        for (;n < 1; ) {\n          n += computeIntlMonthsInYear.call(this, --e);\n        }\n      } else {\n        let t;\n        for (;n > (t = computeIntlMonthsInYear.call(this, e)); ) {\n          n -= t, e++;\n        }\n      }\n    }\n    return [ e, n ];\n  },\n  year(e) {\n    return this.O(e).year;\n  },\n  month(e) {\n    const {year: n, F: t} = this.O(e), {C: o} = this.B(n);\n    return o[t] + 1;\n  },\n  day(e) {\n    return this.O(e).day;\n  }\n})), Qa = \"numeric\", Xa = [ \"timeZoneName\" ], es = {\n  month: Qa,\n  day: Qa\n}, ns = {\n  year: Qa,\n  month: Qa\n}, ts = /*@__PURE__*/ Object.assign({}, ns, {\n  day: Qa\n}), os = {\n  hour: Qa,\n  minute: Qa,\n  second: Qa\n}, rs = /*@__PURE__*/ Object.assign({}, ts, os), is = /*@__PURE__*/ Object.assign({}, rs, {\n  timeZoneName: \"short\"\n}), as = /*@__PURE__*/ Object.keys(ns), ss = /*@__PURE__*/ Object.keys(es), cs = /*@__PURE__*/ Object.keys(ts), us = /*@__PURE__*/ Object.keys(os), ls = [ \"dateStyle\" ], fs = /*@__PURE__*/ as.concat(ls), ds = /*@__PURE__*/ ss.concat(ls), ms = /*@__PURE__*/ cs.concat(ls, [ \"weekday\" ]), ps = /*@__PURE__*/ us.concat([ \"dayPeriod\", \"timeStyle\" ]), hs = /*@__PURE__*/ ms.concat(ps), gs = /*@__PURE__*/ hs.concat(Xa), Ts = /*@__PURE__*/ Xa.concat(ps), Ds = /*@__PURE__*/ Xa.concat(ms), Is = /*@__PURE__*/ Xa.concat([ \"day\", \"weekday\" ], ps), Ms = /*@__PURE__*/ Xa.concat([ \"year\", \"weekday\" ], ps), Ns = {}, t = [ /*@__PURE__*/ createOptionsTransformer(hs, rs), y ], s = [ /*@__PURE__*/ createOptionsTransformer(gs, is), y, 0, (e, n) => {\n  const t = I(e.timeZone);\n  if (n && I(n.timeZone) !== t) {\n    throw new RangeError(Fr);\n  }\n  return t;\n} ], n = [ /*@__PURE__*/ createOptionsTransformer(hs, rs, Xa), isoToEpochMilli ], o = [ /*@__PURE__*/ createOptionsTransformer(ms, ts, Ts), isoToEpochMilli ], r = [ /*@__PURE__*/ createOptionsTransformer(ps, os, Ds), e => isoTimeFieldsToNano(e) / be ], a = [ /*@__PURE__*/ createOptionsTransformer(fs, ns, Is), isoToEpochMilli, 1 ], i = [ /*@__PURE__*/ createOptionsTransformer(ds, es, Ms), isoToEpochMilli, 1 ];\n\nlet ys;\n\nexport { qt as DurationBranding, Oe as InstantBranding, J as PlainDateBranding, We as PlainDateTimeBranding, q as PlainMonthDayBranding, xe as PlainTimeBranding, L as PlainYearMonthBranding, En as RawDateTimeFormat, Te as ZonedDateTimeBranding, Rt as absDuration, Wt as addDurations, oe as bigNanoToNumber, E as bindArgs, mn as buildZonedIsoFields, te as compareBigNanos, $t as compareDurations, Ze as compareInstants, rt as compareIsoDateFields, gt as compareIsoDateTimeFields, He as compareIsoTimeFields, yn as compareZonedDateTimes, dn as computeZonedHoursInDay, Cn as computeZonedStartOfDay, Lt as constructDurationSlots, Se as constructInstantSlots, Nt as constructPlainDateSlots, pt as constructPlainDateTimeSlots, G as constructPlainMonthDaySlots, ke as constructPlainTimeSlots, tt as constructPlainYearMonthSlots, vn as constructZonedDateTimeSlots, U as copyOptions, Vt as createDurationSlots, qn as createFormatForPrep, e as createFormatPrepper, O as createGetterDescriptors, _ as createInstantSlots, D as createNameDescriptors, Y as createNativeStandardOps, v as createPlainDateSlots, ee as createPlainDateTimeSlots, Ge as createPlainTimeSlots, p as createPropDescriptors, h as createStringTagDescriptors, Yn as createZonedDateTimeSlots, o as dateConfig, en as dateFieldNamesAlpha, n as dateTimeConfig, re as diffBigNanos, le as diffInstants, ut as diffPlainDateTimes, Ft as diffPlainDates, Ae as diffPlainTimes, Xe as diffPlainYearMonth, Dn as diffZonedDateTimes, F as durationFieldNamesAsc, kt as durationWithFields, Ce as epochMicroToInstant, Pe as epochMilliToInstant, ge as epochNanoToInstant, Ie as epochNanoToIso, De as epochSecToInstant, V as excludePropsByName, nn as excludeUndefinedProps, tn as forbiddenField, A as forbiddenValueOf, zt as formatDurationIso, me as formatInstantIso, Fe as formatOffsetNano, yt as formatPlainDateIso, Tt as formatPlainDateTimeIso, W as formatPlainMonthDayIso, qe as formatPlainTimeIso, et as formatPlainYearMonthIso, In as formatZonedDateTimeIso, Bn as getCurrentEpochNano, An as getCurrentIsoDateTime, Nn as getCurrentTimeZoneId, Jt as getDurationBlank, N as getEpochMicro, y as getEpochMilli, B as getEpochNano, M as getEpochSec, I as getId, ln as getRequiredDateFields, cn as getRequiredMonthDayFields, un as getRequiredYearMonthFields, we as getSingleInstantFor, C as hasAllPropsByName, t as instantConfig, fe as instantToZonedDateTime, ue as instantsEqual, Z as invalidBag, P as invalidCallingContext, Ln as invalidFormatType, g as invalidProtocol, z as isObjectLike, je as isTimeZoneSlotsEqual, X as isoCalendarId, Dt as isoTimeFieldDefaults, j as isoTimeFieldNamesAsc, b as mapPropNames, T as mapProps, Jn as memoize, kn as mismatchingFormatTypes, i as monthDayConfig, se as moveInstant, bt as movePlainDate, ct as movePlainDateTime, Ye as movePlainTime, Qe as movePlainYearMonth, hn as moveZonedDateTime, be as nanoInMilli, xt as negateDuration, he as numberToBigNano, sn as parseCalendarId, Kt as parseDuration, pe as parseInstant, At as parsePlainDate, Ct as parsePlainDateTime, Q as parsePlainMonthDay, ze as parsePlainTime, ot as parsePlainYearMonth, Xt as parseRelativeToSlots, Ne as parseTimeZoneId, Mn as parseZonedDateTime, Ot as plainDateTimeToPlainMonthDay, St as plainDateTimeToPlainYearMonth, mt as plainDateTimeToZonedDateTime, at as plainDateTimeWithFields, st as plainDateTimeWithPlainDate, lt as plainDateTimeWithPlainTime, ft as plainDateTimesEqual, wt as plainDateToPlainDateTime, Mt as plainDateToPlainMonthDay, jt as plainDateToPlainYearMonth, vt as plainDateToZonedDateTime, Zt as plainDateWithFields, It as plainDatesEqual, R as plainMonthDayToPlainDate, k as plainMonthDayWithFields, x as plainMonthDaysEqual, Le as plainTimeToPlainDateTime, Je as plainTimeToZonedDateTime, Be as plainTimeWithFields, Ve as plainTimesEqual, _e as plainYearMonthToPlainDate, Ke as plainYearMonthWithFields, $e as plainYearMonthsEqual, Vn as pluckProps, ie as queryNativeTimeZone, rn as refineCalendarId, _t as refineDateDiffOptions, Ht as refineDurationBag, ve as refineEpochDisambigOptions, Qt as refineMaybeZonedDateTimeBag, H as refineOverflowOptions, Yt as refinePlainDateBag, Pt as refinePlainDateTimeBag, K as refinePlainMonthDayBag, Ue as refinePlainTimeBag, nt as refinePlainYearMonthBag, Me as refineTimeZoneId, jn as refineZonedDateTimeBag, wn as refineZonedFieldOptions, f as requireBoolean, $ as requireFunction, u as requireInteger, c as requireIntegerOrUndefined, on as requireNonNullish, de as requireObjectLike, d as requirePositiveInteger, S as requirePositiveIntegerOrUndefined, m as requireString, l as requireStringOrUndefined, an as resolveCalendarId, ye as resolveTimeZoneId, Gt as roundDuration, ce as roundInstant, dt as roundPlainDateTime, Ee as roundPlainTime, Pn as roundZonedDateTime, it as slotsWithCalendar, On as slotsWithTimeZone, r as timeConfig, w as timeFieldNamesAsc, Ut as totalDuration, Et as unitNamesAsc, ne as validateTimeZoneGap, ae as validateTimeZoneOffset, a as yearMonthConfig, s as zonedConfig, Zn as zonedDateTimeToInstant, Bt as zonedDateTimeToPlainDate, ht as zonedDateTimeToPlainDateTime, Fn as zonedDateTimeToPlainMonthDay, Re as zonedDateTimeToPlainTime, bn as zonedDateTimeToPlainYearMonth, Sn as zonedDateTimeWithFields, Tn as zonedDateTimeWithPlainDate, pn as zonedDateTimeWithPlainTime, gn as zonedDateTimesEqual, fn as zonedEpochSlotsToIso };\n","function createSlotClass(e, t, n, o, r) {\n  function Class(...e) {\n    if (!(this instanceof Class)) {\n      throw new TypeError(P);\n    }\n    oo(this, t(...e));\n  }\n  function bindMethod(e, t) {\n    return Object.defineProperties((function(...t) {\n      return e.call(this, getSpecificSlots(this), ...t);\n    }), D(t));\n  }\n  function getSpecificSlots(t) {\n    const n = no(t);\n    if (!n || n.branding !== e) {\n      throw new TypeError(P);\n    }\n    return n;\n  }\n  return Object.defineProperties(Class.prototype, {\n    ...O(T(bindMethod, n)),\n    ...p(T(bindMethod, o)),\n    ...h(\"Temporal.\" + e)\n  }), Object.defineProperties(Class, {\n    ...p(r),\n    ...D(e)\n  }), [ Class, e => {\n    const t = Object.create(Class.prototype);\n    return oo(t, e), t;\n  }, getSpecificSlots ];\n}\n\nfunction createProtocolValidator(e) {\n  return e = e.concat(\"id\").sort(), t => {\n    if (!C(t, e)) {\n      throw new TypeError(g);\n    }\n    return t;\n  };\n}\n\nfunction rejectInvalidBag(e) {\n  if (no(e) || void 0 !== e.calendar || void 0 !== e.timeZone) {\n    throw new TypeError(Z);\n  }\n  return e;\n}\n\nfunction createCalendarFieldMethods(e, t) {\n  const n = {};\n  for (const o in e) {\n    n[o] = ({o: e}, n) => {\n      const r = no(n) || {}, {branding: a} = r, i = a === J || t.includes(a) ? r : toPlainDateSlots(n);\n      return e[o](i);\n    };\n  }\n  return n;\n}\n\nfunction createCalendarGetters(e) {\n  const t = {};\n  for (const n in e) {\n    t[n] = e => {\n      const {calendar: t} = e;\n      return (o = t, \"string\" == typeof o ? Y(o) : (r = o, Object.assign(Object.create(co), {\n        i: r\n      })))[n](e);\n      var o, r;\n    };\n  }\n  return t;\n}\n\nfunction neverValueOf() {\n  throw new TypeError(A);\n}\n\nfunction createCalendarFromSlots({calendar: e}) {\n  return \"string\" == typeof e ? new lr(e) : e;\n}\n\nfunction toPlainMonthDaySlots(e, t) {\n  if (t = U(t), z(e)) {\n    const n = no(e);\n    if (n && n.branding === q) {\n      return H(t), n;\n    }\n    const o = extractCalendarSlotFromBag(e);\n    return K(Qo(o || X), !o, e, t);\n  }\n  const n = Q(Y, e);\n  return H(t), n;\n}\n\nfunction getOffsetNanosecondsForAdapter(e, t, n) {\n  return o = t.call(e, Co(_(n))), ae(u(o));\n  var o;\n}\n\nfunction createAdapterOps(e, t = ho) {\n  const n = Object.keys(t).sort(), o = {};\n  for (const r of n) {\n    o[r] = E(t[r], e, $(e[r]));\n  }\n  return o;\n}\n\nfunction createTimeZoneOps(e, t) {\n  return \"string\" == typeof e ? ie(e) : createAdapterOps(e, t);\n}\n\nfunction createTimeZoneOffsetOps(e) {\n  return createTimeZoneOps(e, Do);\n}\n\nfunction toInstantSlots(e) {\n  if (z(e)) {\n    const t = no(e);\n    if (t) {\n      switch (t.branding) {\n       case Oe:\n        return t;\n\n       case Te:\n        return _(t.epochNanoseconds);\n      }\n    }\n  }\n  return pe(e);\n}\n\nfunction toTemporalInstant() {\n  return Co(_(he(this.valueOf(), be)));\n}\n\nfunction getImplTransition(e, t, n) {\n  const o = t.l(toInstantSlots(n).epochNanoseconds, e);\n  return o ? Co(_(o)) : null;\n}\n\nfunction refineTimeZoneSlot(e) {\n  return z(e) ? (no(e) || {}).timeZone || Fo(e) : (e => ye(Ne(m(e))))(e);\n}\n\nfunction toPlainTimeSlots(e, t) {\n  if (z(e)) {\n    const n = no(e) || {};\n    switch (n.branding) {\n     case xe:\n      return H(t), n;\n\n     case We:\n      return H(t), Ge(n);\n\n     case Te:\n      return H(t), Re(createTimeZoneOffsetOps, n);\n    }\n    return Ue(e, t);\n  }\n  return H(t), ze(e);\n}\n\nfunction optionalToPlainTimeFields(e) {\n  return void 0 === e ? void 0 : toPlainTimeSlots(e);\n}\n\nfunction toPlainYearMonthSlots(e, t) {\n  if (t = U(t), z(e)) {\n    const n = no(e);\n    return n && n.branding === L ? (H(t), n) : nt(Ho(getCalendarSlotFromBag(e)), e, t);\n  }\n  const n = ot(Y, e);\n  return H(t), n;\n}\n\nfunction toPlainDateTimeSlots(e, t) {\n  if (t = U(t), z(e)) {\n    const n = no(e) || {};\n    switch (n.branding) {\n     case We:\n      return H(t), n;\n\n     case J:\n      return H(t), ee({\n        ...n,\n        ...Dt\n      });\n\n     case Te:\n      return H(t), ht(createTimeZoneOffsetOps, n);\n    }\n    return Pt(Ko(getCalendarSlotFromBag(e)), e, t);\n  }\n  const n = Ct(e);\n  return H(t), n;\n}\n\nfunction toPlainDateSlots(e, t) {\n  if (t = U(t), z(e)) {\n    const n = no(e) || {};\n    switch (n.branding) {\n     case J:\n      return H(t), n;\n\n     case We:\n      return H(t), v(n);\n\n     case Te:\n      return H(t), Bt(createTimeZoneOffsetOps, n);\n    }\n    return Yt(Ko(getCalendarSlotFromBag(e)), e, t);\n  }\n  const n = At(e);\n  return H(t), n;\n}\n\nfunction dayAdapter(e, t, n) {\n  return d(t.call(e, Yo(v(n, e))));\n}\n\nfunction createCompoundOpsCreator(e) {\n  return t => \"string\" == typeof t ? Y(t) : ((e, t) => {\n    const n = Object.keys(t).sort(), o = {};\n    for (const r of n) {\n      o[r] = E(t[r], e, e[r]);\n    }\n    return o;\n  })(t, e);\n}\n\nfunction toDurationSlots(e) {\n  if (z(e)) {\n    const t = no(e);\n    return t && t.branding === qt ? t : Ht(e);\n  }\n  return Kt(e);\n}\n\nfunction refinePublicRelativeTo(e) {\n  if (void 0 !== e) {\n    if (z(e)) {\n      const t = no(e) || {};\n      switch (t.branding) {\n       case Te:\n       case J:\n        return t;\n\n       case We:\n        return v(t);\n      }\n      const n = getCalendarSlotFromBag(e);\n      return {\n        ...Qt(refineTimeZoneSlot, createTimeZoneOps, Ko(n), e),\n        calendar: n\n      };\n    }\n    return Xt(e);\n  }\n}\n\nfunction getCalendarSlotFromBag(e) {\n  return extractCalendarSlotFromBag(e) || X;\n}\n\nfunction extractCalendarSlotFromBag(e) {\n  const {calendar: t} = e;\n  if (void 0 !== t) {\n    return refineCalendarSlot(t);\n  }\n}\n\nfunction refineCalendarSlot(e) {\n  return z(e) ? (no(e) || {}).calendar || cr(e) : (e => an(sn(m(e))))(e);\n}\n\nfunction toZonedDateTimeSlots(e, t) {\n  if (t = U(t), z(e)) {\n    const n = no(e);\n    if (n && n.branding === Te) {\n      return wn(t), n;\n    }\n    const o = getCalendarSlotFromBag(e);\n    return jn(refineTimeZoneSlot, createTimeZoneOps, Ko(o), o, e, t);\n  }\n  return Mn(e, t);\n}\n\nfunction adaptDateMethods(e) {\n  return T((e => t => e(slotsToIso(t))), e);\n}\n\nfunction slotsToIso(e) {\n  return fn(e, createTimeZoneOffsetOps);\n}\n\nfunction createDateTimeFormatClass() {\n  const e = En.prototype, t = Object.getOwnPropertyDescriptors(e), n = Object.getOwnPropertyDescriptors(En), DateTimeFormat = function(e, t = {}) {\n    if (!(this instanceof DateTimeFormat)) {\n      return new DateTimeFormat(e, t);\n    }\n    Or.set(this, ((e, t = {}) => {\n      const n = new En(e, t), o = n.resolvedOptions(), r = o.locale, a = Vn(Object.keys(t), o), i = Jn(createFormatPrepperForBranding), prepFormat = (...e) => {\n        let t;\n        const o = e.map(((e, n) => {\n          const o = no(e), r = (o || {}).branding;\n          if (n && t && t !== r) {\n            throw new TypeError(kn);\n          }\n          return t = r, o;\n        }));\n        return t ? i(t)(r, a, ...o) : [ n, ...e ];\n      };\n      return prepFormat.u = n, prepFormat;\n    })(e, t));\n  };\n  for (const e in t) {\n    const n = t[e], o = e.startsWith(\"format\") && createFormatMethod(e);\n    \"function\" == typeof n.value ? n.value = \"constructor\" === e ? DateTimeFormat : o || createProxiedMethod(e) : o && (n.get = function() {\n      return o.bind(this);\n    });\n  }\n  return n.prototype.value = Object.create(e, t), Object.defineProperties(DateTimeFormat, n), \n  DateTimeFormat;\n}\n\nfunction createFormatMethod(e) {\n  return function(...t) {\n    const n = Or.get(this), [o, ...r] = n(...t);\n    return o[e](...r);\n  };\n}\n\nfunction createProxiedMethod(e) {\n  return function(...t) {\n    return Or.get(this).u[e](...t);\n  };\n}\n\nfunction createFormatPrepperForBranding(t) {\n  const n = xn[t];\n  if (!n) {\n    throw new TypeError(Ln(t));\n  }\n  return e(n, Jn(qn));\n}\n\nimport { createFormatPrepper as e, instantConfig as t, dateTimeConfig as n, dateConfig as o, timeConfig as r, yearMonthConfig as a, monthDayConfig as i, zonedConfig as s, requireStringOrUndefined as l, requireIntegerOrUndefined as c, requireInteger as u, requirePositiveInteger as d, requireBoolean as f, requireString as m, requirePositiveIntegerOrUndefined as S, createGetterDescriptors as O, mapProps as T, createPropDescriptors as p, createStringTagDescriptors as h, createNameDescriptors as D, invalidCallingContext as P, hasAllPropsByName as C, invalidProtocol as g, invalidBag as Z, mapPropNames as b, durationFieldNamesAsc as F, getId as I, createPlainDateSlots as v, timeFieldNamesAsc as w, isoTimeFieldNamesAsc as j, getEpochSec as M, getEpochMilli as y, getEpochMicro as N, getEpochNano as B, createNativeStandardOps as Y, forbiddenValueOf as A, bindArgs as E, excludePropsByName as V, PlainDateBranding as J, PlainYearMonthBranding as L, PlainMonthDayBranding as q, plainMonthDayWithFields as k, plainMonthDaysEqual as x, plainMonthDayToPlainDate as R, formatPlainMonthDayIso as W, constructPlainMonthDaySlots as G, copyOptions as U, isObjectLike as z, refineOverflowOptions as H, refinePlainMonthDayBag as K, parsePlainMonthDay as Q, isoCalendarId as X, requireFunction as $, createInstantSlots as _, createPlainDateTimeSlots as ee, compareBigNanos as te, validateTimeZoneGap as ne, bigNanoToNumber as oe, diffBigNanos as re, validateTimeZoneOffset as ae, queryNativeTimeZone as ie, moveInstant as se, diffInstants as le, roundInstant as ce, instantsEqual as ue, requireObjectLike as de, instantToZonedDateTime as fe, formatInstantIso as me, constructInstantSlots as Se, InstantBranding as Oe, ZonedDateTimeBranding as Te, parseInstant as pe, numberToBigNano as he, epochSecToInstant as De, epochMilliToInstant as Pe, epochMicroToInstant as Ce, epochNanoToInstant as ge, compareInstants as Ze, nanoInMilli as be, formatOffsetNano as Fe, epochNanoToIso as Ie, refineEpochDisambigOptions as ve, getSingleInstantFor as we, isTimeZoneSlotsEqual as je, refineTimeZoneId as Me, resolveTimeZoneId as ye, parseTimeZoneId as Ne, plainTimeWithFields as Be, movePlainTime as Ye, diffPlainTimes as Ae, roundPlainTime as Ee, plainTimesEqual as Ve, plainTimeToZonedDateTime as Je, plainTimeToPlainDateTime as Le, formatPlainTimeIso as qe, constructPlainTimeSlots as ke, PlainTimeBranding as xe, zonedDateTimeToPlainTime as Re, PlainDateTimeBranding as We, createPlainTimeSlots as Ge, refinePlainTimeBag as Ue, parsePlainTime as ze, compareIsoTimeFields as He, plainYearMonthWithFields as Ke, movePlainYearMonth as Qe, diffPlainYearMonth as Xe, plainYearMonthsEqual as $e, plainYearMonthToPlainDate as _e, formatPlainYearMonthIso as et, constructPlainYearMonthSlots as tt, refinePlainYearMonthBag as nt, parsePlainYearMonth as ot, compareIsoDateFields as rt, plainDateTimeWithFields as at, slotsWithCalendar as it, plainDateTimeWithPlainDate as st, plainDateTimeWithPlainTime as lt, movePlainDateTime as ct, diffPlainDateTimes as ut, roundPlainDateTime as dt, plainDateTimesEqual as ft, plainDateTimeToZonedDateTime as mt, plainDateTimeToPlainYearMonth as St, plainDateTimeToPlainMonthDay as Ot, formatPlainDateTimeIso as Tt, constructPlainDateTimeSlots as pt, zonedDateTimeToPlainDateTime as ht, isoTimeFieldDefaults as Dt, refinePlainDateTimeBag as Pt, parsePlainDateTime as Ct, compareIsoDateTimeFields as gt, plainDateWithFields as Zt, movePlainDate as bt, diffPlainDates as Ft, plainDatesEqual as It, plainDateToZonedDateTime as vt, plainDateToPlainDateTime as wt, plainDateToPlainYearMonth as jt, plainDateToPlainMonthDay as Mt, formatPlainDateIso as yt, constructPlainDateSlots as Nt, zonedDateTimeToPlainDate as Bt, refinePlainDateBag as Yt, parsePlainDate as At, unitNamesAsc as Et, createDurationSlots as Vt, getDurationBlank as Jt, constructDurationSlots as Lt, DurationBranding as qt, durationWithFields as kt, negateDuration as xt, absDuration as Rt, addDurations as Wt, roundDuration as Gt, totalDuration as Ut, formatDurationIso as zt, refineDurationBag as Ht, parseDuration as Kt, refineMaybeZonedDateTimeBag as Qt, parseRelativeToSlots as Xt, compareDurations as $t, refineDateDiffOptions as _t, dateFieldNamesAlpha as en, forbiddenField as tn, excludeUndefinedProps as nn, requireNonNullish as on, refineCalendarId as rn, resolveCalendarId as an, parseCalendarId as sn, getRequiredDateFields as ln, getRequiredMonthDayFields as cn, getRequiredYearMonthFields as un, computeZonedHoursInDay as dn, zonedEpochSlotsToIso as fn, buildZonedIsoFields as mn, zonedDateTimeWithFields as Sn, slotsWithTimeZone as On, zonedDateTimeWithPlainDate as Tn, zonedDateTimeWithPlainTime as pn, moveZonedDateTime as hn, diffZonedDateTimes as Dn, roundZonedDateTime as Pn, computeZonedStartOfDay as Cn, zonedDateTimesEqual as gn, zonedDateTimeToInstant as Zn, zonedDateTimeToPlainYearMonth as bn, zonedDateTimeToPlainMonthDay as Fn, formatZonedDateTimeIso as In, constructZonedDateTimeSlots as vn, refineZonedFieldOptions as wn, refineZonedDateTimeBag as jn, parseZonedDateTime as Mn, compareZonedDateTimes as yn, getCurrentTimeZoneId as Nn, getCurrentEpochNano as Bn, createZonedDateTimeSlots as Yn, getCurrentIsoDateTime as An, RawDateTimeFormat as En, pluckProps as Vn, memoize as Jn, invalidFormatType as Ln, createFormatForPrep as qn, mismatchingFormatTypes as kn } from \"./internal.js\";\n\nconst xn = {\n  Instant: t,\n  PlainDateTime: n,\n  PlainDate: o,\n  PlainTime: r,\n  PlainYearMonth: a,\n  PlainMonthDay: i\n}, Rn = /*@__PURE__*/ e(t), Wn = /*@__PURE__*/ e(s), Gn = /*@__PURE__*/ e(n), Un = /*@__PURE__*/ e(o), zn = /*@__PURE__*/ e(r), Hn = /*@__PURE__*/ e(a), Kn = /*@__PURE__*/ e(i), Qn = {\n  era: l,\n  eraYear: c,\n  year: u,\n  month: d,\n  daysInMonth: d,\n  daysInYear: d,\n  inLeapYear: f,\n  monthsInYear: d\n}, Xn = {\n  monthCode: m\n}, $n = {\n  day: d\n}, _n = {\n  dayOfWeek: d,\n  dayOfYear: d,\n  weekOfYear: S,\n  yearOfWeek: c,\n  daysInWeek: d\n}, eo = /*@__PURE__*/ Object.assign({}, Qn, Xn, $n, _n), to = /*@__PURE__*/ new WeakMap, no = /*@__PURE__*/ to.get.bind(to), oo = /*@__PURE__*/ to.set.bind(to), ro = {\n  ...createCalendarFieldMethods(Qn, [ L ]),\n  ...createCalendarFieldMethods(_n, []),\n  ...createCalendarFieldMethods(Xn, [ L, q ]),\n  ...createCalendarFieldMethods($n, [ q ])\n}, ao = /*@__PURE__*/ createCalendarGetters(eo), io = /*@__PURE__*/ createCalendarGetters({\n  ...Qn,\n  ...Xn\n}), so = /*@__PURE__*/ createCalendarGetters({\n  ...Xn,\n  ...$n\n}), lo = {\n  calendarId: e => I(e.calendar)\n}, co = /*@__PURE__*/ T(((e, t) => function(n) {\n  const {i: o} = this;\n  return e(o[t](Yo(v(n, o))));\n}), eo), uo = /*@__PURE__*/ b((e => t => t[e]), F.concat(\"sign\")), fo = /*@__PURE__*/ b(((e, t) => e => e[j[t]]), w), mo = {\n  epochSeconds: M,\n  epochMilliseconds: y,\n  epochMicroseconds: N,\n  epochNanoseconds: B\n}, So = /*@__PURE__*/ E(V, new Set([ \"branding\" ])), [Oo, To, po] = createSlotClass(q, E(G, refineCalendarSlot), {\n  ...lo,\n  ...so\n}, {\n  getISOFields: So,\n  getCalendar: createCalendarFromSlots,\n  with(e, t, n) {\n    return To(k(_o, e, this, rejectInvalidBag(t), n));\n  },\n  equals: (e, t) => x(e, toPlainMonthDaySlots(t)),\n  toPlainDate(e, t) {\n    return Yo(R($o, e, this, t));\n  },\n  toLocaleString(e, t, n) {\n    const [o, r] = Kn(t, n, e);\n    return o.format(r);\n  },\n  toString: W,\n  toJSON: e => W(e),\n  valueOf: neverValueOf\n}, {\n  from: (e, t) => To(toPlainMonthDaySlots(e, t))\n}), ho = {\n  getOffsetNanosecondsFor: getOffsetNanosecondsForAdapter,\n  getPossibleInstantsFor(e, t, n) {\n    const o = [ ...t.call(e, No(ee(n, X))) ].map((e => go(e).epochNanoseconds)), r = o.length;\n    return r > 1 && (o.sort(te), ne(oe(re(o[0], o[r - 1])))), o;\n  }\n}, Do = {\n  getOffsetNanosecondsFor: getOffsetNanosecondsForAdapter\n}, [Po, Co, go] = createSlotClass(Oe, Se, mo, {\n  add: (e, t) => Co(se(0, e, toDurationSlots(t))),\n  subtract: (e, t) => Co(se(1, e, toDurationSlots(t))),\n  until: (e, t, n) => ar(le(0, e, toInstantSlots(t), n)),\n  since: (e, t, n) => ar(le(1, e, toInstantSlots(t), n)),\n  round: (e, t) => Co(ce(e, t)),\n  equals: (e, t) => ue(e, toInstantSlots(t)),\n  toZonedDateTime(e, t) {\n    const n = de(t);\n    return dr(fe(e, refineTimeZoneSlot(n.timeZone), refineCalendarSlot(n.calendar)));\n  },\n  toZonedDateTimeISO: (e, t) => dr(fe(e, refineTimeZoneSlot(t))),\n  toLocaleString(e, t, n) {\n    const [o, r] = Rn(t, n, e);\n    return o.format(r);\n  },\n  toString: (e, t) => me(refineTimeZoneSlot, createTimeZoneOffsetOps, e, t),\n  toJSON: e => me(refineTimeZoneSlot, createTimeZoneOffsetOps, e),\n  valueOf: neverValueOf\n}, {\n  from: e => Co(toInstantSlots(e)),\n  fromEpochSeconds: e => Co(De(e)),\n  fromEpochMilliseconds: e => Co(Pe(e)),\n  fromEpochMicroseconds: e => Co(Ce(e)),\n  fromEpochNanoseconds: e => Co(ge(e)),\n  compare: (e, t) => Ze(toInstantSlots(e), toInstantSlots(t))\n}), [Zo, bo] = createSlotClass(\"TimeZone\", (e => {\n  const t = Me(e);\n  return {\n    branding: \"TimeZone\",\n    id: t,\n    o: ie(t)\n  };\n}), {\n  id: e => e.id\n}, {\n  getPossibleInstantsFor: ({o: e}, t) => e.getPossibleInstantsFor(toPlainDateTimeSlots(t)).map((e => Co(_(e)))),\n  getOffsetNanosecondsFor: ({o: e}, t) => e.getOffsetNanosecondsFor(toInstantSlots(t).epochNanoseconds),\n  getOffsetStringFor(e, t) {\n    const n = toInstantSlots(t).epochNanoseconds, o = createAdapterOps(this, Do).getOffsetNanosecondsFor(n);\n    return Fe(o);\n  },\n  getPlainDateTimeFor(e, t, n = X) {\n    const o = toInstantSlots(t).epochNanoseconds, r = createAdapterOps(this, Do).getOffsetNanosecondsFor(o);\n    return No(ee(Ie(o, r), refineCalendarSlot(n)));\n  },\n  getInstantFor(e, t, n) {\n    const o = toPlainDateTimeSlots(t), r = ve(n), a = createAdapterOps(this);\n    return Co(_(we(a, o, r)));\n  },\n  getNextTransition: ({o: e}, t) => getImplTransition(1, e, t),\n  getPreviousTransition: ({o: e}, t) => getImplTransition(-1, e, t),\n  equals(e, t) {\n    return !!je(this, refineTimeZoneSlot(t));\n  },\n  toString: e => e.id,\n  toJSON: e => e.id\n}, {\n  from(e) {\n    const t = refineTimeZoneSlot(e);\n    return \"string\" == typeof t ? new Zo(t) : t;\n  }\n}), Fo = /*@__PURE__*/ createProtocolValidator(Object.keys(ho)), [Io, vo] = createSlotClass(xe, ke, fo, {\n  getISOFields: So,\n  with(e, t, n) {\n    return vo(Be(this, rejectInvalidBag(t), n));\n  },\n  add: (e, t) => vo(Ye(0, e, toDurationSlots(t))),\n  subtract: (e, t) => vo(Ye(1, e, toDurationSlots(t))),\n  until: (e, t, n) => ar(Ae(0, e, toPlainTimeSlots(t), n)),\n  since: (e, t, n) => ar(Ae(1, e, toPlainTimeSlots(t), n)),\n  round: (e, t) => vo(Ee(e, t)),\n  equals: (e, t) => Ve(e, toPlainTimeSlots(t)),\n  toZonedDateTime: (e, t) => dr(Je(refineTimeZoneSlot, toPlainDateSlots, createTimeZoneOps, e, t)),\n  toPlainDateTime: (e, t) => No(Le(e, toPlainDateSlots(t))),\n  toLocaleString(e, t, n) {\n    const [o, r] = zn(t, n, e);\n    return o.format(r);\n  },\n  toString: qe,\n  toJSON: e => qe(e),\n  valueOf: neverValueOf\n}, {\n  from: (e, t) => vo(toPlainTimeSlots(e, t)),\n  compare: (e, t) => He(toPlainTimeSlots(e), toPlainTimeSlots(t))\n}), [wo, jo, Mo] = createSlotClass(L, E(tt, refineCalendarSlot), {\n  ...lo,\n  ...io\n}, {\n  getISOFields: So,\n  getCalendar: createCalendarFromSlots,\n  with(e, t, n) {\n    return jo(Ke(Xo, e, this, rejectInvalidBag(t), n));\n  },\n  add: (e, t, n) => jo(Qe(nr, 0, e, toDurationSlots(t), n)),\n  subtract: (e, t, n) => jo(Qe(nr, 1, e, toDurationSlots(t), n)),\n  until: (e, t, n) => ar(Xe(or, 0, e, toPlainYearMonthSlots(t), n)),\n  since: (e, t, n) => ar(Xe(or, 1, e, toPlainYearMonthSlots(t), n)),\n  equals: (e, t) => $e(e, toPlainYearMonthSlots(t)),\n  toPlainDate(e, t) {\n    return Yo(_e($o, e, this, t));\n  },\n  toLocaleString(e, t, n) {\n    const [o, r] = Hn(t, n, e);\n    return o.format(r);\n  },\n  toString: et,\n  toJSON: e => et(e),\n  valueOf: neverValueOf\n}, {\n  from: (e, t) => jo(toPlainYearMonthSlots(e, t)),\n  compare: (e, t) => rt(toPlainYearMonthSlots(e), toPlainYearMonthSlots(t))\n}), [yo, No] = createSlotClass(We, E(pt, refineCalendarSlot), {\n  ...lo,\n  ...ao,\n  ...fo\n}, {\n  getISOFields: So,\n  getCalendar: createCalendarFromSlots,\n  with(e, t, n) {\n    return No(at($o, e, this, rejectInvalidBag(t), n));\n  },\n  withCalendar: (e, t) => No(it(e, refineCalendarSlot(t))),\n  withPlainDate: (e, t) => No(st(e, toPlainDateSlots(t))),\n  withPlainTime: (e, t) => No(lt(e, optionalToPlainTimeFields(t))),\n  add: (e, t, n) => No(ct(er, 0, e, toDurationSlots(t), n)),\n  subtract: (e, t, n) => No(ct(er, 1, e, toDurationSlots(t), n)),\n  until: (e, t, n) => ar(ut(tr, 0, e, toPlainDateTimeSlots(t), n)),\n  since: (e, t, n) => ar(ut(tr, 1, e, toPlainDateTimeSlots(t), n)),\n  round: (e, t) => No(dt(e, t)),\n  equals: (e, t) => ft(e, toPlainDateTimeSlots(t)),\n  toZonedDateTime: (e, t, n) => dr(mt(createTimeZoneOps, e, refineTimeZoneSlot(t), n)),\n  toPlainDate: e => Yo(v(e)),\n  toPlainTime: e => vo(Ge(e)),\n  toPlainYearMonth(e) {\n    return jo(St(Ho, e, this));\n  },\n  toPlainMonthDay(e) {\n    return To(Ot(Qo, e, this));\n  },\n  toLocaleString(e, t, n) {\n    const [o, r] = Gn(t, n, e);\n    return o.format(r);\n  },\n  toString: Tt,\n  toJSON: e => Tt(e),\n  valueOf: neverValueOf\n}, {\n  from: (e, t) => No(toPlainDateTimeSlots(e, t)),\n  compare: (e, t) => gt(toPlainDateTimeSlots(e), toPlainDateTimeSlots(t))\n}), [Bo, Yo, Ao] = createSlotClass(J, E(Nt, refineCalendarSlot), {\n  ...lo,\n  ...ao\n}, {\n  getISOFields: So,\n  getCalendar: createCalendarFromSlots,\n  with(e, t, n) {\n    return Yo(Zt($o, e, this, rejectInvalidBag(t), n));\n  },\n  withCalendar: (e, t) => Yo(it(e, refineCalendarSlot(t))),\n  add: (e, t, n) => Yo(bt(er, 0, e, toDurationSlots(t), n)),\n  subtract: (e, t, n) => Yo(bt(er, 1, e, toDurationSlots(t), n)),\n  until: (e, t, n) => ar(Ft(tr, 0, e, toPlainDateSlots(t), n)),\n  since: (e, t, n) => ar(Ft(tr, 1, e, toPlainDateSlots(t), n)),\n  equals: (e, t) => It(e, toPlainDateSlots(t)),\n  toZonedDateTime(e, t) {\n    const n = !z(t) || t instanceof Zo ? {\n      timeZone: t\n    } : t;\n    return dr(vt(refineTimeZoneSlot, toPlainTimeSlots, createTimeZoneOps, e, n));\n  },\n  toPlainDateTime: (e, t) => No(wt(e, optionalToPlainTimeFields(t))),\n  toPlainYearMonth(e) {\n    return jo(jt(Ho, e, this));\n  },\n  toPlainMonthDay(e) {\n    return To(Mt(Qo, e, this));\n  },\n  toLocaleString(e, t, n) {\n    const [o, r] = Un(t, n, e);\n    return o.format(r);\n  },\n  toString: yt,\n  toJSON: e => yt(e),\n  valueOf: neverValueOf\n}, {\n  from: (e, t) => Yo(toPlainDateSlots(e, t)),\n  compare: (e, t) => rt(toPlainDateSlots(e), toPlainDateSlots(t))\n}), Eo = {\n  fields(e, t, n) {\n    return [ ...t.call(e, n) ];\n  }\n}, Vo = /*@__PURE__*/ Object.assign({\n  dateFromFields(e, t, n, o) {\n    return Ao(t.call(e, Object.assign(Object.create(null), n), o));\n  }\n}, Eo), Jo = /*@__PURE__*/ Object.assign({\n  yearMonthFromFields(e, t, n, o) {\n    return Mo(t.call(e, Object.assign(Object.create(null), n), o));\n  }\n}, Eo), Lo = /*@__PURE__*/ Object.assign({\n  monthDayFromFields(e, t, n, o) {\n    return po(t.call(e, Object.assign(Object.create(null), n), o));\n  }\n}, Eo), qo = {\n  mergeFields(e, t, n, o) {\n    return de(t.call(e, Object.assign(Object.create(null), n), Object.assign(Object.create(null), o)));\n  }\n}, ko = /*@__PURE__*/ Object.assign({}, Vo, qo), xo = /*@__PURE__*/ Object.assign({}, Jo, qo), Ro = /*@__PURE__*/ Object.assign({}, Lo, qo), Wo = {\n  dateAdd(e, t, n, o, r) {\n    return Ao(t.call(e, Yo(v(n, e)), ar(Vt(o)), r));\n  }\n}, Go = /*@__PURE__*/ Object.assign({}, Wo, {\n  dateUntil(e, t, n, o, r, a) {\n    return ir(t.call(e, Yo(v(n, e)), Yo(v(o, e)), Object.assign(Object.create(null), a, {\n      largestUnit: Et[r]\n    })));\n  }\n}), Uo = /*@__PURE__*/ Object.assign({}, Wo, {\n  day: dayAdapter\n}), zo = /*@__PURE__*/ Object.assign({}, Go, {\n  day: dayAdapter\n}), Ho = /*@__PURE__*/ createCompoundOpsCreator(Jo), Ko = /*@__PURE__*/ createCompoundOpsCreator(Vo), Qo = /*@__PURE__*/ createCompoundOpsCreator(Lo), Xo = /*@__PURE__*/ createCompoundOpsCreator(xo), $o = /*@__PURE__*/ createCompoundOpsCreator(ko), _o = /*@__PURE__*/ createCompoundOpsCreator(Ro), er = /*@__PURE__*/ createCompoundOpsCreator(Wo), tr = /*@__PURE__*/ createCompoundOpsCreator(Go), nr = /*@__PURE__*/ createCompoundOpsCreator(Uo), or = /*@__PURE__*/ createCompoundOpsCreator(zo), [rr, ar, ir] = createSlotClass(qt, Lt, {\n  ...uo,\n  blank: Jt\n}, {\n  with: (e, t) => ar(kt(e, t)),\n  negated: e => ar(xt(e)),\n  abs: e => ar(Rt(e)),\n  add: (e, t, n) => ar(Wt(refinePublicRelativeTo, tr, createTimeZoneOps, 0, e, toDurationSlots(t), n)),\n  subtract: (e, t, n) => ar(Wt(refinePublicRelativeTo, tr, createTimeZoneOps, 1, e, toDurationSlots(t), n)),\n  round: (e, t) => ar(Gt(refinePublicRelativeTo, tr, createTimeZoneOps, e, t)),\n  total: (e, t) => Ut(refinePublicRelativeTo, tr, createTimeZoneOps, e, t),\n  toLocaleString(e, t, n) {\n    return Intl.DurationFormat ? new Intl.DurationFormat(t, n).format(this) : zt(e);\n  },\n  toString: zt,\n  toJSON: e => zt(e),\n  valueOf: neverValueOf\n}, {\n  from: e => ar(toDurationSlots(e)),\n  compare: (e, t, n) => $t(refinePublicRelativeTo, er, createTimeZoneOps, toDurationSlots(e), toDurationSlots(t), n)\n}), sr = {\n  toString: e => e.id,\n  toJSON: e => e.id,\n  ...ro,\n  dateAdd: ({id: e, o: t}, n, o, r) => Yo(v(t.dateAdd(toPlainDateSlots(n), toDurationSlots(o), r), e)),\n  dateUntil: ({o: e}, t, n, o) => ar(Vt(e.dateUntil(toPlainDateSlots(t), toPlainDateSlots(n), _t(o)))),\n  dateFromFields: ({id: e, o: t}, n, o) => Yo(Yt(t, n, o, ln(e))),\n  yearMonthFromFields: ({id: e, o: t}, n, o) => jo(nt(t, n, o, un(e))),\n  monthDayFromFields: ({id: e, o: t}, n, o) => To(K(t, 0, n, o, cn(e))),\n  fields({o: e}, t) {\n    const n = new Set(en), o = [];\n    for (const e of t) {\n      if (m(e), !n.has(e)) {\n        throw new RangeError(tn(e));\n      }\n      n.delete(e), o.push(e);\n    }\n    return e.fields(o);\n  },\n  mergeFields: ({o: e}, t, n) => e.mergeFields(nn(on(t)), nn(on(n)))\n}, [lr] = createSlotClass(\"Calendar\", (e => {\n  const t = rn(e);\n  return {\n    branding: \"Calendar\",\n    id: t,\n    o: Y(t)\n  };\n}), {\n  id: e => e.id\n}, sr, {\n  from(e) {\n    const t = refineCalendarSlot(e);\n    return \"string\" == typeof t ? new lr(t) : t;\n  }\n}), cr = /*@__PURE__*/ createProtocolValidator(Object.keys(sr).slice(4)), [ur, dr] = createSlotClass(Te, E(vn, refineCalendarSlot, refineTimeZoneSlot), {\n  ...mo,\n  ...lo,\n  ...adaptDateMethods(ao),\n  ...adaptDateMethods(fo),\n  offset: e => Fe(slotsToIso(e).offsetNanoseconds),\n  offsetNanoseconds: e => slotsToIso(e).offsetNanoseconds,\n  timeZoneId: e => I(e.timeZone),\n  hoursInDay: e => dn(createTimeZoneOps, e)\n}, {\n  getISOFields: e => mn(createTimeZoneOffsetOps, e),\n  getCalendar: createCalendarFromSlots,\n  getTimeZone: ({timeZone: e}) => \"string\" == typeof e ? new Zo(e) : e,\n  with(e, t, n) {\n    return dr(Sn($o, createTimeZoneOps, e, this, rejectInvalidBag(t), n));\n  },\n  withCalendar: (e, t) => dr(it(e, refineCalendarSlot(t))),\n  withTimeZone: (e, t) => dr(On(e, refineTimeZoneSlot(t))),\n  withPlainDate: (e, t) => dr(Tn(createTimeZoneOps, e, toPlainDateSlots(t))),\n  withPlainTime: (e, t) => dr(pn(createTimeZoneOps, e, optionalToPlainTimeFields(t))),\n  add: (e, t, n) => dr(hn(er, createTimeZoneOps, 0, e, toDurationSlots(t), n)),\n  subtract: (e, t, n) => dr(hn(er, createTimeZoneOps, 1, e, toDurationSlots(t), n)),\n  until: (e, t, n) => ar(Vt(Dn(tr, createTimeZoneOps, 0, e, toZonedDateTimeSlots(t), n))),\n  since: (e, t, n) => ar(Vt(Dn(tr, createTimeZoneOps, 1, e, toZonedDateTimeSlots(t), n))),\n  round: (e, t) => dr(Pn(createTimeZoneOps, e, t)),\n  startOfDay: e => dr(Cn(createTimeZoneOps, e)),\n  equals: (e, t) => gn(e, toZonedDateTimeSlots(t)),\n  toInstant: e => Co(Zn(e)),\n  toPlainDateTime: e => No(ht(createTimeZoneOffsetOps, e)),\n  toPlainDate: e => Yo(Bt(createTimeZoneOffsetOps, e)),\n  toPlainTime: e => vo(Re(createTimeZoneOffsetOps, e)),\n  toPlainYearMonth(e) {\n    return jo(bn(Ho, e, this));\n  },\n  toPlainMonthDay(e) {\n    return To(Fn(Qo, e, this));\n  },\n  toLocaleString(e, t, n = {}) {\n    const [o, r] = Wn(t, n, e);\n    return o.format(r);\n  },\n  toString: (e, t) => In(createTimeZoneOffsetOps, e, t),\n  toJSON: e => In(createTimeZoneOffsetOps, e),\n  valueOf: neverValueOf\n}, {\n  from: (e, t) => dr(toZonedDateTimeSlots(e, t)),\n  compare: (e, t) => yn(toZonedDateTimeSlots(e), toZonedDateTimeSlots(t))\n}), fr = /*@__PURE__*/ Object.defineProperties({}, {\n  ...h(\"Temporal.Now\"),\n  ...p({\n    timeZoneId: () => Nn(),\n    instant: () => Co(_(Bn())),\n    zonedDateTime: (e, t = Nn()) => dr(Yn(Bn(), refineTimeZoneSlot(t), refineCalendarSlot(e))),\n    zonedDateTimeISO: (e = Nn()) => dr(Yn(Bn(), refineTimeZoneSlot(e), X)),\n    plainDateTime: (e, t = Nn()) => No(ee(An(createTimeZoneOffsetOps(refineTimeZoneSlot(t))), refineCalendarSlot(e))),\n    plainDateTimeISO: (e = Nn()) => No(ee(An(createTimeZoneOffsetOps(refineTimeZoneSlot(e))), X)),\n    plainDate: (e, t = Nn()) => Yo(v(An(createTimeZoneOffsetOps(refineTimeZoneSlot(t))), refineCalendarSlot(e))),\n    plainDateISO: (e = Nn()) => Yo(v(An(createTimeZoneOffsetOps(refineTimeZoneSlot(e))), X)),\n    plainTimeISO: (e = Nn()) => vo(Ge(An(createTimeZoneOffsetOps(refineTimeZoneSlot(e)))))\n  })\n}), mr = /*@__PURE__*/ Object.defineProperties({}, {\n  ...h(\"Temporal\"),\n  ...p({\n    PlainYearMonth: wo,\n    PlainMonthDay: Oo,\n    PlainDate: Bo,\n    PlainTime: Io,\n    PlainDateTime: yo,\n    ZonedDateTime: ur,\n    Instant: Po,\n    Calendar: lr,\n    TimeZone: Zo,\n    Duration: rr,\n    Now: fr\n  })\n}), Sr = /*@__PURE__*/ createDateTimeFormatClass(), Or = /*@__PURE__*/ new WeakMap, Tr = /*@__PURE__*/ Object.defineProperties(Object.create(Intl), p({\n  DateTimeFormat: Sr\n}));\n\nexport { Sr as DateTimeFormat, Tr as IntlExtended, mr as Temporal, toTemporalInstant };\n","/******************************************************************************\nCopyright (c) Microsoft Corporation.\n\nPermission to use, copy, modify, and/or distribute this software for any\npurpose with or without fee is hereby granted.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\nPERFORMANCE OF THIS SOFTWARE.\n***************************************************************************** */\n/* global Reflect, Promise, SuppressedError, Symbol, Iterator */\n\nvar extendStatics = function(d, b) {\n  extendStatics = Object.setPrototypeOf ||\n      ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n      function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n  return extendStatics(d, b);\n};\n\nexport function __extends(d, b) {\n  if (typeof b !== \"function\" && b !== null)\n      throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\n  extendStatics(d, b);\n  function __() { this.constructor = d; }\n  d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n}\n\nexport var __assign = function() {\n  __assign = Object.assign || function __assign(t) {\n      for (var s, i = 1, n = arguments.length; i < n; i++) {\n          s = arguments[i];\n          for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\n      }\n      return t;\n  }\n  return __assign.apply(this, arguments);\n}\n\nexport function __rest(s, e) {\n  var t = {};\n  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\n      t[p] = s[p];\n  if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\n      for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\n          if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\n              t[p[i]] = s[p[i]];\n      }\n  return t;\n}\n\nexport function __decorate(decorators, target, key, desc) {\n  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n  if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n  return c > 3 && r && Object.defineProperty(target, key, r), r;\n}\n\nexport function __param(paramIndex, decorator) {\n  return function (target, key) { decorator(target, key, paramIndex); }\n}\n\nexport function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {\n  function accept(f) { if (f !== void 0 && typeof f !== \"function\") throw new TypeError(\"Function expected\"); return f; }\n  var kind = contextIn.kind, key = kind === \"getter\" ? \"get\" : kind === \"setter\" ? \"set\" : \"value\";\n  var target = !descriptorIn && ctor ? contextIn[\"static\"] ? ctor : ctor.prototype : null;\n  var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});\n  var _, done = false;\n  for (var i = decorators.length - 1; i >= 0; i--) {\n      var context = {};\n      for (var p in contextIn) context[p] = p === \"access\" ? {} : contextIn[p];\n      for (var p in contextIn.access) context.access[p] = contextIn.access[p];\n      context.addInitializer = function (f) { if (done) throw new TypeError(\"Cannot add initializers after decoration has completed\"); extraInitializers.push(accept(f || null)); };\n      var result = (0, decorators[i])(kind === \"accessor\" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);\n      if (kind === \"accessor\") {\n          if (result === void 0) continue;\n          if (result === null || typeof result !== \"object\") throw new TypeError(\"Object expected\");\n          if (_ = accept(result.get)) descriptor.get = _;\n          if (_ = accept(result.set)) descriptor.set = _;\n          if (_ = accept(result.init)) initializers.unshift(_);\n      }\n      else if (_ = accept(result)) {\n          if (kind === \"field\") initializers.unshift(_);\n          else descriptor[key] = _;\n      }\n  }\n  if (target) Object.defineProperty(target, contextIn.name, descriptor);\n  done = true;\n};\n\nexport function __runInitializers(thisArg, initializers, value) {\n  var useValue = arguments.length > 2;\n  for (var i = 0; i < initializers.length; i++) {\n      value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);\n  }\n  return useValue ? value : void 0;\n};\n\nexport function __propKey(x) {\n  return typeof x === \"symbol\" ? x : \"\".concat(x);\n};\n\nexport function __setFunctionName(f, name, prefix) {\n  if (typeof name === \"symbol\") name = name.description ? \"[\".concat(name.description, \"]\") : \"\";\n  return Object.defineProperty(f, \"name\", { configurable: true, value: prefix ? \"\".concat(prefix, \" \", name) : name });\n};\n\nexport function __metadata(metadataKey, metadataValue) {\n  if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\n}\n\nexport function __awaiter(thisArg, _arguments, P, generator) {\n  function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n  return new (P || (P = Promise))(function (resolve, reject) {\n      function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n      function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n      function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n      step((generator = generator.apply(thisArg, _arguments || [])).next());\n  });\n}\n\nexport function __generator(thisArg, body) {\n  var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === \"function\" ? Iterator : Object).prototype);\n  return g.next = verb(0), g[\"throw\"] = verb(1), g[\"return\"] = verb(2), typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n  function verb(n) { return function (v) { return step([n, v]); }; }\n  function step(op) {\n      if (f) throw new TypeError(\"Generator is already executing.\");\n      while (g && (g = 0, op[0] && (_ = 0)), _) try {\n          if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\n          if (y = 0, t) op = [op[0] & 2, t.value];\n          switch (op[0]) {\n              case 0: case 1: t = op; break;\n              case 4: _.label++; return { value: op[1], done: false };\n              case 5: _.label++; y = op[1]; op = [0]; continue;\n              case 7: op = _.ops.pop(); _.trys.pop(); continue;\n              default:\n                  if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n                  if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n                  if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n                  if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n                  if (t[2]) _.ops.pop();\n                  _.trys.pop(); continue;\n          }\n          op = body.call(thisArg, _);\n      } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\n      if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\n  }\n}\n\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\n  if (k2 === undefined) k2 = k;\n  var desc = Object.getOwnPropertyDescriptor(m, k);\n  if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n  }\n  Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n  if (k2 === undefined) k2 = k;\n  o[k2] = m[k];\n});\n\nexport function __exportStar(m, o) {\n  for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\n}\n\nexport function __values(o) {\n  var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\n  if (m) return m.call(o);\n  if (o && typeof o.length === \"number\") return {\n      next: function () {\n          if (o && i >= o.length) o = void 0;\n          return { value: o && o[i++], done: !o };\n      }\n  };\n  throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\n}\n\nexport function __read(o, n) {\n  var m = typeof Symbol === \"function\" && o[Symbol.iterator];\n  if (!m) return o;\n  var i = m.call(o), r, ar = [], e;\n  try {\n      while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\n  }\n  catch (error) { e = { error: error }; }\n  finally {\n      try {\n          if (r && !r.done && (m = i[\"return\"])) m.call(i);\n      }\n      finally { if (e) throw e.error; }\n  }\n  return ar;\n}\n\n/** @deprecated */\nexport function __spread() {\n  for (var ar = [], i = 0; i < arguments.length; i++)\n      ar = ar.concat(__read(arguments[i]));\n  return ar;\n}\n\n/** @deprecated */\nexport function __spreadArrays() {\n  for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\n  for (var r = Array(s), k = 0, i = 0; i < il; i++)\n      for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\n          r[k] = a[j];\n  return r;\n}\n\nexport function __spreadArray(to, from, pack) {\n  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n      if (ar || !(i in from)) {\n          if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n          ar[i] = from[i];\n      }\n  }\n  return to.concat(ar || Array.prototype.slice.call(from));\n}\n\nexport function __await(v) {\n  return this instanceof __await ? (this.v = v, this) : new __await(v);\n}\n\nexport function __asyncGenerator(thisArg, _arguments, generator) {\n  if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\n  var g = generator.apply(thisArg, _arguments || []), i, q = [];\n  return i = Object.create((typeof AsyncIterator === \"function\" ? AsyncIterator : Object).prototype), verb(\"next\"), verb(\"throw\"), verb(\"return\", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;\n  function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }\n  function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }\n  function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\n  function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\n  function fulfill(value) { resume(\"next\", value); }\n  function reject(value) { resume(\"throw\", value); }\n  function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\n}\n\nexport function __asyncDelegator(o) {\n  var i, p;\n  return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\n  function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }\n}\n\nexport function __asyncValues(o) {\n  if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\n  var m = o[Symbol.asyncIterator], i;\n  return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\n  function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\n  function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\n}\n\nexport function __makeTemplateObject(cooked, raw) {\n  if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\n  return cooked;\n};\n\nvar __setModuleDefault = Object.create ? (function(o, v) {\n  Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n  o[\"default\"] = v;\n};\n\nvar ownKeys = function(o) {\n  ownKeys = Object.getOwnPropertyNames || function (o) {\n    var ar = [];\n    for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;\n    return ar;\n  };\n  return ownKeys(o);\n};\n\nexport function __importStar(mod) {\n  if (mod && mod.__esModule) return mod;\n  var result = {};\n  if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== \"default\") __createBinding(result, mod, k[i]);\n  __setModuleDefault(result, mod);\n  return result;\n}\n\nexport function __importDefault(mod) {\n  return (mod && mod.__esModule) ? mod : { default: mod };\n}\n\nexport function __classPrivateFieldGet(receiver, state, kind, f) {\n  if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n  if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n  return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n}\n\nexport function __classPrivateFieldSet(receiver, state, value, kind, f) {\n  if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n  if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n  if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n  return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n}\n\nexport function __classPrivateFieldIn(state, receiver) {\n  if (receiver === null || (typeof receiver !== \"object\" && typeof receiver !== \"function\")) throw new TypeError(\"Cannot use 'in' operator on non-object\");\n  return typeof state === \"function\" ? receiver === state : state.has(receiver);\n}\n\nexport function __addDisposableResource(env, value, async) {\n  if (value !== null && value !== void 0) {\n    if (typeof value !== \"object\" && typeof value !== \"function\") throw new TypeError(\"Object expected.\");\n    var dispose, inner;\n    if (async) {\n      if (!Symbol.asyncDispose) throw new TypeError(\"Symbol.asyncDispose is not defined.\");\n      dispose = value[Symbol.asyncDispose];\n    }\n    if (dispose === void 0) {\n      if (!Symbol.dispose) throw new TypeError(\"Symbol.dispose is not defined.\");\n      dispose = value[Symbol.dispose];\n      if (async) inner = dispose;\n    }\n    if (typeof dispose !== \"function\") throw new TypeError(\"Object not disposable.\");\n    if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };\n    env.stack.push({ value: value, dispose: dispose, async: async });\n  }\n  else if (async) {\n    env.stack.push({ async: true });\n  }\n  return value;\n}\n\nvar _SuppressedError = typeof SuppressedError === \"function\" ? SuppressedError : function (error, suppressed, message) {\n  var e = new Error(message);\n  return e.name = \"SuppressedError\", e.error = error, e.suppressed = suppressed, e;\n};\n\nexport function __disposeResources(env) {\n  function fail(e) {\n    env.error = env.hasError ? new _SuppressedError(e, env.error, \"An error was suppressed during disposal.\") : e;\n    env.hasError = true;\n  }\n  var r, s = 0;\n  function next() {\n    while (r = env.stack.pop()) {\n      try {\n        if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);\n        if (r.dispose) {\n          var result = r.dispose.call(r.value);\n          if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });\n        }\n        else s |= 1;\n      }\n      catch (e) {\n        fail(e);\n      }\n    }\n    if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();\n    if (env.hasError) throw env.error;\n  }\n  return next();\n}\n\nexport function __rewriteRelativeImportExtension(path, preserveJsx) {\n  if (typeof path === \"string\" && /^\\.\\.?\\//.test(path)) {\n      return path.replace(/\\.(tsx)$|((?:\\.d)?)((?:\\.[^./]+?)?)\\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {\n          return tsx ? preserveJsx ? \".jsx\" : \".js\" : d && (!ext || !cm) ? m : (d + ext + \".\" + cm.toLowerCase() + \"js\");\n      });\n  }\n  return path;\n}\n\nexport default {\n  __extends,\n  __assign,\n  __rest,\n  __decorate,\n  __param,\n  __esDecorate,\n  __runInitializers,\n  __propKey,\n  __setFunctionName,\n  __metadata,\n  __awaiter,\n  __generator,\n  __createBinding,\n  __exportStar,\n  __values,\n  __read,\n  __spread,\n  __spreadArrays,\n  __spreadArray,\n  __await,\n  __asyncGenerator,\n  __asyncDelegator,\n  __asyncValues,\n  __makeTemplateObject,\n  __importStar,\n  __importDefault,\n  __classPrivateFieldGet,\n  __classPrivateFieldSet,\n  __classPrivateFieldIn,\n  __addDisposableResource,\n  __disposeResources,\n  __rewriteRelativeImportExtension,\n};\n","/////////////////////////////////////////////////////////////////////////////////\n/* UAParser.js v1.0.40\n   Copyright © 2012-2024 Faisal Salman <f@faisalman.com>\n   MIT License *//*\n   Detect Browser, Engine, OS, CPU, and Device type/model from User-Agent data.\n   Supports browser & node.js environment. \n   Demo   : https://faisalman.github.io/ua-parser-js\n   Source : https://github.com/faisalman/ua-parser-js */\n/////////////////////////////////////////////////////////////////////////////////\n\n(function (window, undefined) {\n\n    'use strict';\n\n    //////////////\n    // Constants\n    /////////////\n\n\n    var LIBVERSION  = '1.0.40',\n        EMPTY       = '',\n        UNKNOWN     = '?',\n        FUNC_TYPE   = 'function',\n        UNDEF_TYPE  = 'undefined',\n        OBJ_TYPE    = 'object',\n        STR_TYPE    = 'string',\n        MAJOR       = 'major',\n        MODEL       = 'model',\n        NAME        = 'name',\n        TYPE        = 'type',\n        VENDOR      = 'vendor',\n        VERSION     = 'version',\n        ARCHITECTURE= 'architecture',\n        CONSOLE     = 'console',\n        MOBILE      = 'mobile',\n        TABLET      = 'tablet',\n        SMARTTV     = 'smarttv',\n        WEARABLE    = 'wearable',\n        EMBEDDED    = 'embedded',\n        UA_MAX_LENGTH = 500;\n\n    var AMAZON  = 'Amazon',\n        APPLE   = 'Apple',\n        ASUS    = 'ASUS',\n        BLACKBERRY = 'BlackBerry',\n        BROWSER = 'Browser',\n        CHROME  = 'Chrome',\n        EDGE    = 'Edge',\n        FIREFOX = 'Firefox',\n        GOOGLE  = 'Google',\n        HUAWEI  = 'Huawei',\n        LG      = 'LG',\n        MICROSOFT = 'Microsoft',\n        MOTOROLA  = 'Motorola',\n        OPERA   = 'Opera',\n        SAMSUNG = 'Samsung',\n        SHARP   = 'Sharp',\n        SONY    = 'Sony',\n        XIAOMI  = 'Xiaomi',\n        ZEBRA   = 'Zebra',\n        FACEBOOK    = 'Facebook',\n        CHROMIUM_OS = 'Chromium OS',\n        MAC_OS  = 'Mac OS',\n        SUFFIX_BROWSER = ' Browser';\n\n    ///////////\n    // Helper\n    //////////\n\n    var extend = function (regexes, extensions) {\n            var mergedRegexes = {};\n            for (var i in regexes) {\n                if (extensions[i] && extensions[i].length % 2 === 0) {\n                    mergedRegexes[i] = extensions[i].concat(regexes[i]);\n                } else {\n                    mergedRegexes[i] = regexes[i];\n                }\n            }\n            return mergedRegexes;\n        },\n        enumerize = function (arr) {\n            var enums = {};\n            for (var i=0; i<arr.length; i++) {\n                enums[arr[i].toUpperCase()] = arr[i];\n            }\n            return enums;\n        },\n        has = function (str1, str2) {\n            return typeof str1 === STR_TYPE ? lowerize(str2).indexOf(lowerize(str1)) !== -1 : false;\n        },\n        lowerize = function (str) {\n            return str.toLowerCase();\n        },\n        majorize = function (version) {\n            return typeof(version) === STR_TYPE ? version.replace(/[^\\d\\.]/g, EMPTY).split('.')[0] : undefined;\n        },\n        trim = function (str, len) {\n            if (typeof(str) === STR_TYPE) {\n                str = str.replace(/^\\s\\s*/, EMPTY);\n                return typeof(len) === UNDEF_TYPE ? str : str.substring(0, UA_MAX_LENGTH);\n            }\n    };\n\n    ///////////////\n    // Map helper\n    //////////////\n\n    var rgxMapper = function (ua, arrays) {\n\n            var i = 0, j, k, p, q, matches, match;\n\n            // loop through all regexes maps\n            while (i < arrays.length && !matches) {\n\n                var regex = arrays[i],       // even sequence (0,2,4,..)\n                    props = arrays[i + 1];   // odd sequence (1,3,5,..)\n                j = k = 0;\n\n                // try matching uastring with regexes\n                while (j < regex.length && !matches) {\n\n                    if (!regex[j]) { break; }\n                    matches = regex[j++].exec(ua);\n\n                    if (!!matches) {\n                        for (p = 0; p < props.length; p++) {\n                            match = matches[++k];\n                            q = props[p];\n                            // check if given property is actually array\n                            if (typeof q === OBJ_TYPE && q.length > 0) {\n                                if (q.length === 2) {\n                                    if (typeof q[1] == FUNC_TYPE) {\n                                        // assign modified match\n                                        this[q[0]] = q[1].call(this, match);\n                                    } else {\n                                        // assign given value, ignore regex match\n                                        this[q[0]] = q[1];\n                                    }\n                                } else if (q.length === 3) {\n                                    // check whether function or regex\n                                    if (typeof q[1] === FUNC_TYPE && !(q[1].exec && q[1].test)) {\n                                        // call function (usually string mapper)\n                                        this[q[0]] = match ? q[1].call(this, match, q[2]) : undefined;\n                                    } else {\n                                        // sanitize match using given regex\n                                        this[q[0]] = match ? match.replace(q[1], q[2]) : undefined;\n                                    }\n                                } else if (q.length === 4) {\n                                        this[q[0]] = match ? q[3].call(this, match.replace(q[1], q[2])) : undefined;\n                                }\n                            } else {\n                                this[q] = match ? match : undefined;\n                            }\n                        }\n                    }\n                }\n                i += 2;\n            }\n        },\n\n        strMapper = function (str, map) {\n\n            for (var i in map) {\n                // check if current value is array\n                if (typeof map[i] === OBJ_TYPE && map[i].length > 0) {\n                    for (var j = 0; j < map[i].length; j++) {\n                        if (has(map[i][j], str)) {\n                            return (i === UNKNOWN) ? undefined : i;\n                        }\n                    }\n                } else if (has(map[i], str)) {\n                    return (i === UNKNOWN) ? undefined : i;\n                }\n            }\n            return map.hasOwnProperty('*') ? map['*'] : str;\n    };\n\n    ///////////////\n    // String map\n    //////////////\n\n    // Safari < 3.0\n    var oldSafariMap = {\n            '1.0'   : '/8',\n            '1.2'   : '/1',\n            '1.3'   : '/3',\n            '2.0'   : '/412',\n            '2.0.2' : '/416',\n            '2.0.3' : '/417',\n            '2.0.4' : '/419',\n            '?'     : '/'\n        },\n        windowsVersionMap = {\n            'ME'        : '4.90',\n            'NT 3.11'   : 'NT3.51',\n            'NT 4.0'    : 'NT4.0',\n            '2000'      : 'NT 5.0',\n            'XP'        : ['NT 5.1', 'NT 5.2'],\n            'Vista'     : 'NT 6.0',\n            '7'         : 'NT 6.1',\n            '8'         : 'NT 6.2',\n            '8.1'       : 'NT 6.3',\n            '10'        : ['NT 6.4', 'NT 10.0'],\n            'RT'        : 'ARM'\n    };\n\n    //////////////\n    // Regex map\n    /////////////\n\n    var regexes = {\n\n        browser : [[\n\n            /\\b(?:crmo|crios)\\/([\\w\\.]+)/i                                      // Chrome for Android/iOS\n            ], [VERSION, [NAME, 'Chrome']], [\n            /edg(?:e|ios|a)?\\/([\\w\\.]+)/i                                       // Microsoft Edge\n            ], [VERSION, [NAME, 'Edge']], [\n\n            // Presto based\n            /(opera mini)\\/([-\\w\\.]+)/i,                                        // Opera Mini\n            /(opera [mobiletab]{3,6})\\b.+version\\/([-\\w\\.]+)/i,                 // Opera Mobi/Tablet\n            /(opera)(?:.+version\\/|[\\/ ]+)([\\w\\.]+)/i                           // Opera\n            ], [NAME, VERSION], [\n            /opios[\\/ ]+([\\w\\.]+)/i                                             // Opera mini on iphone >= 8.0\n            ], [VERSION, [NAME, OPERA+' Mini']], [\n            /\\bop(?:rg)?x\\/([\\w\\.]+)/i                                          // Opera GX\n            ], [VERSION, [NAME, OPERA+' GX']], [\n            /\\bopr\\/([\\w\\.]+)/i                                                 // Opera Webkit\n            ], [VERSION, [NAME, OPERA]], [\n\n            // Mixed\n            /\\bb[ai]*d(?:uhd|[ub]*[aekoprswx]{5,6})[\\/ ]?([\\w\\.]+)/i            // Baidu\n            ], [VERSION, [NAME, 'Baidu']], [\n            /\\b(?:mxbrowser|mxios|myie2)\\/?([-\\w\\.]*)\\b/i                       // Maxthon\n            ], [VERSION, [NAME, 'Maxthon']], [\n            /(kindle)\\/([\\w\\.]+)/i,                                             // Kindle\n            /(lunascape|maxthon|netfront|jasmine|blazer|sleipnir)[\\/ ]?([\\w\\.]*)/i,      \n                                                                                // Lunascape/Maxthon/Netfront/Jasmine/Blazer/Sleipnir\n            // Trident based\n            /(avant|iemobile|slim(?:browser|boat|jet))[\\/ ]?([\\d\\.]*)/i,        // Avant/IEMobile/SlimBrowser/SlimBoat/Slimjet\n            /(?:ms|\\()(ie) ([\\w\\.]+)/i,                                         // Internet Explorer\n\n            // Blink/Webkit/KHTML based                                         // Flock/RockMelt/Midori/Epiphany/Silk/Skyfire/Bolt/Iron/Iridium/PhantomJS/Bowser/QupZilla/Falkon\n            /(flock|rockmelt|midori|epiphany|silk|skyfire|ovibrowser|bolt|iron|vivaldi|iridium|phantomjs|bowser|qupzilla|falkon|rekonq|puffin|brave|whale(?!.+naver)|qqbrowserlite|duckduckgo|klar|helio|(?=comodo_)?dragon)\\/([-\\w\\.]+)/i,\n                                                                                // Rekonq/Puffin/Brave/Whale/QQBrowserLite/QQ//Vivaldi/DuckDuckGo/Klar/Helio/Dragon\n            /(heytap|ovi|115)browser\\/([\\d\\.]+)/i,                              // HeyTap/Ovi/115\n            /(weibo)__([\\d\\.]+)/i                                               // Weibo\n            ], [NAME, VERSION], [\n            /quark(?:pc)?\\/([-\\w\\.]+)/i                                         // Quark\n            ], [VERSION, [NAME, 'Quark']], [\n            /\\bddg\\/([\\w\\.]+)/i                                                 // DuckDuckGo\n            ], [VERSION, [NAME, 'DuckDuckGo']], [\n            /(?:\\buc? ?browser|(?:juc.+)ucweb)[\\/ ]?([\\w\\.]+)/i                 // UCBrowser\n            ], [VERSION, [NAME, 'UC'+BROWSER]], [\n            /microm.+\\bqbcore\\/([\\w\\.]+)/i,                                     // WeChat Desktop for Windows Built-in Browser\n            /\\bqbcore\\/([\\w\\.]+).+microm/i,\n            /micromessenger\\/([\\w\\.]+)/i                                        // WeChat\n            ], [VERSION, [NAME, 'WeChat']], [\n            /konqueror\\/([\\w\\.]+)/i                                             // Konqueror\n            ], [VERSION, [NAME, 'Konqueror']], [\n            /trident.+rv[: ]([\\w\\.]{1,9})\\b.+like gecko/i                       // IE11\n            ], [VERSION, [NAME, 'IE']], [\n            /ya(?:search)?browser\\/([\\w\\.]+)/i                                  // Yandex\n            ], [VERSION, [NAME, 'Yandex']], [\n            /slbrowser\\/([\\w\\.]+)/i                                             // Smart Lenovo Browser\n            ], [VERSION, [NAME, 'Smart Lenovo '+BROWSER]], [\n            /(avast|avg)\\/([\\w\\.]+)/i                                           // Avast/AVG Secure Browser\n            ], [[NAME, /(.+)/, '$1 Secure '+BROWSER], VERSION], [\n            /\\bfocus\\/([\\w\\.]+)/i                                               // Firefox Focus\n            ], [VERSION, [NAME, FIREFOX+' Focus']], [\n            /\\bopt\\/([\\w\\.]+)/i                                                 // Opera Touch\n            ], [VERSION, [NAME, OPERA+' Touch']], [\n            /coc_coc\\w+\\/([\\w\\.]+)/i                                            // Coc Coc Browser\n            ], [VERSION, [NAME, 'Coc Coc']], [\n            /dolfin\\/([\\w\\.]+)/i                                                // Dolphin\n            ], [VERSION, [NAME, 'Dolphin']], [\n            /coast\\/([\\w\\.]+)/i                                                 // Opera Coast\n            ], [VERSION, [NAME, OPERA+' Coast']], [\n            /miuibrowser\\/([\\w\\.]+)/i                                           // MIUI Browser\n            ], [VERSION, [NAME, 'MIUI' + SUFFIX_BROWSER]], [\n            /fxios\\/([\\w\\.-]+)/i                                                // Firefox for iOS\n            ], [VERSION, [NAME, FIREFOX]], [\n            /\\bqihoobrowser\\/?([\\w\\.]*)/i                                       // 360\n            ], [VERSION, [NAME, '360']], [\n            /\\b(qq)\\/([\\w\\.]+)/i                                                // QQ\n            ], [[NAME, /(.+)/, '$1Browser'], VERSION], [\n            /(oculus|sailfish|huawei|vivo|pico)browser\\/([\\w\\.]+)/i\n            ], [[NAME, /(.+)/, '$1' + SUFFIX_BROWSER], VERSION], [              // Oculus/Sailfish/HuaweiBrowser/VivoBrowser/PicoBrowser\n            /samsungbrowser\\/([\\w\\.]+)/i                                        // Samsung Internet\n            ], [VERSION, [NAME, SAMSUNG + ' Internet']], [\n            /metasr[\\/ ]?([\\d\\.]+)/i                                            // Sogou Explorer\n            ], [VERSION, [NAME, 'Sogou Explorer']], [\n            /(sogou)mo\\w+\\/([\\d\\.]+)/i                                          // Sogou Mobile\n            ], [[NAME, 'Sogou Mobile'], VERSION], [\n            /(electron)\\/([\\w\\.]+) safari/i,                                    // Electron-based App\n            /(tesla)(?: qtcarbrowser|\\/(20\\d\\d\\.[-\\w\\.]+))/i,                   // Tesla\n            /m?(qqbrowser|2345(?=browser|chrome|explorer))\\w*[\\/ ]?v?([\\w\\.]+)/i   // QQ/2345\n            ], [NAME, VERSION], [\n            /(lbbrowser|rekonq)/i,                                              // LieBao Browser/Rekonq\n            /\\[(linkedin)app\\]/i                                                // LinkedIn App for iOS & Android\n            ], [NAME], [\n            /ome\\/([\\w\\.]+) \\w* ?(iron) saf/i,                                  // Iron\n            /ome\\/([\\w\\.]+).+qihu (360)[es]e/i                                  // 360\n            ], [VERSION, NAME], [\n\n            // WebView\n            /((?:fban\\/fbios|fb_iab\\/fb4a)(?!.+fbav)|;fbav\\/([\\w\\.]+);)/i       // Facebook App for iOS & Android\n            ], [[NAME, FACEBOOK], VERSION], [\n            /(Klarna)\\/([\\w\\.]+)/i,                                             // Klarna Shopping Browser for iOS & Android\n            /(kakao(?:talk|story))[\\/ ]([\\w\\.]+)/i,                             // Kakao App\n            /(naver)\\(.*?(\\d+\\.[\\w\\.]+).*\\)/i,                                  // Naver InApp\n            /safari (line)\\/([\\w\\.]+)/i,                                        // Line App for iOS\n            /\\b(line)\\/([\\w\\.]+)\\/iab/i,                                        // Line App for Android\n            /(alipay)client\\/([\\w\\.]+)/i,                                       // Alipay\n            /(twitter)(?:and| f.+e\\/([\\w\\.]+))/i,                               // Twitter\n            /(chromium|instagram|snapchat)[\\/ ]([-\\w\\.]+)/i                     // Chromium/Instagram/Snapchat\n            ], [NAME, VERSION], [\n            /\\bgsa\\/([\\w\\.]+) .*safari\\//i                                      // Google Search Appliance on iOS\n            ], [VERSION, [NAME, 'GSA']], [\n            /musical_ly(?:.+app_?version\\/|_)([\\w\\.]+)/i                        // TikTok\n            ], [VERSION, [NAME, 'TikTok']], [\n\n            /headlesschrome(?:\\/([\\w\\.]+)| )/i                                  // Chrome Headless\n            ], [VERSION, [NAME, CHROME+' Headless']], [\n\n            / wv\\).+(chrome)\\/([\\w\\.]+)/i                                       // Chrome WebView\n            ], [[NAME, CHROME+' WebView'], VERSION], [\n\n            /droid.+ version\\/([\\w\\.]+)\\b.+(?:mobile safari|safari)/i           // Android Browser\n            ], [VERSION, [NAME, 'Android '+BROWSER]], [\n\n            /(chrome|omniweb|arora|[tizenoka]{5} ?browser)\\/v?([\\w\\.]+)/i       // Chrome/OmniWeb/Arora/Tizen/Nokia\n            ], [NAME, VERSION], [\n\n            /version\\/([\\w\\.\\,]+) .*mobile\\/\\w+ (safari)/i                      // Mobile Safari\n            ], [VERSION, [NAME, 'Mobile Safari']], [\n            /version\\/([\\w(\\.|\\,)]+) .*(mobile ?safari|safari)/i                // Safari & Safari Mobile\n            ], [VERSION, NAME], [\n            /webkit.+?(mobile ?safari|safari)(\\/[\\w\\.]+)/i                      // Safari < 3.0\n            ], [NAME, [VERSION, strMapper, oldSafariMap]], [\n\n            /(webkit|khtml)\\/([\\w\\.]+)/i\n            ], [NAME, VERSION], [\n\n            // Gecko based\n            /(navigator|netscape\\d?)\\/([-\\w\\.]+)/i                              // Netscape\n            ], [[NAME, 'Netscape'], VERSION], [\n            /(wolvic|librewolf)\\/([\\w\\.]+)/i                                    // Wolvic/LibreWolf\n            ], [NAME, VERSION], [\n            /mobile vr; rv:([\\w\\.]+)\\).+firefox/i                               // Firefox Reality\n            ], [VERSION, [NAME, FIREFOX+' Reality']], [\n            /ekiohf.+(flow)\\/([\\w\\.]+)/i,                                       // Flow\n            /(swiftfox)/i,                                                      // Swiftfox\n            /(icedragon|iceweasel|camino|chimera|fennec|maemo browser|minimo|conkeror)[\\/ ]?([\\w\\.\\+]+)/i,\n                                                                                // IceDragon/Iceweasel/Camino/Chimera/Fennec/Maemo/Minimo/Conkeror\n            /(seamonkey|k-meleon|icecat|iceape|firebird|phoenix|palemoon|basilisk|waterfox)\\/([-\\w\\.]+)$/i,\n                                                                                // Firefox/SeaMonkey/K-Meleon/IceCat/IceApe/Firebird/Phoenix\n            /(firefox)\\/([\\w\\.]+)/i,                                            // Other Firefox-based\n            /(mozilla)\\/([\\w\\.]+) .+rv\\:.+gecko\\/\\d+/i,                         // Mozilla\n\n            // Other\n            /(polaris|lynx|dillo|icab|doris|amaya|w3m|netsurf|obigo|mosaic|(?:go|ice|up)[\\. ]?browser)[-\\/ ]?v?([\\w\\.]+)/i,\n                                                                                // Polaris/Lynx/Dillo/iCab/Doris/Amaya/w3m/NetSurf/Obigo/Mosaic/Go/ICE/UP.Browser\n            /(links) \\(([\\w\\.]+)/i                                              // Links\n            ], [NAME, [VERSION, /_/g, '.']], [\n            \n            /(cobalt)\\/([\\w\\.]+)/i                                              // Cobalt\n            ], [NAME, [VERSION, /master.|lts./, \"\"]]\n        ],\n\n        cpu : [[\n\n            /(?:(amd|x(?:(?:86|64)[-_])?|wow|win)64)[;\\)]/i                     // AMD64 (x64)\n            ], [[ARCHITECTURE, 'amd64']], [\n\n            /(ia32(?=;))/i                                                      // IA32 (quicktime)\n            ], [[ARCHITECTURE, lowerize]], [\n\n            /((?:i[346]|x)86)[;\\)]/i                                            // IA32 (x86)\n            ], [[ARCHITECTURE, 'ia32']], [\n\n            /\\b(aarch64|arm(v?8e?l?|_?64))\\b/i                                 // ARM64\n            ], [[ARCHITECTURE, 'arm64']], [\n\n            /\\b(arm(?:v[67])?ht?n?[fl]p?)\\b/i                                   // ARMHF\n            ], [[ARCHITECTURE, 'armhf']], [\n\n            // PocketPC mistakenly identified as PowerPC\n            /windows (ce|mobile); ppc;/i\n            ], [[ARCHITECTURE, 'arm']], [\n\n            /((?:ppc|powerpc)(?:64)?)(?: mac|;|\\))/i                            // PowerPC\n            ], [[ARCHITECTURE, /ower/, EMPTY, lowerize]], [\n\n            /(sun4\\w)[;\\)]/i                                                    // SPARC\n            ], [[ARCHITECTURE, 'sparc']], [\n\n            /((?:avr32|ia64(?=;))|68k(?=\\))|\\barm(?=v(?:[1-7]|[5-7]1)l?|;|eabi)|(?=atmel )avr|(?:irix|mips|sparc)(?:64)?\\b|pa-risc)/i\n                                                                                // IA64, 68K, ARM/64, AVR/32, IRIX/64, MIPS/64, SPARC/64, PA-RISC\n            ], [[ARCHITECTURE, lowerize]]\n        ],\n\n        device : [[\n\n            //////////////////////////\n            // MOBILES & TABLETS\n            /////////////////////////\n\n            // Samsung\n            /\\b(sch-i[89]0\\d|shw-m380s|sm-[ptx]\\w{2,4}|gt-[pn]\\d{2,4}|sgh-t8[56]9|nexus 10)/i\n            ], [MODEL, [VENDOR, SAMSUNG], [TYPE, TABLET]], [\n            /\\b((?:s[cgp]h|gt|sm)-(?![lr])\\w+|sc[g-]?[\\d]+a?|galaxy nexus)/i,\n            /samsung[- ]((?!sm-[lr])[-\\w]+)/i,\n            /sec-(sgh\\w+)/i\n            ], [MODEL, [VENDOR, SAMSUNG], [TYPE, MOBILE]], [\n\n            // Apple\n            /(?:\\/|\\()(ip(?:hone|od)[\\w, ]*)(?:\\/|;)/i                          // iPod/iPhone\n            ], [MODEL, [VENDOR, APPLE], [TYPE, MOBILE]], [\n            /\\((ipad);[-\\w\\),; ]+apple/i,                                       // iPad\n            /applecoremedia\\/[\\w\\.]+ \\((ipad)/i,\n            /\\b(ipad)\\d\\d?,\\d\\d?[;\\]].+ios/i\n            ], [MODEL, [VENDOR, APPLE], [TYPE, TABLET]], [\n            /(macintosh);/i\n            ], [MODEL, [VENDOR, APPLE]], [\n\n            // Sharp\n            /\\b(sh-?[altvz]?\\d\\d[a-ekm]?)/i\n            ], [MODEL, [VENDOR, SHARP], [TYPE, MOBILE]], [\n\n            // Honor\n            /(?:honor)([-\\w ]+)[;\\)]/i\n            ], [MODEL, [VENDOR, 'Honor'], [TYPE, MOBILE]], [\n\n            // Huawei\n            /\\b((?:ag[rs][23]?|bah2?|sht?|btv)-a?[lw]\\d{2})\\b(?!.+d\\/s)/i\n            ], [MODEL, [VENDOR, HUAWEI], [TYPE, TABLET]], [\n            /(?:huawei)([-\\w ]+)[;\\)]/i,\n            /\\b(nexus 6p|\\w{2,4}e?-[atu]?[ln][\\dx][012359c][adn]?)\\b(?!.+d\\/s)/i\n            ], [MODEL, [VENDOR, HUAWEI], [TYPE, MOBILE]], [\n\n            // Xiaomi\n            /\\b(poco[\\w ]+|m2\\d{3}j\\d\\d[a-z]{2})(?: bui|\\))/i,                  // Xiaomi POCO\n            /\\b; (\\w+) build\\/hm\\1/i,                                           // Xiaomi Hongmi 'numeric' models\n            /\\b(hm[-_ ]?note?[_ ]?(?:\\d\\w)?) bui/i,                             // Xiaomi Hongmi\n            /\\b(redmi[\\-_ ]?(?:note|k)?[\\w_ ]+)(?: bui|\\))/i,                   // Xiaomi Redmi\n            /oid[^\\)]+; (m?[12][0-389][01]\\w{3,6}[c-y])( bui|; wv|\\))/i,        // Xiaomi Redmi 'numeric' models\n            /\\b(mi[-_ ]?(?:a\\d|one|one[_ ]plus|note lte|max|cc)?[_ ]?(?:\\d?\\w?)[_ ]?(?:plus|se|lite|pro)?)(?: bui|\\))/i // Xiaomi Mi\n            ], [[MODEL, /_/g, ' '], [VENDOR, XIAOMI], [TYPE, MOBILE]], [\n            /oid[^\\)]+; (2\\d{4}(283|rpbf)[cgl])( bui|\\))/i,                     // Redmi Pad\n            /\\b(mi[-_ ]?(?:pad)(?:[\\w_ ]+))(?: bui|\\))/i                        // Mi Pad tablets\n            ],[[MODEL, /_/g, ' '], [VENDOR, XIAOMI], [TYPE, TABLET]], [\n\n            // OPPO\n            /; (\\w+) bui.+ oppo/i,\n            /\\b(cph[12]\\d{3}|p(?:af|c[al]|d\\w|e[ar])[mt]\\d0|x9007|a101op)\\b/i\n            ], [MODEL, [VENDOR, 'OPPO'], [TYPE, MOBILE]], [\n            /\\b(opd2\\d{3}a?) bui/i\n            ], [MODEL, [VENDOR, 'OPPO'], [TYPE, TABLET]], [\n\n            // Vivo\n            /vivo (\\w+)(?: bui|\\))/i,\n            /\\b(v[12]\\d{3}\\w?[at])(?: bui|;)/i\n            ], [MODEL, [VENDOR, 'Vivo'], [TYPE, MOBILE]], [\n\n            // Realme\n            /\\b(rmx[1-3]\\d{3})(?: bui|;|\\))/i\n            ], [MODEL, [VENDOR, 'Realme'], [TYPE, MOBILE]], [\n\n            // Motorola\n            /\\b(milestone|droid(?:[2-4x]| (?:bionic|x2|pro|razr))?:?( 4g)?)\\b[\\w ]+build\\//i,\n            /\\bmot(?:orola)?[- ](\\w*)/i,\n            /((?:moto[\\w\\(\\) ]+|xt\\d{3,4}|nexus 6)(?= bui|\\)))/i\n            ], [MODEL, [VENDOR, MOTOROLA], [TYPE, MOBILE]], [\n            /\\b(mz60\\d|xoom[2 ]{0,2}) build\\//i\n            ], [MODEL, [VENDOR, MOTOROLA], [TYPE, TABLET]], [\n\n            // LG\n            /((?=lg)?[vl]k\\-?\\d{3}) bui| 3\\.[-\\w; ]{10}lg?-([06cv9]{3,4})/i\n            ], [MODEL, [VENDOR, LG], [TYPE, TABLET]], [\n            /(lm(?:-?f100[nv]?|-[\\w\\.]+)(?= bui|\\))|nexus [45])/i,\n            /\\blg[-e;\\/ ]+((?!browser|netcast|android tv)\\w+)/i,\n            /\\blg-?([\\d\\w]+) bui/i\n            ], [MODEL, [VENDOR, LG], [TYPE, MOBILE]], [\n\n            // Lenovo\n            /(ideatab[-\\w ]+)/i,\n            /lenovo ?(s[56]000[-\\w]+|tab(?:[\\w ]+)|yt[-\\d\\w]{6}|tb[-\\d\\w]{6})/i\n            ], [MODEL, [VENDOR, 'Lenovo'], [TYPE, TABLET]], [\n\n            // Nokia\n            /(?:maemo|nokia).*(n900|lumia \\d+)/i,\n            /nokia[-_ ]?([-\\w\\.]*)/i\n            ], [[MODEL, /_/g, ' '], [VENDOR, 'Nokia'], [TYPE, MOBILE]], [\n\n            // Google\n            /(pixel c)\\b/i                                                      // Google Pixel C\n            ], [MODEL, [VENDOR, GOOGLE], [TYPE, TABLET]], [\n            /droid.+; (pixel[\\daxl ]{0,6})(?: bui|\\))/i                         // Google Pixel\n            ], [MODEL, [VENDOR, GOOGLE], [TYPE, MOBILE]], [\n\n            // Sony\n            /droid.+; (a?\\d[0-2]{2}so|[c-g]\\d{4}|so[-gl]\\w+|xq-a\\w[4-7][12])(?= bui|\\).+chrome\\/(?![1-6]{0,1}\\d\\.))/i\n            ], [MODEL, [VENDOR, SONY], [TYPE, MOBILE]], [\n            /sony tablet [ps]/i,\n            /\\b(?:sony)?sgp\\w+(?: bui|\\))/i\n            ], [[MODEL, 'Xperia Tablet'], [VENDOR, SONY], [TYPE, TABLET]], [\n\n            // OnePlus\n            / (kb2005|in20[12]5|be20[12][59])\\b/i,\n            /(?:one)?(?:plus)? (a\\d0\\d\\d)(?: b|\\))/i\n            ], [MODEL, [VENDOR, 'OnePlus'], [TYPE, MOBILE]], [\n\n            // Amazon\n            /(alexa)webm/i,\n            /(kf[a-z]{2}wi|aeo(?!bc)\\w\\w)( bui|\\))/i,                           // Kindle Fire without Silk / Echo Show\n            /(kf[a-z]+)( bui|\\)).+silk\\//i                                      // Kindle Fire HD\n            ], [MODEL, [VENDOR, AMAZON], [TYPE, TABLET]], [\n            /((?:sd|kf)[0349hijorstuw]+)( bui|\\)).+silk\\//i                     // Fire Phone\n            ], [[MODEL, /(.+)/g, 'Fire Phone $1'], [VENDOR, AMAZON], [TYPE, MOBILE]], [\n\n            // BlackBerry\n            /(playbook);[-\\w\\),; ]+(rim)/i                                      // BlackBerry PlayBook\n            ], [MODEL, VENDOR, [TYPE, TABLET]], [\n            /\\b((?:bb[a-f]|st[hv])100-\\d)/i,\n            /\\(bb10; (\\w+)/i                                                    // BlackBerry 10\n            ], [MODEL, [VENDOR, BLACKBERRY], [TYPE, MOBILE]], [\n\n            // Asus\n            /(?:\\b|asus_)(transfo[prime ]{4,10} \\w+|eeepc|slider \\w+|nexus 7|padfone|p00[cj])/i\n            ], [MODEL, [VENDOR, ASUS], [TYPE, TABLET]], [\n            / (z[bes]6[027][012][km][ls]|zenfone \\d\\w?)\\b/i\n            ], [MODEL, [VENDOR, ASUS], [TYPE, MOBILE]], [\n\n            // HTC\n            /(nexus 9)/i                                                        // HTC Nexus 9\n            ], [MODEL, [VENDOR, 'HTC'], [TYPE, TABLET]], [\n            /(htc)[-;_ ]{1,2}([\\w ]+(?=\\)| bui)|\\w+)/i,                         // HTC\n\n            // ZTE\n            /(zte)[- ]([\\w ]+?)(?: bui|\\/|\\))/i,\n            /(alcatel|geeksphone|nexian|panasonic(?!(?:;|\\.))|sony(?!-bra))[-_ ]?([-\\w]*)/i         // Alcatel/GeeksPhone/Nexian/Panasonic/Sony\n            ], [VENDOR, [MODEL, /_/g, ' '], [TYPE, MOBILE]], [\n\n            // TCL\n            /droid [\\w\\.]+; ((?:8[14]9[16]|9(?:0(?:48|60|8[01])|1(?:3[27]|66)|2(?:6[69]|9[56])|466))[gqswx])\\w*(\\)| bui)/i\n            ], [MODEL, [VENDOR, 'TCL'], [TYPE, TABLET]], [\n\n            // itel\n            /(itel) ((\\w+))/i\n            ], [[VENDOR, lowerize], MODEL, [TYPE, strMapper, { 'tablet' : ['p10001l', 'w7001'], '*' : 'mobile' }]], [\n\n            // Acer\n            /droid.+; ([ab][1-7]-?[0178a]\\d\\d?)/i\n            ], [MODEL, [VENDOR, 'Acer'], [TYPE, TABLET]], [\n\n            // Meizu\n            /droid.+; (m[1-5] note) bui/i,\n            /\\bmz-([-\\w]{2,})/i\n            ], [MODEL, [VENDOR, 'Meizu'], [TYPE, MOBILE]], [\n                \n            // Ulefone\n            /; ((?:power )?armor(?:[\\w ]{0,8}))(?: bui|\\))/i\n            ], [MODEL, [VENDOR, 'Ulefone'], [TYPE, MOBILE]], [\n\n            // Energizer\n            /; (energy ?\\w+)(?: bui|\\))/i,\n            /; energizer ([\\w ]+)(?: bui|\\))/i\n            ], [MODEL, [VENDOR, 'Energizer'], [TYPE, MOBILE]], [\n\n            // Cat\n            /; cat (b35);/i,\n            /; (b15q?|s22 flip|s48c|s62 pro)(?: bui|\\))/i\n            ], [MODEL, [VENDOR, 'Cat'], [TYPE, MOBILE]], [\n\n            // Smartfren\n            /((?:new )?andromax[\\w- ]+)(?: bui|\\))/i\n            ], [MODEL, [VENDOR, 'Smartfren'], [TYPE, MOBILE]], [\n\n            // Nothing\n            /droid.+; (a(?:015|06[35]|142p?))/i\n            ], [MODEL, [VENDOR, 'Nothing'], [TYPE, MOBILE]], [\n\n            // MIXED\n            /(blackberry|benq|palm(?=\\-)|sonyericsson|acer|asus|dell|meizu|motorola|polytron|infinix|tecno|micromax|advan)[-_ ]?([-\\w]*)/i,\n                                                                                // BlackBerry/BenQ/Palm/Sony-Ericsson/Acer/Asus/Dell/Meizu/Motorola/Polytron/Infinix/Tecno/Micromax/Advan\n            /; (imo) ((?!tab)[\\w ]+?)(?: bui|\\))/i,                             // IMO\n            /(hp) ([\\w ]+\\w)/i,                                                 // HP iPAQ\n            /(asus)-?(\\w+)/i,                                                   // Asus\n            /(microsoft); (lumia[\\w ]+)/i,                                      // Microsoft Lumia\n            /(lenovo)[-_ ]?([-\\w]+)/i,                                          // Lenovo\n            /(jolla)/i,                                                         // Jolla\n            /(oppo) ?([\\w ]+) bui/i                                             // OPPO\n            ], [VENDOR, MODEL, [TYPE, MOBILE]], [\n\n            /(imo) (tab \\w+)/i,                                                 // IMO\n            /(kobo)\\s(ereader|touch)/i,                                         // Kobo\n            /(archos) (gamepad2?)/i,                                            // Archos\n            /(hp).+(touchpad(?!.+tablet)|tablet)/i,                             // HP TouchPad\n            /(kindle)\\/([\\w\\.]+)/i,                                             // Kindle\n            /(nook)[\\w ]+build\\/(\\w+)/i,                                        // Nook\n            /(dell) (strea[kpr\\d ]*[\\dko])/i,                                   // Dell Streak\n            /(le[- ]+pan)[- ]+(\\w{1,9}) bui/i,                                  // Le Pan Tablets\n            /(trinity)[- ]*(t\\d{3}) bui/i,                                      // Trinity Tablets\n            /(gigaset)[- ]+(q\\w{1,9}) bui/i,                                    // Gigaset Tablets\n            /(vodafone) ([\\w ]+)(?:\\)| bui)/i                                   // Vodafone\n            ], [VENDOR, MODEL, [TYPE, TABLET]], [\n\n            /(surface duo)/i                                                    // Surface Duo\n            ], [MODEL, [VENDOR, MICROSOFT], [TYPE, TABLET]], [\n            /droid [\\d\\.]+; (fp\\du?)(?: b|\\))/i                                 // Fairphone\n            ], [MODEL, [VENDOR, 'Fairphone'], [TYPE, MOBILE]], [\n            /(u304aa)/i                                                         // AT&T\n            ], [MODEL, [VENDOR, 'AT&T'], [TYPE, MOBILE]], [\n            /\\bsie-(\\w*)/i                                                      // Siemens\n            ], [MODEL, [VENDOR, 'Siemens'], [TYPE, MOBILE]], [\n            /\\b(rct\\w+) b/i                                                     // RCA Tablets\n            ], [MODEL, [VENDOR, 'RCA'], [TYPE, TABLET]], [\n            /\\b(venue[\\d ]{2,7}) b/i                                            // Dell Venue Tablets\n            ], [MODEL, [VENDOR, 'Dell'], [TYPE, TABLET]], [\n            /\\b(q(?:mv|ta)\\w+) b/i                                              // Verizon Tablet\n            ], [MODEL, [VENDOR, 'Verizon'], [TYPE, TABLET]], [\n            /\\b(?:barnes[& ]+noble |bn[rt])([\\w\\+ ]*) b/i                       // Barnes & Noble Tablet\n            ], [MODEL, [VENDOR, 'Barnes & Noble'], [TYPE, TABLET]], [\n            /\\b(tm\\d{3}\\w+) b/i\n            ], [MODEL, [VENDOR, 'NuVision'], [TYPE, TABLET]], [\n            /\\b(k88) b/i                                                        // ZTE K Series Tablet\n            ], [MODEL, [VENDOR, 'ZTE'], [TYPE, TABLET]], [\n            /\\b(nx\\d{3}j) b/i                                                   // ZTE Nubia\n            ], [MODEL, [VENDOR, 'ZTE'], [TYPE, MOBILE]], [\n            /\\b(gen\\d{3}) b.+49h/i                                              // Swiss GEN Mobile\n            ], [MODEL, [VENDOR, 'Swiss'], [TYPE, MOBILE]], [\n            /\\b(zur\\d{3}) b/i                                                   // Swiss ZUR Tablet\n            ], [MODEL, [VENDOR, 'Swiss'], [TYPE, TABLET]], [\n            /\\b((zeki)?tb.*\\b) b/i                                              // Zeki Tablets\n            ], [MODEL, [VENDOR, 'Zeki'], [TYPE, TABLET]], [\n            /\\b([yr]\\d{2}) b/i,\n            /\\b(dragon[- ]+touch |dt)(\\w{5}) b/i                                // Dragon Touch Tablet\n            ], [[VENDOR, 'Dragon Touch'], MODEL, [TYPE, TABLET]], [\n            /\\b(ns-?\\w{0,9}) b/i                                                // Insignia Tablets\n            ], [MODEL, [VENDOR, 'Insignia'], [TYPE, TABLET]], [\n            /\\b((nxa|next)-?\\w{0,9}) b/i                                        // NextBook Tablets\n            ], [MODEL, [VENDOR, 'NextBook'], [TYPE, TABLET]], [\n            /\\b(xtreme\\_)?(v(1[045]|2[015]|[3469]0|7[05])) b/i                  // Voice Xtreme Phones\n            ], [[VENDOR, 'Voice'], MODEL, [TYPE, MOBILE]], [\n            /\\b(lvtel\\-)?(v1[12]) b/i                                           // LvTel Phones\n            ], [[VENDOR, 'LvTel'], MODEL, [TYPE, MOBILE]], [\n            /\\b(ph-1) /i                                                        // Essential PH-1\n            ], [MODEL, [VENDOR, 'Essential'], [TYPE, MOBILE]], [\n            /\\b(v(100md|700na|7011|917g).*\\b) b/i                               // Envizen Tablets\n            ], [MODEL, [VENDOR, 'Envizen'], [TYPE, TABLET]], [\n            /\\b(trio[-\\w\\. ]+) b/i                                              // MachSpeed Tablets\n            ], [MODEL, [VENDOR, 'MachSpeed'], [TYPE, TABLET]], [\n            /\\btu_(1491) b/i                                                    // Rotor Tablets\n            ], [MODEL, [VENDOR, 'Rotor'], [TYPE, TABLET]], [\n            /(shield[\\w ]+) b/i                                                 // Nvidia Shield Tablets\n            ], [MODEL, [VENDOR, 'Nvidia'], [TYPE, TABLET]], [\n            /(sprint) (\\w+)/i                                                   // Sprint Phones\n            ], [VENDOR, MODEL, [TYPE, MOBILE]], [\n            /(kin\\.[onetw]{3})/i                                                // Microsoft Kin\n            ], [[MODEL, /\\./g, ' '], [VENDOR, MICROSOFT], [TYPE, MOBILE]], [\n            /droid.+; (cc6666?|et5[16]|mc[239][23]x?|vc8[03]x?)\\)/i             // Zebra\n            ], [MODEL, [VENDOR, ZEBRA], [TYPE, TABLET]], [\n            /droid.+; (ec30|ps20|tc[2-8]\\d[kx])\\)/i\n            ], [MODEL, [VENDOR, ZEBRA], [TYPE, MOBILE]], [\n\n            ///////////////////\n            // SMARTTVS\n            ///////////////////\n\n            /smart-tv.+(samsung)/i                                              // Samsung\n            ], [VENDOR, [TYPE, SMARTTV]], [\n            /hbbtv.+maple;(\\d+)/i\n            ], [[MODEL, /^/, 'SmartTV'], [VENDOR, SAMSUNG], [TYPE, SMARTTV]], [\n            /(nux; netcast.+smarttv|lg (netcast\\.tv-201\\d|android tv))/i        // LG SmartTV\n            ], [[VENDOR, LG], [TYPE, SMARTTV]], [\n            /(apple) ?tv/i                                                      // Apple TV\n            ], [VENDOR, [MODEL, APPLE+' TV'], [TYPE, SMARTTV]], [\n            /crkey/i                                                            // Google Chromecast\n            ], [[MODEL, CHROME+'cast'], [VENDOR, GOOGLE], [TYPE, SMARTTV]], [\n            /droid.+aft(\\w+)( bui|\\))/i                                         // Fire TV\n            ], [MODEL, [VENDOR, AMAZON], [TYPE, SMARTTV]], [\n            /\\(dtv[\\);].+(aquos)/i,\n            /(aquos-tv[\\w ]+)\\)/i                                               // Sharp\n            ], [MODEL, [VENDOR, SHARP], [TYPE, SMARTTV]],[\n            /(bravia[\\w ]+)( bui|\\))/i                                              // Sony\n            ], [MODEL, [VENDOR, SONY], [TYPE, SMARTTV]], [\n            /(mitv-\\w{5}) bui/i                                                 // Xiaomi\n            ], [MODEL, [VENDOR, XIAOMI], [TYPE, SMARTTV]], [\n            /Hbbtv.*(technisat) (.*);/i                                         // TechniSAT\n            ], [VENDOR, MODEL, [TYPE, SMARTTV]], [\n            /\\b(roku)[\\dx]*[\\)\\/]((?:dvp-)?[\\d\\.]*)/i,                          // Roku\n            /hbbtv\\/\\d+\\.\\d+\\.\\d+ +\\([\\w\\+ ]*; *([\\w\\d][^;]*);([^;]*)/i         // HbbTV devices\n            ], [[VENDOR, trim], [MODEL, trim], [TYPE, SMARTTV]], [\n            /\\b(android tv|smart[- ]?tv|opera tv|tv; rv:)\\b/i                   // SmartTV from Unidentified Vendors\n            ], [[TYPE, SMARTTV]], [\n\n            ///////////////////\n            // CONSOLES\n            ///////////////////\n\n            /(ouya)/i,                                                          // Ouya\n            /(nintendo) ([wids3utch]+)/i                                        // Nintendo\n            ], [VENDOR, MODEL, [TYPE, CONSOLE]], [\n            /droid.+; (shield) bui/i                                            // Nvidia\n            ], [MODEL, [VENDOR, 'Nvidia'], [TYPE, CONSOLE]], [\n            /(playstation [345portablevi]+)/i                                   // Playstation\n            ], [MODEL, [VENDOR, SONY], [TYPE, CONSOLE]], [\n            /\\b(xbox(?: one)?(?!; xbox))[\\); ]/i                                // Microsoft Xbox\n            ], [MODEL, [VENDOR, MICROSOFT], [TYPE, CONSOLE]], [\n\n            ///////////////////\n            // WEARABLES\n            ///////////////////\n\n            /\\b(sm-[lr]\\d\\d[05][fnuw]?s?)\\b/i                                   // Samsung Galaxy Watch\n            ], [MODEL, [VENDOR, SAMSUNG], [TYPE, WEARABLE]], [\n            /((pebble))app/i                                                    // Pebble\n            ], [VENDOR, MODEL, [TYPE, WEARABLE]], [\n            /(watch)(?: ?os[,\\/]|\\d,\\d\\/)[\\d\\.]+/i                              // Apple Watch\n            ], [MODEL, [VENDOR, APPLE], [TYPE, WEARABLE]], [\n            /droid.+; (glass) \\d/i                                              // Google Glass\n            ], [MODEL, [VENDOR, GOOGLE], [TYPE, WEARABLE]], [\n            /droid.+; (wt63?0{2,3})\\)/i\n            ], [MODEL, [VENDOR, ZEBRA], [TYPE, WEARABLE]], [\n\n            ///////////////////\n            // XR\n            ///////////////////\n\n            /droid.+; (glass) \\d/i                                              // Google Glass\n            ], [MODEL, [VENDOR, GOOGLE], [TYPE, WEARABLE]], [\n            /(pico) (4|neo3(?: link|pro)?)/i                                    // Pico\n            ], [VENDOR, MODEL, [TYPE, WEARABLE]], [\n            /; (quest( \\d| pro)?)/i                                             // Oculus Quest\n            ], [MODEL, [VENDOR, FACEBOOK], [TYPE, WEARABLE]], [\n\n            ///////////////////\n            // EMBEDDED\n            ///////////////////\n\n            /(tesla)(?: qtcarbrowser|\\/[-\\w\\.]+)/i                              // Tesla\n            ], [VENDOR, [TYPE, EMBEDDED]], [\n            /(aeobc)\\b/i                                                        // Echo Dot\n            ], [MODEL, [VENDOR, AMAZON], [TYPE, EMBEDDED]], [\n\n            ////////////////////\n            // MIXED (GENERIC)\n            ///////////////////\n\n            /droid .+?; ([^;]+?)(?: bui|; wv\\)|\\) applew).+? mobile safari/i    // Android Phones from Unidentified Vendors\n            ], [MODEL, [TYPE, MOBILE]], [\n            /droid .+?; ([^;]+?)(?: bui|\\) applew).+?(?! mobile) safari/i       // Android Tablets from Unidentified Vendors\n            ], [MODEL, [TYPE, TABLET]], [\n            /\\b((tablet|tab)[;\\/]|focus\\/\\d(?!.+mobile))/i                      // Unidentifiable Tablet\n            ], [[TYPE, TABLET]], [\n            /(phone|mobile(?:[;\\/]| [ \\w\\/\\.]*safari)|pda(?=.+windows ce))/i    // Unidentifiable Mobile\n            ], [[TYPE, MOBILE]], [\n            /(android[-\\w\\. ]{0,9});.+buil/i                                    // Generic Android Device\n            ], [MODEL, [VENDOR, 'Generic']]\n        ],\n\n        engine : [[\n\n            /windows.+ edge\\/([\\w\\.]+)/i                                       // EdgeHTML\n            ], [VERSION, [NAME, EDGE+'HTML']], [\n\n            /(arkweb)\\/([\\w\\.]+)/i                                              // ArkWeb\n            ], [NAME, VERSION], [\n\n            /webkit\\/537\\.36.+chrome\\/(?!27)([\\w\\.]+)/i                         // Blink\n            ], [VERSION, [NAME, 'Blink']], [\n\n            /(presto)\\/([\\w\\.]+)/i,                                             // Presto\n            /(webkit|trident|netfront|netsurf|amaya|lynx|w3m|goanna|servo)\\/([\\w\\.]+)/i, // WebKit/Trident/NetFront/NetSurf/Amaya/Lynx/w3m/Goanna/Servo\n            /ekioh(flow)\\/([\\w\\.]+)/i,                                          // Flow\n            /(khtml|tasman|links)[\\/ ]\\(?([\\w\\.]+)/i,                           // KHTML/Tasman/Links\n            /(icab)[\\/ ]([23]\\.[\\d\\.]+)/i,                                      // iCab\n            /\\b(libweb)/i\n            ], [NAME, VERSION], [\n\n            /rv\\:([\\w\\.]{1,9})\\b.+(gecko)/i                                     // Gecko\n            ], [VERSION, NAME]\n        ],\n\n        os : [[\n\n            // Windows\n            /microsoft (windows) (vista|xp)/i                                   // Windows (iTunes)\n            ], [NAME, VERSION], [\n            /(windows (?:phone(?: os)?|mobile))[\\/ ]?([\\d\\.\\w ]*)/i             // Windows Phone\n            ], [NAME, [VERSION, strMapper, windowsVersionMap]], [\n            /windows nt 6\\.2; (arm)/i,                                        // Windows RT\n            /windows[\\/ ]?([ntce\\d\\. ]+\\w)(?!.+xbox)/i,\n            /(?:win(?=3|9|n)|win 9x )([nt\\d\\.]+)/i\n            ], [[VERSION, strMapper, windowsVersionMap], [NAME, 'Windows']], [\n\n            // iOS/macOS\n            /ip[honead]{2,4}\\b(?:.*os ([\\w]+) like mac|; opera)/i,              // iOS\n            /(?:ios;fbsv\\/|iphone.+ios[\\/ ])([\\d\\.]+)/i,\n            /cfnetwork\\/.+darwin/i\n            ], [[VERSION, /_/g, '.'], [NAME, 'iOS']], [\n            /(mac os x) ?([\\w\\. ]*)/i,\n            /(macintosh|mac_powerpc\\b)(?!.+haiku)/i                             // Mac OS\n            ], [[NAME, MAC_OS], [VERSION, /_/g, '.']], [\n\n            // Mobile OSes\n            /droid ([\\w\\.]+)\\b.+(android[- ]x86|harmonyos)/i                    // Android-x86/HarmonyOS\n            ], [VERSION, NAME], [                                               // Android/WebOS/QNX/Bada/RIM/Maemo/MeeGo/Sailfish OS/OpenHarmony\n            /(android|webos|qnx|bada|rim tablet os|maemo|meego|sailfish|openharmony)[-\\/ ]?([\\w\\.]*)/i,\n            /(blackberry)\\w*\\/([\\w\\.]*)/i,                                      // Blackberry\n            /(tizen|kaios)[\\/ ]([\\w\\.]+)/i,                                     // Tizen/KaiOS\n            /\\((series40);/i                                                    // Series 40\n            ], [NAME, VERSION], [\n            /\\(bb(10);/i                                                        // BlackBerry 10\n            ], [VERSION, [NAME, BLACKBERRY]], [\n            /(?:symbian ?os|symbos|s60(?=;)|series60)[-\\/ ]?([\\w\\.]*)/i         // Symbian\n            ], [VERSION, [NAME, 'Symbian']], [\n            /mozilla\\/[\\d\\.]+ \\((?:mobile|tablet|tv|mobile; [\\w ]+); rv:.+ gecko\\/([\\w\\.]+)/i // Firefox OS\n            ], [VERSION, [NAME, FIREFOX+' OS']], [\n            /web0s;.+rt(tv)/i,\n            /\\b(?:hp)?wos(?:browser)?\\/([\\w\\.]+)/i                              // WebOS\n            ], [VERSION, [NAME, 'webOS']], [\n            /watch(?: ?os[,\\/]|\\d,\\d\\/)([\\d\\.]+)/i                              // watchOS\n            ], [VERSION, [NAME, 'watchOS']], [\n\n            // Google Chromecast\n            /crkey\\/([\\d\\.]+)/i                                                 // Google Chromecast\n            ], [VERSION, [NAME, CHROME+'cast']], [\n            /(cros) [\\w]+(?:\\)| ([\\w\\.]+)\\b)/i                                  // Chromium OS\n            ], [[NAME, CHROMIUM_OS], VERSION],[\n\n            // Smart TVs\n            /panasonic;(viera)/i,                                               // Panasonic Viera\n            /(netrange)mmh/i,                                                   // Netrange\n            /(nettv)\\/(\\d+\\.[\\w\\.]+)/i,                                         // NetTV\n\n            // Console\n            /(nintendo|playstation) ([wids345portablevuch]+)/i,                 // Nintendo/Playstation\n            /(xbox); +xbox ([^\\);]+)/i,                                         // Microsoft Xbox (360, One, X, S, Series X, Series S)\n\n            // Other\n            /\\b(joli|palm)\\b ?(?:os)?\\/?([\\w\\.]*)/i,                            // Joli/Palm\n            /(mint)[\\/\\(\\) ]?(\\w*)/i,                                           // Mint\n            /(mageia|vectorlinux)[; ]/i,                                        // Mageia/VectorLinux\n            /([kxln]?ubuntu|debian|suse|opensuse|gentoo|arch(?= linux)|slackware|fedora|mandriva|centos|pclinuxos|red ?hat|zenwalk|linpus|raspbian|plan 9|minix|risc os|contiki|deepin|manjaro|elementary os|sabayon|linspire)(?: gnu\\/linux)?(?: enterprise)?(?:[- ]linux)?(?:-gnu)?[-\\/ ]?(?!chrom|package)([-\\w\\.]*)/i,\n                                                                                // Ubuntu/Debian/SUSE/Gentoo/Arch/Slackware/Fedora/Mandriva/CentOS/PCLinuxOS/RedHat/Zenwalk/Linpus/Raspbian/Plan9/Minix/RISCOS/Contiki/Deepin/Manjaro/elementary/Sabayon/Linspire\n            /(hurd|linux) ?([\\w\\.]*)/i,                                         // Hurd/Linux\n            /(gnu) ?([\\w\\.]*)/i,                                                // GNU\n            /\\b([-frentopcghs]{0,5}bsd|dragonfly)[\\/ ]?(?!amd|[ix346]{1,2}86)([\\w\\.]*)/i, // FreeBSD/NetBSD/OpenBSD/PC-BSD/GhostBSD/DragonFly\n            /(haiku) (\\w+)/i                                                    // Haiku\n            ], [NAME, VERSION], [\n            /(sunos) ?([\\w\\.\\d]*)/i                                             // Solaris\n            ], [[NAME, 'Solaris'], VERSION], [\n            /((?:open)?solaris)[-\\/ ]?([\\w\\.]*)/i,                              // Solaris\n            /(aix) ((\\d)(?=\\.|\\)| )[\\w\\.])*/i,                                  // AIX\n            /\\b(beos|os\\/2|amigaos|morphos|openvms|fuchsia|hp-ux|serenityos)/i, // BeOS/OS2/AmigaOS/MorphOS/OpenVMS/Fuchsia/HP-UX/SerenityOS\n            /(unix) ?([\\w\\.]*)/i                                                // UNIX\n            ], [NAME, VERSION]\n        ]\n    };\n\n    /////////////////\n    // Constructor\n    ////////////////\n\n    var UAParser = function (ua, extensions) {\n\n        if (typeof ua === OBJ_TYPE) {\n            extensions = ua;\n            ua = undefined;\n        }\n\n        if (!(this instanceof UAParser)) {\n            return new UAParser(ua, extensions).getResult();\n        }\n\n        var _navigator = (typeof window !== UNDEF_TYPE && window.navigator) ? window.navigator : undefined;\n        var _ua = ua || ((_navigator && _navigator.userAgent) ? _navigator.userAgent : EMPTY);\n        var _uach = (_navigator && _navigator.userAgentData) ? _navigator.userAgentData : undefined;\n        var _rgxmap = extensions ? extend(regexes, extensions) : regexes;\n        var _isSelfNav = _navigator && _navigator.userAgent == _ua;\n\n        this.getBrowser = function () {\n            var _browser = {};\n            _browser[NAME] = undefined;\n            _browser[VERSION] = undefined;\n            rgxMapper.call(_browser, _ua, _rgxmap.browser);\n            _browser[MAJOR] = majorize(_browser[VERSION]);\n            // Brave-specific detection\n            if (_isSelfNav && _navigator && _navigator.brave && typeof _navigator.brave.isBrave == FUNC_TYPE) {\n                _browser[NAME] = 'Brave';\n            }\n            return _browser;\n        };\n        this.getCPU = function () {\n            var _cpu = {};\n            _cpu[ARCHITECTURE] = undefined;\n            rgxMapper.call(_cpu, _ua, _rgxmap.cpu);\n            return _cpu;\n        };\n        this.getDevice = function () {\n            var _device = {};\n            _device[VENDOR] = undefined;\n            _device[MODEL] = undefined;\n            _device[TYPE] = undefined;\n            rgxMapper.call(_device, _ua, _rgxmap.device);\n            if (_isSelfNav && !_device[TYPE] && _uach && _uach.mobile) {\n                _device[TYPE] = MOBILE;\n            }\n            // iPadOS-specific detection: identified as Mac, but has some iOS-only properties\n            if (_isSelfNav && _device[MODEL] == 'Macintosh' && _navigator && typeof _navigator.standalone !== UNDEF_TYPE && _navigator.maxTouchPoints && _navigator.maxTouchPoints > 2) {\n                _device[MODEL] = 'iPad';\n                _device[TYPE] = TABLET;\n            }\n            return _device;\n        };\n        this.getEngine = function () {\n            var _engine = {};\n            _engine[NAME] = undefined;\n            _engine[VERSION] = undefined;\n            rgxMapper.call(_engine, _ua, _rgxmap.engine);\n            return _engine;\n        };\n        this.getOS = function () {\n            var _os = {};\n            _os[NAME] = undefined;\n            _os[VERSION] = undefined;\n            rgxMapper.call(_os, _ua, _rgxmap.os);\n            if (_isSelfNav && !_os[NAME] && _uach && _uach.platform && _uach.platform != 'Unknown') {\n                _os[NAME] = _uach.platform  \n                                    .replace(/chrome os/i, CHROMIUM_OS)\n                                    .replace(/macos/i, MAC_OS);           // backward compatibility\n            }\n            return _os;\n        };\n        this.getResult = function () {\n            return {\n                ua      : this.getUA(),\n                browser : this.getBrowser(),\n                engine  : this.getEngine(),\n                os      : this.getOS(),\n                device  : this.getDevice(),\n                cpu     : this.getCPU()\n            };\n        };\n        this.getUA = function () {\n            return _ua;\n        };\n        this.setUA = function (ua) {\n            _ua = (typeof ua === STR_TYPE && ua.length > UA_MAX_LENGTH) ? trim(ua, UA_MAX_LENGTH) : ua;\n            return this;\n        };\n        this.setUA(_ua);\n        return this;\n    };\n\n    UAParser.VERSION = LIBVERSION;\n    UAParser.BROWSER =  enumerize([NAME, VERSION, MAJOR]);\n    UAParser.CPU = enumerize([ARCHITECTURE]);\n    UAParser.DEVICE = enumerize([MODEL, VENDOR, TYPE, CONSOLE, MOBILE, SMARTTV, TABLET, WEARABLE, EMBEDDED]);\n    UAParser.ENGINE = UAParser.OS = enumerize([NAME, VERSION]);\n\n    ///////////\n    // Export\n    //////////\n\n    // check js environment\n    if (typeof(exports) !== UNDEF_TYPE) {\n        // nodejs env\n        if (typeof module !== UNDEF_TYPE && module.exports) {\n            exports = module.exports = UAParser;\n        }\n        exports.UAParser = UAParser;\n    } else {\n        // requirejs env (optional)\n        if (typeof(define) === FUNC_TYPE && define.amd) {\n            define(function () {\n                return UAParser;\n            });\n        } else if (typeof window !== UNDEF_TYPE) {\n            // browser env\n            window.UAParser = UAParser;\n        }\n    }\n\n    // jQuery/Zepto specific (optional)\n    // Note:\n    //   In AMD env the global scope should be kept clean, but jQuery is an exception.\n    //   jQuery always exports to global scope, unless jQuery.noConflict(true) is used,\n    //   and we should catch that.\n    var $ = typeof window !== UNDEF_TYPE && (window.jQuery || window.Zepto);\n    if ($ && !$.ua) {\n        var parser = new UAParser();\n        $.ua = parser.getResult();\n        $.ua.get = function () {\n            return parser.getUA();\n        };\n        $.ua.set = function (ua) {\n            parser.setUA(ua);\n            var result = parser.getResult();\n            for (var prop in result) {\n                $.ua[prop] = result[prop];\n            }\n        };\n    }\n\n})(typeof window === 'object' ? window : this);\n","import { __assign } from \"tslib\";\nfunction ItoI(a) {\n    return a;\n}\nfunction innerCreateMedium(defaults, middleware) {\n    if (middleware === void 0) { middleware = ItoI; }\n    var buffer = [];\n    var assigned = false;\n    var medium = {\n        read: function () {\n            if (assigned) {\n                throw new Error('Sidecar: could not `read` from an `assigned` medium. `read` could be used only with `useMedium`.');\n            }\n            if (buffer.length) {\n                return buffer[buffer.length - 1];\n            }\n            return defaults;\n        },\n        useMedium: function (data) {\n            var item = middleware(data, assigned);\n            buffer.push(item);\n            return function () {\n                buffer = buffer.filter(function (x) { return x !== item; });\n            };\n        },\n        assignSyncMedium: function (cb) {\n            assigned = true;\n            while (buffer.length) {\n                var cbs = buffer;\n                buffer = [];\n                cbs.forEach(cb);\n            }\n            buffer = {\n                push: function (x) { return cb(x); },\n                filter: function () { return buffer; },\n            };\n        },\n        assignMedium: function (cb) {\n            assigned = true;\n            var pendingQueue = [];\n            if (buffer.length) {\n                var cbs = buffer;\n                buffer = [];\n                cbs.forEach(cb);\n                pendingQueue = buffer;\n            }\n            var executeQueue = function () {\n                var cbs = pendingQueue;\n                pendingQueue = [];\n                cbs.forEach(cb);\n            };\n            var cycle = function () { return Promise.resolve().then(executeQueue); };\n            cycle();\n            buffer = {\n                push: function (x) {\n                    pendingQueue.push(x);\n                    cycle();\n                },\n                filter: function (filter) {\n                    pendingQueue = pendingQueue.filter(filter);\n                    return buffer;\n                },\n            };\n        },\n    };\n    return medium;\n}\nexport function createMedium(defaults, middleware) {\n    if (middleware === void 0) { middleware = ItoI; }\n    return innerCreateMedium(defaults, middleware);\n}\n// eslint-disable-next-line @typescript-eslint/ban-types\nexport function createSidecarMedium(options) {\n    if (options === void 0) { options = {}; }\n    var medium = innerCreateMedium(null);\n    medium.options = __assign({ async: true, ssr: false }, options);\n    return medium;\n}\n","'use strict';\n\nvar whichTypedArray = require('which-typed-array');\n\n/** @type {import('.')} */\nmodule.exports = function isTypedArray(value) {\n\treturn !!whichTypedArray(value);\n};\n","'use strict';\n\nvar forEach = require('for-each');\nvar availableTypedArrays = require('available-typed-arrays');\nvar callBind = require('call-bind');\nvar callBound = require('call-bound');\nvar gOPD = require('gopd');\n\n/** @type {(O: object) => string} */\nvar $toString = callBound('Object.prototype.toString');\nvar hasToStringTag = require('has-tostringtag/shams')();\n\nvar g = typeof globalThis === 'undefined' ? global : globalThis;\nvar typedArrays = availableTypedArrays();\n\nvar $slice = callBound('String.prototype.slice');\nvar getPrototypeOf = Object.getPrototypeOf; // require('getprototypeof');\n\n/** @type {<T = unknown>(array: readonly T[], value: unknown) => number} */\nvar $indexOf = callBound('Array.prototype.indexOf', true) || function indexOf(array, value) {\n\tfor (var i = 0; i < array.length; i += 1) {\n\t\tif (array[i] === value) {\n\t\t\treturn i;\n\t\t}\n\t}\n\treturn -1;\n};\n\n/** @typedef {(receiver: import('.').TypedArray) => string | typeof Uint8Array.prototype.slice.call | typeof Uint8Array.prototype.set.call} Getter */\n/** @type {{ [k in `\\$${import('.').TypedArrayName}`]?: Getter } & { __proto__: null }} */\nvar cache = { __proto__: null };\nif (hasToStringTag && gOPD && getPrototypeOf) {\n\tforEach(typedArrays, function (typedArray) {\n\t\tvar arr = new g[typedArray]();\n\t\tif (Symbol.toStringTag in arr) {\n\t\t\tvar proto = getPrototypeOf(arr);\n\t\t\t// @ts-expect-error TS won't narrow inside a closure\n\t\t\tvar descriptor = gOPD(proto, Symbol.toStringTag);\n\t\t\tif (!descriptor) {\n\t\t\t\tvar superProto = getPrototypeOf(proto);\n\t\t\t\t// @ts-expect-error TS won't narrow inside a closure\n\t\t\t\tdescriptor = gOPD(superProto, Symbol.toStringTag);\n\t\t\t}\n\t\t\t// @ts-expect-error TODO: fix\n\t\t\tcache['$' + typedArray] = callBind(descriptor.get);\n\t\t}\n\t});\n} else {\n\tforEach(typedArrays, function (typedArray) {\n\t\tvar arr = new g[typedArray]();\n\t\tvar fn = arr.slice || arr.set;\n\t\tif (fn) {\n\t\t\t// @ts-expect-error TODO: fix\n\t\t\tcache['$' + typedArray] = callBind(fn);\n\t\t}\n\t});\n}\n\n/** @type {(value: object) => false | import('.').TypedArrayName} */\nvar tryTypedArrays = function tryAllTypedArrays(value) {\n\t/** @type {ReturnType<typeof tryAllTypedArrays>} */ var found = false;\n\tforEach(\n\t\t// eslint-disable-next-line no-extra-parens\n\t\t/** @type {Record<`\\$${TypedArrayName}`, Getter>} */ /** @type {any} */ (cache),\n\t\t/** @type {(getter: Getter, name: `\\$${import('.').TypedArrayName}`) => void} */\n\t\tfunction (getter, typedArray) {\n\t\t\tif (!found) {\n\t\t\t\ttry {\n\t\t\t\t// @ts-expect-error TODO: fix\n\t\t\t\t\tif ('$' + getter(value) === typedArray) {\n\t\t\t\t\t\tfound = $slice(typedArray, 1);\n\t\t\t\t\t}\n\t\t\t\t} catch (e) { /**/ }\n\t\t\t}\n\t\t}\n\t);\n\treturn found;\n};\n\n/** @type {(value: object) => false | import('.').TypedArrayName} */\nvar trySlices = function tryAllSlices(value) {\n\t/** @type {ReturnType<typeof tryAllSlices>} */ var found = false;\n\tforEach(\n\t\t// eslint-disable-next-line no-extra-parens\n\t\t/** @type {Record<`\\$${TypedArrayName}`, Getter>} */ /** @type {any} */ (cache),\n\t\t/** @type {(getter: typeof cache, name: `\\$${import('.').TypedArrayName}`) => void} */ function (getter, name) {\n\t\t\tif (!found) {\n\t\t\t\ttry {\n\t\t\t\t\t// @ts-expect-error TODO: fix\n\t\t\t\t\tgetter(value);\n\t\t\t\t\tfound = $slice(name, 1);\n\t\t\t\t} catch (e) { /**/ }\n\t\t\t}\n\t\t}\n\t);\n\treturn found;\n};\n\n/** @type {import('.')} */\nmodule.exports = function whichTypedArray(value) {\n\tif (!value || typeof value !== 'object') { return false; }\n\tif (!hasToStringTag) {\n\t\t/** @type {string} */\n\t\tvar tag = $slice($toString(value), 8, -1);\n\t\tif ($indexOf(typedArrays, tag) > -1) {\n\t\t\treturn tag;\n\t\t}\n\t\tif (tag !== 'Object') {\n\t\t\treturn false;\n\t\t}\n\t\t// node < 0.6 hits here on real Typed Arrays\n\t\treturn trySlices(value);\n\t}\n\tif (!gOPD) { return null; } // unknown engine\n\treturn tryTypedArrays(value);\n};\n","'use strict';\n\nvar forEach = require('for-each');\nvar availableTypedArrays = require('available-typed-arrays');\nvar callBind = require('call-bind');\nvar callBound = require('call-bind/callBound');\nvar gOPD = require('gopd');\n\n/** @type {(O: object) => string} */\nvar $toString = callBound('Object.prototype.toString');\nvar hasToStringTag = require('has-tostringtag/shams')();\n\nvar g = typeof globalThis === 'undefined' ? global : globalThis;\nvar typedArrays = availableTypedArrays();\n\nvar $slice = callBound('String.prototype.slice');\nvar getPrototypeOf = Object.getPrototypeOf; // require('getprototypeof');\n\n/** @type {<T = unknown>(array: readonly T[], value: unknown) => number} */\nvar $indexOf = callBound('Array.prototype.indexOf', true) || function indexOf(array, value) {\n\tfor (var i = 0; i < array.length; i += 1) {\n\t\tif (array[i] === value) {\n\t\t\treturn i;\n\t\t}\n\t}\n\treturn -1;\n};\n\n/** @typedef {(receiver: import('.').TypedArray) => string | typeof Uint8Array.prototype.slice.call | typeof Uint8Array.prototype.set.call} Getter */\n/** @type {{ [k in `\\$${import('.').TypedArrayName}`]?: Getter } & { __proto__: null }} */\nvar cache = { __proto__: null };\nif (hasToStringTag && gOPD && getPrototypeOf) {\n\tforEach(typedArrays, function (typedArray) {\n\t\tvar arr = new g[typedArray]();\n\t\tif (Symbol.toStringTag in arr) {\n\t\t\tvar proto = getPrototypeOf(arr);\n\t\t\t// @ts-expect-error TS won't narrow inside a closure\n\t\t\tvar descriptor = gOPD(proto, Symbol.toStringTag);\n\t\t\tif (!descriptor) {\n\t\t\t\tvar superProto = getPrototypeOf(proto);\n\t\t\t\t// @ts-expect-error TS won't narrow inside a closure\n\t\t\t\tdescriptor = gOPD(superProto, Symbol.toStringTag);\n\t\t\t}\n\t\t\t// @ts-expect-error TODO: fix\n\t\t\tcache['$' + typedArray] = callBind(descriptor.get);\n\t\t}\n\t});\n} else {\n\tforEach(typedArrays, function (typedArray) {\n\t\tvar arr = new g[typedArray]();\n\t\tvar fn = arr.slice || arr.set;\n\t\tif (fn) {\n\t\t\t// @ts-expect-error TODO: fix\n\t\t\tcache['$' + typedArray] = callBind(fn);\n\t\t}\n\t});\n}\n\n/** @type {(value: object) => false | import('.').TypedArrayName} */\nvar tryTypedArrays = function tryAllTypedArrays(value) {\n\t/** @type {ReturnType<typeof tryAllTypedArrays>} */ var found = false;\n\tforEach(\n\t\t// eslint-disable-next-line no-extra-parens\n\t\t/** @type {Record<`\\$${TypedArrayName}`, Getter>} */ /** @type {any} */ (cache),\n\t\t/** @type {(getter: Getter, name: `\\$${import('.').TypedArrayName}`) => void} */\n\t\tfunction (getter, typedArray) {\n\t\t\tif (!found) {\n\t\t\t\ttry {\n\t\t\t\t// @ts-expect-error TODO: fix\n\t\t\t\t\tif ('$' + getter(value) === typedArray) {\n\t\t\t\t\t\tfound = $slice(typedArray, 1);\n\t\t\t\t\t}\n\t\t\t\t} catch (e) { /**/ }\n\t\t\t}\n\t\t}\n\t);\n\treturn found;\n};\n\n/** @type {(value: object) => false | import('.').TypedArrayName} */\nvar trySlices = function tryAllSlices(value) {\n\t/** @type {ReturnType<typeof tryAllSlices>} */ var found = false;\n\tforEach(\n\t\t// eslint-disable-next-line no-extra-parens\n\t\t/** @type {Record<`\\$${TypedArrayName}`, Getter>} */ /** @type {any} */ (cache),\n\t\t/** @type {(getter: typeof cache, name: `\\$${import('.').TypedArrayName}`) => void} */ function (getter, name) {\n\t\t\tif (!found) {\n\t\t\t\ttry {\n\t\t\t\t\t// @ts-expect-error TODO: fix\n\t\t\t\t\tgetter(value);\n\t\t\t\t\tfound = $slice(name, 1);\n\t\t\t\t} catch (e) { /**/ }\n\t\t\t}\n\t\t}\n\t);\n\treturn found;\n};\n\n/** @type {import('.')} */\nmodule.exports = function whichTypedArray(value) {\n\tif (!value || typeof value !== 'object') { return false; }\n\tif (!hasToStringTag) {\n\t\t/** @type {string} */\n\t\tvar tag = $slice($toString(value), 8, -1);\n\t\tif ($indexOf(typedArrays, tag) > -1) {\n\t\t\treturn tag;\n\t\t}\n\t\tif (tag !== 'Object') {\n\t\t\treturn false;\n\t\t}\n\t\t// node < 0.6 hits here on real Typed Arrays\n\t\treturn trySlices(value);\n\t}\n\tif (!gOPD) { return null; } // unknown engine\n\treturn tryTypedArrays(value);\n};\n","module.exports = function isBuffer(arg) {\n  return arg && typeof arg === 'object'\n    && typeof arg.copy === 'function'\n    && typeof arg.fill === 'function'\n    && typeof arg.readUInt8 === 'function';\n}","// Currently in sync with Node.js lib/internal/util/types.js\n// https://github.com/nodejs/node/commit/112cc7c27551254aa2b17098fb774867f05ed0d9\n\n'use strict';\n\nvar isArgumentsObject = require('is-arguments');\nvar isGeneratorFunction = require('is-generator-function');\nvar whichTypedArray = require('which-typed-array');\nvar isTypedArray = require('is-typed-array');\n\nfunction uncurryThis(f) {\n  return f.call.bind(f);\n}\n\nvar BigIntSupported = typeof BigInt !== 'undefined';\nvar SymbolSupported = typeof Symbol !== 'undefined';\n\nvar ObjectToString = uncurryThis(Object.prototype.toString);\n\nvar numberValue = uncurryThis(Number.prototype.valueOf);\nvar stringValue = uncurryThis(String.prototype.valueOf);\nvar booleanValue = uncurryThis(Boolean.prototype.valueOf);\n\nif (BigIntSupported) {\n  var bigIntValue = uncurryThis(BigInt.prototype.valueOf);\n}\n\nif (SymbolSupported) {\n  var symbolValue = uncurryThis(Symbol.prototype.valueOf);\n}\n\nfunction checkBoxedPrimitive(value, prototypeValueOf) {\n  if (typeof value !== 'object') {\n    return false;\n  }\n  try {\n    prototypeValueOf(value);\n    return true;\n  } catch(e) {\n    return false;\n  }\n}\n\nexports.isArgumentsObject = isArgumentsObject;\nexports.isGeneratorFunction = isGeneratorFunction;\nexports.isTypedArray = isTypedArray;\n\n// Taken from here and modified for better browser support\n// https://github.com/sindresorhus/p-is-promise/blob/cda35a513bda03f977ad5cde3a079d237e82d7ef/index.js\nfunction isPromise(input) {\n\treturn (\n\t\t(\n\t\t\ttypeof Promise !== 'undefined' &&\n\t\t\tinput instanceof Promise\n\t\t) ||\n\t\t(\n\t\t\tinput !== null &&\n\t\t\ttypeof input === 'object' &&\n\t\t\ttypeof input.then === 'function' &&\n\t\t\ttypeof input.catch === 'function'\n\t\t)\n\t);\n}\nexports.isPromise = isPromise;\n\nfunction isArrayBufferView(value) {\n  if (typeof ArrayBuffer !== 'undefined' && ArrayBuffer.isView) {\n    return ArrayBuffer.isView(value);\n  }\n\n  return (\n    isTypedArray(value) ||\n    isDataView(value)\n  );\n}\nexports.isArrayBufferView = isArrayBufferView;\n\n\nfunction isUint8Array(value) {\n  return whichTypedArray(value) === 'Uint8Array';\n}\nexports.isUint8Array = isUint8Array;\n\nfunction isUint8ClampedArray(value) {\n  return whichTypedArray(value) === 'Uint8ClampedArray';\n}\nexports.isUint8ClampedArray = isUint8ClampedArray;\n\nfunction isUint16Array(value) {\n  return whichTypedArray(value) === 'Uint16Array';\n}\nexports.isUint16Array = isUint16Array;\n\nfunction isUint32Array(value) {\n  return whichTypedArray(value) === 'Uint32Array';\n}\nexports.isUint32Array = isUint32Array;\n\nfunction isInt8Array(value) {\n  return whichTypedArray(value) === 'Int8Array';\n}\nexports.isInt8Array = isInt8Array;\n\nfunction isInt16Array(value) {\n  return whichTypedArray(value) === 'Int16Array';\n}\nexports.isInt16Array = isInt16Array;\n\nfunction isInt32Array(value) {\n  return whichTypedArray(value) === 'Int32Array';\n}\nexports.isInt32Array = isInt32Array;\n\nfunction isFloat32Array(value) {\n  return whichTypedArray(value) === 'Float32Array';\n}\nexports.isFloat32Array = isFloat32Array;\n\nfunction isFloat64Array(value) {\n  return whichTypedArray(value) === 'Float64Array';\n}\nexports.isFloat64Array = isFloat64Array;\n\nfunction isBigInt64Array(value) {\n  return whichTypedArray(value) === 'BigInt64Array';\n}\nexports.isBigInt64Array = isBigInt64Array;\n\nfunction isBigUint64Array(value) {\n  return whichTypedArray(value) === 'BigUint64Array';\n}\nexports.isBigUint64Array = isBigUint64Array;\n\nfunction isMapToString(value) {\n  return ObjectToString(value) === '[object Map]';\n}\nisMapToString.working = (\n  typeof Map !== 'undefined' &&\n  isMapToString(new Map())\n);\n\nfunction isMap(value) {\n  if (typeof Map === 'undefined') {\n    return false;\n  }\n\n  return isMapToString.working\n    ? isMapToString(value)\n    : value instanceof Map;\n}\nexports.isMap = isMap;\n\nfunction isSetToString(value) {\n  return ObjectToString(value) === '[object Set]';\n}\nisSetToString.working = (\n  typeof Set !== 'undefined' &&\n  isSetToString(new Set())\n);\nfunction isSet(value) {\n  if (typeof Set === 'undefined') {\n    return false;\n  }\n\n  return isSetToString.working\n    ? isSetToString(value)\n    : value instanceof Set;\n}\nexports.isSet = isSet;\n\nfunction isWeakMapToString(value) {\n  return ObjectToString(value) === '[object WeakMap]';\n}\nisWeakMapToString.working = (\n  typeof WeakMap !== 'undefined' &&\n  isWeakMapToString(new WeakMap())\n);\nfunction isWeakMap(value) {\n  if (typeof WeakMap === 'undefined') {\n    return false;\n  }\n\n  return isWeakMapToString.working\n    ? isWeakMapToString(value)\n    : value instanceof WeakMap;\n}\nexports.isWeakMap = isWeakMap;\n\nfunction isWeakSetToString(value) {\n  return ObjectToString(value) === '[object WeakSet]';\n}\nisWeakSetToString.working = (\n  typeof WeakSet !== 'undefined' &&\n  isWeakSetToString(new WeakSet())\n);\nfunction isWeakSet(value) {\n  return isWeakSetToString(value);\n}\nexports.isWeakSet = isWeakSet;\n\nfunction isArrayBufferToString(value) {\n  return ObjectToString(value) === '[object ArrayBuffer]';\n}\nisArrayBufferToString.working = (\n  typeof ArrayBuffer !== 'undefined' &&\n  isArrayBufferToString(new ArrayBuffer())\n);\nfunction isArrayBuffer(value) {\n  if (typeof ArrayBuffer === 'undefined') {\n    return false;\n  }\n\n  return isArrayBufferToString.working\n    ? isArrayBufferToString(value)\n    : value instanceof ArrayBuffer;\n}\nexports.isArrayBuffer = isArrayBuffer;\n\nfunction isDataViewToString(value) {\n  return ObjectToString(value) === '[object DataView]';\n}\nisDataViewToString.working = (\n  typeof ArrayBuffer !== 'undefined' &&\n  typeof DataView !== 'undefined' &&\n  isDataViewToString(new DataView(new ArrayBuffer(1), 0, 1))\n);\nfunction isDataView(value) {\n  if (typeof DataView === 'undefined') {\n    return false;\n  }\n\n  return isDataViewToString.working\n    ? isDataViewToString(value)\n    : value instanceof DataView;\n}\nexports.isDataView = isDataView;\n\n// Store a copy of SharedArrayBuffer in case it's deleted elsewhere\nvar SharedArrayBufferCopy = typeof SharedArrayBuffer !== 'undefined' ? SharedArrayBuffer : undefined;\nfunction isSharedArrayBufferToString(value) {\n  return ObjectToString(value) === '[object SharedArrayBuffer]';\n}\nfunction isSharedArrayBuffer(value) {\n  if (typeof SharedArrayBufferCopy === 'undefined') {\n    return false;\n  }\n\n  if (typeof isSharedArrayBufferToString.working === 'undefined') {\n    isSharedArrayBufferToString.working = isSharedArrayBufferToString(new SharedArrayBufferCopy());\n  }\n\n  return isSharedArrayBufferToString.working\n    ? isSharedArrayBufferToString(value)\n    : value instanceof SharedArrayBufferCopy;\n}\nexports.isSharedArrayBuffer = isSharedArrayBuffer;\n\nfunction isAsyncFunction(value) {\n  return ObjectToString(value) === '[object AsyncFunction]';\n}\nexports.isAsyncFunction = isAsyncFunction;\n\nfunction isMapIterator(value) {\n  return ObjectToString(value) === '[object Map Iterator]';\n}\nexports.isMapIterator = isMapIterator;\n\nfunction isSetIterator(value) {\n  return ObjectToString(value) === '[object Set Iterator]';\n}\nexports.isSetIterator = isSetIterator;\n\nfunction isGeneratorObject(value) {\n  return ObjectToString(value) === '[object Generator]';\n}\nexports.isGeneratorObject = isGeneratorObject;\n\nfunction isWebAssemblyCompiledModule(value) {\n  return ObjectToString(value) === '[object WebAssembly.Module]';\n}\nexports.isWebAssemblyCompiledModule = isWebAssemblyCompiledModule;\n\nfunction isNumberObject(value) {\n  return checkBoxedPrimitive(value, numberValue);\n}\nexports.isNumberObject = isNumberObject;\n\nfunction isStringObject(value) {\n  return checkBoxedPrimitive(value, stringValue);\n}\nexports.isStringObject = isStringObject;\n\nfunction isBooleanObject(value) {\n  return checkBoxedPrimitive(value, booleanValue);\n}\nexports.isBooleanObject = isBooleanObject;\n\nfunction isBigIntObject(value) {\n  return BigIntSupported && checkBoxedPrimitive(value, bigIntValue);\n}\nexports.isBigIntObject = isBigIntObject;\n\nfunction isSymbolObject(value) {\n  return SymbolSupported && checkBoxedPrimitive(value, symbolValue);\n}\nexports.isSymbolObject = isSymbolObject;\n\nfunction isBoxedPrimitive(value) {\n  return (\n    isNumberObject(value) ||\n    isStringObject(value) ||\n    isBooleanObject(value) ||\n    isBigIntObject(value) ||\n    isSymbolObject(value)\n  );\n}\nexports.isBoxedPrimitive = isBoxedPrimitive;\n\nfunction isAnyArrayBuffer(value) {\n  return typeof Uint8Array !== 'undefined' && (\n    isArrayBuffer(value) ||\n    isSharedArrayBuffer(value)\n  );\n}\nexports.isAnyArrayBuffer = isAnyArrayBuffer;\n\n['isProxy', 'isExternal', 'isModuleNamespaceObject'].forEach(function(method) {\n  Object.defineProperty(exports, method, {\n    enumerable: false,\n    value: function() {\n      throw new Error(method + ' is not supported in userland');\n    }\n  });\n});\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nvar getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors ||\n  function getOwnPropertyDescriptors(obj) {\n    var keys = Object.keys(obj);\n    var descriptors = {};\n    for (var i = 0; i < keys.length; i++) {\n      descriptors[keys[i]] = Object.getOwnPropertyDescriptor(obj, keys[i]);\n    }\n    return descriptors;\n  };\n\nvar formatRegExp = /%[sdj%]/g;\nexports.format = function(f) {\n  if (!isString(f)) {\n    var objects = [];\n    for (var i = 0; i < arguments.length; i++) {\n      objects.push(inspect(arguments[i]));\n    }\n    return objects.join(' ');\n  }\n\n  var i = 1;\n  var args = arguments;\n  var len = args.length;\n  var str = String(f).replace(formatRegExp, function(x) {\n    if (x === '%%') return '%';\n    if (i >= len) return x;\n    switch (x) {\n      case '%s': return String(args[i++]);\n      case '%d': return Number(args[i++]);\n      case '%j':\n        try {\n          return JSON.stringify(args[i++]);\n        } catch (_) {\n          return '[Circular]';\n        }\n      default:\n        return x;\n    }\n  });\n  for (var x = args[i]; i < len; x = args[++i]) {\n    if (isNull(x) || !isObject(x)) {\n      str += ' ' + x;\n    } else {\n      str += ' ' + inspect(x);\n    }\n  }\n  return str;\n};\n\n\n// Mark that a method should not be used.\n// Returns a modified function which warns once by default.\n// If --no-deprecation is set, then it is a no-op.\nexports.deprecate = function(fn, msg) {\n  if (typeof process !== 'undefined' && process.noDeprecation === true) {\n    return fn;\n  }\n\n  // Allow for deprecating things in the process of starting up.\n  if (typeof process === 'undefined') {\n    return function() {\n      return exports.deprecate(fn, msg).apply(this, arguments);\n    };\n  }\n\n  var warned = false;\n  function deprecated() {\n    if (!warned) {\n      if (process.throwDeprecation) {\n        throw new Error(msg);\n      } else if (process.traceDeprecation) {\n        console.trace(msg);\n      } else {\n        console.error(msg);\n      }\n      warned = true;\n    }\n    return fn.apply(this, arguments);\n  }\n\n  return deprecated;\n};\n\n\nvar debugs = {};\nvar debugEnvRegex = /^$/;\n\nif (process.env.NODE_DEBUG) {\n  var debugEnv = process.env.NODE_DEBUG;\n  debugEnv = debugEnv.replace(/[|\\\\{}()[\\]^$+?.]/g, '\\\\$&')\n    .replace(/\\*/g, '.*')\n    .replace(/,/g, '$|^')\n    .toUpperCase();\n  debugEnvRegex = new RegExp('^' + debugEnv + '$', 'i');\n}\nexports.debuglog = function(set) {\n  set = set.toUpperCase();\n  if (!debugs[set]) {\n    if (debugEnvRegex.test(set)) {\n      var pid = process.pid;\n      debugs[set] = function() {\n        var msg = exports.format.apply(exports, arguments);\n        console.error('%s %d: %s', set, pid, msg);\n      };\n    } else {\n      debugs[set] = function() {};\n    }\n  }\n  return debugs[set];\n};\n\n\n/**\n * Echos the value of a value. Trys to print the value out\n * in the best way possible given the different types.\n *\n * @param {Object} obj The object to print out.\n * @param {Object} opts Optional options object that alters the output.\n */\n/* legacy: obj, showHidden, depth, colors*/\nfunction inspect(obj, opts) {\n  // default options\n  var ctx = {\n    seen: [],\n    stylize: stylizeNoColor\n  };\n  // legacy...\n  if (arguments.length >= 3) ctx.depth = arguments[2];\n  if (arguments.length >= 4) ctx.colors = arguments[3];\n  if (isBoolean(opts)) {\n    // legacy...\n    ctx.showHidden = opts;\n  } else if (opts) {\n    // got an \"options\" object\n    exports._extend(ctx, opts);\n  }\n  // set default options\n  if (isUndefined(ctx.showHidden)) ctx.showHidden = false;\n  if (isUndefined(ctx.depth)) ctx.depth = 2;\n  if (isUndefined(ctx.colors)) ctx.colors = false;\n  if (isUndefined(ctx.customInspect)) ctx.customInspect = true;\n  if (ctx.colors) ctx.stylize = stylizeWithColor;\n  return formatValue(ctx, obj, ctx.depth);\n}\nexports.inspect = inspect;\n\n\n// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics\ninspect.colors = {\n  'bold' : [1, 22],\n  'italic' : [3, 23],\n  'underline' : [4, 24],\n  'inverse' : [7, 27],\n  'white' : [37, 39],\n  'grey' : [90, 39],\n  'black' : [30, 39],\n  'blue' : [34, 39],\n  'cyan' : [36, 39],\n  'green' : [32, 39],\n  'magenta' : [35, 39],\n  'red' : [31, 39],\n  'yellow' : [33, 39]\n};\n\n// Don't use 'blue' not visible on cmd.exe\ninspect.styles = {\n  'special': 'cyan',\n  'number': 'yellow',\n  'boolean': 'yellow',\n  'undefined': 'grey',\n  'null': 'bold',\n  'string': 'green',\n  'date': 'magenta',\n  // \"name\": intentionally not styling\n  'regexp': 'red'\n};\n\n\nfunction stylizeWithColor(str, styleType) {\n  var style = inspect.styles[styleType];\n\n  if (style) {\n    return '\\u001b[' + inspect.colors[style][0] + 'm' + str +\n           '\\u001b[' + inspect.colors[style][1] + 'm';\n  } else {\n    return str;\n  }\n}\n\n\nfunction stylizeNoColor(str, styleType) {\n  return str;\n}\n\n\nfunction arrayToHash(array) {\n  var hash = {};\n\n  array.forEach(function(val, idx) {\n    hash[val] = true;\n  });\n\n  return hash;\n}\n\n\nfunction formatValue(ctx, value, recurseTimes) {\n  // Provide a hook for user-specified inspect functions.\n  // Check that value is an object with an inspect function on it\n  if (ctx.customInspect &&\n      value &&\n      isFunction(value.inspect) &&\n      // Filter out the util module, it's inspect function is special\n      value.inspect !== exports.inspect &&\n      // Also filter out any prototype objects using the circular check.\n      !(value.constructor && value.constructor.prototype === value)) {\n    var ret = value.inspect(recurseTimes, ctx);\n    if (!isString(ret)) {\n      ret = formatValue(ctx, ret, recurseTimes);\n    }\n    return ret;\n  }\n\n  // Primitive types cannot have properties\n  var primitive = formatPrimitive(ctx, value);\n  if (primitive) {\n    return primitive;\n  }\n\n  // Look up the keys of the object.\n  var keys = Object.keys(value);\n  var visibleKeys = arrayToHash(keys);\n\n  if (ctx.showHidden) {\n    keys = Object.getOwnPropertyNames(value);\n  }\n\n  // IE doesn't make error fields non-enumerable\n  // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx\n  if (isError(value)\n      && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {\n    return formatError(value);\n  }\n\n  // Some type of object without properties can be shortcutted.\n  if (keys.length === 0) {\n    if (isFunction(value)) {\n      var name = value.name ? ': ' + value.name : '';\n      return ctx.stylize('[Function' + name + ']', 'special');\n    }\n    if (isRegExp(value)) {\n      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n    }\n    if (isDate(value)) {\n      return ctx.stylize(Date.prototype.toString.call(value), 'date');\n    }\n    if (isError(value)) {\n      return formatError(value);\n    }\n  }\n\n  var base = '', array = false, braces = ['{', '}'];\n\n  // Make Array say that they are Array\n  if (isArray(value)) {\n    array = true;\n    braces = ['[', ']'];\n  }\n\n  // Make functions say that they are functions\n  if (isFunction(value)) {\n    var n = value.name ? ': ' + value.name : '';\n    base = ' [Function' + n + ']';\n  }\n\n  // Make RegExps say that they are RegExps\n  if (isRegExp(value)) {\n    base = ' ' + RegExp.prototype.toString.call(value);\n  }\n\n  // Make dates with properties first say the date\n  if (isDate(value)) {\n    base = ' ' + Date.prototype.toUTCString.call(value);\n  }\n\n  // Make error with message first say the error\n  if (isError(value)) {\n    base = ' ' + formatError(value);\n  }\n\n  if (keys.length === 0 && (!array || value.length == 0)) {\n    return braces[0] + base + braces[1];\n  }\n\n  if (recurseTimes < 0) {\n    if (isRegExp(value)) {\n      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n    } else {\n      return ctx.stylize('[Object]', 'special');\n    }\n  }\n\n  ctx.seen.push(value);\n\n  var output;\n  if (array) {\n    output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);\n  } else {\n    output = keys.map(function(key) {\n      return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);\n    });\n  }\n\n  ctx.seen.pop();\n\n  return reduceToSingleString(output, base, braces);\n}\n\n\nfunction formatPrimitive(ctx, value) {\n  if (isUndefined(value))\n    return ctx.stylize('undefined', 'undefined');\n  if (isString(value)) {\n    var simple = '\\'' + JSON.stringify(value).replace(/^\"|\"$/g, '')\n                                             .replace(/'/g, \"\\\\'\")\n                                             .replace(/\\\\\"/g, '\"') + '\\'';\n    return ctx.stylize(simple, 'string');\n  }\n  if (isNumber(value))\n    return ctx.stylize('' + value, 'number');\n  if (isBoolean(value))\n    return ctx.stylize('' + value, 'boolean');\n  // For some reason typeof null is \"object\", so special case here.\n  if (isNull(value))\n    return ctx.stylize('null', 'null');\n}\n\n\nfunction formatError(value) {\n  return '[' + Error.prototype.toString.call(value) + ']';\n}\n\n\nfunction formatArray(ctx, value, recurseTimes, visibleKeys, keys) {\n  var output = [];\n  for (var i = 0, l = value.length; i < l; ++i) {\n    if (hasOwnProperty(value, String(i))) {\n      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,\n          String(i), true));\n    } else {\n      output.push('');\n    }\n  }\n  keys.forEach(function(key) {\n    if (!key.match(/^\\d+$/)) {\n      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,\n          key, true));\n    }\n  });\n  return output;\n}\n\n\nfunction formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {\n  var name, str, desc;\n  desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };\n  if (desc.get) {\n    if (desc.set) {\n      str = ctx.stylize('[Getter/Setter]', 'special');\n    } else {\n      str = ctx.stylize('[Getter]', 'special');\n    }\n  } else {\n    if (desc.set) {\n      str = ctx.stylize('[Setter]', 'special');\n    }\n  }\n  if (!hasOwnProperty(visibleKeys, key)) {\n    name = '[' + key + ']';\n  }\n  if (!str) {\n    if (ctx.seen.indexOf(desc.value) < 0) {\n      if (isNull(recurseTimes)) {\n        str = formatValue(ctx, desc.value, null);\n      } else {\n        str = formatValue(ctx, desc.value, recurseTimes - 1);\n      }\n      if (str.indexOf('\\n') > -1) {\n        if (array) {\n          str = str.split('\\n').map(function(line) {\n            return '  ' + line;\n          }).join('\\n').slice(2);\n        } else {\n          str = '\\n' + str.split('\\n').map(function(line) {\n            return '   ' + line;\n          }).join('\\n');\n        }\n      }\n    } else {\n      str = ctx.stylize('[Circular]', 'special');\n    }\n  }\n  if (isUndefined(name)) {\n    if (array && key.match(/^\\d+$/)) {\n      return str;\n    }\n    name = JSON.stringify('' + key);\n    if (name.match(/^\"([a-zA-Z_][a-zA-Z_0-9]*)\"$/)) {\n      name = name.slice(1, -1);\n      name = ctx.stylize(name, 'name');\n    } else {\n      name = name.replace(/'/g, \"\\\\'\")\n                 .replace(/\\\\\"/g, '\"')\n                 .replace(/(^\"|\"$)/g, \"'\");\n      name = ctx.stylize(name, 'string');\n    }\n  }\n\n  return name + ': ' + str;\n}\n\n\nfunction reduceToSingleString(output, base, braces) {\n  var numLinesEst = 0;\n  var length = output.reduce(function(prev, cur) {\n    numLinesEst++;\n    if (cur.indexOf('\\n') >= 0) numLinesEst++;\n    return prev + cur.replace(/\\u001b\\[\\d\\d?m/g, '').length + 1;\n  }, 0);\n\n  if (length > 60) {\n    return braces[0] +\n           (base === '' ? '' : base + '\\n ') +\n           ' ' +\n           output.join(',\\n  ') +\n           ' ' +\n           braces[1];\n  }\n\n  return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];\n}\n\n\n// NOTE: These type checking functions intentionally don't use `instanceof`\n// because it is fragile and can be easily faked with `Object.create()`.\nexports.types = require('./support/types');\n\nfunction isArray(ar) {\n  return Array.isArray(ar);\n}\nexports.isArray = isArray;\n\nfunction isBoolean(arg) {\n  return typeof arg === 'boolean';\n}\nexports.isBoolean = isBoolean;\n\nfunction isNull(arg) {\n  return arg === null;\n}\nexports.isNull = isNull;\n\nfunction isNullOrUndefined(arg) {\n  return arg == null;\n}\nexports.isNullOrUndefined = isNullOrUndefined;\n\nfunction isNumber(arg) {\n  return typeof arg === 'number';\n}\nexports.isNumber = isNumber;\n\nfunction isString(arg) {\n  return typeof arg === 'string';\n}\nexports.isString = isString;\n\nfunction isSymbol(arg) {\n  return typeof arg === 'symbol';\n}\nexports.isSymbol = isSymbol;\n\nfunction isUndefined(arg) {\n  return arg === void 0;\n}\nexports.isUndefined = isUndefined;\n\nfunction isRegExp(re) {\n  return isObject(re) && objectToString(re) === '[object RegExp]';\n}\nexports.isRegExp = isRegExp;\nexports.types.isRegExp = isRegExp;\n\nfunction isObject(arg) {\n  return typeof arg === 'object' && arg !== null;\n}\nexports.isObject = isObject;\n\nfunction isDate(d) {\n  return isObject(d) && objectToString(d) === '[object Date]';\n}\nexports.isDate = isDate;\nexports.types.isDate = isDate;\n\nfunction isError(e) {\n  return isObject(e) &&\n      (objectToString(e) === '[object Error]' || e instanceof Error);\n}\nexports.isError = isError;\nexports.types.isNativeError = isError;\n\nfunction isFunction(arg) {\n  return typeof arg === 'function';\n}\nexports.isFunction = isFunction;\n\nfunction isPrimitive(arg) {\n  return arg === null ||\n         typeof arg === 'boolean' ||\n         typeof arg === 'number' ||\n         typeof arg === 'string' ||\n         typeof arg === 'symbol' ||  // ES6 symbol\n         typeof arg === 'undefined';\n}\nexports.isPrimitive = isPrimitive;\n\nexports.isBuffer = require('./support/isBuffer');\n\nfunction objectToString(o) {\n  return Object.prototype.toString.call(o);\n}\n\n\nfunction pad(n) {\n  return n < 10 ? '0' + n.toString(10) : n.toString(10);\n}\n\n\nvar months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',\n              'Oct', 'Nov', 'Dec'];\n\n// 26 Feb 16:19:34\nfunction timestamp() {\n  var d = new Date();\n  var time = [pad(d.getHours()),\n              pad(d.getMinutes()),\n              pad(d.getSeconds())].join(':');\n  return [d.getDate(), months[d.getMonth()], time].join(' ');\n}\n\n\n// log is just a thin wrapper to console.log that prepends a timestamp\nexports.log = function() {\n  console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));\n};\n\n\n/**\n * Inherit the prototype methods from one constructor into another.\n *\n * The Function.prototype.inherits from lang.js rewritten as a standalone\n * function (not on Function.prototype). NOTE: If this file is to be loaded\n * during bootstrapping this function needs to be rewritten using some native\n * functions as prototype setup using normal JavaScript does not work as\n * expected during bootstrapping (see mirror.js in r114903).\n *\n * @param {function} ctor Constructor function which needs to inherit the\n *     prototype.\n * @param {function} superCtor Constructor function to inherit prototype from.\n */\nexports.inherits = require('inherits');\n\nexports._extend = function(origin, add) {\n  // Don't do anything if add isn't an object\n  if (!add || !isObject(add)) return origin;\n\n  var keys = Object.keys(add);\n  var i = keys.length;\n  while (i--) {\n    origin[keys[i]] = add[keys[i]];\n  }\n  return origin;\n};\n\nfunction hasOwnProperty(obj, prop) {\n  return Object.prototype.hasOwnProperty.call(obj, prop);\n}\n\nvar kCustomPromisifiedSymbol = typeof Symbol !== 'undefined' ? Symbol('util.promisify.custom') : undefined;\n\nexports.promisify = function promisify(original) {\n  if (typeof original !== 'function')\n    throw new TypeError('The \"original\" argument must be of type Function');\n\n  if (kCustomPromisifiedSymbol && original[kCustomPromisifiedSymbol]) {\n    var fn = original[kCustomPromisifiedSymbol];\n    if (typeof fn !== 'function') {\n      throw new TypeError('The \"util.promisify.custom\" argument must be of type Function');\n    }\n    Object.defineProperty(fn, kCustomPromisifiedSymbol, {\n      value: fn, enumerable: false, writable: false, configurable: true\n    });\n    return fn;\n  }\n\n  function fn() {\n    var promiseResolve, promiseReject;\n    var promise = new Promise(function (resolve, reject) {\n      promiseResolve = resolve;\n      promiseReject = reject;\n    });\n\n    var args = [];\n    for (var i = 0; i < arguments.length; i++) {\n      args.push(arguments[i]);\n    }\n    args.push(function (err, value) {\n      if (err) {\n        promiseReject(err);\n      } else {\n        promiseResolve(value);\n      }\n    });\n\n    try {\n      original.apply(this, args);\n    } catch (err) {\n      promiseReject(err);\n    }\n\n    return promise;\n  }\n\n  Object.setPrototypeOf(fn, Object.getPrototypeOf(original));\n\n  if (kCustomPromisifiedSymbol) Object.defineProperty(fn, kCustomPromisifiedSymbol, {\n    value: fn, enumerable: false, writable: false, configurable: true\n  });\n  return Object.defineProperties(\n    fn,\n    getOwnPropertyDescriptors(original)\n  );\n}\n\nexports.promisify.custom = kCustomPromisifiedSymbol\n\nfunction callbackifyOnRejected(reason, cb) {\n  // `!reason` guard inspired by bluebird (Ref: https://goo.gl/t5IS6M).\n  // Because `null` is a special error value in callbacks which means \"no error\n  // occurred\", we error-wrap so the callback consumer can distinguish between\n  // \"the promise rejected with null\" or \"the promise fulfilled with undefined\".\n  if (!reason) {\n    var newReason = new Error('Promise was rejected with a falsy value');\n    newReason.reason = reason;\n    reason = newReason;\n  }\n  return cb(reason);\n}\n\nfunction callbackify(original) {\n  if (typeof original !== 'function') {\n    throw new TypeError('The \"original\" argument must be of type Function');\n  }\n\n  // We DO NOT return the promise as it gives the user a false sense that\n  // the promise is actually somehow related to the callback's execution\n  // and that the callback throwing will reject the promise.\n  function callbackified() {\n    var args = [];\n    for (var i = 0; i < arguments.length; i++) {\n      args.push(arguments[i]);\n    }\n\n    var maybeCb = args.pop();\n    if (typeof maybeCb !== 'function') {\n      throw new TypeError('The last argument must be of type Function');\n    }\n    var self = this;\n    var cb = function() {\n      return maybeCb.apply(self, arguments);\n    };\n    // In true node style we process the callback on `nextTick` with all the\n    // implications (stack, `uncaughtException`, `async_hooks`)\n    original.apply(this, args)\n      .then(function(ret) { process.nextTick(cb.bind(null, null, ret)) },\n            function(rej) { process.nextTick(callbackifyOnRejected.bind(null, rej, cb)) });\n  }\n\n  Object.setPrototypeOf(callbackified, Object.getPrototypeOf(original));\n  Object.defineProperties(callbackified,\n                          getOwnPropertyDescriptors(original));\n  return callbackified;\n}\nexports.callbackify = callbackify;\n","const randomUUID = typeof crypto !== 'undefined' && crypto.randomUUID && crypto.randomUUID.bind(crypto);\nexport default { randomUUID };\n","let getRandomValues;\nconst rnds8 = new Uint8Array(16);\nexport default function rng() {\n    if (!getRandomValues) {\n        if (typeof crypto === 'undefined' || !crypto.getRandomValues) {\n            throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');\n        }\n        getRandomValues = crypto.getRandomValues.bind(crypto);\n    }\n    return getRandomValues(rnds8);\n}\n","import validate from './validate.js';\nconst byteToHex = [];\nfor (let i = 0; i < 256; ++i) {\n    byteToHex.push((i + 0x100).toString(16).slice(1));\n}\nexport function unsafeStringify(arr, offset = 0) {\n    return (byteToHex[arr[offset + 0]] +\n        byteToHex[arr[offset + 1]] +\n        byteToHex[arr[offset + 2]] +\n        byteToHex[arr[offset + 3]] +\n        '-' +\n        byteToHex[arr[offset + 4]] +\n        byteToHex[arr[offset + 5]] +\n        '-' +\n        byteToHex[arr[offset + 6]] +\n        byteToHex[arr[offset + 7]] +\n        '-' +\n        byteToHex[arr[offset + 8]] +\n        byteToHex[arr[offset + 9]] +\n        '-' +\n        byteToHex[arr[offset + 10]] +\n        byteToHex[arr[offset + 11]] +\n        byteToHex[arr[offset + 12]] +\n        byteToHex[arr[offset + 13]] +\n        byteToHex[arr[offset + 14]] +\n        byteToHex[arr[offset + 15]]).toLowerCase();\n}\nfunction stringify(arr, offset = 0) {\n    const uuid = unsafeStringify(arr, offset);\n    if (!validate(uuid)) {\n        throw TypeError('Stringified UUID is invalid');\n    }\n    return uuid;\n}\nexport default stringify;\n","import native from './native.js';\nimport rng from './rng.js';\nimport { unsafeStringify } from './stringify.js';\nfunction v4(options, buf, offset) {\n    if (native.randomUUID && !buf && !options) {\n        return native.randomUUID();\n    }\n    options = options || {};\n    const rnds = options.random ?? options.rng?.() ?? rng();\n    if (rnds.length < 16) {\n        throw new Error('Random bytes length must be >= 16');\n    }\n    rnds[6] = (rnds[6] & 0x0f) | 0x40;\n    rnds[8] = (rnds[8] & 0x3f) | 0x80;\n    if (buf) {\n        offset = offset || 0;\n        if (offset < 0 || offset + 16 > buf.length) {\n            throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);\n        }\n        for (let i = 0; i < 16; ++i) {\n            buf[offset + i] = rnds[i];\n        }\n        return buf;\n    }\n    return unsafeStringify(rnds);\n}\nexport default v4;\n"],"names":["module","exports","e","ReferenceError","__esModule","a","n","TypeError","toPropertyKey","_defineProperties","r","t","length","o","enumerable","configurable","writable","Object","defineProperty","key","prototype","value","_extends","assign","bind","arguments","hasOwnProperty","call","apply","_inheritsLoose","create","constructor","_objectWithoutProperties","i","getOwnPropertySymbols","indexOf","propertyIsEnumerable","_objectWithoutPropertiesLoose","_setPrototypeOf","setPrototypeOf","__proto__","_getPrototypeOf","getPrototypeOf","_typeof","assertThisInitialized","Symbol","toPrimitive","String","Number","iterator","MAX_SAFE_INTEGER","constants","MAX_LENGTH","MAX_SAFE_COMPONENT_LENGTH","MAX_SAFE_BUILD_LENGTH","RELEASE_TYPES","SEMVER_SPEC_VERSION","FLAG_INCLUDE_PRERELEASE","FLAG_LOOSE","debug_1","process","env","NODE_DEBUG","test","args","console","error","require$$0","debug","require$$1","re","safeRe","src","R","LETTERDASHNUMBER","safeRegexReplacements","createToken","name","isGlobal","safe","token","max","split","join","makeSafeRegex","index","RegExp","NUMERICIDENTIFIER","NUMERICIDENTIFIERLOOSE","NONNUMERICIDENTIFIER","PRERELEASEIDENTIFIER","PRERELEASEIDENTIFIERLOOSE","BUILDIDENTIFIER","MAINVERSION","PRERELEASE","BUILD","FULLPLAIN","MAINVERSIONLOOSE","PRERELEASELOOSE","LOOSEPLAIN","XRANGEIDENTIFIER","XRANGEIDENTIFIERLOOSE","GTLT","XRANGEPLAIN","XRANGEPLAINLOOSE","COERCEPLAIN","COERCE","COERCEFULL","LONETILDE","LONECARET","looseOption","freeze","loose","emptyOpts","parseOptions_1","options","numeric","compareIdentifiers","b","anum","bnum","identifiers","rcompareIdentifiers","require$$2","parseOptions","require$$3","require$$4","SemVer","version","includePrerelease","this","m","trim","match","LOOSE","FULL","raw","major","minor","patch","prerelease","map","id","num","build","format","toString","compare","other","compareMain","comparePre","compareBuild","inc","release","identifier","identifierBase","base","Error","push","isNaN","semver","parse_1","throwErrors","er","compare_1","compareBuild_1","versionA","versionB","gt_1","lt_1","eq_1","neq_1","gte_1","lte_1","eq","neq","gt","gte","lt","lte","require$$5","cmp_1","op","SPACE_CHARACTERS","Range","range","Comparator","set","formatted","replace","parseRange","filter","c","first","isNullSet","isAny","comps","k","memoKey","cached","cache","get","hr","HYPHENRANGELOOSE","HYPHENRANGE","hyphenReplace","COMPARATORTRIM","comparatorTrimReplace","TILDETRIM","tildeTrimReplace","CARETTRIM","caretTrimReplace","rangeList","comp","parseComparator","replaceGTE0","COMPARATORLOOSE","rangeMap","Map","comparators","size","has","delete","result","values","intersects","some","thisComparators","isSatisfiable","rangeComparators","every","thisComparator","rangeComparator","testSet","LRU","lrucache","firstKey","keys","next","require$$6","remainingComparators","slice","testComparator","pop","otherComparator","replaceCarets","replaceTildes","replaceXRanges","replaceStars","isX","toLowerCase","replaceTilde","TILDELOOSE","TILDE","_","M","p","pr","ret","replaceCaret","CARETLOOSE","CARET","z","replaceXRange","XRANGELOOSE","XRANGE","gtlt","xM","xm","xp","anyX","STAR","GTE0PRE","GTE0","incPr","$0","from","fM","fm","fp","fpr","fb","to","tM","tm","tp","tpr","ANY","allowed","parse","operator","COMPARATOR","cmp","startsWith","includes","comparator","satisfies_1","satisfies","require$$7","outside_1","hilo","gtfn","ltefn","ltfn","ecomp","high","low","forEach","internalRe","valid","valid_1","v","clean","clean_1","s","inc_1","diff","diff_1","version1","version2","v1","v2","comparison","v1Higher","highVersion","lowVersion","highHasPre","prefix","require$$8","major_1","require$$9","minor_1","require$$10","patch_1","require$$11","prerelease_1","parsed","require$$12","require$$13","rcompare","rcompare_1","require$$14","compareLoose","compareLoose_1","require$$15","require$$16","sort","sort_1","list","require$$17","rsort","rsort_1","require$$18","require$$19","require$$20","require$$21","require$$22","require$$23","require$$24","require$$25","coerce","coerce_1","rtl","coerceRtlRegex","COERCERTLFULL","COERCERTL","exec","lastIndex","require$$26","require$$27","require$$28","require$$29","toComparators","toComparators_1","require$$30","maxSatisfying","maxSatisfying_1","versions","maxSV","rangeObj","require$$31","minSatisfying","minSatisfying_1","min","minSV","require$$32","minVersion","minVersion_1","minver","setMin","compver","require$$33","validRange","require$$34","outside","require$$35","gtr","gtr_1","require$$36","ltr","ltr_1","require$$37","intersects_1","r1","r2","require$$38","simplifyRange","simplify","prev","ranges","simplified","original","require$$39","subset","minimumVersionWithPreRelease","minimumVersion","simpleSubset","sub","dom","eqSet","Set","gtltComp","higherGT","lowerLT","add","higher","lower","hasDomLT","hasDomGT","needDomLTPre","needDomGTPre","subset_1","sawNonNull","OUTER","simpleSub","simpleDom","isSub","require$$40","tokens","moduleSignature","load","moduleFactorySignature","moduleApiVersion","moduleExportSignature","default","isInterface","obj","type","ModuleIncompatibleError","pluginVersion","super","ModuleLoader","api","modules","started","moduleExport","Module","start","Promise","all","plugin","sides","Math","round","floor","createCoords","x","y","oppositeSideMap","left","right","bottom","top","oppositeAlignmentMap","end","clamp","param","placement","getOppositeAxis","axis","getAxisLength","getAlignmentAxis","alignment","getOppositePlacement","side","padding","expandPaddingObject","rect","width","height","computeCoordsFromPlacement","_ref","reference","floating","sideAxis","alignmentAxis","alignLength","isVertical","commonX","commonY","commonAlign","coords","async","detectOverflow","state","_await$platform$isEle","platform","rects","elements","strategy","boundary","rootBoundary","elementContext","altBoundary","paddingObject","element","clippingClientRect","getClippingRect","isElement","contextElement","getDocumentElement","offsetParent","getOffsetParent","offsetScale","getScale","elementClientRect","convertOffsetParentRelativeRectToViewportRelativeRect","getSideOffsets","overflow","isAnySideFullyClipped","getCssDimensions","css","parseFloat","hasOffset","offsetWidth","offsetHeight","shouldFallback","$","unwrapElement","domElement","getBoundingClientRect","isFinite","noOffsets","getVisualOffsets","win","visualViewport","offsetLeft","offsetTop","includeScale","isFixedStrategy","clientRect","scale","visualOffsets","isFixed","floatingOffsetParent","shouldAddVisualOffsets","offsetWin","currentWin","currentIFrame","iframeScale","iframeRect","clientLeft","paddingLeft","clientTop","paddingTop","getWindowScrollBarX","leftScroll","scrollLeft","getClientRectFromClippingAncestor","clippingAncestor","html","clientWidth","clientHeight","visualViewportBased","getViewportRect","scroll","body","ownerDocument","scrollWidth","scrollHeight","scrollTop","direction","getDocumentRect","getInnerBoundingClientRect","hasFixedPositionAncestor","stopNode","parentNode","position","getRectRelativeToOffsetParent","isOffsetParentAnElement","documentElement","offsets","offsetRect","htmlX","htmlY","htmlRect","isStaticPositioned","getTrueOffsetParent","polyfill","rawOffsetParent","svgOffsetParent","topLayer","clippingAncestors","cachedResult","el","currentContainingBlockComputedStyle","elementIsFixed","currentNode","computedStyle","currentNodeIsContaining","ancestor","getClippingElementAncestors","_c","concat","firstClippingAncestor","clippingRect","reduce","accRect","getElementRects","data","getOffsetParentFn","getDimensionsFn","getDimensions","floatingDimensions","getClientRects","Array","isRTL","autoUpdate","update","ancestorScroll","ancestorResize","elementResize","ResizeObserver","layoutShift","IntersectionObserver","animationFrame","referenceEl","ancestors","addEventListener","passive","cleanupIo","onMove","timeoutId","io","root","cleanup","_io","clearTimeout","disconnect","refresh","skip","threshold","rootMargin","isFirstUpdate","handleObserve","entries","ratio","intersectionRatio","setTimeout","observe","observeMove","frameId","reobserveFrame","resizeObserver","firstEntry","target","unobserve","cancelAnimationFrame","requestAnimationFrame","_resizeObserver","prevRefRect","frameLoop","nextRefRect","_resizeObserver2","removeEventListener","fn","_middlewareData$offse","_middlewareData$arrow","middlewareData","diffCoords","mainAxisMulti","crossAxisMulti","rawValue","mainAxis","crossAxis","convertValueToCoords","offset","arrow","alignmentOffset","checkMainAxis","checkCrossAxis","limiter","detectOverflowOptions","mainAxisCoord","crossAxisCoord","maxSide","limitedCoords","enabled","_middlewareData$flip","initialPlacement","fallbackPlacements","specifiedFallbackPlacements","fallbackStrategy","fallbackAxisSideDirection","flipAlignment","initialSideAxis","isBasePlacement","oppositePlacement","getExpandedPlacements","hasFallbackAxisSideDirection","isStart","lr","rl","tb","bt","getSideList","getOppositeAxisPlacements","placements","overflows","overflowsData","flip","mainAlignmentSide","_middlewareData$flip2","_overflowsData$filter","nextIndex","nextPlacement","reset","resetPlacement","d","_overflowsData$filter2","currentSideAxis","acc","_state$middlewareData","_state$middlewareData2","isYAxis","heightSide","widthSide","maximumClippingHeight","maximumClippingWidth","overflowAvailableHeight","overflowAvailableWidth","noShift","shift","availableHeight","availableWidth","xMin","xMax","yMin","yMax","nextDimensions","referenceHiddenOffsets","referenceHidden","escapedOffsets","escaped","arrowDimensions","minProp","maxProp","clientProp","endDiff","startDiff","arrowOffsetParent","clientSize","centerToReference","largestPossiblePadding","minPadding","maxPadding","min$1","center","shouldAddOffset","centerOffset","rawOffset","computedOffset","len","limitMin","limitMax","_middlewareData$offse2","isOriginSide","mergedOptions","platformWithCache","config","middleware","validMiddleware","Boolean","statefulPlacement","resetCount","nextX","nextY","computePosition","document","useLayoutEffect","useEffect","deepEqual","isArray","$$typeof","getDPR","window","defaultView","devicePixelRatio","roundByDPR","dpr","useLatestRef","ref","current","useFloating","externalReference","externalFloating","transform","whileElementsMounted","open","setData","isPositioned","latestMiddleware","setLatestMiddleware","_reference","_setReference","_floating","_setFloating","setReference","node","referenceRef","setFloating","floatingRef","floatingEl","dataRef","hasWhileElementsMounted","whileElementsMountedRef","platformRef","openRef","then","fullData","isMountedRef","refs","floatingStyles","initialStyles","willChange","arrow$1","deps","limitShift","hide","doc","activeElement","_activeElement","shadowRoot","parent","child","rootNode","getRootNode","contains","host","uaData","navigator","userAgentData","brands","brand","userAgent","event","isAndroid","pressure","detail","pointerType","isSafari","vendor","strict","undefined","isEventTargetWithin","composedPath","TYPEABLE_SELECTOR","matches","preventDefault","stopPropagation","candidateSelectors","candidateSelector","NoElement","Element","msMatchesSelector","webkitMatchesSelector","_element$getRootNode","isInert","lookUp","_node$getAttribute","inertAtt","getAttribute","getCandidates","includeContainer","candidates","querySelectorAll","unshift","getCandidatesIteratively","elementsToCheck","tagName","assigned","assignedElements","nestedCandidates","children","flatten","scopeParent","getShadowRoot","validShadowRoot","shadowRootFilter","hasTabIndex","parseInt","getTabIndex","tabIndex","_node$getAttribute2","attValue","isContentEditable","sortOrderedTabbables","documentOrder","isInput","isNonTabbableRadio","isRadio","radioSet","radioScope","form","queryRadios","CSS","escape","err","message","checked","nodes","getCheckedRadio","isTabbableRadio","isZeroArea","_node$getBoundingClie","isHidden","displayCheck","getComputedStyle","visibility","nodeUnderDetails","parentElement","originalNode","assignedSlot","_nodeRoot","_nodeRootHost","_nodeRootHost$ownerDo","_node$ownerDocument","nodeRoot","nodeRootHost","attached","_nodeRoot2","_nodeRootHost2","_nodeRootHost2$ownerD","isNodeAttached","isNodeMatchingSelectorFocusable","disabled","isHiddenInput","isDetailsWithSummary","item","isDisabledFromFieldset","isNodeMatchingSelectorTabbable","isValidShadowRootTabbable","shadowHostNode","sortByOrder","regularTabbables","orderedTabbables","isScope","candidateTabindex","getSortOrderTabIndex","content","sortable","tabbable","container","isTabbable","useMergeRefs","SafeReact","useSafeInsertionEffect","useInsertionEffect","useEffectEvent","callback","_len","_key","ARROW_UP","ARROW_DOWN","ARROW_LEFT","ARROW_RIGHT","horizontalKeys","verticalKeys","source","serverHandoffComplete","count","genId","random","useId","setId","FloatingArrow","props","context","tipRadius","strokeWidth","staticOffset","stroke","style","restStyle","rest","clipPathId","setIsRTL","isVerticalSide","computedStaticOffset","computedStrokeWidth","halfStrokeWidth","svgX","svgY","isCustomShape","yOffsetProp","xOffsetProp","arrowX","arrowY","dValue","rotation","viewBox","pointerEvents","clipPath","fill","createPubSub","emit","_map$get","handler","on","listener","off","_map$get2","l","FloatingNodeContext","FloatingTreeContext","useFloatingParentNodeId","_React$useContext","useFloatingTree","createAttribute","useRef","safePolygonIdentifier","getDelay","prop","useHover","onOpenChange","events","delay","handleClose","mouseOnly","restMs","move","tree","parentId","handleCloseRef","delayRef","pointerTypeRef","timeoutRef","handlerRef","restTimeoutRef","blockMouseMoveRef","performedPointerEventsMutationRef","unbindMouseMoveRef","restTimeoutPendingRef","isHoverOpen","_dataRef$current$open","openEvent","onLeave","closeWithDelay","runElseBranch","reason","closeDelay","cleanupMouseMoveHandler","clearPointerEvents","removeAttribute","isClickLikeOpenEvent","domReference","_elements$floating","onScrollMouseLeave","onMouseEnter","once","onMouseLeave","_elements$floating2","openDelay","floatingContext","clientX","clientY","onClose","relatedTarget","_handleCloseRef$curre","__options","blockPointerEvents","_tree$nodesRef$curren","setAttribute","parentFloating","nodesRef","find","setPointerRef","onPointerDown","onPointerEnter","onMouseMove","nativeEvent","handleMouseMove","movementX","movementY","NOOP","FloatingDelayGroupContext","initialDelay","timeoutMs","currentId","setCurrentId","setState","isInstantPhase","useDelayGroupContext","FloatingDelayGroup","initialCurrentIdRef","Provider","useDelayGroup","floatingId","optionId","groupContext","close","unset","timeout","rafId","enqueueFocus","preventScroll","cancelPrevious","sync","focus","getChildren","allChildren","_node$context","currentChildren","_currentChildren","_node$context2","counterMap","WeakMap","uncontrolledElementsSet","WeakSet","markerMap","lockCount$1","supportsInert","HTMLElement","unwrapHost","correctElements","targets","correctedTarget","markOthers","avoidElements","ariaHidden","inert","uncorrectedAvoidElements","markerName","controlAttribute","elementsToKeep","elementsToStop","hiddenElements","markerCounter","keep","deep","attr","alreadyHidden","counterValue","markerValue","clear","applyAttributeToOthers","getTabbableOptions","getTabbableIn","allTabbable","reverse","activeIndex","getNextTabbable","getPreviousTabbable","isOutsideEvent","containerElement","currentTarget","disableFocusInside","dataset","tabindex","enableFocusInside","HIDDEN_STYLES","border","clip","margin","whiteSpace","setActiveElementOnTab","FocusGuard","role","setRole","restProps","PortalContext","FloatingPortal","preserveTabOrder","portalNode","uniqueId","portalContext","usePortalContext","setPortalNode","portalNodeRef","remove","queueMicrotask","existingIdRoot","getElementById","subRoot","createElement","appendChild","idWrapper","useFloatingPortalNode","focusManagerState","setFocusManagerState","beforeOutsideRef","afterOutsideRef","beforeInsideRef","afterInsideRef","modal","shouldRenderGuards","onFocus","_beforeInsideRef$curr","prevTabbable","_afterInsideRef$curre","nextTabbable","closeOnFocusOut","FOCUSABLE_ATTRIBUTE","getFloatingFocusElement","floatingElement","hasAttribute","querySelector","LIST_LIMIT","previouslyFocusedElements","addPreviouslyFocusedElement","isConnected","getPreviouslyFocusedElement","VisuallyHiddenDismiss","FloatingFocusManager","order","guards","_guards","initialFocus","returnFocus","restoreFocus","visuallyHiddenDismiss","outsideElementsInert","nodeId","ignoreInitialFocus","isUntrappedTypeableCombobox","inertSupported","useInert","orderRef","initialFocusRef","returnFocusRef","startDismissButtonRef","endDismissButtonRef","preventReturnFocusRef","isPointerDownRef","tabbableIndexRef","isInsidePortal","floatingFocusElement","getTabbableContent","getTabbableElements","flat","onKeyDown","els","shiftKey","handleFocusIn","tabbableIndex","handleFocusOutside","handlePointerDown","movedToUnrelatedNode","_nodes$find","allAncestors","currentParentId","getAncestors","_node$context3","_node$context4","prevTabbableIndex","tabbableContent","nodeToFocus","beforeGuardRef","afterGuardRef","mergedBeforeGuardRef","mergedAfterGuardRef","renderDismissButton","location","onClick","_portalContext$portal","portalNodes","insideElements","previouslyFocusedElement","focusableElements","initialFocusValue","elToFocus","focusAlreadyInsideFloatingEl","preventReturnFocusScroll","nested","mozInputSource","isTrusted","buttons","fallbackEl","insertAdjacentElement","activeEl","isFocusInsideFloatingTree","_node$context5","returnElement","tabbableReturnElement","tabbableOptions","getFirstTabbableElement","MutationObserver","handleMutation","observer","childList","subtree","attributes","_portalContext$before","_portalContext$afterO","bubbleHandlerKeys","pointerdown","mousedown","click","captureHandlerKeys","normalizeProp","normalizable","_normalizable$escapeK","_normalizable$outside","escapeKey","outsidePress","useDismiss","unstable_outsidePress","outsidePressEvent","referencePress","referencePressEvent","bubbles","capture","outsidePressFn","insideReactTreeRef","endedOrStartedInsideRef","escapeKeyBubbles","outsidePressBubbles","escapeKeyCapture","outsidePressCapture","isComposingRef","closeOnEscapeKeyDown","_dataRef$current$floa","shouldDismiss","_child$context","__escapeKeyBubbles","isReactEvent","closeOnEscapeKeyDownCapture","_getTarget2","_getTarget","closeOnPressOutside","_dataRef$current$floa2","insideReactTree","endedOrStartedInside","inertSelector","markers","targetRootAncestor","nextParent","marker","lastTraversableNode","scrollRe","isScrollableX","overflowX","isScrollableY","overflowY","canScrollX","canScrollY","pressedVerticalScrollbar","offsetX","pressedHorizontalScrollbar","offsetY","targetIsInsideChildren","_child$context2","__outsidePressBubbles","closeOnPressOutsideCapture","_getTarget4","_getTarget3","compositionTimeout","onScroll","handleCompositionStart","handleCompositionEnd","_doc$defaultView","onMouseDown","onMouseUp","internalRootContext","onOpenChangeProp","elementsProp","positionReference","setPositionReference","useFloatingRootContext","rootContext","computedElements","_domReference","setDomReference","_setPositionReference","domReferenceRef","computedPositionReference","useFocus","visibleOnly","blockFocusRef","keyboardModalityRef","onBlur","maxTouchPoints","movedToFocusGuard","ACTIVE_KEY","SELECTED_KEY","mergeProps","userProps","propsList","elementKey","isItem","domUserProps","__","validProps","propsOrGetProps","val","useInteractions","referenceDeps","floatingDeps","itemDeps","getReferenceProps","getFloatingProps","getItemProps","componentRoleToAriaRoleMap","useRole","_componentRoleToAriaR","ariaRole","referenceId","isNested","floatingProps","active","selected","commonProps","hasWindow","getNodeName","isNode","nodeName","getWindow","Node","isHTMLElement","isShadowRoot","ShadowRoot","isOverflowElement","display","isTableElement","isTopLayer","selector","isContainingBlock","elementOrCss","webkit","isWebKit","perspective","containerType","backdropFilter","contain","getContainingBlock","getParentNode","isLastTraversableNode","supports","getNodeScroll","scrollX","scrollY","getNearestOverflowAncestor","getOverflowAncestors","traverseIframes","_node$ownerDocument2","scrollableAncestor","isBody","frameElement","getFrameElement","__importDefault","mod","EMOJI","DATA_BY_CATEGORY","getEmojiFromUnicode","EMOTICON_TO_EMOJI","compact_json_1","iamcal_json_1","emoji_json_1","emojibase_1","UNICODE_TO_EMOJI","unicode","stripVariation","EMOJIBASE_GROUP_ID_TO_CATEGORY","people","nature","foods","places","activity","objects","symbols","flags","MAX_EMOJI_VERSION","EMOJI_TO_VERSION","versionString","emojis","emoji","str","emojiData","hexcode","shortcodeData","label","shortcodes","categoryId","group","emoticon","emoticons","flatMap","generateEmoticonPermutations","_interopRequireDefault","_classCallCheck2","_createClass2","_inherits2","_possibleConstructorReturn2","_getPrototypeOf2","_defineProperty2","_getRequireWildcardCache","nodeInterop","cacheBabelInterop","cacheNodeInterop","_createSuper","Derived","hasNativeReflectConstruct","Reflect","construct","sham","Proxy","valueOf","_isNativeReflectConstruct","Super","NewTarget","Spinner","_React$PureComponent","_super","renderFactory","newObj","hasPropertyDescriptor","getOwnPropertyDescriptor","desc","_interopRequireWildcard","PureComponent","React","TextInputField","onChange","SetupEncryptionKind","_assertThisInitialized2","CryptoSetupExtensionsBase","DefaultCryptoSetupExtensions","_CryptoSetupExtension","_this","response","credentials","log","ExperimentalExtensionsBase","DefaultExperimentalExtensions","_ExperimentalExtensio","RoomViewLifecycle","composeEventHandlers","originalEventHandler","ourEventHandler","checkForDefaultPrevented","defaultPrevented","composeRefs","setRef","useComposedRefs","createContextScope","scopeName","createContextScopeDeps","defaultContexts","createScope","scopeContexts","defaultContext","scope","contexts","rootComponentName","BaseContext","Context","jsx","displayName","consumerName","composeContextScopes","scopes","baseScope","scopeHooks","createScope2","useScope","overrideScopes","nextScopes","nextScopes2","useReactId","deterministicId","reactId","Primitive","primitive","forwardedRef","asChild","primitiveProps","Comp","for","dispatchDiscreteCustomEvent","dispatchEvent","Slot","slotProps","childrenArray","toArray","slottable","isSlottable","newElement","newChildren","only","SlotClone","childrenRef","getter","mayWarn","isReactWarning","getElementRef","Slottable","Fragment","childProps","overrideProps","propName","slotPropValue","childPropValue","useLayoutEffect2","globalThis","lastHref","addHistoryInstrumentationHandler","instrumentHistory","historyReplacementFunction","originalHistoryFunction","url","handlerData","href","history","WINDOW","DEBUG_BUILD","exceptionFromError","stackParser","ex","frames","parseStackFrames","exception","extractType","extractMessage","stacktrace","eventFromPlainObject","syntheticException","isUnhandledRejection","client","normalizeDepth","getOptions","errorFromProp","getErrorPropertyFromObject","extra","__serialized__","getNonErrorObjectExceptionValue","eventFromError","stack","skipLines","reactMinifiedRegexp","getSkipFirstStackStringLines","framesToPop","getPopFirstTopFrames","isWebAssemblyException","WebAssembly","Exception","eventFromException","hint","attachStacktrace","eventFromUnknownInput","level","event_id","eventFromMessage","eventFromString","domException","ignoreOnError","shouldIgnoreOnError","wrap","isFunction","wrapper","__sentry_wrapped__","sentryWrapped","wrappedArguments","arg","addEventProcessor","mechanism","property","debounceTimerID","lastCapturedEventType","lastCapturedEventTargetId","instrumentDOM","triggerDOMHandler","globalDOMEventHandler","makeDOMEventHandler","globalObject","proto","originalAddEventListener","handlers","__sentry_instrumentation_handlers__","handlerForType","refCount","originalRemoveEventListener","globalListener","getEventTarget","eventType","shouldSkipDOMEvent","_sentryId","isSimilarToLastCapturedEvent","global","SENTRY_XHR_DATA_KEY","instrumentXHR","XMLHttpRequest","xhrproto","originalOpen","xhrOpenThisArg","xhrOpenArgArray","virtualError","startTimestamp","time","method","is","toUpperCase","parseUrl","request_headers","__sentry_own_request__","onreadystatechangeHandler","xhrInfo","readyState","status_code","status","endTimestamp","xhr","onreadystatechange","originalOnreadystatechange","onreadystatechangeThisArg","onreadystatechangeArgArray","setRequestHeader","originalSetRequestHeader","setRequestHeaderThisArg","setRequestHeaderArgArray","header","send","originalSend","sendThisArg","sendArgArray","sentryXhrData","instrumentConsole","originalConsoleMethod","instrumentFetch","onFetchResolved","skipNativeFetchCheck","originalFetch","fetchArgs","getUrlFromResource","hasProp","parseFetchArgs","fetchData","resource","DEFAULT_BREADCRUMBS","addBreadcrumb","breadcrumb","isolationScope","beforeBreadcrumb","maxBreadcrumbs","mergedBreadcrumb","timestamp","finalBreadcrumb","severityLevelFromString","getBreadcrumbLogLevelFromHttpStatusCode","statusCode","query","fragment","path","protocol","search","hash","relative","MAX_ALLOWED_STRING_LENGTH","breadcrumbsIntegration","_options","fetch","sentry","setup","addConsoleInstrumentationHandler","_getConsoleBreadcrumbHandler","_getDomBreadcrumbHandler","addXhrInstrumentationHandler","_getXhrBreadcrumbHandler","addFetchInstrumentationHandler","_getFetchBreadcrumbHandler","_getHistoryBreadcrumbHandler","category","_getSentryBreadcrumbHandler","DEFAULT_EVENT_TARGET","browserApiErrorsIntegration","eventTarget","setInterval","setupOnce","_wrapTimeFunction","_wrapRAF","_wrapXHR","eventTargetOption","_wrapEventTarget","originalCallback","function","handled","wrapOptions","originalFunction","eventName","handleEvent","_oldOnErrorHandler","instrumentError","onerror","msg","line","column","__SENTRY_INSTRUMENTED__","_oldOnUnhandledRejectionHandler","instrumentUnhandledRejection","onunhandledrejection","globalHandlersIntegration","stackTraceLimit","addGlobalErrorInstrumentationHandler","_enhanceEventWithInitialFrame","originalException","_installGlobalOnErrorHandler","globalHandlerLog","addGlobalUnhandledRejectionInstrumentationHandler","_getUnhandledRejectionError","_installGlobalOnUnhandledRejectionHandler","httpContextIntegration","preprocessEvent","request","referrer","headers","Referer","initAndBind","clientClass","enable","warn","initialScope","setClient","setCurrentClient","init","getBaseApiEndpoint","dsn","DSN_REGEX","withPassword","pass","port","projectId","publicKey","items","addItemToEnvelope","envelope","newItem","forEachEnvelopeItem","envelopeItems","envelopeItem","encodeUTF8","input","carrier","encodePolyfill","TextEncoder","encode","serializeEnvelope","envHeaders","parts","JSON","stringify","append","itemHeaders","payload","Uint8Array","stringifiedPayload","normalize","buffers","totalLength","buf","merged","buffer","concatBuffers","createAttachmentEnvelopeItem","attachment","filename","content_type","contentType","attachment_type","attachmentType","ITEM_TYPE_TO_DATA_CATEGORY_MAP","session","sessions","transaction","client_report","user_report","profile","profile_chunk","replay_event","replay_recording","check_in","feedback","span","raw_security","envelopeItemTypeToDataCategory","getSdkMetadataForEnvelopeHeader","metadataOrEvent","sdk","createEventEnvelope","metadata","tunnel","sdkInfo","integrations","packages","enhanceEventWithSdkInfo","envelopeHeaders","dynamicSamplingContext","sdkProcessingMetadata","sent_at","Date","toISOString","trace","createEventEnvelopeHeaders","SentryError","logLevel","ALREADY_SEEN_ERROR","MISSING_RELEASE_FOR_SESSION_ERROR","Client","_integrations","_numProcessing","_outcomes","_hooks","_eventProcessors","_dsn","getEnvelopeEndpointWithUrlEncodedAuth","_metadata","_transport","transport","recordDroppedEvent","transportOptions","captureException","eventId","hintWithEventId","_process","_captureEvent","captureMessage","currentScope","eventMessage","promisedEvent","captureEvent","capturedSpanScope","capturedSpanIsolationScope","captureSession","sendSession","getDsn","getSdkMetadata","getTransport","flush","_isClientDoneProcessing","clientFinished","transportFlushed","getEventProcessors","eventProcessor","_isEnabled","_setupIntegrations","getIntegrationByName","integrationName","addIntegration","integration","isAlreadyInstalled","sendEvent","attachments","promise","sendEnvelope","sendResponse","clientReleaseOption","environment","clientEnvironmentOption","sessionAttrs","attrs","toJSON","createSessionEnvelope","sendClientReports","sampleRate","rate","processedEvent","trace_id","parent_span_id","span_id","origin","description","start_timestamp","profile_id","exclusive_time","measurements","is_segment","discarded_events","addAutoIpAddressToUser","objWithMaybeUser","user","ip_address","addAutoIpAddressToSession","ipAddress","BrowserClient","opts","parentSpanIsAlwaysRootSpan","names","applySdkMetadata","SENTRY_SDK_SOURCE","visibilityState","_flushOutcomes","sendDefaultPii","_prepareEvent","browserSessionIntegration","ignoreDuration","applyAggregateErrorsToEvent","exceptionFromErrorImplementation","parser","maxValueLimit","limit","exceptions","maxValueLength","aggregateExceptionsFromError","prevExceptions","exceptionId","newExceptions","applyExceptionGroupFieldsForParentException","newException","newExceptionId","applyExceptionGroupFieldsForChildException","errors","childError","is_exception_group","exception_id","parent_id","linkedErrorsIntegration","createFrame","func","lineno","colno","frame","in_app","chromeRegexNoFnName","chromeRegex","chromeEvalRegex","geckoREgex","geckoEvalRegex","defaultStackLineParsers","noFnParts","col","subMatch","extractSafariExtensionDetails","defaultStackParser","isSafariExtension","isSafariWebExtension","cachedImplementations","getNativeImplementation","impl","sandbox","hidden","head","contentWindow","removeChild","clearCachedImplementation","makePromiseBuffer","task","splice","resolve","taskProducer","drain","reject","counter","capturedSetTimeout","DEFAULT_RETRY_AFTER","now","headerDelay","DEFAULT_TRANSPORT_BUFFER_SIZE","createTransport","makeRequest","bufferSize","rateLimits","filteredEnvelopeItems","dataCategory","isRateLimited","filteredEnvelope","recordEnvelopeLoss","updateRateLimits","makeFetchTransport","nativeFetch","pendingBodySize","pendingCount","requestSize","requestOptions","referrerPolicy","keepalive","fetchOptions","dropTopLevelUndefinedKeys","mutatetedObj","getOwnPropertyNames","optionsArg","defaultIntegrations","breadcrumbs","dedupe","__SENTRY_RELEASE__","SENTRY_RELEASE","windowWithMaybeExtension","extensionObject","chrome","runtimeId","runtime","isDedicatedExtensionPage","getMainCarrier","getSentryCarrier","__SENTRY__","getGlobalSingleton","creator","DEFAULT_ENVIRONMENT","AsyncContextStack","assignedScope","assignedIsolationScope","_stack","_isolationScope","withScope","_pushScope","maybePromiseResult","_popScope","res","getClient","getStackTop","getScope","getIsolationScope","clone","getAsyncContextStack","registry","withSetScope","withIsolationScope","acs","withSetIsolationScope","getCurrentScope","getGlobalScope","getTraceContextFromScope","propagationContext","getPropagationContext","traceId","parentSpanId","propagationSpanId","captureContext","setUser","startSession","getUser","currentSession","getSession","endSession","setSession","_sendSessionUpdate","installedIntegrations","getIntegrationsToSetup","userIntegrations","isDefaultInstance","resolvedUserIntegrations","integrationsByName","currentInstance","existingInstance","filterDuplicates","setupIntegrations","integrationIndex","setupIntegration","afterSetupIntegrations","afterAllSetup","dedupeIntegration","previousEvent","processEvent","currentEvent","currentMessage","previousMessage","_isSameFingerprint","_isSameStacktrace","_isSameMessageEvent","previousException","_getExceptionFromEvent","currentException","_isSameExceptionEvent","_shouldDropEvent","_oO","currentFrames","previousFrames","frameA","frameB","currentFingerprint","fingerprint","previousFingerprint","DEFAULT_IGNORE_ERRORS","eventFiltersIntegration","_hint","clientOptions","internalOptions","allowUrls","denyUrls","ignoreErrors","disableErrorDefaults","ignoreTransactions","ignoreInternal","_mergeOptions","_isSentryError","inboundFiltersIntegration","originalFunctionToString","SETUP_CLIENTS","functionToStringIntegration","Function","SCOPE_SPAN_FIELD","_setSpanForScope","_getSpanForScope","Scope","_notifyingListeners","_scopeListeners","_breadcrumbs","_attachments","_user","_tags","_extra","_contexts","_sdkProcessingMetadata","_propagationContext","sampleRand","newScope","_level","_session","_transactionName","_fingerprint","_client","_lastEventId","setLastEventId","lastEventId","addScopeListener","email","username","_notifyScopeListeners","setTags","tags","setTag","setExtras","extras","setExtra","setFingerprint","setLevel","setTransactionName","setContext","scopeToMerge","scopeInstance","getScopeData","setPropagationContext","maxCrumbs","getLastBreadcrumb","clearBreadcrumbs","addAttachment","clearAttachments","eventProcessors","transactionName","setSDKProcessingMetadata","newData","merge","logger","SEMANTIC_ATTRIBUTE_SENTRY_SOURCE","SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE","SEMANTIC_ATTRIBUTE_SENTRY_OP","SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN","SEMANTIC_ATTRIBUTE_PROFILE_ID","SEMANTIC_ATTRIBUTE_EXCLUSIVE_TIME","makeSession","startingTime","sid","duration","sessionToJSON","updateSession","did","abnormal_mechanism","SENTRY_BAGGAGE_KEY_PREFIX","SENTRY_BAGGAGE_KEY_PREFIX_REGEX","baggageHeaderToDynamicSamplingContext","baggageHeader","baggageObject","parseBaggageHeader","hasSpansEnabled","maybeOptions","__SENTRY_TRACING__","tracesSampleRate","tracesSampler","FROZEN_DSC_FIELD","getDynamicSamplingContextFromClient","public_key","dsc","getDynamicSamplingContextFromScope","getDynamicSamplingContextFromSpan","rootSpan","rootSpanJson","rootSpanAttributes","traceState","spanContext","rootSpanSampleRate","applyLocalSampleRateToDsc","sample_rate","SCOPE_ON_START_SPAN_FIELD","ISOLATION_SCOPE_ON_START_SPAN_FIELD","getCapturedScopesOnSpan","DEFAULT_MAX_STRING_LENGTH","htmlTreeAsString","elem","currentElem","MAX_TRAVERSE_HEIGHT","out","separator","sepLength","nextStr","keyAttrs","maxStringLength","_htmlElementAsString","keyAttrPairs","keyAttr","keyAttrPair","className","instrumented","addHandler","maybeInstrument","instrumentFn","objectToString","isError","wat","isInstanceOf","isBuiltin","isErrorEvent","isDOMError","isDOMException","isString","isParameterizedString","isPrimitive","isPlainObject","isEvent","Event","isRegExp","isThenable","isSyntheticEvent","_e","isVueViewModel","__isVue","_isVue","CONSOLE_LEVELS","originalConsoleMethods","consoleSandbox","wrappedFuncs","wrappedLevels","disable","isEnabled","uuid4","crypto","gbl","msCrypto","getCrypto","getRandomByte","randomUUID","getRandomValues","typedArray","getFirstException","getEventDescription","firstException","depth","maxProperties","Infinity","visit","ERROR","normalizeToSize","object","maxSize","normalized","encodeURI","utf8Length","memo","inner","memoize","unmemoize","memoBuilder","stringified","_events","objName","getConstructorName","stringifyValue","remainingDepth","valueWithToJSON","numAdded","visitable","visitKey","visitValue","replacementFactory","wrapped","markFunctionWrapped","addNonEnumerableProperty","o_O","getOriginalFunction","__sentry_original__","convertToPlainObject","getOwnProperties","serializeEventTarget","CustomEvent","extractedProps","extractExceptionKeysForMessage","maxLength","includedKeys","serialized","dropUndefinedKeys","inputValue","_dropUndefinedKeys","memoizationMap","isPojo","memoVal","returnValue","generateTraceId","generateSpanId","substring","STACKTRACE_FRAME_LIMIT","UNKNOWN_FUNCTION","WEBPACK_ERROR_REGEXP","STRIP_FRAME_REGEXP","createStackParser","parsers","sortedParsers","skipFirstLines","lines","cleanedLine","localStack","getLastStackFrame","stripSentryFramesAndReverse","stackParserFromStackParserOptions","arr","defaultFunctionName","getFunctionName","getFramesFromEvent","truncate","supportsHistory","supportsFetch","Headers","Request","Response","isNativeFunction","supportsNativeFetch","EdgeRuntime","resolvedSyncPromise","SyncPromise","rejectedSyncPromise","executor","_state","States","PENDING","_handlers","_runExecutor","onfulfilled","onrejected","_executeHandlers","onfinally","isRejected","cachedHandlers","RESOLVED","_value","REJECTED","setResult","ONE_SECOND_IN_MS","dateTimestampInSeconds","timestampInSeconds","performance","approxStartingTimeOrigin","timeOrigin","createUnixTimestampInSecondsFunc","SDK_VERSION","GLOBAL_OBJ","getPossibleEventMessages","possibleMessages","lastException","initialObj","mergeObj","levels","output","notifyEventProcessors","processors","processor","final","parsedStackResults","lastKeysCount","cachedFilenameDebugIds","getFilenameToDebugIdMap","debugIdMap","_sentryDebugIds","debugIdKeys","stackKey","parsedStack","stackFrame","debugId","applyScopeDataToEvent","cleanedExtra","cleanedTags","cleanedUser","cleanedContexts","applyDataToEvent","applySpanToEvent","applyFingerprintToEvent","mergedBreadcrumbs","applyBreadcrumbsToEvent","applySdkMetadataToEvent","mergeScopeData","mergeData","mergeAndOverwriteScopeData","mergeVal","prepareEvent","normalizeMaxBreadth","prepared","dist","applyClientOptions","integrationNames","applyIntegrationsMetadata","filenameDebugIdMap","debug_id","applyDebugIds","finalScope","getFinalScope","clientEventProcessors","evt","abs_path","debug_meta","images","code_file","applyDebugMeta","maxBreadth","spans","normalizeEvent","parseEventHintOrCaptureContext","hintIsScopeOrFunction","captureContextKeys","hintIsScopeContext","SPAN_STATUS_UNSET","SPAN_STATUS_OK","TRACE_FLAG_SAMPLED","hasShownSpanDropWarning","spanToTraceContext","spanId","isRemote","spanToJSON","convertSpanLinksForEnvelope","links","traceFlags","restContext","sampled","spanTimeInputToSeconds","ensureTimestampInSeconds","getTime","getSpanJSON","spanIsSentrySpan","castSpan","startTime","endTime","spanIsOpenTelemetrySdkTraceBaseSpan","getStatusMessage","spanIsSampled","code","ROOT_SPAN_FIELD","getRootSpan","showSpanDropWarning","BlockIcon","xmlns","forwardRef","ChatProblemIcon","ChatIcon","CheckIcon","ChevronLeftIcon","CloseIcon","CollapseIcon","DeleteIcon","DownloadIcon","EditIcon","fillRule","clipRule","ErrorIcon","ExpandIcon","FilesIcon","LeaveIcon","LinkIcon","LocationPinSolidIcon","MentionIcon","PopOutIcon","SearchIcon","ShareIcon","ThreadsIcon","UserAddIcon","UserSolidIcon","VerifiedIcon","VideoCallSolidIcon","VisibilityOffIcon","WarningIcon","MX_USERNAME_PREFIX","MX_ROOM_PREFIX","MX_ALIAS_PREFIX","graphemeSegmenter","Intl","Segmenter","getInitialLetter","initial","segment","done","Avatar","onError","_excluded","onKeyUp","shouldBeAButton","_objectSpread","useIdColorHash","classNames","styles","loading","alt","AVATAR_MASK_ID","AvatarStackUsageCount","AvatarStack","svgMask","insertAdjacentHTML","_document$getElementB","sum","char","charCodeAt","Badge","kind","classes","Typography","as","weight","Button","kindProp","iconOnly","Icon","destructive","destructiveProp","button","iconSize","jsxs","UnstyledButton","icon","IconButton","indicator","tooltip","subtleBackground","IndicatorIcon","colour","Tooltip","Component","onSubmit","onPointerUp","onKeyPress","_excluded2","eventHandlers","CheckboxInput","Glass","Children","SpinnerIcon","InlineSpinner","Link","rel","useCallbackRef","callbackRef","defaultProp","uncontrolledProp","setUncontrolledProp","uncontrolledState","prevValueRef","handleChange","useUncontrolledState","isControlled","nextValue","value2","createCollection","PROVIDER_NAME","createCollectionContext","createCollectionScope","CollectionProviderImpl","useCollectionContext","collectionRef","itemMap","CollectionProvider","COLLECTION_SLOT_NAME","CollectionSlot","composedRefs","ITEM_SLOT_NAME","ITEM_DATA_ATTR","CollectionItemSlot","itemData","ItemSlot","collectionNode","orderedNodes","DirectionContext","useDirection","localDir","globalDir","originalBodyPointerEvents","CONTEXT_UPDATE","POINTER_DOWN_OUTSIDE","FOCUS_OUTSIDE","DismissableLayerContext","layers","layersWithOutsidePointerEventsDisabled","branches","DismissableLayer","disableOutsidePointerEvents","onEscapeKeyDown","onPointerDownOutside","onFocusOutside","onInteractOutside","onDismiss","layerProps","setNode","force","node2","highestLayerWithOutsidePointerEventsDisabled","highestLayerWithOutsidePointerEventsDisabledIndex","isBodyPointerEventsDisabled","isPointerEventsEnabled","pointerDownOutside","handlePointerDownOutside","isPointerInsideReactTreeRef","handleClickRef","handleAndDispatchPointerDownOutsideEvent2","handleAndDispatchCustomEvent","eventDetail","discrete","originalEvent","timerId","onPointerDownCapture","usePointerDownOutside","isPointerDownOnBranch","branch","focusOutside","isFocusInsideReactTreeRef","handleFocus","onFocusCapture","onBlurCapture","useFocusOutside","onEscapeKeyDownProp","handleKeyDown","useEscapeKeydown","dispatchUpdate","handleUpdate","div","DismissableLayerBranch","cancelable","useFocusGuards","edgeGuards","createFocusGuard","outline","opacity","AUTOFOCUS_ON_MOUNT","AUTOFOCUS_ON_UNMOUNT","EVENT_OPTIONS","FocusScope","loop","trapped","onMountAutoFocus","onMountAutoFocusProp","onUnmountAutoFocus","onUnmountAutoFocusProp","scopeProps","setContainer","lastFocusedElementRef","focusScope","paused","pause","resume","handleFocusIn2","select","handleFocusOut2","handleMutations2","mutations","mutation","removedNodes","mutationObserver","focusScopesStack","mountEvent","candidate","focusFirst","getTabbableCandidates","unmountEvent","isTabKey","altKey","ctrlKey","metaKey","focusedElement","container2","last","findVisible","getTabbableEdges","walker","createTreeWalker","NodeFilter","SHOW_ELEMENT","acceptNode","FILTER_SKIP","FILTER_ACCEPT","nextNode","upTo","HTMLInputElement","isSelectableInput","activeFocusScope","arrayRemove","createFocusScopesStack","array","updatedArray","Arrow","arrowProps","svg","preserveAspectRatio","points","POPPER_NAME","createPopperContext","createPopperScope","PopperProvider","usePopperContext","Popper","__scopePopper","anchor","setAnchor","onAnchorChange","ANCHOR_NAME","PopperAnchor","virtualRef","anchorProps","CONTENT_NAME","PopperContentProvider","useContentContext","PopperContent","sideOffset","align","alignOffset","arrowPadding","avoidCollisions","collisionBoundary","collisionPadding","collisionPaddingProp","sticky","hideWhenDetached","updatePositionStrategy","onPlaced","contentProps","setContent","setArrow","arrowSize","setSize","entry","borderSizeEntry","borderSize","box","useSize","arrowWidth","arrowHeight","desiredPlacement","hasExplicitBoundaries","isNotNull","anchorWidth","anchorHeight","contentStyle","setProperty","transformOrigin","placedSide","placedAlign","getSideAndAlignFromPlacement","handlePlaced","cannotCenterArrow","contentZIndex","setContentZIndex","zIndex","minWidth","dir","onArrowChange","shouldHideArrow","animation","ARROW_NAME","OPPOSITE_SIDE","PopperArrow","contentContext","baseSide","isArrowHidden","noArrowAlign","arrowXCenter","arrowYCenter","Root2","Anchor","Content","Portal","containerProp","portalProps","mounted","setMounted","Presence","present","presence","stylesRef","prevPresentRef","prevAnimationNameRef","initialState","machine","useStateMachine","UNMOUNT","ANIMATION_OUT","unmountSuspended","MOUNT","ANIMATION_END","unmounted","currentAnimationName","getAnimationName","wasPresent","prevAnimationName","ownerWindow","handleAnimationEnd","isCurrentAnimation","animationName","currentFillMode","animationFillMode","handleAnimationStart","isPresent","usePresence","ENTRY_FOCUS","GROUP_NAME","Collection","useCollection","createRovingFocusGroupContext","createRovingFocusGroupScope","RovingFocusProvider","useRovingFocusContext","RovingFocusGroup","__scopeRovingFocusGroup","RovingFocusGroupImpl","orientation","currentTabStopId","currentTabStopIdProp","defaultCurrentTabStopId","onCurrentTabStopIdChange","onEntryFocus","preventScrollOnEntryFocus","groupProps","setCurrentTabStopId","isTabbingBackOut","setIsTabbingBackOut","handleEntryFocus","getItems","isClickFocusRef","focusableItemsCount","setFocusableItemsCount","onItemFocus","tabStopId","onItemShiftTab","onFocusableItemAdd","prevCount","onFocusableItemRemove","isKeyboardFocus","entryFocusEvent","focusable","ITEM_NAME","RovingFocusGroupItem","itemProps","autoId","isCurrentTabStop","focusIntent","getDirectionAwareKey","MAP_KEY_TO_FOCUS_INTENT","getFocusIntent","candidateNodes","currentIndex","startIndex","ArrowLeft","ArrowUp","ArrowRight","ArrowDown","PageUp","Home","PageDown","End","PREVIOUSLY_FOCUSED_ELEMENT","Item","getDefaultParent","originalTarget","uncontrolledNodes","lockCount","correctTargets","hiddenNodes","hideOthers","activeParentNode","zeroRightClassName","fullWidthClassName","assignRef","useIsomorphicLayoutEffect","currentValues","defaultValue","initialValue","newValue","useState","facade","oldValue","prevRefs_1","nextRefs_1","current_1","effectCar","nothing","RemoveScroll","parentRef","_a","onScrollCapture","onWheelCapture","onTouchMoveCapture","callbacks","setCallbacks","forwardProps","removeScrollBar","shards","sideCar","noIsolation","allowPinchZoom","_b","Container","gapMode","__rest","SideCar","containerRef","containerProps","__assign","lockRef","defaultProps","fullWidth","zeroRight","currentNonce","Target","read","isSideCarExport","makeStyleTag","tag","nonce","stylesheetSingleton","stylesheet","styleSheet","cssText","createTextNode","getElementsByTagName","insertStyleTag","styleSingleton","sheet","useStyle","isDynamic","dynamic","zeroGap","gap","getGapWidth","cs","getOffset","documentWidth","windowWidth","innerWidth","Style","lockAttribute","getStyles","allowRelative","important","getCurrentUseCounter","RemoveScrollBar","noRelative","noImportant","newCounter","passiveSupported","nonPassive","elementCanBeScrolled","alwaysContainsScroll","locationCouldBeScrolled","elementCouldBeScrolled","getScrollVariables","elementCouldBeVScrolled","elementCouldBeHScrolled","getHScrollVariables","getTouchXY","changedTouches","getDeltaXY","deltaX","deltaY","extractRef","generateStyle","idCounter","lockStack","getOutermostShadowParent","shadowParent","medium","exported","useMedium","shouldPreventQueue","touchStartRef","activeAxis","lastProps","classList","allow_1","__spreadArray","shouldCancelEvent","touches","currentAxis","touch","touchStart","moveDirection","abs","canBeScrolledInMainDirection","cancelingAxis","endTarget","sourceDelta","noOverscroll","directionFactor","getDirectionFactor","delta","targetInLock","shouldCancelScroll","isDeltaPositive","availableScroll","availableScrollTop","elementScroll","handleScroll","shouldPrevent","_event","sourceEvent","should","shardNodes","shouldCancel","scrollTouchStart","scrollWheel","scrollTouchMove","inst","ReactRemoveScroll","SELECTION_KEYS","LAST_KEYS","FIRST_LAST_KEYS","SUB_OPEN_KEYS","SUB_CLOSE_KEYS","MENU_NAME","createMenuContext","createMenuScope","usePopperScope","useRovingFocusGroupScope","MenuProvider","useMenuContext","MenuRootProvider","useMenuRootContext","Menu","__scopeMenu","popperScope","isUsingKeyboardRef","handleOpenChange","handlePointer","onContentChange","MenuAnchor","PortalProvider","forceMount","MenuPortal","MenuContentProvider","useMenuContentContext","MenuContent","MenuRootContentModal","MenuRootContentNonModal","MenuContentImpl","trapFocus","disableOutsideScroll","onOpenAutoFocus","onCloseAutoFocus","rovingFocusGroupScope","currentItemId","setCurrentItemId","contentRef","timerRef","searchRef","pointerGraceTimerRef","pointerGraceIntentRef","pointerDirRef","lastPointerXRef","ScrollLockWrapper","scrollLockWrapperProps","handleTypeaheadSearch","currentItem","currentMatch","textValue","nextMatch","isRepeated","normalizedSearch","currentMatchIndex","wrappedValues","getNextMatch","updateSearch","isPointerMovingToSubmenu","area","cursorPos","point","polygon","inside","j","xi","yi","xj","yj","isPointInPolygon","isPointerInGraceArea","onItemEnter","onItemLeave","onTriggerLeave","onPointerGraceIntentChange","intent","getOpenState","isKeyDownInside","closest","isModifierKey","isCharacterKey","onPointerMove","whenMouse","pointerXHasChanged","newDir","MenuGroup","MenuLabel","labelProps","ITEM_SELECT","MenuItem","onSelect","MenuItemImpl","menuItem","itemSelectEvent","isTypingAhead","isFocused","setIsFocused","textContent","setTextContent","onPointerLeave","MenuCheckboxItem","onCheckedChange","checkboxItemProps","ItemIndicatorProvider","isIndeterminate","getCheckedState","RADIO_GROUP_NAME","RadioGroupProvider","useRadioGroupContext","onValueChange","MenuRadioGroup","handleValueChange","RADIO_ITEM_NAME","MenuRadioItem","radioItemProps","ITEM_INDICATOR_NAME","useItemIndicatorContext","MenuItemIndicator","itemIndicatorProps","indicatorContext","MenuSeparator","separatorProps","MenuArrow","SUB_NAME","MenuSubProvider","useMenuSubContext","MenuSub","parentMenuContext","trigger","setTrigger","contentId","triggerId","onTriggerChange","SUB_TRIGGER_NAME","MenuSubTrigger","subContext","openTimerRef","clearOpenTimer","pointerGraceTimer","contentRect","rightSide","bleed","contentNearEdge","contentFarEdge","SUB_CONTENT_NAME","MenuSubContent","subContentProps","isCloseKey","Root3","Anchor2","Content2","Group","Label","Item2","CheckboxItem","RadioGroup","RadioItem","ItemIndicator","Separator","Arrow2","SubTrigger","SubContent","DROPDOWN_MENU_NAME","createDropdownMenuContext","createDropdownMenuScope","useMenuScope","DropdownMenuProvider","useDropdownMenuContext","DropdownMenu","__scopeDropdownMenu","openProp","defaultOpen","menuScope","triggerRef","setOpen","onOpenToggle","prevOpen","TRIGGER_NAME","DropdownMenuTrigger","triggerProps","DropdownMenuPortal","DropdownMenuContent","hasInteractedOutsideRef","ctrlLeftClick","isRightClick","DropdownMenuGroup","DropdownMenuLabel","DropdownMenuItem","DropdownMenuCheckboxItem","DropdownMenuRadioGroup","radioGroupProps","DropdownMenuRadioItem","DropdownMenuItemIndicator","DropdownMenuSeparator","DropdownMenuArrow","DropdownMenuSubTrigger","subTriggerProps","DropdownMenuSubContent","Trigger","Portal2","MenuTitle","title","Text","FloatingMenu","showTitle","titleId","DIALOG_NAME","createDialogContext","createDialogScope","DialogProvider","useDialogContext","Dialog","__scopeDialog","descriptionId","DialogTrigger","composedTriggerRef","getState","DialogPortal","OVERLAY_NAME","DialogOverlay","overlayProps","DialogOverlayImpl","DialogContent","DialogContentModal","DialogContentNonModal","DialogContentImpl","hasPointerDownOutsideRef","targetIsTrigger","TitleWarning","DescriptionWarning","TITLE_NAME","DialogTitle","titleProps","h2","DESCRIPTION_NAME","DialogDescription","descriptionProps","CLOSE_NAME","DialogClose","closeProps","TITLE_WARNING_NAME","WarningProvider","useWarningContext","contentName","titleName","docsSlug","titleWarningContext","MESSAGE","describedById","Overlay","Title","Description","Close","DrawerContext","drawerRef","overlayRef","onPress","onRelease","onDrag","onNestedDrag","onNestedOpenChange","onNestedRelease","dismissible","isOpen","isDragging","keyboardIsOpen","snapPointsOffset","snapPoints","handleOnly","shouldFade","activeSnapPoint","setActiveSnapPoint","closeDrawer","shouldAnimate","shouldScaleBackground","setBackgroundColorOnScale","noBodyStyles","autoFocus","useDrawerContext","isIPad","testPlatform","isIOS","__insertCSS","chain$1","isScrollable","getScrollParent","scrollingElement","nonTextInputTypes","restore","preventScrollCount","usePreventScroll","isDisabled","scrollable","lastY","onTouchStart","pageY","onTouchMove","onTouchEnd","innerHeight","scrollIntoView","onWindowScroll","scrollTo","pageXOffset","pageYOffset","restoreStyles","cur","setStyle","removeEvents","addEvent","preventScrollMobileSafari","scrollableTop","targetTop","HTMLTextAreaElement","ignoreCache","originalStyles","getTranslate","webkitTransform","mozTransform","mat","assignStyle","prevStyle","TRANSITIONS","DURATION","EASE","NESTED_DISPLACEMENT","DRAG_CLASS","setValue","previousBodyPosition","onDragProp","onReleaseProp","closeThreshold","scrollLockTimeout","fadeFromIndex","activeSnapPointProp","setActiveSnapPointProp","fixed","disablePreventScroll","snapToSequentialPoint","preventScrollRestoration","repositionInputs","onAnimationEnd","_drawerRef_current","_drawerRef_current1","setIsOpen","restorePositionSetting","hasBeenOpened","setHasBeenOpened","setIsDragging","justReleased","setJustReleased","openTime","dragStartTime","dragEndTime","lastTimeDragPrevented","isAllowedToDrag","nestedOpenChangeTimer","pointerStart","previousDiffFromInitial","drawerHeightRef","drawerWidthRef","initialDrawerHeight","onSnapPointChange","activeSnapPointIndex","onReleaseSnapPoints","onDragSnapPoints","getPercentageDragged","getSnapPointsPercentageDragged","windowDimensions","setWindowDimensions","onResize","isLastSnapPoint","_snapPoints_findIndex","findIndex","snapPoint","containerSize","_snapPoints_map","isPx","snapPointAsNumber","activeSnapPointOffset","snapToPoint","dimension","_snapPointsOffset_findIndex","newSnapPointIndex","snapPointDim","transition","newIndex","absDraggedDistance","isDraggingDown","isOverlaySnapPoint","targetSnapPointIndex","snapPointDistance","percentageDragged","draggedDistance","velocity","currentPosition","isFirst","hasDraggedUp","closestSnapPoint","curr","dim","dragDirection","useSnapPoints","activeUrl","setActiveUrl","scrollPos","setPositionFixed","bottomBarHeight","matchMedia","usePositionFixed","shouldDrag","isDraggingInDirection","_window_getSelection","highlightedText","getSelection","swipeAmount","date","fromWithin","cancelDrag","resetDrawer","currentSwipeAmount","borderRadius","transitionProperty","transitionDuration","transitionTimingFunction","_window_visualViewport","onVisualViewportChange","visualViewportHeight","totalHeight","diffFromInitial","drawerHeight","isTallEnough","offsetFromTop","newDrawerHeight","isMobileFirefox","scrollBehavior","setPointerCapture","pointerId","pageX","timeTaken","distMoved","_drawerRef_current_getBoundingClientRect_height","visibleDrawerHeight","_drawerRef_current_getBoundingClientRect_width","visibleDrawerWidth","isHorizontalSwipe","directionMultiplier","noCloseSnapPointsPreCondition","snapPointPercentageDragged","dampenedDraggedDistance","translateValue","opacityValue","scaleValue","borderRadiusValue","initialScale","newScale","newTranslate","translate","composedRef","hasSnapPoints","delayedSnapPoints","setDelayedSnapPoints","pointerStartRef","lastKnownPointerEventRef","wasBeyondThePointRef","timeoutIdRef","initialBackgroundColor","useMemo","backgroundColor","background","wrapperStylesCleanup","removeProperty","useScaleBackground","handleOnPointerUp","yPosition","xPosition","swipeStartThreshold","isAllowedToSwipe","isDeltaX","dFactor","isDeltaInDirection","onPointerOut","onContextMenu","Handle","preventCycle","closeTimeoutIdRef","shouldCancelInteractionRef","handleCancelInteraction","currentSnapIndex","nextSnapPoint","handleCycleSnapPoints","onPointerCancel","Drawer","Root","NestedRoot","getPlatform","_globalThis$navigator","DrawerMenu","drawerMenu","DropdownMenuItemWrapper","childrenProp","drawer","MenuItemWrapper","MenuContext","createContext","ChevronRightIcon","onClickProp","hideChevron","useContext","useCallback","selectEvent","iconIsReactElement","isValidElement","componentIcon","SvgIcon","DEFAULT_ORIENTATION","ORIENTATIONS","decorative","orientationProp","domProps","isValidOrientation","semanticProps","SPACING_CUSTOM_PROP","theirRef","spacing","ourRef","_ourRef$current","RadixSeparator","TooltipContext","useTooltipContext","hasLabel","isTriggerInteractive","nonInteractiveTriggerTabIndex","controlledOpen","caption","ariaAtomic","ariaLive","labelId","captionId","arrowRef","uncontrolledOpen","setUncontrolledOpen","open2","hoverDelay","hover","pressTimer","press","onTouchCancel","dismiss","purpose","interactions","tooltipProps","useTooltip","TooltipAnchor","TooltipContent","Caption","_useTooltipContext","invisible","cloneElement","spanProps","_excluded3","TooltipProvider","Heading","typography","possibleNames","g","acquired","acquireAsync","resolver","timer","race","tryAcquire","pow","trunc","Uint8ClampedArray","cos","PI","BrowserslistError","noop","loadQueries","getStat","stats","loadConfig","loadCountry","loadFeature","parseConfig","readConfig","findConfig","findConfigFile","clearCaches","oldDataWarning","browserslist","captureStackTrace","jsReleases","agents","e2c","jsEOL","parseWithoutCache","isVersionsMatch","normalizeElectron","versionToUse","nameMapper","getMajor","getMajorVersions","released","number","majorVersions","uniq","minimum","filtered","fillUsage","generateFilter","sign","parseLatestFloat","parseSimpleInt","compareSemver","semverFilterLoose","compareSemverLoose","normalizeVersion","resolved","versionAliases","resolveVersion","filterByYear","since","byName","releaseDate","cloneData","aliases","mobileToDesktop","desktopNames","desktop","android","normalizeAndroidVersions","copy","copyObject","cloned","androidVersions","chromeVersions","iFirstEvergreen","checkName","filterJumps","nVersions","jump","op_mob","isSupported","withPartial","queries","parseQueries","not","QUERIES","compose","prepareOpts","prepareQueries","defaults","checkQueries","parseCache","needsPath","ignoreUnknownVersions","dangerousExtend","browser","customUsage","cacheKey","name1","name2","BROWSERSLIST_DISABLE_CACHE","nodeQuery","matched","nodeVersions","sinceQuery","year","month","day","UTC","coverQuery","coverage","usage","place","coveraged","custom","fx","ff","ios","explorer","blackberry","explorermobile","operamini","operamobile","chromeandroid","firefoxandroid","ucandroid","qqandroid","and_chr","and_ff","ie_mob","browsers","customStats","dataByBrowser","last_major_versions","regexp","last_versions","last_electron_major_versions","last_node_major_versions","last_browser_major_versions","last_electron_versions","last_node_versions","last_browser_versions","unreleased_versions","unreleased_electron_versions","unreleased_browser_versions","last_years","years","since_y","since_y_m","since_y_m_d","popularity","popularity_in_my_stats","percentage","popularity_in_config_stats","loadStat","popularity_in_place","cover","cover_in","feature","supportType","features","iMax","checkDesktop","electron_range","fromToUse","toToUse","node_range","browser_range","electron_ray","node_ray","browser_ray","alias","firefox_esr","opera_mini_all","electron_version","node_major_version","node_minor_version","node_patch_version","current_node","maintained_node","phantomjs_1_9","phantomjs_2_1","browser_version","browserslist_config","extends","dead","unknown","release_date","usage_global","full","interval","AND_REGEXP","OR_REGEXP","matchQuery","matchBlock","string","qs","predicate","substr","block","$apply","$call","$reflectApply","actualApply","$TypeError","$actualApply","GetIntrinsic","callBind","$indexOf","allowMissing","intrinsic","setFunctionLength","$defineProperty","callBindBasic","applyBind","adjustedLength","A","K","E","F","G","B","kC","C","L","H","N","O","P","Q","I","S","T","U","V","W","X","Y","Z","f","h","q","u","w","AB","BB","CB","DB","EB","FB","GB","HB","IB","JB","KB","LB","MB","D","lC","IC","J","NB","OB","PB","QB","RB","SB","TB","UB","VB","WB","XB","YB","ZB","aB","bB","cB","dB","eB","fB","gB","hB","iB","jB","kB","lB","mB","nB","oB","pB","qB","rB","sB","tB","JC","uB","KC","vB","wB","xB","yB","zB","AC","BC","LC","MC","NC","OC","PC","mC","nC","oC","pC","qC","QC","rC","sC","tC","uC","RC","CC","DC","vC","wC","xC","SC","TC","EC","yC","FC","UC","VC","WC","XC","YC","zC","GC","ZC","aC","bC","cC","dC","HC","eC","fC","gC","hC","iC","jC","AD","BD","CD","DD","ED","FD","GD","HD","ID","JD","KD","LD","MD","ND","OD","PD","QD","RD","SD","TD","UD","VD","WD","XD","YD","ZD","aD","bD","cD","dD","eD","fD","gD","hD","iD","jD","kD","lD","mD","nD","oD","pD","agentsData","unpackBrowserVersions","versionsData","prefix_exceptions","map2","key2","browserVersions","hasOwn","appendClass","parseValue","newClass","isContainer","_type","resumeAt","entering","_firstChild","_next","_parent","NodeWalker","nodeType","sourcepos","_lastChild","_prev","_sourcepos","_open","_string_content","_literal","_listData","_info","_destination","_title","_isFenced","_fenceChar","_fenceLength","_fenceOffset","_onEnter","_onExit","tight","delimiter","delim","unlink","prependChild","insertAfter","sibling","insertBefore","_fromCodePoint","ENTITY","TAGNAME","OPENTAG","CLOSETAG","reHtmlTag","reBackslashOrAmp","ESCAPABLE","reEntityOrEscapedChar","reXmlSpecial","unescapeChar","charAt","unescapeString","replaceUnsafeChar","escapeXml","fromCodePoint","RangeError","fromCharCode","stringFromCharCode","highSurrogate","lowSurrogate","codeUnits","codePoint","uri","C_SINGLEQUOTE","C_DOUBLEQUOTE","ESCAPED_CHAR","rePunctuation","reLinkTitle","reLinkDestinationBraces","reEscapable","reEntityHere","reTicks","reTicksHere","reEllipses","reDash","reEmailAutolink","reAutolink","reSpnl","reWhitespaceChar","reUnicodeWhitespaceChar","reFinalSpace","reInitialSpace","reSpaceAtEndOfLine","reLinkLabel","reMain","normalizeReference","subject","pos","peek","spnl","parseBackticks","ticks","contents","afterOpenTicks","parseBackslash","subj","parseAutolink","dest","parseHtmlTag","scanDelims","cc","char_before","char_after","cc_after","left_flanking","right_flanking","can_open","can_close","after_is_whitespace","after_is_punctuation","before_is_whitespace","before_is_punctuation","numdelims","startpos","handleDelim","smart","delimiters","origdelims","previous","removeDelimiter","processEmphasis","stack_bottom","opener","closer","old_closer","opener_inl","closer_inl","tempstack","use_delims","tmp","opener_found","openers_bottom_index","openers_bottom","odd_match","closercc","emph","literal","parseLinkTitle","parseLinkDestination","savepos","openparens","parseLinkLabel","parseOpenBracket","addBracket","parseBang","parseCloseBracket","is_image","reflabel","brackets","removeBracket","image","beforelabel","bracketAfter","link","refmap","destination","previousDelimiter","parseEntity","parseString","chars","enCount","emCount","repeat","parseNewline","lastc","hardbreak","parseReference","rawlabel","matchChars","beforetitle","atLineEnd","normlabel","parseInline","parseInlines","reHtmlBlockOpen","reHtmlBlockClose","reThematicBreak","reMaybeSpecial","reNonSpace","reBulletListMarker","reOrderedListMarker","reATXHeadingMarker","reCodeFence","reClosingCodeFence","reSetextHeadingLine","reLineEnding","isSpaceOrTab","ln","endsWithBlankLine","addLine","partiallyConsumedTab","charsToTab","tip","currentLine","addChild","blocks","canContain","finalize","lineNumber","column_number","newBlock","closeUnmatchedBlocks","allClosed","oldtip","lastMatchedContainer","continue","emptyNodes","hasReferenceDefs","inlineParser","removedText","removeLinkReferenceDefinitions","acceptsLines","subitem","block_quote","indented","nextNonspace","advanceNextNonspace","advanceOffset","blank","indent","markerOffset","heading","thematic_break","code_block","lastLineLength","newlinePos","firstLine","info","html_block","_htmlBlockType","paragraph","blockStarts","fenceLength","blockType","list_data","item_data","nextc","spacesStartCol","spacesStartOffset","bulletChar","blank_item","spaces_after_marker","parseListMarker","columns","charsToAdvance","nextNonspaceColumn","findNextNonspace","cols","incorporateLine","lastChild","all_matched","matchedLeaf","starts","startsLen","above","processInlines","Document","timeEnd","Renderer","render","ast","lastOut","lit","cr","esc","reUnsafeProtocol","reSafeDataProtocol","potentiallyUnsafe","HtmlRenderer","softbreak","disableTags","text","html_inline","linebreak","strong","grandparent","listTight","tagname","info_words","cls","listType","listStart","custom_inline","onEnter","onExit","custom_block","selfclosing","attrib","att","reXMLTag","XmlRenderer","indentLevel","selfClosing","nodetype","listDelimiter","delimword","decodeXML","decodeHTMLStrict","decodeHTML","determineBranch","JUMP_OFFSET_BASE","BinTrieFlags","xmlDecodeTree","htmlDecodeTree","decode_data_html_1","decode_data_xml_1","decode_codepoint_1","getDecoder","decodeTree","lastIdx","strIdx","excess","treeIdx","HAS_VALUE","MULTI_BYTE","cp","entity","nodeIdx","branchCount","BRANCH_LENGTH","jumpOffset","JUMP_TABLE","lo","hi","mid","midVal","htmlDecoder","xmlDecoder","decodeMap","getTrie","encodeHTMLTrieRe","getCodePoint","entities_json_1","isHighSurrugate","codePointAt","htmlTrie","_d","trie","_i","lastMap","regExp","escapeUTF8","encodeNonAsciiHTML","encodeHTML","encodeXML","xml_json_1","encode_trie_1","htmlReplacer","getCharRegExp","xmlReplacer","xmlInvalidChars","xmlCodeMap","nonAscii","Uint16Array","EntityLevel","DecodingMode","EncodingMode","decode_1","encode_1","encode_2","decode_2","PARAM_REGEXP","TEXT_REGEXP","TOKEN_REGEXP","QESC_REGEXP","QUOTE_REGEXP","TYPE_REGEXP","qstring","ContentType","parameters","getHeader","getcontenttype","extend","isDate","sprintf","except","strftime","translationScope","isSymbol","getEntry","translations","hasOwnProp","Counterpart","EventEmitter","_registry","locale","interpolate","fallbackLocales","interpolations","normalizedKeys","keepTrailingDot","keyTransformer","generateMissingEntry","registerTranslations","setMaxListeners","getLocale","setLocale","getFallbackLocale","setFallbackLocale","getAvailableLocales","availableLocales","setAvailableLocales","getSeparator","setSeparator","setInterpolate","getInterpolate","setKeyTransformer","getKeyTransformer","setMissingEntryGenerator","getMissingEntryGenerator","registerInterpolations","onLocaleChange","addLocaleChangeListener","addListener","offLocaleChange","removeLocaleChangeListener","removeListener","onTranslationNotFound","addTranslationNotFoundListener","offTranslationNotFound","removeTranslationNotFoundListener","addErrorListener","offError","removeErrorListener","fallbackLocale","_normalizeKeys","fallback","_fallback","ii","fallbackKeys","_pluralize","_interpolate","localize","pluralizeFunc","withLocale","withSeparator","_normalizeKey","normalizedKeyArray","listenerCount","_resolve","dateOrTime","instance","Instance","Translator","counterpart","pluralize","formats","long","short","datetime","dateNames","pad","hours12","hour","getHours","weekNumber","firstWeekday","wday","getDay","firstDayOfYear","getFullYear","weekNum","days","abbreviated_days","months","getMonth","abbreviated_months","getDate","ceil","getMinutes","ordinal","am","pm","getSeconds","tzString","getTimezoneOffset","__locale","isMergeableObject","isNonNullObject","stringValue","REACT_ELEMENT_TYPE","isReactElement","isSpecial","cloneUnlessOtherwiseSpecified","deepmerge","defaultArrayMerge","getKeys","symbol","getEnumerableOwnPropertySymbols","propertyIsOnObject","mergeObject","propertyIsUnsafe","customMerge","getMergeFunction","arrayMerge","sourceIsArray","deepmerge_1","$SyntaxError","gopd","nonEnumerable","nonWritable","nonConfigurable","pack","ar","SuppressedError","aKey","aValue","checkElementType","elementTypeNames","elementTypeName","objToNode","objNode","insideSvg","createComment","createElementNS","childNodes","childNode","valueDiffing","getFromRoute","route","applyDiff","newNode","action","_const","addElement","addTextElement","preDiffApply","addAttribute","modifyAttribute","modifyTextElement","textDiff","modifyValue","modifyComment","modifyChecked","modifySelected","replaceElement","namespaceURI","replaceChild","relocateGroup","groupLength","removeElement","parentRoute","removeTextElement","postDiffApply","swap","p1","p2","undoDOM","diffs","undoDiff","elementDescriptors","findUniqueDescriptors","li","uniqueDescriptors","duplicateDescriptors","descriptor","inUnique","uniqueInBoth","l1","l2","l1Unique","l2Unique","inBoth","removeDone","outerDone","innerDone","valueDone","cleanNode","diffNode","elementNode","diffChildNode","isEqual","e1","e2","e1Attributes","e2Attributes","attribute","roughlyEqual","sameSiblings","preventRecursion","nodeList1","nodeList2","makeBooleanArray","markSubTrees","oldTree","newTree","oldChildren","marked1","marked2","subsets","returnIndex","foundAllSubsets","c1","c2","lcsSize","c1Length","c2Length","subsetsSame","c1Desc","c2Desc","c1Index","c1Element","c2Index","c2Element","findCommonSubsets","markBoth","subsetsAge","getFromVirtualRoute","nodeIndex","applyVirtual","routeInfo","newSubsets","preVirtualDiffApply","movedNode","splitLength","postVirtualDiffApply","applyVirtualDiff","nodeToObj","aNode","tagRE","attrRE","unescape","lookup","br","embed","img","keygen","meta","track","wbr","parseTag","caseSensitive","voidElement","tagMatch","endIndex","reg","stringToObj","isComment","nextChar","comment","t1Node","t2Node","t1","t2","diffcount","foundAll","t1Orig","t2Orig","tracker","DiffTracker","findDiffs","diffcap","findNextDiff","fdiffs","maxDepth","findOuterDiff","filterOuterDiff","findInnerDiff","findValueDiff","attr1","attr2","attrLength","Diff","t1ChildNodes","t2ChildNodes","childNodesLengthDifference","maxChildCount","cachedSubtrees","subtrees","attemptGroupRelocation","destinationDifferent","toGroup","similarNode","gapInformation","stable","gaps1","gaps2","endOld","endNew","getGapInformation","shortest","index2","index1","testI","DEFAULT_OPTIONS","currentValue","expectedValue","compress","components","varNames","varName","applyDOM","undo","DiffFinder","tick","messages","wrapkey","oldfn","fin","fout","tStr","nf","stringCollapse","outerHTML","terminator","diff_match_patch","Diff_Timeout","Diff_EditCost","Match_Threshold","Match_Distance","Patch_DeleteThreshold","Patch_Margin","Match_MaxBits","DIFF_DELETE","diff_main","text1","text2","opt_checklines","opt_deadline","MAX_VALUE","deadline","checklines","commonlength","diff_commonPrefix","commonprefix","diff_commonSuffix","commonsuffix","diff_compute_","diff_cleanupMerge","longtext","shorttext","hm","diff_halfMatch_","text1_a","text1_b","text2_a","text2_b","mid_common","diffs_a","diffs_b","diff_lineMode_","diff_bisect_","diff_linesToChars_","chars1","chars2","linearray","lineArray","diff_charsToLines_","diff_cleanupSemantic","pointer","count_delete","count_insert","text_delete","text_insert","subDiff","text1_length","text2_length","max_d","v_offset","v_length","front","k1start","k1end","k2start","k2end","k1","k1_offset","y1","x1","k2_offset","x2","diff_bisectSplit_","k2","y2","text1a","text2a","text1b","text2b","diffsb","lineHash","diff_linesToCharsMunge_","lineStart","lineEnd","lineArrayLength","maxLines","pointermin","pointermax","pointermid","pointerstart","pointerend","diff_commonOverlap_","text_length","best","pattern","found","dmp","diff_halfMatchI_","best_longtext_a","best_longtext_b","best_shorttext_a","best_shorttext_b","seed","best_common","prefixLength","suffixLength","hm1","hm2","changes","equalities","equalitiesLength","lastEquality","length_insertions1","length_deletions1","length_insertions2","length_deletions2","diff_cleanupSemanticLossless","deletion","insertion","overlap_length1","overlap_length2","diff_cleanupSemanticScore_","one","two","char1","char2","nonAlphaNumeric1","nonAlphaNumericRegex_","nonAlphaNumeric2","whitespace1","whitespaceRegex_","whitespace2","lineBreak1","linebreakRegex_","lineBreak2","blankLine1","blanklineEndRegex_","blankLine2","blanklineStartRegex_","equality1","edit","equality2","commonOffset","commonString","bestEquality1","bestEdit","bestEquality2","bestScore","score","diff_cleanupEfficiency","pre_ins","pre_del","post_ins","post_del","diff_xIndex","loc","last_chars1","last_chars2","diff_prettyHtml","pattern_amp","pattern_lt","pattern_gt","pattern_para","diff_text1","diff_text2","diff_levenshtein","levenshtein","insertions","deletions","diff_toDelta","diff_fromDelta","diffsLength","decodeURI","match_main","match_bitap_","match_alphabet_","match_bitapScore_","accuracy","proximity","score_threshold","best_loc","lastIndexOf","bin_min","bin_mid","matchmask","last_rd","bin_max","finish","rd","charMatch","patch_addContext_","start2","length1","suffix","start1","length2","patch_make","opt_b","opt_c","patches","patch_obj","patchDiffLength","char_count1","char_count2","prepatch_text","postpatch_text","diff_type","diff_text","patch_deepCopy","patchesCopy","patchCopy","patch_apply","nullPadding","patch_addPadding","patch_splitMax","results","start_loc","expected_loc","end_loc","paddingLength","extraLength","patch_size","bigpatch","precontext","empty","postcontext","patch_toText","patch_fromText","textline","textPointer","patchHeader","dijkstra","single_source_shortest_paths","graph","predecessors","costs","cost_of_s_to_u","adjacent_nodes","cost_of_s_to_u_plus_cost_of_e","cost_of_s_to_v","PriorityQueue","make","cost","extract_shortest_path_from_predecessor_list","find_path","queue","sorter","default_sorter","ElementType","Doctype","CDATA","Tag","Script","Comment","Directive","isTag","hasProtoAccessor","gOPD","$Object","$getPrototypeOf","shortcode","SEQUENCE_REMOVAL_PATTERN","LIGHT_SKIN","MEDIUM_LIGHT_SKIN","MEDIUM_DARK_SKIN","GROUP_KEY_ANIMALS_NATURE","GROUP_KEY_FOOD_DRINK","GROUP_KEY_TRAVEL_PLACES","GROUP_KEY_ACTIVITIES","GROUP_KEY_OBJECTS","GROUP_KEY_SYMBOLS","GROUP_KEY_FLAGS","GROUP_KEY_COMPONENT","SKIN_KEY_LIGHT","SKIN_KEY_MEDIUM_LIGHT","SKIN_KEY_MEDIUM","SKIN_KEY_MEDIUM_DARK","SKIN_KEY_DARK","LATEST_EMOJI_VERSION","LATEST_UNICODE_VERSION","LATEST_CLDR_VERSION","FIRST_UNICODE_EMOJI_VERSION","EMOJI_VERSIONS","UNICODE_VERSIONS","SUPPORTED_LOCALES","withNose","isFace","fetchUrl","cachedData","redirect","ALIASES","discord","skins","joinShortcodesToEmoji","skinEmoji","skin","baseEmoji","joinShortcodes","fetchFromCDN","customPreset","preset","customLocale","fetchShortcodes","flattenEmojiData","STRIP_PATTERN","EvalError","SyntaxError","URIError","matchHtmlRegExp","ReflectOwnKeys","ReflectApply","receiver","ownKeys","NumberIsNaN","emitter","errorListener","eventTargetAgnosticAddListener","addErrorHandlerIfEventEmitter","_eventsCount","_maxListeners","defaultMaxListeners","checkListener","_getMaxListeners","that","_addListener","prepend","existing","warning","newListener","warned","onceWrapper","fired","wrapFn","_onceWrap","_listeners","unwrap","evlistener","unwrapListeners","arrayClone","wrapListener","getMaxListeners","doError","listeners","prependListener","prependOnceListener","originalListener","spliceOne","removeAllListeners","rawListeners","eventNames","ap","toStr","hasOwnConstructor","hasIsPrototypeOf","getProperty","copyIsArray","ARRAY","BIT","BITS","BYTE","BYTES","EMPTY","EXPONENT","FUNCTION","IEC","INVALID_NUMBER","INVALID_ROUND","JEDEC","OBJECT","PERIOD","ROUND","SI","SI_KBIT","SI_KBYTE","SPACE","STRING","ZERO","STRINGS","iec","bits","bytes","jedec","fullform","filesize","localeOptions","spacer","standard","fullforms","exponent","roundingMethod","precision","neg","roundingFunc","toPrecision","toLocaleString","padEnd","unit","isCallable","thisArg","forEachArray","forEachString","forEachObject","concatty","bound","arrLike","slicy","boundLength","boundArgs","joiner","joiny","Empty","implementation","$Error","$EvalError","$RangeError","$ReferenceError","$URIError","$Function","getEvalledConstructor","expressionSyntax","$gOPD","throwTypeError","ThrowTypeError","calleeThrows","gOPDthrows","hasSymbols","getProto","$ObjectGPO","$ReflectGPO","needsEval","TypedArray","INTRINSICS","AggregateError","ArrayBuffer","Atomics","BigInt","BigInt64Array","BigUint64Array","DataView","decodeURIComponent","encodeURIComponent","eval","Float32Array","Float64Array","FinalizationRegistry","Int8Array","Int16Array","Int32Array","SharedArrayBuffer","Uint32Array","WeakRef","errorProto","doEval","gen","LEGACY_ALIASES","$concat","$spliceApply","$replace","$strSlice","$exec","rePropName","reEscapeChar","getBaseIntrinsic","intrinsicName","quote","subString","stringToPath","intrinsicBaseName","intrinsicRealName","skipFurtherCaching","isOwn","part","reflectGetProto","originalGetProto","getDunderProto","glob","reStr","extended","globstar","inGroup","prevChar","starCount","hasPropertyDescriptors","hasArrayLengthDefineBug","origSymbol","hasSymbolSham","sym","symObj","syms","toStringTag","$hasOwn","named_references_1","require","numeric_unicode_map_1","surrogate_pairs_1","allNamedReferences","namedReferences","html5","replaceUsingRegExp","macroText","macroRegExp","macroReplacer","replaceResult","replaceMatch","replaceLastIndex","replaceInput","encodeRegExps","specialChars","nonAsciiPrintable","nonAsciiPrintableOnly","extensive","defaultEncodeOptions","mode","encodeRegExp","references","characters","isHex","defaultDecodeOptions","baseDecodeRegExps","xml","bodyRegExps","html4","decodeRegExps","outOfBoundsChar","defaultDecodeEntityOptions","getDecodedEntity","isAttribute","isStrict","decodeResult","decodeEntityLastChar","decodeResultByReference","decodeSecondChar","decodeCode","numericUnicodeMap","entities","decodeRegExp","fj","astralCodePoint","attributeNames","elementNames","__createBinding","__setModuleDefault","__importStar","entities_1","foreignNames_js_1","unencodedElements","replaceQuotes","singleTag","renderNode","renderComment","renderCdata","xmlMode","foreignModeIntegrationPoints","foreignElements","attribs","encodeEntities","decodeEntities","escapeAttribute","emptyAttrs","formatAttributes","selfClosingTags","renderTag","escapeText","renderText","__exportStar","DomHandler","domelementtype_1","node_js_1","defaultOpts","withStartIndices","withEndIndices","elementCB","tagStack","lastNode","onparserinit","onreset","onend","handleCallback","onclosetag","onopentag","addNode","ontext","oncomment","oncommentend","oncdatastart","oncdataend","onprocessinginstruction","ProcessingInstruction","previousSibling","extendStatics","__extends","cloneNode","hasChildren","isDocument","isDirective","isText","isCDATA","NodeWithChildren","DataNode","recursive","namespace","cloneChildren","clone_1","clone_2","clone_3","instruction","sourceCodeLocation","childs","ctor","superCtor","super_","TempCtor","word","includeBoundaries","v4","v6seg","v6","v46Exact","v4exact","v6exact","ip","exact","hasToStringTag","$toString","callBound","isStandardArguments","isLegacyArguments","callee","supportsStandardArguments","badArrayLike","isCallableMarker","fnToStr","reflectApply","constructorRegex","isES6ClassFn","fnStr","tryFunctionObject","isIE68","isDDA","strClass","GeneratorFunction","isFnRegex","generatorFunc","getGeneratorFunc","ipRegex","isIp","isObject","prot","jwtDecode","InvalidTokenError","base64UrlDecode","atob","b64DecodeUnicode","decoded","SourceLocation","lexer","second","Token","noexpand","treatAsRelax","endToken","ParseError","rawMessage","underlined","self","uppercase","ESCAPE_LOOKUP","ESCAPE_REGEX","getBaseElem","utils","deflt","setting","defaultIfUndefined","hyphenate","isCharacterBox","baseElem","protocolFromUrl","SETTINGS_SCHEMA","displayMode","cli","enum","leqno","fleqn","throwOnError","cliDescription","errorColor","cliProcessor","color","macros","cliDefault","def","defs","minRuleThickness","colorIsTextColor","trust","maxExpand","globalGroup","getDefaultValue","schema","defaultType","Settings","reportNonstrict","errorCode","errorMsg","useStrictBehavior","cramped","sup","fracNum","fracDen","cramp","text$1","isTight","Style$1","DISPLAY","TEXT","SCRIPT","SCRIPTSCRIPT","scriptData","allBlocks","supportedCodepoint","codepoint","hLinePad","doubleleftarrow","doublerightarrow","leftarrow","leftbrace","leftbraceunder","leftgroup","leftgroupunder","leftharpoon","leftharpoonplus","leftharpoondown","leftharpoondownplus","lefthook","leftlinesegment","leftmapsto","leftToFrom","longequal","midbrace","midbraceunder","oiintSize1","oiintSize2","oiiintSize1","oiiintSize2","rightarrow","rightbrace","rightbraceunder","rightgroup","rightgroupunder","rightharpoon","rightharpoonplus","rightharpoondown","rightharpoondownplus","righthook","rightlinesegment","rightToFrom","twoheadleftarrow","twoheadrightarrow","tilde1","tilde2","tilde3","tilde4","vec","widehat1","widehat2","widehat3","widehat4","widecheck1","widecheck2","widecheck3","widecheck4","baraboveleftarrow","rightarrowabovebar","baraboveshortleftharpoon","rightharpoonaboveshortbar","shortbaraboveleftharpoon","shortrightharpoonabovebar","DocumentFragment","maxFontSize","hasClass","toNode","frag","createDocumentFragment","toMarkup","markup","toText","fontMetricsData","sigmasAndXis","slant","space","stretch","shrink","xHeight","quad","extraSpace","num1","num2","num3","denom1","denom2","sup1","sup2","sup3","sub1","sub2","supDrop","subDrop","delim1","delim2","axisHeight","defaultRuleThickness","bigOpSpacing1","bigOpSpacing2","bigOpSpacing3","bigOpSpacing4","bigOpSpacing5","sqrtRuleThickness","ptPerEm","doubleRuleSep","arrayRuleWidth","fboxsep","fboxrule","extraCharacterMap","getCharacterMetrics","character","font","ch","metrics","italic","skew","fontMetricsBySizeIndex","sizeStyleMap","sizeMultipliers","sizeAtStyle","Options","textSize","phantom","fontFamily","fontWeight","fontShape","sizeMultiplier","_fontMetrics","BASESIZE","extension","havingStyle","havingCrampedStyle","havingSize","havingBaseStyle","wantSize","havingBaseSizing","withColor","withPhantom","withFont","withTextFontFamily","withTextFontWeight","withTextFontShape","sizingClasses","oldOptions","baseSizingClasses","fontMetrics","sizeIndex","cssEmPerMu","getGlobalMetrics","getColor","ptPerUnit","relativeUnit","validUnit","calculateSize","sizeValue","unitOptions","makeEm","toFixed","createClass","initNode","invalidAttributeNameRegex","Span","Img","iCombinations","SymbolNode","script","scriptFromCodepoint","marginRight","needsSpan","SvgNode","PathNode","pathName","alternate","LineNode","assertSymbolDomNode","ATOMS","NON_ATOMS","defineSymbol","acceptUnicodeChar","math","main","ams","accent","bin","mathord","punct","textord","ligatures","mathTextSymbols","textSymbols","_ch","letters","_i2","_ch2","wideChar","_i3","_ch3","_i4","_ch4","extraLatin","_i5","_ch5","wideLatinLetterData","wideNumeralData","lookupSymbol","fontName","makeSymbol","symbolNode","canCombine","_style","sizeElementFromChildren","makeSpan$2","makeSvgSpan","makeFragment","retrieveTextFontName","baseFontName","fontMap","variant","svgData","buildCommon","mathsym","makeSpan","makeLineSpan","thickness","borderBottomWidth","makeAnchor","wrapFragment","makeVList","params","positionType","_depth","currPos","positionData","firstChild","getVListChildrenAndDepth","pstrutSize","pstrut","realChildren","minPos","maxPos","_child","_elem","wrapperClasses","wrapperStyle","childWrap","marginLeft","rows","vlist","emptySpan","depthStrut","topStrut","vtable","makeOrd","isFont","fontOrFamily","wideFontName","wideFontClass","wideCharacterFont","fontClasses","fontData","fontClass","boldsymbol","_fontName","_fontName3","_fontName2","makeGlue","measurement","rule","staticSvg","svgNode","tryCombineChars","thinspace","mediumspace","thickspace","spacings","mord","mop","mbin","mrel","minner","mopen","mclose","mpunct","tightSpacings","_functions","_htmlGroupBuilders","_mathmlGroupBuilders","defineFunction","htmlBuilder","mathmlBuilder","numArgs","argTypes","allowedInArgument","allowedInText","allowedInMath","numOptionalArgs","infix","defineFunctionBuilders","_ref2","normalizeArgument","ordargument","makeSpan$1","binLeftCanceller","binRightCanceller","styleMap$1","DomEnum","buildExpression$1","expression","isRealGroup","surrounding","groups","buildGroup$1","glueOptions","dummyPrev","dummyNext","isRoot","traverseNonSpaceNodes","prevType","getTypeOfDomTree","partialGroup","checkPartialGroup","nonspace","getOutermostNode","makeNullDelimiter","moreClasses","baseOptions","groupNode","multiplier","buildHTMLUnbreakable","strut","verticalAlign","buildHTML","eqnNum","tagChild","nobreak","htmlNode","newDocumentFragment","MathNode","TextNode","mathMLTree","SpaceNode","makeText","makeRow","getVariant","isNumberPunctuation","buildExpression","isOrdgroup","buildGroup","lastGroup","_group","buildExpressionRow","buildMathML","texExpression","isDisplayMode","forMathmlOnly","annotation","semantics","wrapperClass","optionsFromSettings","settings","displayWrap","stretchyCodePoint","widehat","widecheck","widetilde","utilde","overleftarrow","underleftarrow","xleftarrow","overrightarrow","underrightarrow","xrightarrow","underbrace","overbrace","overgroup","undergroup","overleftrightarrow","underleftrightarrow","xleftrightarrow","Overrightarrow","xRightarrow","overleftharpoon","xleftharpoonup","overrightharpoon","xrightharpoonup","xLeftarrow","xLeftrightarrow","xhookleftarrow","xhookrightarrow","xmapsto","xrightharpoondown","xleftharpoondown","xrightleftharpoons","xleftrightharpoons","xtwoheadleftarrow","xtwoheadrightarrow","xlongequal","xtofrom","xrightleftarrows","xrightequilibrium","xleftequilibrium","katexImagesData","overlinesegment","underlinesegment","stretchy","topPad","bottomPad","borderColor","viewBoxWidth","viewBoxHeight","_height","numChars","imgIndex","widthClasses","aligns","paths","_minWidth","_viewBoxHeight","_height2","numSvgChildren","_path","_svgNode","_span","buildSvgSpan_","assertNodeType","assertSymbolNodeType","typedNode","checkSymbolNodeType","htmlBuilder$a","grp","supSubGroup","assertSpan","isShifty","baseChar","accentBody","accentBelow","clearance","isStretchy","accentFull","accentWrap","mathmlBuilder$9","accentNode","NON_STRETCHY_ACCENT_REGEX","funcName","innerGroup","kern","paddedNode","optArgs","below","lowerGroup","newOptions","upperGroup","arrowPrefix","arrowBody","arrowShift","upperShift","lowerShift","arrowNode","upperNode","lowerNode","_lowerNode","htmlBuilder$9","mclass","mathmlBuilder$8","lspace","rspace","binrelClass","atom","family","_ref3","baseArg","shiftedArg","baseOp","limits","alwaysHandleSupSub","parentIsSupSub","suppressBaseShift","supsub","textShadow","cdArrowFunctionName","isStartOfArrow","cdArrow","arrowChar","labels","callFunction","bareArrow","arrowGroup","htmlBuilder$8","mathmlBuilder$7","breakOnTokenText","gullet","parseExpression","future","parseSizeGroup","newLine","marginTop","globalMap","checkControlSequence","tok","letCommand","macro","unexpandable","isExpandable","consumeSpaces","parseFunction","popToken","insert","consumeArg","expandTokens","getRHS","_ref4","middle","pushToken","getMetrics","styleWrap","toStyle","delimSizeMultiplier","centerSpan","makeLargeDelim","mathrmSize","makeGlyphSpan","sizeClass","makeInner","innerPath","lap","verts","doubleVerts","makeStackedDelim","heightTotal","svgLabel","topMetrics","topHeightTotal","repeatMetrics","repeatHeightTotal","bottomMetrics","bottomHeightTotal","middleHeightTotal","middleFactor","middleMetrics","minHeight","realHeightTotal","midHeight","pathStr","tallDelim","_innerHeight","emPad","sqrtSvg","sqrtName","extraVinculum","sqrtMain","sqrtSize1","sqrtSize2","sqrtSize3","sqrtSize4","sqrtTall","sqrtPath","pathNode","stackLargeDelimiters","stackAlwaysDelimiters","stackNeverDelimiters","sizeToMaxHeight","stackNeverDelimiterSequence","stackAlwaysDelimiterSequence","stackLargeDelimiterSequence","delimTypeToFont","traverseSequence","sequence","heightDepth","makeCustomSizedDelim","delimType","makeSmallDelim","sqrtImage","advanceWidth","spanHeight","texHeight","ruleWidth","sizedDelim","customSizedDelim","leftRightDelim","delimiterExtend","maxDistFromAxis","delimiterSizes","checkDelimiter","symDelim","assertParsed","leftrightDepth","expect","rightColor","leftDelim","rightDelim","innerDepth","hadMiddle","isMiddle","colorOptions","leftNode","rightNode","middleDelim","textNode","middleNode","htmlBuilder$7","imgShift","isSingleChar","lineWeight","angleHeight","ruleThickness","borderStyle","borderWidth","borderTopWidth","borderRightWidth","mathmlBuilder$6","thk","_ref5","_environments","defineEnvironment","_macros","defineMacro","getHLines","hlineInfo","nxt","consume","validateAmsEnvironmentContext","envName","getAutoTag","parseArray","hskipBeforeAndAfter","addJot","arraystretch","colSeparationType","autoTag","singleRow","emptySingleRow","maxNumCols","beginGroup","expandMacroAsText","row","rowGaps","hLinesBeforeRow","beginRow","endRow","subparse","cell","endGroup","nextToken","dCellStyle","htmlBuilder$6","nr","nc","hlines","pt","arraycolsep","baselineskip","jot","arrayskip","arstrutHeight","arstrutDepth","setHLinePos","hlinesInGap","isDashed","inrow","outrow","elt","rowGap","colSep","colDescrNum","colDescriptions","tagSpans","rw","tagSpan","colDescr","firstSeparator","lineType","borderRightStyle","_shift","sepwidth","pregap","_shift2","postgap","dashes","vListElems","hline","lineShift","eqnNumCol","alignMap","mathmlBuilder$5","tbl","glue","table","menclose","columnLines","prevTypeWasAlign","iStart","iEnd","_cols","rowLines","alignedHandler","numMaths","separationType","isSplit","numCols","emptyGroup","arg0","isAligned","styling","curMaths","nde","ca","colAlign","parsedRows","endChar","rowNodes","labelNum","inLabel","wrappedArrow","parseCD","environments","nameGroup","_args","parseArguments","endNameToken","htmlBuilder$5","mathmlBuilder$4","fontAliases","adjustStyle","originalStyle","htmlBuilder$4","nstyle","dstyle","numerm","numer","continued","hStrut","dStrut","ruleSpacing","numShift","denomShift","frac","delimSize","denomm","denom","hasBarLine","barSize","midShift","candidateClearance","mathmlBuilder$3","isDisplay","withDelims","leftOp","rightOp","replaceWith","stylArray","delimFromValue","delimString","barNode","isBlank","styl","textOrd","_ref6","assert","htmlBuilder$3","braceBody","isOver","vSpan","command","formatUnsupportedCmd","trustContext","class","keyVal","mathml","sizeData","totalheight","mathFunction","muUnit","fix","outerMode","switchMode","chooseMathStyle","scriptscript","assembleSupSub","supGroup","subGroup","baseShift","finalGroup","subIsSingleCharacter","_bottom","noSuccessor","htmlBuilder$2","hasLimits","large","stash","oval","mathmlBuilder$1","singleCharBigOps","fName","singleCharIntegrals","htmlBuilder$1","childText","sizingGroup","isAllString","semisimple","amount","dy","sizeFuncs","smashHeight","smashDepth","tbArg","letter","smashedNode","theta","phi","lineClearance","minDelimiterHeight","delimDepth","rootm","toShift","rootVList","rootVListWrap","styleMap","newStyle","builderDelegate","htmlBuilderDelegate","supm","subm","minSupShift","valueBase","valueSup","valueSub","supShift","subShift","_newOptions","isOiint","maxWidth","psi","vlistElem","_vlistElem","isBrace","_base2","_base","defaultVariant","cssSpace","regularSpace","ord","padNode","textFontFamilies","textFontWeights","textFontShapes","optionsWithFont","makeVerb","star","functions","spaceRegexString","controlWordWhitespaceRegexString","combiningDiacriticalMarkString","combiningDiacriticalMarksEndRegex","tokenRegexString","Lexer","tokenRegex","catcodes","setCatcode","lex","nlIndex","Namespace","builtins","globalMacros","undefStack","undefs","undef","endGroups","expandOnce","consumeArgs","digitToNumber","digit","newcommand","existsOK","nonexistsOK","skipIfExists","exists","isDefined","argText","expandNextToken","dotsByToken","thedots","expandAfterFuture","spaceAfterDots","latexRaiseA","braketHelper","middleDouble","oldMiddle","oldMiddleDouble","midMacro","double","doubled","expanded","implicitCommands","MacroExpander","expansionCount","feed","newMode","pushTokens","scanArgument","isOptional","delims","isDelimited","countExpansion","expandableOnly","topToken","expansion","_getExpansion","expandMacro","oldStackLength","definition","catcode","stripped","bodyLexer","unicodeSubRegEx","uSubsAndSups","unicodeAccents","unicodeSymbols","Parser","oldToken","breakOnInfix","endOfExpression","parseAtom","formLigatures","handleInfixNodes","overIndex","numerNode","denomNode","numerBody","denomBody","handleSupSubscript","symbolToken","parseGroup","textordArray","superscript","subscript","prime","primes","subsupTokens","funcData","totalArgs","argType","parseGroupOfType","optional","parseColorGroup","parseUrlGroup","parseArgumentGroup","parseStringGroup","modeName","argToken","parseRegexGroup","regex","firstToken","lastToken","groupEnd","parseSymbol","nucleus","parseTree","toParse","baseNode","renderToDomTree","compatMode","renderError","katexNode","mathMLNode","_htmlNode","buildTree","katex","renderToString","__parse","__renderToDomTree","__renderToHTMLTree","buildHTMLTree","__setFontMetrics","__defineSymbol","__defineFunction","__defineMacro","__domTree","HTML_NODE","TXT_NODE","replaceChildWithChildren","oldChild","lastNewChild","tokensToNodes","isLink","check","linkifyElementHelper","ignoreTags","childElement","nodeValue","tokenize","nextSibling","getDefaultRender","eventListeners","linkifyElement","helper","linkifyReactElement","elementId","rendered","stringToElements","newProps","Linkify","linkId","defaultRender","attributesToString","linkifyStr","linkify","encodedTlds","encodedUtlds","properties","ascii","alpha","asciinumeric","alphanumeric","domain","scheme","slashscheme","whitespace","registerGroup","addToGroups","State","jr","jd","accepts","go","nextState","exactOnly","ta","inputs","tt","tr","ts","templateState","allFlags","flagsForToken","WORD","UWORD","ASCIINUMERICAL","ALPHANUMERICAL","LOCALHOST","TLD","UTLD","SCHEME","SLASH_SCHEME","NUM","WS","NL","OPENBRACE","CLOSEBRACE","OPENBRACKET","CLOSEBRACKET","OPENPAREN","CLOSEPAREN","OPENANGLEBRACKET","CLOSEANGLEBRACKET","FULLWIDTHLEFTPAREN","FULLWIDTHRIGHTPAREN","LEFTCORNERBRACKET","RIGHTCORNERBRACKET","LEFTWHITECORNERBRACKET","RIGHTWHITECORNERBRACKET","FULLWIDTHLESSTHAN","FULLWIDTHGREATERTHAN","AMPERSAND","APOSTROPHE","ASTERISK","AT","BACKSLASH","BACKTICK","COLON","COMMA","DOLLAR","DOT","EQUALS","EXCLAMATION","HYPHEN","PERCENT","PIPE","PLUS","POUND","QUERY","QUOTE","FULLWIDTHMIDDLEDOT","SEMI","SLASH","UNDERSCORE","EMOJI$1","SYM","tk","ASCII_LETTER","LETTER","DIGIT","EMOJI_VARIATION","CR","LF","EMOJI_JOINER","OBJECT_REPLACEMENT","tlds","utlds","run$1","iterable","stringToArray","charCount","cursor","charCursor","tokenLength","latestAccepting","sinceAccepts","charsSinceAccepts","fastts","defaultt","decodeTlds","encoded","words","popDigitCount","popCount","defaultProtocol","formatHref","nl2br","validate","ignoredTags","uppercaseIgnoredTags","ir","option","getObj","MultiToken","createTokenClass","toHref","toFormattedString","toFormattedHref","toObject","toFormattedObject","formattedHref","Email","Nl","Url","hasProtocol","multi","Base","makeState","initMultiToken","Multi","startIdx","endIdx","warnAdvice","INIT","scanner","tokenQueue","pluginQueue","customSchemes","initialized","registerTokenPlugin","registerPlugin","registerCustomProtocol","optionalSlashSlash","Start","Num","Asciinumeric","Alphanumeric","Word","UWord","Cr","Ws","Emoji","EmojiJoiner","wordjr","uwordjr","tld","utld","sch","init$2","qsAccepting","qsNonAccepting","localpartAccepting","Localpart","Domain","Scheme","SlashScheme","LocalpartAt","LocalpartDot","EmailDomain","EmailDomainDot","Email$1","EmailDomainHyphen","EmailColon","DomainHyphen","DomainDot","DomainDotTld","DomainDotTldColon","DomainDotTldColonPort","Url$1","UrlNonaccept","SchemeColon","SlashSchemeColon","SlashSchemeColonSlash","UriPrefix","bracketPairs","OPEN","CLOSE","UrlOpen","UrlOpenQ","UrlOpenSyms","init$1","multis","textTokens","secondState","multiLength","subtokens","run","scan","FUNC_ERROR_TEXT","HASH_UNDEFINED","PLACEHOLDER","WRAP_CURRY_RIGHT_FLAG","WRAP_PARTIAL_FLAG","WRAP_PARTIAL_RIGHT_FLAG","WRAP_ARY_FLAG","WRAP_REARG_FLAG","INFINITY","NAN","MAX_ARRAY_LENGTH","wrapFlags","argsTag","arrayTag","boolTag","dateTag","errorTag","funcTag","genTag","mapTag","numberTag","objectTag","promiseTag","regexpTag","stringTag","symbolTag","weakMapTag","arrayBufferTag","dataViewTag","float32Tag","float64Tag","int8Tag","int16Tag","int32Tag","uint8Tag","uint8ClampedTag","uint16Tag","uint32Tag","reEmptyStringLeading","reEmptyStringMiddle","reEmptyStringTrailing","reEscapedHtml","reUnescapedHtml","reHasEscapedHtml","reHasUnescapedHtml","reEscape","reEvaluate","reInterpolate","reIsDeepProp","reIsPlainProp","reRegExpChar","reHasRegExpChar","reTrimStart","reWhitespace","reWrapComment","reWrapDetails","reSplitDetails","reAsciiWord","reForbiddenIdentifierChars","reEsTemplate","reFlags","reIsBadHex","reIsBinary","reIsHostCtor","reIsOctal","reIsUint","reLatin","reNoMatch","reUnescapedString","rsAstralRange","rsComboRange","rsComboMarksRange","rsDingbatRange","rsLowerRange","rsUpperRange","rsVarRange","rsBreakRange","rsMathOpRange","rsApos","rsAstral","rsBreak","rsCombo","rsDigits","rsDingbat","rsLower","rsMisc","rsFitz","rsNonAstral","rsRegional","rsSurrPair","rsUpper","rsZWJ","rsMiscLower","rsMiscUpper","rsOptContrLower","rsOptContrUpper","reOptMod","rsOptVar","rsSeq","rsEmoji","rsSymbol","reApos","reComboMark","reUnicode","reUnicodeWord","reHasUnicode","reHasUnicodeWord","contextProps","templateCounter","typedArrayTags","cloneableTags","stringEscapes","freeParseFloat","freeParseInt","freeGlobal","freeSelf","freeExports","freeModule","moduleExports","freeProcess","nodeUtil","types","binding","nodeIsArrayBuffer","isArrayBuffer","nodeIsDate","nodeIsMap","isMap","nodeIsRegExp","nodeIsSet","isSet","nodeIsTypedArray","isTypedArray","arrayAggregator","setter","iteratee","accumulator","arrayEach","arrayEachRight","arrayEvery","arrayFilter","resIndex","arrayIncludes","baseIndexOf","arrayIncludesWith","arrayMap","arrayPush","arrayReduce","initAccum","arrayReduceRight","arraySome","asciiSize","baseProperty","baseFindKey","collection","eachFunc","baseFindIndex","fromIndex","fromRight","strictIndexOf","baseIsNaN","baseIndexOfWith","baseMean","baseSum","basePropertyOf","baseReduce","baseTimes","baseTrim","trimmedEndIndex","baseUnary","baseValues","cacheHas","charsStartIndex","strSymbols","chrSymbols","charsEndIndex","deburrLetter","escapeHtmlChar","escapeStringChar","chr","hasUnicode","mapToArray","overArg","replaceHolders","placeholder","setToArray","setToPairs","stringSize","unicodeSize","unicodeToArray","asciiToArray","unescapeHtmlChar","runInContext","uid","pick","arrayProto","funcProto","objectProto","coreJsData","funcToString","maskSrcKey","IE_PROTO","nativeObjectToString","objectCtorString","oldDash","reIsNative","Buffer","allocUnsafe","getPrototype","objectCreate","spreadableSymbol","isConcatSpreadable","symIterator","symToStringTag","getNative","ctxClearTimeout","ctxNow","ctxSetTimeout","nativeCeil","nativeFloor","nativeGetSymbols","nativeIsBuffer","isBuffer","nativeIsFinite","nativeJoin","nativeKeys","nativeMax","nativeMin","nativeNow","nativeParseInt","nativeRandom","nativeReverse","nativeCreate","metaMap","realNames","dataViewCtorString","toSource","mapCtorString","promiseCtorString","setCtorString","weakMapCtorString","symbolProto","symbolValueOf","symbolToString","lodash","isObjectLike","LazyWrapper","LodashWrapper","wrapperClone","baseCreate","baseLodash","chainAll","__wrapped__","__actions__","__chain__","__index__","__values__","__dir__","__filtered__","__iteratees__","__takeCount__","__views__","Hash","ListCache","MapCache","SetCache","__data__","Stack","arrayLikeKeys","inherited","isArr","isArg","isArguments","isBuff","isType","skipIndexes","isIndex","arraySample","baseRandom","arraySampleSize","shuffleSelf","copyArray","baseClamp","arrayShuffle","assignMergeValue","baseAssignValue","assignValue","objValue","assocIndexOf","baseAggregator","baseEach","baseAssign","baseAt","upper","baseClone","bitmask","customizer","isDeep","isFlat","isFull","initCloneArray","getTag","isFunc","cloneBuffer","initCloneObject","getSymbolsIn","copySymbolsIn","keysIn","baseAssignIn","getSymbols","copySymbols","Ctor","cloneArrayBuffer","dataView","byteOffset","byteLength","cloneDataView","cloneTypedArray","cloneRegExp","initCloneByTag","stacked","subValue","getAllKeysIn","getAllKeys","baseConformsTo","baseDelay","wait","baseDifference","isCommon","valuesLength","outer","computed","valuesIndex","templateSettings","getMapData","pairs","LARGE_ARRAY_SIZE","createBaseEach","baseForOwn","baseEachRight","baseForOwnRight","baseEvery","baseExtremum","baseFilter","baseFlatten","isFlattenable","baseFor","createBaseFor","baseForRight","baseFunctions","baseGet","castPath","toKey","baseGetAllKeys","keysFunc","symbolsFunc","baseGetTag","unmasked","getRawTag","baseGt","baseHas","baseHasIn","baseIntersection","arrays","othLength","othIndex","caches","seen","baseInvoke","baseIsArguments","baseIsEqual","equalFunc","objIsArr","othIsArr","objTag","othTag","objIsObj","othIsObj","isSameTag","equalArrays","convert","isPartial","equalByTag","objIsWrapped","othIsWrapped","objUnwrapped","othUnwrapped","objProps","objLength","othProps","objStacked","othStacked","skipCtor","othValue","compared","objCtor","othCtor","equalObjects","baseIsEqualDeep","baseIsMatch","matchData","noCustomizer","srcValue","COMPARE_PARTIAL_FLAG","baseIsNative","baseIteratee","identity","baseMatchesProperty","baseMatches","baseKeys","isPrototype","baseKeysIn","nativeKeysIn","isProto","baseLt","baseMap","isArrayLike","getMatchData","matchesStrictComparable","isKey","isStrictComparable","hasIn","baseMerge","srcIndex","mergeFunc","safeGet","isTyped","isArrayLikeObject","toPlainObject","baseMergeDeep","baseNth","baseOrderBy","iteratees","orders","getIteratee","criteria","comparer","baseSortBy","objCriteria","othCriteria","ordersLength","compareAscending","compareMultiple","basePickBy","baseSet","basePullAll","basePullAt","indexes","baseUnset","baseRepeat","baseRest","setToString","overRest","baseSample","baseSampleSize","baseSetData","baseSetToString","constant","baseShuffle","baseSlice","baseSome","baseSortedIndex","retHighest","baseSortedIndexBy","valIsNaN","valIsNull","valIsSymbol","valIsUndefined","othIsDefined","othIsNull","othIsReflexive","othIsSymbol","setLow","baseSortedUniq","baseToNumber","baseToString","baseUniq","createSet","seenIndex","baseUpdate","updater","baseWhile","isDrop","baseWrapperValue","actions","baseXor","baseZipObject","assignFunc","valsLength","castArrayLikeObject","castFunction","castRest","castSlice","arrayBuffer","valIsDefined","valIsReflexive","composeArgs","partials","holders","isCurried","argsIndex","argsLength","holdersLength","leftIndex","leftLength","rangeLength","isUncurried","composeArgsRight","holdersIndex","rightIndex","rightLength","isNew","createAggregator","initializer","createAssigner","assigner","sources","guard","isIterateeCall","createCaseFirst","methodName","trailing","createCompounder","deburr","createCtor","thisBinding","createFind","findIndexFunc","createFlow","flatRest","funcs","prereq","thru","getFuncName","getData","isLaziable","plant","createHybrid","partialsRight","holdersRight","argPos","ary","arity","isAry","isBind","isBindKey","isFlip","getHolder","holdersCount","countHolders","newHolders","createRecurry","arrLength","oldArray","reorder","createInverter","toIteratee","baseInverter","createMathOperation","createOver","arrayFunc","createPadding","charsLength","createRange","step","toFinite","baseRange","createRelationalOperation","toNumber","wrapFunc","isCurry","setWrapToString","createRound","toInteger","pair","createToPairs","baseToPairs","createWrap","srcBitmask","newBitmask","isCombo","createCurry","createPartial","createBind","customDefaultsAssignIn","customDefaultsMerge","customOmitClone","arrStacked","arrValue","otherFunc","getValue","stubArray","hasPath","hasFunc","isLength","ctorString","isMaskable","stubFalse","otherArgs","shortOut","details","insertWrapDetails","updateWrapDetails","getWrapDetails","lastCalled","stamp","remaining","rand","memoizeCapped","difference","differenceBy","differenceWith","findLastIndex","intersection","mapped","intersectionBy","intersectionWith","pull","pullAll","pullAt","union","unionBy","unionWith","unzip","unzipWith","without","xor","xorBy","xorWith","zip","zipWith","chain","interceptor","wrapperAt","countBy","findLast","forEachRight","groupBy","invokeMap","keyBy","partition","sortBy","before","bindKey","WRAP_BIND_FLAG","debounce","lastArgs","lastThis","maxWait","lastCallTime","lastInvokeTime","leading","maxing","invokeFunc","shouldInvoke","timeSinceLastCall","timerExpired","trailingEdge","timeWaiting","remainingWait","debounced","isInvoking","leadingEdge","cancel","defer","memoized","Cache","negate","overArgs","transforms","funcsLength","partial","partialRight","rearg","isInteger","isNumber","iteratorToArray","remainder","toLength","isBinary","assignIn","assignInWith","assignWith","at","propsIndex","propsLength","defaultsDeep","mergeWith","invert","invertBy","invoke","omit","CLONE_DEEP_FLAG","basePick","pickBy","toPairs","toPairsIn","camelCase","capitalize","upperFirst","kebabCase","lowerCase","lowerFirst","snakeCase","startCase","upperCase","hasUnicodeWord","unicodeWords","asciiWords","attempt","bindAll","methodNames","flow","flowRight","methodOf","mixin","over","overEvery","overSome","basePropertyDeep","rangeRight","augend","addend","divide","dividend","divisor","multiply","multiplicand","subtract","minuend","subtrahend","after","castArray","chunk","compact","cond","conforms","baseConforms","curry","curryRight","drop","dropRight","dropRightWhile","dropWhile","baseFill","flatMapDeep","flatMapDepth","flattenDeep","flattenDepth","fromPairs","functionsIn","mapKeys","mapValues","matchesProperty","nthArg","omitBy","orderBy","propertyOf","pullAllBy","pullAllWith","sampleSize","setWith","shuffle","sortedUniq","sortedUniqBy","spread","tail","take","takeRight","takeRightWhile","takeWhile","tap","throttle","toPath","isArrLike","unary","uniqBy","uniqWith","updateWith","valuesIn","zipObject","zipObjectDeep","entriesIn","extendWith","cloneDeep","cloneDeepWith","cloneWith","conformsTo","defaultTo","endsWith","escapeRegExp","findKey","findLastKey","forIn","forInRight","forOwn","forOwnRight","inRange","baseInRange","isBoolean","isEmpty","isEqualWith","isMatch","isMatchWith","isNative","isNil","isNull","isSafeInteger","isUndefined","isWeakMap","isWeakSet","strictLastIndexOf","maxBy","mean","meanBy","minBy","stubObject","stubString","stubTrue","nth","noConflict","strLength","padStart","radix","temp","reduceRight","sample","sortedIndex","sortedIndexBy","sortedIndexOf","sortedLastIndex","sortedLastIndexBy","sortedLastIndexOf","sumBy","template","isEscaping","isEvaluating","imports","importsKeys","importsValues","reDelimiters","evaluate","sourceURL","escapeValue","interpolateValue","esTemplateValue","evaluateValue","variable","times","toLower","toSafeInteger","toUpper","trimEnd","trimStart","omission","newEnd","each","eachRight","VERSION","isFilter","takeName","dropName","checkIteratee","isTaker","lodashFunc","retUnwrapped","isLazy","useLazy","isHybrid","isUnwrapped","onlyLazy","chainName","isRight","view","getView","iterLength","takeCount","iterIndex","commit","$isNaN","encryptAttachment","plaintextBuffer","ivArray","subarray","subtle","generateKey","cryptoKey","exportKey","exportedKey","encrypt","ciphertextBuffer","digest","sha256Buffer","iv","encodeBase64","hashes","sha256","decryptAttachment","decodeBase64","expectedSha256base64","importKey","digestResult","counterLength","decrypt","uint8Array","latin1String","paddedBase64","btoa","inputLength","outputLength","base64","ExtensibleEvents","_NamespacedMap","_InvalidEventError","_MRoomMessage","_MMessage","_message_types","_poll_types","_MPoll","_createForOfIteratorHelper","allowArrayLike","it","minLen","_arrayLikeToArray","_unsupportedIterableToArray","normalCompletion","didErr","_e2","arr2","_defineProperty","Constructor","_classCallCheck","NamespacedMap","LEGACY_M_ROOM_MESSAGE","parseMRoomMessage","M_MESSAGE","parseMMessage","M_EMOTE","M_NOTICE","M_POLL_START","parseMPoll","M_POLL_RESPONSE","M_POLL_END","protoProps","staticProps","_defaultInstance","defaultInstance","unknownInterpretOrder","wireEventType","interpreter","registerInterpreter","wireFormat","_this$_unknownInterpr","_unknownInterpretOrder","interpreters","hasNamespaced","getNamespaced","_step","_iterator","tryType","InvalidEventError","_assertThisInitialized","_possibleConstructorReturn","_wrapNativeSuper","Class","_cache","Wrapper","_construct","Parent","_Error","subClass","superClass","_inherits","internalMap","altName","_createClass","UnstableValue","NamespacedValue","unstable","included","_NamespacedValue","EmoteEvent","_MessageEvent2","_get","_superPropBase","_MessageEvent","_content","M_TEXT","M_HTML","primaryEventType","isEventTypeSame","MessageEvent","ExtensibleEvent","_ExtensibleEvent2","_types","enumerableOnly","getOwnPropertyDescriptors","defineProperties","_ExtensibleEvent","mmessage","findIn","wireContent","mtext","mhtml","isProvided","mimetype","renderings","isOptionalAString","messageRendering","mime","_this$html","serializeMMessageOnly","msgtype","formatted_body","NoticeEvent","PollEndEvent","_relationship_types","REFERENCE_RELATION","rel_type","pollEventId","closingMessage","serialize","PollResponseEvent","validateAgainst","answers","internalAnswerIds","internalSpoiled","poll","pa","maxSelections","spoiled","answerIds","PollStartEvent","PollAnswerSubevent","_toConsumableArray","_arrayWithoutHoles","iter","_iterableToArray","_nonIterableSpread","_super2","_this2","question","rawKind","M_POLL_KIND_DISCLOSED","M_POLL_KIND_UNDISCLOSED","max_selections","_content2","_content3","LETTERS","_ExtensibleEvents","_IPartialEvent","_MessageMatchers","_EmoteEvent","_NoticeEvent","_PollStartEvent","_PollResponseEvent","_PollEndEvent","wireEvent","_wireEvent$content","_wireEvent$content2","_wireEvent$content3","_objectSpread2","_objectSpread3","_objectSpread4","LegacyMsgType","isEventLike","Emote","Notice","given","expected","expectedNs","givenNs","PushRuleActionName","TweakName","ConditionOperator","DMMemberCountCondition","isDmMemberCountCondition","condition","ConditionKind","PushRuleKind","RuleId","M_BEACON_INFO","M_BEACON","EventType","RelationType","MsgType","RoomCreateTypeField","RoomType","ToDeviceMessageId","UNSTABLE_MSC3088_PURPOSE","UNSTABLE_MSC3088_ENABLED","UNSTABLE_MSC3089_TREE_SUBTYPE","UNSTABLE_MSC3089_LEAF","UNSTABLE_MSC3089_BRANCH","UNSTABLE_MSC2716_MARKER","MSC3912_RELATION_BASED_REDACTIONS_PROP","UNSTABLE_ELEMENT_FUNCTIONAL_USERS","EVENT_VISIBILITY_CHANGE_TYPE","PUSHER_ENABLED","PUSHER_DEVICE_ID","LOCAL_NOTIFICATION_SETTINGS_PREFIX","UNSIGNED_THREAD_ID_FIELD","UNSIGNED_MEMBERSHIP_FIELD","KnownMembership","Visibility","Preset","JoinRule","RestrictedAllowType","GuestAccess","HistoryVisibility","UpdateDelayedEventAction","SearchOrderBy","UNREAD_THREAD_NOTIFICATIONS","ServerControlledNamespacedValue","M_TOPIC","ReEmitter","reEmit","reEmittersByEvent","reEmitters","forSource","stopReEmitting","TypedReEmitter","AutoDiscoveryAction","AutoDiscoveryError","AutoDiscovery","fromDiscoveryConfig","wellknown","_hsVersions$raw","clientConfig","FAIL_ERROR","ERROR_INVALID","base_url","PROMPT","FAIL_PROMPT","ERROR_INVALID_HS_BASE_URL","hsUrl","sanitizeWellKnownUrl","hsVersions","fetchWellKnownObject","ERROR_INVALID_HOMESERVER","hsVersionSet","supportedVersionFound","SUPPORTED_MATRIX_VERSIONS","ERROR_UNSUPPORTED_HOMESERVER_SPEC_VERSION","SUCCESS","isUrl","failingClientConfig","ERROR_INVALID_IS","ERROR_INVALID_IS_BASE_URL","isResponse","ERROR_INVALID_IDENTITY_SERVER","notProps","findClientConfig","domainWithProtocol","IGNORE","getRawClientConfig","_response$raw","_parsed","URL","hostname","pathname","saferUrl","fetchFn","setFetchFn","Method","Get","signal","timeoutSignal","ERROR_MISSING_WELLKNOWN","ok","json","ERROR_INVALID_JSON","Invalid","GenericFailure","InvalidHsBaseUrl","InvalidHomeserver","InvalidIsBaseUrl","InvalidIdentityServer","InvalidIs","MissingWellknown","InvalidJson","UnsupportedHomeserverSpecVersion","toBase64","omitPadding","alphabet","encodeUnpaddedBase64","encodeUnpaddedBase64Url","fromBase64","lastChunkHandling","StubStore","isNewlyCreated","getSyncToken","fromToken","setSyncToken","storeRoom","room","getRoom","roomId","getRooms","removeRoom","getRoomSummaries","storeUser","userId","getUsers","scrollback","setUserCreator","storeEvents","toStart","storeFilter","getFilter","filterId","getFilterIdByName","filterName","setFilterIdByName","storeAccountDataEvents","getAccountData","setSyncData","syncData","wantsSave","save","startup","getSavedSync","getSavedSyncToken","deleteAllData","getOutOfBandMembers","setOutOfBandMembers","membershipEvents","clearOutOfBandMembers","getClientOptions","storeClientOptions","getPendingEvents","setPendingEvents","saveToDeviceBatches","batch","getOldestToDeviceBatch","removeToDeviceBatch","destroy","MSC3089Branch","indexEvent","directory","stateKey","getStateKey","isActive","getContent","_this$indexEvent$getC","getRoomId","sendStateEvent","redactEvent","nextVersion","getVersionHistory","getName","setName","isLocked","setLocked","locked","getFileInfo","file","getFileEvent","getOriginalContent","httpUrl","mxcUrlToHttp","getUnfilteredTimelineSet","findEventById","getLiveTimeline","EventTimeline","BACKWARDS","paginationToken","decryptEventIfNeeded","createNewVersion","encryptedContents","additionalContent","fileEventResponse","createFile","Replace","fileHistory","timelineEvents","getEvents","childEvent","parentEvent","replacingEventId","getId","getFile","DEFAULT_TREE_POWER_LEVELS_TEMPLATE","invite","kick","ban","redact","state_default","events_default","users_default","RoomPowerLevels","RoomHistoryVisibility","RoomTombstone","RoomEncryption","RoomName","RoomMessage","RoomMessageEncrypted","Sticker","users","TreePermissions","MSC3089TreeSpace","isTopLevel","parentEvents","currentState","getStateEvents","SpaceParent","_e$getContent","andSubspaces","promises","retryInvite","getDirectories","simpleRetryOperation","catch","errcode","promiseRetry","setPermissions","_pls$events","currentPls","pls","viewLevel","editLevel","adminLevel","Viewer","Editor","Owner","getPermissions","_pls$events2","_pls$users","userLevel","createDirectory","unstableCreateFileTree","SpaceChild","via","getDomain","trees","unstableGetFileTreeSpace","getDirectory","subdirectories","kickMemberships","Invite","Knock","Join","members","RoomMember","member","getUserId","membership","leave","getOrderedChildren","ordered","lexicographicCompare","_roomA$currentState$g","_roomA$currentState$g2","_roomB$currentState$g","_roomB$currentState$g2","roomA","roomB","createTsA","RoomCreate","getTs","createTsB","getParentRoom","parentRoom","getOrder","setOrder","_currentChild$getCont2","movingUp","newOrder","DEFAULT_ALPHABET","ensureBeforeIsSane","nextString","startOrder","endOrder","averageBetweenStrings","prevString","lastOrder","_currentChild$getCont","currentChild","content_uri","mxc","uploadContent","includeFilename","fileContent","File","sendMessage","fileEventId","listFiles","listAllFiles","_this$room$currentSta","ToDeviceMessageQueue","retryTimeout","sending","running","headBatch","store","sendBatch","retryAttempts","retryDelay","MatrixScheduler","RETRY_BACKOFF_RATELIMIT","httpStatus","sendQueue","oldState","SyncState","Syncing","ClientEvent","Sync","onResumedSync","stop","queueBatch","batches","batchWithTxnId","txnId","makeTxnId","msgmap","deviceId","contentMap","MapWithDefault","getOrCreate","sendToDevice","RUST_SDK_STORE_PREFIX","getRelationsThreadFilter","threadId","_e$content","_e$content2","THREAD_RELATION_TYPE","TURN_CHECK_INTERVAL","UNSTABLE_MSC3852_LAST_SEEN_UA","PendingEventOrdering","GET_LOGIN_TOKEN_CAPABILITY","UNSTABLE_MSC2666_SHARED_ROOMS","UNSTABLE_MSC2666_MUTUAL_ROOMS","UNSTABLE_MSC2666_QUERY_MUTUAL_ROOMS","UNSTABLE_MSC4140_DELAYED_EVENTS","UNSTABLE_MSC4133_EXTENDED_PROFILES","EVENT_ID_PREFIX","SSO_ACTION_PARAM","MatrixClient","TypedEventEmitter","_opts$logger","_opts$usingExternalCr","_opts$cryptoCallbacks","PushProcessor","MediaHandler","isInitialSyncComplete","supportsMatrixCall","callEventHandler","groupCallEventHandler","startCallEventHandler","matrixRTC","startMatrixRTC","_this$getRooms","unreadRooms","getUnreadNotificationCount","NotificationCountType","Total","currentUserId","getSafeUserId","fixupNotifications","fixupRoomNotifications","baseUrl","idBaseUrl","identityServer","usingExternalCrypto","sessionId","secureRandomString","http","MatrixHttpApi","accessToken","refreshToken","tokenRefreshFunction","ClientPrefix","V3","onlyData","extraParams","queryParams","localTimeoutMs","useAuthorizationHeader","pickleKey","legacyPickleKey","useLivekitForGroupCalls","scheduler","setProcessFunction","eventToSend","EventStatus","SENDING","updatePendingEventStatus","sendEventHttpRequest","updatePendingEvent","SENT","CallEventHandler","GroupCallEventHandler","canSupportVoip","MatrixRTCSessionManager","serverCapabilitiesService","ServerCapabilities","timelineSupport","legacyCryptoStore","cryptoStore","verificationMethods","cryptoCallbacks","forceTURN","iceCandidatePoolSize","supportsCallTransfer","fallbackICEServerAllowed","isVoipWithNoMediaAllowed","useE2eForGroupCall","livekitServiceURL","roomNameGenerator","toDeviceMessageQueue","MatrixEventEvent","Decrypted","fixNotificationCountOnDecryption","ignoredInvites","IgnoredInvites","_secretStorage","ServerSideSecretStorageImpl","newStore","_store","User","createUser","startClient","clientRunning","checkTurnServersIntervalID","checkTurnServers","syncApi","getVersions","threads","fwdPagination","doesServerSupportThread","Thread","setServerSideSupport","setServerSideListSupport","setServerSideFwdPaginationSupport","clientOpts","slidingSync","SlidingSyncSdk","buildSyncApiOptions","SyncApi","clientWellKnownPollPeriod","clientWellKnownIntervalID","fetchClientWellKnown","cryptoBackend","canResetEntireTimeline","canResetTimelineCallback","stopClient","_this$cryptoBackend","_this$syncApi","_this$peekSync","_this$callEventHandle","_this$groupCallEventH","peekSync","stopPeeking","clearInterval","clearStores","indexedDB","dbname","prom","req","deleteDatabase","onsuccess","onblocked","deleteRustSdkStore","_this$credentials$use","_this$credentials","_this$credentials2","getUserIdLocalpart","_this$credentials$use2","_this$credentials3","getDeviceId","getSessionId","supportsVoip","getMediaHandler","mediaHandler","setForceTURN","setSupportsCallTransfer","support","getUseE2eForGroupCall","createCall","createNewMatrixCall","createGroupCall","isPtt","dataChannelsEnabled","dataChannelOptions","getGroupCallForRoom","GroupCall","getLivekitServiceURL","setLivekitServiceURL","newURL","waitUntilRoomReadyForGroupCalls","groupCalls","getSyncState","_this$syncApi$getSync","_this$syncApi2","getSyncStateData","Prepared","isGuest","isGuestAccount","setGuest","guest","getScheduler","retryImmediately","_this$syncApi$retryIm","_this$syncApi3","getNotifTimelineSet","notifTimelineSet","setNotifTimelineSet","getCapabilities","caps","getCachedCapabilities","fetchCapabilities","initRustCrypto","_this$legacyPickleKey","RustCrypto","rustCrypto","secretStorage","storePrefix","useIndexedDB","storeKey","storageKey","storePassphrase","storagePassword","legacyMigrationProgressListener","progress","total","CryptoEvent","LegacyCryptoStoreMigrationProgress","setSupportedVerificationMethods","RoomMemberEvent","Membership","onRoomMembership","onLiveEventFromSync","reEmitter","VerificationRequestReceived","UserTrustStatusChanged","KeyBackupStatus","KeyBackupSessionsRemaining","KeyBackupFailed","KeyBackupDecryptionKeyCached","KeysChanged","DevicesUpdated","WillUpdateDevices","DehydratedDeviceCreated","DehydratedDeviceUploaded","RehydrationStarted","RehydrationProgress","RehydrationCompleted","RehydrationError","DehydrationKeyCached","DehydratedDeviceRotationError","isRoomEncrypted","hasEncryptionStateEvent","isKeyBackupKeyStored","isStored","makeKeyBackupPath","$roomId","$sessionId","queryData","deleteKeysFromBackup","authedRequest","Delete","getMediaConfig","MediaPrefix","getVisibleRooms","msc3946ProcessDynamicPredecessor","allRooms","replacedRooms","_r$findPredecessor","predecessor","findPredecessor","setAccountData","retryNetworkOperation","setAccountDataRaw","existingData","deepCompare","updatedDefer","accountDataListener","getType","AccountData","$userId","$type","Put","getAccountDataFromServer","_data","deleteAccountData","msc3391DeleteAccountDataServerSupport","canSupport","Feature","AccountDataDeletion","ServerSupport","Unsupported","Unstable","getIgnoredUsers","IgnoredUserList","setIgnoredUsers","userIds","ignored_users","isUserIgnored","joinRoom","roomIdOrAlias","syncRoom","hasMembershipState","signPromise","inviteSignUrl","searchParams","requestOtherUrl","Post","viaServers","server_name","signedInviteObj","third_party_signed","$roomid","room_id","resolvedRoom","createRoom","knockRoom","$roomIdOrAlias","resendEvent","encryptAndSendEvent","cancelPendingEvent","QUEUED","NOT_SENT","ENCRYPTING","eventsBeingEncrypted","removeEventFromQueue","CANCELLED","setRoomName","setRoomTopic","topic","htmlTopic","ContentHelpers","RoomTopic","getRoomTags","setRoomTag","$tag","deleteRoomTag","setRoomAccountData","setPowerLevel","powerLevel","_this$getRoom","getStateEvent","MatrixError","unstable_createLiveBeacon","beaconInfoContent","unstable_setLiveBeacon","threadIdOrEventType","eventTypeOrContent","contentOrTxnId","txnIdOrVoid","addThreadRelationIfNeeded","sendCompleteEvent","_content$mRelates_to","_content$mRelates_to2","_this$getRoom2","isReply","is_falling_back","thread","getThread","_thread$lastReply$get","_thread$lastReply","lastReply","ev","isRelation","eventObject","delayOptsOrTxnId","delayOpts","localEvent","MatrixEvent","user_id","sender","origin_server_ts","setThread","Replaced","VisibilityChange","BeforeRedaction","targetId","getAssociatedId","LocalEventIdReplaced","updateAssociatedId","setTxnId","setStatus","addPendingEvent","cancelled","encryptEventIfNeeded","queueEvent","getQueueForEvent","shouldEncryptEventForRoom","encryptEvent","_this$cryptoBackend2","isEncrypted","Reaction","isRedaction","isEncryptionEnabledInRoom","getEncryptedIfNeededEventType","_this$getRoom3","newStatus","getTxnId","pathParams","$eventType","getWireType","$stateKey","$txnId","isState","pathTemplate","redacts","$redactsEventId","getWireContent","getUnstableDelayQueryOpts","_eventId","_opts","_opts2","with_rel_types","RelationBasedRedactions","Stable","RoomRedaction","sendContent","sendTextMessage","_threadId","sendNotice","_threadId2","sendEmoteMessage","_threadId3","sendImageMessage","_threadId4","Image","sendStickerMessage","_threadId5","sendHtmlMessage","htmlBody","_threadId6","sendHtmlNotice","_threadId7","sendHtmlEmote","_threadId8","_unstable_sendDelayedEvent","doesServerSupportUnstableFeature","UnsupportedDelayedEventsEndpointError","_unstable_sendDelayedStateEvent","_unstable_getDelayedEvents","queryDict","_unstable_updateDelayedEvent","delayId","$delayId","sendReceipt","receiptType","unthreaded","$receiptType","$eventId","fullBody","supportsThreads","thread_id","threadIdForReceipt","addLocalEchoReceipt","sendReadReceipt","ReceiptType","Read","hasPendingEvent","setRoomReadMarkers","rmEventId","rrEvent","rpEvent","rrEventId","rpEventId","ReadPrivate","setRoomReadMarkersHttpRequest","getUrlPreview","urlPreviewCache","resp","priority","sendTyping","isTyping","typing","getRoomUpgradeHistory","verifyLinks","currentRoom","findPredecessorRooms","findSuccessorRooms","_room$findPredecessor","seenRoomIDs","predecessorRoomId","_room$findPredecessor2","predecessorRoom","tombstone","tombstoneEvent","successorRoom","_successorRoom$findPr","membershipChange","inviteByEmail","inviteByThreePid","address","_this$identityServer","identityServerUrl","getIdentityServerUrl","id_server","getAccessToken","identityAccessToken","Leave","leaveRoomChain","includeFuture","upgradeHistory","eligibleToLeave","populationResults","doLeave","Ban","forget","deleteRoom","$room_id","DeleteRoom","unban","$membership","getPushActionsForEvent","forceRecalculate","getPushActions","pushProcessor","actionsAndRuleForEvent","setPushDetails","getPushDetailsForEvent","getPushDetails","setProfileInfo","$info","setDisplayName","displayname","UserEvent","DisplayName","setAvatarUrl","avatar_url","avatarUrl","AvatarUrl","mxcUrl","resizeMethod","allowDirectLinks","allowRedirects","useAuthentication","getHttpUriForMxc","setSyncPresence","_this$syncApi4","setPresence","getPresence","timeToWaitMs","ongoingScrollbacks","errorTs","timeWaitedMs","sleep","createMessagesRequest","Direction","Backward","_res$end","_res$end2","matrixEvents","getEventMapper","stateEvents","setUnknownStateEvents","threadedEvents","unknownRelations","partitionThreadedEvents","processAggregatedTimelineEvents","addEventsToTimeline","processThreadEvents","relations","aggregateChildEvent","preventReEmit","mapper","plainOldJsObject","state_key","setUnsigned","getUnsigned","unsigned","bundledEdit","getServerAggregatedRelation","replacement","makeReplaced","findThreadForEvent","eventMapperFor","getEventTimeline","timelineSet","_this$clientOpts","_timelineSet$getTimel","_timelineSet$room$fin","getTimelineForEvent","getThreadTimeline","lazyLoadMembers","Filter","LAZY_LOADING_MESSAGES_FILTER","events_after","events_before","timeline","addTimeline","initialiseState","FORWARDS","liveTimeline","_this$clientOpts2","recurse","RelationsRecursion","hasServerSideSupport","hasServerSideFwdPaginationSupport","_resOlder$next_batch","_resNewer$next_batch","_timelineSet$getTimel2","resOlder","fetchRelations","resNewer","Forward","_timelineSet$thread","next_batch","fetchRoomEvent","setPaginationToken","_resOlder$next_batch2","eventsNewer","nextBatch","_resNewer$next_batch2","_timelineSet$thread2","getLatestTimeline","threadListType","_res$chunk","createThreadListMessagesRequest","_res$chunk2","_this$clientOpts3","_res$chunk3","messagesPath","timelineFilter","_this$clientOpts4","_timelineFilter$getRo","getRoomTimelineFilterComponent","ThreadFilterType","All","_this$clientOpts5","include","threadFilterTypeToFilter","_timelineFilter$getRo2","hasServerSideListSupport","FeatureSupport","V1","_res$chunk4","prev_batch","paginateEventTimeline","eventTimeline","isNotifTimeline","getTimelineSet","backwards","getPaginationToken","pendingRequest","paginationRequests","_opts$limit","next_token","notifications","noUnsafeEventProps","notification","finally","roomState","processThreadRoots","_eventTimeline$getRoo","_eventTimeline$getRoo2","getSender","getEventReadUpTo","newToken","_thread$rootEvent","_eventTimeline$getRoo3","rootEvent","atEnd","resetNotifTimelineSet","resetLiveTimeline","peekInRoom","_this$peekSync2","setGuestAccess","writePromise","RoomGuestAccess","guest_access","allowJoin","CanJoin","Forbidden","readPromise","allowRead","history_visibility","WorldReadable","requestRegisterEmailToken","clientSecret","sendAttempt","nextLink","requestTokenFromEndpoint","client_secret","send_attempt","next_link","requestRegisterMsisdnToken","phoneCountry","phoneNumber","country","phone_number","requestAdd3pidEmailToken","requestAdd3pidMsisdnToken","requestPasswordEmailToken","requestPasswordMsisdnToken","endpoint","postParams","getRoomPushRule","_this$pushRules$scope","pushRules","rule_id","setRoomMutePushRule","mute","hasDontNotifyRule","roomPushRule","DontNotify","deferred","deletePushRule","RoomSpecific","addPushRule","getPushRules","err2","searchMessageText","roomEvents","search_term","search_categories","room_events","searchRoomEvents","term","order_by","Recent","event_context","before_limit","after_limit","include_profile","searchResults","_query","highlights","processRoomEventsSearch","backPaginateRoomEventsSearch","searchOpts","abortSignal","_roomEvents$results$l","_roomEvents$results","hl","resultsLength","sr","SearchResult","fromJson","getEvent","getTimeline","setMetadata","syncLeftRooms","syncedLeftRooms","syncLeftRoomsPromise","createFilter","filter_id","allowCached","$filterId","getOrCreateFilter","existingId","existingFilter","oldDef","getDefinition","newDef","createdFilter","getOpenIdToken","turnServer","getTurnServers","turnServers","getTurnServersExpiry","turnServersExpiry","pollingTurnServers","credentialsGood","remainingTime","uris","ttl","servers","urls","credential","password","TurnServers","TurnServersError","setFallbackICEServerAllowed","allow","isFallbackICEServerAllowed","isSynapseAdministrator","admin","whoisSynapseUser","deactivateSynapseUser","_this$getDomain","clientWellKnownPromise","clientWellKnown","ClientWellKnown","getClientWellKnown","waitForClientWellKnown","primTypes","serializableOpts","_unstable_getSharedRooms","sharedRoomsSupport","mutualRoomsSupport","queryMutualRoomsSupport","rooms","tokenQuery","joined","next_batch_token","serverVersionsPromise","serverVersions","buildFeatureSupportMap","isVersionSupported","unstableFeatures","doesServerForceEncryptionForPreset","presetName","versionsPresetName","threadUnstable","threadStable","listUnstable","listStable","fwdPaginationUnstable","fwdPaginationStable","determineFeatureSupport","None","hasLazyLoadMembersEnabled","_this$clientOpts6","setCanResetTimelineCallback","cb","getCanResetTimelineCallback","relationType","_result$next_batch","_result$prev_batch","fetchedEventType","eventResult","allEvents","prevBatch","generateClientSecret","shouldAttemptDecryption","attemptDecryption","isBeingDecrypted","getDecryptionPromise","termsUrlForService","serviceType","SERVICE_TYPES","IS","getUrl","IdentityPrefix","V2","IM","getHomeserverUrl","stripProto","_this$idBaseUrl","_this$idBaseUrl2","setIdentityServerUrl","setIdBaseUrl","getRefreshToken","_this$http$opts$refre","setAccessToken","isLoggedIn","txnCtr","isUsernameAvailable","available","register","auth","bindThreepids","guestAccessToken","inhibitLogin","refresh_token","guest_access_token","inhibit_login","registerRequest","registerGuest","performRefreshRequestWithPrefix","inhibitLogoutEmit","loginFlows","login","loginType","loginRequest","access_token","loginWithPassword","getCasLoginUrl","redirectUrl","getSsoLoginUrl","idpId","loginWithToken","logout","abort","deactivateAccount","erase","requestLoginToken","getFallbackAuthUrl","authSessionId","$loginType","_this$identityServer2","invitesNeedingToken","invite_3pid","id_access_token","Experimental","replaceParam","queryString","templatedUrl","$relationType","includeMembership","excludeMembership","atEventId","not_membership","upgradeRoom","newVersion","new_version","roomInitialSync","_limit$toString","FullyRead","getJoinedRooms","getJoinedRoomMembers","publicRooms","server","createAlias","$alias","deleteAlias","getLocalAliases","getRoomIdForAlias","getRoomDirectoryVisibility","setRoomDirectoryVisibility","searchUserDirectory","cancelUpload","upload","getCurrentUploads","getProfileInfo","doesServerSupportExtendedProfiles","getExtendedProfileRequestPrefix","getExtendedProfile","getExtendedProfileProperty","$key","setExtendedProfileProperty","deleteExtendedProfileProperty","patchExtendedProfile","Patch","setExtendedProfile","getThreePids","addThreePidOnly","bindThreePid","unbindThreePid","deleteThreePid","setPassword","authDict","newPassword","logoutDevices","new_password","logout_devices","getDevices","getDevice","$device_id","setDeviceDetails","deleteDevice","deleteMultipleDevices","devices","getPushers","pushers","pusher","setPusher","removePusher","pushKey","appId","pushkey","app_id","setLocalNotificationSettings","notificationSettings","rules","setPushRules","rewriteDefaultRules","updateCachedPushRuleKeys","ruleId","$kind","$ruleId","setPushRuleEnabled","setPushRuleActions","uploadKeysRequest","uploadKeySignatures","downloadKeysForUsers","device_keys","claimOneTimeKeys","keyAlgorithm","safeSet","one_time_keys","getKeyChanges","qps","uploadDeviceSigningKeys","registerWithIdentityServer","hsOpenIdToken","requestEmailToken","idServerRequest","requestMsisdnToken","submitMsisdnToken","msisdnToken","submitMsisdnTokenOtherUrl","getIdentityHashDetails","identityHashedLookup","addressPairs","localMapping","addr","med","hashBuffer","hashed","unhashed","foundAddresses","mxid","plainAddress","lookupThreePid","bulkLookupThreePids","v1results","mapping","originalQuery","threepids","getIdentityAccount","deviceMessages","queueToDevice","getThirdpartyProtocols","getThirdpartyLocation","$protocol","getThirdpartyUser","getTerms","agreeToTerms","termsUrls","Authorization","user_accepts","reportEvent","reportRoom","getRoomHierarchy","suggestedOnly","suggested_only","max_depth","PrivateChat","power_level_content_override","creation_content","Space","initial_state","algorithm","_purposeEvent$getCont","_createEvent$getConte","getMyMembership","createEvent","purposeEvent","proxyBaseUrl","clientTimeout","_this$clientOpts7","threadSupport","supportsIntentionalMentions","IntentionalMentions","getRoomSummary","paramOpts","toStartOfTimeline","processThreadedEvents","processBeaconEvents","processPollEvents","whoami","timestampToEvent","getAuthIssuer","getAuthMetadata","authMetadata","issuer","discoverAndValidateOIDCIssuerWellKnown","validateAuthMetadataAndKeys","fromEntries","_actions$tweaks","ourUserId","isThreadEvent","threadRootId","isThreadRoot","hasReadEvent","hasUserReadEvent","tweaks","highlight","newCount","getUnreadCountForEventContext","Highlight","setThreadUnreadNotificationCount","setUnreadNotificationCount","notify","inMainTimelineForReceipt","MAIN_ROOM_TIMELINE","relationEventId","DecryptionError","detailedString","detailedStringForDecryptionError","makeHtmlMessage","makeHtmlNotice","makeHtmlEmote","makeTextMessage","makeNotice","makeEmoteMessage","getTextForLocationEvent","assetType","LocationAssetType","Self","makeLocationContent","defaultedText","timestampEvent","M_TIMESTAMP","Location","geo_uri","M_LOCATION","M_ASSET","parseLocationEvent","wireEventContent","_location$uri","_asset$type","asset","geoUri","fallbackText","makeTopicContent","parseTopicContent","_mtopic$find$body","_mtopic$find","_mtopic$find2","mtopic","_content$topic","makeBeaconInfoContent","isLive","live","parseBeaconInfoContent","_M_TIMESTAMP$findIn","makeBeaconContent","beaconInfoEventId","parseBeaconContent","_M_TIMESTAMP$findIn2","serverNameRegex","mediaIdRegex","serverName","mediaId","validateServerName","validateMediaId","verb","ALPHABET","BASE_MAP","xc","BASE","LEADER","FACTOR","iFACTOR","decodeUnsafe","psz","zeroes","b256","carry","it3","it4","vch","isView","pbegin","pend","b58","it1","it2","decode","OLM_RECOVERY_KEY_PREFIX","KEY_SIZE","encodeRecoveryKey","_base58key$match","parity","bs58","decodeRecoveryKey","recoveryKey","DEFAULT_BIT_SIZE","deriveRecoveryKeyFromPassphrase","passphrase","salt","iterations","numBits","keybits","deriveBits","DecryptionFailureCode","DeviceIsolationModeKind","AllDevicesIsolationMode","errorOnVerifiedUserProblems","OnlySignedDevicesIsolationMode","UserVerificationStatus","crossSigningVerified","crossSigningVerifiedBefore","tofu","needsUserApproval","isVerified","isCrossSigningVerified","wasCrossSigningVerified","isTofu","DeviceVerificationStatus","_opts$signedByOwner","_opts$crossSigningVer","_opts$tofu","_opts$localVerified","_opts$trustCrossSigne","signedByOwner","localVerified","trustCrossSignedDevices","ImportRoomKeyStage","CrossSigningKey","EventShieldColour","EventShieldReason","VerificationRequestEvent","VerificationPhase","VerifierEvent","canAcceptVerificationRequest","phase","Ready","accepting","declining","ACCOUNT_OBJECT_KEY_MIGRATION_STATE","MigrationState","SESSION_BATCH_SIZE","Backend","db","onversionchange","containsData","getMigrationState","migrationState","NOT_STARTED","doTxn","IndexedDBCryptoStore","STORE_ACCOUNT","txn","getReq","objectStore","_getReq$result","setMigrationState","put","getAccount","abortWithException","storeAccount","accountPickle","getCrossSigningKeys","getSecretStorePrivateKey","storeSecretStorePrivateKey","countEndToEndSessions","countReq","getEndToEndSessions","deviceKey","openCursor","lastReceivedMessageTs","getEndToEndSession","storeEndToEndSession","sessionInfo","getEndToEndSessionsBatch","STORE_SESSIONS","deleteEndToEndSessionsBatch","getEndToEndInboundGroupSession","senderCurve25519Key","withheld","withheldGetReq","storeEndToEndInboundGroupSession","sessionData","countEndToEndInboundGroupSessions","STORE_INBOUND_GROUP_SESSIONS","getEndToEndInboundGroupSessionsBatch","STORE_BACKUP","sessionStore","backupStore","backupGetReq","senderKey","needsBackup","deleteEndToEndInboundGroupSessionsBatch","getEndToEndDeviceData","getEndToEndRooms","markSessionsNeedingBackup","stores","oncomplete","_mx_abortexception","onabort","promiseifyTxn","DB_MIGRATIONS","outgoingRoomKeyRequestsStore","createObjectStore","keyPath","createIndex","createDatabase","dbName","IndexedDBHelpers","existsAndIsNotMigrated","indexedDb","openDBRequest","onupgradeneeded","backendPromise","IndexedDBCryptoStoreBackend","oldVersion","migration","backend","STORE_INBOUND_GROUP_SESSIONS_WITHHELD","InvalidCryptoStoreError","InvalidCryptoStoreState","TooNew","LocalStorageCryptoStore","localStorage","MemoryCryptoStore","E2E_PREFIX","KEY_END_TO_END_MIGRATION_STATE","KEY_END_TO_END_ACCOUNT","KEY_CROSS_SIGNING_KEYS","KEY_INBOUND_SESSION_PREFIX","KEY_INBOUND_SESSION_WITHHELD_PREFIX","KEY_ROOMS_PREFIX","KEY_SESSIONS_NEEDING_BACKUP","keyEndToEndSessions","keyEndToEndInboundGroupSession","_store$key","_getJsonItem","getJsonItem","setJsonItem","_getEndToEndSessions","fixedSessions","_sessions$sessionId","_this$_getEndToEndSes","_this$store$key","deviceSessions","removeItem","keyEndToEndInboundGroupSessionWithheld","sessionsNeedingBackup","getItem","setItem","encodeSessionKey","decodeSessionKey","keyParts","account","crossSigningKeys","privateKeys","inboundGroupSessions","inboundGroupSessionsWithheld","sessionKey","plaintext","utf8","KeySignatureUploadError","ClientStoppedError","clientEndpoint","isEquivalentTo","_response$answers","featureSupportResolver","unstablePrefixes","matrixVersion","ThreadUnreadNotifications","LoginTokenRequest","supportMap","supportCondition","_versions$versions$in","_versions$versions","_supportCondition$uns","_supportCondition$uns2","supportMatrixVersion","supportUnstablePrefixes","unstablePrefix","_versions$unstable_fe","unstable_features","FilterComponent","filterJson","_event$getUnsigned","_bundledRelationships","bundledRelationships","relationSenders","current_user_participated","checkFields","not_types","not_rooms","senders","not_senders","contains_url","FILTER_RELATED_BY_SENDERS","FILTER_RELATED_BY_REL_TYPES","containsUrl","relationTypes","literalKeys","actualValue","filterValue","typePrefix","matchesWildcard","matchFunc","notName","disallowedValues","allowedValues","containsUrlFilter","relationTypesFilter","arrayMatchesFilter","relationSendersFilter","setProp","keyNesting","nestedKeys","currentObj","jsonObj","setDefinition","getFilterId","roomFilterJson","roomFilterFields","roomFilter","roomTimelineFilter","filterRoomTimeline","setTimelineLimit","setUnreadThreadNotifications","_this$definition","_this$definition2","setLazyLoadMembers","setIncludeLeaveRooms","includeLeave","lazy_load_members","HTTPError","httpHeaders","isRateLimitError","getRetryAfterMs","_this$httpHeaders","retryAfter","ms","toUTCString","errorJson","headerValue","retry_after_ms","asWidgetApiErrorData","_this$httpStatus","_this$url","_this$errcode","_this$data$error","http_status","http_headers","fromWidgetApiErrorData","safeGetRetryAfterMs","defaultMs","_error$getRetryAfterM","ConnectionError","cause","TokenRefreshError","_cause$message","HttpApiEvent","controller","AbortController","anySignal","signals","onAbort","aborted","parseErrorResponse","_contentType","_contentType2","isXhr","getAllResponseHeaders","colonIdx","parseContentType","getResponseContentType","responseURL","maxAttempts","attempts","lastConnectionError","calculateRetryBackoff","retryConnectionError","TokenRefreshOutcome","FetchHttpApi","eventEmitter","_opts$useAuthorizatio","_initProto","checkObjectHasKeys","abortController","fullUri","tokenRefreshPromise","doNotAttemptTokenRefresh","tryRefreshToken","allSettled","outcome","Success","Failure","NoConsent","consent_uri","SessionLoggedOut","Logout","_this$opts$logger","OidcAuthError","_this$opts$logger2","_opts$json","_body$constructor","_opts$localTimeoutMs","_opts$keepAlive","urlForLogs","sanitizeUrlForLogs","jsonBody","keepAlive","_this$opts$logger3","_this$opts$logger4","asUrl","sanitizedQs","URLSearchParams","sanitizedQsString","sanitizedQsUrlPiece","baseUrlWithFallback","baseUrlWithoutTrailingSlash","encodeParams","_FetchHttpApi","_applyDecs","realCallbackKey","callbackList","delayMs","runAt","idx","binarySearch","scheduleRealCallback","runCallbacks","callbacksToRun","_opts$includeFilename","_opts$abortController","_opts$type","_opts$name","fileName","loaded","timeoutFn","timeoutTimer","DONE","DOMException","statusText","responseText","onprogress","_opts$progressHandler","progressHandler","uploads","getContentUri","EMAIL_STAGE_TYPE","MSISDN_STAGE_TYPE","AuthType","NoAuthFlowFoundError","required_stages","flows","InteractiveAuth","requestingEmailToken","emailAttempt","requestTokenResult","requestEmailTokenCallback","emailAddress","emailSid","matrixClient","authData","requestCallback","doRequest","busyChangedCallback","busyChanged","stateUpdatedCallback","stateUpdated","startAuthStage","supportedStages","attemptAuth","_this$data","attemptAuthDeferred","startNextAuthStage","_this$busyChangedCall","_this$busyChangedCall2","submitPromise","currentStage","creds","threepid_creds","submitAuthDict","_this$data2","getClientSecret","getStageParams","_this$data3","getChosenFlow","chosenFlow","_this$data4","_this$busyChangedCall3","_this$busyChangedCall4","getEmailSid","setEmailSid","_matrixError$data$flo","_matrixError$data","_this$data5","_this$chosenFlow","matrixError","errorFlows","haveFlows","_this$attemptAuthDefe","completed","stages","_this$data6","_this$data7","nextStage","chooseStage","_this$data8","_this$data9","Dummy","chooseFlow","firstUncompletedStage","scoreFlow","stage","_this$data10","haveEmail","haveMsisdn","flowHasEmail","flowHasMsisdn","requiredStages","_this$data11","stageType","isValidFilterId","MemoryStore","_this$createUser","setRawDisplayName","getDirectionalContent","syncToken","RoomStateEvent","Members","onRoomMember","getMembers","summary","filters","_this$filters$get","accountData","oobMembers","_this$pendingEvents$r","pendingEvents","pendingToDeviceBatches","nextToDeviceBatchId","RoomWidgetClientEvent","RoomWidgetClient","widgetApi","capabilities","sendContentLoaded","_capabilities$sendEve","_capabilities$receive","_capabilities$sendSta","_capabilities$receive2","_capabilities$sendEve2","_capabilities$receive3","_capabilities$sendSta2","_capabilities$receive4","_capabilities$sendToD","_capabilities$receive5","_capabilities$sendEve3","_capabilities$sendSta3","pendingSendingEventsTxId","_this$pendingSendingE","matchingTxId","txId","_this$pendingSendingE2","PendingEventsChanged","transaction_id","updateTxId","injectRoomEvents","setSyncState","ack","encrypted","makeEncrypted","ToDeviceEvent","transportSend","processAndThrow","transportSendComplete","sendComplete","widgetApiReady","receiveEvent","receiveMessage","sendState","receiveState","requestCapabilityForRoomTimeline","requestCapabilityToSendEvent","requestCapabilityToReceiveEvent","requestCapabilityToSendMessage","msgType","requestCapabilityToReceiveMessage","requestCapabilityToSendState","requestCapabilityToReceiveState","requestCapabilityToSendToDevice","receiveToDevice","requestCapabilityToReceiveToDevice","sendDelayedEvents","requestCapability","MatrixCapabilities","MSC4157SendDelayedEvent","updateDelayedEvents","MSC4157UpdateDelayedEvent","MSC3846TurnServers","WidgetApiToWidgetAction","SendEvent","onEvent","SendToDevice","onToDevice","_this$capabilities$re","_this$capabilities$re2","lifecycle","readStateEvents","rawEvent","watchTurnServers","sendRoomEvent","parent_delay_id","timeoutToConnectionError","validateSendDelayedEventResponse","delay_id","updateDelayedEvent","recursiveMapToObject","requestOpenIDConnectToken","expires_in","matrix_server_name","token_type","encryptAndSendToDevices","userDeviceInfoArr","sendToDeviceViaWidgetApi","syncState","reply","onClientStopped","return","WidgetApiResponseError","matrix_api_error","debuglog","TimelineWindow","_timelineSet$room","windowLimit","RoomEvent","Timeline","onTimelineEvent","initialEventId","initialWindowSize","initFields","eventIndex","TimelineIndex","getBaseIndex","eventCount","getTimelineIndex","_this$start","_this$end","tl","retreat","advance","unpaginate","_room","_atStart","removed","onEventRemoved","canPaginate","minIndex","maxIndex","hasNeighbouringTimeline","getNeighbouringTimeline","paginate","requestLimit","pendingPaginate","startOfTimeline","_this$end2","_this$end3","cappedDelta","neighbour","RemoteIndexedDBStoreBackend","workerFactory","_this$onClose","seq","inFlight","connect","ensureStarted","doCmd","clearDatabase","getNextBatchToken","syncToDatabase","userTuples","getUserPresenceEvents","startPromise","worker","onmessage","onWorkerMessage","_this$worker","nextSeq","postMessage","_this$worker2","terminate","IndexedDBStore","LocalIndexedDBStoreBackend","degradable","syncTs","userModifiedMap","getLastModifiedTime","startedUp","userPresenceEvents","setPresenceEvent","reallySave","fallbackFn","pendingEventsKey","ThreepidMedium","DELEGATED_OIDC_COMPATIBILITY","IdentityProviderBrand","SSOAction","ProfileKeyMSC4175Timezone","LocalStorageErrors","LocalStorageErrorsEventsEmitter","localStorageErrorsEventsEmitter","cryptoStoreFactory","setCryptoStoreFactory","fac","amendClientOpts","_opts$store","_opts$scheduler","_opts$cryptoStore","createClient","createRoomWidgetClient","DEFAULT_EXPIRE_DURATION","CallMembership","equal","membershipData","sessionErrors","checkSessionsMembershipData","_data$focus_active","device_id","call_id","application","focus_active","foci_preferred","created_ts","callId","membershipID","createdTs","_this$membershipData$","getAbsoluteExpiry","_this$membershipData$2","expires","getMsUntilExpiry","isExpired","getPreferredFoci","getFocusSelection","focusActive","isLivekitFocusActive","focus_selection","rootLogger","getChild","ActionScheduler","membershipLoopHandler","_actions","startWithJoin","MembershipActionType","SendFirstDelayedEvent","nextAction","wakeupUpdate","wakeupPromise","wakeup","handlerResult","actionUpdate","initiateJoin","_this$wakeup","initiateLeave","_this$wakeup2","SendScheduledDelayedLeaveEvent","Status","MembershipManager","isJoined","activated","fociPreferred","leavePromiseDefer","defaultState","_this$leavePromiseDef","_this$leavePromiseDef2","onRTCSessionMemberUpdate","memberships","sendingMembershipActions","SendJoinEvent","hasMemberStateEvent","getActiveFocus","oldestMembership","getOldestMembership","joinConfig","oldStatus","makeMembershipStateKey","rateLimitRetries","networkErrorRetries","expireUpdateIterations","callMemberEventRetryDelayMinimum","_this$joinConfig$call","_this$joinConfig","membershipEventExpiryTimeout","_this$joinConfig$memb","_this$joinConfig2","membershipExpiryTimeout","membershipEventExpiryTimeoutHeadroom","_this$joinConfig$memb2","_this$joinConfig3","membershipExpiryTimeoutHeadroom","computeNextExpiryActionTs","iteration","membershipServerSideExpiryTimeout","_this$membershipServe","_this$joinConfig4","membershipServerSideExpiryTimeoutOverride","membershipKeepAlivePeriod","_this$joinConfig$memb3","_this$joinConfig5","maximumRateLimitRetryCount","_this$joinConfig$maxi","_this$joinConfig6","maximumNetworkErrorRetryCount","_this$joinConfig$maxi2","_this$joinConfig7","cancelKnownDelayIdBeforeSendFirstDelayedEvent","sendFirstDelayedLeaveEvent","RestartDelayedEvent","restartDelayedEvent","createInsertActionUpdate","SendMainDelayedEvent","sendMainDelayedEvent","sendScheduledDelayedLeaveEventOrFallbackToSendLeaveEvent","SendLeaveEvent","sendJoinEvent","UpdateExpiry","updateExpiryOnJoinedEvent","sendFallbackLeaveEvent","GroupCallMemberPrefix","repeatActionType","manageMaxDelayExceededSituation","actionUpdateFromErrors","isUnsupportedDelayedEndpoint","Cancel","resetRateLimitCounter","createReplaceActionUpdate","isNotFoundError","Restart","Send","makeMyMembership","nextExpireUpdateIteration","localUserId","localDeviceId","getVersion","_this$fociPreferred","maxDelayAllowed","updateLimit","actionUpdateFromRateLimitError","updateNetwork","actionUpdateFromNetworkErrorRetry","_this$state$rateLimit","resendDelay","_this$state$networkEr","retries","retryDurationString","retryCounterString","Connecting","Connected","Disconnecting","Unknown","Disconnected","EncryptionManager","updateEncryptionKeyThrottle","_this$joinConfig$upda","makeKeyDelay","_this$joinConfig$make","useKeyDelay","_this$joinConfig$useK","getMemberships","onEncryptionKeysChanged","counters","roomEventEncryptionKeysSent","roomEventEncryptionKeysReceived","totals","roomEventEncryptionKeysReceivedTotalAge","keysEventUpdateTimeout","lastEncryptionKeyUpdateRequest","indexToSend","myKeys","getKeysForParticipant","currentEncryptionKeyIndex","keyIndexToSend","keyToSend","sent_ts","statistics","CallEncryptionKeysPrefix","encryptionKeys","sendEncryptionKeysEvent","age","encryptionKey","encryptionKeyIndex","setEncryptionKey","manageMediaKeys","makeNewKeyTimeout","newKeyIndex","makeNewSenderKey","getEncryptionKeys","_this$joinConfig$mana","requestSendCurrentKey","getParticipantId","setNewKeyTimeouts","onMembershipsUpdate","oldMemberships","oldMembershipIds","isMyMembership","getParticipantIdFromMembership","newMembershipIds","anyLeft","anyJoined","oldFingerprints","lastMembershipFingerprints","storeLastMembershipFingerprints","onRotateKeyTimeout","newFingerprints","delayBeforeUse","secureRandomBase64Url","getNewEncryptionKeyIndex","_this$encryptionKeys$","encryptionKeyString","keyBin","participantId","participantKeys","existingKeyAtIndex","useKeyTimeout","LegacyMembershipManager","callMemberEventRetryJitter","_this$joinConfig$call2","updateCallMembershipRunning","needCallMembershipUpdate","updateCallMembershipEvent","knownDisconnectDelayId","disconnectDelayId","resendIfRateLimited","scheduleDelayDisconnection","relativeExpiry","fociActive","ownFocusActive","ownFociPreferred","triggerCallMembershipEventUpdate","memberEventTimeout","makeNewMembership","_this$ownFociPreferre","newContent","prepareDelayedDisconnection","sentDelayedDisconnect","delayDisconnection","numRetriesAllowed","_e$getRetryAfterMs","MatrixRTCSessionEvent","MatrixRTCSession","encryptionManager","_callId","callMembershipsForRoom","callMemberEvents","callMemberships","memberEvent","eventKeysCount","membershipContents","_membership$sender","roomSessionForRoom","roomSubset","_memberships$","onCallEncryptionEventReceived","recalculateSessionMembers","_this$_callId","_this$memberships$","_this$membershipManag","logDurationSync","MembershipsChanged","membershipManager","setExpiryTimer","onRoomMemberUpdate","EncryptionKeyChanged","_this$membershipManag2","_this$membershipManag3","_this$membershipManag4","expiryTimeout","joinRoomSession","_joinConfig$useNewMem","useNewMembershipManager","MembershipManagerError","JoinStateChanged","leaveRoomSession","leavePromise","_this$membershipManag5","getFocusInUse","reemitEncryptionKeys","_this$encryptionManag","soonestExpiry","thisExpiry","MatrixRTCSessionManagerEvents","consumeCallEncryptionEvent","refreshRoom","_this$client$getRooms","roomSessions","Room","onRoom","onTimeline","Events","onRoomState","sess","getActiveRoomSession","getRoomSession","isRetry","isDecryptionFailure","decryptionFailureReason","onCallEncryption","isNewSession","wasActiveAndKnown","nowActive","SessionEnded","SessionStarted","BeaconEvent","isTimestampInDuration","durationMs","getBeaconInfoIdentifier","Beacon","_latestLocationEvent","LocationUpdate","latestLocationState","setBeaconInfo","_isLive","beaconInfoId","beaconInfoOwner","beaconInfoEventType","beaconInfo","_beaconInfo","latestLocationEvent","beaconInfoEvent","Update","clearLatestLocation","livenessWatchTimeout","Destroy","monitorLiveness","checkLiveness","expiryInMs","addLocations","beaconLocationEvents","_validLocationEvents$","sortEventsByLatestContentTimestamp","prevLiveness","LivenessChange","DeviceVerification","Device","algorithms","verified","Unverified","signatures","dehydrated","getFingerprint","getIdentityKey","DuplicateStrategy","EventTimelineSet","_this$room$relations","_this$room","_room$client","displayPendingEvents","timelines","_eventIdToTimeline","RelationsContainer","getTimelines","setFilter","setLiveTimeline","eventIdToTimeline","replaceEventId","oldEventId","newEventId","existingTimeline","backPaginationToken","forwardPaginationToken","resetAllTimelines","oldTimeline","newTimeline","forkLive","fork","TimelineReset","addToState","inverseDirection","didUpdate","lastEventWasNew","addEventToTimeline","existingIsLive","timelineIsLive","backwardsIsLive","forwardsIsLive","setNeighbouringTimeline","addLiveEvent","duplicateStrategy","fromCache","timelineWasEmpty","tlEvents","setEventMetadata","_this$thread","aggregateParentEvent","_this$thread2","eventDebugString","liveEvent","insertEventIntoTimeline","_this$thread3","_this$thread4","parentEventId","insertIndex","insertEvent","handleRemoteEcho","removeEvent","compareEventOrdering","eventId1","eventId2","timeline1","timeline2","idx1","idx2","evId","shouldLiveInRoom","shouldLiveInThread","eventShouldLiveIn","_this$room2","stateContext","eventTimelineSet","_eventTimelineSet$roo","_eventTimelineSet$roo2","startState","RoomState","endState","_this$startState","_this$endState","setStateEvents","forkState","baseIndex","startToken","prevTimeline","nextTimeline","_roomState","MESSAGE_VISIBLE","visible","_this$sender","_this$target","affectsSelf","changed","newSender","getSentinelMember","newTarget","forwardLooking","SentinelUpdated","_this$getTs","internaliseString","_event$content","_event$content2","txn_id","getAge","localTimestamp","unstableExtensibleEvent","_hasCachedExtEv","_cachedExtEv","getEffectiveEvent","invalidateExtensibleEvent","clearEvent","getDetails","_this$getDate","_this$event$content","_this$clearEvent$cont","_localRedactionEvent","_replacingEvent","_this$_replacingEvent","_this$getWireContent","relatesTo","replyEventId","_this$getWireContent$","_this$getWireContent2","getPrevContent","prev_content","getLocalAge","getMembershipAtEvent","cryptoType","cryptoContent","claimedEd25519Key","decryptionPromise","_decryptionFailureReason","isEncryptedDisabledForUnverifiedDevices","MEGOLM_KEY_WITHHELD_FOR_UNVERIFIED_DEVICE","isRedacted","alreadyDecrypted","forceRedecrypt","forceRedecryptIfUntrusted","isKeySourceUntrusted","retryDecryption","decryptionLoop","getKeyRequestRecipients","decryptEvent","setClearData","detailedError","setClearDataForDecryptionFailure","UNKNOWN_ERROR","decryptionResult","_decryptionResult$sen","_decryptionResult$cla","forwardingCurve25519KeyChain","untrusted","getClearContent","getSenderKey","getKeysClaimed","ed25519","getClaimedEd25519Key","getForwardingCurve25519KeyChain","unmarkLocallyRedacted","redacted_because","markLocallyRedacted","redactionEvent","applyVisibilityEvent","visibilityChange","_visibilityChange$vis","_visibilityChange$rea","change","messageVisibility","makeRedacted","REDACT_KEEP_KEYS","keeps","REDACT_KEEP_CONTENT_MAP","moveAllRelatedToMainTimeline","moveToMainTimeline","_event$getRelation","getRelation","asVisibilityChange","relation","isVisibilityEvent","getRedactionEvent","_this$clearEvent","_this$event$unsigned","_this$clearEvent$unsi","_this$clearEvent2","pushDetails","pushActions","_this$getAge","oldUnsigned","oldId","isSending","replaceLocalEventId","relType","_this$getWireContent3","_this$getWireContent$2","newEvent","getAssociatedStatus","_this$getUnsigned$mR","replaceRelation","replacingEvent","replacingEventDate","_this$_replacingEvent2","localRedactionEvent","hasAssociation","flagCancelled","_isCancelled","isCancelled","toSnapshot","otherEvent","myProps","deepSortedObjectEntries","theirProps","decrypted","ThreadEvent","setThreadId","RoomJoinRules","join_rule","POLICIES_ACCOUNT_EVENT_TYPE","IGNORE_INVITES_ACCOUNT_EVENT_KEY","PolicyRecommendation","PolicyScope","scopeToEventTypeMap","PolicyRuleUser","PolicyRuleRoom","Server","PolicyRuleServer","addRule","getOrCreateTargetRoom","recommendation","removeRule","addSource","getOrCreateSourceRooms","withIgnoreInvitesPolicies","ignoreInvitesPolicies","getRuleForInvite","policyRooms","senderServer","roomServer","globToRegexp","getIgnoreInvitesPolicies","hasChanges","sourceRooms","getPoliciesAndIgnoreInvitesPolicies","policies","_this$client$getAccou","hasIgnoreInvitesPolicies","PollEvent","filterResponseRelations","relationEvents","pollEndTimestamp","responseEvents","Poll","undecryptableEventIds","previousCount","undecryptableRelationsCount","undecryptableRelationEventIds","UndecryptableRelations","pollEvent","pollId","endEventId","_this$endEvent","endEvent","isEnded","isFetchingResponses","_isFetchingResponses","getResponses","responses","fetchResponses","onNewRelation","_this$endEvent2","validateEndEvent","refilterResponsesOnEnd","countUndecryptableEvents","Responses","_this$endEvent3","_allRelations$nextBat","allRelations","relationsNextBatch","Relations","pollEndEvent","pollCloseTimestamp","_this$endEvent4","getRelations","_this$responses","roomCurrentState","endEventSender","maySendRedactionForEvent","isPollEvent","synthesizeReceipt","Receipt","ReadReceipt","getReadReceiptForUserId","ignoreSynthesized","_this$receipts$get$ge","_this$receipts$get","realReceipt","syntheticReceipt","receipts","compareReceipts","_this$getUnfilteredTi","latestReceipt","getLatestReceipt","receiptPointsAtConsistentEvent","receipt","_receipt$data","publicReadReceipt","privateReadReceipt","addReceiptToStructure","synthetic","_pair$ReceiptPairSynt2","_pair$ReceiptPairSynt3","receiptTypesMap","existingReceipt","_pair$ReceiptPairSynt","wrappedReceipt","ordering","preferSynthetic","cachedReceipt","receiptCacheByEventId","previousEventId","getReceiptsForEvent","lastEvent","setUnread","addReceipt","getUsersReadUpTo","isSupportedReceiptType","RelatedRelations","getChildEventsForEvent","_this$relations$get","getAllChildEventsForEvent","_this$relations$get2","relationsForEvent","relationsRecord","relationsWithRelType","relationsWithEventType","setTargetEvent","onEventDecrypted","relatesToEventId","_timelineSet$findEven","relatesToEvent","getPendingEvent","RelationsEvent","altEventTypes","onEventStatus","redactedEvent","Annotation","removeAnnotationFromAggregation","targetEvent","lastReplacement","getLastReplacement","onBeforeRedaction","Redaction","relationEventIds","matchesEventType","targetEventType","altTargetEventTypes","addAnnotationToAggregation","Add","maybeEmitCreated","Remove","eventsForKey","annotationsByKey","sortedAnnotationsByKey","aEvents","eventsFromSender","annotationsBySender","_event$getRelation2","getSortedAnnotationsByKey","getAnnotationsBySender","minTs","creationEmitted","RelationsCreated","rawDisplayName","updateModifiedTime","markOutOfBand","_isOutOfBand","isOutOfBand","setMembershipEvent","_event$getDirectional","_event$getDirectional2","oldMembership","disambiguate","selfUserId","strippedDisplayName","removeHiddenChars","MXID_PATTERN","LTR_RTL_PATTERN","getUserIdsWithDisplayName","shouldDisambiguate","oldName","removeDirectionOverrideChars","calculateDisplayName","Name","setPowerLevelEvent","powerLevelEvent","evContent","maxLevel","lvl","oldPowerLevel","oldPowerLevelNorm","powerLevelNorm","PowerLevel","setTypingEvent","oldTyping","typingList","user_ids","Typing","modified","isKicked","getDMInviter","memberContent","inviteSender","prev_sender","is_direct","getAvatarUrl","allowDefault","rawUrl","getMxcAvatarUrl","OobStatus","oobMemberFlags","NotStarted","getJoinedMemberCount","summaryJoinedMemberCount","joinedMemberCount","setJoinedMemberCount","getInvitedMemberCount","summaryInvitedMemberCount","invitedMemberCount","setInvitedMemberCount","getMembersExcept","excludedIds","getMember","sentinel","sentinels","hasLiveBeacons","_this$liveBeaconIds","liveBeaconIds","_liveBeaconIds","eventsByStateKey","Finished","_copy$getMember","unknownStateEvents","markerFoundOptions","setBeacon","lastStateEvent","getStateEventMatching","_event$getContent$dis","setStateEvent","updateDisplayNameCache","updateThirdPartyTokenCache","onBeaconLivenessChange","getOrCreateMember","updateMember","oldLastModified","Marker","beacons","beaconByEventIdDict","dict","beacon","processBeaconRelation","relatedToEventId","NewMember","beaconIdentifier","_event$getRedactionEv","New","BeaconLiveness","_this$events$get$get","_this$events$get","pwrLvlEvent","needsOutOfBandMembers","outOfBandMembersReady","markOutOfBandMembersStarted","InProgress","markOutOfBandMembersFailed","setOutOfBandMember","stateEvent","existingMember","getInviteForThreePidToken","tokenToInvite","_this$displayNameToUs","displayNameToUserIds","mxEvent","maySendEvent","hasSufficientPowerLevelFor","powerLevelsEvent","powerLevels","requiredLevel","maySendMessage","maySendEventOfType","mayClientSendStateEvent","stateEventType","maySendStateEvent","eventsLevels","stateDefault","eventsDefault","userPowerLevel","mayTriggerNotifOfType","notifLevelKey","notifLevel","getJoinRule","_joinRuleEvent$getCon","joinRuleEvent","getHistoryVisibility","_historyVisibilityEve","historyVisibilityEvent","Shared","getGuestAccess","_guestAccessEvent$get","guestAccessEvent","predecessorEvent","RoomPredecessor","predecessor_room_id","last_known_event_id","via_servers","third_party_invite","signed","RoomThirdPartyInvite","userIdsToDisplayNames","strippedOldName","existingUserIds","filteredUserIDs","strippedDisplayname","_this$displayNameToUs2","RoomSummary","RoomReceipts","danglingReceipts","danglingReceipt","threadedReceipts","unthreadedReceipts","ThreadedReceipts","ReceiptsByUser","DanglingReceipts","receiptContent","eventReceipt","receiptsByUser","DanglingReceipt","isAfterOrSame","threaded","userSentLatestEventInThread","_this$room$getThread","ReceiptInfo","UserReceipts","real","receiptInfo","_this$synthetic","getByType","userReceipts","leftEventId","rightEventId","isAfter","_this$data$get","_this$data$get2","createFn","created","leftEvent","rightEvent","isLeftEventInMainTimeline","isRightEventInMainTimeline","compareSameTimeline","leftTimeline","rightTimeline","guessOrderBasedOnTimestamp","compareEventsInMainTimeline","leftEventThreadId","rightEventThreadId","leftThread","compareEventsInThreads","leftTs","rightTs","KNOWN_SAFE_ROOM_VERSION","SAFE_ROOM_VERSIONS","myUserId","recreateEvent","_this$threadsTimeline","_this$threadsTimeline2","updateThreadRootEvent","threadsTimelineSets","hasCurrentUserParticipated","redactId","currentStateEvent","visibilityEvents","redactVisibilityChangeEvent","pendingEventOrdering","Chronological","normalizedName","onReceipt","timelineSets","fixUpLegacyTimelineFields","Detached","pendingEventList","toDevice","serializedEvent","membersPromise","createThreadsTimelineSets","_this$client","threadTimelineSetsPromise","createThreadTimelineSet","My","decryptCriticalEvents","readReceiptEventId","readReceiptTimelineIndex","matrixEvent","decryptionPromises","decryptAllEvents","getCreator","_createEvent$getSende","getVersionWarning","getRecommendedVersion","versionCap","safeVer","RoomVersionStability","checkVersionAgainstCapability","urgent","needsUpgrade","currentVersion","userMayUpgradeRoom","removePendingEvent","savePendingEvents","_this$pendingEventLis","_this$pendingEventLis2","_this$pendingEventLis3","_this$pendingEventLis4","getLastActiveTimestamp","MIN_SAFE_INTEGER","getLastLiveEvent","_lastRoomEvent$getTs","_lastThreadEvent$getT","lastRoomEvent","lastThread","getLastThread","lastThreadEvent","getThreads","_threadEvent$getTs","_lastThreadEvent$getT2","threadEvent","_this$selfMembership","selfMembership","me","_this$summaryHeroes","getInvitedAndJoinedMemberCount","summaryHeroes","guessDMUserId","inviterId","anyMember","getFunctionalMembers","mFunctionalMembers","service_members","getAvatarFallbackMember","_this$summaryHeroes2","functionalMembers","nonFunctionalMemberCount","nonFunctionalHeroes","hasHeroes","availableMember","nonFunctionalMembers","availableUser","updateMyMembership","prevMembership","cleanupAfterLeaving","MyMembership","loadMembersFromServer","lastSyncToken","loadMembers","fromServer","rawMembersEvents","memberEvents","membersLoaded","loadMembersIfNeeded","inMemoryUpdate","_m$events$member","clearLoadedMembersIfNeeded","refreshLiveTimeline","liveTimelineBefore","backwardPaginationToken","eventsBefore","mostRecentEventInTimeline","TimelineRefresh","setTimelineNeedsRefresh","previousOldState","previousCurrentState","OldStateUpdated","CurrentStateUpdated","clearNotificationsOnReceipt","threadIds","hasUnthreadedReceipt","receiptGroup","userReceipt","singleReceipt","typedSingleReceipt","getThreadUnreadNotificationCount","_this$getThread","maxHistory","highlightCount","_pushActions$tweaks","getTimelineSets","timelineNeedsRefresh","getTimelineNeedsRefresh","getRoomUnreadNotificationCount","threadNotification","threadNotifications","_threadNotification$t","_this$notificationCou","notificationCounts","_this$threadNotificat","_this$threadNotificat2","hasThreadUnreadNotification","_notification$highlig","_notification$total","_this$threadNotificat3","_this$threadNotificat4","UnreadNotifications","threadsAggregateNotificationType","_threadNotification$h","_threadNotification$t2","resetThreadUnreadNotificationCountFromSync","exceptThreadIds","notifs","setSummary","heroes","joinedCount","invitedCount","Summary","setBlacklistUnverifiedDevices","blacklistUnverifiedDevices","getBlacklistUnverifiedDevices","roomAvatarEvent","RoomAvatar","mainUrl","_this$currentState$ge","getCanonicalAlias","canonicalAlias","RoomCanonicalAlias","getAltAliases","alt_aliases","_this$threads$get","getJoinedMembers","getMembersWithMembership","getEncryptionTargetMembers","shouldEncryptForInvitedMembers","_ev$getContent","getDefaultRoomName","calculateRoomName","getOrCreateFilteredTimelineSet","prepopulateTimeline","useSyncEvents","filteredTimelineSets","unfilteredLiveTimeline","livePaginationToken","getThreadListFilter","filterType","currentUserParticipated","createThread","fetchRoomThreads","threadsReady","fetchRoomThreadList","allThreadsFilter","threadRoots","eventA","eventB","threadAMetadata","threadBMetadata","latest_event","latestMyThreadsRootEvent","_this$threadsTimeline3","Ignore","threadRelationship","_this$threadsTimeline4","NewReply","onThreadReply","onThreadUpdate","onThreadDelete","processPollEvent","maybeDecryptedEvent","polls","updateThreadRootEvents","_timeline$getEvents","roomEvent","clearEventMetadata","removeFilteredTimelineSet","roots","_this$client2","isThreadRelation","_this$findEventById","addThreadedEvents","addEvents","_this$findEventById2","applyRedaction","eventsByThread","_eventsByThread","threadEvents","_this$cachedThreadRea","relatedEvents","cachedThreadReadReceipts","initialEventsFetched","processLiveEvent","applyNewVisibilityEvent","applyPendingVisibilityEvents","tid","txnToEvent","addLiveEventOptions","aggregateNonLiveRelation","LocalEchoUpdated","isEventEncrypted","getEventForTxnId","remoteEvent","ALLOWED_TRANSITIONS","removedEvent","revertRedactionLocalEcho","RedactionCancelled","assertTimelineSetsAreLive","addLiveEvents","findThreadRoots","neighbouringEvents","_eventsByThread$threa","existingEvent","roomReceipts","_receipt$thread_id","_this$unthreadedRecei","_this$unthreadedRecei2","receiptForMainTimeline","receiptDestination","_this$cachedThreadRea2","oldestThreadedReceiptTs","addEphemeralEvents","eventIds","removedAny","recalculate","membershipEvent","invite_room_state","strippedEvent","addTags","Tags","addAccountData","canInvite","getTypeWarning","isSpaceRoom","isCallRoom","UnstableCall","isElementVideoRoom","ElementVideo","RoomNameType","Actual","Generated","subtype","memberNamesToRoomName","EmptyRoom","ignoreRoomNameEvent","mRoomName","inviteJoinCount","excludedUserIds","otherNames","otherMembers","collator","Collator","thirdPartyInvites","thirdPartyNames","display_name","leftNames","visibilityEventsOnOriginalEvent","originalEventId","newVisibility","visibilityEvent","getOldestThreadedReceiptTs","getLastUnthreadedReceiptFor","unreadThreads","_this$getLiveTimeline","countWithoutMe","EventContext","ourEvent","ourEventIndex","getOurEventIndex","getPaginateToken","paginateTokens","setPaginateToken","atStart","eventMapper","jsonContext","eventsAfter","rank","_opts$pendingEventOrd","processRootEventPromise","redaction","replyCount","updatePendingReplyCount","_currentUserParticipated","_this$lastEvent","updateThreadMetadata","shouldSendLocalEchoReceipt","onEcho","onRedaction","onLocalEcho","onTimelineReset","processReceipts","fetchRootEvent","eventData","setPreferUnstable","_this$client$canSuppo","_this$getReadReceiptF","oldReceiptEventId","receiptEvent","isNewestReply","addRelatedThreadEvent","fetchEditsWhereNeeded","_this$timelineSet$rel","_this$timelineSet$rel2","_this$client$canSuppo2","_this$replayEvents","replayEvents","getRootEventBundledRelationship","processRootEvent","bundledRelationship","_this$lastEvent2","lastPendingEvent","pendingReplyCount","oldLive","newLive","newBackward","oldForward","updateThreadFromRootEvent","initalEventFetchProm","_this$client$canSuppo3","isAnEncryptedThreadMessage","editEvent","_event$event","replyToEvent","_this$lastPendingEven","isCurrentUser","beforeFirstThreadedReceipt","lastReplyId","readUpToId","unthreadedReceipt","_this$timeline","_ev$getId","_this$lastReply$getTs","_this$lastReply","_this$room$getLastUnt","_this$room$getLastUnt2","_this$lastReply$getTs2","_this$lastReply2","unthreadedReceiptTs","beforeLastUnthreadedReceipt","EventEmitterEvents","emitPromised","CurrentlyActive","LastPresenceTs","firstFire","eventsToFire","currently_active","currentlyActive","status_msg","presenceStatusMsg","lastActiveAgo","last_active_ago","lastPresenceTs","eventToFire","oldUrl","getLastActiveTs","generateScope","generateAuthorizationParams","redirectUri","codeVerifier","generateAuthorizationUrl","authorizationUrl","clientId","generateCodeChallenge","generateOidcAuthorizationUrl","homeserverUrl","prompt","urlState","oidcClient","OidcClient","client_id","redirect_uri","authority","response_mode","response_type","stateStore","WebStorageStateStore","sessionStorage","userState","createSigninRequest","url_state","completeAuthorizationCodeGrant","reconstructedUrl","Log","setLogger","SigninResponse","stateString","OidcError","MissingOrInvalidStoredState","signInState","SigninState","fromStorageString","signinResponse","processSigninResponse","validateStoredUserState","validateBearerTokenResponse","validateIdToken","id_token","normalizedTokenResponse","expires_at","normalizeBearerTokenResponseTokenType","oidcClientSettings","tokenResponse","idTokenClaims","errorType","CodeExchangeFailed","issuerOpenIdConfigUrl","issuerWellKnownResponse","issuerWellKnown","validatedIssuerConfig","validateAuthMetadata","OidcClientSettingsStore","metadataService","MetadataService","signingKeys","getSigningKeys","DEVICE_CODE_SCOPE","urlHasCommonBase","urlStr","registerOidcClient","delegatedAuthConfig","clientMetadata","registration_endpoint","DynamicRegistrationNotSupported","grantTypes","grant_types_supported","commonBase","clientUri","client_name","clientName","client_uri","response_types","grant_types","redirect_uris","redirectUris","id_token_signed_response_alg","token_endpoint_auth_method","application_type","applicationType","contacts","logo_uri","logoUri","policy_uri","policyUri","tos_uri","tosUri","DynamicRegistrationFailed","DynamicRegistrationInvalid","OidcTokenRefresher","oidcClientReady","initialiseOidcClient","_config$signingKeys","doRefreshAccessToken","inflightRefreshRequest","getNewTokens","persistTokens","refreshTokenState","session_state","useRefreshToken","timeoutInSeconds","isRecord","requiredStringProperty","wellKnown","optionalStringProperty","optionalStringArrayProperty","requiredArrayValue","OpSupport","isValid","decodeIdToken","idToken","claims","iss","aud","exp","InvalidIdToken","isValidBearerTokenResponse","InvalidBearerTokenResponse","RULEKINDS_IN_ORDER","Override","ContentSpecific","SenderSpecific","Underride","DEFAULT_OVERRIDE_RULES","conditions","EventPropertyIs","SenderNotificationPermission","Notify","set_tweak","EventMatch","RoomServerAcl","UserDefinedRules","EXPECTED_DEFAULT_OVERRIDE_RULE_IDS","Master","SuppressNotices","InviteToSelf","MemberEvent","IsUserMention","ContainsDisplayName","IsRoomMention","AtRoomNotification","Tombstone","DEFAULT_UNDERRIDE_RULES","CallStarted","Sound","EXPECTED_DEFAULT_UNDERRIDE_RULE_IDS","IncomingCall","EncryptedDM","DM","Message","EncryptedMessage","mergeRulesWithDefaults","incomingRules","defaultRules","orderedRuleIds","incomingDefaultRules","incomingCustomRules","insertDefaultPushRule","newRules","nextExpectedRuleIdIndex","ruleIndex","actionListToActionsObject","actionList","actionObj","override","underride","toRemoveKeys","parsedKeys","ruleset","partsForDottedKey","matchingRuleFromKindSet","kindset","rawrule","templateRuleToRaw","ruleMatchesEvent","tprule","eventFulfillsCondition","eventFulfillsEventMatchCondition","eventFulfillsEventPropertyIsCondition","EventPropertyContains","eventFulfillsEventPropertyContains","eventFulfillsDisplayNameCondition","RoomMemberCount","eventFulfillsRoomMemberCountCondition","eventFulfillsSenderNotifPermCondition","CallStartedPrefix","eventFulfillsCallStartedCondition","memberCount","ineq","rhs","_room$currentState","pat","valueForDottedKey","createCachedRegex","_cond","cachedGlobToRegex","firstPart","isNullOrUndefined","matchingRuleForEventWithRulesets","rulesets","pushActionsForEventAndRulesets","_rule$conditions","ContainsUserName","actionsForEvent","getPushRuleById","_result$rule","getPushRuleAndKindById","_this$client$pushRule","LOWERCASE","UPPERCASE","DIGITS","secureRandomStringFrom","randomValueCutoff","entropyBuffer","entropyBufferPos","randomByte","QUEUE_MESSAGES","retryAlgorithm","queueAlgorithm","queueName","peekNextEvent","queues","procFn","removeNextEvent","processQueue","waitTimeMs","clearQueue","disableQueue","startProcessingQueues","activeQueues","SECRET_STORAGE_ALGORITHM_V1_AES","accountDataAdapter","getDefaultKeyId","_defaultKey$key","defaultKey","setDefaultKeyId","keyId","addKey","keyInfo","mac","calculateKeyCheck","getKey","hasKey","checkKey","trimTrailingEquals","secret","defaultKeyId","encryption","getSecretStorageKey","secretInfo","encInfo","ciphertext","decryption","returned","privateKey","encryptAESSecretStorageItem","decryptAESSecretStorageItem","ZERO_STR","clearTimeouts","refreshTimeout","howLong","ExtensionE2EE","when","ExtensionState","PreProcess","onRequest","isInitial","onResponse","device_lists","processDeviceLists","processKeyCounts","device_one_time_keys_count","onSyncCompleted","ExtensionToDevice","extReq","cancelledKeyVerificationTxns","preprocessToDeviceMessages","mapToDeviceEvent","toDeviceEvent","ExtensionAccountData","PostProcess","processGlobalAccountData","accountDataEvents","mapEvents","globalAccountData","prevEventsMap","accountDataEvent","PushRules","prevEvent","ExtensionTyping","processEphemeralEvents","ExtensionReceipts","syncOpts","defaultClientOpts","defaultSyncApiOpts","SlidingSyncEvent","Lifecycle","onLifecycle","RoomData","onRoomData","extensions","ext","registerExtension","roomData","_createAndReEmitRoom","processRoomData","SlidingSyncState","Complete","purgeNotifications","lastPos","updateSyncState","oldSyncToken","nextSyncToken","catchingUp","RequestFinished","failCount","Reconnecting","shouldAbortSync","_this$syncStateData","syncStateData","registerStateListeners","_this$client$getUser","required_state","ensureNameEvent","ephemeralEvents","knownEvents","oldEvents","newEvents","seenKnownEvent","recvEvent","notification_count","highlight_count","invited_count","joined_count","invite_state","inviteStateEvents","_roomData$prev_batch","num_live","addNotifications","processRoomEvent","onCryptoEvent","promiseMapSeries","stateEventList","timelineEventList","numLive","liveTimelineEvents","resolveInvites","resolveInvitesToProfiles","requestedProfileInfo","inviteEvent","_err","newState","old","timelineEvent","notifEvents","_this$client$getNotif","ephEvents","MSC3575_WILDCARD","MSC3575_STATE_KEY_ME","MSC3575_STATE_KEY_LAZY","SlidingList","replaceList","setModified","isModified","updateListRange","newRanges","_list$filters","_list$ranges","roomIndexToRoomId","getList","forceIncludeAllParams","isIndexInRange","SlidingSync","lists","roomSubscriptionInfo","timeoutMS","addCustomSubscription","customSubscriptions","useCustomSubscription","roomIdToCustomSubscription","confirmedRoomSubscriptions","getListData","getListParams","setListRanges","resend","setList","existingList","listModifiedCount","getRoomSubscriptions","desiredRoomSubscriptions","modifyRoomSubscriptions","modifyRoomSubscriptionInfo","rs","getExtensionRequest","extName","onPreExtensionsResponse","onPostExtensionsResponse","invokeRoomDataListeners","invokeLifecycleListeners","shiftRight","listKey","shiftLeft","removeEntry","addEntry","processListOps","gapIndex","listData","ops","room_ids","_this$abortController","needsResend","txnIdDefers","resolveTransactionDefers","txnIndex","_this$abortController2","terminated","List","resetup","_this$abortController3","currentPos","doNotUpdateList","_resp$lists","_resp$rooms","_resp$extensions","reqLists","reqBody","newSubscriptions","unsubscriptions","unsubscribe_rooms","room_subscriptions","customSubName","pendingReq","listKeysWithUpdates","_list$ops","setA","setB","ReceiptAccumulator","setUnthreaded","unthreadedReadReceipts","setThreaded","threadedReadReceipts","allUnthreaded","allThreaded","receiptsForThread","consumeEphemeralEvents","buildAccumulatedReceiptEvent","receiptEventContent","receiptData","Category","SyncAccumulator","maxTimelineEntries","accumulate","syncResponse","fromDatabase","accumulateRooms","accumulateAccountData","account_data","accumulateRoom","knock","knockRooms","accumulateInviteState","accumulateKnockState","inviteRooms","accumulateJoinState","joinRooms","currentData","hasAdded","knock_state","_data$ephemeral","_data$state","_data$orgMatrixMsc","_data$timeline","_currentState","_timeline","_accountData","_unreadNotifications","_unreadThreadNotifications","_summary","_receipts","unread_notifications","_sum$HEROES_KEY","_sum$JOINED_COUNT_KEY","_sum$INVITED_COUNT_KE","HEROES_KEY","INVITED_COUNT_KEY","JOINED_COUNT_KEY","ephemeral","limited","_data$timeline$prev_b","transformedEvent","_e$unsigned","_localTs","getJSON","forDatabase","roomJson","evType","msgData","rollBackState","prevStateEvent","deepCopy","accData","roomsData","eventMap","MSC2716_ROOM_VERSIONS","getFilterName","SetPresence","initialSyncLimit","pollTimeout","_roomId","recoverFromSyncStartupError","savedSyncPromise","buildDefaultFilter","startKeepAlives","markerEvent","onMarkerStateEvent","HistoryImportedWithinTimeline","_data$rooms","leaveRooms","mapSyncResponseToRoomArray","leaveObj","isBrandNewRoom","mapAndInjectRoomEvents","processEventsForNotifs","_this$_peekRoom","_peekRoom","_this$_peekRoom2","oldStateEvents","presenceEvent","peekPoll","peekRoom","keepaliveProm","_globalThis$window","_globalThis$window$ad","onOnline","doSync","savedSyncTokenPromise","savedSync","syncFromCache","prepareLazyLoadingForSync","currentSyncRequest","firstSyncFilter","savedSyncToken","initialFilter","doSyncRequest","_globalThis$window2","_globalThis$window2$r","keepAliveTimer","connectionReturnedDefer","syncEventData","processSyncResponse","storeIsInvalid","syncOptions","onSyncError","failedSyncCount","SyncUnexpectedError","hasSyncedBefore","Stopped","getSyncParams","getGuestFilter","disablePresence","set_presence","Offline","_cacheBuster","keepAlivePromise","Catchup","_data$presence","_data$account_data","_this$syncOpts$crypto","_data$device_unused_f","to_device","toDeviceMessages","inviteObj","mapSyncEventsFormat","_joinObj$UNREAD_THREA","joinObj","stateAfterEvents","eventsFormingFinalState","_joinObj$unread_notif","_joinObj$unread_notif2","unreadThreadNotifications","unreadNotification","_unreadNotification$n","hasNoNotifications","_unreadNotification$h","_syncEventData$oldSyn","emitEvent","knockObj","_client$getNotifTimel","device_unused_fallback_key_types","pokeKeepAlive","connDidFail","_this$abortController4","success","unsafeProp","findEncryptionEvent","wrappedRoom","stateAfterEventList","eitherStateEventList","_client$getUser","VerificationMethod","aesKey","hmacKey","deriveKeys","verify","TextDecoder","ivStr","encodedData","hmac","zeroSalt","hkdfkey","aesProm","hmacProm","MINIMUM_MATRIX_VERSION","MAXIMUM_MATRIX_VERSION","CallState","CallType","CallDirection","CallParty","CallEvent","CallErrorCode","FALLBACK_ICE_SERVER","CALL_TIMEOUT_MS","CallError","genCallID","getCodecParamMods","mediaType","codec","enableDtx","maxAverageBitrate","getTransceiverKey","MatrixCall","_opts$forceTURN","Fledgling","candidatesEnded","sdpMid","callHasEnded","queueCandidate","_this$peerConn","peerConn","iceGatheringState","LocalOfferFailed","Local","successor","getUserMediaFailed","NoUserMedia","placeCallFailed","IceFailed","_this$peerConn2","_this$peerConn3","_this$peerConn$iceCon","_this$peerConn4","_this$peerConn5","_this$peerConn8","iceConnectionState","connectionState","iceDisconnectedTimeout","iceReconnectionTimeOut","callLengthInterval","callStartTime","LengthChanged","_this$peerConn6","_this$peerConn7","restartIce","hangup","_this$peerConn9","_this$peerConn10","_this$peerConn11","getRemoteFeeds","setAudioVideoMuted","_this$peerConn12","signalingState","streams","stream","pushRemoteFeed","removeTrackListeners","onRemoveTrack","getTracks","deleteFeedByStream","DataChannel","channel","CreateOffer","opponentVersion","queueGotLocalOffer","partyIdMatches","Ringing","Remote","UserHangup","party_id","opponentPartyId","InviteSent","Inbound","AnsweredElsewhere","invitee","ourPartyId","opponentDeviceId","opponentSessionId","groupCallId","isOnlyDataChannelAllowed","placeVoiceCall","placeCall","placeVideoCall","createDataChannel","dataChannel","getOpponentMember","opponentMember","getOpponentDeviceId","getOpponentSessionId","opponentCanBeTransferred","opponentCaps","opponentSupportsDTMF","getRemoteAssertedIdentity","remoteAssertedIdentity","hasUserMediaVideoSender","hasRemoteUserMediaVideoTrack","Video","Voice","hasLocalUserMediaVideoTrack","_this$localUsermediaS","localUsermediaStream","getVideoTracks","_feed$stream","SDPStreamMetadataPurpose","Usermedia","hasLocalUserMediaAudioTrack","_this$localUsermediaS2","getAudioTracks","hasRemoteUserMediaAudioTrack","_feed$stream2","hasUserMediaAudioSender","_this$transceivers$ge","transceivers","_this$transceivers$ge2","localUsermediaFeed","getLocalFeeds","localScreensharingFeed","Screenshare","_this$localUsermediaF","localScreensharingStream","_this$localScreenshar","remoteUsermediaFeed","remoteScreensharingFeed","remoteUsermediaStream","_this$remoteUsermedia","remoteScreensharingStream","_this$remoteScreensha","getFeedByStreamId","streamId","getFeeds","feeds","isLocal","initOpponentCrypto","_this$getOpponentMemb","hasOpponentDeviceInfo","GroupCallUnknownDeviceError","getLocalSDPStreamMetadata","updateStreamIds","localFeed","sdpMetadataStreamId","audio_muted","isAudioMuted","video_muted","isVideoMuted","noIncomingFeeds","opponentSupportsSDPStreamMetadata","pushRemoteFeedWithoutMetadata","remoteSDPStreamMetadata","audioMuted","videoMuted","CallFeed","FeedsChanged","_this$feeds$find","oldRemoteStream","pushNewLocalFeed","addToPeerConnection","setTracksEnabled","pushLocalFeed","callFeed","tKey","transceiver","replaceTrack","addTrack","newTransceiver","getTransceivers","removeLocalFeed","audioTransceiverKey","videoTransceiverKey","transceiverKey","removeTrack","stopScreensharingStream","deleteFeed","deleteAllFeeds","dispose","getCurrentCallStats","callStatsAtEnd","collectCallStats","statsReport","getStats","initWithInvite","_this$feeds$find2","sdpStreamMetadata","SDPStreamMetadataKey","updateRemoteSDPStreamMetadata","createPeerConnection","PeerConnectionCreated","chooseOpponent","setRemoteDescription","offer","addBufferedIceCandidates","SetRemoteDescription","remoteStream","ringingTimer","_this$stats","hangupParty","Ended","stopAllMedia","removeStatsReportGatherer","Hangup","lifetime","onState","initWithHangup","shouldAnswerWithMediaType","wantedValue","valueOfTheOtherSide","answer","audio","video","inviteOrAnswerSent","waitForLocalAVStream","WaitLocalMedia","prevState","answerWithAudio","answerWithVideo","_this$client$getDevic","getUserMediaStream","answerWithCallFeeds","callFeeds","queueGotCallFeedsForAnswer","replacedBy","newCall","Outbound","suppressEvent","sendVoipEvent","CallHangup","CallReject","upgradeCall","getAudio","getVideo","updateLocalUsermediaStream","isScreensharing","setScreensharingEnabled","setScreensharingEnabledWithoutMetadataSupport","audioTransceiver","videoTransceiver","getScreensharingStream","_this$localUsermediaS3","_this$transceivers$ge4","_this$transceivers$ge3","forceAudio","forceVideo","audioEnabled","remoteOnHold","videoEnabled","oldSender","added","setLocalVideoMuted","muted","_this$localUsermediaF3","_this$localUsermediaF2","stopVideoTrackTimer","hasVideoDevice","isLocalVideoMuted","updateMuteStatus","sendMetadataUpdate","_this$localUsermediaF4","_this$localUsermediaF5","setMicrophoneMuted","_this$localUsermediaF6","hasAudioDevice","isMicrophoneMuted","_this$localUsermediaF7","_this$localUsermediaF8","isRemoteOnHold","setRemoteOnHold","onHold","RemoteHoldUnhold","isLocalOnHold","callOnHold","currentDirection","sendDtmfDigit","getSenders","_sender$track","dtmf","insertDTMF","micShouldBeMuted","vidShouldBeMuted","CallSDPStreamMetadataChangedPrefix","gotCallFeedsForInvite","requestScreenshareFeed","addTransceiver","sendAnswer","answerContent","sdp","localDescription","discardCount","discardDuplicateCandidates","CallAnswer","SendAnswer","UnknownDevices","sendCandidateQueue","responsePromiseChain","gotCallFeedsForAnswer","mungeSdp","mods","parseSdp","media","payloadTypeToCodecMap","codecToPayloadTypeMap","rtp","extraConfig","fmtp","writeSdp","createOffer","createAnswer","CreateAnswer","getRidOfRTXCodecs","setLocalDescription","SetLocalDescription","onRemoteIceCandidatesReceived","fromPartyId","addIceCandidates","bufferedCandidates","remoteCandidateBuffer","onAnswerReceived","isSettingRemoteAnswerPending","CallSelectAnswer","selected_party_id","onSelectAnswerReceived","selectedPartyId","onNegotiateReceived","polite","readyForOffer","makingOffer","offerCollision","ignoreOffer","prevLocalOnHold","_localDescription","CallNegotiate","newLocalOnHold","LocalHoldUnhold","HoldUnhold","recursivelyAssign","_streamId","onSDPStreamMetadataChangedReceived","onAssertedIdentityReceived","asserted_identity","AssertedIdentityChanged","wrappedGotLocalOffer","gotLocalOffer","getLocalOfferFailed","CallInvite","_localDescription2","_localDescription3","SignallingFailed","SendInvite","inviteTimeout","InviteTimeout","RTCRtpReceiver","RTCRtpSender","screenshareVideoTransceiver","setCodecPreferences","recvCodecs","codecs","sendCodecs","mimeType","realContent","conf_id","_this$getOpponentMemb2","toDeviceSeq","sender_session_id","dest_session_id","uuidv4","SendVoipEvent","_this$getOpponentMemb3","candidateSendQueue","candidateSendTries","newQueue","transfer","targetUserId","profileInfo","replacementId","replacement_id","target_user","create_call","CallReplaces","Transferred","transferToCall","transferTargetCall","_transferTargetCall$g","_this$getOpponentMemb4","targetProfileInfo","opponentUserId","transfereeProfileInfo","newCallId","bodyToTransferTarget","await_call","bodyToTransferee","hangupReason","shouldEmit","_this$stats2","calls","stopUserMediaStream","checkForErrorListener","CallCandidates","_this$client$getDevic2","placeCallWithCallFeeds","_this$stats3","pc","RTCPeerConnection","iceTransportPolicy","iceServers","bundlePolicy","onIceConnectionStateChanged","onSignallingStateChanged","gotLocalIceCandidate","onIceGatheringStateChange","onTrack","onNegotiationNeeded","onDataChannel","opponentMemberId","addStatsReportGatherer","_getMember","_this$stats4","updateOpponentMember","sdpMLineIndex","addIceCandidate","hasPeerConnection","initStats","peerId","tracks","_window$RTCPeerConnec","RTCSessionDescription","RTCIceCandidate","mediaDevices","optionsForceTURN","CallEventHandlerEvent","currentEventBuffer","callEventBuffer","eventBufferPromiseChain","evaluateEventBuffer","nextSeqByCall","toDeviceEventBuffers","nextEvent","candidateEventsByCall","onSync","onRoomTimeline","onToDeviceEvent","eventBuffer","callEvents","ignoreCallIds","handleCallEvent","_getGroupCallById","ReceivedVoipEvent","callRoomId","getGroupCallById","senderId","groupCall","GroupCallEvent","weSentTheEvent","_createNewMatrixCall2","onHangupReceived","onRejectReceived","onAnsweredElsewhere","CallAssertedIdentity","CallAssertedIdentityPrefix","CallSDPStreamMetadataChanged","_this$client$getTurnS","_createNewMatrixCall","_groupCall","timeUntilTurnCresExpire","getGroupCallStats","_groupCall2","GroupCallErrorCode","UnknownDevice","existingCall","thisCall","_call$getOpponentMemb","isCalling","Incoming","audioContext","SPEAKING_THRESHOLD","CallFeedEvent","NewStream","connected","analyser","measuringVolumeActivity","getFloatFrequencyData","frequencyBinCount","maxVolume","volume","speakingVolumeSamples","VolumeChanged","newSpeaking","speakingThreshold","speaking","Speaking","volumeLooperTimeout","volumeLooper","updateStream","hasAudioTrack","initVolumeMeasuring","onCallState","_connected","ConnectedChanged","oldStream","newStream","wasMeasuringVolumeActivity","onAddTrack","measureVolumeActivity","AudioContext","createAnalyser","fftSize","smoothingTimeConstant","createMediaStreamSource","_callRoom$getMember","callRoom","isSpeaking","setNewStream","MuteStateChanged","setSpeakingThreshold","userMediaStreams","screensharingStreams","_this$stream","_this$call","_audioContext","_disposed","Disposed","disposed","getLocalVolume","localVolume","setLocalVolume","LocalVolumeChanged","ConnectionStats","ConnectionStatsBuilder","buildBandwidthReport","availableIncomingBitrate","availableOutgoingBitrate","download","TransportStatsBuilder","buildReport","report","conferenceStatsTransport","isFocus","localUsedCandidate","localCandidateId","remoteUsedCandidate","remoteCandidateId","localIp","localCandidateType","candidateType","remoteCandidateType","networkType","rtt","currentRoundTripTime","NaN","MediaSsrcHandler","local","remote","findMidBySsrc","ssrc","ssrcToMid","ssrcs","_m$ssrcs","getSsrcToMidMap","MediaTrackHandler","getLocalTracks","getTackById","trackId","getLocalTrackIdByMid","_transceiver$sender","getRemoteTrackIdByMid","_transceiver$receiver","getActiveSimulcastStreams","getTransceiverByTrackId","MediaTrackStats","packetsTotal","packetsLost","isDownloadStream","concealedAudio","totalAudioDuration","setLoss","loss","getLoss","setResolution","resolution","getResolution","setFramerate","framerate","getFramerate","setBitrate","bitrate","getBitrate","setCodec","codecShortType","getCodec","resetBitrate","alive","isAlive","isMuted","setJitter","jitter","getJitter","setAudioConcealment","concealedAudioDuration","audioConcealment","getAudioConcealment","MediaTrackStatsHandler","mediaSsrcHandler","mediaTrackHandler","findTrack2Stats","trackID","trackIdentifier","trackStats","track2stats","findLocalVideoTrackStats","getTrack2stats","findTransceiverByTrackId","ValueFormatter","getNonNegativeValue","imput","TrackStatsBuilder","buildFramerateResolution","frameHeight","frameWidth","frameRate","framesPerSecond","calculateSimulcastFramerate","layer","timeMs","framesSent","buildCodec","codecId","buildBitrateReceived","calculateBitrate","bytesReceived","buildBitrateSend","bytesSent","buildPacketsLost","packetsNow","packetsBefore","packetsDiff","packetsLostNow","packetsLostBefore","packetsLostDiff","bytesNowAny","bytesBeforeAny","nowTimestamp","beforeTimestamp","bytesNow","bytesBefore","bytesProcessed","bitrateKbps","setTrackStatsState","buildTrackSummary","trackStatsList","videoTrackSummary","maxJitter","maxPacketLoss","totalAudio","audioTrackSummary","remoteTrackList","audioTrackList","trackSummary","_stats$getAudioConcea","_stats$getAudioConcea2","buildJitter","jitterStr","buildAudioConcealment","totalSamplesDuration","totalSamplesReceived","concealedSamples","ConnectionStatsReportBuilder","totalPackets","lostPackets","bitrateDownload","bitrateUpload","resolutions","framerates","audioBitrateDownload","audioBitrateUpload","videoBitrateDownload","videoBitrateUpload","totalConcealedAudio","audioConcealmentForTrack","packetLoss","calculatePacketLoss","totalAudioConcealment","CallFeedStatsReporter","buildCallFeedReport","rtpTransceivers","_t$sender","buildTrackStats","_track$getSettings","_track$getConstraints","settingDeviceId","getSettings","constrainDeviceId","getConstraints","expandCallFeedReport","audioTracks","videoTracks","feedStats","CallStatsReportGatherer","onSignalStateChange","processStats","isFirstCollection","previousStatsReport","receivedMedia","receivedAudioMedia","receivedVideoMedia","statsPromise","_this$connectionStats","_this$connectionStats2","currentStatsReport","processStatsReport","handleError","connectionStats","_this$currentStatsRep","byteSentStatsReport","nominated","bandwidth","remoteSource","emitByteSendReport","emitCallFeedReport","processAndEmitConnectionStatsReport","setActive","getActive","emitConnectionStatsReport","stopProcessingStats","currentRemoteDescription","currentLocalDescription","setOpponentMemberId","StatsReportEmitter","byteSentStats","StatsReport","BYTE_SENT_STATS","CONNECTION_STATS","CALL_FEED_REPORT","emitSummaryStatsReport","SUMMARY_STATS","SummaryStatsReportGatherer","allSummary","summaryTotalCount","peerConnectionsCount","summaryCounter","receivedAudio","receivedVideo","countTrackListReceivedMedia","countConcealedAudio","buildMaxJitter","buildMaxPacketLoss","percentageReceivedMedia","percentageReceivedVideoMedia","percentageReceivedAudioMedia","percentageConcealedAudio","peerConnections","extendSummaryReport","callParticipants","userEntry","device","opponentDevicesInCall","opponentUsersInCall","diffDevicesToPeerConnections","ratioPeerConnectionToDevices","hasReceivedAudio","hasReceivedVideo","GroupCallStats","reports","gatherers","hasStatsReportGatherer","peerConnection","getStatsReportGatherer","_this$getStatsReportG","summaryStatsReportGatherer","GroupCallIntent","GroupCallType","GroupCallTerminationReason","GroupCallStatsReportEvent","GroupCallError","GroupCallState","DEVICE_TIMEOUT","getCallUserId","isCallWithoutVideoAndAudio","useLivekit","_room$currentState$ge","_room$currentState$ge2","ByteSentStats","participants","SummaryStats","localCallFeed","forEachCall","CallFeedStats","LocalCallFeedUninitialized","_newCall$getOpponentM","_this$calls$get","deviceMap","prevCall","initCall","callExpected","CallsChanged","needsRetry","participantMap","callMap","retriesMap","retryCallCounts","participant","_retriesMap$get","_retriesMap","wantsOutgoingCall","placeOutgoingCalls","currentUserMediaFeed","getUserMediaFeed","remoteFeedChanged","currentCallForUserDevice","addUserMediaFeed","replaceUserMediaFeed","removeUserMediaFeed","currentScreenshareFeed","getScreenshareFeed","addScreenshareFeed","replaceScreenshareFeed","removeScreenshareFeed","_oldState","_call$getOpponentMemb2","_call$getOpponentMemb3","_call$getOpponentMemb4","disposeCall","topAvg","nextActiveSpeaker","userMediaFeeds","avg","activeSpeaker","ActiveSpeakerChanged","updateParticipants","Entered","updateMemberState","_livekitServiceURL","creationTs","GroupCallPrefix","ParticipantsChanged","onParticipantsChanged","GroupCallStateChanged","onStateChanged","LocalScreenshareStateChanged","onLocalFeedsChanged","allowCallWithoutVideoAndAudio","GroupCallEventHandlerEvent","Outgoing","sendCallStateEvent","groupCallState","updateLivekitServiceURL","prevValue","_participants","participantStateEqual","screensharing","mapsEqual","deviceMapsEqual","_creationTs","enteredViaAnotherSession","_enteredViaAnotherSession","localScreenshareFeed","hasLocalParticipant","_this$participants$ge","_this$participants$ge2","_this$participants$ge3","initLocalCallFeed","InitializingLocalCallFeed","initCallFeedPromise","initLocalCallFeedInternal","MediaStream","initWithAudioMuted","initWithVideoMuted","LocalCallFeedInitialized","enter","onIncomingCall","retryCallLoopInterval","onRetryCallLoop","retryCallInterval","onActiveSpeakerLoop","activeSpeakerLoopInterval","activeSpeakerInterval","localDesktopCapturerSourceId","stopAllStreams","transmitTimer","participantsExpirationTimer","emitStateEvent","existingStateEvent","CallEnded","sendUpdatesBefore","pttMaxTransmitTime","_call$localUsermediaF","sendUpdates","updates","checkAudioPermissionIfNecessary","LocalMuteStateChanged","onTrackEnded","desktopCapturerSourceId","throwOnFail","callsChanged","_this$calls$get2","NewSession","PlaceCallFailed","getMemberStateEvents","onCallFeedsChanged","onCallStateChanged","onCallHangup","onCallReplaced","callHandlers","usermediaFeed","screenshareFeed","UserMediaFeedsChanged","existingFeed","replacementFeed","feedIndex","screenshareFeeds","ScreenshareFeedsChanged","localMember","entered","nextExpiration","validDevices","session_id","expires_ts","updateDevices","_event$getContent","otherCalls","newDevices","newCalls","addDeviceToMemberState","resendMemberStateTimer","cleanMemberState","myDevices","last_seen_ts","userID","statsCollectIntervalTime","onConnectionStats","onByteSentStats","onSummaryStats","onCallFeedReport","setGroupCallStatsInterval","createGroupCallForRoom","currentGroupCall","createGroupCallFromRoomStateEvent","onRoomsChanged","onRoomStateChanged","getRoomDeferred","roomDeferreds","resolveFunc","sortedCallEvents","callEvent","callType","callIntent","maxPacketLifeTime","maxRetransmits","MediaHandlerEvent","restoreMediaSettings","audioInput","videoInput","setAudioInput","updateLocalUsermediaStreams","setAudioSettings","audioSettings","setVideoInput","setMediaInputs","callMediaStreamParams","localUserMediaStream","LocalStreamsChanged","enumerateDevices","reusable","getMediaStreamPromise","getUserMediaStreamInternal","shouldRequestAudio","shouldRequestVideo","canReuseStream","_this$localUserMediaS","_this$localUserMediaS2","_this$localUserMediaS3","constraints","getUserMediaContraints","getUserMedia","mediaStream","_this$localUserMediaS4","getTrackById","screenshareConstraints","getScreenshareContraints","getDisplayMedia","matchingStream","isWebkit","webkitGetUserMedia","ideal","autoGainControl","echoCancellation","noiseSuppression","mandatory","chromeMediaSource","chromeMediaSourceId","KEY_SEPARATOR","normalizeLanguageKey","language","getNormalizedLanguageKeys","languageKeys","normalizedLanguage","languageParts","_PostmessageTransport","_WidgetApiDirection","_WidgetApiAction","_Capabilities","_ApiVersion","_WidgetEventCapability","_GetOpenIDAction","_SimpleObservable","_Symbols","_UpdateDelayedEventAction","_regeneratorRuntime","Op","$Symbol","iteratorSymbol","asyncIteratorSymbol","asyncIterator","toStringTagSymbol","define","innerFn","outerFn","tryLocsList","protoGenerator","Generator","generator","makeInvokeMethod","tryCatch","ContinueSentinel","GeneratorFunctionPrototype","IteratorPrototype","NativeIteratorPrototype","Gp","defineIteratorMethods","_invoke","AsyncIterator","PromiseImpl","record","__await","unwrapped","previousPromise","callInvokeWithMethodAndArg","doneResult","delegate","delegateResult","maybeInvokeDelegate","sent","_sent","dispatchException","abrupt","resultName","nextLoc","pushTryEntry","locs","tryLoc","catchLoc","finallyLoc","afterLoc","tryEntries","resetTryEntry","completion","iteratorMethod","isGeneratorFunction","genFun","mark","awrap","skipTempReset","rootRecord","rval","handle","caught","hasCatch","hasFinally","finallyEntry","complete","thrown","delegateYield","asyncGeneratorStep","_throw","_asyncToGenerator","_toPropertyKey","prim","_toPrimitive","_asyncIterator","retry","AsyncFromSyncIterator","AsyncFromSyncIteratorContinuation","thr","ClientWidgetApi","_EventEmitter","_feedStateUpdate","_flushRoomState","_feedToDevice","_feedEvent","_handleDownloadFile","_handleUploadFile","_handleGetMediaConfig","_handleUserDirectorySearch","_handleReadRelations","_handleUnwatchTurnServers","_handleWatchTurnServers","_pollTurnServers","_handleSendToDevice","_handleReadEvents","_supportsUpdateState","_getWidgetVersions","widget","iframe","driver","PostmessageTransport","WidgetApiDirection","ToWidget","targetOrigin","handleMessage","onIframeLoad","capability","allowedCapabilities","hasCapability","Symbols","AnyRoom","allowedEvents","matchesAsRoomEvent","EventDirection","matchesAsStateEvent","matchesAsToDeviceEvent","Receive","matchesAsRoomAccountData","isStopped","_callee","_context","cachedWidgetVersions","SupportedApiVersions","supported_versions","t0","requestedCaps","Capabilities","validateCapabilities","allowedCaps","allowCapabilities","requested","_this$allowedEvents","_this3","_step2","_iterator2","WidgetEventCapability","findEventCapabilities","NotifyCapabilities","approved","_step3","_iterator3","isTimelineCapability","getTimelineRoomIDFromCapability","_step4","_iterator4","getKnownRooms","pushRoomState","viewedRoomId","canUseRoomTimeline","waitForIframeLoad","beginCapabilities","contentLoadedWaitTimer","contentLoadedActionSent","CurrentApiVersions","_callee2","_context2","getWidgetVersions","UnstableApiVersion","MSC2762_UPDATE_STATE","_request$data","_this4","newlyRequested","_request$data2","_request$data3","_this5","MSC2931Navigate","onErr","handleDriverError","navigate","_this6","replyState","OpenIDCredentials","original_request_id","requestId","replyError","OpenIDRequestState","Blocked","SimpleObservable","PendingUserConfirmation","Allowed","askOpenID","_this7","readRoomAccountData","canReceiveRoomAccountData","evs","_callee3","askRoomIds","_iterator5","_step5","_stateKey","_this8","_context3","canReceiveStateEvent","canReceiveRoomEvent","readRoomEvents","supportsUpdateState","readRoomTimeline","readRoomState","_x","_this9","sendEventPromise","isDelayedEvent","canSendStateEvent","_request$data$delay","_request$data$parent_","sendDelayedEvent","_request$data$delay2","_request$data$parent_2","canSendRoomEvent","sentEvent","_this10","_callee4","_context4","canSendToDeviceEvent","_x2","_callee5","initialServer","_iteratorAbruptCompletion","_didIteratorError","_iteratorError","_context5","UpdateTurnServers","_x3","_x4","_callee6","_yield$turnServers$ne","_context6","pollTurnServers","_x5","_callee7","_context7","_x6","_callee8","_this11","_context8","readEventRelations","event_type","_x7","_callee9","_context9","MSC3973UserDirectorySearch","_x8","_callee10","_context10","MSC4039UploadFile","_x9","_callee11","_context11","uploadFile","contentUri","_x10","_callee12","_context12","MSC4039DownloadFile","downloadFile","_x11","processError","actionEv","WidgetApiFromWidgetAction","ContentLoaded","handleContentLoadedAction","replyVersions","handleSendEvent","handleSendToDevice","GetOpenIDCredentials","handleOIDC","handleNavigate","MSC2974RenegotiateCapabilities","handleCapabilitiesRenegotiate","MSC2876ReadEvents","handleReadEvents","WatchTurnServers","handleWatchTurnServers","UnwatchTurnServers","handleUnwatchTurnServers","MSC3869ReadRelations","handleReadRelations","handleUserDirectorySearch","BeeperReadRoomAccountData","handleReadRoomAccountData","MSC4039GetMediaConfigAction","handleGetMediaConfig","MSC4039UploadFileAction","handleUploadFile","MSC4039DownloadFileAction","handleDownloadFile","handleUpdateDelayedEvent","theme","ThemeChange","lang","LanguageChange","TakeScreenshot","isVisible","UpdateVisibility","WidgetConfig","ButtonClicked","CloseModalWidget","_callee13","currentViewedRoomId","_rawEvent$content","_context13","setViewedRoomId","_x12","_x13","_callee14","_context14","canReceiveToDeviceEvent","_x14","_x15","_callee15","_iterator6","_step6","eventTypeMap","_iterator7","_step7","stateKeyMap","_context15","pushRoomStateTasks","pushRoomStateResult","UpdateState","flushRoomStateTask","_step8","_this12","_iterator8","_loop","cap","EventKind","_cap$keyStr","_this12$flushRoomStat","keyStr","_step9","_iterator9","flushRoomState","_callee16","_context16","_x16","_WidgetType","_ModalWidgetActions","_awaitAsyncGenerator","_OverloadYield","_AsyncGenerator","back","overloaded","nextKey","settle","WidgetApi","_downloadFile","_uploadFile","_getMediaConfig","_searchUserDirectory","_readEventRelations","widgetId","clientOrigin","FromWidget","approvedCapabilities","requestedCapabilities","capabilitiesFinished","supportsMSC2974Renegotiate","forStateEvent","forToDeviceEvent","forRoomEvent","forRoomMessageEvent","forRoomAccountData","rdata","handlerFn","sticker","SendSticker","UpdateAlwaysOnScreen","MatrixWidgetType","Custom","OpenModalWidget","parentDelayId","roomIds","getClientVersions","MSC3869","buttonId","BuiltInModalButtonID","SetModalButtonEnabled","setTurnServer","onUpdateTurnServers","turnServerWatchers","searchTerm","MSC3973","MSC4039","MSC2974","handleCapabilities","cachedClientVersions","MSC2871","WidgetDriver","_WidgetApi","_ClientWidgetApi","_IWidgetApiErrorResponse","_WidgetKind","_ModalButtonKind","_url","_utils","_Widget","_WidgetParser","_urlTemplate","_WidgetDriver","MatrixApiVersion","Prerelease1","Prerelease2","MSC2762","MSC2873","MSC2931","MSC2876","MSC3819","MSC3846","StickerpickerCapabilities","StickerSending","VideoConferenceCapabilities","AlwaysOnScreen","responseData","ModalButtonKind","WidgetKind","Widget","assertPresent","creatorUserId","rawData","templateUrl","runTemplate","ToDevice","RoomAccount","eventSegment","expectingKeyStr","WidgetParser","_Object$keys","roughWidget","asStateEvent","parseRoomWidget","estimatedWidget","processEstimatedWidget","isValidUrl","variables","widgetRoomId","userDisplayName","userHttpAvatarUrl","clientTheme","clientLanguage","rexp","excluded","sourceKeys","sourceSymbolKeys","sendDirection","initialWidgetId","transportWindow","inboundWindow","_widgetId","_ready","idBase","outboundRequests","sendInternal","ready","nextRequestId","prResolve","prReject","cleanUp","timeoutSeconds","onStop","stopController","strictOriginCheck","handleResponse","invertedDirection","handleRequest","isErrorResponse","_response$response$er","initialFn","encodeCache","exclude","keepEscaped","nextCode","defaultChars","getEncodeCache","componentChars","safeIsNaN","areInputsEqual","newInputs","lastInputs","memoizeOne","resultFn","newArgs","lastResult","_Mime_extensionToType","_Mime_typeToExtension","_Mime_typeToExtensions","__classPrivateFieldGet","typeMap","allExtensions","starred","currentType","getExtension","getAllExtensions","_freeze","_getTestState","nanoid","customAlphabet","defaultSize","nopLogger","Logger","_name","_format","_method","methodLogger","createStatic","staticMethod","staticLogger","JwtUtils","generateSignedJwt","encodedToken","CryptoUtils","encodeBase64Url","signature","_randomWord","generateUUIDv4","generateCodeVerifier","code_verifier","generateBasicAuth","alg","msgUint8","customCalculateJwkThumbprint","jwk","jsonObject","kty","crv","utf8encodedAndHashed","generateDPoPProof","httpMethod","keyPair","hashedToken","encodedHash","ath","publicJwk","generateDPoPJkt","generateDPoPKeys","namedCurve","_callbacks","_logger","removeHandler","raise","PopupUtils","outerWidth","screenX","screenY","outerHeight","Timer","_timerHandle","_expiration","_callback","getEpochTime","durationInSeconds","expiration","timerDurationInSeconds","UrlUtils","readParams","responseMode","ErrorResponse","error_description","error_uri","ErrorTimeout","AccessTokenEvents","_expiringTimer","_expiredTimer","_expiringNotificationTimeInSeconds","expiringNotificationTimeInSeconds","expiring","expired","unload","addAccessTokenExpiring","removeAccessTokenExpiring","addAccessTokenExpired","removeAccessTokenExpired","CheckSessionIFrame","_client_id","_intervalInSeconds","_stopOnError","_timer","_session_state","_message","_frame_origin","_frame","parsedUrl","onload","InMemoryWebStorage","ErrorDPoPNonce","JsonService","additionalContentTypes","_jwtHandler","_extraHeaders","_contentTypes","fetchWithTimeout","initFetch","getJson","appendExtraHeaders","throw","postForm","basicAuth","initCredentials","extraHeaders","customKeys","protectedHeaders","headerName","toLocaleLowerCase","_settings","_signingKeys","_metadataUrl","metadataUrl","_jsonService","fetchRequestCredentials","_fetchRequestCredentials","resetSigningKeys","getMetadata","requestTimeoutInSeconds","metadataSeed","getIssuer","_getMetadataProperty","getAuthorizationEndpoint","getUserInfoEndpoint","getTokenEndpoint","getCheckSessionIframe","getEndSessionEndpoint","getRevocationEndpoint","getKeysEndpoint","jwks_uri","keySet","_prefix","post_logout_redirect_uri","client_authentication","max_age","ui_locales","acr_values","filterProtocolClaims","loadUserInfo","staleStateAgeInSeconds","mergeClaimsStrategy","disablePKCE","revokeTokenAdditionalContentTypes","refreshTokenAllowedScope","extraQueryParams","extraTokenParams","dpop","omitScopeWhenRequesting","UserInfoService","_metadataService","_getClaimsFromJwt","getClaims","TokenClient","exchangeCode","grant_type","exchangeCredentials","exchangeRefreshToken","revoke","token_type_hint","ResponseValidator","_claimsService","_userInfoService","_tokenClient","validateSigninResponse","_processSigninState","_processCode","isOpenId","_validateIdTokenAttributes","_processClaims","skipUserInfo","validateCredentialsResponse","validateRefreshResponse","hasIdToken","validateSignoutResponse","validateSub","mergeClaims","existingToken","incoming","auth_time","azp","request_type","toStorageString","storageString","clearStaleState","storage","cutoff","code_challenge","state_data","dpopJkt","optionalParams","stateParam","SigninRequest","splitState","SignoutRequest","id_token_hint","SignoutResponse","DefaultProtocolClaims","InternalRequiredProtocolClaims","ClaimsService","protocolClaims","claim","claims1","claims2","mergedValues","DPoPState","_validator","request_uri","login_hint","signinRequest","signinState","readSigninResponseState","removeState","storedStateString","dpopProof","getDpopProof","dpopStore","dpopState","processResourceOwnerPasswordCredentials","allowableScopes","createSignoutRequest","signoutState","readSignoutResponseState","processSignoutResponse","revokeToken","SessionMonitor","_userManager","_start","_sub","_checkSessionIFrame","intervalInSeconds","checkSessionIntervalInSeconds","stopOnError","stopCheckSessionOnError","checkSessionIFrame","_stop","monitorAnonymousSession","timerHandle","querySessionStatus","tmpUser","raiseEvent","_raiseUserSessionChanged","_raiseUserSignedOut","_raiseUserSignedIn","addUserLoaded","addUserUnloaded","_init","messageSource","AbstractChildWindow","_abort","_disposeHandlers","_window","keepOpen","scriptOrigin","_dispose","_notifyParent","DefaultPopupWindowFeatures","toolbar","closePopupWindowAfterInSeconds","DefaultPopupTarget","DefaultAccessTokenExpiringNotificationTimeInSeconds","DefaultCheckSessionIntervalInSeconds","UserManagerSettingsStore","popup_redirect_uri","popup_post_logout_redirect_uri","popupWindowFeatures","popupWindowTarget","redirectMethod","redirectTarget","iframeNotifyParentOrigin","iframeScriptOrigin","silent_redirect_uri","silentRequestTimeoutInSeconds","automaticSilentRenew","validateSubOnSilentRenew","includeIdTokenInSilentRenew","monitorSession","query_status_response_type","revokeTokenTypes","revokeTokensOnSignout","includeIdTokenInSilentSignout","accessTokenExpiringNotificationTimeInSeconds","userStore","IFrameWindow","_timeoutInSeconds","createHiddenIframe","notifyParent","IFrameNavigator","prepare","PopupWindow","popupSignal","centeredPopup","closed","popupClosedInterval","notifyOpener","PopupNavigator","RedirectNavigator","targetWindow","UserManagerEvents","_userLoaded","_userUnloaded","_silentRenewError","_userSignedIn","_userSignedOut","_userSessionChanged","removeUserLoaded","removeUserUnloaded","addSilentRenewError","removeSilentRenewError","_raiseSilentRenewError","addUserSignedIn","removeUserSignedIn","addUserSignedOut","removeUserSignedOut","addUserSessionChanged","removeUserSessionChanged","SilentRenewService","_isStarted","_retryTimer","_tokenExpiring","signinSilent","RefreshState","UserManager","redirectNavigator","popupNavigator","iframeNavigator","_redirectNavigator","_popupNavigator","_iframeNavigator","_silentRenewService","startSilentRenew","_sessionMonitor","_loadUser","removeUser","signinRedirect","requestArgs","bind_authorization_code","_signinStart","signinRedirectCallback","_signinEnd","signinResourceOwnerCredentials","_buildUser","signinPopup","_signin","signinPopupCallback","_useRefreshToken","verifySub","signinSilentCallback","signinCallback","signoutCallback","signoutRedirectCallback","signoutPopupCallback","signoutSilentCallback","navResponse","signoutRedirect","_signoutStart","_signoutEnd","signoutPopup","_signout","_revokeInternal","signoutRequest","signoutResponse","signoutSilent","revokeTokens","typesPresent","stopSilentRenew","_userStoreKey","dpopSettings","dpopKeys","Version","IndexedDbDPoPStore","_dbName","_storeName","createStore","promisifyRequest","storeName","txMode","webkitAudioContext","isRecordingSupported","bufferLength","encoderApplication","encoderFrameSize","encoderPath","encoderSampleRate","maxFramesPerPage","mediaTrackConstraints","monitorGain","numberOfChannels","recordingGain","resampleQuality","streamPages","wavBitDepth","sourceNode","encodedSamplePosition","initAudioContext","initialize","initWorklet","initEncoder","clearStream","monitorGainNode","recordingGainNode","encoder","encoderNode","encodeBuffers","getChannelData","createGain","setMonitorGain","setRecordingGain","audioWorklet","AudioWorkletNode","numberOfOutputs","createScriptProcessor","onaudioprocess","inputBuffer","Worker","initSourceNode","initWorker","streamPage","storePage","recordedPages","samplePosition","page","originalSampleRate","wavSampleRate","addModule","onpause","onresume","gain","setTargetAtTime","currentTime","onstart","ondataavailable","onstop","isSpace","collectCharacters","regEx","descriptors","currentDescriptor","regexLeadingSpaces","regexLeadingCommasOrSpaces","regexLeadingNotSpaces","regexTrailingCommas","regexNonNegativeInteger","regexFloatingPoint","parseDescriptors","lastChar","intVal","floatVal","pError","isColorSupported","bold","underline","inverse","strikethrough","black","red","green","yellow","blue","magenta","cyan","white","gray","bgBlack","bgRed","bgGreen","bgYellow","bgBlue","bgMagenta","bgCyan","bgWhite","blackBright","redBright","greenBright","yellowBright","blueBright","magentaBright","cyanBright","whiteBright","bgBlackBright","bgRedBright","bgGreenBright","bgYellowBright","bgBlueBright","bgMagentaBright","bgCyanBright","bgWhiteBright","createColors","crc32","ended","chunks","uint8","uint32","crcActual","int32","chunkData","factory","CRC32","signed_crc_table","use_buffer","crc32_buf_8","crc","bstr","DO_NOT_EXPORT_CRC","Config","DEBUG","LIB_VERSION","nativeIsArray","ObjProto","isEmptyObject","isEmptyString","isNullish","ArrayProto","nativeForEach","nativeIndexOf","assignableWindow","LOGGER_PREFIX","_log","POSTHOG_DEBUG","consoleLog","_len2","_key2","_len3","_key3","_len4","_key4","critical","_console","_len5","_key5","uninitializedWarning","breaker","eachArray","FormData","isFormData","needle","ownProps","resArray","trySafe","safewrap","stripEmptyProperties","stripLeadingDollar","Compression","registerEvent","fixEvent","cancelBubble","oldSchool","useCapture","ontype","old_handler","new_handler","old_handlers","old_result","new_result","severityLevels","PEOPLE_DISTINCT_ID_KEY","ALIAS_ID_KEY","EVENT_TIMERS_KEY","AUTOCAPTURE_DISABLED_SERVER_SIDE","HEATMAPS_ENABLED_SERVER_SIDE","EXCEPTION_CAPTURE_ENABLED_SERVER_SIDE","EXCEPTION_CAPTURE_ENDPOINT","WEB_VITALS_ENABLED_SERVER_SIDE","SESSION_RECORDING_ENABLED_SERVER_SIDE","CONSOLE_LOG_RECORDING_ENABLED_SERVER_SIDE","SESSION_RECORDING_NETWORK_PAYLOAD_CAPTURE","SESSION_RECORDING_CANVAS_RECORDING","SESSION_RECORDING_SAMPLE_RATE","SESSION_RECORDING_MINIMUM_DURATION","SESSION_ID","SESSION_RECORDING_IS_SAMPLED","ENABLED_FEATURE_FLAGS","PERSISTENCE_EARLY_ACCESS_FEATURES","STORED_PERSON_PROPERTIES_KEY","STORED_GROUP_PROPERTIES_KEY","SURVEYS","SURVEYS_ACTIVATED","FLAG_CALL_REPORTED","USER_STATE","CLIENT_SESSION_PROPS","CAPTURE_RATE_LIMIT","INITIAL_CAMPAIGN_PARAMS","INITIAL_REFERRER_INFO","INITIAL_PERSON_INFO","ENABLE_PERSON_PROCESSING","TOOLBAR_ID","PERSISTENCE_RESERVED_PROPERTIES","PERSISTENCE_ACTIVE_FEATURE_FLAGS","PERSISTENCE_OVERRIDE_FEATURE_FLAGS","PERSISTENCE_FEATURE_FLAG_PAYLOADS","filterActiveFeatureFlags","featureFlags","activeFeatureFlags","_step$value","_slicedToArray","PostHogFeatureFlags","_override_warning","featureFlagEventHandlers","reloadFeatureFlagsQueued","reloadFeatureFlagsInAction","getFlagVariants","enabledFlags","get_property","overriddenFlags","finalFlags","overriddenKeys","_startReloadTimer","anon_distinct_id","$anon_distinct_id","isPaused","_reloadFeatureFlagsRequest","advanced_disable_feature_flags","setReloadingPaused","personProperties","groupProperties","json_data","distinct_id","get_distinct_id","getGroups","person_properties","group_properties","disable_flags","_send_request","requestRouter","endpointFor","compression","disable_compression","Base64","feature_flag_request_timeout_ms","_response$json","errorsLoading","receivedFeatureFlags","decideEndpointWasHit","getFlags","_this$instance$persis","flagValue","flagReportValue","flagCallReported","send_event","persistence","$feature_flag","$feature_flag_response","getFlagPayloads","getFeatureFlag","currentFlags","currentFlagPayloads","_persistence$register2","flagPayloads","_persistence$register","$enabled_feature_flags","newFeatureFlags","newFeatureFlagPayloads","errorsWhileComputingFlags","_fireFeatureFlagsCallbacks","suppressWarning","__loaded","unregister","flagsObj","addFeatureFlagsHandler","_this$_prepareFeature","_prepareFeatureFlagsForCallbacks","flagVariants","removeFeatureFlagsHandler","isEnrolled","_this$instance$persis5","_this$instance$persis6","enrollmentPersonProp","$feature_enrollment","$set","setPersonPropertiesForFlags","newFlags","force_reload","existing_early_access_features","_this4$instance$persi","earlyAccessFeatures","flag","variantKey","_this$_prepareFeature2","reloadFeatureFlags","existingProperties","groupType","group_type","UUID","compareTo","unixTsMs","randA","randBHi","randBLo","V7Generator","DefaultRandom","generateOrAbort","valueAfterReset","resetCounter","fromFieldsV7","nextUint32","UUIDV7_DENY_WEAK_RNG","defaultGenerator","uuidv7","uuidv7obj","generate","firstNonPublicSubDomain","DOMAIN_MATCH_REGEX","cookieStore","is_supported","nameEQ","cookie","cross_subdomain","is_secure","secure","cdomain","matchedSubDomain","cookieJar","candidateCookieValue","originalMatch","chooseCookieDomain","setTime","new_cookie_val","_localStorage_supported","localStore","supported","COOKIE_PERSISTED_PROPERTIES","localPlusCookieStore","cookieProperties","cookiePersistedProperties","memoryStorage","memoryStore","sessionStorageSupported","localDomains","convertToURL","isUrlMatchingRegex","getQueryParam","keyValuePair","queryParts","_getHashParam","MOBILE","IOS","ANDROID","TABLET","ANDROID_TABLET","IPAD","APPLE","APPLE_WATCH","SAFARI","BLACKBERRY","SAMSUNG","SAMSUNG_BROWSER","SAMSUNG_INTERNET","CHROME","CHROME_OS","CHROME_IOS","INTERNET_EXPLORER","INTERNET_EXPLORER_MOBILE","OPERA","OPERA_MINI","EDGE","MICROSOFT_EDGE","FIREFOX","FIREFOX_IOS","NINTENDO","PLAYSTATION","XBOX","ANDROID_MOBILE","MOBILE_SAFARI","WINDOWS","WINDOWS_PHONE","NOKIA","OUYA","GENERIC","GENERIC_MOBILE","GENERIC_TABLET","KONQUEROR","BROWSER_VERSION_REGEX_SUFFIX","DEFAULT_BROWSER_VERSION_REGEX","XBOX_REGEX","PLAYSTATION_REGEX","NINTENDO_REGEX","BLACKBERRY_REGEX","windowsVersionMap","detectBrowser","user_agent","FACEBOOK","ua","safariCheck","versionRegexes","_versionRegexes","osMatchers","osVersion","versionParts","detectDevice","URL_REGEX_PREFIX","CAMPAIGN_PARAMS","Info","campaignParams","customParams","_campaignParamsFromUrl","campaign_keywords","kwkey","kw","_searchEngine","_searchInfoFromReferrer","keyword","searchInfo","browserVersion","regexes","browserLanguage","userLanguage","os","_osMatchers$i","rgex","resultOrFn","deviceType","referringDomain","_convertToURL","referrerInfo","$referrer","$referring_domain","initialPersonInfo","initialPersonPropsFromInfo","_convertToURL2","initial_referrer","initial_current_url","$initial_referrer","$initial_referring_domain","_Info$os2","os_name","os_version","$os","$os_version","$browser","$device","$device_type","$current_url","$host","$pathname","$raw_user_agent","$browser_version","$browser_language","$screen_height","screen","$screen_width","$viewport_height","$viewport_width","$lib","$lib_version","$insert_id","$time","people_properties","_Info$os4","CASE_INSENSITIVE_PERSISTENCE_TYPES","PostHogPersistence","campaign_params_saved","buildStorage","update_config","storage_type","expire_days","default_value","default_expiry","custom_campaign_params","register_once","initialReferrerInfo","initialPersonProps","oldConfig","set_disabled","set_cross_subdomain","set_secure","event_name","timers","estimateSize","sizeable","FULL_SNAPSHOT_EVENT_TYPE","META_EVENT_TYPE","splitBuffer","sizeLimit","half","firstHalf","secondHalf","windowId","EventType2","IncrementalSource","IncrementalSource2","splitClassString","checkForURLMatches","urlsList","getClassNames","baseVal","makeSafeText","shouldCaptureValue","getSafeText","elText","shouldCaptureElement","isSensitiveElement","_makeSafeText","isTextNode","isElementNode","isDocumentFragment","autocaptureCompatibleElements","getParentElement","curEl","shouldCaptureDomEvent","autocaptureConfig","captureOnAnyElement","allowedEventTypes","url_allowlist","url_ignorelist","dom_event_allowlist","allowlist","parentIsUsefulElement","targetElementList","compStyles","getPropertyValue","element_allowlist","elementType","_ret","css_selector_allowlist","_loop2","_ret2","coreCCPattern","anchoredCCRegex","unanchoredCCRegex","coreSSNPattern","anchoredSSNRegex","unanchoredSSNRegex","anchorRegexes","getDirectAndNestedSpanText","getNestedSpanText","_child$tagName","spanText","getElementsChainString","_element$nth_child","_element$nth_of_type","el_string","tag_name","attr_class","single_class","nth_child","nth_of_type","attr_id","sortedAttributes","localeCompare","escapeQuotes","_ref7","_ref8","_el$$el_text","_el$attr__href","extractAttrClass","_ref9","_ref11","_ref12","REDACTED","defaultNetworkOptions","initiatorTypes","maskRequestFn","recordHeaders","recordBody","recordInitialRequests","recordPerformance","performanceEntryTypeToObserve","payloadSizeLimitBytes","payloadHostDenyList","HEADER_DENY_LIST","PAYLOAD_CONTENT_DENY_LIST","POSTHOG_PATHS_TO_IGNORE","enforcePayloadSizeLimit","requestContentLength","Blob","scrubPayload","scrubbed","_scrubbed","_scrubbed2","ToolbarState","MutationRateLimiter","rrweb","_this$options$refillR","_this$options$bucketS","mutationBuckets","refillRate","bucketSize","mirror","getNode","closestSVG","_data$removes$length","_data$removes","_data$attributes$leng","_data$attributes","_data$texts$length","_data$texts","_data$adds$length","_data$adds","removes","texts","adds","initialMutationCount","numberOfChanges","_this$mutationBuckets","_this$options$onBlock","_this$options","_this$getNodeOrReleva2","getNodeOrRelevantParent","loggedTracker","onBlockedNode","mutationCount","refillBuckets","ACTIVE_SOURCES","MouseMove","MouseInteraction","Scroll","ViewportResize","Input","TouchMove","MediaInteraction","Drag","newQueuedEvent","rrwebMethod","enqueuedAt","SessionRecording","_captureStarted","_endpoint","stopRrweb","receivedDecide","_flushBuffer","_tryAddCustomEvent","sessionManager","_this$sessionManager$","checkAndGetSessionAndWindowId","clearBuffer","_setupSampling","_assignableWindow$rrw","_this$instance$config","session_recording","full_snapshot_interval_millis","_this$buffer","_this$buffer2","mostRecentSnapshot","sessionStartTimestamp","enabled_server_side","enabled_client_side","disable_session_recording","enable_recording_console_log","canvasRecording_server_side","fps","quality","_this$instance$config2","_this$instance$config3","networkPayloadCapture_server_side","networkPayloadCapture_client_side","headersEnabled","bodyEnabled","clientConfigForPerformanceCapture","capture_performance","network_timing","networkTimingEnabled","capturePerformance","isRecordingEnabled","_linkedFlag","_linkedFlagSeen","isSampled","_startCapture","stopRecording","_this$instance$persis3","sessionIdChanged","currentSampleRate","shouldSample","storedIsSampled","makeDecision","_response$sessionReco","_response$sessionReco2","_response$sessionReco3","_persistDecideResponse","sessionRecording","linkedFlag","linkedVariant","onFeatureFlags","_flags","variants","flagIsPresent","linkedFlagMatches","startIfEnabledOrStop","_samplingSessionListener","onSessionId","makeSamplingDecision","persistResponse","_response$sessionReco4","_response$sessionReco5","_response$sessionReco6","_response$sessionReco7","_response$sessionReco8","_response$sessionReco9","_response$sessionReco10","receivedSampleRate","parsedSampleRate","receivedMinimumDuration","minimumDurationMilliseconds","consoleLogRecordingEnabled","networkPayloadCapture","recordCanvas","canvasFps","canvasQuality","_this$instance$sessio","onRRwebEmit","consent","isOptedOut","rrwebRecord","_onScriptLoaded","loadScript","_event$data","isUserInteraction","isInteractiveEvent","isIdle","_lastActivityTimestamp","FIVE_MINUTES","_fullSnapshotTimer","returningFromIdle","_this$sessionManager$3","windowIdChanged","_tryTakeFullSnapshot","queuedRRWebEvent","queuedRRWebEvents","_tryRRWebMethod","addCustomEvent","takeFullSnapshot","_this$mutationRateLim","sessionRecordingOptions","blockClass","blockSelector","ignoreClass","maskTextClass","maskTextSelector","maskTextFn","maskAllInputs","maskInputOptions","maskInputFn","slimDOMOptions","collectFonts","inlineStylesheet","recordCrossOriginIframes","userSessionRecordingOptions","_Object$entries","_Object$entries$_i","canvasRecording","sampling","canvas","dataURLOptions","mutationRateLimiter","activePlugins","_gatherRRWebPlugins","plugins","_addCaptureHook","_maskUrl","fullSnapshotIntervalMillis","rrwebConsoleRecord","isConsoleLogCaptureEnabled","getRecordConsolePlugin","getRecordNetworkPlugin","_forceAllowLocalhostNetworkCapture","instanceConfig","remoteNetworkOptions","_options$payloadSizeL","canRecordHeaders","canRecordBody","canRecordPerformance","payloadLimiter","requestBody","requestHeaders","responseBody","responseHeaders","enforcedCleaningFn","hasDeprecatedMaskFunction","maskNetworkRequestFn","maskCapturedNetworkRequestFn","cleanedURL","_instanceConfig$sessi","_instanceConfig$sessi2","_instanceConfig$sessi3","cleanedRequest","capturedRequest","buildNetworkRequestOptions","_processQueuedEvents","Meta","_lastHref","_pageViewFallBack","FullSnapshot","_scheduleFullSnapshot","throttledEvent","throttleMutations","updatedPayload","_updateWindowAndSessionIds","$snapshot_bytes","$snapshot_data","$session_id","$window_id","_captureSnapshotBuffered","capture_pageview","currentUrl","itemsToProcess","_networkRequest","networkRequest","flushBufferTimer","minimumDuration","sessionDuration","isPositiveSessionDuration","isBelowMinimumDuration","snapshotBuffer","_captureSnapshot","_this$buffer3","additionalBytes","_noTruncate","_batchKey","Decide","_hasBootstrappedFeatureFlags","advanced_disable_feature_flags_on_first_load","parseDecideResponse","_afterDecideResponse","opt_in_site_apps","scriptUrl","STATE_FROM_WINDOW","LOCALSTORAGE_KEY","Toolbar","_assignableWindow$ph_","UNINITIALIZED","_location","_history","toolbarParams","stateHash","replaceState","userIntent","loadToolbar","toolbarRunning","disableToolbarMetrics","region","advanced_disable_toolbar_metrics","apiURL","instrument","getToolbarState","LOADED","_callLoadToolbar","setToolbarState","LOADING","fiveMinutesInMillis","timestampToNearestFiveMinutes","maybeLoadToolbar","RequestQueue","sendRequest","flushTimeout","setFlushTimeout","clearFlushTimeout","requests","formatQueue","requestValues","flushTimeoutMs","_requests$key$data","batchKey","u8","u16","u32","fleb","fdeb","clim","freb","eb","fl","revfl","revfd","rev","hMap","cd","mb","co","le","rvb","sv","r_1","flt","fdt","flm","fdm","shft","slc","wbits","wbits16","hTree","i0","i1","i2","maxSym","mbt","dt","lft","cst","i2_1","i2_2","i2_3","lc","cl","cln","clen","cf","wfblk","dat","wblk","lf","df","bs","bl","dlt","mlb","ddt","mdb","lclt","nlc","lcdt","ndc","lcfreq","lct","mlcb","nlcc","lm","ll","dm","dl","flen","ftlen","dtlen","llm","lcts","clct","dst","deo","et","crct","wbytes","gzipSync","opt","pre","post","st","plvl","lst","msk_1","bs1_1","bs2_1","hsh","lc_1","wi","hv","imod","pimod","rem","ch_1","dif","maxn","maxd","ml","nl","mmd","md","ti","lin","din","mem","dopt","mtime","SUPPORTS_REQUEST","CONTENT_TYPE_PLAIN","extendURLParams","_url$split2","newParams","newSearch","formdata","use_val","use_key","arg_separator","tph_arr","formDataToQuery","encodeToDataString","encodePostData","GZipJS","gzipData","ai","b64data","h1","h3","h4","b64","ac","enc","tmp_arr","stringl","utftext","utf8Encode","AVAILABLE_TRANSPORTS","_encodePostData","withCredentials","_options$callback","_encodePostData2","_aborter","aborter","_options$callback2","_options$callback3","sendBeacon","_encodePostData3","sendBeaconBody","RequestRouterRegion","RetryQueue","areWeOnline","onLine","retriesPerformedSoFar","retry_count","enqueue","msToNextRetry","rawBackoffTime","minBackoff","cappedBackoffTime","retryAt","logMessage","isPolling","poller","pollIntervalMs","notToFlush","toFlush","retriableRequest","MAX_SESSION_IDLE_TIMEOUT","SessionIdManager","sessionIdGenerator","windowIdGenerator","_this$config$bootstra","_windowId","_sessionId","_sessionStartTimestamp","_sessionActivityTimestamp","_sessionIdGenerator","_windowIdGenerator","persistenceName","desiredTimeout","_sessionTimeoutMs","_window_id_storage_key","_primary_window_exists_storage_key","_canUseSessionStorage","lastWindowId","primaryWindowExists","bootstrap","sessionID","uuid","hex","_setSessionId","_listenToReloadWindow","_sessionIdChangedHandlers","sessionActivityTimestamp","readOnly","_this$_getSessionId2","_getSessionId","lastTimestamp","_getWindowId","sessionPastMaximumLength","valuesChanged","noSessionId","activityTimeout","changeReason","newTimestamp","_setWindowId","ingestionDomain","RequestRouter","api_host","ui_host","_regionCache","apiHost","US","EU","CUSTOM","uiHost","scriptUrlToLoad","disable_external_dependency_loading","addScript","scriptTag","_scripts$0$parentNode","scripts","BASE_ERROR_ENDPOINT","ExceptionObserver","_this$instance$persis2","_window$onerror","hasHandlers","__POSTHOG_INSTRUMENTED__","wrapOnError","posthogErrorWrappingFunctions","wrapUnhandledRejection","unwrapOnError","unwrapUnhandledRejection","stopCapturing","remoteEnabled","startIfEnabled","_this$remoteEnabled","_window$onerror2","originalOnUnhandledRejectionHandler","isCapturing","startCapturing","_this$unwrapOnError","_this$unwrapUnhandled","autocaptureExceptionsResponse","autocaptureExceptions","errorProperties","posthogHost","$exception_personURL","sendExceptionEvent","NAME","createEventProcessor","_posthog","organization","_ref$severityAllowLis","severityAllowList","_event$exception","_exceptions$","_exceptions$2","_exceptions$3","_exceptions$4","_posthog$exceptionObs","personUrl","sessionRecordingStarted","get_session_replay_url","withTimestamp","$exception_message","$exception_type","$exception_level","$sentry_event_id","$sentry_exception","$sentry_exception_message","$sentry_exception_type","$sentry_tags","$level","exceptionObserver","SentryIntegration","addGlobalEventProcessor","SurveyType","SurveyQuestionType","SurveyQuestionBranchingType","PageViewManager","_instance","_window$location$path","_previousPageViewProperties","_currentPath","scrollManager","resetContext","_prevPageviewTimestamp","previousPath","previousTimestamp","scrollContext","getContext","maxScrollHeight","lastScrollY","maxScrollY","maxContentHeight","lastContentY","maxContentY","$prev_pageview_last_scroll","$prev_pageview_last_scroll_percentage","$prev_pageview_max_scroll","$prev_pageview_max_scroll_percentage","$prev_pageview_last_content","$prev_pageview_last_content_percentage","$prev_pageview_max_content","$prev_pageview_max_content_percentage","$prev_pageview_pathname","$prev_pageview_duration","SimpleEventEmitter","ActionMatcher","checkStepEvent","checkStepUrl","checkStepElement","actionEvents","actionRegistry","_this$instance","_this$instance2","eventPayload","_this$instance3","_this$instance4","_this3$actionRegistry","_action$steps","steps","_this3$actionEvents","autocapture","_this$instance5","selectorsToWatch","_action$steps2","setElementSelectors","_this$actionRegistry","checkAction","_debugEventEmitter","onAction","checkStep","_event$properties","eventUrl","matchString","url_matching","getElementsList","href_matching","text_matching","$el_text","_event$properties2","elementSelectors","$element_selectors","$elements","matching","adjustedRegExpStringPattern","escapeStringRegexp","SurveyEventReceiver","eventToSurveys","actionToSurveys","surveys","setupEventBasedSurveys","setupActionBasedSurveys","actionBasedSurveys","survey","_survey$conditions","_survey$conditions2","_survey$conditions2$a","_survey$conditions2$a2","actionMatcher","_addActionHook","actionName","_survey$conditions3","_survey$conditions4","_survey$conditions4$a","_survey$conditions5","_survey$conditions5$a","_survey$conditions5$a2","_this$actionMatcher","_survey$conditions6","_survey$conditions6$a","_survey$conditions6$a2","knownSurveys","_survey$conditions7","_survey$conditions8","_survey$conditions8$e","_survey$conditions8$e2","_survey$conditions9","_survey$conditions9$e","_survey$conditions9$e2","_this$instance3$persi","existingActivatedSurveys","SURVEY_SHOWN_EVENT_NAME","_eventPayload$propert","surveyId","$survey_id","_updateActivatedSurveys","_this$instance4$persi","activatedSurveys","_this$instance5$persi","_this$instance6","_this$instance6$persi","surveyUrlValidationMap","icontains","conditionsUrl","not_icontains","not_regex","is_not","PostHogSurveys","_surveyEventReceiver","_decideServerResponse","loadIfEnabled","surveysGenerator","extendPostHogWithSurveys","disable_surveys","_surveyManager","forceReload","existingSurveys","_this2$instance$persi","_this2$_surveyEventRe","eventOrActionBasedSurveys","_survey$conditions2$e","_survey$conditions3$e","_survey$conditions3$e2","getSurveys","_this3$_surveyEventRe","conditionMatchedSurveys","start_date","end_date","_survey$conditions$ur","urlCheck","urlMatchType","selectorCheck","targetingMatchedSurveys","_survey$conditions10","_survey$conditions11","_survey$conditions11$","_survey$conditions12","_survey$conditions12$","_survey$conditions13","_survey$conditions14","_survey$conditions14$","_survey$conditions15","_survey$conditions15$","linked_flag_key","targeting_flag_key","internal_targeting_flag_key","linkedFlagCheck","isFeatureEnabled","targetingFlagCheck","hasEvents","hasActions","eventBasedTargetingFlagCheck","overrideInternalTargetingFlagCheck","_canActivateRepeatedly","internalTargetingFlagCheck","currentQuestionIndex","_question$branching","questions","nextQuestionIndex","branching","SpecificQuestion","ResponseBased","SingleChoice","_question$branching2","_question$branching2$","selectedChoiceIndex","choices","responseValues","nextStep","Rating","_question$branching3","_question$branching3$","ratingBucket","responseValue","__PosthogExtensions__","canActivateRepeatedly","canRenderSurvey","renderSurvey","RateLimiter","_instance$config$rate","_instance$config$rate2","httpResponse","quota_limited","serverLimits","captureEventsPerSecond","rate_limiting","events_per_second","captureEventsBurstLimit","events_burst_limit","lastEventRateLimited","clientRateLimitContext","checkOnly","bucket","$$client_ingestion_warning_message","skip_client_rate_limiting","set_property","remainingTokens","generateSessionSourceParams","initialPathName","SessionPropsManager","sessionIdManager","sessionSourceParamGenerator","stored","_getStoredProps","_sessionSourceParamGenerator","_persistence","_sessionIdManager","_onSessionIdCallback","_this$_getStoredProps","$client_session_initial_referring_host","$client_session_initial_pathname","$client_session_initial_utm_source","utm_source","$client_session_initial_utm_campaign","utm_campaign","$client_session_initial_utm_medium","utm_medium","$client_session_initial_utm_content","utm_content","$client_session_initial_utm_term","utm_term","DEFAULT_BLOCKED_UA_STRS","isBlockedUA","customBlockedUserAgents","uaLower","blockedUA","blockedUaLower","RageClick","clicks","lastClick","elementInToolbar","_el$closest","Heatmaps","_enabledServerSide","flushInterval","capture_heatmaps","flush_interval_milliseconds","enable_heatmaps","_initialized","_setupListeners","_flushInterval","flushIntervalMilliseconds","_this$_flushInterval","getAndClearBuffer","optIn","_onClick","_onMouseMove","scrollElement","isFixedOrSticky","breakOnElement","target_fixed","_this$rageclicks","_getProperties","rageclicks","isRageClick","_capture","_mouseMoveTimeout","$heatmap_data","ScrollManager","_this$context$maxScro","_this$context$maxScro2","_this$context$maxCont","_this$context$maxCont2","contentY","contentHeight","ctx","_updateScrollData","scroll_root_selector","COPY_AUTOCAPTURE_EVENT","limitText","ConsentStatus","Autocapture","_elementSelectors","_config$url_allowlist","_config$url_ignorelis","isBrowserSupported","copiedTextHandler","capture_copied_text","_addDomEventHandlers","elementsChainAsString","_elementsChainAsString","_isDisabledServerSide","selectors","_this$_elementSelecto","matchedElements","matchedElement","_this$_isDisabledServ","persistedServerDisabled","memoryDisabled","advanced_disable_decide","disabledServer","previousElementSibling","_el","propertyKey","propertyValue","maskInputs","maskText","_this$config","elementAttributeIgnorelist","element_attribute_ignorelist","attributeName","nthChild","nthOfType","_previousElementSibling","$event_type","$ce_version","srcElement","_e$target","_getEventTarget","MouseEvent","rageclick","isCopyAutocapture","_elementsJson$","_elementsJson$2","externalHref","elementsJson","autocaptureAugmentProperties","explicitNoCapture","shouldCaptureEl","_getPropertiesFromElement","mask_all_element_attributes","mask_all_text","augmentProperties","_getAugmentPropertiesFromElement","_window$location","hrefHost","locationHost","_getDefaultProperties","$elements_chain","$external_click_url","getElementSelectors","_window$getSelection","selectedContent","clipType","TracingHeaders","_restoreXHRPatch","postHogTracingHeadersPatchFns","_patchXHR","_restoreFetchPatch","_patchFetch","_this$_restoreXHRPatc","_this$_restoreFetchPa","__add_tracing_headers","_loadScript","_startCapturing","ConsentManager","getDnt","DENIED","storedConsent","opt_out_capturing_by_default","isOptedIn","cookie_expiration","cross_subdomain_cookie","secure_cookie","opt_out_capturing_cookie_prefix","GRANTED","_storage","persistenceType","opt_out_capturing_persistence_type","otherStorage","optInOut","respect_dnt","doNotTrack","dntValue","FIFTEEN_MINUTES_IN_MILLIS","WebVitalsAutocapture","firstMetricTimestamp","_delayedFlushTimer","metric","sessionIds","$currentUrl","_currentURL","_maxAllowedValue","_flushToCapture","_assignableWindow$pos","postHogWebVitalsCallbacks","onLCP","onCLS","onFCP","onINP","_addToBuffer","configured","__web_vitals_max_value","web_vitals","webVitalsOptIn","instances","__NOOP","PRIMARY_INSTANCE_NAME","ENQUEUE_REQUESTS","defaultConfig","documentLocation","persistence_name","store_google","custom_blocked_useragents","save_referrer","capture_pageleave","verbose","upgrade","disable_persistence","opt_out_persistence_by_default","opt_out_useragent_filter","property_denylist","sanitize_properties","inapp_protocol","inapp_link_new_window","request_batching","properties_string_max_length","on_request_error","get_device_id","_onCapture","session_idle_timeout_seconds","person_profiles","configRenames","origConfig","renames","process_person","xhr_headers","cookie_name","disable_cookie","newConfig","property_blacklist","DeprecatedWebPerformanceObserver","__forceAllowLocalhost","PostHog","sentryIntegration","__request_queue","analyticsDefaultEndpoint","pageViewManager","rateLimiter","setProps","setPersonProperties","set_once","_instances$name","namedPosthog","_config$bootstrap","_window$addEventListe","_triggered_notifs","set_config","on_xhr_error","sessionPersistence","initialPersistenceProps","initialSessionProps","_requestQueue","_send_retriable_request","_retryQueue","sessionPropsManager","disable_scroll_properties","startMeasuringScrollPosition","heatmaps","webVitalsAutocapture","thisC","_sync_opt_out_with_persistence","distinctID","_config$bootstrap2","_config$bootstrap3","deviceID","isIdentifiedID","_config$bootstrap4","_config$bootstrap7","activeFlags","_config$bootstrap5","_config$bootstrap5$fe","_config$bootstrap6","_config$bootstrap6$fe","featureFlagPayloads","_config$bootstrap8","_config$bootstrap8$fe","_config$bootstrap9","_config$bootstrap9$fe","_handle_unload","posthog","bootstrapUser","getSegmentAnonymousId","anonymousId","segmentUser","enrichEvent","_ctx$event$properties","additionalProperties","_calculate_event_properties","isLoaded","identify","setupSegmentIntegration","_loaded","_response$analytics","_this$sessionRecordin","_this$autocapture","_this$heatmaps","_this$surveys","_this$webVitalsAutoca","_this$exceptionObserv","supportedCompression","analytics","afterDecideResponse","disableDecide","_start_queue_if_opted_in","send_instantly","resetRequestQueue","_this$_requestQueue","has_opted_out_capturing","_this$_requestQueue2","_this$_retryQueue","_shouldCapturePageleave","isServerRateLimited","api_transport","_options$transport","_find$method","_find","ver","transportMethod","_this5$config$on_requ","_this5$config","checkForLimiting","fn_name","alias_calls","other_calls","capturing_calls","execute","caller","_this$config$bootstra2","_execute_array","_options$_url","_is_bot","update_search_keyword","update_campaign_params","update_referrer_info","set_initial_person_info","systemTime","setOnceProperties","_calculate_set_once_properties","$set_once","COPY_IN_PROGRESS_SET","internalDeepCircularCopy","_copyAndTruncateStrings","finalSet","_internalEventEmitter","event_properties","remove_event_timer","persistenceProps","infoProperties","__preview_send_client_session_params","sessionProps","getSessionProps","performanceProperties","doPageView","doPageLeave","duration_in_ms","_isIdentified","denylisted_prop","_hasPersonProcessing","dataSetOnce","get_initial_props","_this$persistence","_this$persistence2","_this$sessionPersiste","_this$persistence3","_this$sessionPersiste2","getFeatureFlagPayload","_unused","updateEarlyAccessFeatureEnrollment","getEarlyAccessFeatures","_this$sessionManager$2","_this$sessionManager","getActiveMatchingSurveys","getNextSurveyStep","new_distinct_id","userPropertiesToSet","userPropertiesToSetOnce","_requirePersonProcessing","previous_distinct_id","$user_id","$had_persisted_distinct_id","isKnownAnonymous","setAnonymousDistinctId","groupKey","groupPropertiesToSet","existingGroups","resetGroupPropertiesForFlags","$groups","$group_type","$group_key","$group_set","setGroupPropertiesForFlags","resetPersonPropertiesForFlags","reset_device_id","_this$persistence4","_this$sessionPersiste3","_this$persistence5","_this$sessionManager2","resetSessionId","_this$sessionManager3","_this$sessionManager$4","_options$timestampLoo","LOOK_BACK","timestampLookBack","recordingStartTime","_register_single","_this$persistence6","_this$sessionRecordin2","_this$autocapture2","_this$heatmaps2","_this$sessionRecordin3","overrideAll","_this$sessionManager4","_this$persistence7","ids","linked_flag","overrideLinkedFlag","_this$sessionRecordin4","property_name","_this$persistence8","_this$sessionPersiste4","_this$config$name","_this$persistence9","_this$sessionPersiste5","_this$persistence10","_this$persistence10$p","_this$persistence11","_this$persistence11$p","function_name","_this$persistence12","_this$sessionPersiste6","_this$persistence13","_this$sessionPersiste7","defaultPersistenceDisabled","persistenceDisabled","_options$captureEvent","captureEventName","captureProperties","brandObj","webdriver","klass","posthogMain","dom_loaded_handler","_dom_loaded","cachedSetTimeout","cachedClearTimeout","defaultSetTimout","defaultClearTimeout","runTimeout","fun","currentQueue","draining","queueIndex","cleanUpNextTick","drainQueue","runClearTimeout","nextTick","argv","cwd","chdir","umask","canPromise","QRCode","CanvasRenderer","SvgRenderer","renderCanvas","renderFunc","argsNum","isLastArgCb","renderToDataURL","getSymbolSize","getRowColCoords","posCount","intervals","positions","getPositions","posLength","Mode","ALPHA_NUM_CHARS","AlphanumericData","ALPHANUMERIC","getBitsLength","getLength","write","bitBuffer","BitBuffer","bufIndex","putBit","getLengthInBits","bit","BitMatrix","reservedBit","reserved","isReserved","ByteData","ECLevel","EC_BLOCKS_TABLE","EC_CODEWORDS_TABLE","getBlocksCount","errorCorrectionLevel","getTotalCodewordsCount","fromString","Utils","G15_BCH","getBCHDigit","getEncodedBits","mask","EXP_TABLE","LOG_TABLE","mul","KanjiData","KANJI","toSJIS","Patterns","PATTERN000","PATTERN001","PATTERN010","PATTERN011","PATTERN100","PATTERN101","PATTERN110","PATTERN111","PenaltyScores","getMaskAt","maskPattern","getPenaltyN1","sameCountCol","sameCountRow","lastCol","lastRow","getPenaltyN2","getPenaltyN3","bitsCol","bitsRow","getPenaltyN4","darkCount","modulesCount","applyMask","getBestMask","setupFormatFunc","numPatterns","bestPattern","lowerPenalty","penalty","VersionCheck","Regex","NUMERIC","ccBits","MIXED","getCharCountIndicator","getBestModeForData","dataStr","testNumeric","testAlphanumeric","testKanji","NumericData","remainingNum","GF","coeff","divident","generateECPolynomial","degree","poly","AlignmentPattern","FinderPattern","MaskPattern","ECCode","ReedSolomonEncoder","FormatInfo","Segments","setupFormatInfo","matrix","createData","segments","dataTotalCodewordsBits","getSymbolTotalCodewords","remainingByte","totalCodewords","ecTotalCodewords","dataTotalCodewords","ecTotalBlocks","blocksInGroup2","blocksInGroup1","totalCodewordsInGroup1","dataCodewordsInGroup1","dataCodewordsInGroup2","ecCount","dcData","ecData","maxDataSize","dataSize","createCodewords","createSymbol","fromArray","estimatedVersion","rawSegments","rawSplit","getBestVersionForData","bestVersion","dataBits","moduleCount","setupFinderPattern","setupTimingPattern","setupAlignmentPattern","setupVersionInfo","bitIndex","byteIndex","dark","setupData","toSJISFunc","setToSJISFunction","Polynomial","genPoly","paddedData","buff","kanji","byte","BYTE_KANJI","TEST_KANJI","TEST_NUMERIC","TEST_ALPHANUMERIC","getStringByteLength","getSegments","getSegmentsFromString","numSegs","alphaNumSegs","byteSegs","kanjiSegs","isKanjiModeEnabled","s1","s2","getSegmentBitsLength","buildSingleSegment","modesHint","bestMode","seg","segs","buildNodes","prevNodeIds","nodeGroup","currentNodeIds","lastCount","prevNodeId","buildGraph","optimizedSegs","prevSeg","mergeSegments","toSJISFunction","CODEWORDS_COUNT","G18_BCH","getReservedBitsCount","getTotalBitsFromDataArray","totalBits","reservedBits","getCapacity","usableBits","ecl","getBestVersionForMixedData","getBestVersionForDataLength","qrData","canvasEl","getCanvasElement","getImageWidth","createImageData","qrToImageData","clearRect","clearCanvas","putImageData","rendererOpts","toDataURL","getColorAttrib","svgCmd","cmd","qrcodesize","bg","light","moveBy","newRow","lineLength","qrToPath","svgTag","hex2rgba","hexCode","hexValue","qrSize","imgData","qr","symbolSize","scaledMargin","palette","posDst","pxColor","rowSizeBase","colSizeBase","edgeBase","topRight","bottomRight","bottomLeft","topLeft","Resizer","onResizeStart","replaceStyles","userSelect","DEFAULT_SIZE","snap","gridGap","hasDirection","isTouchEvent","findClosestSnap","snapArray","snapGap","closestGapIndex","getStringSize","getPixelSize","parentSize","definedProps","baseClassName","Resizable","resizable","parentLeft","parentTop","resizableLeft","resizableRight","resizableTop","resizableBottom","targetLeft","appendBase","flex","removeBase","isResizing","propsSize","backgroundStyle","flexBasis","orgWidth","orgHeight","orgPosition","getSize","getParentSize","percent","wrapChanged","flexWrap","bindEvents","unbindEvents","componentDidMount","componentWillUnmount","createSizeForCssProperty","newSize","calculateNewMaxFromBoundary","maxHeight","boundWidth","boundHeight","boundsByDirection","widthByDirection","heightByDirection","bounds","parent_1","calculateNewSizeFromDirection","resizeRatio","resizeRatioX","resizeRatioY","lockAspectRatio","lockAspectRatioExtraHeight","lockAspectRatioExtraWidth","newWidth","newHeight","extraHeight","extraWidth","calculateNewSizeFromAspectRatio","computedMinWidth","computedMaxWidth","computedMinHeight","computedMaxHeight","extraMinWidth","extraMaxWidth","extraMinHeight","extraMaxHeight","lockedMinWidth","lockedMaxWidth","lockedMinHeight","lockedMaxHeight","setBoundingClientRect","adjustedScale","parent_2","parentRect","targetRect","top_1","isMouseEvent","parent_3","flexDirection","flexDir","TouchEvent","calculateNewMax","boundaryMax","grid","newGridWidth","newGridHeight","vw","vh","widthChanged","heightChanged","flexBaseChanged","flushSync","onResizeStop","updateSize","renderResizer","handleStyles","handleClasses","handleWrapperStyle","handleWrapperClass","handleComponent","resizers","extendsProps","sizeStyle","boxSizing","flexShrink","BlurhashCanvas","handleRef","draw","punch","pixels","imageData","componentDidUpdate","__objRest","__spreadProps","__spreadValues","canvasStyle","Blurhash","resolutionX","resolutionY","aa","da","ea","fa","ha","ia","ja","ka","la","ma","acceptsBooleans","attributeNamespace","mustUseProperty","propertyName","sanitizeURL","removeEmptyString","ra","sa","qa","oa","setAttributeNS","xlinkHref","__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED","va","wa","ya","za","Aa","Ba","Ca","Da","Ea","Fa","Ga","Ha","Ia","Ja","Ka","La","Ma","Na","Oa","prepareStackTrace","Pa","Qa","_payload","Ra","Sa","Ta","Va","_valueTracker","stopTracking","Ua","Wa","Xa","Ya","defaultChecked","_wrapperState","initialChecked","Za","controlled","ab","bb","defaultSelected","gb","dangerouslySetInnerHTML","hb","ib","jb","kb","lb","nb","innerHTML","MSApp","execUnsafeLocalFunction","ob","pb","animationIterationCount","aspectRatio","borderImageOutset","borderImageSlice","borderImageWidth","boxFlex","boxFlexGroup","boxOrdinalGroup","columnCount","flexGrow","flexPositive","flexNegative","flexOrder","gridArea","gridRow","gridRowEnd","gridRowSpan","gridRowStart","gridColumn","gridColumnEnd","gridColumnSpan","gridColumnStart","lineClamp","lineHeight","orphans","tabSize","widows","zoom","fillOpacity","floodOpacity","stopOpacity","strokeDasharray","strokeDashoffset","strokeMiterlimit","strokeOpacity","qb","rb","sb","menuitem","ub","vb","wb","xb","correspondingUseElement","yb","zb","Ab","Bb","Cb","stateNode","Db","Eb","Fb","Gb","Hb","Ib","Jb","Kb","Lb","Mb","Nb","Ob","Pb","Qb","Rb","Sb","Tb","Vb","Wb","memoizedState","Xb","Zb","Yb","$b","unstable_scheduleCallback","bc","unstable_cancelCallback","unstable_shouldYield","dc","unstable_requestPaint","unstable_now","ec","unstable_getCurrentPriorityLevel","fc","unstable_ImmediatePriority","gc","unstable_UserBlockingPriority","hc","unstable_NormalPriority","ic","unstable_LowPriority","jc","unstable_IdlePriority","kc","oc","clz32","qc","LN2","rc","sc","tc","uc","pendingLanes","suspendedLanes","pingedLanes","entangledLanes","entanglements","vc","yc","zc","Ac","eventTimes","Cc","Dc","Ec","Fc","Gc","Hc","Ic","Jc","Kc","Lc","Mc","Nc","Oc","Pc","Qc","Rc","Sc","Tc","blockedOn","domEventName","eventSystemFlags","targetContainers","Vc","Wc","isDehydrated","containerInfo","Xc","Yc","Zc","$c","ad","bd","ReactCurrentBatchConfig","dd","ed","fd","gd","hd","Uc","kd","ld","nd","od","keyCode","charCode","pd","qd","_reactName","_targetInst","isDefaultPrevented","isPropagationStopped","persist","isPersistent","wd","xd","yd","sd","eventPhase","timeStamp","td","ud","vd","Ad","getModifierState","zd","fromElement","toElement","Bd","Dd","dataTransfer","Fd","Hd","elapsedTime","pseudoElement","Id","clipboardData","Jd","Ld","Md","Esc","Spacebar","Left","Up","Right","Down","Del","Win","Apps","MozPrintableKey","Nd","Od","Alt","Control","Shift","Pd","Qd","which","Rd","Td","tangentialPressure","tiltX","tiltY","twist","isPrimary","Vd","targetTouches","Xd","Yd","wheelDeltaX","wheelDeltaY","wheelDelta","deltaZ","deltaMode","Zd","$d","ae","be","documentMode","ce","de","ee","fe","ge","he","ie","tel","week","ne","oe","pe","qe","se","te","ue","ve","we","xe","ye","ze","oninput","Ae","detachEvent","Be","Ce","attachEvent","De","Ee","Fe","He","Ie","Je","Ke","Le","compareDocumentPosition","Me","HTMLIFrameElement","Ne","contentEditable","Oe","focusedElem","selectionRange","selectionStart","selectionEnd","rangeCount","anchorNode","anchorOffset","focusNode","focusOffset","setStart","removeAllRanges","addRange","setEnd","Pe","Qe","Re","Se","Te","Ue","Ve","We","animationend","animationiteration","animationstart","transitionend","Xe","Ye","Ze","$e","af","bf","ef","gf","hf","mf","Ub","of","pf","qf","rf","sf","tf","uf","parentWindow","vf","wf","na","xa","$a","ba","je","ke","xf","yf","zf","Af","Bf","Cf","Df","Ef","__html","Ff","Gf","Hf","Jf","If","Kf","Lf","Mf","Nf","Of","Pf","Qf","Rf","Sf","Tf","Uf","Vf","Wf","Xf","Yf","contextTypes","__reactInternalMemoizedUnmaskedChildContext","__reactInternalMemoizedMaskedChildContext","Zf","childContextTypes","$f","ag","getChildContext","cg","__reactInternalMemoizedMergedChildContext","dg","eg","fg","gg","hg","jg","kg","lg","mg","ng","og","pg","qg","rg","sg","tg","ug","vg","wg","xg","yg","zg","Ag","Bg","Cg","pendingProps","treeContext","retryLane","Dg","Eg","Fg","Gg","memoizedProps","Hg","Ig","Jg","Kg","Lg","_owner","_stringRef","Mg","Ng","Og","Pg","Qg","Rg","Sg","Tg","Ug","Vg","Wg","Xg","Yg","Zg","$g","ah","_currentValue","bh","childLanes","dependencies","firstContext","lanes","dh","eh","memoizedValue","fh","gh","hh","interleaved","ih","jh","kh","updateQueue","baseState","firstBaseUpdate","lastBaseUpdate","shared","pending","effects","lh","mh","eventTime","lane","nh","oh","ph","qh","rh","sh","th","uh","wh","xh","yh","zh","Ah","Bh","Ch","revealOrder","Dh","Eh","_workInProgressVersionPrimary","Fh","ReactCurrentDispatcher","Gh","Hh","Ih","Jh","Kh","Lh","Mh","Nh","Oh","Ph","Qh","Rh","Sh","Th","baseQueue","Uh","Vh","Wh","lastRenderedReducer","hasEagerState","eagerState","lastRenderedState","dispatch","Xh","Yh","Zh","$h","getSnapshot","bi","ci","di","lastEffect","ei","fi","gi","ji","ki","mi","ni","oi","pi","qi","ri","si","ui","vi","zi","Ai","Bi","readContext","useImperativeHandle","useReducer","useDebugValue","useDeferredValue","useTransition","useMutableSource","useSyncExternalStore","unstable_isNewReconciler","identifierPrefix","Ci","Di","Ei","isMounted","_reactInternals","enqueueSetState","enqueueReplaceState","enqueueForceUpdate","Fi","shouldComponentUpdate","isPureReactComponent","Gi","contextType","Hi","componentWillReceiveProps","UNSAFE_componentWillReceiveProps","Ii","getDerivedStateFromProps","getSnapshotBeforeUpdate","UNSAFE_componentWillMount","componentWillMount","Ji","Ki","Li","Mi","Ni","Oi","Pi","Qi","getDerivedStateFromError","componentDidCatch","Ri","componentStack","Si","pingCache","Ti","Ui","Vi","Wi","ReactCurrentOwner","Xi","Yi","Zi","$i","aj","bj","cj","dj","baseLanes","cachePool","transitions","ej","gj","hj","ij","UNSAFE_componentWillUpdate","componentWillUpdate","jj","kj","pendingContext","lj","zj","Aj","Bj","Cj","mj","nj","oj","pj","qj","sj","dgst","tj","uj","_reactRetry","rj","subtreeFlags","vj","wj","isBackwards","rendering","renderingStartTime","tailMode","Dj","Ej","Fj","wasMultiple","multiple","suppressHydrationWarning","onclick","Gj","Hj","Ij","Jj","Kj","Lj","Mj","Nj","Pj","Qj","Rj","Sj","Tj","Uj","Vj","_reactRootContainer","Wj","Xj","Yj","Zj","onCommitFiberUnmount","ak","bk","ck","dk","ek","fk","gk","hk","ik","jk","kk","__reactInternalSnapshotBeforeUpdate","Vk","lk","mk","nk","pk","qk","rk","sk","uk","vk","wk","xk","yk","zk","Ak","Bk","Ck","Dk","callbackNode","expirationTimes","expiredLanes","wc","callbackPriority","ig","Ek","Fk","Gk","Hk","Ik","Jk","Kk","Lk","Mk","Nk","Ok","finishedWork","finishedLanes","Pk","timeoutHandle","Qk","Rk","Sk","Tk","Uk","mutableReadLanes","Bc","Oj","onCommitFiberRoot","mc","onRecoverableError","Wk","onPostCommitFiberRoot","Xk","Yk","$k","isReactComponent","pendingChildren","al","mutableSourceEagerHydrationData","pendingSuspenseBoundaries","gl","il","Zk","kl","reportError","_internalRoot","ol","pl","ql","unmount","unstable_scheduleHydration","sl","usingClientEntryPoint","findFiberByHostInstance","bundleType","rendererPackageName","ul","rendererConfig","overrideHookState","overrideHookStateDeletePath","overrideHookStateRenamePath","overridePropsDeletePath","overridePropsRenamePath","setErrorHandler","setSuspenseHandler","scheduleUpdate","currentDispatcherRef","findHostInstanceByFiber","findHostInstancesForRefresh","scheduleRefresh","scheduleRoot","setRefreshHandler","getCurrentFiber","reconcilerVersion","__REACT_DEVTOOLS_GLOBAL_HOOK__","vl","supportsFiber","inject","createPortal","createRoot","unstable_strictMode","findDOMNode","hydrate","hydrateRoot","hydratedSources","_getVersion","_source","unmountComponentAtNode","unstable_batchedUpdates","unstable_renderSubtreeIntoContainer","checkDCE","FOCUS_GROUP","FOCUS_DISABLED","hiddenGuard","InFocusGuard","_ref$children","propTypes","mediumFocus","mediumBlur","mediumEffect","mediumSidecar","ssr","emptyArray","FocusLock","_extends2","_useState","realObserved","setObserved","observed","originalFocusedElement","_props$disabled","_props$noFocusGuards","noFocusGuards","_props$persistentFocu","persistentFocus","_props$crossFrame","crossFrame","_props$autoFocus","allowTextSelection","whiteList","hasPositiveIndices","_props$shards","_props$as","_props$lockProps","lockProps","_props$returnFocus","shouldReturnFocus","focusOptions","onActivationCallback","onActivation","onDeactivationCallback","onDeactivation","captureFocusRestore","_document","allowDefer","focusRestore","returnFocusTo","howToReturnFocus","returnFocusOptions","setObserveNode","newObserved","hasLeadingGuards","hasTailingGuards","mergedRef","focusScopeValue","reducePropsToState","handleStateChangeOnClient","WrappedComponent","mountedInstances","emitChange","SideEffect","_PureComponent","_proto","getDisplayName","asArray","getFirst","DOCUMENT_FRAGMENT_NODE","isTopNode","DOCUMENT_NODE","isVisibleUncached","checkParent","ELEMENT_NODE","isElementHidden","isVisibleCached","visibilityCache","isAutoFocusAllowedCached","isAutoFocusAllowed","isAutoFocusAllowedUncached","getDataset","isHTMLInputElement","isRadioElement","isGuard","focusGuard","isNotAGuard","tabSort","aTab","bTab","tabDiff","indexDiff","orderByTabIndex","filterNegative","keepGuards","queryTabbables","queryGuardTabbables","getFocusablesWithShadowDom","withGuards","getFocusables","parents","focusableWithShadowDom","focusableWithIframes","contentDocument","getFocusablesWithIFrame","filterFocusable","isHTMLButtonElement","notHiddenInput","filterAutoFocusable","getTabbableNodes","topNodes","getFocusableNodes","parentAutofocusables","topNode","parentFocus","iframeBody","getActiveElement","inDocument","safeProbe","getTopParent","getAllAffectedNodes","contained","DOCUMENT_POSITION_CONTAINED_BY","DOCUMENT_POSITION_CONTAINS","filterNested","focusInside","focusInFrame","focusInsideIframe","focusOn","correctNode","findSelectedRadio","pickFirstFocus","pickFocusable","NEW_FOCUS","newFocus","innerNodes","innerTabbables","outerNodes","cnt","firstFocus","lastFocus","isOnGuard","lastNodeInside","resultSet","firstNodeIndex","lastNodeIndex","correctedNodes","currentFocusableIndex","previousFocusableIndex","tabbableNodes","currentTabbableIndex","previousTabbableIndex","focusIndexDiff","returnFirstNode","returnLastNode","pickAutofocus","nodesIndexes","autoFocusables","autoFocusable","autofocus","getParents","getCommonParent","nodeA","nodeB","parentsA","parentsB","currentParent","getTopCommonParent","baseActiveElement","leftEntry","rightEntries","activeElements","leftEntries","topCommon","subEntry","common","allParentAutofocusables","focusSolver","commonParent","anyFocusable","innerElements","srcNodes","dstNodes","remap","orderedInnerElements","innerFocusables","innerTabbable","newId","guardCount","lockDisabled","moveFocusInside","weakRef","deref","targetElement","currentElement","nextElementSibling","recordElementLocation","stack_1","savedCurrent","focusables","aim","_f","focusables_1","restoreFocusTo","moveFocus","cycle","onlyTabbable","defaultOptions","solution","useTabbables","shard","getRelativeFocusable","pickBoundary","what","deferAction","focusOnBody","isFreeFocus","focusIsHidden","lastActiveTrap","lastActiveFocus","tryRestoreFocus","lastPortaledElement","focusWasOutsideWindow","windowFocused","defaultWhitelist","autoGuard","allNodes","lastGuard","focusAutoGuard","lockItem","checkInHost","getNodeFocusables","activateTrap","_lastActiveTrap","workingNode","portaledElement","workingArea","focusWhitelisted","shouldForceRestoreFocus","withinHost","blur","newActiveElement","focusedIndex","onTrap","observerNode","onWindowFocus","onWindowBlur","focusLockAPI","focusNextElement","focusPrevElement","focusFirstElement","focusLastElement","assignSyncMedium","assignMedium","traps","trap","lastTrap","sameTrap","FocusLockCombination","replaceClassName","origClass","classToRemove","removeClass","CSSTransition","_React$Component","appliedClasses","appear","exit","maybeNode","maybeAppearing","_this$resolveArgument","resolveArguments","appearing","removeClasses","addClass","onEntering","_this$resolveArgument2","onEntered","_this$resolveArgument3","onExiting","onExited","nodeRef","isStringClassNames","activeClassName","doneClassName","_addClass","_this$appliedClasses$","_this$props","Transition","_leaveRenders","_enterRenders","modes","callHook","_element$props","leaveRenders","changeState","in","enterRenders","SwitchTransition","appeared","component","_this$state","isMounting","UNMOUNTED","EXITED","ENTERING","ENTERED","EXITING","initialStatus","appearStatus","unmountOnExit","mountOnEnter","nextCallback","updateStatus","prevProps","nextStatus","cancelNextCallback","getTimeouts","mounting","performEnter","performExit","timeouts","enterTimeout","safeSetState","onTransitionEnd","setNextCallback","doesNotHaveTimeoutOrListener","addEndListener","maybeNextCallback","TransitionGroupContext","forceReflow","__self","__source","forceUpdate","_status","_result","Profiler","StrictMode","Suspense","act","_currentValue2","_threadCount","Consumer","_defaultValue","_globalName","createFactory","createRef","lazy","startTransition","unstable_act","base32Encoding","base32","_parse","_stringify","encoding","_opts$out","codes","written","_opts$pad","htmlparser","parseSrcset","postcssParse","mediaTags","vulnerableTags","sanitizeHtml","VALID_HTML_ATTRIBUTE_NAME","_recursing","tempResult","Frame","tagPosition","mediaChildren","updateParentNodeText","updateParentNodeMediaChildren","htmlParserDefaults","tagAllowed","allowedTags","allowVulnerableTags","nonTextTagsArray","nonTextTags","allowedAttributesMap","allowedAttributesGlobMap","allowedAttributes","globRegex","allowedClassesMap","allowedClassesGlobMap","allowedClassesRegexMap","allowedClasses","transformTagsMap","transformTagsAll","skipMap","transformMap","skipText","skipTextDepth","transformTags","transFun","simpleTransform","addedText","initializeState","enforceHtmlBoundary","hasText","transformedTag","innerText","disallowedTagsMode","nestingLimit","escapeHtml","textFilter","allowedScriptHostnames","allowedScriptDomains","allowedEmptyAttributes","nonBooleanAttributes","passedAllowedAttributesMapCheck","splitStrArray","allowedSchemesAppliedToAttributes","naughtyHref","allowedHostname","allowedDomain","isRelativeUrl","allowIframeRelativeUrls","allowedIframeHostnames","allowedIframeDomains","evil","allowedSpecificClasses","allowedWildcardClasses","allowedSpecificClassesGlob","allowedSpecificClassesRegex","allowedWildcardClassesRegex","allowedClassesGlobs","filterClasses","parseStyleAttributes","filteredAST","abstractSyntaxTree","allowedStyles","astRules","selectedRule","allowedDeclarationsList","attributeObject","regularExpression","filterDeclarations","filterCss","extractedAttributes","attrObject","stringifyStyleAttributes","lastFrame","isImplied","exclusiveFilter","firstIndex","allowProtocolRelative","allowedSchemesByTag","allowedSchemes","allowedGlobs","clss","newTagName","newAttribs","AtRule","proxyOf","registerAtRule","Rule","Declaration","isClean","my","cleanSource","markTreeDirty","markDirty","cleanRaws","keepBetween","getIterator","lastEach","getProxyProcessor","toProxy","exist","existIndex","rebuild","raws","removeAll","replaceValues","walkDecls","decl","fast","walk","addToError","walkAtRules","walkComments","walkRules","registerParse","dependant","registerRule","registerRoot","pico","terminalHighlight","CssSyntaxError","endLine","endColumn","setMessage","showSourceCode","aside","gutter","subLineStart","subLineEnd","subLine","LazyResult","Processor","toResult","registerLazyResult","registerProcessor","PreviousMap","fromJSON","ownInputs","inputHydrated","inputId","isAbsolute","SourceMapConsumer","SourceMapGenerator","fileURLToPath","pathToFileURL","fromOffsetCache","sourceMapAvailable","pathAvailable","hasBOM","consumer","mapResolve","fromOffset","lastLine","lineToIndex","prevIndex","sourceRoot","fromUrl","originalPositionFor","mapFile","sourceContentFor","consumerCache","registerInput","MapGenerator","Result","TYPE_TO_CLASS_NAME","atrule","PLUGIN_PROPS","AtRuleExit","CommentExit","DeclarationExit","DocumentExit","Once","OnceExit","postcssPlugin","RootExit","RuleExit","NOT_VISITORS","isPromise","toStack","visitorIndex","visitors","cleanMarks","postcss","processed","inline","syntax","helpers","processing","runAsync","onRejected","onFinally","getAsyncError","lastPlugin","postcssVersion","prepareVisitors","hasListener","runOnRoot","visitTick","visitor","stringifier","walkSync","visitSync","onFulfilled","warnings","registerPostcss","comma","separators","inQuote","prevQuote","dirname","sep","cssString","mapOpts","originalCSS","usesFileUrls","absolute","memoizedFileURLs","memoizedPaths","memoizedURLs","addAnnotation","isInline","outputFile","eol","applyPrevMaps","toUrl","sourcesContent","applySourceMap","clearAnnotation","generateMap","generateString","fromSourceMap","ignoreInvalidMapping","addMapping","generated","isSourcesContent","setSourcesContent","isAnnotation","noSource","sourcePath","semicolon","withContent","previousMaps","already","toFileUrl","setSourceContent","fileURL","NoWorkResult","_processor","_css","_map","generatedCSS","generatedMap","_root","Stringifier","postcssNode","overrides","between","cloneAfter","cloneBefore","rangeBy","markClean","positionBy","stringRepresentation","positionInside","bookmark","foundSelf","emitInputs","inputsNextIndex","proxyCache","tokenizer","SAFE_COMMENT_NEIGHBOR","spaces","createTokenizer","unnamedAtrule","endOfFile","getPosition","spacesAndCommentsFromEnd","afterName","spacesAndCommentsFromStart","checkMissedSemicolon","colon","founded","doubleColon","customProperty","findLastWithPosition","unknownWord","firstSpaces","precheckMissedSemicolon","stringFrom","spacesFromEnd","emptyRule","unexpectedClose","endFile","unclosedBlock","freeSemicolon","ownSemicolon","bracket","unclosedBracket","lastTokenType","Warning","warningPrinted","LANG","transformer","processOpts","pluginOpts","atRule","existsSync","readFileSync","loadAnnotation","startWith","loadMap","decodeInline","uriMatch","baseUriMatch","getAnnotationURL","sourceMapString","mappings","_mappings","sections","comments","loadFile","prevPath","use","ignore","DEFAULT_RAW","beforeClose","beforeComment","beforeDecl","beforeOpen","beforeRule","commentLeft","commentRight","emptyBody","builder","beforeAfter","detect","own","rawCache","rawBeforeClose","rawBeforeComment","rawBeforeDecl","rawBeforeOpen","rawBeforeRule","rawColon","rawEmptyBody","rawIndent","rawSemicolon","SINGLE_QUOTE","DOUBLE_QUOTE","NEWLINE","FEED","TAB","OPEN_SQUARE","CLOSE_SQUARE","OPEN_PARENTHESES","CLOSE_PARENTHESES","OPEN_CURLY","CLOSE_CURLY","SEMICOLON","RE_AT_END","RE_WORD_END","RE_BAD_BRACKET","RE_HEX_ESCAPE","currentToken","escapePos","unclosed","ignoreUnclosed","controlChar","printed","sortIndex","setImmediate","expirationTime","priorityLevel","scheduling","isInputPending","MessageChannel","port2","port1","unstable_Profiling","unstable_continueExecution","unstable_forceFrameRate","unstable_getFirstCallbackNode","unstable_next","unstable_pauseExecution","unstable_runWithPriority","unstable_wrapCallback","grammar","sessionConfig","raddr","tcptype","generation","maxMessageSize","dir2","clksrcExt","mediaClockValue","rateNumerator","rateDenominator","writer","parseParams","parseFmtpConfig","parsePayloads","parseRemoteCandidates","parseImageAttributes","parseSimulcastStreamList","toIntIfInt","parseReg","needsBlank","keyLocation","rawName","attachProperties","validLine","paramReducer","expr","scid","formatRegExp","formatStr","makeLine","defaultOuterOrder","defaultInnerOrder","mLine","payloads","outerOrder","innerOrder","hasDescriptors","$floor","functionLengthIsConfigurable","functionLengthIsWritable","not_string","not_bool","not_type","not_primitive","numeric_arg","not_json","modulo","key_access","index_access","parse_tree","pad_character","pad_length","is_positive","tree_length","param_no","toExponential","pad_char","sprintf_format","fmt","sprintf_cache","_fmt","arg_names","field_list","replacement_field","field_match","sprintf_parse","vsprintf","clampProp","clampEntity","getDefinedProp","clampNumber","numberOutOfRange","missingField","Jn","zipProps","remapProps","Vn","nn","allPropsEqual","zeroOutProps","sortStrings","padNumber","compareNumbers","divModFloor","modFloor","divModTrunc","divTrunc","modTrunc","hasHalf","givenFieldsToBigNano","Xr","Qr","nanoToGivenFields","requireNumberIsPositive","requireNumberIsInteger","requirePropDefined","requireType","invalidEntity","expectedInteger","expectedPositive","toStringViaPrimitive","toBigInt","invalidBigInt","forbiddenBigIntToNumber","expectedFinite","toStrictInteger","toPositiveInteger","createBigNano","addBigNanos","moveBigNano","bigNanoOutside","bigIntToBigNano","bigNanoToBigInt","divModBigNano","hashIntlFormatParts","formatToParts","checkIsoYearMonthInBounds","isoYear","checkIsoDateInBounds","checkIsoDateTimeInBounds","Dt","isoHour","checkEpochNanoInBounds","isoToEpochNano","isoDay","isoNanosecond","isoTimeFieldsToNano","nanoToIsoTimeAndDay","epochNanoToSec","epochNanoToSecMod","_r","isoToEpochMilli","isoArgsToEpochMilli","isoMonth","isoMinute","isoSecond","isoMillisecond","Gr","isoMicrosecond","Vr","isoToEpochNanoWithOffset","isoArgsToEpochSec","Hr","isoToLegacyDate","setUTCHours","setUTCFullYear","epochMilliToIso","getUTCFullYear","getUTCMonth","getUTCDate","getUTCHours","getUTCMinutes","getUTCSeconds","getUTCMilliseconds","computeIsoDateParts","computeIsoMonthsInYear","computeIsoDaysInMonth","computeIsoInLeapYear","computeIsoDaysInYear","computeIsoDayOfWeek","getUTCDay","computeGregoryEraParts","computeJapaneseEraParts","era","eraYear","parseIntlYear","checkIsoDateTimeFields","checkIsoDateFields","constrainIsoTimeFields","constrainIsoDateFields","isIsoDateFieldsValid","wn","normalizeOptions","refineDiffOptions","parseRoundingIncInteger","checkLargestSmallestUnit","refineRoundingInc","refineRoundingOptions","normalizeOptionsOrString","refineDateDisplayOptions","refineTimeDisplayOptions","refineTimeDisplayTuple","refineSubsecDigits","refineSmallestUnitAndSubsecDigits","overrideOverflowOptions","refineUnitOption","$r","invalidChoice","Et","refineChoiceOption","Ar","branding","epochNanoseconds","Yn","calendar","timeZone","createPlainYearMonthSlots","createPlainMonthDaySlots","Ge","Vt","qt","computeDurationSign","extractEpochNano","isIdLikeEqual","totalDayTimeDuration","durationFieldsToBigNano","clampRelativeDuration","computeEpochNanoFrac","vr","roundDateTime","roundDateTimeToNano","computeNanoInc","roundTimeToNano","moveByDays","roundByInc","roundToMinute","Jr","computeDayInterval","computeDayFloor","roundDayTimeDurationByInc","getMaxDurationUnit","nanoToDurationDayTimeFields","roundBigNanoByInc","roundRelativeDuration","isUniformUnit","isZonedEpochSlots","nudgeZonedTimeDuration","nudgeDayTimeDuration","nudgeRelativeDuration","roundBigNano","roundWithMode","ga","nanoToDurationTimeFields","weeks","getOffsetNanosecondsFor","formatIsoDateTimeFields","In","formatCalendar","Tt","yt","formatIsoDateFields","formatDateLikeIso","formatIsoYearMonthFields","formatIsoMonthDayFields","formatIsoTimeFields","zt","negateDurationFields","hours","minutes","checkDurationTimeUnit","formatSubsecNano","formatDurationFragments","formatDurationNumber","formatCalendarId","xr","getSignStr","Kr","useGrouping","_zonedEpochSlotsToIso","offsetNanoseconds","getMatchingInstantFor","getPossibleInstantsFor","kr","Yr","wr","Br","durationHasDateParts","hn","moveZonedEpochs","ct","moveDateTime","moveDate","moveToDayOfMonthUnsafe","xt","dateAdd","moveTime","createMarkerSystem","createMarkerToEpochNano","createMoveMarker","createDiffMarkers","diffZonedEpochsExact","diffDateTimesExact","Wt","relativeTo","checkDurationUnits","zr","Rr","Zr","createSplitTuple","computePeriod","parseOffsetNano","parseOffsetNanoMaybe","failedParse","At","parseDateTimeLike","finalizeDateTime","finalizeDate","requireIsoCalendar","invalidSubstring","finalizeZonedDateTime","an","resolveSlotsCalendar","organizeIsoYearParts","organizeTimeParts","organizeAnnotationParts","parseYearMonthOnly","parseMonthDayOnly","parseInt0","parseSubsecNano","parseSign","createRegExp","getTimeZoneEssence","getTimeZoneAtomic","resolvedOptions","yn","rt","diffEpochNanos","Dn","getCommonCalendarSlot","Fr","diffZonedEpochsBig","ut","diffDateTimesBig","Ft","diffDateLike","dateUntil","diffTimes","diffEpochNanosExact","updateMid","diffDays","diffEpochMilliByDay","Er","createIntlCalendar","epochMilliToIntlFields","computeCalendarIdBase","createIntlFieldCache","createIntlYearDataCache","Wr","parseIntlPartsYear","eraYearToYear","relatedYear","computeIntlDateParts","computeIntlEpochMilli","computeIntlLeapMonth","queryMonthStrings","getCalendarLeapMonthMeta","computeIntlDaysInYear","computeIntlDaysInMonth","computeIntlMonthsInYear","invalidCalendar","computeNativeWeekOfYear","computeNativeYearOfWeek","computeNativeDayOfYear","parseMonthCode","invalidMonthCode","monthCodeNumberToMonth","monthToMonthCodeNumber","getCalendarEraOrigins","getCalendarIdBase","Qt","refineCalendarFields","en","dateFromFields","refineTimeBag","Yt","nt","yearMonthFromFields","monthCode","monthDayFromFields","refineFields","fields","duplicateFields","tn","noValidFields","mergeCalendarFields","mergeFields","convertToPlainMonthDay","convertToPlainYearMonth","convertToIso","refineYear","Dr","gr","invalidEra","Ir","missingYear","refineMonth","Pr","Mr","Nr","refineDay","spliceFields","ht","Bt","getPreferredCalendarSlot","createNativeOpsCreator","createOptionsTransformer","timeStyle","qn","Ns","toEpochMillis","Lr","En","An","Bn","Nn","ys","yr","Ur","nanosecond","microsecond","millisecond","minute","bce","meiji","taisho","showa","heisei","reiwa","ethioaa","era0","ethiopic","era1","coptic","roc","beforeroc","minguo","buddhist","islamic","indian","saka","persian","chinese","dangi","hebrew","DateTimeFormat","constrain","compatible","earlier","later","prefer","auto","never","always","halfFloor","halfCeil","halfTrunc","expand","halfExpand","halfEven","IntlTimeZone","FixedTimeZone","getOffsetSec","pinch","inLeapYear","monthsInYear","daysInMonth","daysInYear","dayOfYear","dayOfWeek","daysInWeek","weekOfYear","yearOfWeek","computeWeekShift","computeWeeksInYear","es","ns","timeZoneName","ss","us","ls","fs","ds","ps","hs","gs","Ts","Ds","Is","Ms","createSlotClass","oo","bindMethod","getSpecificSlots","no","createProtocolValidator","rejectInvalidBag","createCalendarFieldMethods","toPlainDateSlots","createCalendarGetters","neverValueOf","createCalendarFromSlots","toPlainMonthDaySlots","extractCalendarSlotFromBag","Qo","getOffsetNanosecondsForAdapter","Co","createAdapterOps","ho","createTimeZoneOps","createTimeZoneOffsetOps","Do","toInstantSlots","getImplTransition","refineTimeZoneSlot","Fo","toPlainTimeSlots","optionalToPlainTimeFields","toPlainYearMonthSlots","Ho","getCalendarSlotFromBag","ot","toPlainDateTimeSlots","Pt","Ko","Ct","dayAdapter","Yo","createCompoundOpsCreator","toDurationSlots","Ht","parseUnit","Kt","refinePublicRelativeTo","Xt","refineCalendarSlot","sn","toZonedDateTimeSlots","jn","Mn","adaptDateMethods","slotsToIso","createDateTimeFormatClass","Or","createFormatPrepperForBranding","prepFormat","createFormatMethod","createProxiedMethod","xn","Ln","Instant","PlainDateTime","PlainDate","PlainTime","PlainYearMonth","PlainMonthDay","Rn","Wn","Gn","Un","zn","Hn","Kn","Qn","Xn","$n","_n","eo","ro","ao","so","calendarId","uo","fo","mo","epochSeconds","epochMilliseconds","epochMicroseconds","So","Oo","To","po","getISOFields","getCalendar","_o","equals","toPlainDate","$o","No","Po","until","toZonedDateTime","dr","toZonedDateTimeISO","fromEpochSeconds","fromEpochMilliseconds","fromEpochMicroseconds","fromEpochNanoseconds","Zo","bo","getOffsetStringFor","getPlainDateTimeFor","getInstantFor","getNextTransition","getPreviousTransition","Io","vo","plainDate","toPlainDateTime","wo","jo","Mo","Xo","or","yo","withCalendar","withPlainDate","withPlainTime","ft","mt","toPlainTime","toPlainYearMonth","St","toPlainMonthDay","Ot","Bo","Ao","Zt","It","plainTime","vt","wt","jt","Mt","Eo","Vo","Jo","Lo","qo","ko","xo","Ro","Wo","Go","largestUnit","Uo","zo","rr","with","kt","negated","Rt","Gt","Ut","DurationFormat","$t","_t","un","cn","rn","ur","timeZoneId","hoursInDay","dn","mn","getTimeZone","Sn","withTimeZone","On","Tn","pn","Pn","startOfDay","Cn","gn","toInstant","Zn","bn","Fn","fr","instant","zonedDateTime","zonedDateTimeISO","plainDateTime","plainDateTimeISO","plainDateISO","plainTimeISO","mr","ZonedDateTime","Calendar","TimeZone","Duration","Now","Sr","__decorate","decorators","decorate","__param","paramIndex","decorator","__esDecorate","descriptorIn","contextIn","initializers","extraInitializers","accept","access","addInitializer","__runInitializers","useValue","__propKey","__setFunctionName","__metadata","metadataKey","metadataValue","__awaiter","_arguments","fulfilled","rejected","__generator","trys","Iterator","__values","__read","__spread","__spreadArrays","jl","__asyncGenerator","fulfill","__asyncDelegator","__asyncValues","__makeTemplateObject","cooked","__classPrivateFieldSet","__classPrivateFieldIn","__addDisposableResource","asyncDispose","_SuppressedError","suppressed","__disposeResources","fail","hasError","__rewriteRelativeImportExtension","preserveJsx","tsx","cm","FUNC_TYPE","UNDEF_TYPE","OBJ_TYPE","STR_TYPE","MAJOR","MODEL","TYPE","VENDOR","ARCHITECTURE","CONSOLE","SMARTTV","WEARABLE","EMBEDDED","AMAZON","ASUS","BROWSER","GOOGLE","HUAWEI","LG","MICROSOFT","MOTOROLA","SHARP","SONY","XIAOMI","ZEBRA","CHROMIUM_OS","MAC_OS","SUFFIX_BROWSER","enumerize","enums","str1","str2","lowerize","rgxMapper","strMapper","cpu","engine","UAParser","getResult","_navigator","_ua","_uach","_rgxmap","mergedRegexes","_isSelfNav","getBrowser","_browser","brave","isBrave","getCPU","_cpu","_device","mobile","standalone","getEngine","_engine","getOS","_os","getUA","setUA","CPU","DEVICE","ENGINE","OS","jQuery","Zepto","ItoI","innerCreateMedium","cbs","pendingQueue","executeQueue","createMedium","createSidecarMedium","whichTypedArray","availableTypedArrays","typedArrays","$slice","superProto","trySlices","tryTypedArrays","readUInt8","isArgumentsObject","uncurryThis","BigIntSupported","SymbolSupported","ObjectToString","numberValue","booleanValue","bigIntValue","symbolValue","checkBoxedPrimitive","prototypeValueOf","isMapToString","isSetToString","isWeakMapToString","isWeakSetToString","isArrayBufferToString","working","isDataViewToString","isDataView","isArrayBufferView","isUint8Array","isUint8ClampedArray","isUint16Array","isUint32Array","isInt8Array","isInt16Array","isInt32Array","isFloat32Array","isFloat64Array","isBigInt64Array","isBigUint64Array","SharedArrayBufferCopy","isSharedArrayBufferToString","isSharedArrayBuffer","isNumberObject","isStringObject","isBooleanObject","isBigIntObject","isSymbolObject","isAsyncFunction","isMapIterator","isSetIterator","isGeneratorObject","isWebAssemblyCompiledModule","isBoxedPrimitive","isAnyArrayBuffer","inspect","deprecate","noDeprecation","throwDeprecation","traceDeprecation","debugs","debugEnvRegex","debugEnv","stylize","stylizeNoColor","colors","showHidden","_extend","customInspect","stylizeWithColor","formatValue","styleType","recurseTimes","simple","formatPrimitive","visibleKeys","arrayToHash","formatError","braces","formatProperty","formatArray","numLinesEst","reduceToSingleString","pid","isNativeError","inherits","kCustomPromisifiedSymbol","callbackifyOnRejected","newReason","promisify","promiseResolve","promiseReject","callbackify","callbackified","maybeCb","rej","rnds8","byteToHex","unsafeStringify","rnds","rng"],"sourceRoot":""}